<?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 id="rocs" 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-12-02</date>
<releaseinfo
>1.8.0 &kde; 4.10</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 de centrala funktionerna och arbetssättet i &rocs;. För den ivrige 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 algoritmer. </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 datastrukturer, ett kraftfullt skriptverktyg för att utföra algoritmer, och flera hjälpverktyg 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 dataelement och koppla ihop dem, eller genom att använda en av datastrukturgeneratorerna (om tillgänglig för det aktuella datastrukturgränssnittet) 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. Alla ändringarna som görs av algoritmen syns direkt i den visuella grafeditorn. </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 de centrala delarna av &rocs;. Vi förklarar de viktiga begreppen datastruktur, datastrukturgränssnitt och elementtyper. Kännedom om dessa koncept är användbart 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 datastrukturgränssnitt</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 datastrukturgränssnitt. Datastrukturgränssnitt 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 datastrukturgränssnitt 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 gränssnittet 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 pilar till dem, samt ändra dem med skript. För detta har varje datastruktur sitt unika namn som den går att komma åt med från skript. På grund av valet av gränssnitt för den aktuella datastrukturen kan det hända att du inte kan ändra datastrukturen helt godtyckligt (t.ex. ska ett träd aldrig innehålla en cykel). Datastrukturgränssnittet bestäms av det gränssnitt för datastrukturer 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 kan ha många egenskaper. Vissa av dessa egenskaper är standardvärden från datastrukturgränssnittet. Se dokumentationen av datastrukturgränssnittet för mer information. För att lägga till fler egenskaper i 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 vilket tillhörande värde som helst. Namnet måste börja med en bokstav (a-z eller A-Z) och kan bara innehålla bokstäver, siffror och '_'. Om du försöker använda ett ogiltigt tecken i egenskapsnamnet ändras inte egenskapen. </para>
<para
>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>
<para
>Du kan också använda skript. Du behöver bara använda <literal
>add_property</literal
> med namn och värde på egenskapen. Därefter kan du använda node/pointer.propertyName för att ändra eller läsa av värdena. </para>
<para
>Här är ett exempel på hur dynamiska egenskaper används med datastrukturgränssnittet "Graf". <programlisting
>nodes = myGraph.list_nodes()
for (var i = 0; i &lt; nodes.length; ++i ){
    nodes[i].add_property("MyProperty", 0)
}
nodes[0].MyProperty = 2
nodes[1].MyProperty = nodes[0].MyProperty + 2
    </programlisting>
</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 datastrukturgränssnittet "Graf" 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
>Dokumentväljare</term>
    <listitem
><para
>Det aktuella dokumentet och datastrukturen måste väljas med den här menyraden längst upp. Att skapa eller ta bort datastrukturer samt att komma åt datastrukturers egenskaper är också möjligt här. </para
></listitem>
</varlistentry>
<varlistentry>
    <term
>Visuell grafeditor</term>
    <listitem
><para
>Detta är skrivtavlan där datastrukturer kan 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
>Denna verktygsrad tillhandahåller alla verktyg för den visuella grafeditorn.Använd verktygen <guibutton
>Lägg till data</guibutton
> eller <guibutton
>Lägg till anslutning</guibutton
> för att skapa nya dataelement och lägga till dataelement respektive pilar. Nya dataelement läggs till i datastrukturen som för närvarande är markerad i <emphasis
>Dokumentväljaren</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
>Sidorad</term>
    <listitem
><para
>Till höger finns sidoraden som tillhandahåller flera verktyg för arbetsflödet: <itemizedlist>
        <listitem
><para
>Elementtyper: Denna grafiska komponent ger direktåtkomst till de tillgängliga pil- och datatyper.</para
></listitem>
        <listitem
><para
>Journal: Varje projekt har sin egen journal som t.ex. kan användas för anteckningar om uppgifter, resultat eller observationer.</para
></listitem>
        <listitem
><para
>Dokumentation: Den här grafiska komponenten kan användas för att direkt komma åt handboken och därmed skriptdokumentationen.</para
></listitem>
        </itemizedlist>
    </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
>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 längst upp i den grafiska komponenten. Om ett fel uppstår i skriptet, väljes automatiskt felsökningsutmatning. </para
></listitem>
</varlistentry>
<varlistentry>
    <term
>Styrning</term>
    <listitem
><para
>Här hittar man hur körning av algoritmerna styrs. 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>
<inlinemediaobject
><imageobject>
<imagedata fileref="hi22-action-rocsselectmove.png" format="PNG"/></imageobject>
</inlinemediaobject
> <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>
<inlinemediaobject
><imageobject>
<imagedata fileref="hi22-action-rocsadddata.png" format="PNG"/></imageobject>
</inlinemediaobject
> <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>
<inlinemediaobject
><imageobject>
<imagedata fileref="hi22-action-rocsaddedge.png" format="PNG"/></imageobject>
</inlinemediaobject
> <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>
<inlinemediaobject
><imageobject>
<imagedata fileref="hi22-action-rocsdeletedata.png" format="PNG"/></imageobject>
</inlinemediaobject
> <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>
<inlinemediaobject
><imageobject>
<imagedata fileref="hi22-action-rocszoom.png" format="PNG"/></imageobject>
</inlinemediaobject
> <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>
</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>
</sect2>
</sect1>

<sect1 id="user-interface-documents">
<title
>Arbeta med grafdokument</title>
<para
>Ett projekt i &rocs; innehåller ett eller flera grafdokument som kan redigeras med den visuella grafeditorn. Dessutom kan varje dokument innehålla ett godtyckligt antal datastrukturer. Här använder datastrukturer i ett dokument alla samma datastrukturgränssnitt. Det här avsnittet förklarar hur man byter mellan dokument och hur man skapar nya. </para>

<sect2 id="user-interface-documents-selector">
<title
>Dokumentväljarraden</title>
<para
>Dokumentväljarraden används för att välja det aktuella grafdokumentet och dessutom den aktuella datastrukturen. Att använda det visuella grafeditorverktyget för att skapa datastrukturelement lägger automatiskt till de nyskapade elementen i den aktuella datastrukturen. Dessutom ger raden direktåtkomst för att ta bort befintliga eller skapa nya datastrukturer inne i det aktuella dokumentet. </para>

<itemizedlist>
<listitem
><para>
<inlinemediaobject
><imageobject>
<imagedata fileref="hi22-action-rocsnew.png" format="PNG"/></imageobject>
</inlinemediaobject
> <guilabel
>Ny</guilabel
>: Åtgärden skapar en ny datastruktur med användning av ett automatiskt namngivningsmönster given av datastrukturens gränssnitt. Den skapade datastrukturen läggs till i grafdokumentet som för närvarande är valt. </para
></listitem>
<listitem
><para>
<inlinemediaobject
><imageobject>
<imagedata fileref="hi22-action-rocsdelete.png" format="PNG"/></imageobject>
</inlinemediaobject
> <guilabel
>Ta bort</guilabel
>: Åtgärden tar bort datastrukturen som för närvarande är markerad i datastrukturväljaren för det aktuella dokumentet. </para
></listitem>
<listitem
><para>
<inlinemediaobject
><imageobject>
<imagedata fileref="hi22-action-rocsproperties.png" format="PNG"/></imageobject>
</inlinemediaobject
> <guilabel
>Datastrukturegenskaper</guilabel
>: Öppna en dialogruta som ger tillgång till datastrukturens egenskaper. </para
></listitem>
<listitem
><para>
<inlinemediaobject
><imageobject>
<imagedata fileref="hi22-action-rocsproperties.png" format="PNG"/></imageobject>
</inlinemediaobject
> <guilabel
>Dokumentegenskaper</guilabel
>: Öppna en dialogruta som ger tillgång till dokumentegenskaperna samt data- och piltyperna i dokumentet. </para
></listitem>
</itemizedlist>

<screenshot>
<screeninfo
>Huvudverktygsraden.</screeninfo>
<mediaobject>
<imageobject>
<imagedata fileref="document-selector.png" format="PNG"/>
</imageobject>
<textobject>
<phrase
>Dokumentväljarraden</phrase>
</textobject>
</mediaobject>
</screenshot>
</sect2>

<sect2 id="user-interface-documents-menu">
<title
>Skapa och Importera grafdokument</title>
<para
>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 (för mer om detta, se <xref linkend="import-export"/>). </para>
</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 datastrukturgränssnittet, utökas datastrukturens funktionalitet av motsvarande gränssnitt, och du måste ta en titt på den specialiserade funktionaliteten. I synnerhet, använder datastrukturgränssnitt 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 gränssnitt tillhandahåller en särskild uppsättning funktioner och egenskaper för sina datastrukturer och deras element. Men varje gränssnitt 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 datastrukturgränssnitt. </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
    int id        // unik identifierare för dataelement
    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 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 och värde
    string value();
    node start();                       // startnod för pilen
    node end();                         // målnod för pilen
    void remove();                      // ta bort denna pil
</programlisting>
</sect2>
</sect1>

<sect1 id="scripting-backend-graph">
<title
>Gränssnittet för grafer</title>
<sect2>
<title
>Grafegenskaper och funktioner</title>



<sect3>
<title
>Specifika egenskaper i gränssnittet för grafer</title>
<para
>Dialogrutan för datastrukturegenskaper gör det möjligt att anpassa inställningar som är specifika för grafgränssnittet. Där kan du använda <guilabel
>Graftyp</guilabel
> för att välja grafens typ. Betydelsen av typerna är följande: </para>
<itemizedlist>
    <listitem
><para
><guilabel
>Graf</guilabel
>: Graf där samma bågar (med avseende på start- och slutpunkt) inte får finnas flera gånger. </para
></listitem>
    <listitem
><para
><guilabel
>Multigraf</guilabel
>: Graf där likadana bågar (med avseende på start- och slutpunkt) kan finnas flera gånger. </para
></listitem>
</itemizedlist>
</sect3>

<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_nodes(int type);           // lista över alla noder av angiven typ
    array list_edges();                   // lista över alla bågar i grafen
    array list_edges(int type);           // lista över alla bågar av angiven typ
    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 piltyp i 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
>Grafgränssnittet 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-backend-linkedlist">
<title
>Gränssnittet 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-backend-rootedtree">
<title
>Gränssnittet för rotade träd</title>
<sect2>
<title
>Egenskaper och funktioner för Rotat träd</title>

<sect3>
<title
>Gränssnittet för rotade träd</title>
<para
>Dialogrutan för datastrukturegenskaper gör det möjligt att anpassa inställningar som är specifika för trädgränssnittet. Där kan markera egenskapen <guilabel
>Visa alla pilar</guilabel
> för att visa alla pilar mellan trädets noder. Om den inte markeras, kombineras flera pilar mellan samma noder till en. </para>
</sect3>

<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 och export 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
>Filer med Trivial Graph-format</para
></listitem>
    </itemizedlist>

<sect2 id="format-specification-tgf">
<title
>Trivial Graph-filformat</title>
<para
><emphasis
>Trivial Graph-formatet</emphasis
> (TGF) är ett enkelt textbaserat filformat för att beskriva grafer. En TGF-fil består av en lista med noddefinitioner, som avbildar nod-identifierare på etiketter, följt av en lista med bågarna. Det är bara möjligt att ha en etikett per nod och ett värde per båge i detta format. &rocs; tolkar importerade grafer som oriktade grafer. Exporterade grafer innehåller två bågar per anslutning om anslutningarna är bidirektionella. </para>

<sect3>
<title
>Formatspecifikation</title>
    <itemizedlist>
        <listitem
><para
>Filen börjar med en lista med noder (en nod per rad), följt av en rad med det enda tecknet "#", följt av en lista med bågar (en båge per rad).</para
></listitem>
        <listitem
><para
>En nod består av ett heltal (identifierare), följt av ett mellanslag, följt av en godtycklig sträng.</para
></listitem>
        <listitem
><para
>En båge består av två heltal (identifierare) åtskilda med ett mellanslag, följda av ett mellanslag, följt av en godtycklig sträng. Det antas att den riktade bågen pekar från den första identifieraren till den andra.</para
></listitem>
    </itemizedlist>
</sect3>
<sect3>
<title
>Exempel</title>
<programlisting
>1 startnod
2 sändare
3 mottagare
#
1 2 blå
2 1 röd
2 3 grön
</programlisting>
</sect3>
</sect2>

<sect2 id="format-specification-dot">
<title
>DOT-språket, Graphviz graffilformat</title>
<para
>DOT-språket är ett grafbeskrivningsspråk med vanlig text som både tillåter en bra mänskligt läsbar representation av grafer samt en effektiv behandling av graflayoutprogram. DOT är standardfilformat för Graphviz grafvisualiseringssvit, men används också av många andra grafverktyg. De vanliga filändelserna för DOT är <emphasis
>.gv</emphasis
> och <emphasis
>.dot</emphasis
>. </para>

<sect3>
<title
>Funktioner som inte stöds</title>
<para
>&rocs; kan tolka alla graffiler som innehåller en graf angiven enligt språkdefinitionen för DOT<footnote
><para
>http://www.graphviz.org/content/dot-language</para
></footnote
>. Stödet för språkets funktioner är fullständigt, trots följande undantag: </para>
    <itemizedlist>
        <listitem
><para
>delgraf: På grund av avsaknaden av ett delgrafskoncept i &rocs;, importeras bara delgrafer som en uppsättning dataelement och anslutningar. I synnerhet importeras inte anslutningar till eller från delgrafer.</para
></listitem>
        <listitem
><para
>&HTML;- och &XML;-attribut: Attribut (som beteckningar) som innehåller &HTML;- eller &XML;-syntax läses oförändrade. I synnerhet läses inte justeringar av teckensnitt och stilar från sådana attribut.</para
></listitem>
    </itemizedlist>
</sect3>
<sect3>
<title
>Exempel</title>
<programlisting
>digraph min_graf {
    a -> b -> c;
    b -> d;
}
</programlisting>
</sect3>
</sect2>

</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:
-->
