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

<bookinfo>
<title
>Manuel de &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
>Antoine</firstname
><surname
>Balestrat</surname
><affiliation
><address
><email
>merkil33@gmail.com</email
></address
></affiliation
><contrib
>Traduction française&nbsp;</contrib
></othercredit
> 
</authorgroup>

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

<date
>02-12-2012</date>
<releaseinfo
>1.8.0 &kde; 4.10</releaseinfo>

<legalnotice
>&FDLNotice;</legalnotice>

<abstract>
<para
>&rocs; est un outil d'affichage pour la théorie des graphes pour KDE. </para>
</abstract>

<keywordset>
<keyword
>KDE</keyword>
<keyword
>kdeedu</keyword>
<keyword
>mathématiques</keyword>
<keyword
>math</keyword>
<keyword
>graphes</keyword>
<keyword
>sommet</keyword>
<keyword
>arête</keyword>
</keywordset>

</bookinfo>

<chapter id="introduction">
<title
>Introduction</title>
<para
>Ce chapitre fournit un aperçu des fonctionnalités essentielles et du processus de &rocs;. Pour le lecteur très pressé qui veut utiliser immédiatement &rocs;, il est conseillé au moins de lire <xref linkend="introduction-nutshell"/> et d'utiliser <xref linkend="scripting"/> comme référence lors de l'écriture d'algorithmes. </para>

<sect1 id="introduction-goals">
<title
>Objectifs, public visé et processus</title>
<para
>&rocs; est un EDI de théorie des graphes pour toute personne intéressée par  la création et l'analyse des algorithmes de graphes. Ceci inclut explicitement </para>
<itemizedlist>
    <listitem
><para
>conférenciers qui veulent présenter des algorithmes à leurs élèves, </para
></listitem>
    <listitem
><para
>aux élèves qui souhaitent comprendre et voir comment leurs algorithmes fonctionnent, </para
></listitem>
    <listitem
><para
>et toute personne qui est intéressée dans les structures de données et les algorithmes.</para
></listitem>
</itemizedlist>

<para
>Pour ces utilisateurs, &rocs; dispose d'un éditeur de structure de données simple d'utilisation pour en créer, d'un puissant moteur de langage de scripts pour exécuter les algorithmes, ainsi de nombreux outils d'aide pour vos simulations et vos expériences. </para>

<para
>Pour utiliser &rocs;, la méthode standard est de commencer par la création d'un graphe avec l'éditeur visuel de graphes. Vous pouvez le faire, soit à la main, en ajoutant des éléments de données et en les reliant, ou en utilisant l'une du générateur de structures de données (si disponible pour le moteur sélectionné de structures de données). Les générateurs de structures de données peuvent être trouvés dans <menuchoice
><guimenu
>Document de graphe</guimenu
> <guimenuitem
>Outils</guimenuitem
> <guimenuitem
>Générer le graphe</guimenuitem
></menuchoice
>. Ensuite, vous pouvez associer des valeurs aux éléments de la structure de données, soit à la main ou en utilisant <menuchoice
><guimenu
>Document de graphe</guimenu
> <guimenuitem
>Outils</guimenuitem
> <guimenuitem
>Associer des valeurs</guimenuitem
></menuchoice
>. Enfin, vous pouvez écrire votre algorithme en Javascript et l'exécuter avec la structure de données nouvellement créée. Toutes les modifications que votre algorithme effectue sur la structure de données seront visibles directement dans l'éditeur visuel de graphe. </para>

<screenshot>
<screeninfo
>Une capture d'écran de &rocs;.</screeninfo>
<mediaobject>
<imageobject>
<imagedata fileref="rocs-screenshot.png" format="PNG"/>
</imageobject>
<textobject>
<phrase
>Une capture d'écran de &rocs;.</phrase>
</textobject>
</mediaobject>
</screenshot>
</sect1>

<sect1 id="introduction-nutshell">
<title
>&rocs; pour les nuls</title>
<para
>Cette section fournit un aperçu synthétique des éléments essentiels de &rocs;. Les notions importantes concernant les structures de données, les moteurs de structures de données et les types d'éléments sont expliquées. La compréhension de ces concepts est utile pour comprendre comment créer et modifier ces structures de données dans &rocs;. </para>
<para
>En général, &rocs; fonctionne avec des projets : lors du lancement de &rocs;, un projet vide est créé et vous pouvez le remplacer en chargeant ou important un autre projet. Dans les faits, un projet lui même consiste en des <emphasis
>documents de graphe</emphasis
> et des <emphasis
>scripts</emphasis
>. </para>

<sect2>
<title
>Moteurs pour les documents de graphe et de structures de données</title>
<para
>Un document de graphe représente le contenu d'un espace vide dans l'éditeur visuel de graphe. En fait, un document de graphe peut contenir plusieurs structures de données à la fois mais qu'un seul moteur de structures de données. Les moteurs de structures de données sont présents pour plusieurs types de graphe (graphes généraux, listes chaînées, arborescences) et fournissent pour les types de graphes spécifiques des fonctionnalités additionnelles. Cela peut être le positionnement automatique des éléments, des ensembles d'icônes spéciales ou des ensembles étendus de fonctions de scripts à utiliser dans vos algorithmes. Pour plus de détails, veuillez consulter la section correspondante du manuel. Il est possible de changer de moteur de structure de données pour un document de graphe, cependant, des informations peuvent être perdues (&pex; des arêtes en cercle dans un graphe standard ne seront pas transférées dans une arborescence si vous changez pour un moteur d'arborescence). </para>
<para
>Les documents de graphe représentent aussi la base pour la définition des types de pointeurs et des types de données. </para>
</sect2>

<sect2>
<title
>Structures de données</title>
<para
>Les structures de données sont la base de tout travail dans &rocs;. Vous pouvez ajouter en ajouter une ou plusieurs dans un document de graphe, ajouter des éléments de données (noeuds, données) et des pointeurs vers elles, ainsi que les modifier par des scripts. Pour cela, chaque structure de données possède son nom unique qui peut être utilisé par vos scripts. Par suite de votre choix pour le moteur de structure de données actuel, il se peut que vous ne puissiez pas modifier arbitrairement les structures de données (&pex; une arborescence ne peut jamais contenir un cycle). Le moteur de structure de données est fixé par celui associé au document de graphe correspondant qui contient la structure de données. </para>
</sect2>

<sect2>
<title
>Types de pointeurs</title>
<para
>A partir des types de base, vous pouvez définir des types différents de pointeurs pouvant être utilisés dans vos structures de données. En particulier, un type de pointeur peut obtenir une disposition individuelle (essentiellement une couleur) et il est facile de ne manipuler que des pointeurs d'un type spécifique à partir de vos scripts. Les cas d'utilisation typique des pointeur peut être d'implémenter des méta-arêtes dans votre structures de données qui affichent les relations entre les éléments de données (&pex; afficher les communications intéressantes). Mais aussi, si vos scripts devront identifier des types spécifiques d'arêtes (&pex; des liens dans une arborescence ou des arêtes sécantes pour un algorithme de recherche en profondeur d'abord), les types de pointeurs peuvent être une façon élégante de le faire. </para>
</sect2>

<sect2>
<title
>Types de données</title>
<para
>Dans de nombreux problèmes de structures de données, un ensemble d'éléments de données devraient être rassemblés par groupes de différents types (&pex; problèmes de regroupement ou problèmes de couverture). Ou, il est utile pour l'exécution d'un algorithme de définir un type d'élément de données pour exprimer un type spécifique (&pex; recherche en largeur). Pour de tels cas d'utilisation, vous pouvez définir des types de données. Chaque type de données possède sa propre icône et tous les types de données peuvent être facilement accessibles à partir de vos scripts. </para>
</sect2>

<sect2>
<title
>Propriétés dynamiques</title>
<para
>Tout élément et pointeur de données peuvent avoir de nombreuses propriétés. Certaines d'entre elles existent par défaut à partir du moteur de structure de données. Pour plus de détails, veuillez consulter la documentation sur le moteur de structure de données. Pour ajouter des propriétés supplémentaires à des éléments ou des pointeurs de données, vous pouvez leur ajouter des <emphasis
>propriétés dynamiques</emphasis
>. Chacune d'entre elles est identifiée par son nom et peut contenir n'importe quelle valeur lui étant associée. Le nom doit commencer par une lettre (a-z ou A-Z) et peut contenir uniquement des lettres, des nombres et des « _ ». Si vous tentez d'utiliser d'autres caractères non valables dans le nom de propriété, la propriété ne sera pas modifiée. </para>
<para
>Pour ajouter des propriétés dynamiques, utilisez les boîtes de dialogue <guilabel
>Propriétés de données</guilabel
> et <guilabel
>Propriétés de pointeurs</guilabel
> à partir des menus contextuels pour les éléments respectifs ou les fonctions de scripts comme expliqué en <xref linkend="scripting-data-structure"/>. </para>
<para
>Vous pouvez aussi utiliser des scripts. Vous avez juste besoin d'utiliser <literal
>add_property</literal
> avec le nom et la valeur de votre propriété. Après cela, vous pouvez utiliser la méthode « propertyName » pour le noeud / pointeur pour définir / obtenir leurs valeurs. </para>
<para
>Voici un exemple de comment utiliser les propriétés dynamiques avec le moteur de structures de données « Graphe ». <programlisting
>nodes = myGraph.list_nodes() 
for (var i = 0 ; i &lt; nodes.length ; ++i ){ 
    nodes[i].add_property("MyProperty", 0) 
} 
nodes[0].MyProperty = 2 
nodes[1].MyProperty = nodes[0].MyProperty + 2
    </programlisting>
</para>
</sect2>
</sect1>

<sect1 id="introduction-tutorial">
<title
>Tutoriel</title>
<para
>Dans cette section, un exemple de projet est créé pour explorer quelques unes des fonctions les plus importantes de &rocs;. L'objectif est de créer un graphe et un script qui réalisent un algorithme d'approximation de niveau 2 pour le problème <emphasis
>trajet minimum par tous les sommets</emphasis
>. Ce problème consiste à trouver un sous-ensemble de noeuds de graphe C de taille minimale de façon que chaque noeud du graphe soit connecté à au moins un noeud dans C. Il est connu comme étant « NP-hard ». L'exemple veut illustrer comment trouver une approximation de niveau 2 en trouvant une correspondance dans le graphe donné. Dans la suite, les termes communs pour les algorithmes de graphes seront utilisés : le graphe est la structure de données, les noeuds sont les éléments de données et les arêtes sont les pointeurs). </para>
<para
>Notre objectif est d'afficher la correspondance entre la couverture des sommets correspondante et minimale. Pour cela, il faut spécifier deux types de pointeurs, un pour afficher les arêtes qui correspondent et un pour afficher les arêtes ordinaires, ainsi que deux types de données qui seront utilisés pour distinguer les noeuds contenus dans C et ceux qui ne le sont pas. </para>

<sect2>
<title
>Générer un graphe</title>
<para
>Pour le moteur de structures de données « graphe », &rocs; est livré avec un outil d'aide qui peut générer des graphes. Il faut aller dans <menuchoice
><guimenu
>Document de graphe</guimenu
> <guisubmenu
>Outils</guisubmenu
> <guimenuitem
>Générer le graphe</guimenuitem
></menuchoice
>. Un graphe «Graphe aléatoire » est généré avec 30 noeuds, 90 arêtes et une valeur d'initialisation « seed » de 1 (Cette valeur permet de démarrer le générateur aléatoire de graphe : l'utilisation de la même valeur plusieurs fois produit des graphes identiques et reproductibles). Enfin, le nom du graphe est modifié via le panneau de la structure de données et <literal
>test-graphe</literal
> est appelé. </para>
</sect2>

<sect2>
<title
>Créer des types</title>
<para
>Le <guibutton
>bouton de propriétés de document</guibutton
> est utilisé dans le panneau de structure de données pour ouvrir la boîte de dialogue pour les types de données et de pointeurs du document de graphe courant. Pour les types de données, un nouveau type nommé « C » est ajouté qui reçoit automatiquement l'identifiant <literal
>1</literal
>. Pour ce type, l'image de serveur est sélectionnée comme icône. De plus, la page de type de pointeur est choisie et un nouveau type de pointeur nommé « correspondant » est ajouté. Celui ci prend automatiquement l'identifiant <literal
>1</literal
>. La couleur bleue est choisie. </para>
</sect2>

<sect2>
<title
>L'algorithme</title>
<para
>Enfin, il reste à implémenter l'algorithme d'approximation. Pour cela, l'implémentation suivante est utilisée : </para>
<programlisting
>var E = test-graphe.list_edges() ; // ensembles des arêtes non traitées 
var C = new Array() ;            // arêtes qui correspondent 
while (E.length 
> 0) {
    var e = E[0] ;        // sélection de la première arête e={u,v}
    var u = e.start() ; 
    var v = e.end() ; 
    e.set_type(1) ;        // indique que l'arête est une arête qui correspond 
    E.shift() ;            // supprime e (i.e., E[0]) de la liste des arêtes 
    C.push(u) ;            // ajoute u à C 
    C.push(v) ;            // ajoute v à C 

    // marque u,v comme des noeuds de C
    u.set_type(1) ; 
    v.set_type(1) ; 

    // supprime de E toutes les arêtes  arrivant sur u or v 
    var adjacent = u.adj_edges() ; 
    for (var i=0; i &lt; adjacent.length; i++) {
        var index = E.indexOf(adjacent[i]) ;  // trouve l'index 
        if (index!=-1) { 
            E.splice(index, 1) ; // le supprime si vraiment trouvé 
        }
    }
    var adjacent = v.adj_edges() ; 
    for (var i=0 ; i &lt; adjacent.length ; i++) { 
        var index = E.indexOf(adjacent[i]) ;  // trouve l'indice 
        if (index!=-1) {
            E.splice(index, 1) ;  // le supprime si vraiment trouvé 
        }
    }
}
output("Le trajet par tous les sommets contient " + C.length + " noeuds.") ;
</programlisting>
</sect2>

<sect2>
<title
>Exécuter l'algorithme</title>
<para
>Enfin, l'algorithme doit être exécuter. Pour cela, l'exécution peut être lancée par le <guibutton
>bouton Exécuter</guibutton
> dans le tableau de bord des scripts. </para>
</sect2>
</sect1>
</chapter>

<chapter id="user-interface">
<title
>L'interface utilisateur de &rocs;</title>

<sect1 id="user-interface-all">
<title
>Éléments principaux de l'interface utilisateur</title>
<para
>L'interface utilisateur est divisée en plusieurs parties distinctes, comme le montre la capture d'écran ci-dessous. </para>
<screenshot>
    <screeninfo
>Éléments de l'interface de &rocs;.</screeninfo>
    <mediaobject>
    <imageobject>
    <imagedata fileref="rocs-interfaces.png" format="PNG"/>
    </imageobject>
    <textobject>
    <phrase
>Éléments de l'interface de &rocs;.</phrase>
    </textobject>
    </mediaobject>
</screenshot>
<variablelist>
<varlistentry>
    <term
>Sélecteur de document</term>
    <listitem
><para
>Dans cette barre de menu de haut niveau, vous devez sélectionner le document courant et la structure de données. La création et la suppression de structures de données comme l'accès à leurs propriétés sont aussi possibles ici. </para
></listitem>
</varlistentry>
<varlistentry>
    <term
>Éditeur visuel de graphe</term>
    <listitem
><para
>Ceci est l'espace vide où les structures de données peuvent être créées et modifiées. Faites un clic droit dans cet espace sur des éléments de données ou des pointeurs pour ouvrir les menus contextuels. Vous pouvez utiliser les outils à partir de la <emphasis
>Barre d'outils pour l'éditeur visuel de graphe</emphasis
> pour modifier les éléments dans l'espace vide de l'éditeur visuel de graphe.</para
></listitem>
</varlistentry>
<varlistentry>
    <term
>Barre de l'éditeur visuel de graphe</term>
    <listitem
><para
>Cette barre d'outils regroupe tous les outils pour l'éditeur visuel de graphe. Utilisez l'outil <guibutton
>Ajouter des données</guibutton
> ou <guibutton
>Ajouter une connexion</guibutton
> respectivement pour créer de nouveaux éléments ou pour connecter des éléments. Les nouveaux éléments de données sont ajoutés dans la structure de données actuellement sélectionnée dans le <emphasis
>Sélecteur de documents</emphasis
>.  Veuillez noter que <guibutton
>Ajouter des données</guibutton
> ou <guibutton
>Ajouter une connexion</guibutton
> possèdent tous les deux des menus contextuels pour sélectionner le type associé aux éléments à créer. Pour plus de détails, veuillez consulter <xref linkend="user-interface-toolbars"/>. </para
></listitem>
</varlistentry>
<varlistentry>
    <term
>Panneau latéral</term>
    <listitem
><para
>Sur la droite, vous pouvez trouver le panneau latéral qui fournit plusieurs outils pour votre processus : <itemizedlist>
        <listitem
><para
>Types d'éléments : ce composant graphique vous donne un accès direct aux pointeurs disponibles et au types de données.</para
></listitem>
        <listitem
><para
>Journal : chaque projet possède son propre journal qui peut être utilisé pour, &pex; consigner les tâches, les résultats et les observations.</para
></listitem>
        <listitem
><para
>Documentation : pour obtenir un accès direct au manuel et en même temps à la documentation sur les scripts, vous pouvez ouvrir ce composant graphique.</para
></listitem>
        </itemizedlist>
    </para
></listitem>
</varlistentry>
<varlistentry>
    <term
>Éditeur de script</term>
    <listitem
><para
>Dans cet éditeur de texte, vous pouvez écrire des algorithmes comme expliqué en <xref linkend="scripting"/>. Vous pouvez travailler sur plusieurs algorithmes en même temps en utilisant plusieurs onglets. Un symbole en forme de disque apparaît sur l'onglet si le script a produit des changements non enregistrés. </para
></listitem>
</varlistentry>
<varlistentry>
    <term
>Sortie du script</term>
    <listitem
><para
>Dans cette zone de texte, sont affichés soit les informations de débogage ou la sortie du script correspondant à votre algorithme, selon les paramètres définis en haut du composant graphique. Si le script rencontre une erreur, la sortie de débogage est automatiquement sélectionnée. </para
></listitem>
</varlistentry>
<varlistentry>
    <term
>Contrôles</term>
    <listitem
><para
>Vous pouvez trouver ici les contrôles pour l'exécution de scripts. Vous pouvez exécuter le script actuellement ouvert dans l'éditeur de script en appuyant sur <guiicon
>Exécuter </guiicon
>. Durant l'exécution du script, il est possible de le stopper en appuyant sur le bouton <guiicon
>Stop</guiicon
>. Veuillez noter que l'exécution<guibutton
>Pas à pas</guibutton
> ne s'arrête que sur des mots clé spécifiques (voir <xref linkend="scripting"/>). </para
></listitem>
</varlistentry>
</variablelist>
</sect1>

<sect1 id="user-interface-toolbars">
<title
>Barres d'outils</title>
<para
>Il y a plusieurs barres d'outils dans l'éditeur visuel de graphe qui vous permettent d'accéder aux fonctions en un seul clic. Par défaut, les barres d'outils suivantes sont affichées :</para>
<itemizedlist>
    <listitem
><para
>Barre principale</para
></listitem>
    <listitem
><para
>Barre d'alignement</para
></listitem>
</itemizedlist>
<!--  -->
<sect2 id="user-interface-toolbars-main">
<title
>Barre principale</title>
<para
>La <emphasis
>Barre principale</emphasis
> est constituée des actions suivantes. Cliquer sur une action signifie que le curseur de votre souris applique cette action dans l'éditeur visuel de graphe :</para>
<itemizedlist>
<listitem
><para>
<inlinemediaobject
><imageobject>
<imagedata fileref="hi22-action-rocsselectmove.png" format="PNG"/></imageobject>
</inlinemediaobject
> <guilabel
>Déplacer</guilabel
> : pour sélectionner des éléments, soit cliquez sur un espace vide, maintenez le bouton de la souris enfoncé et dessinez un rectangle qui contient des éléments de données et/ou des pointeurs pour les sélectionner ou soit cliquez directement sur un élément  non encore sélectionné pour le sélectionner. Si vous cliquez sur un élément sélectionné ou sur plusieurs, en maintenant le bouton de la souris enfoncé, et en vous déplaçant autour, vous pouvez déplacer ces éléments.</para
></listitem>
<listitem
><para>
<inlinemediaobject
><imageobject>
<imagedata fileref="hi22-action-rocsadddata.png" format="PNG"/></imageobject>
</inlinemediaobject
> <guilabel
>Ajouter des données</guilabel
> : cliquez sur une position arbitraire dans un espace libre de l'éditeur visuel de graphe pour créer un nouvel élément de données qui appartient à la structure de données actuellement sélectionnée. En maintenant le pointeur de souris enfoncé sur le bouton, un menu contextuel apparaîtra à partir duquel vous pourrez sélectionner le type de données associé aux éléments de données nouvellement créés (uniquement si des types de données différentes existent).</para
></listitem>
<listitem
><para>
<inlinemediaobject
><imageobject>
<imagedata fileref="hi22-action-rocsaddedge.png" format="PNG"/></imageobject>
</inlinemediaobject
> <guilabel
>Ajouter une liaison</guilabel
> : cliquez sur un élément de données, maintenez le bouton de la souris enfoncé et dessinez une ligne reliant un autre élément de données vers lequel le pointeur / arête devra se terminer. Cette action n'est réussie que si le graphe actuel permet d'ajout de cette arête (&cad; dans un graphe non orienté, vous ne pouvez pas ajouter des arêtes multiples entre deux éléments de données). En maintenant le pointeur de souris enfoncé sur le bouton, un menu contextuel apparaît à partir duquel le pointeur de type des pointeurs nouvellement créés peut être sélectionné (uniquement si différents pointeurs de type existent).</para
></listitem>
<listitem
><para>
<inlinemediaobject
><imageobject>
<imagedata fileref="hi22-action-rocsdeletedata.png" format="PNG"/></imageobject>
</inlinemediaobject
> <guilabel
>Supprimer</guilabel
> : cliquez sur un élément pour le supprimer. Si vous supprimez un sommet, toutes les arêtes adjacentes le seront aussi.</para
></listitem>
<listitem
><para>
<inlinemediaobject
><imageobject>
<imagedata fileref="hi22-action-rocszoom.png" format="PNG"/></imageobject>
</inlinemediaobject
> <guilabel
>Zoom</guilabel
> : cliquez sur l'espace vide, maintenez le &BGS; enfoncé puis dessinez un rectangle. Un zoom sera fait dans l'espace vide sur la zone sélectionnée. Utilisez la molette de la souris pour faire aussi bien un zoom avant ou arrière. Un double clic avec le &BGS; fera revenir au zoom initial.</para
></listitem>
</itemizedlist>
</sect2>

<sect2 id="user-interface-toolbars-alignment">
<title
>Barre d'alignement</title>
<para
>Vous pouvez aussi afficher la <emphasis
>Barre d'alignement</emphasis
>. Sélectionner une action depuis cette barre a un effet direct sur les sommets sélectionnés :</para>
<itemizedlist>
<listitem
><para>
<inlinemediaobject
><imageobject>
<imagedata fileref="hi22-action-rocsaligntop.png" format="PNG"/></imageobject>
</inlinemediaobject
> <guilabel
>Haut</guilabel
> : aligne les éléments de données par rapport à la position verticale de l'élément de données le plus haut. Cela affecte seulement les positions verticales.</para
></listitem>
<listitem
><para>
<inlinemediaobject
><imageobject>
<imagedata fileref="hi22-action-rocsalignvmiddle.png" format="PNG"/></imageobject>
</inlinemediaobject
> <guilabel
>Centré</guilabel
> : aligne les éléments de données par rapport à la position verticale donnée à partir du centre des positions verticales de tous les éléments de données sélectionnés. Cela affecte seulement les positions verticales.</para
></listitem>
<listitem
><para>
<inlinemediaobject
><imageobject>
<imagedata fileref="hi22-action-rocsalignbottom.png" format="PNG"/></imageobject>
</inlinemediaobject
> <guilabel
>Bas</guilabel
> : aligne les éléments de données par rapport à la position verticale de l'élément de données le plus bas. Cela affecte seulement les positions verticales.</para
></listitem>
<listitem
><para>
<inlinemediaobject
><imageobject>
<imagedata fileref="hi22-action-rocsalignleft.png" format="PNG"/></imageobject>
</inlinemediaobject
> <guilabel
>Gauche</guilabel
> : aligne les éléments de données par rapport à la position horizontale de l'élément de données le plus à droite. Cela affecte seulement les positions horizontales.</para
></listitem>
<listitem
><para>
<inlinemediaobject
><imageobject>
<imagedata fileref="hi22-action-rocsalignhmiddle.png" format="PNG"/></imageobject>
</inlinemediaobject
> <guilabel
>Centre</guilabel
> : aligne les éléments de données par rapport à la position horizontale de l'élément de données le plus à droite. Cela affecte seulement les positions horizontales.</para
></listitem>
<listitem
><para>
<inlinemediaobject
><imageobject>
<imagedata fileref="hi22-action-rocsalignright.png" format="PNG"/></imageobject>
</inlinemediaobject
> <guilabel
>Droite</guilabel
> : aligne les éléments de données par rapport à la position horizontale de l'élément de données le plus à droite. Cela affecte seulement les positions horizontales.</para
></listitem>
<listitem
><para>
<inlinemediaobject
><imageobject>
<imagedata fileref="hi22-action-rocsaligncircle.png" format="PNG"/></imageobject>
</inlinemediaobject
> <guilabel
>Cercle</guilabel
> : aligne les éléments de données sur un cercle de diamètre égal à la distance maximale des éléments de données. Ceux-ci sont positionnés dans le même ordre que donné par la vue réalisée à partir du centre de gravité de ces éléments de données.</para
></listitem>
<listitem
><para>
<inlinemediaobject
><imageobject>
<imagedata fileref="hi22-action-rocsaligntree.png" format="PNG"/></imageobject>
</inlinemediaobject
> <guilabel
>Minimiser les arêtes sécantes</guilabel
> : ré-organiser les éléments de données sélectionnés pour limiter le nom d'arêtes sécantes (application de l'algorithme de Fruchterman-Reingold).</para
></listitem>
</itemizedlist>
</sect2>
</sect1>

<sect1 id="user-interface-documents">
<title
>Travailler avec des documents de graphes</title>
<para
>Un projet &rocs; contient un ou plusieurs documents de graphe qui peuvent être modifiés avec l'éditeur visuel de graphe. De plus, chaque document peut contenir un nombre arbitraire de structures de données. Toutes les structures de données du document utilisent ici  le même moteur de structures de données. Cette section expliquera comment passer d'un document à un autre et comment en créer de nouveaux. </para>

<sect2 id="user-interface-documents-selector">
<title
>La barre de sélecteur de document</title>
<para
>La barre de sélecteur de documents est utilisée pour sélectionner le document courant de graphe et plus tard la structure de données courante. L'utilisation de l'éditeur visuel de graphe pour créer des éléments de structures de données ajoutera automatiquement ces éléments nouvellement créés  à la structure de données courante. De plus, cette barre fournit un accès direct à la suppression ou la création de nouvelles structures de données à l'intérieur du document courant. </para>

<itemizedlist>
<listitem
><para>
<inlinemediaobject
><imageobject>
<imagedata fileref="hi22-action-rocsnew.png" format="PNG"/></imageobject>
</inlinemediaobject
> <guilabel
>Nouveau</guilabel
> : cette action créé une nouvelles structure de données en utilisant une règle automatique de nommage fournie par le moteur de structure de données. La structure de données créée est ajoutée dans le document de graphe actuellement sélectionné. </para
></listitem>
<listitem
><para>
<inlinemediaobject
><imageobject>
<imagedata fileref="hi22-action-rocsdelete.png" format="PNG"/></imageobject>
</inlinemediaobject
> <guilabel
>Supprimer</guilabel
> : cette action supprime la structure de données actuellement sélectionnée dans le sélecteur de structure de données pour le document courant. </para
></listitem>
<listitem
><para>
<inlinemediaobject
><imageobject>
<imagedata fileref="hi22-action-rocsproperties.png" format="PNG"/></imageobject>
</inlinemediaobject
> <guilabel
>Propriétés de la structure de données</guilabel
> : ouvre une boîte de dialogue donnant accès aux propriétés de la structure de données. </para
></listitem>
<listitem
><para>
<inlinemediaobject
><imageobject>
<imagedata fileref="hi22-action-rocsproperties.png" format="PNG"/></imageobject>
</inlinemediaobject
> <guilabel
>Propriétés de document</guilabel
> : ouvre une boîte de dialogue donnant accès aux propriétés de document aussi bien qu'aux types de données et de pointeurs du document. </para
></listitem>
</itemizedlist>

<screenshot>
<screeninfo
>La barre principale d'outils.</screeninfo>
<mediaobject>
<imageobject>
<imagedata fileref="document-selector.png" format="PNG"/>
</imageobject>
<textobject>
<phrase
>La barre de sélecteur de documents.</phrase>
</textobject>
</mediaobject>
</screenshot>
</sect2>

<sect2 id="user-interface-documents-menu">
<title
>Créer et importer des documents de graphe</title>
<para
>Pour créer un nouveau document de graphe ou pour en ajouter un au projet, utilisez <menuchoice
><guimenu
>Projet</guimenu
> <guimenuitem
>Nouveau document de graphe</guimenuitem
></menuchoice
> ou <menuchoice
><guimenu
>Projet</guimenu
> <guimenuitem
>Importer un graphe &rocs;</guimenuitem
></menuchoice
>.  </para>
</sect2>

</sect1>
</chapter>

<chapter id="scripting">
<title
>Écriture et exécution d'algorithmes dans &rocs;</title>

<para
>&rocs; utilise en interne un moteur de langage de scripts « QtScript », qui est un moteur spécifique JavaScript. Cela signifie que tous les algorithmes que vous développez, doivent utiliser JavaScript. Le comment JavaScript fonctionne et comment écrire du code JavaScript ne sont pas traités dans ce manuel. Ainsi, ne sera expliqué que l'accès aux structures de données, aux éléments de données et aux pointeurs vers vos structures de données  à partir du moteur de langage de scripts. Puisque vous n'utilisez  jamais d'objets standards de structures de données mais uniquement un seul qui est fourni par le moteur de structure de données actuellement utilisé, la fonctionnalité de structure de données est étendue par le moteur associé et vous devriez prendre connaissance de la fonctionnalité spécifique. En particulier, les moteurs de structures de données utilisent des termes communs selon leurs domaines ( noeuds et arêtes dans les graphes, feuilles et racines dans les arborescences, etc. ) </para>
<para
>Il est important de savoir que les modifications faites par le moteur de langage de scripts sont directement reportées dans les propriétés de l'espace vide de l'éditeur visuel de graphe. Par conséquent, les scripts modifient en réalité les structures de données. </para>

<sect1 id="scripting-data-structure">
<title
>Les éléments basiques de structures de données </title>
<para
>Chaque moteur fournit un ensemble particulier de fonctions et de propriétés pour ses structures de données et leurs éléments. Mais, aussi, chaque moteur fournir les propriétés et les fonctions qui sont définies pour la structure de base de données standard. Par conséquent, tout ce qui est expliqué dans ces sections sont valables pour tout type de moteur de structure de données. </para>
<sect2
><title
>Propriétés basiques de structures de données</title>
<para
>Les structures de données sont identifiées par leurs noms. Si vous avez créé une structure de données avec le nom <literal
>test-graphe</literal
>, alors, vous pouvez y accéder simplement la référençant par son identifiant. Par exemple, si vous voulez obtenir un tableau contenant tous les éléments de données dans une structure de données particulière, vous pouvez écrire <literal
>test-graphe.list_nodes() ; </literal
> dans le script. </para>

<sect3>
<title
>Propriétés et fonctions basiques de structures de données</title>
<para
>Chaque structure de données <literal
>test-graphe</literal
> possède les propriétés suivantes qui peuvent être lues ou écrites par <literal
>test-graphe.property</literal
> : </para>
<programlisting
>nom de chaîne // identification de la structure de données
</programlisting>
</sect3>
</sect2>

<sect2>
<title
>Propriétés et fonctions basiques des éléments de données</title>
<para
>Chaque élément de données possède les propriétés suivantes qui peuvent être lues ou écrites : </para>
<programlisting
>double x      // coordonnée en x de la position courante 
    double y      // coordonnée en y de la position courant 
    double width  // taille 
    string value  // valeur 
    int id        // identifiant unique pour l'élément de données 
    string name   // nom 
    string color  // couleur en hexa-décimal
</programlisting>
<para
>De plus, chaque propriété dynamique d'un élément de données peut être adressée par son nom. </para>

<para
>Chaque objet d'élément de données fournit les méthodes suivantes : </para>
<programlisting
>int type() ;                         //  type de la donnée pour l'élément de données 
    int set_type(int) ;                  // défini le type de la donnée pour l'élément de données 
    void add_property(string name,      // ajoute une propriété dynamique à l'élément de données avec le nom et la valeur spécifié 
                      string value) ;
    array adj_data() ;                   // liste des données adjacentes 
    array adj_pointers() ;               // liste des pointeurs adjacents 
    array input_pointers() ;             // liste des pointeurs en entrée 
    array output_pointers() ;            // liste des pointeurs en sortie 
    array loop_pointers() ;              // liste des pointeurs formant une boucle 
    array connected_pointers(target) ;   // listes  des pointers pointant sur la « cible » 
    void  remove() ;                     // supprime cet élément de données
</programlisting>
</sect2>

<sect2>
<title
>Propriétés et fonction basiques de pointeur</title>
<para
>Chaque pointeur possède les propriétés suivantes qui peuvent être lues ou écrites : </para>
<programlisting
>string color  // couleur en hexa-décimal 
    string value  // valeur 
    string name   // nom 
    double width  // largeur 
    string style  // valeur parmi : pointillé, tiret, tiret-pointillé, pleine
</programlisting>
<para
>De plus, chaque propriété dynamique d'un pointeur peut être adressée par son nom. </para>

<para
>Chaque objet de pointeur fournit les méthodes suivantes : </para>
<programlisting
>int type() ;                         // type de pointeur de pointeur 
    int set_type(int) ;                  // définit le type de pointeur de pointeur 
    void add_property(string name,      // ajoute une propriété dynamique  à l'élément de données avec le nom et la valeur spécifié 
                      string value) ;
    node start() ;                       // noeud de début du pointeur 
    node end() ;                         // noeud cible du pointeur 
    void remove() ;                      // supprime ce pointer
</programlisting>
</sect2>
</sect1>

<sect1 id="scripting-backend-graph">
<title
>Le moteur de graphe</title>
<sect2>
<title
>Propriétés et fonctions du graphe</title>



<sect3>
<title
>Propriétés spécifiques du moteur de graphe</title>
<para
>La boîte de dialogue pour les propriétés de la structure de données donne accès à la configuration des paramètres spécifiques au moteur de graphe. A cet endroit là, avec <guilabel
>Type de graphe</guilabel
>, vous pouvez sélectionnez le type de graphe. La signification de ces types est la suivante : </para>
<itemizedlist>
    <listitem
><para
><guilabel
>Graphe</guilabel
> : graphe pour lequel les même arêtes (sauf les points de départ et de fin) ne peuvent exister en plusieurs exemplaires. </para
></listitem>
    <listitem
><para
><guilabel
>Multi-graphe</guilabel
> : graphe pour lequel les même arêtes (sauf les points de départ et de fin) peuvent exister en plusieurs exemplaires. </para
></listitem>
</itemizedlist>
</sect3>

<sect3>
<title
>La structure de graphe</title>
<para
>Pour un objet donné de structure de données de type « Graphe », vous pouvez utiliser les fonctions associées suivantes : </para>
<programlisting
>array list_nodes() ;                   // liste de tous les noeuds du graphe 
    array list_nodes(int type) ;           // liste de tous les noeuds du graphe d'un type donné 
    array list_edges() ;                   // liste de toutes les arêtes du graphe  
    array list_edges(int type) ;           // liste de toutes les arêtes du graphe d'un type donné  
    node add_node(name) ;                  // ajoute un nouveau noeud et le retourne 
    edge add_edge(node from, node to) ;    // ajoute une nouvelle arête de « from » à « to » et la retourne 
    array overlay_edges(int overlayID) ;   // liste de toutes les arêtes  d'un circuit donné 
    edge add_overlay_edge(node from,
                          node to,
                          int overlayID) ; // ajoute une arête d'un type de pointeur donné dans un circuit spécifique
</programlisting>
</sect3>

<sect3>
<title
>Noeuds de graphe</title>
<para
>Pour un objet donné de structure de données de type « graphe », vous pouvez utiliser les fonctions associées suivantes sur les noeuds du graphe en addition aux propriétés fournies par les éléments de données :  </para>
<programlisting
>array adj_nodes() ;                    // listes de tous les noeuds  adjacents 
    array adj_edges() ;                    // liste de toutes les arêtes connectées 
    array input_edges() ;                  // liste des arêtes en entrée  
    array output_edges() ;                 // liste des arêtes en sortie 
    array loop_edges() ;                   // liste  de toutes les arêtes arrivant sur le noeud 
    array connected_edges(node target) ;   // toutes arêtes qui  connecte cenoeud au noeud « target »
</programlisting>
</sect3>

<sect3>
<title
>Arêtes de graphe</title>
<para
>Pour des arêtes particulières de structure de données de type « graphe », seules les propriétés standards de la structure de données sont disponibles. </para>
</sect3>
</sect2>

<sect2>
<title
>Algorithmes de structure de graphe</title>
<para
>Le moteur de graphe fournit certaines fonctions spéciales qui peuvent être utilisées à partir du moteur d'écriture de scripts.</para>
<variablelist>
<varlistentry>
<term
>Calcul du trajet le plus court</term>
<listitem>
    <para
>Calcule le trajet le plus court entre les noeuds <emphasis
>début</emphasis
> et <emphasis
>fin</emphasis
>. Les deux noeuds doivent appartenir au même graphe. Ce calcul tient compte du fait que le graphe soit orienté ou non orienté.</para>
    <funcsynopsis>
    <funcprototype
><funcdef
>tableau <function
>dijkstra-trajet-le-plus-cour</function
></funcdef
> <paramdef
>noeud <parameter
><replaceable
>début</replaceable
></parameter
></paramdef
><paramdef
>noeud<parameter
><replaceable
>fin</replaceable
></parameter
></paramdef
> </funcprototype>
    </funcsynopsis>
</listitem>
</varlistentry>
<varlistentry>
<term
>Longueur du trajet la plus courte</term>
<listitem>
    <para
>Calcule le trajet le plus court entre les sommets <emphasis
>début</emphasis
> et <emphasis
>fin</emphasis
> en passant par tous les autres noeuds du graphe. Ce calcul tient compte du fait que le graphe soit orienté ou non orienté.</para>
    <funcsynopsis>
    <funcprototype
><funcdef
>tableau<function
>distances</function
></funcdef
> <paramdef
>noeud<parameter
><replaceable
>début</replaceable
></parameter
></paramdef
> </funcprototype>
    </funcsynopsis>
</listitem>
</varlistentry>
</variablelist>
</sect2>
</sect1>

<sect1 id="scripting-backend-linkedlist">
<title
>Le moteur pour les listes chaînées</title>
<sect2>
<title
>Propriétés et fonctions pour les listes chaînées</title>

<sect3>
<title
>La structure de liste chaînée</title>
<para
>Pour un objet de structure de données de type « liste chaînée », vous pouvez appeler les fonctions de ce type suivantes : </para>
<programlisting
>node begin() ;                           // fournit le noeud de tête de la liste chaînée 
    setBegin(node begin) :                   // définit le noeud « début » comme le début de la liste et réordonne la liste 
    createNode() ;                           // créer un nouveau noeud de la liste
</programlisting>
</sect3>

<sect3>
<title
>Noeuds de liste chaînée</title>
<para
>Pour un objet de structure de données de type « liste chaînée », vous pouvez utiliser les fonctions associées suivantes sur les noeuds de graphe en addition aux propriétés fournies par les éléments de données :  </para>
<programlisting
>node front() ;                           // retourne le prédécesseur du noeud
</programlisting>
</sect3>

<sect3>
<title
>Arêtes de liste chaînée</title>
<para
>Pour des arêtes de structure de données de type « liste chaînée », seules les propriétés standards de la structure de données sont disponibles. </para>
</sect3>
</sect2>
</sect1>

<sect1 id="scripting-backend-rootedtree">
<title
>Le moteur pour arborescence</title>
<sect2>
<title
>Propriétés et fonctions d'arborescence</title>

<sect3>
<title
>Moteur pour arborescence</title>
<para
>La boîte de dialogue des propriétés de structure de données vous permet de configurer les paramètres  spécifiques pour le moteur de graphe. A cet endroit, la sélection du paramètre <guilabel
>Afficher tous les pointeurs</guilabel
> conduit à l'affichage de tous les pointeurs entre les noeuds de l'arborescence. S'il n'est pas sélectionné, les pointeurs multiples entre les même noeuds sont regroupés en un seul. </para>
</sect3>

<sect3>
<title
>La structure d'arborescence</title>
<para
>Pour un objet donné de structure de données de type « Arborescence », les propriétés suivantes peuvent être lues ou écrites : </para>
<programlisting
>ShowAllPointers     // positionné à Vrai si affichage de toutes les arêtes, positionné à Faux si les arêtes multiples doivent être regroupées
</programlisting>
<para
>Pour un objet donné de structure de données de type « Arborescence », vous pouvez appeler les fonctions associées suivantes :  </para>
<programlisting
>node add_data(string name) ;         // ajoute un noeud à l'arborescence avec un nom donné 
    void set_root_node(node root) ;      // définit le noeud comme la racine de l'arborescence 
    node root_node() ;                   // retourne la racine de l'arborescence
</programlisting>
</sect3>

<sect3>
<title
>Noeuds d'arborescence</title>
<para
>Pour un objet donné de noeud de type « Arborescence », les propriétés suivantes peuvent être lues ou écrites : </para>
<programlisting
>int numberOfChilds                  // définit le nombre d'enfants (autorisés) pour ce noeud 
    node left_child                     // lecture seule : noeud qui est le fils à gauche 
    node right_child                    // lecture seule : noeud qui est le fils à droite 
    node node_parent                    // lecture seule : noeud qui est le parent
</programlisting>
<para
>Pour un objet donné de noeud de type « Arborescence », vous pouvez appeler les fonctions associées suivantes :  </para>
<programlisting
>node add_left_child(node child) ;    // ajoute un fils à gauche 
    node add_right_child(node child) ;   // ajoute un fils à droite 
    node add_child(node child, int i) ;  // ajoute un fils comme i ième fils du noeud 
    node add_node_parent(node child) ;   // ajoute un parent (ne fonctionne que s'il a pas encore de parent défini) 
    node left_child() ;                  // retourne le fils de gauche 
    node right_child() ;                 // retourne le fils de droite 
    node child_at(int i) ;               // return the i-th child of the node
    node node_parent() ;                 // retourne le noeud parent
</programlisting>
</sect3>

<sect3>
<title
>Arêtes d'arborescence</title>
<para
>Pour des arêtes particulières de structure de données de type « Arborescence », seules les propriétés standards de la structure de données sont disponibles. </para>
</sect3>
</sect2>
</sect1>

<sect1 id="scripting-controls">
<title
>Contrôle de l'exécution de script</title>
 

<sect2>
<title
>Inclure les fichiers</title>
<para
>Vos documents de scripts peuvent inclure d'autres scripts. Ceci peut être utilise pour réduire la taille des documents de scripts et améliorer leur lisibilité. En utilisant <menuchoice
><guimenu
>Document de scripts</guimenu
> <guimenuitem
>Inclut potentiellement</guimenuitem
></menuchoice
>, vous pouvez obtenir une liste des fichiers de scripts déjà fournis avec &rocs; et qui pourraient être utilisés. Vous pouvez intégrer un fichier de script avec la commande suivante : </para>
<programlisting
>include_script(string path) ;            // emplacement relatif ou absolu vers le fichier de script
</programlisting>
</sect2>

<sect2 id="scripting-output">
<title
>Sortie du script</title>
<para
>Durant l'exécution d'un algorithme, les sorties du débogage et du programme sont affichés dans la <emphasis
>Sortie de débogage et de script</emphasis
>. Si le moteur de langage de scripts détecte une erreur de syntaxe dans votre script, l'erreur est aussi affichée comme un message de débogage. Veuillez noter que tous les messages du programme sont aussi affichés sur la sortie de débogage (affiché comme du texte en gras). </para>
<para
>Vous pouvez contrôler le texte qui est affiché par la sortie du script par les fonctions suivantes : </para>
<programlisting
>output(string message) ;            // affiche le message comme une sortie du script 
    debug(string message) ;             // affiche le message comme une sortie de débogage
</programlisting>
</sect2>

<sect2 id="scripting-controlling">
<title
>Contrôle de l'exécution de script</title>
<para
>Il y a différents modes d'exécution pour vos scripts. </para>
<para
>Vous pouvez contrôler le texte qui est affiché par la sortie du script par les fonctions suivantes : </para>
<itemizedlist>
    <listitem
><para>
        <inlinemediaobject
><imageobject>
        <imagedata fileref="rocs-control-engine-run.png" format="PNG"/></imageobject>
</inlinemediaobject
> <guilabel
>Démarrer</guilabel
> : exécute le script jusqu'à ce qu'il se termine.</para
></listitem>
    <listitem
><para>
        <inlinemediaobject
><imageobject>
        <imagedata fileref="rocs-control-engine-stop.png" format="PNG"/></imageobject>
</inlinemediaobject
> <guilabel
>Arrêter</guilabel
> : arrêter l'exécution du script (disponible uniquement si le script est en cours d'exécution).</para
></listitem>
    <listitem
><para>
        <inlinemediaobject
><imageobject>
        <imagedata fileref="rocs-control-engine-step.png" format="PNG"/></imageobject>
</inlinemediaobject
> <guilabel
>Pas à pas</guilabel
> : exécute un script jusqu'à ce qu'un pas soit exécuté. Un pas s'arrête quand le script appelle la fonction <literal
>interrupt()</literal
> : </para>
    <programlisting
>interrupt() ;    // termine un pas
    </programlisting>
    </listitem>
    <listitem
><para>
        <inlinemediaobject
><imageobject>
        <imagedata fileref="rocs-control-engine-debug.png" format="PNG"/></imageobject>
</inlinemediaobject
> <guilabel
>Débogage</guilabel
> : exécute un script dans le mode de débogage. Cela ouvre une fenêtre de dialogue QtScript pour débogage.</para
></listitem>
</itemizedlist>
</sect2>
</sect1>
</chapter>

<chapter id="import-export">
<title
>Importer et Exporter</title>
<sect1 id="import-export-projects">
    <title
>Échanger des projets &rocs;</title>
    <para
>Les projets &rocs; peuvent être importés et exportés sous forme de fichiers d'archives <literal
>.tar.gz</literal
>. Ces archives peuvent servir pour s'échanger des projets. Les importations et exportations peuvent se faire respectivement avec <menuchoice
><guimenu
>Fichier</guimenu
> <guimenuitem
>Importer le project</guimenuitem
></menuchoice
> and <menuchoice
><guimenu
>Fichier</guimenu
> <guimenuitem
>Exporter le project</guimenuitem
></menuchoice
>. </para>
</sect1>

<sect1 id="import-export-graphs">
    <title
>Importer et Exporter des documents de graphe</title>
    <para
>&rocs; prend en charge actuellement l'import et l'export pour les formats de fichier suivants :</para>
    <itemizedlist>
        <listitem
><para
>Fichiers DOT, aussi connus sous le nom de fichiers Graphviz</para
></listitem>
        <listitem
><para
>Fichiers GML</para
></listitem>
        <listitem
><para
>Fichiers au format de graphe Trivial</para
></listitem>
    </itemizedlist>

<sect2 id="format-specification-tgf">
<title
>Format de fichier de graphe Trivial</title>
<para
>Le <emphasis
>Trivial Graph Format</emphasis
> (TGF) est un format de fichier construit sur du texte simple pour décrire des graphes. Un fichier TGF consiste en une liste de définition de noeuds, qui fait correspondre des identifiants de noeuds à des étiquettes, suivie par une liste d'arêtes. Dans ce format, il n'est possible de n'avoir qu'un label par noeud et une valeur par arête. &rocs; interprète les graphes importés comme des graphes non dirigés. Les graphes exportés contiendront deux arêtes par connexion si les connexions sont bi-directionnelles. </para>

<sect3>
<title
>Spécification de format</title>
    <itemizedlist>
        <listitem
><para
>Le fichier débute par une liste de noeuds (un noeud par ligne), suivi par une ligne avec uniquement le caractère « # », suivi par une liste d'arêtes (une arête par ligne).</para
></listitem>
        <listitem
><para
>Un noeud consiste en un entier (identifiant), suivi par un espace et suivi par une chaîne arbitraire.</para
></listitem>
        <listitem
><para
>Une arête consiste en deux entiers (identifiants) séparés par une espace, suivie par une espace, suivie par une chaîne arbitraire. Par hypothèse, l'arête dirigée va du premier identifiant vers le second. </para
></listitem>
    </itemizedlist>
</sect3>
<sect3>
<title
>Exemple</title>
<programlisting
>1 noeud de départ
2 transmetteur 
3 récepteur 
#
1 2 bleu 
2 1 rouge 
2 3 vert
</programlisting>
</sect3>
</sect2>

<sect2 id="format-specification-dot">
<title
>Langage DOT / Format de fichier de graphe Graphviz</title>
<para
>Le langage DOT est un langage de description de graphe en texte brute qui permet à la fois une représentation correcte, lisible par un humain, de graphe et aussi, un traitement efficace par des programmes de mise en forme de graphes. DOT est le format de fichiers par défaut pour la suite d'affichage de graphes Graphviz. Mais, il est aussi largement utilisé par d'autres outils de graphe. Les extensions classiques des fichiers pour DOT sont <emphasis
>.gv</emphasis
> et <emphasis
>.dot</emphasis
>. </para>

<sect3>
<title
>Fonctionnalités non prises en charge</title>
<para
>&rocs; peut traiter tout fichier de graphe qui contient un graphe possédant une spécification en langage DOT <footnote
><para
>http://www.graphviz.org/content/dot-language</para
></footnote
>. La prise en charge des fonctionnalités du langage est complète, malgré les restrictions suivantes :  </para>
    <itemizedlist>
        <listitem
><para
>sous-graphe : à cause de manques dans la notion de sous-graphe dans &rocs;, ceux-co ne sont importés que comme ensemble d'éléments et de connexion de données. En particulier, les connexions vers ou à partir de sous-graphes ne sont pas importés.</para
></listitem>
        <listitem
><para
>Attributs &HTML; et &XML; : les attributs (comme les étiquettes) qui contiennent des syntaxes &HTML; ou &XML; sont lus tel quel. En particulier, aucune modification de polices et de styles n'est faite sur ces attributs.</para
></listitem>
    </itemizedlist>
</sect3>
<sect3>
<title
>Exemple</title>
<programlisting
>digraph myGraph {
    a -> b -> c;
    b -> d;
}
</programlisting>
</sect3>
</sect2>

</sect1>
</chapter>

<chapter id="credits">
<title
>Remerciements et licence</title>

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

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

<para
>Traduction française par &XavierBesnard;, Antoine Balestrat <email
>merkil33@gmail.com</email
>.</para
>  
&underFDL; &underGPL; </chapter>

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

<sect1 id="getting-rocs">
<title
>Comment obtenir &rocs;</title>
&install.intro.documentation; </sect1>

<sect1 id="compilation">
<title
>Compilation et 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:
-->
