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

<bookinfo>
<title
>Das Handbuch zu &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
>Burkhard</firstname
><surname
>Lück</surname
><affiliation
><address
><email
>lueck@hube-lueck.de</email
></address
></affiliation
><contrib
>Übersetzung</contrib
></othercredit
> 
</authorgroup>

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

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

<legalnotice
>&FDLNotice;</legalnotice>

<abstract>
<para
>&rocs; ist ein Graphentheorie-Werkzeug für &kde;. </para>
</abstract>

<keywordset>
<keyword
>KDE</keyword>
<keyword
>kdeedu</keyword>
<keyword
>Mathematik</keyword>
<keyword
>Mathe</keyword>
<keyword
>Graphen</keyword>
<keyword
>Knoten</keyword>
<keyword
>Kante</keyword>
</keywordset>

</bookinfo>

<chapter id="introduction">
<title
>Einführung</title>
<para
>Diese Kapitel ist ein Überblick über &rocs;. Leser, die direkt mit &rocs; beginnen möchten, sollten auf jeden Fall <xref linkend="introduction-nutshell"/> lesen und <xref linkend=" scripting"/> beim Schreiben von Skripten als Referenz benutzen. </para>

<sect1 id="introduction-goals">
<title
>Ziel, Zielgruppe und Arbeitsablauf</title>
<para
>&rocs; ist eine Entwicklungsumgebung für Graphen-Theorie für Alle, die an der Entwicklung und Analyse von Graphen-Algorithmen arbeiten, unter anderem:</para>
<itemizedlist>
    <listitem
><para
>Lehrer, die Ihren Studenten Algorithmen demonstrieren möchten,</para
></listitem>
    <listitem
><para
>Studenten, die verstehen und sehen möchten, wie ein Algorithmus funktioniert,</para
></listitem>
    <listitem
><para
>Und alle, die an Datenstrukturen und Algorithmen interessiert sind</para
></listitem>
</itemizedlist>

<para
>Für alle diese Benutzer stellt &rocs; einen einfach zu bedienenden Datenstruktur-Editor für die Erstellung von Graphen, Listen oder Bäumen, ein leistungsfähiges Skriptmodul für QtScript zur Ausführung von Algorithmen und mehrere Hilfswerkzeuge zur Einrichtung von Datenstrukturen für Ihre Simulationen und Experimente bereit. </para>

<para
>Beim typischen Arbeitsablauf erstellen Sie als erstes einen Graphen mit dem visuellen Editor. Den Graphen können Sie von Hand erstellen, indem Sie Datenelemente hinzufügen und sie verbinden. Wenn es einen Hilfsalgorithmus für die ausgewählte Datenstruktur gibt, können Sie alternativ auch aus dem Menü <menuchoice
><guimenu
>Extras</guimenu
><guimenuitem
>Graphen erstellen</guimenuitem
></menuchoice
> verwenden. Mit <menuchoice
><guimenu
>Extras</guimenu
><guimenuitem
>Werte zuweisen</guimenuitem
></menuchoice
> ist es möglich, den Datenstrukturelementen eines Graphen Werte zuzuweisen. Zum Schluß müssen Sie den Algorithmus in der Sprache JavaScript schreiben und mit  der gerade erstellten Datenstruktur ausführen. Die Änderungen durch den Algorithmus sind sofort auf der Zeichenfläche des visuellen Graphen-Editors sichtbar. </para>

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

<sect1 id="introduction-nutshell">
<title
>&rocs; kurz zusammengefasst</title>
<para
>Dieser Abschnitt enthält eine knappe Übersicht über die wichtigsten Elemente von &rocs;. Die wichtigen Begriffe Datenstrukturen, Datenstrukturmodule und Elementarten werden erläutert. Kenntnis dieser Elemente hilf beim Verständnis, wie Datenstrukturen in &rocs; erstellt und geändert werden können. </para>
<para
>Im allgemeinen arbeitet &rocs; mit Projekten: wenn Sie &rocs; starten, wird ein leeres Projekt erstellt. Dieses Projekt können Sie durch Laden oder Importieren eines anderen Projekts ersetzen. Ein Projekt besteht aus <emphasis
>Graphendokumenten</emphasis
> und <emphasis
>Skripten</emphasis
>. </para>

<sect2>
<title
>Graphendokumente und Datenstrukturmodule</title>
<para
>Ein Graphendokument repräsentiert den Inhalt der Zeichenfläche im visuellen Graphen-Editor.Daher kann ein  Graphendokument gleichzeitig mehrere Datenstrukturen, aber nur ein Datenstrukturmodul enthalten. Es gibt Datenstrukturmodule für mehrere Graphentypen (Allgemeine Graphen, verkettete Listen, Wurzelbäume), die zusätzliche Funktionen beinhalten wie zum Beispiel automatische Anordnung der Elemente, besondere Symbole oder erweiterte Skriptfunktionen, die in Algorithmen benutzt werden können. Es ist möglich, das Datenstrukturmodul eines Graphendokuments zu ändern, dabei gehen aber unter Umständen Informationen verloren. Es werden zum Beispiel die Kanten eines Kreises in einem allgemeinen Graphen nicht zu einer Baumstruktur hinzugefügt, wenn Sie zum Wurzelbaummodul wechseln. </para>
<para
>Graphendokumente bilden auch die Basis für die Definition von Zeiger- und Datentypen. </para>
</sect2>

<sect2>
<title
>Datenstrukturen</title>
<para
>Datenstrukturen sind die Grundlage aller Arbeit mit &rocs;. Sie können eine oder mehrere Datenstrukturen zu einem Graphendokument hinzufügen, Datenelemente (Knoten, Daten) und Zeiger auf Knoten einfügen und sie mit Skripten bearbeiten. Dazu hat jede Datenstruktur einen eindeutigen Namen oder Bezeichner, über den im Skript auf die Struktur zugegriffen werden kann. Für ein aktuell ausgewähltes Datenstrukturmodul können die Datenstrukturen nicht willkürlich geändert werden, &eg; darf eine Baumstruktur keine Kreisstruktur haben. Die Datenstruktur wird durch das verwendete Strukturmodul aus dem Graphendokument, das diese Struktur enthält, vorgegeben </para>
</sect2>

<sect2>
<title
>Zeigertypen</title>
<para
>Es lassen sich verschiedene Zeigertypen definieren, die in Datenstrukturen verwendet werden können. Ein Zeigertyp kann ein individuelles Layout - im wesentlichen eine Farbe - erhalten. Es ist dann leicht möglich, Zugriff nur auf Zeiger eines bestimmten Typs in den Skripten zu erhalten. Ein typischer Anwendungsfall für Zeiger ist die Implementierung von Metakanten einer Datenstruktur, um Beziehungen zwischen Datenelementen zu visualisieren. Aber auch wenn das Skript bestimmte Arten von Kanten wie zum Beispiel Baum- und Kreuzkanten bei einer Tiefensuche (englisch depth-first search) identifizieren soll, sind Zeigertypen ein elegante Implementation dafür. </para>
</sect2>

<sect2>
<title
>Datentypen</title>
<para
>Bei vielen Problemen, die mit Datenstrukturen bearbeitet werden, sollte eine Gruppe von Datenelementen in eigene Strukturtypen aufgeteilt werden, &eg; bei Cluster- und Überdeckungsproblemen. Für die Ausführung eines Algorithmus ist es nützlich, einen Datenelementtyp für einen bestimmten Typ wie zum Beispiel Breitensuche (english breadth-first search) anzugeben. Für solche Anwendungsfälle können eigene Datentypen definiert werden. Jeder Datentyp hat ein eigenes Symbol. Für eigene definierte Datentypen ist der Zugriff vom Skript leicht möglich. </para>
</sect2>

<sect2>
<title
>Dynamische Eigenschaften</title>
<para
>Jedes Datenelement und jeder Zeiger hat die beiden Eigenschaften <literal
>name</literal
> und <literal
>value</literal
>. Um die Eigenschaften von Datenelementen und Zeigern zu erweitern, können <emphasis
>dynamische Eigenschaften</emphasis
> hinzugefügt werden. Eine dynamische Eigenschaft wird über ihren Namen identifiziert und darf eine beliebige Zeichenkette enthalten. Um dynamische Eigenschaften hinzuzufügen, können Sie die Dialoge <guilabel
>Dateneigenschaften</guilabel
> und <guilabel
>Zeigereigenschaften</guilabel
> aus dem Kontextmenü der entsprechenden Elemente oder die Skriptfunktionen benutzen, die im Abschnitt <xref linkend="scripting-data-structure"/> erläutert werden. </para>
</sect2>
</sect1>

<sect1 id="introduction-tutorial">
<title
>Anleitung</title>
<para
>In diesem Abschnitt wird ein Beispielprojekt erzeugt, um die wichtigsten Funktionen von &rocs; zu zeigen. Als Ziel soll ein Graph und ein Skript erstellt werden, um damit einen einfachen  Approximationsalgorithmus für das <emphasis
>Minimum-Knotenüberdeckungproblem</emphasis
> zu zeigen, der eine Knotenüberdeckung mit Güte 2 berechnet. Mit dem Minimum-Knotenüberdeckungsproblem wird eine Untermenge von Graphenknoten C mit minimaler Größe gesucht, so dass jede Graphenkante mit mindestens einem Knoten in C verbunden ist. Dies Problem ist NP-vollständig. Es soll gezeigt werden, wie eine Approximation mit dem Faktor 2 durch Suchen nach Matching in den angegebenen Graphen gefunden wird. Im Folgenden werden die üblichen Begriffe für Graphenalgorithmen verwendet: Graph für die Datenstruktur, Knoten für die Datenelemente und Kanten für die Zeiger. </para>
<para
>Ziel ist die Visualisierung der Übereinstimmung von Matching-Knotenüberdeckungen und Minimum-Knotenüberdeckungen. Dazu werden zwei Zeigertypen definiert, einer für die Matching-Kanten und einer zur Darstellung normaler Kanten, außerdem noch zwei Datentypen, die zur Unterscheidung von in C enthaltenen bzw. nicht enthaltenen Knoten verwendet werden. </para>

<sect2>
<title
>Einen Graphen erstellen</title>
<para
>Für das Graphenmodul können mit &rocs; Graphen erzeugt werden. Wählen Sie dazu <menuchoice
><guimenu
>Graphendokument</guimenu
> <guisubmenu
>Extras</guisubmenu
> <guimenuitem
>Graph erstellen</guimenuitem
></menuchoice
>. Erstellen Sie einen „Zufälligen Graphen“ mit 30 Knoten, 90 Kanten und mit Seed = 1. Seed ist der Startwert für den Generator des zufälligen Graphen. Wird der gleich Seed verwendet, ergibt das auch reproduzierbar den gleichen Graphen. Dann ändern Sie den Namen des Graphen im Datenstrukturbereich in <literal
>testgraph</literal
>. </para>
</sect2>

<sect2>
<title
>Typen erstellen</title>
<para
>Klicken Sie auf ein Datenelement oder eine Verbindung im Datenstrukturbereich, um den Einstellungsdialog für Daten- und Zeigertypen des aktuellen Dokuments zu öffnen. Als Datentyp wird ein neuer Typ namens „C“ hinzugefügt. Dieser erhält automatisch die Kennung <literal
>1</literal
>. Als Symbol wird das Serverbild ausgewählt. Dann wird der Dialog Eigenschaften des Zeigertyps geöffnet und ein neuer Zeigertyp mit dem Namen „matching“ erstellt. Er erhält automatisch die Kennung <literal
>1</literal
>. Als Farbe wird Blau eingestellt. </para>
</sect2>

<sect2>
<title
>Der Algorithmus</title>
<para
>Dann muss der Algorithmus der Approximation wie im folgenden implementiert werden: </para>
<programlisting
>var E = testgraph.list_edges(); // Menge der nicht bearbeiteten Kanten
var C = new Array();            // Matching-Kanten
while (E.length 
> 0) {
    var e = E[0];        // die erste Kante e={u,v}
    var u = e.start();
    var v = e.end();
    e.set_type(1);        // als Matching-Kanten setzen
    E.shift();            // e (i.e., E[0]) aus der Liste der Kanten entfernen
    C.push(u);            // u zu C hinzufügen
    C.push(v);            // v zu C hinzufügen


    // u,v als Knoten von C markieren C
    u.set_type(1);
    v.set_type(1);

    // von E alle Kanten entfernen, die inzident zu u oder v sind
    var adjacent = u.adj_edges();
    for (var i=0; i &lt; adjacent.length; i++) {
        var index = E.indexOf(adjacent[i]); // Index suchen
        if (index!=-1) {
            E.splice(index, 1); // Löschen, wenn gefunden
        }
    }
    var adjacent = v.adj_edges();
    for (var i=0; i &lt; adjacent.length; i++) {
        var index = E.indexOf(adjacent[i]); // Index suchen
        if (index!=-1) {
            E.splice(index, 1); // Löschen, wenn gefunden
        }
    }
}
output("Knotenüberdeckung enthält " + C.length + " Knoten.");
</programlisting>
</sect2>

<sect2>
<title
>Ausführung des Algorithmus</title>
<para
>Schließlich soll der Algorithmus ausgeführt werden. Die Ausführung wird mit dem Knopf <guibutton
>Ausführen</guibutton
> der Bedienelemente für Skripte gestartet. </para>
</sect2>
</sect1>
</chapter>

<chapter id="user-interface">
<title
>Die Benutzerschnittstelle von &rocs;</title>

<sect1 id="user-interface-all">
<title
>Standardelemente der Benutzeroberfläche</title>
<para
>Die Benutzerschnittstelle besteht aus mehreren logischen Teilen, die im folgenden Bildschirmfoto gezeigt werden. </para>
<screenshot>
    <screeninfo
>Bedienungselemente der &rocs;-Benutzeroberfläche</screeninfo>
    <mediaobject>
    <imageobject>
    <imagedata fileref="rocs-interfaces.png" format="PNG"/>
    </imageobject>
    <textobject>
    <phrase
>Bedienungselemente der &rocs;-Benutzeroberfläche</phrase>
    </textobject>
    </mediaobject>
</screenshot>
<variablelist>
<varlistentry>
    <term
>Visueller Graphen-Editor</term>
    <listitem
><para
>Dies ist die Zeichenfläche, auf der die Datenstrukturen erstellt und bearbeitet werden. Klicken Sie mit der &RMBn; auf die Zeichenfläche, auf Datenelemente oder Zeiger, um die zugehörigen Kontextmenüs zu öffnen. Sie können auch die Aktionen aus der Werkzeugleiste benutzen, um die Elemente auf der Zeichenfläche zu bearbeiten.</para
></listitem>
</varlistentry>
<varlistentry>
    <term
>Werkzeugleiste für den visuellen Graphen-Editor</term>
    <listitem
><para
>In dieser Werkzeugleiste finden Sie Aktionen für die Zeichenfläche des visuellen Graphen-Editor. Mit <guibutton
>Daten hinzufügen</guibutton
> oder <guibutton
>Verbindungen hinzufügen</guibutton
> können neue Datenelement erstellt und neue Datenelemente oder neue Zeiger zu einer aktuell im Bereich <emphasis
>Graphen-Eigenschaften</emphasis
> ausgewählten Datenstruktur hinzugefügt werden. Beachten Sie dass <guibutton
>Daten hinzufügen</guibutton
> und auch <guibutton
>Verbindungen hinzufügen</guibutton
> Untermenüs enthalten können, um den Daten- oder Zeigertyp des neuen Elements auszuwählen. Weitere Informationen dazu im Abschnitt <xref linkend="user-interface-toolbars"/>. </para
></listitem>
</varlistentry>
<varlistentry>
    <term
>Graphen-Eigenschaften</term>
    <listitem
><para
>Oben können Sie das aktuelle Graphendokument auswählen und dessen Einstellungsdialog öffnen sowie neue Datenstrukturen zum aktuellen Graphendokument &ie; zur aktuellen Zeichenfläche hinzufügen. Darunter wird die aktuelle Datenstruktur ausgewählt. Sie können mit den entsprechenden Knöpfen einstellen, welche Eigenschaften von Datenelementen und Zeigern wie Namen, Werte und Objekte auf der Zeichenfläche angezeigt werden. Klicken Sie auf die Namen der Daten- und Zeigertypen, um den Einstellungsdialog zu öffnen. Weitere Informationen finden Sie im Abschnitt <xref linkend="user-interface-graph-properties"/>. </para
></listitem>
</varlistentry>
<varlistentry>
    <term
>Skripteditor</term>
    <listitem
><para
>In diesem Texteditor können Sie Algorithmen schreiben, das wird im <xref linkend="scripting"/> erläutert. Sie können gleichzeitig an mehreren Skriptdokumenten arbeiten, indem Sie Unterfenster verwenden. Enthält ein Unterfenster noch nicht gespeicherte Änderungen, dann wird ein kleines Diskettensymbol auf dem Karteireiter angezeigt. </para
></listitem>
</varlistentry>
<varlistentry>
    <term
>Fehler- und Skriptausgabe</term>
    <listitem
><para
>In diesem Textfeld werden Fehlermeldungen oder Skriptausgaben Ihres Algorithmus angezeigt, abhängig von der gewählten Ausgabeeinstellung. Tritt ein Fehler in Ihrem Skript auf, wird automatisch die Fehlerausgabe gewählt. Zusätzlich werden in der Fehlerausgabe alle Meldungen des Programms angezeigt. </para
></listitem>
</varlistentry>
<varlistentry>
    <term
>Bedienelemente</term>
    <listitem
><para
>In diesem Bereich finden Sie die Bedienelelemente, um die Ausführung von Skripten zu steuern. Mit dem Knopf <guibutton
>Ausführen</guibutton
> starten Sie das aktuell im Editor geöffnete Skript.  Wird ein Skript ausgeführt, können Sie es mit <guibutton
>Anhalten</guibutton
> stoppen. Beachten Sie, dass die Ausführung von <guibutton
>Ein Schritt</guibutton
> nur bei bestimmten Schlüsselwörtern anhält, siehe <xref linkend="scripting"/>. </para
></listitem>
</varlistentry>
</variablelist>
</sect1>

<sect1 id="user-interface-toolbars">
<title
>Werkzeugleisten</title>
<para
>Es gibt mehrere verschiedene Werkzeugleisten für den visuellen Graphen-Editor, die den Zugriff auf alle Aktion mit einem Mausklick ermöglichen. In der Voreinstellung werden folgende Werkzeugleisten angezeigt:</para>
<itemizedlist>
    <listitem
><para
>Haupt-Werkzeugleiste</para
></listitem>
    <listitem
><para
>Layout-Werkzeugleiste</para
></listitem>
</itemizedlist>
<!--  -->
<sect2 id="user-interface-toolbars-main">
<title
>Haupt-Werkzeugleiste</title>
<para
>Die <emphasis
>Haupt-Werkzeugleiste</emphasis
> enthält die im Folgenden genannten Aktionen. Klicken Sie auf den Knopf für eine Aktion, dann können Sie diese Aktion anschließend mit dem Mauszeiger auf die Elemente auf der Zeichenfläche anwenden.</para>
<itemizedlist>
<listitem
><para
><guilabel
>Verschieben</guilabel
>: Um Elemente auszuwählen, klicken Sie entweder mit der &LMBn; auf eine freie Stelle auf der Zeichenfläche, halten die Maustaste gedrückt und ziehen ein Rechteck um Datenelemente und/oder Zeiger, um sie auszuwählen oder klicken Sie sonst zur Auswahl auf ein nicht ausgewähltes Element. Klicken Sie dann auf ein oder mehrere ausgewählte Elemente und verschieben sie mit gedrückter Maustaste. Ausgewählte Elemente können auch mit den Pfeiltasten verschoben werden.</para
></listitem>
<listitem
><para
><guilabel
>Daten hinzufügen</guilabel
>: Klicken Sie mit der &LMBn; auf eine beliebige Position auf der Zeichenfläche, um ein neues Datenelement für die gerade ausgewählte Datenstruktur zu erstellen. Halten Sie die Maustaste gedrückt, dann erscheint ein Menü, aus dem der Datentyp des neu erstellten Datenelements ausgewählt werden kann, wenn es mehrere Datentypen gibt.</para
></listitem>
<listitem
><para
><guilabel
>Verbindung hinzufügen</guilabel
>: Klicken Sie mit der &LMBn; auf ein Datenelement, halten Sie die Maustaste gedrückt und ziehen Sie eine Linie zu einem anderen Datenelement. Diese Aktion kann nur dann ausgeführt werden, wenn beim aktuellen Graphen diese Kante hinzugefügt werden kann. In einem ungerichteten Graphen dürfen Sie &eg; nicht mehrere Kanten zwischen zwei Datenelementen einfügen. Halten Sie die Maustaste gedrückt, dann erscheint ein Menü, aus dem der Datentyp des neu erstellten Zeigers ausgewählt werden kann, wenn es mehrere Zeigertypen gibt.</para
></listitem>
<listitem
><para
><guilabel
>Löschen</guilabel
>: Klicken Sie auf ein Element, um es zu löschen. Löschen Sie einen Knoten, dann werden alle anliegenden Kanten ebenfalls gelöscht.</para
></listitem>
<listitem
><para
><guilabel
>Vergrößerung</guilabel
>: Klicken Sie auf die Zeichenfläche, halten Sie die &LMB; gedrückt und zeichnen Sie ein Rechteck. Die Zeichenfläche wird auf diesen gewählten Bereich vergrößert. Mit dem Mausrad können Sie die Ansicht ebenfalls vergrößern bzw. verkleinern. Doppelklicken mit der &LMBn; stellt die ursprüngliche Vergrößerung wieder her.</para
></listitem>
</itemizedlist>
<screenshot>
<screeninfo
>Die Haupt-Werkzeugleiste</screeninfo>
<mediaobject>
<imageobject>
<imagedata fileref="rocs-toolbar-main.png" format="PNG"/>
</imageobject>
<textobject>
<phrase
>Die Haupt-Werkzeugleiste</phrase>
</textobject>
</mediaobject>
</screenshot>
</sect2>

<sect2 id="user-interface-toolbars-alignment">
<title
>Layout-Werkzeugleiste</title>
<para
>Weiterhin gibt es noch die zusätzliche <emphasis
>Layout-Werkzeugleiste</emphasis
>. Drücken Sie einen Knopf in dieser Werkzeugleiste, dann wird die Aktion direkt an aktuell ausgewählten Knoten ausgeführt:</para>
<itemizedlist>
<listitem
><para>
<inlinemediaobject
><imageobject>
<imagedata fileref="hi22-action-rocsaligntop.png" format="PNG"/></imageobject>
</inlinemediaobject
> <guilabel
>Oben</guilabel
>: Richtet die Datenelemente an der senkrechten Position des obersten Datenelements aus. Die waagerechte Position bleibt unverändert.</para
></listitem>
<listitem
><para>
<inlinemediaobject
><imageobject>
<imagedata fileref="hi22-action-rocsalignvmiddle.png" format="PNG"/></imageobject>
</inlinemediaobject
> <guilabel
>Mittig</guilabel
>: Richtet die Datenelemente an der senkrechten Position aus, die durch die Mitte der senkrechten Positionen aller ausgewählten Datenelemente bestimmt wird. Die waagerechte Position bleibt unverändert.</para
></listitem>
<listitem
><para>
<inlinemediaobject
><imageobject>
<imagedata fileref="hi22-action-rocsalignbottom.png" format="PNG"/></imageobject>
</inlinemediaobject
> <guilabel
>Unten</guilabel
>: Richtet die Datenelemente an der senkrechten Position des untersten Datenelements aus. Die waagerechte Position bleibt unverändert.</para
></listitem>
<listitem
><para>
<inlinemediaobject
><imageobject>
<imagedata fileref="hi22-action-rocsalignleft.png" format="PNG"/></imageobject>
</inlinemediaobject
> <guilabel
>Mittig</guilabel
>: Richtet die Datenelemente an der waagerechten Position des obersten Datenelements aus. Die senkrechte Position bleibt unverändert.</para
></listitem>
<listitem
><para>
<inlinemediaobject
><imageobject>
<imagedata fileref="hi22-action-rocsalignhmiddle.png" format="PNG"/></imageobject>
</inlinemediaobject
> <guilabel
>Mittig</guilabel
>: Richtet die Datenelemente an der waagerechten Position des obersten Datenelements aus. Die senkrechte Position bleibt unverändert.</para
></listitem>
<listitem
><para>
<inlinemediaobject
><imageobject>
<imagedata fileref="hi22-action-rocsalignright.png" format="PNG"/></imageobject>
</inlinemediaobject
> <guilabel
>Rechts</guilabel
>: Richtet die Datenelemente an der waagerechten Position des rechten Datenelements aus. Die senkrechte Position bleibt unverändert.</para
></listitem>
<listitem
><para>
<inlinemediaobject
><imageobject>
<imagedata fileref="hi22-action-rocsaligncircle.png" format="PNG"/></imageobject>
</inlinemediaobject
> <guilabel
>Kreis</guilabel
>: Richtet die Datenelemente auf einem Kreis mit dem größten Abstand der Datenelemente als Durchmesser aus. Die Datenelemente werden in der Reihenfolge angeordnet, die sich aus der Sicht des Schwerpunkts der durch die Datenelemente gebildeten Fläche ergibt.</para
></listitem>
<listitem
><para>
<inlinemediaobject
><imageobject>
<imagedata fileref="hi22-action-rocsaligntree.png" format="PNG"/></imageobject>
</inlinemediaobject
> <guilabel
>Kreuzende Kanten minimieren</guilabel
>: Verwendet den Fruchterman-Reingold-Algorithmus, um durch eine geänderte Anordnung der Datenelemente die Anzahl der kreuzenden Verbindungen zu minimieren.</para
></listitem>
</itemizedlist>
<screenshot>
<screeninfo
>Die Layout-Werkzeugleiste</screeninfo>
<mediaobject>
<imageobject>
<imagedata fileref="rocs-toolbar-alignment.png" format="PNG"/>
</imageobject>
<textobject>
<phrase
>Die Layout-Werkzeugleiste</phrase>
</textobject>
</mediaobject>
</screenshot>
</sect2>
</sect1>

<sect1 id="user-interface-graph-properties">
<title
>Der Bereich Graphen-Eigenschaften</title>
<para
>Oben in diesem Bereich kann das aktuelle Graphendokument ausgewählt werden. Darunter können neue Datenstrukturen erstellt oder vorhandene bearbeitet und eingerichtet werden. </para>

<sect2 id="user-interface-graph-properties-document">
<title
>Dokumentenauswahl und Eigenschaften</title>
<para
>Oben in diesem Bereich kann das aktuelle Graphendokument ausgewählt werden. Das Graphendokument repräsentiert die Zeichenfläche, die im visuellen Graphen-Editor angezeigt wird. Um ein neues Graphendokument zu erstellen oder ein vorhandenes zum Projekt hinzuzufügen, benutzen Sie <menuchoice
><guimenu
>Projekt</guimenu
> <guimenuitem
>Neues Graphendokument</guimenuitem
></menuchoice
> oder <menuchoice
><guimenu
>Projekt</guimenu
> <guimenuitem
>&rocs;-Graphen importieren</guimenuitem
></menuchoice
>. Sie können auch Graphendokumente aus anderen Programmen importieren, siehe <xref linkend="import-export"/>. Klicken Sie auf <guibutton
>Eigenschaften</guibutton
>, dann können Sie sie bearbeiten. </para>
</sect2>

<sect2 id="user-interface-graph-properties-datastructure-create">
<title
>Neue Datenstrukturen erstellen</title>
<para
>Neue Datenstrukturen werden durch Eingabe einer Kennung (ohne Leer- und Sonderzeichen) und Drücken auf <guibutton
>Hinzufügen</guibutton
> erstellt. Die Kennung verwenden die Algorithmen zum Zugriff auf Datenstrukturen. </para>
</sect2>

<sect2 id="user-interface-graph-properties-datastructure-config">
<title
>Datenstrukturen einrichten</title>
<para
>Alle vorhandenen Datenstrukturen des aktuellen Graphendokuments werden in der Auswahlliste angezeigt. Wenn Sie ein Graphendokument auswählen, werden Einstellungen für die zugehörigen Datenstrukturen angezeigt: </para>
    
<itemizedlist>
    <listitem
><para
><guibutton
>Löschen</guibutton
>: Löscht diese Datenstruktur. </para
></listitem>
    <listitem
><para
><guilabel
>Name</guilabel
>: Dies ist die Kennung der Datenstruktur. Diese Kennung verwenden die Algorithmen zum Zugriff auf Datenstrukturen. </para
></listitem>
    <listitem
><para
>Im Bereich <guilabel
>Anzeigeeinstellungen</guilabel
> werden alle Daten- und Verbindungstypen aufgeführt. Klicken Sie auf den Namen, um den Einrichtungsdialog für die zugehörigen Typen zu öffnen. Außerdem kann die Anzeige von Datenelementen, Verbindungen, Namen und Werten von Elementen der angegebenen Typen mit den entsprechenden Knöpfen ein- und ausgeschaltet werden. </para
></listitem>
</itemizedlist>
</sect2>

<sect2 id="user-interface-graph-properties-datastructure-individual">
<title
>Moduloptionen einer Datenstruktur einrichten</title>
<para
>Jedes Datenstrukturmodul kann Optionen zum Einrichtungsdialog der Datenstruktur hinzufügen. Das Standard-Datenstrukturmodul enthält die folgenden Optionen: </para>
    
<sect3>
<title
>Modul „Graph“</title>
<para
>Mit <guilabel
>Graphentyp</guilabel
> können Sie den Typ eines Graphen auswählen. Die Typen haben folgende Bedeutung: </para>
<itemizedlist>
    <listitem
><para
><guilabel
>Gerichteter Graph</guilabel
>: Graph mit gerichteten Kanten, bei dem mehrere Kanten mit gleicher Orientierung zwischen gleichen Knoten nicht erlaubt sind. </para
></listitem>
    <listitem
><para
><guilabel
>Ungerichteter Graph</guilabel
>: Graph mit ungerichteten Kanten, bei dem mehrere Kanten zwischen gleichen Knoten nicht erlaubt sind. </para
></listitem>
    <listitem
><para
><guilabel
>Gerichteter Multigraph</guilabel
>: Graph mit gerichteten Kanten, bei dem mehrere Kanten mit gleicher Orientierung zwischen gleichen Knoten erlaubt sind. </para
></listitem>
    <listitem
><para
><guilabel
>Ungerichteter Multigraph</guilabel
>: Graph mit ungerichteten Kanten, bei dem mehrere Kanten zwischen gleichen Knoten erlaubt sind. </para
></listitem>
</itemizedlist>
</sect3>

<sect3>
<title
>Modul „Wurzelbaum“</title>
<para
>Kreuzen Sie <guilabel
>Alle Zeiger anzeigen</guilabel
> an, dann werden alle Zeiger zwischen den Baumknoten angezeigt. Ist diese Einstellung nicht aktiv, werden mehrere Zeiger zwischen denselben Knoten zusammengefasst. </para>
</sect3>

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

<chapter id="scripting">
<title
>Schreiben und Ausführen von Algorithmen in &rocs;</title>

<para
>&rocs; verwendet intern QtScript als Skriptmodul, das von JavaScript abgeleitet ist. Daher müssen Ihre implementierten Algorithmen in JavaScript geschrieben werden. Diese Skriptsprache wird hier nicht erklärt, nur der Zugriff auf Datenstrukturen, Datenelemente und Zeiger Ihrer Datenstrukturen mit dem Skriptmodul. Sie verwenden nie ein Basisstrukturobjekt, sondern immer das Objekt, das vom gerade verwendeten Datenstrukturmodul bereitgestellt wird. Die Funktionalität der Datenstruktur wird also durch das zugehörige Modul erweitert. Daher sollten Sie die speziellen Funktionen der Module benutzen. Insbesondere verwenden Datenstrukturmodule die üblichen Begriffe Ihrer Domäne wie zum Beispiel Knoten und Kanten für Graphen und Wurzel und Blätter für Baumstrukturen &etc; </para>
<para
>Beachten Sie, dass Änderungen durch das Skriptmodul direkt die Eigenschaften im visuellen Graphen-Editor auf der Zeichenfläche verändern. Daher ändern Skripte tatsächlich die Datenstruktur. </para>

<sect1 id="scripting-data-structure">
<title
>Die Basiselemente von Datenstrukturen</title>
<para
>Jedes Modul stellt einen speziellen Satz von Funktionen und Eigenschaften für seine Datenstrukturen und deren Elemente bereit. Außerdem gibt es noch die Eigenschaften und Funktionen für die Basisdatenstruktur. Daher treffen die Erläuterungen in diesem Abschnitt für alle Datenstrukturmodule zu. </para>
<sect2
><title
>Basiseigenschaften von Datenstrukturen</title>
<para
>Datenstrukturen werden über den Namen identifiziert. Angenommen Sie haben eine Datenstruktur mit dem Namen <literal
>testgraph</literal
>, dann erhalten Sie über diese Kennung Zugriff auf die Datenstruktur. Um zum Beispiel ein Feld aller Datenelemente einer bestimmten Datenstruktur zu erhalten, verwenden Sie <literal
>testgraph.list_nodes();</literal
> im Skript. </para>

<sect3>
<title
>Basiseigenschaften von Datenstrukturen und Funktionen</title>
<para
>Jede Datenstruktur <literal
>testgraph</literal
> hat folgende Eigenschaften, die mit <literal
>testgraph.property</literal
> geschrieben oder gelesen werden können: </para>
<programlisting
>string name  // Kennung der Datenstruktur
</programlisting>
</sect3>
</sect2>

<sect2>
<title
>Basiseigenschaften von Datenelementen und Funktionen</title>
<para
>Jedes Datenelement hat die folgenden Eigenschaften, die geschrieben und gelesen werden können: </para>
<programlisting
>double x      // x-Koordinate der aktuellen Position
    double y      // y-Koordinate der aktuellen Position
    double width  // Größe
    string value  // Wert
    string name   // Name
    string color  // Farbe in HEXA
</programlisting>
<para
>Außerdem ist der Zugriff auf jede dynamische Eigenschaft eines Datenelements über seinen Namen möglich. </para>

<para
>Jedes Datenelementobjekt stellt die folgenden Methoden bereit: </para>
<programlisting
>int type();                         // Datentyp des Datenelements
    int set_type(int);                  // setzt den Datentyp des Elements
    void add_property(string name,      // fügt eine dynamische Eigenschaft mit dem angegebenen Namen und Wert hinzu
                      string value);
    array adj_data();                   // Liste der anliegenden Daten
    array adj_pointers();               // Liste der anliegenden Zeiger
array input_pointers();             // Liste der Eingabezeiger
    array output_pointers();            // Liste der Ausgabezeiger
    array loop_pointers();              // Liste der Zeiger, die eine Schleife bilden
    array connected_pointers(target);   // Liste der Zeiger zu „target“
    void self_remove();                 // entfernt dieses Datenelement
</programlisting>
</sect2>

<sect2>
<title
>Basiseigenschaften von Zeigern und Funktionen</title>
<para
>Jeder Zeiger hat die folgenden Eigenschaften, die geschrieben und gelesen werden können: </para>
<programlisting
>string color  // Farbe in HEXA
    string value  // Wert
    string name   // Name
    double width  // Breite
    string style  // Erlaubte Werte dot, dash, dash dot, solid
</programlisting>
<para
>Außerdem ist der Zugriff auf jede dynamische Eigenschaft eines Zeigers über seinen Namen möglich. </para>

<para
>Jedes Zeigerobjekt stellt die folgenden Methoden bereit: </para>
<programlisting
>int type();                         // Zeigertyp des Zeigers
    int set_type(int);                  // setzt den Zeigertyp des Zeigers
    void add_property(string name,      // fügt dynamische Eigenschaften zum Datenelement mit dem Namen und Wert hinzu
                      string value);
    node start();                       // Startknoten des Zeigers
    node end();                         // Zielknoten des Zeigers
    void self_remove();                 // entfernt diesen Zeiger
</programlisting>
</sect2>
</sect1>

<sect1 id="scripting-plugin-graph">
<title
>Das Modul „Graph“</title>
<sect2>
<title
>Grapheneigenschaften und Funktionen</title>

<sect3>
<title
>Die Graphenstruktur</title>
<para
>Mit einem Datenstrukturobjekt vom Typ „Graph“ können Sie folgende Member-Funktionen aufrufen: </para>
<programlisting
>array list_nodes();                   // Liste aller Knoten des Graphen
    array list_edges();                   // Liste aller Kanten des Graphen
    node add_node(name);                  // fügt einen neuen Knoten hinzu und gibt ihn zurück
    edge add_edge(node from, node to);    // fügt eine neue Kante von „from“ nach „to“ hinzu und gibt sie zurück
    array overlay_edges(int overlayID);   // Liste aller Kanten in der angegebenen Überlagerung
    edge add_overlay_edge(node from,
                          node to,
                          int overlayID); // fügt eine Kante vom angegebenen Zeigertyp/in der angegebenen Überlagerung hinzu
</programlisting>
</sect3>

<sect3>
<title
>Graphenknoten</title>
<para
>Mit einem Datenstrukturobjekt vom Typ „Graph“ können Sie folgende Member-Funktionen für die Graphenknoten zusätzlich zu den Eigenschaften des Datenelements aufrufen: </para>
<programlisting
>array adj_nodes();                    // Liste aller anliegenden Knoten
    array adj_edges();                    // Liste der anliegenden Kanten
    array input_edges();                  // Liste der Eingabe-Kanten
    array output_edges();                 // Liste der Ausgabe-Kanten
    array loop_edges();                   // Liste aller Kanten, die mit dem Knoten in einer Schleife liegen
    array connected_edges(node target);   // Alle Kanten, die mit dem Knoten „target“ verbunden sind
</programlisting>
</sect3>

<sect3>
<title
>Graphenkanten</title>
<para
>Für Kanten einer Datenstruktur vom Typ „Graph“ sind nur die Eigenschaften der Basis-Datenstruktur verfügbar. </para>
</sect3>
</sect2>

<sect2>
<title
>Graphenstruktur-Algorithmen</title>
<para
>Das Modul „Graph“ stellt einige besondere Funktionen bereit, die mit dem Skriptmodul verwendet werden können.</para>
<variablelist>
<varlistentry>
<term
>Berechnung des kürzesten Wegs</term>
<listitem>
    <para
>Berechnet den kürzesten Weg zwischen dem <emphasis
>Start</emphasis
>- und <emphasis
>Endknoten</emphasis
>. Beide Knoten müssen auf demselben Graphen liegen. Bei dieser Berechnung wird berücksichtigt, ob der Graph gerichtet oder ungerichtet ist.</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
>Entfernungen des kürzesten Wegs</term>
<listitem>
    <para
>Berechnet die Entfernungen der kürzesten Wege vom Knoten <emphasis
>Start</emphasis
> zu allen anderen Knoten des Graphen. Bei dieser Berechnung wird berücksichtigt, ob der Graph gerichtet oder ungerichtet ist.</para>
    <funcsynopsis>
    <funcprototype
><funcdef
>array <function
>distances</function
></funcdef
> <paramdef
>node <parameter
><replaceable
>start</replaceable
></parameter
></paramdef
> </funcprototype>
    </funcsynopsis>
</listitem>
</varlistentry>
</variablelist>
</sect2>
</sect1>

<sect1 id="scripting-plugin-linkedlist">
<title
>Das Modul „Verkettete Liste“</title>
<sect2>
<title
>Eigenschaften von verketteten Listen und Funktionen</title>

<sect3>
<title
>Die Struktur „Verkettete Liste“</title>
<para
>Mit einem Datenstrukturobjekt vom Typ „Verkettete Liste“ können Sie folgende Member-Funktionen aufrufen: </para>
<programlisting
>node begin();                           // gibt den ersten Knoten der verketteten Liste zurück
    setBegin(node begin):                   // setzt den Knoten „begin“ als ersten Knoten der Liste und ordnet die Liste um
    createNode();                           // erstellt einen neuen Knoten in der Liste
</programlisting>
</sect3>

<sect3>
<title
>Knoten verketteter Liste</title>
<para
>Mit einem Datenstrukturobjekt vom Typ „Verkettete Liste“ können Sie folgende Member-Funktionen für die Graphenknoten zusätzlich zu den Eigenschaften des Datenelements aufrufen: </para>
<programlisting
>node front();                           // gibt den Vorgänger des Knotens zurück
</programlisting>
</sect3>

<sect3>
<title
>Kanten verketteter Listen</title>
<para
>Für Kanten einer Datenstruktur vom Typ „Verkettete Liste“ sind nur die Eigenschaften der Basis-Datenstruktur verfügbar. </para>
</sect3>
</sect2>
</sect1>

<sect1 id="scripting-plugin-rootedtree">
<title
>Das Modul „Wurzelbaum“</title>
<sect2>
<title
>Eigenschaften von Wurzelbäumen und Funktionen</title>

<sect3>
<title
>Die Struktur „Wurzelbaum“</title>
<para
>Für jedes Datenstrukturobjekt vom Typ „Wurzelbaum“ können folgende Eigenschaften geschrieben oder gelesen werden: </para>
<programlisting
>ShowAllPointers     // wenn wahr, werden alle Kanten angezeigt. Setzen Sie dies auf falsch, wenn mehrfache Kanten zusammengefasst werden sollen
</programlisting>
<para
>Mit einem Datenstrukturobjekt vom Typ „Wurzelbaum“ können Sie folgende Member-Funktionen aufrufen: </para>
<programlisting
>node add_data(string name);         // fügt einen Knoten mit dem angegebenen Namen zum Baum hinzu
    void set_root_node(node root);      // setzt root als Wurzel des Baums
    node root_node();                   // gibt den Wurzelknoten des Baums zurück
</programlisting>
</sect3>

<sect3>
<title
>Knoten von Wurzelbäumen</title>
<para
>Für ein Knotenobjekt vom Typ „Wurzelbaum“ können folgende Eigenschaften geschrieben oder gelesen werden: </para>
<programlisting
>int numberOfChilds                  // setzt die Anzahl der zulässigen Unterknoten für diesen Knoten
    node left_child                     // nur lesbar: gibt den linken Unterknoten zurück
    node right_child                    // nur lesbar: gibt den rechten Unterknoten zurück
    node node_parent                    // nur lesbar: gibt den übergeordneten Knoten zurück
</programlisting>
<para
>Mit einem Knotenobjekt vom Typ „Wurzelbaum“ können Sie folgende Member-Funktionen aufrufen: </para>
<programlisting
>node add_left_child(node child);    // linken Unterknoten hinzufügen
    node add_right_child(node child);   // rechten Unterknoten hinzufügen
    node add_child(node child, int i);  // Unterknoten als n-ten Unterknoten zum Knoten hinzufügen
    node add_node_parent(node child);   // Übergeordneten Knoten hinzufügen (nur möglich, wenn noch nicht vorhanden)
    node left_child();                  // rechten Unterknoten zurückgeben
    node right_child();                 // linken Unterknoten zurückgeben
    node child_at(int i);               // n-ten Unterknoten des Knotens zurückgeben
    node node_parent();                 // Übergeordneten Knoten zurückgeben
</programlisting>
</sect3>

<sect3>
<title
>Kanten von Wurzelbäumen</title>
<para
>Für Kanten einer Datenstruktur vom Typ „Wurzelbaum“ sind nur die Eigenschaften der Basis-Datenstruktur verfügbar. </para>
</sect3>
</sect2>
</sect1>

<sect1 id="scripting-controls">
<title
>Kontrolle der Skriptausführung</title>
     

<sect2>
<title
>Dateien einbeziehen</title>
<para
>Ihr Skriptdokument kann andere Skripte einschließen. Das ist nützlich, um die Größe des Skriptdokuments zu verringern und die Lesbarkeit zu verbessern. Benutzen Sie <menuchoice
><guimenu
>Skripte</guimenu
><guimenuitem
>Mögliche Includes</guimenuitem
></menuchoice
> aus dem Menü, um eine Liste von Skriptdateien anzuzeigen, die mit &rocs; ausgeliefert werden. Eine Skriptdatei schließen Sie mit folgendem Befehl ein: </para>
<programlisting
>include_script(string path);            // relativer oder absoluter Pfad zur Skriptdatei
</programlisting>
</sect2>

<sect2 id="scripting-output">
<title
>Skriptausgabe</title>
<para
>Bei der Ausführung eines Algorithmus werden Meldungen in der <emphasis
>Fehler- &amp; Skriptausgabe</emphasis
> angezeigt. Erkennt das Skriptmodul einen Syntaxfehler in Ihrem Skript, wird der Fehler als Debug-Nachricht angezeigt. Auch alle Programmausgaben werden in der Fehlerausgabe als fettgedruckter Text angezeigt. </para>
<para
>Sie können den angezeigten Text in der Skriptausgabe mit folgenden Funktionen steuern: </para>
<programlisting
>output(string message);            // zeigt message als Skriptausgabe
    debug(string message);             // zeigt message als Fehlerausgabe
</programlisting>
</sect2>

<sect2 id="scripting-controlling">
<title
>Kontrolle der Skriptausführung</title>
<para
>Es gibt verschiedene Ausführungsmodi für Skripte. </para>
<para
>Sie können den angezeigten Text in der Skriptausgabe mit folgenden Funktionen steuern: </para>
<itemizedlist>
    <listitem
><para>
        <inlinemediaobject
><imageobject>
        <imagedata fileref="rocs-control-engine-run.png" format="PNG"/></imageobject>
</inlinemediaobject
> <guilabel
>Ausführen</guilabel
>: Führt das Skript bis zum Ende aus.</para
></listitem>
    <listitem
><para>
        <inlinemediaobject
><imageobject>
        <imagedata fileref="rocs-control-engine-stop.png" format="PNG"/></imageobject>
</inlinemediaobject
> <guilabel
>Anhalten</guilabel
>: Hält die Ausführung eines Skripts an und ist nur während der Ausführung aktiviert.</para
></listitem>
    <listitem
><para>
        <inlinemediaobject
><imageobject>
        <imagedata fileref="rocs-control-engine-step.png" format="PNG"/></imageobject>
</inlinemediaobject
> <guilabel
>Ein Schritt</guilabel
>: Führt das Skript bis zum Ende eines Schritts aus. Ein Schritt endet, wenn das Skript die Funktion <literal
>interrupt()</literal
> aufruft:</para>
    <programlisting
>interrupt();    // beendet einen Schritt
    </programlisting>
    </listitem>
    <listitem
><para>
        <inlinemediaobject
><imageobject>
        <imagedata fileref="rocs-control-engine-debug.png" format="PNG"/></imageobject>
</inlinemediaobject
> <guilabel
>Debuggen</guilabel
>: Führt das Skript im Debug-Modus aus, damit wird der QtScript-Debugdialog geöffnet.</para
></listitem>
</itemizedlist>
</sect2>
</sect1>
</chapter>

<chapter id="import-export">
<title
>Importieren und Exportieren</title>
<sect1 id="import-export-projects">
    <title
>&rocs;-Projekte austauschen</title>
    <para
>&rocs;-Projekte können als Archivdateien im Format <literal
>.tar.gz</literal
> importiert und exportiert werden. Diese Archive können zum Austausch von Projekten benutzt werden. Der Import und Export erfolgt mit <menuchoice
><guimenu
>Datei</guimenu
> <guimenuitem
>Projekt importieren</guimenuitem
></menuchoice
> beziehungsweise <menuchoice
><guimenu
>Datei</guimenu
> <guimenuitem
>Projekt exportieren</guimenuitem
></menuchoice
> </para>
</sect1>

<sect1 id="import-export-graphs">
    <title
>Import von Graphendokumenten</title>
    <para
>&rocs; unterstützt zurzeit den Import und Export folgender Dateiformate:</para>
    <itemizedlist>
        <listitem
><para
>DOT-Dateien, auch als Graphviz-Dateien bekannt.</para
></listitem>
        <listitem
><para
>GML-Dateien</para
></listitem>
        <listitem
><para
>Einfache Textdateien.</para
></listitem>
    </itemizedlist>
    <para
>Die Unterstützung dieser Dateiformate ist noch unvollständig und funktioniert nur für die wichtigsten Werte. Datenelemente und die zugehörigen Verbindungen, die Namen aller Elemente, Werte und Koordinaten werden importiert. </para>
</sect1>
</chapter>

<chapter id="credits">
<title
>Danksagungen und Lizenz</title>

<para
>&rocs; </para>
<para
>Copyright für das Programm:</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
>Copyright der Dokumentation:</para>
<itemizedlist>
	<listitem
><para
>Dokumentation Copyright 2009 &Anne-Marie.Mahfouf; &Anne-Marie.Mahfouf.mail; </para
></listitem>
	<listitem
><para
>Dokumentation Copyright 2009 Tomaz Canabrava (tcanabrava AT kde.org)</para
></listitem>
	<listitem
><para
>Dokumentation Copyright 2011-2012 Andreas Cord-Landwehr (cordlandwehr AT googlemail.com)</para
></listitem>
</itemizedlist>

<para
>Übersetzung Burkhard Lück <email
>lueck@hube-lueck.de</email
></para
> 
&underFDL; &underGPL; </chapter>

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

<sect1 id="getting-rocs">
<title
>Wie Sie &rocs; erhalten</title>
&install.intro.documentation; </sect1>

<sect1 id="compilation">
<title
>Kompilierung und 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:
-->
