<?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 % Dutch "INCLUDE">
]>
<book id="rocs" lang="&language;">

<bookinfo>
<title
>Het handboek van &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>

&Freek.de.Kruijf;&Jaap.Woldringh; 
</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.7.80 &kde; 4.10</releaseinfo>

<legalnotice
>&FDLNotice;</legalnotice>

<abstract>
<para
>&rocs; is een hulpmiddel van KDE voor de grafentheorie. </para>
</abstract>

<keywordset>
<keyword
>KDE</keyword>
<keyword
>kdeedu</keyword>
<keyword
>wiskunde</keyword>
<keyword
>wiskunde</keyword>
<keyword
>grafen</keyword>
<keyword
>knoop</keyword>
<keyword
>kant</keyword>
</keywordset>

</bookinfo>

<chapter id="introduction">
<title
>Inleiding</title>
<para
>In dit hoofdstuk vindt u een overzicht van de kerneigenschappen en manier van werken met &rocs;. Als u direct wilt beginnen met werken met &rocs; raden we u aan <xref linkend="introduction-nutshell"/> te lezen en <xref linkend="scripting"/> te gebruiken als referentie bij het schrijven van algoritmes. </para>

<sect1 id="introduction-goals">
<title
>Doelen, voor wie is dit bestemd en manier van werken.</title>
<para
>&rocs; is een IDE (werkomgeving) voor de grafentheorie, te gebruiken door iedereen die algoritmes in de grafentheorie wil ontwerpen en analyseren. Dit houdt expliciet in</para>
<itemizedlist>
    <listitem
><para
>docenten die algoritmes aan hun studenten willen demonstreren,</para
></listitem>
    <listitem
><para
>studenten die willen begrijpen en zien hoe een algoritme werkt,</para
></listitem>
    <listitem
><para
>en verder iedereen die belang stelt in gegevensstructuren en algoritmes.</para
></listitem>
</itemizedlist>

<para
>Iedereen kan &rocs; goed gebruiken voor het aanmaken van gegevensstructuren, als een krachtig hulpmiddel voor het maken van scripts voor het uitvoeren van algoritmes, en als hulpmiddel voor het uitvoeren van simulaties en experimenten. </para>

<para
>De eerste stap in &rocs; is gewoonlijk een graaf aanmaken in het visuele bewerkingsprogramma voor grafen. U kunt dit met de hand doen, dat wil zeggen gegevenselementen toevoegen en die met elkaar verbinden, of met behulp van een van de hulpalgoritmes (indien aanwezig voor de huidige plugin voor gegevensstructuren), die u vindt in <menuchoice
><guimenu
>Graafdocument</guimenu
> <guimenuitem
>Hulpmiddelen</guimenuitem
> <guimenuitem
>Graaf aanmaken</guimenuitem
></menuchoice
>. U kunt verder waarden toekennen aan de elementen van de gegevensstructuren, met de hand, of met <menuchoice
><guimenu
>Graafdocument</guimenu
> <guimenuitem
>Hulpmiddelen</guimenuitem
> <guimenuitem
>Waarden toekennen</guimenuitem
></menuchoice
>. Tenslotte kunt u een algoritme schrijven in JavaScript en die met de zojuist aangemaakte gegevensstructuur laten uitvoeren (werken). De door uw algoritme aangebrachte veranderingen zijn dan direct zichtbaar in het visuele bewerkingsprogramma. </para>

<screenshot>
<screeninfo
>Schermbeeld van &rocs;.</screeninfo>
<mediaobject>
<imageobject>
<imagedata fileref="rocs-screenshot.png" format="PNG"/>
</imageobject>
<textobject>
<phrase
>Schermbeeld van &rocs;.</phrase>
</textobject>
</mediaobject>
</screenshot>
</sect1>

<sect1 id="introduction-nutshell">
<title
>&rocs; in een notendop</title>
<para
>In dit deel geven we een kort overzicht van de kernelementen van &rocs;. We leggen de belangrijke begrippen uit van gegevensstructuren, de bijbehorende  backends,en  typen van elementen. Kennis hiervan is nodig om te kunnen begrijpen hoe in &rocs; gegevensstructuren kunnen worden aangemaakt en gewijzigd. </para>
<para
>In het algemeen werkt men in &rocs; met projecten: wanneer &rocs; wordt gestart, wordt een leeg project aangemaakt, dat u kunt vervangen door het inlezen of importeren van een ander project. Hierbij bestaat een project zelf uit <emphasis
>graafdocumenten</emphasis
> en <emphasis
>scripts</emphasis
>. </para>

<sect2>
<title
>Backends voor graafdocumenten en gegevensstructuren</title>
<para
>Een graafdocument bevat de inhoud van een whiteboard, in het visuele  bewerkingsprogramma voor de graaf.  Hierin kan een graafdocument diverse gegevensstructuren tegelijk bevatten, maar slechts één bijbehorende backend. Er zijn backends aanwezig voor voor diverse graaftypen (algemene grafen, gekoppelde lijsten (linked lists), boomstructuren (rooted trees)), die toegevoegde functionaliteit bieden voor hun specifieke graaftypen. Dat kan het automatisch positioneren zijn van de elementen, speciale verzamelingen van pictogrammen (iconsets), of een uitgebreide verzameling van scriptfuncties, die in algoritmes kunnen worden gebruikt. (details vindt u elders in dit handboek). In een graafdocument kunt u een andere backend kiezen voor een gegevensstructuur, maar er kan hierdoor wel informatie verloren gaan (bv. kanten van een cirkel in een algemene graaf worden niet aan een boomstructuur toegevoegd, als u overschakelt naar de backend voor een boomstructuur). </para>
<para
>Graafdocumenten vormen ook de basis voor de definitie van pijltypen en gegevenstypen. </para>
</sect2>

<sect2>
<title
>Gegevensstructuren </title>
<para
>Gegevensstructuren vormen de basis van het werken in &rocs;. U kunt er een of meer aan een graafgdocument toevoegen, gegevenselementen toevoegen (knopen, data) en pijlen, en die wijzigen in scripts. Daarom moet elke gegevensstructuur een unieke naam hebben, waarmee die in de scripts kan worden genoemd. Als gevolg van de huidig gekozen backend voor de gegevensstructuren, kan het zijn dat u de gegevensstructuren niet willekeurig kunt wijzigen (bv. een boomstructuur mag nooit een cyclische structuur bevatten). De backend voor gegevensstructuren moet passen bij de gegevensstructuur in het graafdocument. </para>
</sect2>

<sect2>
<title
>Pijltypen</title>
<para
>Met pijltypen kunt u verschillende typen van pijlen definiëren, die in de gegevensstructuren kunnen worden gebruikt. Dit betekent dat een pijltype afzonderlijk kan worden opgemaakt (vooral de kleur), en dat het eenvoudig is in uw scripts alleen pijlen te gebruiken van een bepaald type. Een typisch voorbeeld van het gebruik van pijlen is bij de implementatie van meta-kanten in gegevensstructuren die relaties visualiseren tussen gegevenselementen (bv. communicatie). Maar ook kunnen pijltypen worden gebruikt om op een elegante manier bepaalde soorten kanten te beschrijven (bijvoorbeeld in het algoritme voor het zoeken volgens de methode met de naam "depth first search").  </para>
</sect2>

<sect2>
<title
>Gegevenstypen</title>
<para
>In sommige problemen met gegevensstructuren moet een verzameling van gegevenselementen in groepen met een verschillend type worden verdeeld (bv. bij "clustering" problemen en "covering" problemen). Of is het nuttig om in een algoritme een gegevenselement op te geven voor een bepaald type (bv. bij "breath first search"). Elk gegevenstype heeft zijn eigen pictogram en in uw scripts kunt u de gegevenstypen van een bepaald type eenvoudig gebruiken. </para>
</sect2>

<sect2>
<title
>Dynamische eigenschappen</title>
<para
>Elk gegevenselement en elke pijl kan vele eigenschappen hebben. Sommige hiervan zijn standaard vanuit de backend voor de gegevensstructuur. Zie voor meer hierover de documentatie van deze backend. U kunt eigenschappen toevoegen middels <emphasis
>dynamische eigenschappen</emphasis
>. Iedere dynamische eigenschap heeft een naam en kan elke waarde krijgen. De naam moet met een letter (a-z of A-Z) beginnen, en kan alleen letters, cijfers en '_' bevatten. Indien u een ongeldig teken gebruikt voor de naam van de eigenschap, wordt de eigenschap niet gewijzigd. </para>
<para
>U kunt  dynamische eigenschappen toevoegen in de dialogen  <guilabel
>Eigenschappen gegevens</guilabel
> en <guilabel
>Eigenschappen pijlen</guilabel
> in de erbij behorende contextmenu's  of met de scriptfuncties, zoals wordt uitgelegd in <xref linkend="scripting-data-structure"/>. </para>
<para
>U kunt ook de scripts gebruiken. U hoeft hiervoor alleen <literal
>eigenschap_toevogen</literal
> te gebruiken, met de naam en waarde van de nieuwe eigenschap. Daarna kunt u de waarden ophalen of instellen met knoop/pijl.NaamEigenschap </para>
<para
>Hier volgt een voorbeeld van het gebruik van dynamische eigenschappen met de backend voor grafen. <programlisting
>nodes = mijnGraaf.list_nodes()
for (var i = 0; i &lt; nodes.lengte; ++i ){
    nodes[i].add_property("mijnEigenschap", 0)
}
nodes[0].mijnEigenschap = 2
nodes[1].mijnEigenschap = nodes[0].mijnEigenschap + 2
    </programlisting>
</para>
</sect2>
</sect1>

<sect1 id="introduction-tutorial">
<title
>Instructie</title>
<para
>In dit gedeelte maken we een voorbeeldproject aan, waarin enkele van de meest belangrijke eigenschappen van &rocs; worden gebruikt. Het doel is een graaf en een script te maken voor een eenvoudig 2-benaderingsalgoritme voor het <emphasis
>"minimum vertex cover"</emphasis
>- probleem. Dit houdt in het zoeken naar de kleinste deelverzameling C van de knopen van de graaf, zodat elke kant van de graaf met tenminste een knoop van C is verbonden. Het is bekend dat dit probleem "NP-hard" is, en we willen laten zien hoe we een benadering met een factor 2 kunnen vinden door een overeenkomst in de bestaande graaf te zoeken (in het volgende gebruiken we de gebruikelijke termen in graafalgoritmes: graaf is de gegevensstructuur, knopen zijn de gegevenselementen, kanten zijn de pijlen). (Noot vertaler: ik handhaaf vele Engelse benamingen, ten eerste om de gebruiker van deze tekst in de gelegenheid te stellen om naar deze namen te googlen, en ten tweede omdat ik van de meeste niet de Nederlandse naam (als die er is) ken, of kan vinden). </para>
<para
>Ons doel is de overeenkomst zichtbaar te maken tussen de overeenkomende en de "minimum match cover". Hiervoor moeten we twee pijltypen specificeren, een voor het tonen van de overeenkomende kanten, en een voor de gewone kanten. En verder twee gegevenstypen, die gebruikt worden voor het onderscheid tussen knopen in C en knopen die niet tot C behoren. </para>

<sect2>
<title
>Een graaf genereren</title>
<para
>Voor de graaf-backend is in &rocs; een hulpmiddel aanwezig waarmee grafen kunnen worden aangemaakt. We gaan naar het menu <menuchoice
><guimenu
>Graafdocument</guimenu
> <guisubmenu
>Hulpmiddelen</guisubmenu
> <guimenuitem
>Graaf aanmaken</guimenuitem
></menuchoice
>. Hier genereren we een "Willekeurige graaf", met 30 knopen, 90 kanten en met het zaadje 1 (het zaadje is de startwaarde voor het genereren van willekeurige getallen; meerdere keren dit zelfde zaadje gebruiken resulteert in dezelfde, en dus reproduceerbare grafen). Tenslotte veranderen we de naam van de graaf in het paneel voor de gegevensstructuur in <literal
>testgraaf</literal
>. </para>
</sect2>

<sect2>
<title
>Typen genereren</title>
<para
>We gebruiken de knop <guibutton
>Documenteigenschappen</guibutton
> in het paneel voor de gegevensstructuur, voor het openen van de dialoog voor gegevens- en pijltypen, van het huidige graafdocument. We voegen een nieuw gegevenstype toe met de naam "C", dat automatisch ID (identificatienummer) <literal
>1</literal
> krijgt. Voor dit type selecteren we het pictogram voor de server. Verder gaan we naar de pagina voor de pijltypen, en selecteren een nieuw pijltype dat we "overeenkomend" gaan noemen. Dit krijgt automatisch de naam <literal
>1</literal
>, en we stellen de kleur in op blauw. </para>
</sect2>

<sect2>
<title
>Het algoritme</title>
<para
>Tenslotte moeten we het benaderingsalgoritme implementeren. Hiervoor gebruiken we het volgende:  </para>
<programlisting
>var E = testgraph.list_edges(); // niet verwerkte kanten
var C = new Array();            // overeenkomende kanten
while (E.length 
> 0) {
    var e = E[0];        // we nemen eerste kant e={u,v}
    var u = e.start();
    var v = e.end();
    e.set_type(1);        // maak kant overeenkomend
    E.shift();            // verwijder e (bv. E[0]) uit kantenlijst
    C.push(u);            // voeg u toe aan C
    C.push(v);            // voeg v toe aan C

    // merk u,v als knopen in C
    u.set_type(1);
    v.set_type(1);

    // verwijder uit E alle kanten die in u of v eindigen
    var adjacent = u.adj_edges();
    for (var i=0; i &lt; adjacent.length; i++) {
        var index = E.indexOf(adjacent[i]); // zoek de index
        if (index!=-1) {
            E.splice(index, 1); // verwijder indien gevonden
        }
    }
    var adjacent = v.adj_edges();
    for (var i=0; i &lt; adjacent.length; i++) {
        var index = E.indexOf(adjacent[i]); // zoek de index
        if (index!=-1) {
            E.splice(index, 1); // verwijder indien gevonden
        }
    }
}
output("Vertex Cover bevat " + C.length + " knopen.");
</programlisting>
</sect2>

<sect2>
<title
>Het algoritme uitvoeren</title>
<para
>Tenslotte willen we het algoritme uitvoeren (draaien, laten werken, executeren). Die kunnen we starten met de knop <guibutton
>Uitvoeren</guibutton
> in het controlepaneel voor scripts. </para>
</sect2>
</sect1>
</chapter>

<chapter id="user-interface">
<title
>De gebruikersinterface van &rocs;</title>

<sect1 id="user-interface-all">
<title
>Algemene elementen van de gebruikersinterface</title>
<para
>De gebruikersinterface is verdeeld in een aantal logische gedeelten, zoals getoond in onderstaand schermbeeld. </para>
<screenshot>
    <screeninfo
>GUI-elementen van de interface van &rocs;.</screeninfo>
    <mediaobject>
    <imageobject>
    <imagedata fileref="rocs-interfaces.png" format="PNG"/>
    </imageobject>
    <textobject>
    <phrase
>GUI-elementen van de interface van &rocs;.</phrase>
    </textobject>
    </mediaobject>
</screenshot>
<variablelist>
<varlistentry>
    <term
>Documenten selecteren</term>
    <listitem
><para
>In deze bovenste menubalk moet u het huidige document en de gegevensstructuur selecteren. U kunt hierin ook gegevensstructuren aanmaken en wissen, en ook toegang krijgen tot de eigenschappen van gegevensstructuren. </para
></listitem>
</varlistentry>
<varlistentry>
    <term
>Visuele graafbewerker</term>
    <listitem
><para
>Dit is het zogenaamde "whiteboard", waarin u gegevensstructuren kunt aanmaken en wijzigen. Rechtsklikken in het whiteboard, op gegevenselementen, of op pijlen, opent contextmenu's. U kunt met de hulpmiddelen in de <emphasis
>Werkbalk visuele graafbewerker</emphasis
> de elementen wijzigen in het visuele bewerkingsprogramma van het whiteboard.</para
></listitem>
</varlistentry>
<varlistentry>
    <term
>Werkbalk voor de Werkbalk visuele graafbewerker</term>
    <listitem
><para
>In deze werkbalk zijn de hulpmiddelen beschikbaar voor het visuele bewerkingsprogramma. Met <guibutton
>Gegevens toevoegen</guibutton
> of <guibutton
>Verbinding toevoegen</guibutton
> kunnen nieuwe gegevenselementen of nieuwe pijlen worden toegevoegd. Nieuwe gegevenselementen worden toegevoegd aan de gegevensstructuur die thans is geselecteerd in de <emphasis
>Documentkiezer</emphasis
>. Merk op dat bij zowel <guibutton
>Gegevens toevoegen</guibutton
> als <guibutton
>Verbinding toevoegen</guibutton
> contextmenu's behoren waarin het type kan worden geselecteerd van de  aan te maken gegevens of pijlen. Voor de details, zie <xref linkend="user-interface-toolbars"/>. </para
></listitem>
</varlistentry>
<varlistentry>
    <term
>Zijbalk </term>
    <listitem
><para
>Rechts vindt u de zijbalk waarin u diverse hulpmiddelen vindt om mee te werken: <itemizedlist>
        <listitem
><para
>Elementtypen: Hiermee heeft u direct toegang tot de beschikbare pijl- en gegevenstypen.</para
></listitem>
        <listitem
><para
>Journaal: Bij elk project hoort een eigen journaal waarin &eg; taken, resultaten of waarnemingen kunnen worden genoteerd.</para
></listitem>
        <listitem
><para
>Documentatie: Hiermee kunt u direct toegang krijgen tot het handboek, en zo tot de documentatie over scripts.</para
></listitem>
        </itemizedlist>
    </para
></listitem>
</varlistentry>
<varlistentry>
    <term
>Bewerken van scripts</term>
    <listitem
><para
>In deze tekstverwerker kunt u algoritmes schrijven, zoals in detail is uitgelegd in <xref linkend="scripting"/>. U kunt aan verschillende scriptdocumenten tegelijk werken, in verschillende tabbladen. Indien wijzigingen in een script nog niet zijn opgeslagen verschijnt er een klein schijfsymbooltje in het tabblad. </para
></listitem>
</varlistentry>
<varlistentry>
    <term
>Script-uitvoer</term>
    <listitem
><para
>In dit tekstgebied staat informatie over het herstellen van fouten (debug), of de script-uitvoer van uw algoritme, afhankelijk van de selectie van de ingestelde uitvoer, bovenin. Als het script een fout meldt, wordt automatisch de debug-uitvoer geselecteerd. </para
></listitem>
</varlistentry>
<varlistentry>
    <term
>Besturing</term>
    <listitem
><para
>Hierin kunt u het uitvoeren van scripts regelen. U kunt het script uitvoeren (draaien, laten wereken) dat op dit moment in de scriptbewerker is geopend, door op <guiicon
>Uitvoeren</guiicon
> te klikken. Een script kan tijdens het uitvoeren worden gestopt door op de knop <guiicon
>Stop</guiicon
> te klikken. Merk op dat het uitvoeren met de optie  <guibutton
>Enkele stap</guibutton
> alleen bij specifieke kenwoorden stopt.(zie <xref linkend="scripting"/>). </para
></listitem>
</varlistentry>
</variablelist>
</sect1>

<sect1 id="user-interface-toolbars">
<title
>Werkbalken</title>
<para
>Er zijn een aantal verschillende werkbalken beschikbaar voor het visuele bewerkingsprogramma voor grafen, waarin u met één klik over bepaalde bewerkingen kunt beschikken. Standaard worden de volgende werkbalken getoond:</para>
<itemizedlist>
    <listitem
><para
>Hoofdwerkbalk</para
></listitem>
    <listitem
><para
>Opmaakwerkbalk</para
></listitem>
</itemizedlist>
<!--  -->
<sect2 id="user-interface-toolbars-main">
<title
>Hoofdwerkbalk</title>
<para
>In de <emphasis
>Hoofdwerkbalk</emphasis
> vindt u de volgende acties. Hierop klikken maakt dat uw muisaanwijzer deze actie toepast op het whiteboard van het visuele bewerkingsprogramma voor grafen:</para>
<itemizedlist>
<listitem
><para>
<inlinemediaobject
><imageobject>
<imagedata fileref="hi22-action-rocsselectmove.png" format="PNG"/></imageobject>
</inlinemediaobject
> <guilabel
>Verplaatsen</guilabel
>: U kunt elementen selecteren door in het whiteboard op een lege plek te klikken, of door de muisknop ingedrukt te houden en een rechthoek te "trekken" om enige gegevenselementen en/of pijlen heen om deze elementen te selecteren, of door direct op een niet geselecteerd element te klikken om dit te selecteren. Indien u op een geselecteerd element klikt, of op een verzameling van geselecteerde elementen, kunt u die verplaatsen met de muis, met ingedrukte muisknop. Geselecteerde elementen kunnen ook met de pijltjestoetsen worden verplaatst.</para
></listitem>
<listitem
><para>
<inlinemediaobject
><imageobject>
<imagedata fileref="hi22-action-rocsadddata.png" format="PNG"/></imageobject>
</inlinemediaobject
> <guilabel
>Gegeven toevoegen</guilabel
>: Klik op een willekeurige plaats in het whiteboard van het visuele bewerkingsprogramma, om zo een nieuw gegevenselement aan te maken voor de huidig geselecteerde gegevensstructuur. Door de muisaanwijzer op de knop ingedrukt te houden, komt er een contextmenu, waarin het type kan worden gekozen van de nieuw aangemaakte gegevenselementen (alleen wanneer daarvoor meerdere typen bestaan).</para
></listitem>
<listitem
><para>
<inlinemediaobject
><imageobject>
<imagedata fileref="hi22-action-rocsaddedge.png" format="PNG"/></imageobject>
</inlinemediaobject
> <guilabel
>Verbinding toevoegen</guilabel
>: Klik op een gegevenselement, houdt de muisknop ingedrukt, en trek een lijn naar een ander gegevenselement waarnaar de pijl/kant zal wijzen. Dit zal alleen lukken als het in de huidige graaf is toegestaan deze kant toe te voegen (&eg;, in een ongerichte graaf kunt u niet meerdere kanten toevoegen tussen gegevenselementen). Door de muisaanwijzer op de knop ingedrukt te houden, komt er een contextmenu, waarin het type kan worden gekozen van de nieuw aangemaakte pijlen (alleen wanneer daarvoor meerdere typen bestaan).</para
></listitem>
<listitem
><para>
<inlinemediaobject
><imageobject>
<imagedata fileref="hi22-action-rocsdeletedata.png" format="PNG"/></imageobject>
</inlinemediaobject
> <guilabel
>Verwijderen</guilabel
>: Klik op het element om het te verwijderen. Bij het verwijderen van een knoop worden meteen alle ermee verbonden kanten verwijderd.</para
></listitem>
<listitem
><para>
<inlinemediaobject
><imageobject>
<imagedata fileref="hi22-action-rocszoom.png" format="PNG"/></imageobject>
</inlinemediaobject
> <guilabel
>Zoom</guilabel
>: Klik op het whiteboard, houdt de &LMB; ingedrukt, en "trek" op deze manier een rechthoek. Er wordt dan op deze rechthoek ingezoomd. U kunt ook met het muiswiel in- en uitzoomen. Door met de &LMB; te dubbelklikken wordt de originele zoom hersteld.</para
></listitem>
</itemizedlist>
</sect2>

<sect2 id="user-interface-toolbars-alignment">
<title
>Opmaakwerkbalk</title>
<para
>U kunt de optionele <emphasis
>Opmaakwerkbalk</emphasis
> toevoegen. Op een actie hierin klikken heeft direct effect op de huidig geselecteerde knopen:</para>
<itemizedlist>
<listitem
><para>
<inlinemediaobject
><imageobject>
<imagedata fileref="hi22-action-rocsaligntop.png" format="PNG"/></imageobject>
</inlinemediaobject
> <guilabel
>Boven</guilabel
>: Alle gegevenselementen verticaal uitlijnen op de positie van het bovenste gegevenselement. Dit betreft alleen de verticale posities.</para
></listitem>
<listitem
><para>
<inlinemediaobject
><imageobject>
<imagedata fileref="hi22-action-rocsalignvmiddle.png" format="PNG"/></imageobject>
</inlinemediaobject
> <guilabel
>Midden</guilabel
>: De gegevenselementen uitlijnen op de verticale positie van het middelste van de geselecteerde gegevenselementen. Dit betreft alleen de verticale posities.</para
></listitem>
<listitem
><para>
<inlinemediaobject
><imageobject>
<imagedata fileref="hi22-action-rocsalignbottom.png" format="PNG"/></imageobject>
</inlinemediaobject
> <guilabel
>Onder</guilabel
>: Alle gegevenselementen verticaal uitlijnen op de positie van de onderste gegevenselement. Dit betreft alleen de verticale posities.</para
></listitem>
<listitem
><para>
<inlinemediaobject
><imageobject>
<imagedata fileref="hi22-action-rocsalignleft.png" format="PNG"/></imageobject>
</inlinemediaobject
> <guilabel
>Midden</guilabel
>: Alle gegevenselementen uitlijnen op de horizontale positie van het meest rechtse gegevenselement. Dit betreft alleen de horizontale posities.</para
></listitem>
<listitem
><para>
<inlinemediaobject
><imageobject>
<imagedata fileref="hi22-action-rocsalignhmiddle.png" format="PNG"/></imageobject>
</inlinemediaobject
> <guilabel
>Midden</guilabel
>: Alle gegevenselementen uitlijnen op de horizontale positie van het meest rechtse gegevenselement. Dit betreft alleen de horizontale posities.</para
></listitem>
<listitem
><para>
<inlinemediaobject
><imageobject>
<imagedata fileref="hi22-action-rocsalignright.png" format="PNG"/></imageobject>
</inlinemediaobject
> <guilabel
>Rechts</guilabel
>: Alle gegevenselementen uitlijnen op de horizontale positie van het meest rechtse gegevenselement. Dit betreft alleen de horizontale posities.</para
></listitem>
<listitem
><para>
<inlinemediaobject
><imageobject>
<imagedata fileref="hi22-action-rocsaligncircle.png" format="PNG"/></imageobject>
</inlinemediaobject
> <guilabel
>Cirkel</guilabel
>: Lijnt de gegevenselementen uit op een cirkel, waarvan de diameter gelijk is aan de grootste afstand tussen de gegevenselementen. De gegevenselementen worden geplaatst in dezelfde volgorde, als waarin ze worden gezien vanuit het meetkundige zwaartepunt van de de gegevenselementen.</para
></listitem>
<listitem
><para>
<inlinemediaobject
><imageobject>
<imagedata fileref="hi22-action-rocsaligntree.png" format="PNG"/></imageobject>
</inlinemediaobject
> <guilabel
>Kruisende kanten minimaliseren</guilabel
>:  De geselecteerde gegevenselementen worden zo gerangschikt, dat het aantal elkaar kruisende verbindingen zo klein mogelijk is (met het algoritme van Fruchterman-Reingold).</para
></listitem>
</itemizedlist>
</sect2>
</sect1>

<sect1 id="user-interface-documents">
<title
>Werken met graafdocumenten</title>
<para
>Een project in &rocs; bevat een of meer graafdocumenten die in het visuele grafische bewerkingsprogramma kunnen worden bewerkt. Verder kan elk document een willekeurig aantal gegevensstructuren bevatten. Hierbij wordt voor alle gegevensstructuren in een document dezelfde backend voor gegevensstructuren gebruikt. In deze sectie wordt beschreven hoe u tussen documenten kunt schakelen, en hoe u nieuwe kunt aanmaken. </para>

<sect2 id="user-interface-documents-selector">
<title
>De werkbalk voor het selecteren van documenten</title>
<para
>In de werkbalk voor het selecteren van documenten selecteert u het huidige graafdocument en de huidige gegevensstructuur. Als u gegevenselementen in gegevensstructuren aanmaakt, met de hulpmiddelen in  het visuele grafische bewerkingsprogramma, dan worden deze nieuwe elementen automatisch aan de huidige gegevensstructuur toegevoegd. In deze balk kunt u ook in het huidige document bestaande gegevensstructuren wissen, of nieuwe aanmaken.  </para>

<itemizedlist>
<listitem
><para>
<inlinemediaobject
><imageobject>
<imagedata fileref="hi22-action-rocsnew.png" format="PNG"/></imageobject>
</inlinemediaobject
> <guilabel
>Nieuw</guilabel
>: Hiermee maakt u een nieuwe gegevensstructuur aan, met  een automatische naamgeving afkomstig van de backend voor de gegevensstructuur. De aangemaakte gegevensstructuur wordt toegevoegd aan het huidig geselecteerde graafdocument. </para
></listitem>
<listitem
><para>
<inlinemediaobject
><imageobject>
<imagedata fileref="hi22-action-rocsdelete.png" format="PNG"/></imageobject>
</inlinemediaobject
> <guilabel
>Wissen</guilabel
>: Hiermee wordt de huidig geselecteerde gegevensstructuur gewist in het huidige document. </para
></listitem>
<listitem
><para>
<inlinemediaobject
><imageobject>
<imagedata fileref="hi22-action-rocsproperties.png" format="PNG"/></imageobject>
</inlinemediaobject
> <guilabel
>Eigenschappen gegevensstructuur</guilabel
>: Openen van een dialoog voor de eigenschappen van gegevensstructuren. </para
></listitem>
<listitem
><para>
<inlinemediaobject
><imageobject>
<imagedata fileref="hi22-action-rocsproperties.png" format="PNG"/></imageobject>
</inlinemediaobject
> <guilabel
>Eigenschappen document</guilabel
>: Openen van een dialoog voor de eigenschappen van het document, alsmede die van de gegevenstypen en pijltypen in het document. </para
></listitem>
</itemizedlist>

<screenshot>
<screeninfo
>De hoofdwerkbalk.</screeninfo>
<mediaobject>
<imageobject>
<imagedata fileref="document-selector.png" format="PNG"/>
</imageobject>
<textobject>
<phrase
>Balk voor het selecteren van het document.</phrase>
</textobject>
</mediaobject>
</screenshot>
</sect2>

<sect2 id="user-interface-documents-menu">
<title
>Aanmaken en importeren van graafdocumenten</title>
<para
>U kunt een nieuw graafdocument aanmaken, of een bestaand document aan het project toevoegen met  <menuchoice
><guimenu
>Project</guimenu
> <guimenuitem
>Nieuw graafdocument</guimenuitem
></menuchoice
> of met <menuchoice
><guimenu
>Project</guimenu
> <guimenuitem
>&rocs;-graaf importeren</guimenuitem
></menuchoice
>. U kunt ook graafdocumenten van elders importeren (zie hiervoor <xref linkend="import-export"/>). </para>
</sect2>

</sect1>
</chapter>

<chapter id="scripting">
<title
>Het schrijven en uitvoeren (laten werken) van algoritmes in &rocs; </title>

<para
>In &rocs; wordt intern het programma QtScript (een soort JavaScript) gebruikt. Dit betekent dat alle door u geïmplementeerde scripts in JavaScript moeten worden geschreven. Hoe JavaScript werkt, en hoe u in JavaScript programmeert, wordt in dit handboek niet beschreven, maar we leggen wel uit hoe u met gegevensstructuren, gegevenselementen en pijlen moet werken. Omdat u nooit direct het basisobject gebruikt van de gegevensstructuren, maar een dat geleverd wordt door de backend voor de huidige gegevensstructuur, wordt de functionaliteit door deze backend uitgebreid, en zult u deze speciale functionaliteit moeten bestuderen. In het bijzonder worden in de backends passende termen op hun gebied gebruikt, zoals knopen en kanten in grafen, bladeren en wortels (leafs en roots) in boomstructuren, etc.  </para>
<para
>Het is goed te weten dat veranderingen als gevolg van scripts direct hun weerslag vinden in de eigenschappen in het "whiteboard" van het visuele bewerkingsprogramma. Dat betekent dat scripts de gegevensstructuren daadwerkelijk wijzigen. </para>

<sect1 id="scripting-data-structure">
<title
>De basiselementen van gegevensstructuren </title>
<para
>Iedere backend levert een eigen verzameling van functies en eigenschappen voor zijn gegevensstructuren met hun elementen. Maar elke backend levert ook de functies en eigenschappen die gedefinieerd zijn voor de basisstructuur. Dit betekent dat alles dat hier wordt uitgelegd, geldt voor elke backend voor gegevensstructuren. </para>
<sect2
><title
>Basiseigenschappen van gegevensstructuren</title>
<para
>Gegevensstructuren worden geïdentificeerd door hun namen. Aangenomen dat een gegevensstructuur is aangemaakt met de naam <literal
>testgraaf</literal
>, kunt u deze gegevensstructuur gebruiken door eenvoudig deze naam te noemen. Bijvoorbeeld, om een rij met alle gegevenselementen in de gegevensstructuur te verkrijgen, kunt u in het script schrijven: <literal
>testgraaf.list_nodes();</literal
> </para>

<sect3>
<title
>Basisigenschappen en functies van gegevensstructuren</title>
<para
>Elke gegevensstructuur <literal
>testgraaf</literal
> heeft de volgende eigenschappen die kunnen worden gelezen of geschreven met de <literal
>testgraaf.eigenschap</literal
>: </para>
<programlisting
>tekenreeks voor de naam  // naam van de gegevensstructuur
</programlisting>
</sect3>
</sect2>

<sect2>
<title
>Basiseigenschappen en functies van de gegevenselementen</title>
<para
>Elk gegevenselement heeft de volgende eigenschappen die kunnen worden gelezen en geschreven: </para>
<programlisting
>double x      // x-coördinaat huidige positie
    double y      // y-coördinaat of huidige positie
    double width  // grootte
    string value  // waarde
    int id         // unieke naam gegevenselementen
    string name   // naam
    string color  // kleur in HEXAdecimaal
</programlisting>
<para
>Verder kan elke dynamische eigenschap van een gegevenselement worden gebruikt met behulp van zijn naam. </para>

<para
>Bij elk gegevenselementobject horen de volgende methodes (functies): </para>
<programlisting
>int type();                         // type elk gegevenselement
    int set_type(int);                  // Instellen type van gegevenselement
    void add_property(string naam,      // dynamische eigenschap toevoegen aan gegevenselement met opgegeven naam en waarde
                      string waarde);
    array adj_data();                   // lijst van aangrenzende gegevens
    array adj_pointers();               // lijst van aangrenzende pijlen
    array input_pointers();             // lijst van invoerpijlen
    array output_pointers();            // lijst van uitvoerpijlen
    array loop_pointers();              // lijst van cyclische pijlen
    array connected_pointers(doel);   // lijst van pijlen naar 'doel'
    void self_remove();                 // Dit gegevenselement wissen 
</programlisting>
</sect2>

<sect2>
<title
>Basiseigenschappen en functies van de pijlen</title>
<para
>Elk pijl heeft de volgende eigenschappen die kunnen worden gelezen en geschreven: </para>
<programlisting
>string color  // kleur in HEXAdecimaal
    string value  // waarde
    string name   // naam
    double width  // dikte
    string style  // waarde: dot, dash, dash dot, solid

(vert.: dot: stip; dash: streep; solid: lijn)
</programlisting>
<para
>Verder kan elke dynamische eigenschap van een pijl worden gebruikt met behulp van zijn naam. </para>

<para
>Bij elk pijlobject horen de volgende methodes (functies): </para>
<programlisting
>int type();                         // pijltype van pijl
    int set_type(int);                  // stel pijltype in van de pijl
    void add_property(string naam,      // dynamische eigenschap toevoegen aan gegevenselement met opgegeven naam en waarde
                      string waarde);
    node start();                       // startknoop van de pijl
    node end();                         // eindknoop van de pijl
    void self_remove();                 // deze pijl wissen
</programlisting>
</sect2>
</sect1>

<sect1 id="scripting-backend-graph">
<title
>De graafbackend</title>
<sect2>
<title
>Eigenschappen en functies van grafen</title>



<sect3>
<title
>Eigenschappen van de graafbackend</title>
<para
>In de dialoog voor de eigenschappen van de gegevensstructuur kunt u instellingen doen die behoren tot de graafbackend. Hierin, met <guilabel
>Graaftype</guilabel
>, kunt u het type kiezen van de graaf. De betekenis van deze typen is als volgt: </para>
<itemizedlist>
    <listitem
><para
><guilabel
>Graaf</guilabel
>: Graaf waarin dezelfde kanten (met dezelfde begin- en eindpunten) niet meerdere keren kunnen voorkomen. </para
></listitem>
    <listitem
><para
><guilabel
>Multigraaf</guilabel
>: Graaf waarin dezelfde kanten (met dezelfde begin- en eindpunten) meerdere keren kunnen voorkomen. </para
></listitem>
</itemizedlist>
</sect3>

<sect3>
<title
>Gegevensstructuur van een graaf</title>
<para
>Gegeven een gegevensstructuurobject van het type "Graaf", kunt u de volgende functies gebruiken: </para>
<programlisting
>array list_nodes();                   // lijst van alle knopen van de graaf
    array list_nodes(int type);           // lijst van alle knopen van gegeven type
    array list_edges();                   // lijst van alle kanten van de graaf
    array list_edges(int type);           // lijst van alle kanten van gegeven type
    node add_node(naam);                  // voeg nieuwe knoop toe en geef die terug
    edge add_edge(node van, node tot);    // voeg nieuwe kant toe van 'van' naar 'tot' en geef die terug
    array overlay_edges(int laagID);   // lijst van alle kanten in een gegeven laag
    edge add_overlay_edge(node van,
                          node tot,
                          int laagID); // voeg kant toe van gegeven pijltype/ in opgegeven laag (overlay)
</programlisting>
</sect3>

<sect3>
<title
>Knopen van grafen</title>
<para
>Gegeven een gegevensstructuurobject van het type "Graaf", kunt u de volgende functies gebruiken voor de knopen van de graaf, naast de eigenschappen die worden geleverd door de gegevenselementen: </para>
<programlisting
>array adj_nodes();                    // lijst van alle aangrenzende knopen
    array adj_edges();                    // lijst van alle aangrenzende kanten
    array input_edges();                  // lijst van alle invoerkanten
    array output_edges();                 // lijst van alle uitvoerkanten
    array loop_edges();                   // lijst van alle kanten die met een lus met de knoop verbonden zijn
    array connected_edges(node doel);   // lijst van alle kanten die deze knoop als eindpunt hebben
</programlisting>
</sect3>

<sect3>
<title
>Graafkanten</title>
<para
>Gegeven de kanten van een gegevensstructuur van het type "Graaf", zijn alleen de eigenschappen beschikbaar van de basisgegevensstructuur. </para>
</sect3>
</sect2>

<sect2>
<title
>Algoritmes voor graafstructuren</title>
<para
>De backend voor grafen levert enige speciale functies, die in scripts kunnen worden gebruikt.</para>
<variablelist>
<varlistentry>
<term
>Berekening kortste weg</term>
<listitem>
    <para
>Berekent de kortste weg tussen twee knopen <emphasis
>start</emphasis
> en <emphasis
>eind</emphasis
>. Beide knopen moeten tot dezelfde graaf behoren. In deze berekening wordt rekening gehouden met het wel of niet gericht zijn van de graaf.</para>
    <funcsynopsis>
    <funcprototype
><funcdef
>array <function
>dijkstra_shortest_path</function
></funcdef
> <paramdef
>knoop <parameter
><replaceable
>start</replaceable
></parameter
></paramdef
> <paramdef
>knoop<parameter
><replaceable
>eind</replaceable
></parameter
></paramdef
> </funcprototype>
    </funcsynopsis>
</listitem>
</varlistentry>
<varlistentry>
<term
>Kortste afstanden tussen knopen</term>
<listitem>
    <para
>Berekent de kortste wegen tussen de knoop <emphasis
>start</emphasis
> en alle andere knopen van de graaf. In deze berekening wordt rekening gehouden met het wel of niet gericht zijn van de graaf.</para>
    <funcsynopsis>
    <funcprototype
><funcdef
>array <function
>afstanden</function
></funcdef
> <paramdef
>knoop <parameter
><replaceable
>start</replaceable
></parameter
></paramdef
> </funcprototype>
    </funcsynopsis>
</listitem>
</varlistentry>
</variablelist>
</sect2>
</sect1>

<sect1 id="scripting-backend-linkedlist">
<title
>De backend voor gekoppelde lijsten (Linked List)</title>
<sect2>
<title
>Eigenschappen en functies voor gekoppelde lijsten</title>

<sect3>
<title
>De structuur Gekoppelde lijst</title>
<para
>Gegeven een gegevensstructuurobject van het type "Gekoppelde lijst" (Linked List), kunt u de volgende functies gebruiken: </para>
<programlisting
>node begin();                           // geeft de beginknoop van de gekoppelde lijst
    setBegin(node begin):                   // instellen van de knoop begin als beginknoop van de lijst en lijst opnieuw ordenen
    createNode();                           // een nieuwe knoop aanmaken voor de lijst
</programlisting>
</sect3>

<sect3>
<title
>Knopen van gekoppelde lijst</title>
<para
>Gegeven een gegevensstructuurobject van het type "Gekoppelde lijst" (Linked List), kunt u de volgende functies gebruiken voor de knopen van de graaf, naast de eigenschappen die worden geleverd door de gegevenselementen: </para>
<programlisting
>node front();                           // geeft de vorige knoop in de lijst terug
</programlisting>
</sect3>

<sect3>
<title
>Kanten van gekoppelde lijst</title>
<para
>Gegeven de kanten van een gegevensstructuur van het type "Gekoppelde lijst" (Linked List), zijn alleen de eigenschappen beschikbaar van de basisgegevensstructuur. </para>
</sect3>
</sect2>
</sect1>

<sect1 id="scripting-backend-rootedtree">
<title
>De backend voor de boomstructuur</title>
<sect2>
<title
>Eigenschappen en functies voor de boomstructuur</title>

<sect3>
<title
>Backend voor boomstructuur</title>
<para
>In de dialoog voor de eigenschappen van de gegevensstructuur kunt u instellingen doen die behoren tot de graafbackend. Hierin, door <guilabel
>Alle pijlen tonen</guilabel
> te selecteren, worden alle pijlen getoond tussen de knooppunten in de boom. Indien niet geselecteerd, worden meerdere pijlen tussen twee zelfde knooppunten als één pijl getoond. </para>
</sect3>

<sect3>
<title
>De boomstructuur</title>
<para
>Gegeven een gegevensstructuurobject van het type "Boomstructuur" (Rooted Tree), kunnen de volgende eigenschappen worden gelezen of geschreven: </para>
<programlisting
>ShowAllPointers     // stel in op true (waar), voor het tonen van alle kanten, stel in op false (onwaar), als meerdere kanten als één moeten worden weergegeven.
</programlisting>
<para
>Gegeven een gegevensstructuurobject van het type "Boomstructuur" (Rooted Tree), kunt u de volgende functies gebruiken: </para>
<programlisting
>node add_data(string naam);         // voeg een knoop toe aan een boom met de gegeven naam
    void set_root_node(node root);      // stel root in als rootknoop (beginpunt) van de boom
    node root_node();                   // geef rootknoop (beginpunt) terug van de boom
</programlisting>
</sect3>

<sect3>
<title
>Knopen in boomstructuur als root (beginpunt) beschouwd </title>
<para
>Gegeven een knoopobject van het type "Boomstructuur" (Rooted Tree), kunnen de volgende eigenschappen worden gelezen of geschreven: </para>
<programlisting
>int numberOfChilds                  // stel aantal in van (mogelijke) onderliggende knopen
    node left_child                     // alleen lezen: onderliggende knoop links
    node right_child                    // alleen lezen: onderliggende knoop rechts
    node node_parent                    // alleen lezen: voortbrengende  (bovenliggende) knoop
</programlisting>
<para
>Gegeven knoopobject van het type "Boomstructuur" (Rooted Tree), kunt u de volgende functies gebruiken: </para>
<programlisting
>node add_left_child(node child);    // onderliggende knoop child  links toevoegen
    node add_right_child(node child);   // onderliggende knoop child rechts toevoegen
    node add_child(node child, int i);  // child als i-de onderliggende knoop toevoegen
    node add_node_parent(node child);   // aan knoop child een voortbrengende knoop toevoegen (kan alleen als die er nog niet is)
    node left_child();                  // onderliggende knoop links teruggeven
    node right_child();                 // onderliggende knoop rechts teruggeven
    node child_at(int i);               // de i-de onderliggende knoop teruggeven
    node node_parent();                 // de voortbrengende knoop teruggeven
</programlisting>
</sect3>

<sect3>
<title
>Kanten in boomstructuur</title>
<para
>Gegeven kanten van een gegevensstructuur van het type "Boomstructuur" (Rooted Tree), zijn alleen de eigenschappen beschikbaar van de basisgegevensstructuur. </para>
</sect3>
</sect2>
</sect1>

<sect1 id="scripting-controls">
<title
>Script uitvoeren besturen</title>
 

<sect2>
<title
>Include-bestanden (ingesloten bestanden)</title>
<para
>In scriptdocumenten kunnen andere scripts worden opgenomen. Dit is nuttig om de grootte van scripts te beperken, en voor een betere leesbaarheid. Met <menuchoice
><guimenu
>Scriptdocument</guimenu
><guimenuitem
>Mogelijke Includes</guimenuitem
></menuchoice
> verkrijgt u een lijst met de reeds in &rocs; aanwezige scripts, die kunnen worden ingesloten (include). U kunt een scriptbestand met de volgende opdracht insluiten (dus toevoegen):   </para>
<programlisting
>include_script(string pad);            // relatieve of absolute pad naar scriptbestand
</programlisting>
</sect2>

<sect2 id="scripting-output">
<title
>Scriptuitvoer</title>
<para
>Gedurende het uitvoeren (werking) van een algoritme, worden debug (programmafouten) en programmauitvoer getoond in de <emphasis
>Debug &and; scriptuitvoer</emphasis
>. Indien er een syntaxisfout in uw script wordt ontdekt, wordt de fout ook getoond als een debugbericht. Merk op dat alle programmaberichten ook in de debuguitvoer worden getoond (in een vette letter). </para>
<para
>U kunt met de volgende functies de tekst regelen, die in de scriptuitvoer wordt getoond: </para>
<programlisting
>output(string bericht);            // toont bericht als scriptuitvoer
    debug(string bericht);             // toont bericht als debug output
</programlisting>
</sect2>

<sect2 id="scripting-controlling">
<title
>Regelen script uitvoeren</title>
<para
>U kunt scripts op verschillende manieren uitvoeren (laten werken). </para>
<para
>U kunt met de volgende functies de tekst regelen, die in de scriptuitvoer wordt getoond: </para>
<itemizedlist>
    <listitem
><para>
        <inlinemediaobject
><imageobject>
        <imagedata fileref="rocs-control-engine-run.png" format="PNG"/></imageobject>
</inlinemediaobject
> <guilabel
>Start</guilabel
>: Script uitvoeren tot het einde.</para
></listitem>
    <listitem
><para>
        <inlinemediaobject
><imageobject>
        <imagedata fileref="rocs-control-engine-stop.png" format="PNG"/></imageobject>
</inlinemediaobject
> <guilabel
>Stop</guilabel
>: Stop het uitvoeren van het script (alleen wanneer een script bezig is).</para
></listitem>
    <listitem
><para>
        <inlinemediaobject
><imageobject>
        <imagedata fileref="rocs-control-engine-step.png" format="PNG"/></imageobject>
</inlinemediaobject
> <guilabel
>Enkele stap</guilabel
>: Voer een enkele stap uit van het script. Een stap eindigt met de  functie <literal
>interrupt()</literal
>:</para>
    <programlisting
>interrupt();    // einde van een stap
    </programlisting>
    </listitem>
    <listitem
><para>
        <inlinemediaobject
><imageobject>
        <imagedata fileref="rocs-control-engine-debug.png" format="PNG"/></imageobject>
</inlinemediaobject
> <guilabel
>Debug</guilabel
>: Voer een stap uit in debug-modus. Hiermee wordt de debug-dialoog van QtScript geopend. (Debug is zoeken en verbeteren van programmafouten).</para
></listitem>
</itemizedlist>
</sect2>
</sect1>
</chapter>

<chapter id="import-export">
<title
>Import en export</title>
<sect1 id="import-export-projects">
    <title
>&rocs;-projecten uitwisselen</title>
    <para
>&rocs; projecten kunnen worden geïmporteerd en geëxporteerd als archiefbestanden (<literal
>.tar.gz</literal
>-bestanden). Deze archieven kunnen worden gebruikt om projecten uit te wisselen met anderen. Importeren en  exporteren doet u met <menuchoice
><guimenu
>Bestand</guimenu
> <guimenuitem
>Project importeren</guimenuitem
></menuchoice
> en <menuchoice
><guimenu
>Bestand</guimenu
> <guimenuitem
>Project exporteren</guimenuitem
></menuchoice
>. </para>
</sect1>

<sect1 id="import-export-graphs">
    <title
>Import en export van graafdocumenten</title>
    <para
>Import en export naar de volgende formaten worden door &rocs; ondersteund: </para>
    <itemizedlist>
        <listitem
><para
>DOT-bestanden, ook wel bekend als Graphviz-bestanden.</para
></listitem>
        <listitem
><para
>GML-bestanden</para
></listitem>
        <listitem
><para
>Trivial Graph Format bestanden</para
></listitem>
    </itemizedlist>

<sect2 id="format-specification-tgf">
<title
>Trivial Graph bestandsformaat</title>
<para
><emphasis
>Trivial Graph Format</emphasis
> (TGF) is een formaat waarin een grafiek in een eenvoudig tekstbestand wordt beschreven. Een TGF-bestand bevat een lijst van knoopdefinities, waarin knoop-ID's worden gekoppeld aan namen, gevolgd door een lijst van kanten. In dit formaat is slechts één naam mogelijk per knoop, en één waarde per kant. &rocs; beschouwt geïmporteerde grafen als niet gericht. Geëxporteerde grafen bevatten twee kanten voor elke bidirectionele verbinding (naar beide richtingen). </para>

<sect3>
<title
>Formaatbeschrijving</title>
    <itemizedlist>
        <listitem
><para
>Het bestand begint met een lijst van knopen (op elke regel een knoop), gevolgd door een regel met als enige karakter een '#', gevolgd door een lijst van kanten (op elke regel een kant).</para
></listitem>
        <listitem
><para
>Een knoop wordt beschreven met een geheel getal (als identificatie), gevolgd door een spatie, gevolgd door een willekeurige tekenreeks.</para
></listitem>
        <listitem
><para
>Een kant wordt beschreven door twee gehele getallen (die de verbonden knopen identificeren), gescheiden door een spatie, gevolgd door een spatie, gevolgd door een willekeurige tekenreeks. Aangenomen wordt dat de gerichte kant wijst van de eerste naar de tweede geïdentificeerde knoop.</para
></listitem>
    </itemizedlist>
</sect3>
<sect3>
<title
>Voorbeeld</title>
<programlisting
>1 beginknoop
2 zender
3 aarde
#
1 2 blauw
2 1 rood
2 3 groen
</programlisting>
</sect3>
</sect2>

<sect2 id="format-specification-dot">
<title
>DOT Language / Graphviz Graph bestandsformaat</title>
<para
>De DOT language is een taal voor het beschrijven van een graaf in klare tekst, waarin een goede voor mensen leesbare beschrijving wordt gegeven van grafen, die ook geschikt is voor het efficiënt verwerken door programma's voor het indelen van grafen. DOT is het standaard bestandsformaat voor de Graphviz programma's voor het visualiseren van grafen, maar wordt ook algemeen in andere graafprogramma's gebruikt. De gebruikelijke extensies voor DOT zijn <emphasis
>.gv</emphasis
> en <emphasis
>.dot</emphasis
>. </para>

<sect3>
<title
>Niet ondersteunde eigenschappen</title>
<para
>&rocs; kan elk graafbestand lezen van een graaf die volgens DOT is beschreven <footnote
><para
>http://www.graphviz.org/content/dot-language</para
></footnote
>. De ondersteuning van deze taal is volledig, ondanks de volgende uitzonderingen: </para>
    <itemizedlist>
        <listitem
><para
>subgraaf: Omdat in &rocs; het begrip subgraaf niet bestaat, worden subgrafen slechts geïmporteerd als verzamelingen van gegevenselementen en verbindingen. In het bijzonder worden verbindingen naar en van subgrafen niet geïmporteerd.</para
></listitem>
        <listitem
><para
>&HTML; en &XML; attributen: Attributen (zoals tekst) die &HTML; of &XML; bevatten worden onveranderd gelezen. In het bijzonder worden aanpassingen van lettertypen en stijlen van deze attributen niet gelezen.</para
></listitem>
    </itemizedlist>
</sect3>
<sect3>
<title
>Voorbeeld</title>
<programlisting
>digraph mijnGraaf {
    a -> b -> c;
    b -> d;
}
</programlisting>
</sect3>
</sect2>

</sect1>
</chapter>

<chapter id="credits">
<title
>Dankbetuiging en licentie</title>

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

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

&meld.fouten;&vertaling.freek;&vertaling.jaap; 
&underFDL; &underGPL; </chapter>

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

<sect1 id="getting-rocs">
<title
>Hoe u &rocs; kunt verkrijgen</title>
&install.intro.documentation; </sect1>

<sect1 id="compilation">
<title
>Compileren en installeren</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:
-->
