<?xml version="1.0" ?>
<!DOCTYPE book PUBLIC "-//KDE//DTD DocBook XML V4.2-Based Variant V1.1//EN" "dtd/kdex.dtd" [

  <!ENTITY kappname "&rocs;">
  <!ENTITY package "kdeedu">
  <!ENTITY % addindex "IGNORE">
  <!ENTITY % Swedish "INCLUDE">
]>
<book lang="&language;">

<bookinfo>
<title
>Handbok &rocs;</title>
<authorgroup>
<author
><personname
> <firstname
>Tomaz</firstname
> <surname
>Canabrava</surname
> </personname
> <email
>tomaz.canabrava@gmail.com</email
> </author>
<author
><personname
> <firstname
>Andreas</firstname
> <surname
>Cord-Landwehr</surname
> </personname
> <email
>cordlandwehr@googlemail.com</email
> </author>

<othercredit role="translator"
> <firstname
>Stefan</firstname
> <surname
>Asserhäll</surname
> <affiliation
><address
><email
>stefan.asserhall@comhem.se</email
></address
></affiliation
> <contrib
>Översättare</contrib
></othercredit
> 
</authorgroup>

<copyright
><year
>2009</year
><holder
>Tomaz Canabrava</holder
></copyright>
<copyright
><year
>2011-2012</year
><holder
>Andreas Cord-Landwehr</holder
></copyright>

<date
>2012-05-27</date>
<releaseinfo
>1.7 &kde; 4.9</releaseinfo>

<legalnotice
>&FDLNotice;</legalnotice>

<abstract>
<para
>&rocs; är ett grafteoretiskt verktyg för KDE. </para>
</abstract>

<keywordset>
<keyword
>KDE</keyword>
<keyword
>kdeedu</keyword>
<keyword
>matematik</keyword>
<keyword
>matematik</keyword>
<keyword
>grafer</keyword>
<keyword
>nod</keyword>
<keyword
>båge</keyword>
</keywordset>

</bookinfo>

<chapter id="introduction">
<title
>Inledning</title>
<para
>I det här kapitlet ger vi en översikt av &rocs;. För läsaren som direkt vill börja använda &rocs; föreslår vi att läsa åtminstone <xref linkend="introduction-nutshell"/> och använda <xref linkend="scripting"/> som referens för att skriva skript. </para>

<sect1 id="introduction-goals">
<title
>Syfte, målgrupp och arbetsflöde</title>
<para
>&rocs; är en integrerad utvecklingsmiljö för grafteori avsedd för alla som är intresserade av att konstruera och analysera grafalgoritmer. Det omfattar speciellt</para>
<itemizedlist>
    <listitem
><para
>föreläsare som vill demonstrera algoritmer för sina studenter,</para
></listitem>
    <listitem
><para
>studenter som vill förstå och se hur deras algoritmer fungerar,</para
></listitem>
    <listitem
><para
>och alla som är intresserade av datastrukturer och algoritmer.</para
></listitem>
</itemizedlist>

<para
>För alla dessa användare tillhandahåller &rocs; en lättanvänd datastruktureditor för att skapa grafer, listor eller träd, en kraftfullt Qt Script-skriptverktyg för att utföra algoritmer, och flera hjälpverktyg för att ställa in grafer och datastrukturer för simuleringar och experiment. </para>

<para
>Det vanliga arbetssättet när &rocs; används är att börja med att skapa en graf med den visuella grafeditorn. Det kan man antingen göra för hand, genom att lägga till noder och koppla ihop dem, eller genom att använda en av hjälpalgoritmerna (om tillgänglig för det aktuella insticksprogrammet för datastruktur) som finns under <menuchoice
><guimenu
>Grafdokument</guimenu
><guimenuitem
>Verktyg</guimenuitem
> <guimenuitem
>Skapa graf</guimenuitem
> </menuchoice
>. Dessutom kan man också tilldela värden till datastrukturens element, antingen för hand eller genom att använda <menuchoice
><guimenu
>Grafdokument</guimenu
> <guimenuitem
>Verktyg</guimenuitem
> <guimenuitem
>Tilldela värden</guimenuitem
></menuchoice
>. Till sist kan man skriva algoritmer i Javascript och utföra dem med datastrukturen som just har skapats. Ändringarna som görs av algoritmen syns direkt på den visuella grafeditorns skrivtavla. </para>

<screenshot>
<screeninfo
>En skärmbild av &rocs;.</screeninfo>
<mediaobject>
<imageobject>
<imagedata fileref="rocs-screenshot.png" format="PNG"/>
</imageobject>
<textobject>
<phrase
>En skärmbild av &rocs;.</phrase>
</textobject>
</mediaobject>
</screenshot>
</sect1>

<sect1 id="introduction-nutshell">
<title
>&rocs; i ett nötskal</title>
<para
>I det här avsnittet ger vi en kortfattad översikt av kärnelementen i &rocs;. Vi förklarar de viktiga begreppen datastruktur, insticksprogram för datastrukturer och elementtyper. Kännedom om dessa element är användbar för att förstå hur datastrukturer kan skapas och ändras i &rocs;. </para>
<para
>I allmänhet arbetar &rocs; med projekt: när &rocs; startas skapas ett tomt projekt och du kan ersätta det genom att läsa in eller importera ett annat projekt. Härigenom består ett projekt själva av <emphasis
>grafdokument</emphasis
> och <emphasis
>skript</emphasis
>. </para>

<sect2>
<title
>Grafdokument och insticksprogram för datastrukturer</title>
<para
>Ett grafdokument representerar innehållet på en skrivtavla i den visuella grafeditorn. Härigenom kan ett grafdokument innehålla flera datastrukturer samtidigt, men bara ett insticksprogram för datastrukturer. Insticksprogram för datastrukturer finns tillgängliga för flera olika typer av grafer (allmänna grafer, länkade listor, rotade träd) och tillhandahåller ytterligare funktionalitet för sina specifika typer av grafer. Det kan vara automatisk positionering av elementen, särskilda ikonuppsättningar eller en utökad uppsättning skriptfunktioner för användning i algoritmer (för detaljinformation titta i motsvarande avsnitt av handboken). Det är möjligt att ändra insticksprogram för datastrukturer i ett grafdokument, även om information kan gå förlorad (t.ex. bågarna för en cirkel i en allmän graf läggs inte till i ett träd, om du byter till insticksprogrammet för rotat träd). </para>
<para
>Grafdokument utgör också basen för att definiera piltyper och datatyper. </para>
</sect2>

<sect2>
<title
>Datastrukturer</title>
<para
>Datastrukturer är basen för allt arbete i &rocs;. Du kan lägga till en eller flera sådana i ett grafdokument, och dataelement (noder, datavärden) och pekare till dem, samt ändra dem med skript. För detta har varje datastruktur sitt unika namn som den kan kommas åt med från skript. På grund av valet av insticksprogram för den aktuella datastrukturen kan det inträffa att du inte kan ändra datastrukturen godtyckligt (t.ex. ska ett träd aldrig innehålla en cykel). Insticksprogrammet för datastrukturen bestäms av det insticksprogram för datastrukturer som är associerat med motsvarande grafdokument som innehåller datastrukturen. </para>
</sect2>

<sect2>
<title
>Piltyper</title>
<para
>Med piltyper kan du definiera olika typer av pilar som ska användas av datastrukturerna. Det betyder att en piltyp kan få en individuell layout (stort sett en färg) och det är enkelt att bara komma åt pilar av en viss typ från skript. Typiska användarfall för pilar kan vara att implementera meta-bågar i datastrukturer som åskådliggör förhållanden mellan dataelement (t.ex. åskådliggör kommunikationsbehov). Men om skript dessutom ska identifiera särskilda typer av bågar (t.ex. träd och korsande bågar i djup-först sökalgoritmer), kan piltyper vara ett elegant sätt att implementera det. </para>
</sect2>

<sect2>
<title
>Datatyper</title>
<para
>I flera datastrukturproblem ska en uppsättning dataelement delas upp i grupper av olika typer (t.ex. ett klusterproblem eller täckningsproblem). Annars är det användbart att specificera en dataelementtyp för att uttrycka en specifik sort (t.ex. bredd-först sökning) när en algoritm utförs. För sådana fall kan datatyper definieras. Varje datatyp har sin egen ikon, och dataelement av en viss typ kan enkelt kommas åt från skript. </para>
</sect2>

<sect2>
<title
>Dynamiska egenskaper</title>
<para
>Varje dataelement och pil har de två egenskaperna <literal
>namn</literal
> och <literal
>värde</literal
>. För att utöka egenskaperna hos dataelement och pilar kan du lägga till <emphasis
>dynamiska egenskaper</emphasis
> till dem. Varje dynamisk egenskap identifieras med sitt namn och kan innehålla vilken sträng som helst. Använd dialogrutorna <guilabel
>Dataegenskaper</guilabel
> och <guilabel
>Pilegenskaper</guilabel
> i de sammanhangsberoende menyerna för respektive element eller skriptfunktionerna som förklaras i <xref linkend="scripting-data-structure"/>, för att lägga till dynamiska egenskaper. </para>
</sect2>
</sect1>

<sect1 id="introduction-tutorial">
<title
>Handledning</title>
<para
>I det här avsnittet ska vi skapa ett exempelprojekt för att utforska några av de viktigaste funktionerna i &rocs;. Målet är att skapa en graf och ett skript som åskådliggör en enkel 2-approximativ algoritm för problemet med <emphasis
>minimal hörntäckning</emphasis
>. Minimal hörntäckning är problemet att hitta en delmängd av grafnoder C med minimal storlek, sådan att varje grafbåge är ansluten till minst en nod i C. Problemet är känt som NP-svårt, och vi vill åskådliggöra hur man hittar en approximation med faktorn 2 genom att hitta en motsvarighet i den givna grafen (i det följande använder vi de vanliga termerna för grafalgoritmer: grafen är datastrukturen, noder är dataelementen, bågar är pilarna). </para>
<para
>Vårt mål är att åskådliggöra likheten mellan motsvarigheten och den minimala hörntäckningen. För att göra det behöver vi specificera två piltyper, en för att visa motsvarande bågar och en för att visa vanliga bågar, samt två datatyper som vi använder för att skilja på noder som ingår i C och de som inte ingår i C. </para>

<sect2>
<title
>Skapa en graf</title>
<para
>&rocs; levereras med ett hjälpverktyg för grafinsticksprogrammet som kan skapa grafer. Vi går till <menuchoice
><guimenu
>Grafdokument</guimenu
> <guisubmenu
>Verktyg</guisubmenu
> <guimenuitem
>Skapa graf</guimenuitem
></menuchoice
>. Där skapar vi en "Slumpmässig graf" med 30 noder, 90 bågar och fröet 1 (fröet är startfrö för den slumpmässiga grafgenereringen, används samma frö flera gånger erhålles samma och upprepningsbara grafer). Till sist ändrar vi grafnamnet i datastrukturpanelen och kallar grafen <literal
>testgraf</literal
>. </para>
</sect2>

<sect2>
<title
>Skapa typer</title>
<para
>Vi använder knappen <guibutton
>Dokumentegenskaper</guibutton
> i datastrukturpanelen för att visa egenskapsdialogrutan för data- och piltyper i det aktuella grafdokumentet. I datatyperna lägger vi till en ny typ som heter "C", som automatiskt för identifieraren <literal
>1</literal
>. Vi väljer serverbilden som ikon för typen. Dessutom byter vi till piltypsidan och lägger till en ny piltyp som kallas "match". Den får automatiskt identifieraren <literal
>1</literal
>, och vi ställer in färgen till blå. </para>
</sect2>

<sect2>
<title
>Algoritmen</title>
<para
>Till sist måste vi implementera approximationsalgoritmen. Vi använder följande implementering för den: </para>
<programlisting
>var E = testgraph.list_edges(); // mängden obehandlade bågar
var C = new Array();            // matchande bågar
while (E.length 
> 0) {
    var e = E[0];        // vi tar första bågen e={u,v}
    var u = e.start();
    var v = e.end();
    e.set_type(1);        // ställ in bågen till en matchande båge
    E.shift();            // ta bort e (dvs. E[0]) från listan av bågar
    C.push(u);            // lägg till u i C
    C.push(v);            // lägg till v i C

    // markera u,v som noder i C
    u.set_type(1);
    v.set_type(1);

    // ta bort alla bågar från E som ansluter till u eller v
    var adjacent = u.adj_edges();
    for (var i=0; i &lt; adjacent.length; i++) {
        var index = E.indexOf(adjacent[i]); // hitta index
        if (index!=-1) {
            E.splice(index, 1); // ta bort om redan hittad
        }
    }
    var adjacent = v.adj_edges();
    for (var i=0; i &lt; adjacent.length; i++) {
        var index = E.indexOf(adjacent[i]); // hitta index
        if (index!=-1) {
            E.splice(index, 1); // ta bort om redan hittad
        }
    }
}
output("Vertex Cover contains " + C.length + " nodes.");
</programlisting>
</sect2>

<sect2>
<title
>Utför algoritmen</title>
<para
>Till sist vill vi utföra algoritmen. För att göra det kan vi starta körningen med knappen <guibutton
>Kör</guibutton
> i skriptpanelen. </para>
</sect2>
</sect1>
</chapter>

<chapter id="user-interface">
<title
>&rocs; användargränssnitt</title>

<sect1 id="user-interface-all">
<title
>Allmänna delar i användargränssnittet</title>
<para
>Användargränssnittet är uppdelat i flera logiska delar som framgår av skärmbilden nedan. </para>
<screenshot>
    <screeninfo
>Grafiska element i &rocs; användargränssnitt.</screeninfo>
    <mediaobject>
    <imageobject>
    <imagedata fileref="rocs-interfaces.png" format="PNG"/>
    </imageobject>
    <textobject>
    <phrase
>Grafiska element i &rocs; användargränssnitt.</phrase>
    </textobject>
    </mediaobject>
</screenshot>
<variablelist>
<varlistentry>
    <term
>Visuell grafeditor</term>
    <listitem
><para
>Detta är skrivtavlan där datastrukturer skapas och ändras. Högerklicka på skrivtavlan, på dataelement eller på pilar för att visa sammanhangsberoende menyer. Du kan använda verktygen från den <emphasis
>visuella grafeditorns verktygsrad</emphasis
> för att ändra elementen på den visuella grafeditorns skrivtavla.</para
></listitem>
</varlistentry>
<varlistentry>
    <term
>Den visuella grafeditorns verktygsrad</term>
    <listitem
><para
>Detta är verktygen som ska användas för att ändra datastrukturerna på den visuella grafeditorns skrivtavla. Genom att använda <guibutton
>Lägg till data</guibutton
> eller <guibutton
>Lägg till anslutning</guibutton
> kan du skapa nya dataelement och lägga till dataelement respektive pilar i den markerade datastrukturen i <emphasis
>grafens egenskapskomponent</emphasis
>. Observera att både <guibutton
>Lägg till data</guibutton
> och <guibutton
>Lägg till anslutning</guibutton
> har sammanhangsberoende menyer för val av data- och piltyp för de nya elementen som ska skapas. För detaljerad information, se <xref linkend="user-interface-toolbars"/>. </para
></listitem>
</varlistentry>
<varlistentry>
    <term
>Grafegenskaper</term>
    <listitem
><para
>Längst upp kan du välja aktuellt grafdokument, öppna dess inställningsdialogruta, och lägga till nya datastrukturer i det aktuella grafdokumentet (dvs. på aktuell skrivtavla). Nedanför kan du välja aktuell datastruktur. Där kan du ändra vilka dataelement och pilegenskaper (namn, värden, objekt) som är synliga genom att klicka på respektive knappar. Genom ett klick på data- och piltypernas namn kan du komma åt deras inställningsdialogrutor. För detaljerad information, se <xref linkend="user-interface-graph-properties"/>. </para
></listitem>
</varlistentry>
<varlistentry>
    <term
>Skripteditor</term>
    <listitem
><para
>I texteditorn kan algoritmer skrivas som förklaras i detalj i <xref linkend="scripting"/>. Det går att arbeta med flera skriptdokument samtidigt genom att använda flera flikar. Skivsymbolen på en flik visas om skriptet innehåller osparade ändringar. </para
></listitem>
</varlistentry>
<varlistentry>
    <term
>Felsöknings- och skriptutmatning</term>
    <listitem
><para
>I det här textområdet visas antingen felsökningsinformation eller skriptutmatning från algoritmer, beroende på val av utmatningsinställning. Om ett fel uppstår i skriptet, väljes automatiskt felsökningsutmatning. Förutom felsökningsmeddelanden, innehåller felsökningsutmatningen alla meddelanden. </para
></listitem>
</varlistentry>
<varlistentry>
    <term
>Styrning</term>
    <listitem
><para
>I det här området styrs körning av algoritmerna. Skriptet som för närvarande är öppet i skripteditorn kan köras med genom att klicka på <guiicon
>Kör</guiicon
>. Medan skriptet körs, är det möjligt att stoppa det genom att klicka på knappen <guiicon
>Stopp</guiicon
>. Observera att körning med <guibutton
>Ett steg</guibutton
> bara stoppar vid specifika nyckelord (se <xref linkend="scripting"/>) </para
></listitem>
</varlistentry>
</variablelist>
</sect1>

<sect1 id="user-interface-toolbars">
<title
>Verktygsrader</title>
<para
>Det finns olika verktygsrader för den visuella grafeditorn som gör det möjligt att komma åt funktioner med bara ett klick. Med standardinställningen visas följande verktygsrader:</para>
<itemizedlist>
    <listitem
><para
>Huvudverktygsrad</para
></listitem>
    <listitem
><para
>Justeringsverktygsrad</para
></listitem>
</itemizedlist>
<!--  -->
<sect2 id="user-interface-toolbars-main">
<title
>Huvudverktygsrad</title>
<para
><emphasis
>Huvudverktygsraden</emphasis
> innehåller följande åtgärder. Att klicka på en åtgärd leder till att muspekaren utför den åtgärden på den visuella grafeditorns skrivtavla:</para>
<itemizedlist>
<listitem
><para
><guilabel
>Flytta</guilabel
>: För att markera element, klicka antingen på en oanvänd plats på skrivtavlan, håll musknappen nedtryckt och rita en rektangel som innehåller några noder och/eller bågar för att markera dessa element, eller klicka annars direkt på ett omarkerat element för att markera det. Om du klickar på ett markerat element, eller en uppsättning markerade element, kan de flyttas omkring genom att hålla musknappen nedtryckt och flytta omkring musen. Det är också möjligt att flytta markerade element med piltangenterna.</para
></listitem>
<listitem
><para
><guilabel
>Lägg till data</guilabel
>: Klicka på ett godtyckligt ställe på den visuella grafeditorns skrivtavla för att skapa ett nytt dataelement som hör till datastrukturen som för närvarande är markerad. Genom att hålla muspekaren nedtryckt visas en sammanhangsberoende meny där datatypen för det nyskapade dataelementen kan väljas (bara om olika datatyper finns).</para
></listitem>
<listitem
><para
><guilabel
>Lägg till anslutning</guilabel
>: Klicka på ett dataelement, håll musknappen nedtryckt och rita en linje till ett annat dataelement, dit pilen/bågen ska peka. Åtgärden lyckas bara om den aktuella grafen tillåter att bågen läggs till (i en oriktad graf får t.ex. inte mer än en båge läggas till mellan två dataelement). Genom att hålla muspekaren nedtryckt, dyker en sammanhangsberoende meny upp där piltypen för de nyskapade pilarna kan väljas (bara om olika piltyper finns).</para
></listitem>
<listitem
><para
><guilabel
>Ta bort</guilabel
>: Klicka på ett element för att ta bort det. Om du tar bort en nod, tas också alla intilliggande bågar bort.</para
></listitem>
<listitem
><para
><guilabel
>Zooma</guilabel
>: Klicka på skrivtavlan, håll vänster musknapp nertryckt, och rita på så sätt en rektangel. Skrivtavlan zoomas till det markerade området. Använd också mushjulet för att zooma in eller ut. Ett dubbelklick med musens vänsterknapp återställer ursprunglig zoomnivå.</para
></listitem>
</itemizedlist>
<screenshot>
<screeninfo
>Huvudverktygsraden.</screeninfo>
<mediaobject>
<imageobject>
<imagedata fileref="rocs-toolbar-main.png" format="PNG"/>
</imageobject>
<textobject>
<phrase
>Huvudverktygsraden.</phrase>
</textobject>
</mediaobject>
</screenshot>
</sect2>

<sect2 id="user-interface-toolbars-alignment">
<title
>Justeringsverktygsrad</title>
<para
>Det går att lägga till en valfri <emphasis
>justeringsverktygsrad</emphasis
>. Genom att klicka på ett alternativ i verktygsraden erhålls direkt en effekt på noderna som för närvarande är markerade:</para>
<itemizedlist>
<listitem
><para>
<inlinemediaobject
><imageobject>
<imagedata fileref="hi22-action-rocsaligntop.png" format="PNG"/></imageobject>
</inlinemediaobject
> <guilabel
>Upp</guilabel
>: Justera dataelementen längs den vertikala positionen av det översta dataelementet. Detta påverkar bara vertikala positioner.</para
></listitem>
<listitem
><para>
<inlinemediaobject
><imageobject>
<imagedata fileref="hi22-action-rocsalignvmiddle.png" format="PNG"/></imageobject>
</inlinemediaobject
> <guilabel
>Mitt</guilabel
>: Justera dataelementen längs den vertikala positionen som anges av centrum för alla markerade noders vertikala position. Detta påverkar bara vertikala positioner.</para
></listitem>
<listitem
><para>
<inlinemediaobject
><imageobject>
<imagedata fileref="hi22-action-rocsalignbottom.png" format="PNG"/></imageobject>
</inlinemediaobject
> <guilabel
>Bas</guilabel
>: Justera dataelementen längs den vertikala positionen av det understa dataelementet. Detta påverkar bara vertikala positioner.</para
></listitem>
<listitem
><para>
<inlinemediaobject
><imageobject>
<imagedata fileref="hi22-action-rocsalignleft.png" format="PNG"/></imageobject>
</inlinemediaobject
> <guilabel
>Vänster</guilabel
>: Justera dataelementen längs den horisontella positionen för dataelementet längst åt vänster. Detta påverkar bara horisontella positioner.</para
></listitem>
<listitem
><para>
<inlinemediaobject
><imageobject>
<imagedata fileref="hi22-action-rocsalignhmiddle.png" format="PNG"/></imageobject>
</inlinemediaobject
> <guilabel
>Mitt</guilabel
>: Justera dataelementen längs den horisontella positionen för dataelementet längst upp. Detta påverkar bara horisontella positioner.</para
></listitem>
<listitem
><para>
<inlinemediaobject
><imageobject>
<imagedata fileref="hi22-action-rocsalignright.png" format="PNG"/></imageobject>
</inlinemediaobject
> <guilabel
>Höger</guilabel
>: Justera dataelementen längs den horisontella positionen för dataelementet längst åt höger. Detta påverkar bara horisontella positioner.</para
></listitem>
<listitem
><para>
<inlinemediaobject
><imageobject>
<imagedata fileref="hi22-action-rocsaligncircle.png" format="PNG"/></imageobject>
</inlinemediaobject
> <guilabel
>Cirkel</guilabel
>: Justerar dataelementen längs en cirkel vars diameter är lika med den maximala avståndet mellan dataelementen. Dataelementen placeras i samma följd som ges av hur dessa dataelement ser ut från sin tyngdpunkt.</para
></listitem>
<listitem
><para>
<inlinemediaobject
><imageobject>
<imagedata fileref="hi22-action-rocsaligntree.png" format="PNG"/></imageobject>
</inlinemediaobject
> <guilabel
>Minimera korsande bågar</guilabel
>: Arrangera om markerade dataelement för att minimera antal korsande anslutningar (applicerar Fruchterman-Reingold-algoritmen).</para
></listitem>
</itemizedlist>
<screenshot>
<screeninfo
>Justeringsverktygsraden.</screeninfo>
<mediaobject>
<imageobject>
<imagedata fileref="rocs-toolbar-alignment.png" format="PNG"/>
</imageobject>
<textobject>
<phrase
>Justeringsverktygsraden.</phrase>
</textobject>
</mediaobject>
</screenshot>
</sect2>
</sect1>

<sect1 id="user-interface-graph-properties">
<title
>Panelen Grafegenskaper</title>
<para
>Längst upp i panelen kan det aktuella grafdokumentet väljas. Nedanför det kan nya datastrukturer skapas eller befintliga datastrukturer anpassas. </para>

<sect2 id="user-interface-graph-properties-document">
<title
>Val av dokument och egenskaper</title>
<para
>Längst upp i panelen kan du välja nuvarande grafdokument. Grafdokumentet representerar den skrivtavla som visas i den visuella grafeditorn. För att skapa ett nytt grafdokument, eller lägga till ett befintligt dokument i projektet, använd <menuchoice
><guimenu
>Projekt</guimenu
> <guimenuitem
>Nytt grafdokument</guimenuitem
></menuchoice
> eller <menuchoice
><guimenu
>Projekt</guimenu
> <guimenuitem
>Importera &rocs;-graf</guimenuitem
></menuchoice
>. Du kan också importera grafdokument från tredjepartsprogram (se <xref linkend="import-export"/>). Genom att klicka på <guibutton
>Egenskaper</guibutton
> kan du komma åt grafdokumentets egenskaper. </para>
</sect2>

<sect2 id="user-interface-graph-properties-datastructure-create">
<title
>Skapa ny datastruktur</title>
<para
>Du kan skapa en ny datastruktur genom att infoga en identifierare (utan mellanslag eller specialtecken) och därefter klicka på <guibutton
>Lägg till</guibutton
>. Identifieraren används för att komma åt datastrukturen från algoritmer. </para>
</sect2>

<sect2 id="user-interface-graph-properties-datastructure-config">
<title
>Anpassa datastrukturer</title>
<para
>Alla tillgängliga datastrukturer i det aktuella grafdokumentet visas i en urvalslista. När en markeras, visas inställningarna för den motsvarande datastrukturen: </para>
    
<itemizedlist>
    <listitem
><para
><guibutton
>Ta bort</guibutton
>: Ta bort den här datastrukturen. </para
></listitem>
    <listitem
><para
><guilabel
>Namn</guilabel
>: Detta är datastrukturens identifierare. Denna identifierar används för att komma åt datastrukturen från algoritmer. </para
></listitem>
    <listitem
><para
><guilabel
>Visningsalternativ</guilabel
> Nedanför visas alla data- och piltyper som tillhör datastrukturen. Genom att klicka på namnet kan du öppna inställningsdialogrutorna för de motsvarande typerna. Dessutom kan dataelementens och pilarnas synlighet, namn, och den givna typens elementvärden bestämmas genom att klicka på motsvarande knappar. </para
></listitem>
</itemizedlist>
</sect2>

<sect2 id="user-interface-graph-properties-datastructure-individual">
<title
>Anpassa alternativ i insticksprogram för datastrukturer</title>
<para
>Varje insticksprogram för datastrukturer kan lägga till alternativ i datastrukturens inställningsdialogruta. Standardinsticksprogrammen för datastrukturer tillhandahåller följande alternativ: </para>
    
<sect3>
<title
>Grafinsticksprogram</title>
<para
>Använd <guilabel
>Graftyp</guilabel
> för att välja grafens typ. Betydelsen av typerna är följande: </para>
<itemizedlist>
    <listitem
><para
><guilabel
>Riktad graf</guilabel
>: Graf med riktade bågar, där flera bågar med likadan orientering mellan samma noder inte är tillåtna. </para
></listitem>
    <listitem
><para
><guilabel
>Oriktad graf</guilabel
>: Graf med bågar utan riktning där flera bågar mellan samma noder inte är tillåtna. </para
></listitem>
    <listitem
><para
><guilabel
>Riktad multigraf</guilabel
>: Graf med riktade bågar där flera bågar med samma riktning mellan samma noder är tillåtna. </para
></listitem>
    <listitem
><para
><guilabel
>Oriktad multigraf</guilabel
>: Graf med bågar utan riktning där flera bågar mellan samma noder är tillåtna. </para
></listitem>
</itemizedlist>
</sect3>

<sect3>
<title
>Insticksprogrammet Rotat träd</title>
<para
>Genom att markera egenskapen <guilabel
>Visa alla pilar</guilabel
> visas alla pilar mellan trädets noder. Om den inte markeras, kombineras flera pilar mellan samma noder till en. </para>
</sect3>

</sect2>
</sect1>
</chapter>

<chapter id="scripting">
<title
>Skriva och utföra algoritmer i &rocs;</title>

<para
>Internt använder &rocs; skriptgränssnittet QtScript, som är ett specifikt Javascript-gränssnitt. Det innebär att alla algoritmer du implementerar måste använda Javascript. Hur Javascript fungerar och hur man skriver kod för Javascript täcks inte av den här handboken, men vi beskriver hur du kommer åt datastrukturer, dataelement och pilar i dina datastrukturer via skriptgränssnittet. Eftersom du aldrig använder det grundläggande datastrukturobjektet, utan ett som tillhandahålls av det aktuella insticksprogrammet för datastrukturer, utökas datastrukturens funktionalitet av motsvarande insticksprogram, och du måste ta en titt på den specialiserade funktionaliteten. I synnerhet, använder insticksprogram för datastrukturer vanlig terminologi från sin domän (noder och bågar för grafer, löv och rot för träd, etc.). </para>
<para
>Det är viktigt att känna till att ändringarna som görs av skriptgränssnittet direkt reflekteras i egenskaperna på den visuella grafeditorns skrivtavla. Sålunda ändrar skripten verkligen själva datastrukturerna. </para>

<sect1 id="scripting-data-structure">
<title
>Grundläggande element i datastrukturer</title>
<para
>Varje insticksprogram tillhandahåller en särskild uppsättning funktioner och egenskaper för sina datastrukturer och deras element. Men varje insticksprogram tillhandahåller också egenskaperna och funktionerna som har definierats för basdatastrukturen. Därför är allt som beskrivs i det här avsnittet tillgängligt i alla insticksprogram för datastrukturer. </para>
<sect2
><title
>Grundläggande egenskaper för datastrukturer</title>
<para
>Datastrukturer identifieras av sina namn. Om du alltså skapade en datastruktur med namnet <literal
>testgraf</literal
> kan du komma åt den genom att bara skriva denna identifierare. För att exempelvis få ett fält med alla dataelement i den givna datastrukturen kan du skriva <literal
>testgraf.list_nodes();</literal
> i skriptet. </para>

<sect3>
<title
>Grundläggande egenskaper och funktioner för datastrukturer</title>
<para
>Varje datastrukturs <literal
>testgraf</literal
> har följande egenskaper som kan läsas eller skrivas av <literal
>testgraf.property</literal
>: </para>
<programlisting
>string namn  // identifikation av datastrukturen
</programlisting>
</sect3>
</sect2>

<sect2>
<title
>Grundläggande egenskaper och funktioner för dataelement</title>
<para
>Varje dataelement har följande egenskaper som kan läsas eller skrivas: </para>
<programlisting
>    double x      // x-koordinat för aktuell position
    double y      // y-koordinat för aktuell position
    double width  // storlek
    string value  // värde
    string name   // namn
    string color  // färg i hexadecimal notation
</programlisting>
<para
>Dessutom kan varje dynamisk egenskap i ett dataelement kommas åt via sitt namn. </para>

<para
>Varje dataelement tillhandahåller också följande metoder: </para>
<programlisting
>    int type();                         // dataelementets datatyp
    int set_type(int);                  // ange dataelementets datatyp
    void add_property(string name,      // lägg till dynamisk egenskap för
                      string value);    // dataelement med angivet namn och värde
    array adj_data();                   // lista över intilliggande data
    array adj_pointers();               // lista över intilliggande pilar
    array input_pointers();             // lista över pilar som pekar inåt
    array output_pointers();            // lista över pilar som pekar utåt
    array loop_pointers();              // lista över pilar som själva formar en cirkel
    array connected_pointers(target);   // lista över pilar som pekar på'target'
    void self_remove();                 // ta bort detta dataelement
</programlisting>
</sect2>

<sect2>
<title
>Basegenskaper och funktioner för pilar</title>
<para
>Varje pil har följande egenskaper som kan läsas eller skrivas: </para>
<programlisting
>    string color  // färg i hexadecimal notation
    string value  // värde
    string name   // namn
    double width  // bredd
    string style  // något av värdena: dot, dash, dash dot, solid
</programlisting>
<para
>Dessutom kan varje dynamisk egenskap för en pil kommas åt via sitt namn. </para>

<para
>Varje pilobjekt tillhandahåller följande metoder: </para>
<programlisting
>    int type();                         // pilens piltyp
    int set_type(int);                  // ange pilens piltyp
    void add_property(string name,      // lägg till dynamisk egenskap för
                      string value);    // dataelement med angivet namn ochvärde
    node start();                       // startnod för pilen
    node end();                         // målnod för pilen
    void self_remove();                 // ta bort denna pil
</programlisting>
</sect2>
</sect1>

<sect1 id="scripting-plugin-graph">
<title
>Insticksprogrammet för grafer</title>
<sect2>
<title
>Grafegenskaper och funktioner</title>

<sect3>
<title
>Grafstrukturen</title>
<para
>Med ett datastrukturobjekt av typen "Graph" kan du anropa följande medlemsfunktioner: </para>
<programlisting
>    array list_nodes();                   // lista över alla noder i grafen
    array list_edges();                   // lista över alla bågar i grafen
    node add_node(name);                  // lägg till och returnera noden
    edge add_edge(node from, node to);    // lägg till och returnera ny bågefrån 'from' till 'to'
    array overlay_edges(int overlayID);   // lista över alla bågar i angivet överlägg
    edge add_overlay_edge(node from,
                          node to,
                          int overlayID); // lägg till båge för given piltypi angivet överlägg
</programlisting>
</sect3>

<sect3>
<title
>Grafnoder</title>
<para
>Med ett givet datastrukturobjekt av typen "Graph" kan du anropa följande medlemsfunktioner för grafnoderna utöver egenskaperna som tillhandahålls av dataelementen: </para>
<programlisting
>    array adj_nodes();                    // lista över alla intilliggande noder
    array adj_edges();                    // lista över ihopkopplade bågar
    array input_edges();                  // lista över bågar som pekar inåt
    array output_edges();                 // lista över bågar som pekar utåt
    array loop_edges();                   // lista över alla bågar som går runt till noden
    array connected_edges(node target);   // alla bågar som kopplar denna till noden 'target'
</programlisting>
</sect3>

<sect3>
<title
>Grafbågar</title>
<para
>För givna bågar i en datastruktur av typen "Graph" är bara egenskaperna för basdatastrukturen tillgängliga. </para>
</sect3>
</sect2>

<sect2>
<title
>Algoritmer för grafstruktur</title>
<para
>Grafinsticksprogrammet tillhandahåller några specialfunktioner som kan användas från skriptgränssnittet.</para>
<variablelist>
<varlistentry>
<term
>Beräkning av kortaste vägen</term>
<listitem>
    <para
>Beräknar kortaste väg mellan noderna <emphasis
>start</emphasis
> och <emphasis
>slut</emphasis
>. Båda noderna måste ingå i samma graf. Beräkningen tar hänsyn till om grafen är riktad eller inte.</para>
    <funcsynopsis>
    <funcprototype
><funcdef
>array <function
>dijkstra_shortest_path</function
></funcdef
> <paramdef
>node <parameter
><replaceable
>start</replaceable
></parameter
></paramdef
> <paramdef
>node <parameter
><replaceable
>end</replaceable
></parameter
></paramdef
> </funcprototype>
    </funcsynopsis>
</listitem>
</varlistentry>
<varlistentry>
<term
>Kortaste vägens avstånd</term>
<listitem>
    <para
>Beräknar kortaste vägens avståndet från noden <emphasis
>start</emphasis
> till alla andra noder i grafen. Beräkningen tar hänsyn till om grafen är riktad eller inte.</para>
    <funcsynopsis>
    <funcprototype
><funcdef
>array <function
>distances</function
></funcdef
> <paramdef
>node <parameter
><replaceable
>start</replaceable
></parameter
></paramdef
> </funcprototype>
    </funcsynopsis>
</listitem>
</varlistentry>
</variablelist>
</sect2>
</sect1>

<sect1 id="scripting-plugin-linkedlist">
<title
>Insticksprogrammet för länkade listor</title>
<sect2>
<title
>Länkade listors egenskaper och funktioner</title>

<sect3>
<title
>Länkade listors struktur</title>
<para
>Med ett datastrukturobjekt av typen "Linked List" kan du anropa följande medlemsfunktioner: </para>
<programlisting
>    node begin();                           // ger huvudnoden i den länkadelistan
    setBegin(node begin):                   // ange startnod som listans början och arrangera om den
    createNode();                           // skapa en ny listnod
</programlisting>
</sect3>

<sect3>
<title
>Länkade listnoder</title>
<para
>Med ett datastrukturobjekt av typen "Linked List" kan du anropa följande medlemsfunktioner på grafnoderna utöver egenskaperna som tillhandahålls av dataelementen: </para>
<programlisting
>node front();                           // returnerar nodens föregångare
</programlisting>
</sect3>

<sect3>
<title
>Bågar i länkade listor</title>
<para
>Med bågar från en datastruktur av typen "Linked List" är bara egenskaperna för basdatastrukturen tillgängliga. </para>
</sect3>
</sect2>
</sect1>

<sect1 id="scripting-plugin-rootedtree">
<title
>Insticksprogrammet Rotat träd</title>
<sect2>
<title
>Egenskaper och funktioner för Rotat träd</title>

<sect3>
<title
>Strukturen Rotat träd</title>
<para
>Med ett datastrukturobjekt av typen "Rooted Tree" kan följande egenskaper läsas eller skrivas: </para>
<programlisting
>ShowAllPointers     // ställ in till true om alla bågar ska visas, annars false om bågar ska komprimeras
</programlisting>
<para
>Med ett datastrukturobjekt av typen "Rooted Tree" kan du anropa följande medlemsfunktioner: </para>
<programlisting
>    node add_data(string name);         // lägg till en nod i trädet med givet namn
    void set_root_node(node root);      // ange rot som trädets rotnod
    node root_node();                   // returnera trädets rotnod
</programlisting>
</sect3>

<sect3>
<title
>Noder i Rotat träd</title>
<para
>Med ett nodobjekt av typen "Rooted Tree" kan följande egenskaper läsas eller skrivas: </para>
<programlisting
>    int numberOfChilds                  // ange nodens antal (tillåtna) underliggande noder
    node left_child                     // läs endast: den vänstra underliggande noden
    node right_child                    // läs endast: den högra underliggande noden
    node node_parent                    // läs endast: den ovanliggande noden
</programlisting>
<para
>Med ett nodobjekt av typen "Rooted Tree" kan du anropa följande medlemsfunktioner: </para>
<programlisting
>    node add_left_child(node child);    // lägg till underliggande nod till vänster
    node add_right_child(node child);   // lägg till underliggande nod till höger
    node add_child(node child, int i);  // lägg till en underliggande nod som den i:te noden
    node add_node_parent(node child);   // lägg till ovanliggande nod (fungerar bara om den inte finns)
    node left_child();                  // returnera höger underliggande nod
    node right_child();                 // returnera vänster underliggande nod
    node child_at(int i);               // returnera den i:te underliggande noden
    node node_parent();                 // returnera nodens överliggande nod
</programlisting>
</sect3>

<sect3>
<title
>Bågar i Rotat träd</title>
<para
>Med bågar från en datastruktur av typen "Rooted Tree" är bara egenskaperna för basdatastrukturen tillgängliga. </para>
</sect3>
</sect2>
</sect1>

<sect1 id="scripting-controls">
<title
>Styra körning av skript</title>
     

<sect2>
<title
>Inkludera filer</title>
<para
>Skriptdokument kan inkludera andra skript. Det kan vara användbart för att minska storleken på skriptdokumenten och förbättra läsbarheten. Genom att använda <menuchoice
><guimenu
>Skriptdokument</guimenu
> <guimenuitem
>Möjliga deklarationsfiler</guimenuitem
></menuchoice
> får du en lista över de skriptfiler som levererades med &rocs; som kan inkluderas. Du kan inkludera en skriptfil med följande kommando: </para>
<programlisting
>include_script(string path);            // relativ eller absolut sökvägtill skriptfilen
</programlisting>
</sect2>

<sect2 id="scripting-output">
<title
>Skriptutmatning</title>
<para
>När en algoritm körs visas felsöknings- och programutdata i <emphasis
>felsöknings- och skriptutmatning</emphasis
>. Om skriptgränssnittet upptäcker ett syntaxfel i skriptet visas även det felet som ett felsökningsmeddelande. Observera att alla programmeddelanden också visas i felsökningsutmatningen (med fetstil). </para>
<para
>Du kan bestämma vilken text som visas i skriptutmatningen med följande funktioner: </para>
<programlisting
>    output(string message);            // visar meddelandet som skriptutdata
    debug(string message);             // visar meddelandet som felsökningsutdata
</programlisting>
</sect2>

<sect2 id="scripting-controlling">
<title
>Styr körning av skript</title>
<para
>Det finns olika sätt att köra skripten. </para>
<para
>Du kan bestämma vilken text som visas i skriptutmatningen med följande funktioner: </para>
<itemizedlist>
    <listitem
><para>
        <inlinemediaobject
><imageobject>
        <imagedata fileref="rocs-control-engine-run.png" format="PNG"/></imageobject>
</inlinemediaobject
> <guilabel
>Starta</guilabel
>: Kör skriptet till det är klart.</para
></listitem>
    <listitem
><para>
        <inlinemediaobject
><imageobject>
        <imagedata fileref="rocs-control-engine-stop.png" format="PNG"/></imageobject>
</inlinemediaobject
> <guilabel
>Stoppa</guilabel
>: Stoppa körning av skript (bara tillgängligt om ett skript körs).</para
></listitem>
    <listitem
><para>
        <inlinemediaobject
><imageobject>
        <imagedata fileref="rocs-control-engine-step.png" format="PNG"/></imageobject>
</inlinemediaobject
> <guilabel
>Ett steg</guilabel
>: Kör skript tills ett steg avslutas. Ett steg avslutas när skriptet anropar funktionen <literal
>interrupt()</literal
>:</para>
    <programlisting
>interrupt();    // avslutar ett steg
    </programlisting>
    </listitem>
    <listitem
><para>
        <inlinemediaobject
><imageobject>
        <imagedata fileref="rocs-control-engine-debug.png" format="PNG"/></imageobject>
</inlinemediaobject
> <guilabel
>Felsökning</guilabel
>: Kör skript i felsökningsläge. Detta öppnar QtScripts felsökningsdialogruta.</para
></listitem>
</itemizedlist>
</sect2>
</sect1>
</chapter>

<chapter id="import-export">
<title
>Import och export</title>
<sect1 id="import-export-projects">
    <title
>Utbyt &rocs;-projekt</title>
    <para
>&rocs;-projekt kan importeras och exporteras som arkivfiler <literal
>.tar.gz</literal
>. Dessa arkiv kan användas för att utbyta projekt. Import och export kan utföras med <menuchoice
><guimenu
>Arkiv</guimenu
> <guimenuitem
>Importera projekt</guimenuitem
></menuchoice
> respektive <menuchoice
><guimenu
>Arkiv</guimenu
> <guimenuitem
>Exportera projekt</guimenuitem
></menuchoice
>. </para>
</sect1>

<sect1 id="import-export-graphs">
    <title
>Import av grafdokument</title>
    <para
>&rocs; stöder för närvarande import och export av följande filformat:</para>
    <itemizedlist>
        <listitem
><para
>DOT-filer, också kända som Graphviz-filer.</para
></listitem>
        <listitem
><para
>GML-filer</para
></listitem>
        <listitem
><para
>Vanliga textfiler.</para
></listitem>
    </itemizedlist>
    <para
>Stödet för de flesta av dessa filer är mycket grundläggande och stöder bara grundläggande värden. Dataelement och deras motsvarande anslutningar, namn på alla element, värden, och koordinater importeras. </para>
</sect1>
</chapter>

<chapter id="credits">
<title
>Tack till och licens</title>

<para
>&rocs; </para>
<para
>Program Copyright:</para>
<itemizedlist>
	<listitem
><para
>Copyright 2008 Ugo Sangiori (ugorox SNABELA gmail.com)</para
></listitem>
	<listitem
><para
>Copyright 2008-2012 Tomaz Canabrava (tcanabrava SNABELA kde.org)</para
></listitem>
	<listitem
><para
>Copyright 2008-2012 Wagner Reck (wagner.reck SNABELA gmail.com)</para
></listitem>
	<listitem
><para
>Copyright 2012 Andreas Cord-Landwehr (cordlandwehr SNABELA googlemail.com)</para
></listitem>
</itemizedlist>

<para
>Dokumentation Copyright:</para>
<itemizedlist>
	<listitem
><para
>Dokumentation copyright 2009 &Anne-Marie.Mahfouf; &Anne-Marie.Mahfouf.mail;</para
></listitem>
	<listitem
><para
>Dokumentation copyright 2009 Tomaz Canabrava (tcanabrava SNABELA kde.org)</para
></listitem>
	<listitem
><para
>Dokumentation copyright 2012 Andreas Cord-Landwehr (cordlandwehr SNABELA googlemail.com)</para
></listitem>
</itemizedlist>

<para
>Översättning Stefan Asserhäll <email
>stefan.asserhall@comhem.se</email
></para
> 
&underFDL; &underGPL; </chapter>

<appendix id="installation">
<title
>Installation</title>

<sect1 id="getting-rocs">
<title
>Hur man skaffar &rocs;</title>
&install.intro.documentation; </sect1>

<sect1 id="compilation">
<title
>Kompilering och installation</title>
&install.compile.documentation; </sect1>
</appendix>

&documentation.index;
</book>
<!--
Local Variables:
mode: sgml
sgml-minimize-attributes: nil
sgml-general-insert-case: lower
sgml-indent-step:0
sgml-indent-data:nil
End:
-->
