Defined a new and simpler way to produce graphical view of basic blocks.

18 files changed, 1461 insertions, 5096 deletions

diff --git a/src/gtkext/graph/Makefile.am b/src/gtkext/graph/Makefile.am
index f54a97b..706811b 100755..100644
--- a/src/gtkext/graph/Makefile.am
+++ b/src/gtkext/graph/Makefile.am
@@ -2,14 +2,10 @@
 noinst_LTLIBRARIES  = libgtkextgraph.la
 
 libgtkextgraph_la_SOURCES =				\
-	edge.h edge.c						\
-	layout.h layout.c					\
-	node.h node.c						\
-	params.h							\
-	ranks.h ranks.c
+	cluster.h cluster.c					\
+	edge.h edge.c
 
-libgtkextgraph_la_LIBADD = 				\
-	nodes/libgtkextgraphnodes.la
+libgtkextgraph_la_LIBADD =
 
 libgtkextgraph_la_LDFLAGS =
 
@@ -18,4 +14,4 @@ AM_CPPFLAGS = $(LIBGTK_CFLAGS) $(LIBXML_CFLAGS)
 
 AM_CFLAGS = $(DEBUG_CFLAGS) $(WARNING_FLAGS) $(COMPLIANCE_FLAGS)
 
-SUBDIRS = nodes
+SUBDIRS =
diff --git a/src/gtkext/graph/cluster.c b/src/gtkext/graph/cluster.c
new file mode 100644
index 0000000..4c92718
--- /dev/null
+++ b/src/gtkext/graph/cluster.c
@@ -0,0 +1,1330 @@
+
+/* Chrysalide - Outil d'analyse de fichiers binaires
+ * cluster.c - mise en place de graphiques
+ *
+ * Copyright (C) 2016 Cyrille Bagard
+ *
+ *  This file is part of Chrysalide.
+ *
+ *  OpenIDA is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  OpenIDA is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Foobar.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#include "cluster.h"
+
+
+#include <assert.h>
+#include <malloc.h>
+#include <string.h>
+
+
+#include "../gtkblockview.h"
+#include "../gtkbufferview.h"
+#include "../gtkviewpanel.h"
+#include "../../common/sort.h"
+
+
+
+/* Définition du tracé d'un lien */
+typedef struct _link_def
+{
+    InstructionLinkType type;               /* Complexité du tracé         */
+
+    GdkPoint y;                             /* Position des décrochages    */
+
+    GdkPoint end;                           /* Point d'arrivée final       */
+
+    GGraphEdge *edge;                       /* Lien complet en préparation */
+
+} link_def;
+
+/* Découpage vertical */
+typedef struct _graph_rank
+{
+    unsigned int level;                     /* Niveau des blocs            */
+
+    GGraphCluster **clusters;               /* Ensembles de blocs          */
+    size_t count;                           /* Nombre de ces ensembles     */
+
+} graph_rank;
+
+/* Mise en disposition de blocs en graphique (instance) */
+struct _GGraphCluster
+{
+    GObject parent;                         /* A laisser en premier        */
+
+
+    ////////////////////////////////////////
+    gint top_margin[2];                     /* Espaces gauches et droites  */
+    gint left_margin;                       /* Espaces remontant à gauche  */
+    gint right_margin;                      /* Espaces remontant à droite  */
+    ////////////////////////////////////////
+
+
+    link_def **top_anchors;                 /* Accroches supérieures       */
+    size_t ta_count;                        /* Quantité de ces accroches   */
+
+    GBasicBlock *block;                     /* Bloc d'origine représenté   */
+    GtkWidget *view;                        /* Vue graphique associée      */
+    GtkAllocation alloc;                    /* Emplacement final du bloc   */
+
+    GdkPoint **bottom_anchors;              /* Accroches inférieures       */
+    size_t ba_count;                        /* Quantité de ces accroches   */
+
+    graph_rank *ranks;                      /* Répartition verticale       */
+    size_t ranks_count;                     /* Nombre de divisions         */
+
+};
+
+/* Mise en disposition de blocs en graphique (classe) */
+struct _GGraphClusterClass
+{
+    GObjectClass parent;                    /* A laisser en premier        */
+
+};
+
+
+/* Espace minimal horizontal entre les blocs */
+#define HORIZONTAL_MARGIN 20
+
+/* Espace minimal vertical entre les blocs */
+#define VERTICAL_MARGIN 30
+
+/* Espace minimal entre les liens */
+#define LINK_MARGIN 10
+
+
+/* Initialise la classe des mises en disposition graphique. */
+static void g_graph_cluster_class_init(GGraphClusterClass *);
+
+/* Initialise une mise en disposition de blocs en graphique. */
+static void g_graph_cluster_init(GGraphCluster *);
+
+/* Supprime toutes les références externes. */
+static void g_graph_cluster_dispose(GGraphCluster *);
+
+/* Procède à la libération totale de la mémoire. */
+static void g_graph_cluster_finalize(GGraphCluster *);
+
+/* Complète un graphique avec un sous-ensemble de blocs. */
+static void g_graph_cluster_add_sub(GGraphCluster *, GGraphCluster *, GBasicBlock *);
+
+/* Organisation la disposition d'un ensemble de blocs basiques. */
+static void g_graph_cluster_dispatch_x(GGraphCluster *);
+
+/* Détermine une position pour un ensemble de blocs basiques. */
+//static void g_graph_cluster_set_x(GGraphCluster *, gint);
+
+/* Décalle vers la droite un ensemble de blocs basiques. */
+static void g_graph_cluster_offset_x(GGraphCluster *, gint);
+
+/* Décalle vers le bas un ensemble de blocs basiques. */
+static void g_graph_cluster_set_y(GGraphCluster *, gint);
+
+
+
+
+
+/* Recherche le bloc basique à l'extrémité d'un lien. */
+//static GGraphCluster *g_graph_cluster_find_lower_dest_cluster(const GGraphCluster *, const GArchInstruction *);
+
+/* Met en place les embryons de liens nécessaires. */
+static void g_graph_cluster_define_links(GGraphCluster *, GHashTable *);
+
+/* Détermine les positions de tous les liens en place. */
+static void g_graph_cluster_compute_link_positions(GGraphCluster *);
+
+/* Applique les positions calculées pour chaque lien graphique. */
+static void g_graph_cluster_resolve_links(const GGraphCluster *);
+
+
+
+
+
+
+/* Indique le type définit par la GLib pour les mises en disposition graphique. */
+G_DEFINE_TYPE(GGraphCluster, g_graph_cluster, G_TYPE_OBJECT);
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : klass = classe à initialiser.                                *
+*                                                                             *
+*  Description : Initialise la classe des mises en disposition graphique.     *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_graph_cluster_class_init(GGraphClusterClass *klass)
+{
+    GObjectClass *object;                   /* Autre version de la classe  */
+
+    object = G_OBJECT_CLASS(klass);
+
+    object->dispose = (GObjectFinalizeFunc/* ! */)g_graph_cluster_dispose;
+    object->finalize = (GObjectFinalizeFunc)g_graph_cluster_finalize;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : cluster = instance à initialiser.                            *
+*                                                                             *
+*  Description : Initialise une mise en disposition de blocs en graphique.    *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_graph_cluster_init(GGraphCluster *cluster)
+{
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : cluster = instance d'objet GLib à traiter.                   *
+*                                                                             *
+*  Description : Supprime toutes les références externes.                     *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_graph_cluster_dispose(GGraphCluster *cluster)
+{
+    g_object_unref(G_OBJECT(cluster->block));
+    g_object_unref(G_OBJECT(cluster->view));
+
+    G_OBJECT_CLASS(g_graph_cluster_parent_class)->dispose(G_OBJECT(cluster));
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : cluster = instance d'objet GLib à traiter.                   *
+*                                                                             *
+*  Description : Procède à la libération totale de la mémoire.                *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_graph_cluster_finalize(GGraphCluster *cluster)
+{
+    G_OBJECT_CLASS(g_graph_cluster_parent_class)->finalize(G_OBJECT(cluster));
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : binary      = binaire charger dont le code est à représenter.*
+*                list        = ensemble de blocs basiques à manipuler.        *
+*                index       = indice du bloc principal à mettre en place.    *
+*                highlighted = gestionnaire de surbrillance pour segments.    *
+*                                                                             *
+*  Description : Construit un graphique à partir de blocs basiques.           *
+*                                                                             *
+*  Retour      : Adresse de la structure mise en place.                       *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GGraphCluster *g_graph_cluster_new(GLoadedBinary *binary, const GBlockList *list, size_t index, segcnt_list *highlighted)
+{
+    GGraphCluster *result;                  /* Structure à retourner       */
+    vmpa2t first;                           /* Début d'un groupe de lignes */
+    vmpa2t last;                            /* Fin d'un groupe de lignes   */
+    GCodeBuffer *buffer;                    /* Tampon brut à découper      */
+    GBufferView *view;                      /* Partie affichée du tampon   */
+    GtkRequisition requisition;             /* Taille à l'écran actuelle   */
+
+    result = g_object_new(G_TYPE_GRAPH_CLUSTER, NULL);
+
+    /* Encapsulation du bloc d'entrée */
+
+    result->block = g_block_list_get_block(list, index);
+    g_object_ref(G_OBJECT(result->block));
+
+    result->view = gtk_block_view_new();
+
+    gtk_widget_show(result->view);
+    gtk_view_panel_attach_binary(GTK_VIEW_PANEL(result->view), binary, BVW_GRAPH);
+
+    gtk_view_panel_show_border(GTK_VIEW_PANEL(result->view), true);
+
+    /* Restriction au bloc basique */
+
+    g_basic_block_get_boundary_addresses(result->block, &first, &last);
+
+    buffer = g_loaded_binary_get_disassembled_buffer(binary);
+
+    view = g_buffer_view_new(buffer, highlighted);
+    g_buffer_view_restrict(view, &first, &last);
+    gtk_buffer_view_attach_buffer(GTK_BUFFER_VIEW(result->view), view);
+
+    /* Détermination d'une position initiale centrée */
+
+    gtk_widget_get_preferred_size(result->view, NULL, &requisition);
+
+    result->alloc.x = -requisition.width / 2;
+    result->alloc.y = 0;
+
+    result->alloc.width = requisition.width;
+    result->alloc.height = requisition.height;
+
+    printf("BLOCK INIT :: %d <> %d\n", result->alloc.x, result->alloc.width);
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : cluster = graphique de blocs à compléter.                    *
+*                sub     = sous-ensemble à intégrer.                          *
+*                block   = bloc basique de départ du sous-ensemble.           *
+*                                                                             *
+*  Description : Complète un graphique avec un sous-ensemble de blocs.        *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_graph_cluster_add_sub(GGraphCluster *cluster, GGraphCluster *sub, GBasicBlock *block)
+{
+    unsigned int level;                     /* Niveau du nouvel ensemble   */
+    size_t i;                               /* Boucle de parcours          */
+    graph_rank new;                         /* Nouvel étage à insérer      */
+    graph_rank *rank;                        /* Nouvel étage à compléter     */
+
+    level = g_basic_block_get_rank(block);
+
+    for (i = 0; i < cluster->ranks_count; i++)
+        if (cluster->ranks[i].level == level)
+            break;
+
+    if (i == cluster->ranks_count)
+    {
+        new.level = level;
+
+        new.clusters = (GGraphCluster **)calloc(1, sizeof(GGraphCluster *));
+        new.count = 1;
+
+        new.clusters[0] = sub;
+
+        int cmp_graph_rank(const graph_rank *a, const graph_rank *b)
+        {
+            if (a->level < b->level)
+                return -1;
+
+            else if (a->level > b->level)
+                return 1;
+
+            else
+                return 0;
+
+        }
+
+        cluster->ranks = qinsert(cluster->ranks, &cluster->ranks_count,
+                                 sizeof(graph_rank), (__compar_fn_t)cmp_graph_rank, &new);
+
+    }
+
+    else
+    {
+        rank = &cluster->ranks[i];
+
+        rank->count++;
+        rank->clusters = (GGraphCluster **)realloc(rank->clusters,
+                                                   sizeof(GGraphCluster *) * rank->count);
+
+        rank->clusters[rank->count - 1] = sub;
+
+    }
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : cluster = graphique de blocs à manipuler.                    *
+*                                                                             *
+*  Description : Organisation la disposition d'un ensemble de blocs basiques. *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_graph_cluster_dispatch_x(GGraphCluster *cluster)
+{
+    size_t k;                               /* Boucle de parcours #1       */
+    size_t rcount;                          /* Nombre d'ensembles présents */
+    size_t mid;                             /* Position centrale de départ */
+    gint start;                             /* Position initiale de départ */
+
+    void place_sub(GGraphCluster **iter, size_t loop, gint base, int dir)
+    {
+        size_t i;                           /* Boucle de parcours #2       */
+        GtkAllocation needed;               /* Taille requise              */
+
+        assert(dir == -1 || dir == 1);
+
+        for (i = 0; i < loop; i++, iter += dir)
+        {
+            g_graph_cluster_dispatch_x(*iter);
+
+            g_graph_cluster_compute_needed_alloc(*iter, &needed);
+
+            if (dir > 0)
+                g_graph_cluster_offset_x(*iter, base - needed.x);
+            else
+                g_graph_cluster_offset_x(*iter, base - needed.x - needed.width);
+
+            base += dir * (needed.width + HORIZONTAL_MARGIN);
+
+        }
+
+    }
+
+
+
+
+    for (k = 0; k < cluster->ranks_count; k++)
+    {
+        rcount = cluster->ranks[k].count;
+
+        if (rcount % 2 == 1)
+        {
+            if (rcount > 1)
+            {
+                mid = rcount / 2;
+
+                start = cluster->ranks[k].clusters[mid]->alloc.x - HORIZONTAL_MARGIN;
+
+                place_sub(cluster->ranks[k].clusters + mid - 1, mid, start, -1);
+
+                start *= -1;
+
+                place_sub(cluster->ranks[k].clusters + mid + 1, mid, start, 1);
+
+            }
+
+        }
+
+        else
+        {
+            mid = rcount / 2 - 1;
+
+            start = - HORIZONTAL_MARGIN / 2;
+
+            place_sub(cluster->ranks[k].clusters + mid, mid + 1, start, -1);
+
+            start *= -1;
+
+            place_sub(cluster->ranks[k].clusters + mid + 1, mid + 1, start, 1);
+
+        }
+
+    }
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : cluster = graphique de blocs à actualiser.                   *
+*                x       = position finale sur l'axe des abscisses.           *
+*                                                                             *
+*  Description : Détermine une position pour un ensemble de blocs basiques.   *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+/*
+static void g_graph_cluster_set_x(GGraphCluster *cluster, gint x)
+{
+    g_graph_cluster_offset_x(cluster, -cluster->alloc.x);
+
+    g_graph_cluster_offset_x(cluster, x);
+
+}
+*/
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : cluster = graphique de blocs à actualiser.                   *
+*                offset  = décallage à appliquer.                             *
+*                                                                             *
+*  Description : Décalle vers la droite un ensemble de blocs basiques.        *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_graph_cluster_offset_x(GGraphCluster *cluster, gint offset)
+{
+    size_t i;                               /* Boucle de parcours #1       */
+    size_t j;                               /* Boucle de parcours #2       */
+
+    cluster->alloc.x += offset;
+
+    for (i = 0; i < cluster->ranks_count; i++)
+        for (j = 0; j < cluster->ranks[i].count; j++)
+            g_graph_cluster_offset_x(cluster->ranks[i].clusters[j], offset);
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : cluster = graphique de blocs à actualiser.                   *
+*                base    = position ordonnée à appliquer.                     *
+*                                                                             *
+*  Description : Décalle vers le bas un ensemble de blocs basiques.           *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_graph_cluster_set_y(GGraphCluster *cluster, gint base)
+{
+    size_t i;                               /* Boucle de parcours #1       */
+    gint max;                               /* Hauteur maximale rencontrée */
+    size_t j;                               /* Boucle de parcours #2       */
+    GGraphCluster *sub;                     /* Sous-ensemble traité        */
+    GtkAllocation alloc;                    /* Allocation courante         */
+
+    cluster->alloc.y = base;
+
+    base += cluster->alloc.height;
+
+    for (i = 0; i < cluster->ranks_count; i++)
+    {
+        base += VERTICAL_MARGIN;
+
+        max = 0;
+
+        for (j = 0; j < cluster->ranks[i].count; j++)
+        {
+            sub = cluster->ranks[i].clusters[j];
+
+            g_graph_cluster_set_y(sub, base);
+
+            g_graph_cluster_compute_needed_alloc(sub, &alloc);
+
+            if ((alloc.y + alloc.height) > max)
+                max = alloc.y + alloc.height;
+
+        }
+
+        base = max;
+
+    }
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : cluster = encapsulation à consulter.                         *
+*                alloc   = emplacement idéal pour l'affichage.                *
+*                                                                             *
+*  Description : Détermine l'emplacement requis d'un ensemble de blocs.       *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+void g_graph_cluster_compute_needed_alloc(const GGraphCluster *cluster, GtkAllocation *alloc)
+{
+    GtkAllocation needed;                   /* Taille requise              */
+    size_t i;                               /* Boucle de parcours          */
+    size_t rcount;                          /* Nombre d'ensembles présents */
+
+    *alloc = cluster->alloc;
+
+    for (i = 0; i < cluster->ranks_count; i++)
+    {
+        rcount = cluster->ranks[i].count;
+
+        switch (rcount)
+        {
+            case 1:
+
+                g_graph_cluster_compute_needed_alloc(cluster->ranks[i].clusters[0], &needed);
+
+                if (needed.x < alloc->x)
+                {
+                    alloc->width += (alloc->x + needed.x);
+                    alloc->x = needed.x;
+                }
+
+                if ((needed.x + needed.width) > (alloc->x + alloc->width))
+                    alloc->width += needed.x + needed.width - alloc->x - alloc->width;
+
+                /* La hauteur maximale n'est présente qu'avec le dernier morceau */
+                if ((i + 1) == cluster->ranks_count)
+                {
+                    if ((needed.y + needed.height) > (alloc->y + alloc->height))
+                        alloc->height += needed.y + needed.height - alloc->y - alloc->height;
+                }
+
+                break;
+
+            default:
+
+                assert(rcount >= 2);
+
+                g_graph_cluster_compute_needed_alloc(cluster->ranks[i].clusters[0], &needed);
+
+                if (needed.x < alloc->x)
+                {
+                    alloc->width += (alloc->x + needed.x);
+                    alloc->x = needed.x;
+                }
+
+                /* La hauteur maximale n'est présente qu'avec le dernier morceau */
+                if ((i + 1) == cluster->ranks_count)
+                {
+                    if ((needed.y + needed.height) > (alloc->y + alloc->height))
+                        alloc->height += needed.y + needed.height - alloc->y - alloc->height;
+                }
+
+                g_graph_cluster_compute_needed_alloc(cluster->ranks[i].clusters[rcount - 1], &needed);
+
+                if ((needed.x + needed.width) > (alloc->x + alloc->width))
+                    alloc->width += needed.x + needed.width - alloc->x - alloc->width;
+
+                /* La hauteur maximale n'est présente qu'avec le dernier morceau */
+                if ((i + 1) == cluster->ranks_count)
+                {
+                    if ((needed.y + needed.height) > (alloc->y + alloc->height))
+                        alloc->height += needed.y + needed.height - alloc->y - alloc->height;
+                }
+
+                break;
+
+        }
+
+    }
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : cluster = encapsulation à traiter.                           *
+*                view    = support de destination finale.                     *
+*                                                                             *
+*  Description : Dispose chaque noeud sur la surface de destination donnée.   *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+void g_graph_cluster_place(GGraphCluster *cluster, GtkGraphView *view)
+{
+    size_t i;                               /* Boucle de parcours #1       */
+    size_t j;                               /* Boucle de parcours #2       */
+
+    g_object_ref(G_OBJECT(cluster->view));
+    gtk_graph_view_put(view, cluster->view, &cluster->alloc);
+
+    for (i = 0; i < cluster->ta_count; i++)
+    {
+        g_object_ref(G_OBJECT(cluster->top_anchors[i]->edge));
+        gtk_graph_view_add_edge(view, cluster->top_anchors[i]->edge);
+    }
+
+    for (i = 0; i < cluster->ranks_count; i++)
+        for (j = 0; j < cluster->ranks[i].count; j++)
+            g_graph_cluster_place(cluster->ranks[i].clusters[j], view);
+
+}
+
+
+
+
+
+
+
+
+//////////////////////////////////////////////////////////
+
+
+
+
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : cluster = graphique de blocs à consulter ou remonter.        *
+*                first   = première instruction du bloc basique recherché.    *
+*                                                                             *
+*  Description : Recherche le bloc basique à l'extrémité d'un lien.           *
+*                                                                             *
+*  Retour      : Bloc graphique de destination pour un lien ou NULL si échec. *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+#if 0
+static GGraphCluster *g_graph_cluster_find_lower_dest_cluster(const GGraphCluster *cluster, const GArchInstruction *first)
+{
+    GGraphCluster *result;                  /* Trouvaille à retourner      */
+    size_t i;                               /* Boucle de parcours #1       */
+    const graph_rank *rank;                 /* Confort d'accès             */
+    size_t j;                               /* Boucle de parcours #2       */
+    GArchInstruction *instr;                /* Instruction à comparer      */
+
+    result = NULL;
+
+    for (i = 0; i < cluster->ranks_count && result == NULL; i++)
+    {
+        rank = &cluster->ranks[i];
+
+        for (j = 0; j < rank->count && result == NULL; j++)
+        {
+            g_basic_block_get_boundary(rank->clusters[j]->block, &instr, NULL);
+
+            if (instr == first)
+                result = rank->clusters[j];
+
+        }
+
+    }
+
+    return result;
+
+}
+#endif
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : cluster = graphique de blocs à actualiser.                   *
+*                all     = table regroupant tous les groupes créés.           *
+*                                                                             *
+*  Description : Met en place les embryons de liens nécessaires.              *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_graph_cluster_define_links(GGraphCluster *cluster, GHashTable *all)
+{
+    GArchInstruction *last;                 /* Dernière instruction du bloc*/
+    GArchInstruction **dests;               /* Instr. visée par une autre  */
+    InstructionLinkType *types;             /* Type de lien entre lignes   */
+    size_t dcount;                          /* Nombre de liens de dest.    */
+    size_t i;                               /* Boucle de parcours #1       */
+    GGraphCluster *target;                  /* Bloc ciblé par un lien      */
+    GdkPoint *start;                        /* Point de départ d'un lien   */
+    link_def *end;                          /* Définitions d'arrivée       */
+    size_t j;                               /* Boucle de parcours #2       */
+
+    /* Au niveau du bloc courant */
+
+    g_basic_block_get_boundary(cluster->block, NULL, &last);
+
+    g_arch_instruction_rlock_dest(last);
+    dcount = g_arch_instruction_get_destinations(last, &dests, &types, NULL);
+
+    for (i = 0; i < dcount; i++)
+        switch (types[i])
+        {
+            case ILT_EXEC_FLOW:
+            case ILT_JUMP:
+            case ILT_CASE_JUMP:
+            case ILT_JUMP_IF_TRUE:
+            case ILT_JUMP_IF_FALSE:
+
+                target = G_GRAPH_CLUSTER(g_hash_table_lookup(all, dests[i]));
+                assert(target != NULL);
+
+                /* Point de départ */
+
+                start = (GdkPoint *)calloc(1, sizeof(GdkPoint));
+
+                cluster->bottom_anchors = (GdkPoint **)realloc(cluster->bottom_anchors,
+                                                               ++cluster->ba_count * sizeof(GdkPoint *));
+                cluster->bottom_anchors[cluster->ba_count - 1] = start;
+
+                /* Point d'arrivée */
+
+                end = (link_def *)calloc(1, sizeof(link_def));
+
+                target->top_anchors = (link_def **)realloc(target->top_anchors,
+                                                           ++target->ta_count * sizeof(link_def *));
+                target->top_anchors[target->ta_count - 1] = end;
+
+                /* Etablissement d'un embryon de lien */
+
+                end->type = types[i];
+
+                if (types[i] == ILT_JUMP_IF_TRUE)
+                    end->edge = g_graph_edge_new_true(start, &end->y, &end->end);
+
+                else if (types[i] == ILT_JUMP_IF_FALSE)
+                    end->edge = g_graph_edge_new_false(start, &end->y, &end->end);
+
+                else
+                    end->edge = g_graph_edge_new(start, &end->y, &end->end);
+
+                break;
+
+
+            case ILT_LOOP:
+
+                /* TODO */
+                assert(false);
+
+                break;
+
+            default:
+                break;
+
+        }
+
+    g_arch_instruction_runlock_dest(last);
+
+    /* Propagation de la mise en place */
+
+    for (i = 0; i < cluster->ranks_count; i++)
+        for (j = 0; j < cluster->ranks[i].count; j++)
+            g_graph_cluster_define_links(cluster->ranks[i].clusters[j], all);
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : cluster = graphique de blocs à actualiser.                   *
+*                                                                             *
+*  Description : Détermine les positions de tous les liens en place.          *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_graph_cluster_compute_link_positions(GGraphCluster *cluster)
+{
+    gint mid_x;                             /* Abscisse centrale           */
+    size_t half;                            /* Indice de répartition égale */
+    gint y;                                 /* Ordonnée d'application      */
+
+    size_t i;                               /* Boucle de parcours #1       */
+    GdkPoint *pt;                           /* Point à actualiser          */
+    size_t j;                               /* Boucle de parcours #2       */
+
+
+
+    mid_x = cluster->alloc.x + (cluster->alloc.width / 2);
+
+    /* Du côté des départs... */
+
+    if (cluster->ba_count > 0)
+    {
+        half = cluster->ba_count / 2;
+
+        y = cluster->alloc.y + cluster->alloc.height;
+
+        if (cluster->ba_count % 2 == 1)
+        {
+            for (i = half; i > 0; i--)
+            {
+                pt = cluster->bottom_anchors[i - 1];
+
+                pt->x = mid_x - (half - i + 1) * LINK_MARGIN;
+                pt->y = y;
+
+            }
+
+            pt = cluster->bottom_anchors[half];
+
+            pt->x = mid_x;
+            pt->y = y;
+
+            for (i = half + 1; i < cluster->ba_count; i++)
+            {
+                pt = cluster->bottom_anchors[i];
+
+                pt->x = mid_x + (i - half) * LINK_MARGIN;
+                pt->y = y;
+
+            }
+
+        }
+
+        else
+        {
+            for (i = half; i > 0; i--)
+            {
+                pt = cluster->bottom_anchors[i - 1];
+
+                pt->x = mid_x - LINK_MARGIN / 2 - (half - i) * LINK_MARGIN;
+                pt->y = y;
+
+            }
+
+            for (i = half; i < cluster->ba_count; i++)
+            {
+                pt = cluster->bottom_anchors[i];
+
+                pt->x = mid_x + LINK_MARGIN / 2 + (half - i) * LINK_MARGIN;
+                pt->y = y;
+
+            }
+
+        }
+
+    }
+
+    /* Du côté des arrivées... */
+
+    if (cluster->ta_count > 0)
+    {
+        half = cluster->ta_count / 2;
+
+        y = cluster->alloc.y;
+
+        if (cluster->ta_count % 2 == 1)
+        {
+            for (i = half; i > 0; i--)
+            {
+                pt = &cluster->top_anchors[i - 1]->end;
+
+                pt->x = mid_x - (half - i + 1) * LINK_MARGIN;
+                pt->y = y;
+
+            }
+
+            pt = &cluster->top_anchors[half]->end;
+
+            pt->x = mid_x;
+            pt->y = y;
+
+            for (i = half + 1; i < cluster->ta_count; i++)
+            {
+                pt = &cluster->top_anchors[i]->end;
+
+                pt->x = mid_x + (i - half) * LINK_MARGIN;
+                pt->y = y;
+
+            }
+
+        }
+
+        else
+        {
+            for (i = half; i > 0; i--)
+            {
+                pt = &cluster->top_anchors[i - 1]->end;
+
+                pt->x = mid_x - LINK_MARGIN / 2 - (half - i) * LINK_MARGIN;
+                pt->y = y;
+
+            }
+
+            for (i = half; i < cluster->ta_count; i++)
+            {
+                pt = &cluster->top_anchors[i]->end;
+
+                pt->x = mid_x + LINK_MARGIN / 2 + (half - i) * LINK_MARGIN;
+                pt->y = y;
+
+            }
+
+        }
+
+
+
+
+
+
+
+
+        for (i = 0; i < cluster->ta_count; i++)
+            cluster->top_anchors[i]->y.y = cluster->top_anchors[i]->end.y - 18;
+
+
+
+
+
+
+
+    }
+
+    /* Propagation des déterminations */
+
+    for (i = 0; i < cluster->ranks_count; i++)
+        for (j = 0; j < cluster->ranks[i].count; j++)
+            g_graph_cluster_compute_link_positions(cluster->ranks[i].clusters[j]);
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : cluster = graphique de blocs à consulter.                    *
+*                                                                             *
+*  Description : Applique les positions calculées pour chaque lien graphique. *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_graph_cluster_resolve_links(const GGraphCluster *cluster)
+{
+    size_t i;                               /* Boucle de parcours #1       */
+    size_t j;                               /* Boucle de parcours #2       */
+
+    for (i = 0; i < cluster->ta_count; i++)
+        g_graph_edge_resolve(cluster->top_anchors[i]->edge);
+
+    for (i = 0; i < cluster->ranks_count; i++)
+        for (j = 0; j < cluster->ranks[i].count; j++)
+            g_graph_cluster_resolve_links(cluster->ranks[i].clusters[j]);
+
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+/* Liste de blocs restants à traiter */
+typedef struct _pending_blocks
+{
+    size_t count;                           /* Taille de la liste          */
+    GBasicBlock *list[0];                   /* Liste de blocs à traiter    */
+
+} pending_blocks;
+
+
+
+
+
+/* Met en place un ensemble de blocs sous forme graphique. */
+static GGraphCluster *setup_graph_clusters(GLoadedBinary *, const GBlockList *, size_t , segcnt_list *, pending_blocks *, GHashTable *);
+
+
+
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : binary      = binaire charger dont le code est à représenter.*
+*                list        = ensemble de blocs basiques à manipuler.        *
+*                index       = indice du bloc principal à mettre en place.    *
+*                highlighted = gestionnaire de surbrillance pour segments.    *
+*                pending     = liste de blocs restant à traiter. [OUT]        *
+*                all         = table regroupant tous les groupes créés.       *
+*                                                                             *
+*  Description : Met en place un ensemble de blocs sous forme graphique.      *
+*                                                                             *
+*  Retour      : Ensemble de blocs mis en place.                              *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static GGraphCluster *setup_graph_clusters(GLoadedBinary *binary, const GBlockList *list, size_t index, segcnt_list *highlighted, pending_blocks *pending, GHashTable *all)
+{
+    GGraphCluster *result;                  /* Instance nouvelle à renvoyer*/
+    GBasicBlock *block;                     /* Bloc à manipuler            */
+    GArchInstruction *first;                /* Première instruction du bloc*/
+    GArchInstruction *last;                 /* Dernière instruction du bloc*/
+#ifndef NDEBUG
+    gboolean new;                           /* Bloc déjà traité ?          */
+#endif
+    GArchInstruction **dests;               /* Instr. visée par une autre  */
+    InstructionLinkType *types;             /* Type de lien entre lignes   */
+    size_t dcount;                          /* Nombre de liens de dest.    */
+    size_t i;                               /* Boucle de parcours #1       */
+    GBasicBlock *target;                    /* Bloc ciblé par un lien      */
+    size_t j;                               /* Boucle de parcours #2       */
+    bool changed;                           /* Un ajout a été effectué ?   */
+    const bitfield_t *dominators;           /* Blocs dominant ce même bloc */
+    size_t next;                            /* Indice du prochain bloc     */
+    GGraphCluster *sub;                     /* Sous-ensemble à intégrer    */
+
+    result = g_graph_cluster_new(binary, list, index, highlighted);
+
+    block = g_block_list_get_block(list, index);
+
+    g_basic_block_get_boundary(block, &first, &last);
+
+#ifndef NDEBUG
+    new = g_hash_table_insert(all, first, result);
+    assert(new);
+#else
+    g_hash_table_insert(all, first, result);
+#endif
+
+    /* Détermination des blocs suivants */
+
+    g_arch_instruction_rlock_dest(last);
+    dcount = g_arch_instruction_get_destinations(last, &dests, &types, NULL);
+
+    printf(" ... block=%p dest=%zu\n", block, dcount);
+
+    for (i = 0; i < dcount; i++)
+        switch (types[i])
+        {
+            case ILT_EXEC_FLOW:
+            case ILT_JUMP:
+            case ILT_CASE_JUMP:
+            case ILT_JUMP_IF_TRUE:
+            case ILT_JUMP_IF_FALSE:
+
+                target = g_block_list_find_by_starting_instr(list, dests[i]);
+
+                /**
+                 * Les sauts ne se font pas toujours à l'intérieur d'une même fonction.
+                 * Par exemple sous ARM :
+                 *
+                 *    00008358 <call_gmon_start>:
+                 *        ....
+                 *        8362:       f7ff bfcf       b.w     8304 <_init+0x38>
+                 *        ....
+                 *
+                 */
+
+                printf(" NEW BLK :: %d -> %p\n", types[i], target);
+
+                if (target != NULL)
+                {
+                    for (j = 0; j < pending->count; j++)
+                        if (pending->list[j] == target)
+                            break;
+
+                    if (j == pending->count)
+                    {
+                        assert((pending->count + 1) < g_block_list_count_blocks(list));
+                        pending->list[pending->count++] = target;
+                        printf(" --push-- %d -> %p\n", types[i], target);
+                    }
+
+                    do
+                    {
+                        size_t k;
+                        printf(" --stack-- ");
+                        for (k = 0; k < pending->count; k++)
+                            printf("%p ", pending->list[k]);
+                        printf("\n");
+                    }
+                    while (0);
+
+
+
+                }
+
+                break;
+
+            default:
+                break;
+
+        }
+
+    g_arch_instruction_runlock_dest(last);
+
+    /* Intégration de tous les blocs en attente */
+
+    do
+    {
+        changed = false;
+
+        for (i = 0; i < pending->count && !changed; i++)
+        {
+            block = pending->list[i];
+            dominators = g_basic_block_get_domination(block);
+
+            if (test_in_bit_field(dominators, index, 1))
+            {
+                /* Dépilement */
+
+                changed = true;
+
+                if ((i + 1) < pending->count)
+                    memmove(&pending->list[i], &pending->list[i + 1],
+                            (pending->count - i - 1) * sizeof(GBasicBlock *));
+
+                pending->count--;
+
+                /* Intégration */
+
+                next = g_block_list_get_index(list, block);
+                assert(next < g_block_list_count_blocks(list));
+
+                printf(" --pop-- block=%p index=%zu\n", block, next);
+
+                sub = setup_graph_clusters(binary, list, next, highlighted, pending, all);
+
+                g_graph_cluster_add_sub(result, sub, block);
+
+            }
+
+        }
+
+    }
+    while (changed);
+
+    return result;
+
+}
+
+
+
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : blocks = ensemble des blocs basiques déjà découpés.          *
+*                views  = morceaux de code à afficher de façon organisée.     *
+*                count  = quantité de ces morceaux de code.                   *
+*                                                                             *
+*  Description : Construit un graphique à partir de blocs basiques.           *
+*                                                                             *
+*  Retour      : Adresse de la structure mise en place.                       *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GGraphCluster *bootstrap_graph_cluster(GLoadedBinary *binary, const GBlockList *list, segcnt_list *highlighted)
+{
+    GGraphCluster *result;                  /* Structure à retourner       */
+    GHashTable *all;                        /* Collection des créations    */
+    size_t count;                           /* Taille de la liste de blocs */
+    pending_blocks *pending;                /* Suivi des blocs à traiter   */
+    GtkAllocation needed;                   /* Taille requise              */
+
+
+    all = g_hash_table_new(NULL, NULL);
+
+    count = g_block_list_count_blocks(list);
+
+    pending = (pending_blocks *)calloc(1, sizeof(pending_blocks) + count * sizeof(GBasicBlock *));
+
+
+
+
+    do
+    {
+        size_t i;
+        GBasicBlock *block;
+        const bitfield_t *domination;
+
+        printf("DBG // count : %zu\n", count);
+
+        for (i = 0; i < count; i++)
+        {
+            block = g_block_list_get_block(list, i);
+            domination = g_basic_block_get_domination(block);
+
+            printf("DBG // block [%zu] : 0x%08lx  --  rank = %u\n",
+                   i, gfw(domination), g_basic_block_get_rank(block));
+
+        }
+
+        fflush(NULL);
+
+    }
+    while (0);
+
+
+
+
+
+    result = setup_graph_clusters(binary, list, 0, highlighted, pending, all);
+
+    free(pending);
+
+    g_graph_cluster_define_links(result, all);
+
+    /* Positionnements dans l'espace */
+
+    g_graph_cluster_dispatch_x(result);
+
+    g_graph_cluster_set_y(result, 0);
+
+    /* Réajustement vers la droite */
+
+    g_graph_cluster_compute_needed_alloc(result, &needed);
+
+    g_graph_cluster_offset_x(result, -needed.x);
+
+    /* Application finale sur les liens */
+
+    g_graph_cluster_compute_link_positions(result);
+
+    g_graph_cluster_resolve_links(result);
+
+
+
+
+    g_hash_table_unref(all);
+
+
+    return result;
+
+
+}
diff --git a/src/gtkext/graph/cluster.h b/src/gtkext/graph/cluster.h
new file mode 100644
index 0000000..a41adc7
--- /dev/null
+++ b/src/gtkext/graph/cluster.h
@@ -0,0 +1,71 @@
+
+/* Chrysalide - Outil d'analyse de fichiers binaires
+ * cluster.h - prototypes pour la mise en place de graphiques
+ *
+ * Copyright (C) 2016 Cyrille Bagard
+ *
+ *  This file is part of Chrysalide.
+ *
+ *  OpenIDA is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  OpenIDA is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Foobar.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#ifndef _GTKEXT_GRAPH_CLUSTER_H
+#define _GTKEXT_GRAPH_CLUSTER_H
+
+
+
+#include "../gtkgraphview.h"
+#include "../../analysis/binary.h"
+#include "../../analysis/disass/block.h"
+
+
+
+#define G_TYPE_GRAPH_CLUSTER            g_graph_cluster_get_type()
+#define G_GRAPH_CLUSTER(obj)            (G_TYPE_CHECK_INSTANCE_CAST((obj), G_TYPE_GRAPH_CLUSTER, GGraphCluster))
+#define G_IS_GRAPH_CLUSTER(obj)         (G_TYPE_CHECK_INSTANCE_TYPE((obj), G_TYPE_GRAPH_CLUSTER))
+#define G_GRAPH_CLUSTER_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_GRAPH_CLUSTER, GGraphClusterClass))
+#define G_IS_GRAPH_CLUSTER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_GRAPH_CLUSTER))
+#define G_GRAPH_CLUSTER_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_GRAPH_CLUSTER, GGraphClusterClass))
+
+
+/* Mise en disposition de blocs en graphique (instance) */
+typedef struct _GGraphCluster GGraphCluster;
+
+/* Mise en disposition de blocs en graphique (classe) */
+typedef struct _GGraphClusterClass GGraphClusterClass;
+
+
+/* Indique le type définit par la GLib pour les mises en disposition graphique. */
+GType g_graph_cluster_get_type(void);
+
+/* Construit un graphique à partir de blocs basiques. */
+GGraphCluster *g_graph_cluster_new(GLoadedBinary *, const GBlockList *, size_t, segcnt_list *);
+
+/* Détermine l'emplacement requis d'un ensemble de blocs. */
+void g_graph_cluster_compute_needed_alloc(const GGraphCluster *, GtkAllocation *);
+
+/* Dispose chaque noeud sur la surface de destination donnée. */
+void g_graph_cluster_place(GGraphCluster *, GtkGraphView *);
+
+
+
+
+
+GGraphCluster *bootstrap_graph_cluster(GLoadedBinary *binary, const GBlockList *list, segcnt_list *highlighted);
+
+
+
+
+#endif  /* _GTKEXT_GRAPH_CLUSTER_H */
diff --git a/src/gtkext/graph/edge.c b/src/gtkext/graph/edge.c
index 5750198..a917cc3 100644
--- a/src/gtkext/graph/edge.c
+++ b/src/gtkext/graph/edge.c
@@ -24,10 +24,10 @@
 #include "edge.h"
 
 
+#include <assert.h>
+#include <malloc.h>
 #include <math.h>
-
-
-#include "nodes/virtual.h"
+#include <string.h>
 
 
 
@@ -36,18 +36,13 @@ struct _GGraphEdge
 {
     GObject parent;                         /* A laisser en premier        */
 
-    GFlowNode *src_node;                    /* Bloc de départ du lien      */
-    node_slot_t *src_slot;                  /* Numéro d'ancrage initial    */
-    GFlowNode *dest_node;                   /* Bloc d'arrivée du lien      */
-    node_slot_t *dest_slot;                 /* Numéro d'ancrage final      */
+    EdgeColor color;                        /* Couleur du rendu            */
 
-    hspan_slot_t top_step;                  /* Niveau sup. de destination  */
-    GVirtualNode *container;                /* Conteneur pour les tours    */
-    bool is_left;                           /* Tour par la gauche ?        */
-    vspan_slot_t vert_step;                 /* Position de contournement   */
-    hspan_slot_t bottom_step;               /* Niveau inf. de source       */
+    const GdkPoint *start;                  /* Point de départ du lien     */
+    GdkPoint *mid[2];                        /* Etapes intermédiaires       */
+    size_t m_count;                         /* Quantité de ces étapes      */
+    const GdkPoint *end;                    /* Point d'arrivée du lien     */
 
-    EdgeColor color;                        /* Couleur du rendu            */
     GdkPoint *points;                       /* Points de la ligne dessinée */
     size_t count;                           /* Quantité de ces points      */
 
@@ -61,6 +56,11 @@ struct _GGraphEdgeClass
 };
 
 
+/* Dimensions des flêches */
+#define ARROW_LENGHT 10
+#define ARROW_DEGREES 10
+
+
 /* Initialise la classe des liens graphiques entre deux noeuds. */
 static void g_graph_edge_class_init(GGraphEdgeClass *);
 
@@ -120,8 +120,6 @@ static void g_graph_edge_class_init(GGraphEdgeClass *klass)
 
 static void g_graph_edge_init(GGraphEdge *edge)
 {
-    edge->top_step = UNINITIALIZED_HSPAN_SLOT;
-    edge->bottom_step = UNINITIALIZED_HSPAN_SLOT;
 
 }
 
@@ -140,12 +138,6 @@ static void g_graph_edge_init(GGraphEdge *edge)
 
 static void g_graph_edge_dispose(GGraphEdge *edge)
 {
-    g_object_unref(G_OBJECT(edge->src_node));
-    g_object_unref(G_OBJECT(edge->dest_node));
-
-    if (edge->container != NULL)
-        g_object_unref(G_OBJECT(edge->container));
-
     G_OBJECT_CLASS(g_graph_edge_parent_class)->dispose(G_OBJECT(edge));
 
 }
@@ -175,11 +167,11 @@ static void g_graph_edge_finalize(GGraphEdge *edge)
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : src_node  = bloc de départ du lien.                          *
-*                src_slot  = point d'ancrage associé.                         *
-*                dest_node = bloc d'arrivée du lien.                          *
-*                dest_slot = point d'ancrage associé.                         *
-*                color     = couleur de rendu à l'écran.                      *
+*  Paramètres  : start = point de départ de la flêche.                        *
+*                mid   = points intermédiares variables.                      *
+*                count = nombre de ces points fournis.                        *
+*                end   = point d'arrivée de la flêche.                        *
+*                color = couleur de rendu à l'écran.                          *
 *                                                                             *
 *  Description : Etablit un lien graphique entre deux noeuds graphiques.      *
 *                                                                             *
@@ -189,84 +181,33 @@ static void g_graph_edge_finalize(GGraphEdge *edge)
 *                                                                             *
 ******************************************************************************/
 
-GGraphEdge *g_graph_edge_new(GFlowNode *src_node, node_slot_t *src_slot, GFlowNode *dest_node, node_slot_t *dest_slot, EdgeColor color)
+GGraphEdge *_g_graph_edge_new(const GdkPoint *start, const GdkPoint **mid, size_t count, const GdkPoint *end, EdgeColor color)
 {
     GGraphEdge *result;                     /* Structure à retourner       */
 
     result = g_object_new(G_TYPE_GRAPH_EDGE, NULL);
 
-    g_object_ref(G_OBJECT(src_node));
-    g_object_ref(G_OBJECT(dest_node));
-
-    result->src_node = src_node;
-    result->src_slot = src_slot;
-    result->dest_node = dest_node;
-    result->dest_slot = dest_slot;
-
     result->color = color;
 
-    return G_GRAPH_EDGE(result);
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : a = premier lien à considérer.                               *
-*                b = second lien à considérer.                                *
-*                                                                             *
-*  Description : Etablit la comparaison entre deux liens graphiques.          *
-*                                                                             *
-*  Retour      : Bilan de la comparaison : -1, 0 ou 1.                        *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-int g_graph_edge_compare(const GGraphEdge **a, const GGraphEdge **b)
-{
-    int result;                             /* Bilan à retourner           */
-    const GGraphEdge *_a;                   /* Commodité d'accès #1        */
-    const GGraphEdge *_b;                   /* Commodité d'accès #2        */
-    GdkPoint start_a;                       /* Point de départ A           */
-    GdkPoint start_b;                       /* Point de départ B           */
-
-    _a = *a;
-    _b = *b;
-
-    /**
-     * La comparaison s'établit sur le noeud d'arrivée.
-     */
-
-    if (_a->dest_node < _b->dest_node)
-        result = -1;
+    assert(count == 1 || count == 2);
 
-    else if (_a->dest_node > _b->dest_node)
-        result = 1;
+    result->start = start;
 
-    else
-    {
-        start_a = g_flow_node_get_point_from_slot(_a->src_node, false, _a->src_slot);
-        start_b = g_flow_node_get_point_from_slot(_b->src_node, false, _b->src_slot);
+    memcpy(result->mid, mid, count * sizeof(GdkPoint));
+    result->m_count = count;
 
-        result = g_flow_node_compare_slots_for_edges(_a->dest_node,
-                                                     _a->dest_slot, start_a.x,
-                                                     _b->dest_slot, start_b.x);
-
-    }
+    result->end = end;
 
-    return result;
+    return G_GRAPH_EDGE(result);
 
 }
 
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : edge  = ligne de rendu à mettre à jour.                      *
-*                nodes = noeud au sommet de la hiérarchie.                    *
-*                ranks = classement global dans lequel s'intégrer.            *
+*  Paramètres  : edge = ligne de rendu à définir dans les détails.            *
 *                                                                             *
-*  Description : Prend les dispositions nécessaires à l'insertion du lien.    *
+*  Description : Détermine les positions finales d'un lien graphique.         *
 *                                                                             *
 *  Retour      : -                                                            *
 *                                                                             *
@@ -274,177 +215,31 @@ int g_graph_edge_compare(const GGraphEdge **a, const GGraphEdge **b)
 *                                                                             *
 ******************************************************************************/
 
-void g_graph_edge_reserve_vertical_space(GGraphEdge *edge, GGraphNode *nodes, GGraphRanks *ranks)
+void g_graph_edge_resolve(GGraphEdge *edge)
 {
-    GGraphNode *container;                  /* Conteneur du lien de boucle */
-    unsigned int r1;                        /* Classement de départ        */
-    unsigned int r2;                        /* Classement d'arrivée        */
-
-    switch (edge->color)
-    {
-        case EGC_BLUE:
-
-            container = g_graph_node_find_container(nodes, G_GRAPH_NODE(edge->dest_node));
-            g_object_ref(G_OBJECT(container));
-            edge->container = G_VIRTUAL_NODE(container);
-
-            edge->is_left = true;  /* TODO */
-
-            r1 = g_graph_node_get_rank(G_GRAPH_NODE(edge->src_node));
-            r2 = g_graph_node_get_rank(G_GRAPH_NODE(edge->dest_node));
-
-            edge->vert_step = g_virtual_node_reserve_span(edge->container, r1, r2, edge->is_left);
-
-            break;
-
-        default:
-            break;
-
-    }
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : edge  = ligne de rendu à mettre à jour.                      *
-*                ranks = classement global dans lequel s'intégrer.            *
-*                                                                             *
-*  Description : Prend les dispositions nécessaires à l'insertion du lien.    *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
+    edge->count = 2 + 2 * edge->m_count;
+    edge->points = (GdkPoint *)calloc(edge->count, sizeof(GdkPoint));
 
-void g_graph_edge_reserve_horizontal_space(GGraphEdge *edge, GGraphRanks *ranks)
-{
-    GdkPoint x_src;                         /* Abscisse au niveau du départ*/
-    GdkPoint x_dest;                        /* Abscisse au niveau d'arrivée*/
-    gint x_step;                            /* Transition verticale        */
-    unsigned int rank;                      /* Indice de classement        */
+    edge->points[0] = *edge->start;
 
-    x_src = g_flow_node_get_point_from_slot(edge->src_node, false, edge->src_slot);
-    x_dest = g_flow_node_get_point_from_slot(edge->dest_node, true, edge->dest_slot);
+    edge->points[1].x = edge->start->x;
+    edge->points[1].y = edge->mid[0]->y;
 
-    switch (edge->color)
+    if (edge->m_count == 1)
     {
-        case EGC_BLUE:
-
-            x_step = g_virtual_node_get_x_for_vspan_slot(edge->container,
-                                                         edge->vert_step, edge->is_left);
-
-            rank = g_graph_node_get_rank(G_GRAPH_NODE(edge->src_node));
-            edge->bottom_step = g_graph_ranks_reserve_span(ranks, rank, x_src.x, x_step, false);
-
-            rank = g_graph_node_get_rank(G_GRAPH_NODE(edge->dest_node));
-            edge->top_step = g_graph_ranks_reserve_span(ranks, rank, x_dest.x, x_step, true);
-
-            break;
-
-        default:
-            rank = g_graph_node_get_rank(G_GRAPH_NODE(edge->dest_node));
-            edge->top_step = g_graph_ranks_reserve_span(ranks, rank, x_src.x, x_dest.x, true);
-            break;
-
+        edge->points[2].x = edge->end->x;
+        edge->points[2].y = edge->mid[0]->y;
     }
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : edge  = ligne de rendu à mettre à jour.                      *
-*                ranks = classement global dans lequel s'intégrer.            *
-*                                                                             *
-*  Description : Etablit le tracé du lien graphique entre deux noeuds.        *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-void g_graph_edge_compute(GGraphEdge *edge, GGraphRanks *ranks)
-{
-    GdkPoint start;                         /* Point de départ             */
-    GdkPoint end;                           /* Point d'arrivée             */
-    gint x_step;                            /* Transition verticale        */
-    unsigned int rank;                      /* Indice de classement        */
-
-    start = g_flow_node_get_point_from_slot(edge->src_node, false, edge->src_slot);
-    end = g_flow_node_get_point_from_slot(edge->dest_node, true, edge->dest_slot);
-
-    /* Point de départ */
-
-    edge->count = 2;
-    edge->points = (GdkPoint *)calloc(edge->count, sizeof(GdkPoint));
-
-    edge->points[0] = start;
-    edge->points[1] = start;
-    edge->points[1].y += SLOT_VERT_SEP;
-
-    /* Points de jonction */
-
-    switch (edge->color)
+    else
     {
-        case EGC_BLUE:
-
-            edge->count += 4;
-            edge->points = (GdkPoint *)realloc(edge->points, edge->count * sizeof(GdkPoint));
-
-            x_step = g_virtual_node_get_x_for_vspan_slot(edge->container,
-                                                         edge->vert_step, edge->is_left);
-
-            rank = g_graph_node_get_rank(G_GRAPH_NODE(edge->src_node));
-
-            edge->points[edge->count - 4].x = start.x;
-            edge->points[edge->count - 4].y = g_graph_ranks_get_y_for_hspan_slot(ranks, rank,
-                                                                                 edge->bottom_step,
-                                                                                 false);
+        memcpy(&edge->points[2], edge->mid, edge->m_count * sizeof(GdkPoint));
 
-            edge->points[edge->count - 3].x = x_step;
-            edge->points[edge->count - 3].y = edge->points[edge->count - 4].y;
-
-            rank = g_graph_node_get_rank(G_GRAPH_NODE(edge->dest_node));
-
-            edge->points[edge->count - 2].x = x_step;
-            edge->points[edge->count - 2].y = g_graph_ranks_get_y_for_hspan_slot(ranks, rank,
-                                                                                 edge->top_step,
-                                                                                 true);
-            edge->points[edge->count - 1].x = end.x;
-            edge->points[edge->count - 1].y = edge->points[edge->count - 2].y;
-
-            break;
-
-        default:
-
-            edge->count += 2;
-            edge->points = (GdkPoint *)realloc(edge->points, edge->count * sizeof(GdkPoint));
-
-            rank = g_graph_node_get_rank(G_GRAPH_NODE(edge->dest_node));
-
-            edge->points[edge->count - 2].x = start.x;
-            edge->points[edge->count - 2].y = g_graph_ranks_get_y_for_hspan_slot(ranks, rank,
-                                                                                 edge->top_step,
-                                                                                 true);
-
-            edge->points[edge->count - 1].x = end.x;
-            edge->points[edge->count - 1].y = edge->points[edge->count - 2].y;
-
-            break;
+        edge->points[4].x = edge->end->x;
+        edge->points[4].y = edge->mid[3]->y;
 
     }
 
-    /* Point d'arrivée */
-
-    edge->count += 2;
-    edge->points = (GdkPoint *)realloc(edge->points, edge->count * sizeof(GdkPoint));
-
-    edge->points[edge->count - 2] = end;
-    edge->points[edge->count - 2].y -= SLOT_VERT_SEP;
-    edge->points[edge->count - 1] = end;
+    edge->points[edge->count - 1] = *edge->end;
 
 }
 
diff --git a/src/gtkext/graph/edge.h b/src/gtkext/graph/edge.h
index 64d9658..602c559 100644
--- a/src/gtkext/graph/edge.h
+++ b/src/gtkext/graph/edge.h
@@ -26,17 +26,16 @@
 
 
 #include <glib-object.h>
-
-
-#include "ranks.h"
-#include "nodes/flow.h"
+#include <stdbool.h>
+#include <gtk/gtk.h>
 
 
 
 #define G_TYPE_GRAPH_EDGE               g_graph_edge_get_type()
-#define G_GRAPH_EDGE(obj)               (G_TYPE_CHECK_INSTANCE_CAST((obj), g_graph_edge_get_type(), GGraphEdge))
-#define G_IS_GRAPH_EDGE(obj)            (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_graph_edge_get_type()))
-#define G_GRAPH_EDGE_GET_IFACE(inst)    (G_TYPE_INSTANCE_GET_INTERFACE((inst), g_graph_edge_get_type(), GGraphEdgeIface))
+#define G_GRAPH_EDGE(obj)               (G_TYPE_CHECK_INSTANCE_CAST((obj), G_TYPE_GRAPH_EDGE, GGraphEdge))
+#define G_IS_GRAPH_EDGE(obj)            (G_TYPE_CHECK_INSTANCE_TYPE((obj), G_TYPE_GRAPH_EDGE))
+#define G_GRAPH_EDGE_CLASS(klass)       (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_GRAPH_EDGE, GGraphEdgeClass))
+#define G_IS_GRAPH_EDGE_CLASS(klass)    (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_GRAPH_EDGE))
 #define G_GRAPH_EDGE_GET_CLASS(obj)     (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_GRAPH_EDGE, GGraphEdgeClass))
 
 
@@ -65,19 +64,19 @@ typedef enum _EdgeColor
 GType g_graph_edge_get_type(void);
 
 /* Etablit un lien graphique entre deux noeuds graphiques. */
-GGraphEdge *g_graph_edge_new(GFlowNode *, node_slot_t *, GFlowNode *, node_slot_t *, EdgeColor);
+GGraphEdge *_g_graph_edge_new(const GdkPoint *, const GdkPoint **, size_t, const GdkPoint *, EdgeColor);
 
-/* Etablit la comparaison entre deux liens graphiques. */
-int g_graph_edge_compare(const GGraphEdge **, const GGraphEdge **);
+#define g_graph_edge_new(start, y, end) \
+    _g_graph_edge_new(start, (const GdkPoint *[]) { y }, 1, end, EGC_DEFAULT)
 
-/* Prend les dispositions nécessaires à l'insertion du lien. */
-void g_graph_edge_reserve_vertical_space(GGraphEdge *, GGraphNode *, GGraphRanks *);
+#define g_graph_edge_new_true(start, y, end) \
+    _g_graph_edge_new(start, (const GdkPoint *[]) { y }, 1, end, EGC_GREEN)
 
-/* Prend les dispositions nécessaires à l'insertion du lien. */
-void g_graph_edge_reserve_horizontal_space(GGraphEdge *, GGraphRanks *);
+#define g_graph_edge_new_false(start, y, end) \
+    _g_graph_edge_new(start, (const GdkPoint *[]) { y }, 1, end, EGC_RED)
 
-/* Etablit le tracé du lien graphique entre deux noeuds. */
-void g_graph_edge_compute(GGraphEdge *, GGraphRanks *);
+/* Détermine les positions finales d'un lien graphique. */
+void g_graph_edge_resolve(GGraphEdge *);
 
 /* Dessine les liens graphiques enregistrés dans le moteur. */
 void g_graph_edge_draw(const GGraphEdge *, cairo_t *, bool);
diff --git a/src/gtkext/graph/layout.c b/src/gtkext/graph/layout.c
deleted file mode 100644
index 13f6270..0000000
--- a/src/gtkext/graph/layout.c
+++ /dev/null
@@ -1,491 +0,0 @@
-
-/* Chrysalide - Outil d'analyse de fichiers binaires
- * layout.c - mise en place de graphique
- *
- * Copyright (C) 2009-2014 Cyrille Bagard
- *
- *  This file is part of Chrysalide.
- *
- *  OpenIDA is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 3 of the License, or
- *  (at your option) any later version.
- *
- *  OpenIDA is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with Foobar.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-
-#include "layout.h"
-
-
-#include <malloc.h>
-#include <stdlib.h>
-
-
-#include "node.h"
-#include "ranks.h"
-#include "nodes/flow.h"
-#include "nodes/virtual.h"
-
-
-
-/* Mise en disposition de blocs en graphique (instance) */
-struct _GGraphLayout
-{
-    GObject parent;                         /* A laisser en premier        */
-
-    GGraphNode *nodes;                      /* Noeuds graphiques gérés     */
-    GGraphRanks *ranks;                     /* Classement en rangs         */
-
-    GGraphEdge **edges;                     /* Liens entre les noeuds      */
-    size_t edges_count;                     /* Quantité de ces liens       */
-
-};
-
-/* Mise en disposition de blocs en graphique (classe) */
-struct _GGraphLayoutClass
-{
-    GObjectClass parent;                    /* A laisser en premier        */
-
-};
-
-
-/* Initialise la classe des mises en disposition graphique. */
-static void g_graph_layout_class_init(GGraphLayoutClass *);
-
-/* Initialise une mise en disposition de blocs en graphique. */
-static void g_graph_layout_init(GGraphLayout *);
-
-/* Supprime toutes les références externes. */
-static void g_graph_layout_dispose(GGraphLayout *);
-
-/* Procède à la libération totale de la mémoire. */
-static void g_graph_layout_finalize(GGraphLayout *);
-
-
-
-/* Indique le type définit par la GLib pour les mises en disposition graphique. */
-G_DEFINE_TYPE(GGraphLayout, g_graph_layout, G_TYPE_OBJECT);
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : klass = classe à initialiser.                                *
-*                                                                             *
-*  Description : Initialise la classe des mises en disposition graphique.     *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static void g_graph_layout_class_init(GGraphLayoutClass *klass)
-{
-    GObjectClass *object;                   /* Autre version de la classe  */
-
-    object = G_OBJECT_CLASS(klass);
-
-    object->dispose = (GObjectFinalizeFunc/* ! */)g_graph_layout_dispose;
-    object->finalize = (GObjectFinalizeFunc)g_graph_layout_finalize;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : layout = instance à initialiser.                             *
-*                                                                             *
-*  Description : Initialise une mise en disposition de blocs en graphique.    *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static void g_graph_layout_init(GGraphLayout *layout)
-{
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : node = instance d'objet GLib à traiter.                      *
-*                                                                             *
-*  Description : Supprime toutes les références externes.                     *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static void g_graph_layout_dispose(GGraphLayout *layout)
-{
-    g_object_unref(G_OBJECT(layout->nodes));
-    g_object_unref(G_OBJECT(layout->ranks));
-
-    G_OBJECT_CLASS(g_graph_layout_parent_class)->dispose(G_OBJECT(layout));
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : layout = instance d'objet GLib à traiter.                    *
-*                                                                             *
-*  Description : Procède à la libération totale de la mémoire.                *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static void g_graph_layout_finalize(GGraphLayout *layout)
-{
-    G_OBJECT_CLASS(g_graph_layout_parent_class)->finalize(G_OBJECT(layout));
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : blocks = ensemble des blocs basiques déjà découpés.          *
-*                views  = morceaux de code à afficher de façon organisée.     *
-*                count  = quantité de ces morceaux de code.                   *
-*                                                                             *
-*  Description : Construit un graphique à partir de blocs basiques.           *
-*                                                                             *
-*  Retour      : Adresse de la structure mise en place.                       *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-#include "../../arch/instruction-int.h" // REMME
-#include "nodes/flow.h"
-GGraphLayout *g_graph_layout_new(GInstrBlock *blocks, GtkBufferView **views, size_t count)
-{
-    GGraphLayout *result;                   /* Structure à retourner       */
-
-    result = g_object_new(G_TYPE_GRAPH_LAYOUT, NULL);
-
-    result->nodes = convert_blocks_into_nodes(blocks, views, count);
-
-    result->ranks = g_graph_ranks_new(count);
-
-    /* Situations verticales grossières */
-
-    bool _register_cb(GFlowNode *node, GNodeVisitState state, GGraphLayout *layout)
-    {
-        if (state == GVS_NODE)
-            g_flow_node_link(node, layout, layout->nodes);
-        return true;
-    }
-
-    g_graph_node_visit_nodes(result->nodes, (graph_node_visitor_cb)_register_cb, result);
-
-    bool _print_dbg_cb(GFlowNode *node, GNodeVisitState state, int *depth)
-    {
-        int i;
-
-        if (state == GVS_ENTER || state == GVS_NODE)
-        {
-            for (i = 0; i < *depth; i++)
-                printf("   ");
-
-            printf("- %p\n", node);
-
-        }
-
-        if (state == GVS_ENTER) (*depth)++;
-        else if (state == GVS_EXIT) (*depth)--;
-
-        return true;
-
-    }
-
-    printf("==== graph ====\n");
-    g_graph_node_visit_nodes(result->nodes, (graph_node_visitor_cb)_print_dbg_cb, (int []){ 0 });
-    printf("\n");
-
-    /* Actualisation... */
-
-    g_graph_layout_refresh(result);
-
-    bool _print_dbg_ext_cb(GGraphNode *node, GNodeVisitState state, int *depth)
-    {
-        int i;
-        PendingPositionFlags pending_flag;
-        char *flags;
-        GtkAllocation alloc;
-        GArchInstruction *first;
-        GArchInstruction *last;
-
-        char *flags_list[] = {
-            "NONE",
-            "DIRECT_X",
-            "LEFT_MARGIN",
-            "RIGHT_MARGIN",
-            "LEFT_NODE",
-            "RIGHT_NODE"
-        };  
-
-
-        if (state == GVS_ENTER || state == GVS_NODE)
-        {
-
-
-
-            for (i = 0; i < *depth; i++)
-                printf("   ");
-
-            g_graph_node_get_pending_position(node, &pending_flag, NULL);
-            flags = flags_list[pending_flag];
-
-            alloc = g_graph_node_get_allocation(node);
-            printf("- %p -  \"%s\"  -  (%d ; %d) - (%d ; %d)", node,
-                   flags,
-                   alloc.x, alloc.y,
-                   alloc.width, alloc.height);
-
-            if (G_IS_FLOW_NODE(node))
-            {
-                printf("  - rank = %u  -", g_graph_node_get_rank(node));
-
-                g_flow_block_get_boundary(g_flow_node_get_block(G_FLOW_NODE(node)), &first, &last);
-                printf("  - 0x%08x <-> 0x%08x", first->range.addr.virtual, last->range.addr.virtual);
-            }
-
-            printf("\n");
-
-        }
-
-        if (state == GVS_ENTER) (*depth)++;
-        else if (state == GVS_EXIT) (*depth)--;
-
-        return true;
-
-    }
-
-    printf("==== graph ====\n");
-    g_graph_node_visit_nodes(result->nodes, (graph_node_visitor_cb)_print_dbg_ext_cb, (int []){ 0 });
-    printf("\n");
-
-    return result;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : layout = disposition en graphique à compléter.               *
-*                edge   = lien entre noeuds à conserver.                      *
-*                                                                             *
-*  Description : Ajoute un lien entre deux noeuds au graphique.               *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-void g_graph_layout_add_edge(GGraphLayout *layout, GGraphEdge *edge)
-{
-    layout->edges = (GGraphEdge **)realloc(layout->edges,
-                                           ++layout->edges_count * sizeof(GGraphEdge *));
-
-    layout->edges[layout->edges_count - 1] = edge;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : layout = graphique à mettre à jour.                          *
-*                                                                             *
-*  Description : Met à jour les positions des différents noeuds.              *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-#include "node-int.h"
-void g_graph_layout_refresh(GGraphLayout *layout)
-{
-    size_t i;                               /* Boucle de parcours          */
-
-
-    int counter = 0;
-
-
- restart:
-
-    g_graph_ranks_reset_reservations(layout->ranks);
-
-    bool _reset_cb(GGraphNode *node, GNodeVisitState state, void *unused)
-    {
-        g_graph_node_reset_position(node);
-        if (state == GVS_NODE)
-            g_flow_node_register_rank(G_FLOW_NODE(node), layout->ranks);
-        return true;
-    }
-
-    g_graph_node_visit_nodes(layout->nodes, (graph_node_visitor_cb)_reset_cb, NULL);
-
-    /* Traitement des positions horizontales */
-
-    for (i = 0; i < layout->edges_count; i++)
-        g_graph_edge_reserve_vertical_space(layout->edges[i], layout->nodes, layout->ranks);
-
-    /* Traitement des positions horizontales */
-
-    g_graph_node_set_x_position(layout->nodes, GRAPH_HORIZONTAL_MARGIN);
-
-    g_graph_node_prepare_x_line(layout->nodes, layout->nodes);
-    g_graph_node_apply_position(layout->nodes);
-
-
-
-    bool _reorder_cb(GGraphNode *node, GNodeVisitState state, GGraphNode *nodes)
-    {
-        if (state == GVS_NODE)
-            g_flow_node_reorder_slots(G_FLOW_NODE(node), nodes);
-        return true;
-    }
-
-    //qsort(layout->edges, layout->edges_count, sizeof(GGraphEdge *), (__compar_fn_t)g_graph_edge_compare);
-
-
-
-    if (counter++ == 0)
-    {
-    g_graph_node_visit_nodes(layout->nodes, (graph_node_visitor_cb)_reorder_cb, layout->nodes);
-    goto restart;
-    }
-
-    /*
-    bool _rinint_cb(GGraphNode *node, GNodeVisitState state, GGraphNode *nodes)
-    {
-        node->alloc.x = UNINITIALIZED_NODE_POS;
-        node->alloc.y = UNINITIALIZED_NODE_POS;
-        return true;
-    }
-
-    g_graph_node_visit_nodes(layout->nodes, (graph_node_visitor_cb)_rinint_cb, layout->nodes);
-
-
-    g_graph_node_apply_position(layout->nodes);
-    */
-
-    qsort(layout->edges, layout->edges_count, sizeof(GGraphEdge *), (__compar_fn_t)g_graph_edge_compare);
-
-
-
-    for (i = 0; i < layout->edges_count; i++)
-        g_graph_edge_reserve_horizontal_space(layout->edges[i], layout->ranks);
-
-    /* Traitement des positions verticales */
-
-    g_graph_ranks_compute_y_line(layout->ranks);
-
-    bool _apply_cb(GFlowNode *node, GNodeVisitState state, GGraphRanks *ranks)
-    {
-        if (state == GVS_NODE)
-            g_flow_node_apply_rank(node, ranks);
-        return true;
-    }
-
-    g_graph_node_visit_nodes(layout->nodes, (graph_node_visitor_cb)_apply_cb, layout->ranks);
-
-    /* Mise en place des liens */
-
-    for (i = 0; i < layout->edges_count; i++)
-        g_graph_edge_compute(layout->edges[i], layout->ranks);
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : layout = disposition en graphique prête.                     *
-*                view   = support de destination finale.                      *
-*                                                                             *
-*  Description : Dispose chaque noeud sur la surface de destination donnée.   *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-void g_graph_layout_place(GGraphLayout *layout, GtkGraphView *view)
-{
-    bool _place_cb(GFlowNode *node, GNodeVisitState state, GtkGraphView *view)
-    {
-        if (state == GVS_NODE)
-            g_flow_node_place(node, view);
-        return true;
-    }
-
-    g_graph_node_visit_nodes(layout->nodes, (graph_node_visitor_cb)_place_cb, view);
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : layout      = graphique constitué à consulter.               *
-*                requisition = dimensions souhaitées. [OUT]                   *
-*                                                                             *
-*  Description : Fournit la taille requise pour un plein rendu du graphique.  *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-void g_graph_layout_size_request(const GGraphLayout *layout, GtkRequisition *requisition)
-{
-    GtkAllocation alloc;                    /* Largeur totale requise      */
-
-    alloc = g_graph_node_get_allocation(layout->nodes);
-    requisition->width = alloc.width + 2 * GRAPH_HORIZONTAL_MARGIN;
-
-    requisition->height = g_graph_ranks_get_height(layout->ranks);
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : layout = graphique à représenter.                            *
-*                cairo  = assistant pour le rendu graphique.                  *
-*                arrow  = indique le besoin en flèche à l'arrivée.            *
-*                                                                             *
-*  Description : Dessine les liens graphiques enregistrés dans le moteur.     *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-void g_graph_layout_draw(const GGraphLayout *layout, cairo_t *cairo, bool arrow)
-{
-    size_t i;                               /* Boucle de parcours          */
-
-    for (i = 0; i < layout->edges_count; i++)
-        g_graph_edge_draw(layout->edges[i], cairo, arrow);
-
-}
diff --git a/src/gtkext/graph/layout.h b/src/gtkext/graph/layout.h
deleted file mode 100644
index 37598e8..0000000
--- a/src/gtkext/graph/layout.h
+++ /dev/null
@@ -1,73 +0,0 @@
-
-/* Chrysalide - Outil d'analyse de fichiers binaires
- * layout.h - prototypes pour la mise en place de graphique
- *
- * Copyright (C) 2009-2014 Cyrille Bagard
- *
- *  This file is part of Chrysalide.
- *
- *  OpenIDA is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 3 of the License, or
- *  (at your option) any later version.
- *
- *  OpenIDA is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with Foobar.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-
-#ifndef _GTKEXT_GRAPH_LAYOUT_H
-#define _GTKEXT_GRAPH_LAYOUT_H
-
-
-#include <stdbool.h>
-
-
-#include "edge.h"
-#include "../gtkbufferview.h"
-
-
-
-#define G_TYPE_GRAPH_LAYOUT               g_graph_layout_get_type()
-#define G_GRAPH_LAYOUT(obj)               (G_TYPE_CHECK_INSTANCE_CAST((obj), g_graph_layout_get_type(), GGraphLayout))
-#define G_IS_GRAPH_LAYOUT(obj)            (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_graph_layout_get_type()))
-#define G_GRAPH_LAYOUT_GET_IFACE(inst)    (G_TYPE_INSTANCE_GET_INTERFACE((inst), g_graph_layout_get_type(), GGraphLayoutIface))
-#define G_GRAPH_LAYOUT_GET_CLASS(obj)     (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_GRAPH_LAYOUT, GGraphLayoutClass))
-
-
-/* Mise en disposition de blocs en graphique (instance) */
-typedef struct _GGraphLayout GGraphLayout;
-
-/* Mise en disposition de blocs en graphique (classe) */
-typedef struct _GGraphLayoutClass GGraphLayoutClass;
-
-
-/* Indique le type définit par la GLib pour les mises en disposition graphique. */
-GType g_graph_layout_get_type(void);
-
-/* Construit un graphique à partir de blocs basiques. */
-GGraphLayout *g_graph_layout_new(GInstrBlock *, GtkBufferView **, size_t);
-
-/* Ajoute un lien entre deux noeuds au graphique. */
-void g_graph_layout_add_edge(GGraphLayout *, GGraphEdge *);
-
-/* Met à jour les positions des différents noeuds. */
-void g_graph_layout_refresh(GGraphLayout *);
-
-/* Dispose chaque noeud sur la surface de destination donnée. */
-void g_graph_layout_place(GGraphLayout *, GtkGraphView *);
-
-/* Fournit la taille requise pour un plein rendu du graphique. */
-void g_graph_layout_size_request(const GGraphLayout *, GtkRequisition *);
-
-/* Dessine les liens graphiques enregistrés dans le moteur. */
-void g_graph_layout_draw(const GGraphLayout *, cairo_t *, bool);
-
-
-
-#endif  /* _GRAPH_LAYOUT_H */
diff --git a/src/gtkext/graph/node-int.h b/src/gtkext/graph/node-int.h
deleted file mode 100644
index c052e0d..0000000
--- a/src/gtkext/graph/node-int.h
+++ /dev/null
@@ -1,83 +0,0 @@
-
-/* Chrysalide - Outil d'analyse de fichiers binaires
- * node-int.h - prototypes pour la gestion élémentaire des blocs sous forme de noeuds
- *
- * Copyright (C) 2013 Cyrille Bagard
- *
- *  This file is part of Chrysalide.
- *
- *  OpenIDA is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 3 of the License, or
- *  (at your option) any later version.
- *
- *  OpenIDA is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with Foobar.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-
-#ifndef _GTKEXT_GRAPH_NODE_INT_H
-#define _GTKEXT_GRAPH_NODE_INT_H
-
-
-#include "node.h"
-
-
-
-/* Fournit le rang du noeud dans le graphique. */
-typedef unsigned int (* get_node_rank_fc) (const GGraphNode *);
-
-/* Réinitialise la position d'un noeud d'encapsulation. */
-typedef void (* node_reset_pos_fc) (GGraphNode *);
-
-/* Définit les abscisses relatives du contenu d'un noeud. */
-typedef void (* node_prepare_x_fc) (GGraphNode *, GGraphNode *);
-
-/* Applique une position finale au noeud. */
-typedef void (* node_apply_pos_fc) (GGraphNode *);
-
-/* Altère la position du noeud d'encapsulation. */
-typedef void (* node_set_pos_fc) (GGraphNode *, gint);
-
-/* Parcourt tous les noeuds graphiques dans un ordre donné. */
-typedef bool (* visit_flow_nodes_fc) (GGraphNode *, graph_node_visitor_cb, void *);
-
-/* Recherche le noeud contenant un autre noeud. */
-typedef GGraphNode * (* find_container_fc) (GGraphNode *, GGraphNode *);
-
-
-/* Intermédiaire entre le noeud dot et la bribe de code (instance) */
-struct _GGraphNode
-{
-    GObject parent;                         /* A laisser en premier        */
-
-    GtkAllocation alloc;                    /* Emplacement du bloc rattaché*/
-    PendingPositionFlags pending_flag;      /* Cible le champ valide       */
-    pending_position pending_pos;           /* Indication sur la position  */
-
-};
-
-
-/* Intermédiaire entre le noeud dot et la bribe de code (classe) */
-struct _GGraphNodeClass
-{
-    GObjectClass parent;                    /* A laisser en premier        */
-
-    get_node_rank_fc get_rank;              /* Premier rang d'appartenance */
-    node_reset_pos_fc reset_pos;            /* Réinitialise l'emplacement  */
-    node_prepare_x_fc prepare_x;            /* Préparation des abscisses   */
-    node_apply_pos_fc apply_pos;            /* Applique une absisse finale */
-    node_set_pos_fc set_pos;                /* Définit l'emplacement       */
-    visit_flow_nodes_fc visit;              /* Visite des noeuds d'exécut° */
-    find_container_fc contain;              /* Retrouve un conteneur       */
-
-};
-
-
-
-#endif  /* _GTKEXT_GRAPH_NODE_INT_H */
diff --git a/src/gtkext/graph/node.c b/src/gtkext/graph/node.c
deleted file mode 100644
index 08dd970..0000000
--- a/src/gtkext/graph/node.c
+++ /dev/null
@@ -1,634 +0,0 @@
-
-/* Chrysalide - Outil d'analyse de fichiers binaires
- * node.c - éléments de graphiques chez dot
- *
- * Copyright (C) 2009-2013 Cyrille Bagard
- *
- *  This file is part of Chrysalide.
- *
- *  OpenIDA is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 3 of the License, or
- *  (at your option) any later version.
- *
- *  OpenIDA is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with Foobar.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-
-#include "node.h"
-
-
-#include <assert.h>
-#include <malloc.h>
-#include <stdio.h>
-#include <string.h>
-
-
-#include "node-int.h"
-#include "nodes/flow.h"
-#include "nodes/virtual.h"
-#include "../../common/extstr.h"
-
-
-
-/* -------------------------- GESTION DES NOEUDS A L'UNITE -------------------------- */
-
-
-/* Initialise la classe des intermédiaires avec les noeuds dot. */
-static void g_graph_node_class_init(GGraphNodeClass *);
-
-/* Initialise la classe des intermédiaires avec les noeuds dot. */
-static void g_graph_node_init(GGraphNode *);
-
-/* Supprime toutes les références externes. */
-static void g_graph_node_dispose(GGraphNode *);
-
-/* Procède à la libération totale de la mémoire. */
-static void g_graph_node_finalize(GGraphNode *);
-
-
-
-/* ---------------------------------------------------------------------------------- */
-/*                            GESTION DES NOEUDS A L'UNITE                            */
-/* ---------------------------------------------------------------------------------- */
-
-
-/* Indique le type définit par la GLib pour le noeud. */
-G_DEFINE_TYPE(GGraphNode, g_graph_node, G_TYPE_OBJECT);
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : klass = classe à initialiser.                                *
-*                                                                             *
-*  Description : Initialise la classe des intermédiaires avec les noeuds dot. *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static void g_graph_node_class_init(GGraphNodeClass *klass)
-{
-    GObjectClass *object;                   /* Autre version de la classe  */
-
-    object = G_OBJECT_CLASS(klass);
-
-    object->dispose = (GObjectFinalizeFunc/* ! */)g_graph_node_dispose;
-    object->finalize = (GObjectFinalizeFunc)g_graph_node_finalize;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : node = instance à initialiser.                               *
-*                                                                             *
-*  Description : Initialise la classe des intermédiaires avec les noeuds dot. *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static void g_graph_node_init(GGraphNode *node)
-{
-    node->alloc.x = UNINITIALIZED_NODE_POS;
-    node->alloc.y = UNINITIALIZED_NODE_POS;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : node = instance d'objet GLib à traiter.                      *
-*                                                                             *
-*  Description : Supprime toutes les références externes.                     *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static void g_graph_node_dispose(GGraphNode *node)
-{
-    G_OBJECT_CLASS(g_graph_node_parent_class)->dispose(G_OBJECT(node));
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : node = instance d'objet GLib à traiter.                      *
-*                                                                             *
-*  Description : Procède à la libération totale de la mémoire.                *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static void g_graph_node_finalize(GGraphNode *node)
-{
-    G_OBJECT_CLASS(g_graph_node_parent_class)->finalize(G_OBJECT(node));
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : node = noeud graphique à consulter.                          *
-*                                                                             *
-*  Description : Fournit le rang du noeud dans le graphique.                  *
-*                                                                             *
-*  Retour      : Indice supérieur ou égal à zéro.                             *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-unsigned int g_graph_node_get_rank(const GGraphNode *node)
-{
-    return G_GRAPH_NODE_GET_CLASS(node)->get_rank(node);
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : node = noeud graphique à manipuler.                          *
-*                                                                             *
-*  Description : Réinitialise la position d'un noeud de graphique.            *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-void g_graph_node_reset_position(GGraphNode *node)
-{
-    node->alloc.x = UNINITIALIZED_NODE_POS;
-    node->alloc.y = UNINITIALIZED_NODE_POS;
-
-    node->pending_flag = PPF_NONE;
-
-    if (G_GRAPH_NODE_GET_CLASS(node)->reset_pos != NULL)
-        G_GRAPH_NODE_GET_CLASS(node)->reset_pos(node);
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : node  = noeud d'encapsulation à traiter.                     *
-*                nodes = ensemble des noeuds en place.                        *
-*                                                                             *
-*  Description : Définit les abscisses relatives du contenu d'un noeud.       *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-void g_graph_node_prepare_x_line(GGraphNode *node, GGraphNode *nodes)
-{
-    G_GRAPH_NODE_GET_CLASS(node)->prepare_x(node, nodes);
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : node = noeud graphique à manipuler.                          *
-*                                                                             *
-*  Description : Applique une position finale au noeud.                       *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-void g_graph_node_apply_position(GGraphNode *node)
-{
-    gint x_pos;                             /* Position de référence       */
-    GGraphNode *ref;                        /* Accès rapide                */
-
-    if (G_GRAPH_NODE_GET_CLASS(node)->apply_pos != NULL)
-        G_GRAPH_NODE_GET_CLASS(node)->apply_pos(node);
-
-    switch (node->pending_flag)
-    {
-        case PPF_DIRECT_X:
-            assert(g_graph_node_has_x_position(node->pending_pos.relative_ref));
-            g_graph_node_get_position(node->pending_pos.relative_ref, &x_pos, NULL);
-            x_pos += node->pending_pos.direct_x;
-            g_graph_node_set_x_position(node, x_pos);
-            break;
-
-        case PPF_LEFT_MARGIN:
-            assert(g_graph_node_has_x_position(node->pending_pos.relative_ref));
-            g_graph_node_get_position(node->pending_pos.relative_ref, &x_pos, NULL);
-            x_pos += EDGE_SLOT_HORIZ_MARGIN + node->pending_pos.left_margin;
-            g_graph_node_set_x_position(node, x_pos);
-            break;
-
-        case PPF_RIGHT_MARGIN:
-            assert(g_graph_node_has_x_position(node->pending_pos.relative_ref));
-            g_graph_node_get_position(node->pending_pos.relative_ref, &x_pos, NULL);
-            x_pos += node->pending_pos.right_margin;
-            x_pos -= (EDGE_SLOT_HORIZ_MARGIN + node->alloc.width);
-            g_graph_node_set_x_position(node, x_pos);
-            break;
-
-        case PPF_LEFT_NODE:
-            ref = node->pending_pos.left_node;
-            x_pos = ref->alloc.x - NODE_HORIZONTAL_MARGIN - node->alloc.width;
-            g_graph_node_set_x_position(node, x_pos);
-            break;
-
-        case PPF_RIGHT_NODE:
-            ref = node->pending_pos.right_node;
-            x_pos = ref->alloc.x + ref->alloc.width - NODE_HORIZONTAL_MARGIN;
-            g_graph_node_set_x_position(node, x_pos);
-            break;
-
-        default:
-            /* Position traitée par l'appelant */
-            break;
-
-    }
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : node = noeud graphique à manipuler.                          *
-*  Paramètres  : node   = noeud graphique à manipuler.                        *
-*                x      = abscisse à intégrer.                                *
-*                direct = indique un tracé direct éventuel.                   *
-*                                                                             *
-*  Description : Altère la position du noeud d'encapsulation.                 *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-void g_graph_node_set_x_position(GGraphNode *node, gint x)
-{
-    if (G_GRAPH_NODE_GET_CLASS(node)->set_pos != NULL && x != GRAPH_HORIZONTAL_MARGIN)
-        G_GRAPH_NODE_GET_CLASS(node)->set_pos(node, x);
-
-    node->alloc.x = x;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : node = noeud graphique à manipuler.                          *
-*                flag = nature de l'indication à intégrer.                    *
-*                pos  = argument supplémentaire à venir chercher.             *
-*                                                                             *
-*  Description : Prépare la position du noeud pour l'alignement des liens.    *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-void g_graph_node_set_pending_position(GGraphNode *node, PendingPositionFlags flag, pending_position pos)
-{
-    if (node->pending_flag != PPF_NONE && node->pending_flag != PPF_MIDDLE_OF)
-        return;
-
-    node->pending_flag = flag;
-    node->pending_pos = pos;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : node = noeud graphique à manipuler.                          *
-*                flag = nature de l'indication à intégrer. [OUT]              *
-*                pos  = argument supplémentaire à venir chercher. [OUT]       *
-*                                                                             *
-*  Description : Indique la position du noeud pour l'alignement des liens.    *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-void g_graph_node_get_pending_position(GGraphNode *node, PendingPositionFlags *flag, pending_position *pos)
-{
-    *flag = node->pending_flag;
-
-    if (pos != NULL)
-        *pos = node->pending_pos;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : node = noeud graphique à consulter.                          *
-*                x    = éventuelle abscisse à recevoir ou NULL. [OUT]         *
-*                y    = éventuelle ordonnée à recevoir ou NULL. [OUT]         *
-*                                                                             *
-*  Description : Fournit la position du noeud d'encapsulation.                *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-void g_graph_node_get_position(const GGraphNode *node, gint *x, gint *y)
-{
-    if (x != NULL) *x = node->alloc.x;
-    if (y != NULL) *y = node->alloc.y;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : node = noeud graphique à consulter.                          *
-*                                                                             *
-*  Description : Indique l'espace requis pour un noeud d'encapsulation.       *
-*                                                                             *
-*  Retour      : Espace constitué, entièrement ou non.                        *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-GtkAllocation g_graph_node_get_allocation(const GGraphNode *node)
-{
-    return node->alloc;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : node     = noeud graphique démarrant la visite.              *
-*                callback = ensemble de blocs à parcourir.                    *
-*                data     = donnée utilisateur à associer au parcours.        *
-*                                                                             *
-*  Description : Parcourt tous les noeuds graphiques dans un ordre donné.     *
-*                                                                             *
-*  Retour      : true si le parcours a été jusqu'à son terme, false sinon.    *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-bool g_graph_node_visit_nodes(GGraphNode *node, graph_node_visitor_cb callback, void *data)
-{
-    return G_GRAPH_NODE_GET_CLASS(node)->visit(node, callback, data);
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : nodes  = noeud au sommet de la hiérarchie.                   *
-*                target = élément à retrouver dans l'ensemble de noeuds.      *
-*                                                                             *
-*  Description : Recherche le noeud contenant un autre noeud.                 *
-*                                                                             *
-*  Retour      : Noeud trouvé ou NULL si aucun.                               *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-GGraphNode *g_graph_node_find_container(GGraphNode *nodes, GGraphNode *target)
-{
-    GGraphNode *result;                     /* Trouvaille à retourner      */
-
-    result = NULL;
-
-    if (G_GRAPH_NODE_GET_CLASS(nodes)->contain != NULL)
-        result = G_GRAPH_NODE_GET_CLASS(nodes)->contain(nodes, target);
-
-    return result;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : nodes  = noeud au sommet de la hiérarchie.                   *
-*                ref    = noeud indiquant le niveau de référence.             *
-*                target = élément à retrouver dans l'ensemble de noeuds.      *
-*                                                                             *
-*  Description : Recherche le noeud contenant un autre noeud à un même niveau.*
-*                                                                             *
-*  Retour      : Noeud trouvé ou NULL si aucun.                               *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-GGraphNode *g_graph_node_find_container_at_same_level(GGraphNode *nodes, GGraphNode *ref, GGraphNode *target)
-{
-    GGraphNode *result;                     /* Trouvaille à retourner      */
-    GGraphNode *level;                      /* Niveau de référence         */
-    GGraphNode *container;                  /* Support de la cible         */
-
-    result = NULL;
-
-    level = g_graph_node_find_container(nodes, ref);
-
-    container = g_graph_node_find_container(nodes, target);
-
-    if (container == level)
-        result = target;
-    else
-    {
-        if (container == NULL)
-            result = NULL;
-        else
-            result = g_graph_node_find_container_at_same_level(nodes, ref, container);
-    }
-
-    return result;
-
-}
-
-
-
-/* ---------------------------------------------------------------------------------- */
-/*                         MANIPULATION D'ENSEMBLES DE NOEUDS                         */
-/* ---------------------------------------------------------------------------------- */
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : views = liste de vues à parcourir.                           *
-*                count = taille de la liste.                                  *
-*                addrt = adresse de début du noeud recherché.                 *
-*                                                                             *
-*  Description : Recherche une vue donnée dans une série de vues.             *
-*                                                                             *
-*  Retour      : Vue trouvée ou NULL si aucun.                                *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-GtkBufferView *find_graph_view_by_start_address(GtkBufferView **views, size_t count, const vmpa2t *addr)
-{
-    GtkBufferView *result;                  /* Trouvaille à remonter       */
-    size_t i;                               /* Boucle de parcours          */
-    GBufferView *buffer;                    /* Tampon d'une partie de code */
-    vmpa2t start;                           /* Adresse de départ du tampon */
-
-    result = NULL;
-
-    for (i = 0; i < count && result == NULL; i++)
-    {
-        buffer = gtk_buffer_view_get_buffer(views[i]);
-        g_buffer_view_get_restrictions(buffer, &start, NULL);
-
-        if (cmp_vmpa(&start, addr) == 0)
-            result = views[i];
-
-    }
-
-    return result;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : block = ensemble des blocs basiques déjà découpés.           *
-*                views = morceaux de code à afficher de façon organisée.      *
-*                count = quantité de ces morceaux de code.                    *
-*                                                                             *
-*  Description : Réalise une conversion de blocs en noeuds.                   *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-GGraphNode *convert_blocks_into_nodes(GInstrBlock *block, GtkBufferView **views, size_t count)
-{
-    GGraphNode *result;                     /* Instance nouvelle à renvoyer*/
-    vmpa2t start;                           /* Adresse de départ           */
-    GtkBufferView *view;                    /* Vue existante à retrouver   */
-    size_t max;                             /* Nombre de blocs à gérer     */
-    size_t i;                               /* Boucle de parcours          */
-    GInstrBlock *sub_block;                 /* Sous-bloc intégré           */
-    GGraphNode *child;                      /* Conversion à mémoriser      */
-
-    result = NULL;
-
-    if (G_IS_FLOW_BLOCK(block))
-    {
-        g_flow_block_get_boundary_addresses(G_FLOW_BLOCK(block), &start, NULL);
-        view = find_graph_view_by_start_address(views, count, &start);
-
-        result = g_flow_node_new(G_FLOW_BLOCK(block), view);
-
-    }
-    else if (G_IS_VIRTUAL_BLOCK(block))
-    {
-        result = g_virtual_node_new(G_VIRTUAL_BLOCK(block));
-
-        max = g_virtual_block_count_children(G_VIRTUAL_BLOCK(block));
-
-        for (i = 0; i < max; i++)
-        {
-            sub_block = g_virtual_block_get_child(G_VIRTUAL_BLOCK(block), i);
-            child = convert_blocks_into_nodes(sub_block, views, count);
-
-            g_virtual_node_add_child(G_VIRTUAL_NODE(result), child);
-
-        }
-
-    }
-    /*else BUG_ON(1); */
-
-    return result;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : nodes = noeud au sommet de la hiérarchie.                    *
-*                instr = instruction à retrouver.                             *
-*                entry = position de cette instruction : première ou dernière.*
-*                                                                             *
-*  Description : Recherche le noeud contenant une instruction donnée.         *
-*                                                                             *
-*  Retour      : Noeud trouvé ou NULL.                                        *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-GGraphNode *_find_node_for_instruction(GGraphNode *nodes, GArchInstruction *instr, bool entry)
-{
-    GGraphNode *result;                     /* Trouvaille à retourner      */
-    struct visit_params {
-        GArchInstruction *instr;            /* Instruction recherchée      */
-        bool entry;                         /* Première ou dernière ?      */
-        GGraphNode *found;                  /* Remontée du noeud trouvé    */
-    } params;                               /* Paramètres pour le parcours */
-
-    params.instr = instr;
-    params.entry = entry;
-    params.found = NULL;
-
-    bool _find_node_cb(GFlowNode *node, GNodeVisitState state, struct visit_params *params)
-    {
-        bool result;
-
-        if (state == GVS_NODE)
-        {
-            if ((params->entry && g_flow_node_start_with(node, params->instr))
-                || (!params->entry && g_flow_node_end_with(node, params->instr)))
-            {
-                params->found = G_GRAPH_NODE(node);
-            }
-            result = (params->found == NULL);
-        }
-        else result = true;
-
-        return result;
-
-    }
-
-    g_graph_node_visit_nodes(nodes, (graph_node_visitor_cb)_find_node_cb, &params);
-
-    result = params.found;
-
-    return result;
-
-}
diff --git a/src/gtkext/graph/node.h b/src/gtkext/graph/node.h
deleted file mode 100644
index 6d3589a..0000000
--- a/src/gtkext/graph/node.h
+++ /dev/null
@@ -1,174 +0,0 @@
-
-/* Chrysalide - Outil d'analyse de fichiers binaires
- * node.h - prototypes pour les éléments de graphiques chez dot
- *
- * Copyright (C) 2009-2013 Cyrille Bagard
- *
- *  This file is part of Chrysalide.
- *
- *  OpenIDA is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 3 of the License, or
- *  (at your option) any later version.
- *
- *  OpenIDA is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with Foobar.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-
-#ifndef _GTKEXT_GRAPH_NODE_H
-#define _GTKEXT_GRAPH_NODE_H
-
-
-#include "params.h"
-#include "ranks.h"
-#include "../gtkbufferview.h"
-#include "../gtkgraphview.h"
-#include "../../arch/instruction.h"
-#include "../../analysis/block.h"
-
-
-
-/* -------------------------- GESTION DES NOEUDS A L'UNITE -------------------------- */
-
-
-#define G_TYPE_GRAPH_NODE                  (g_graph_node_get_type())
-#define G_GRAPH_NODE(obj)                  (G_TYPE_CHECK_INSTANCE_CAST((obj), G_TYPE_GRAPH_NODE, GGraphNode))
-#define G_GRAPH_NODE_CLASS(klass)          (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_GRAPH_NODE, GGraphNodeClass))
-#define G_IS_GRAPH_NODE(obj)               (G_TYPE_CHECK_INSTANCE_TYPE((obj), G_TYPE_GRAPH_NODE))
-#define G_IS_GRAPH_NODE_CLASS(klass)       (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_GRAPH_NODE))
-#define G_GRAPH_NODE_GET_CLASS(obj)        (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_GRAPH_NODE, GGraphNodeClass))
-
-
-/* Intermédiaire entre le noeud dot et la bribe de code (instance) */
-typedef struct _GGraphNode GGraphNode;
-
-/* Intermédiaire entre le noeud dot et la bribe de code (classe) */
-typedef struct _GGraphNodeClass GGraphNodeClass;
-
-
-/* Indications sur l'abscisse idéale à adopter */
-typedef union _pending_position
-{
-    /* PPF_DIRECT_X, PPF_LEFT_MARGIN, PPF_RIGHT_MARGIN */
-    struct
-    {
-        union
-        {
-            gint direct_x;                  /* Position strictement vert.  */
-            gint left_margin;               /* Limite à ne pas dépasser #1 */
-            gint right_margin;              /* Limite à ne pas dépasser #2 */
-        };
-        GGraphNode *relative_ref;           /* Eventuelle ref. relative    */
-    };
-
-    /* PPF_LEFT_NODE, PPF_RIGHT_NODE, PPF_MIDDLE_OF */
-    struct
-    {
-        GGraphNode *left_node;              /* Noeud de référence à droite */
-        GGraphNode *right_node;             /* Noeud de référence à gauche */
-    };
-
-} pending_position;
-
-/* Définition présente dans les indications */
-typedef enum _PendingPositionFlags
-{
-    PPF_NONE,                               /* Aucune -> centrage          */
-    PPF_DIRECT_X,                           /* Position strictement vert.  */
-    PPF_LEFT_MARGIN,                        /* Limite à ne pas dépasser #1 */
-    PPF_RIGHT_MARGIN,                       /* Limite à ne pas dépasser #2 */
-    PPF_LEFT_NODE,                          /* Noeud de référence à droite */
-    PPF_RIGHT_NODE,                         /* Noeud de référence à gauche */
-    PPF_MIDDLE_OF                           /* Centré entre deux noeuds    */
-
-} PendingPositionFlags;
-
-/* Détail sur une visite */
-typedef enum _GNodeVisitState
-{
-    GVS_ENTER,                              /* Entrée dans un groupe       */
-    GVS_NODE,                               /* Traitement d'une feuille    */
-    GVS_EXIT                                /* Sortie d'un groupe          */
-
-} GNodeVisitState;
-
-/* Rappel à chaque noeud visité */
-typedef bool (* graph_node_visitor_cb) (GGraphNode *, GNodeVisitState, void *);
-
-
-/* Indique le type définit par la GLib pour le noeud. */
-GType g_graph_node_get_type(void);
-
-/* Fournit le rang du noeud dans le graphique. */
-unsigned int g_graph_node_get_rank(const GGraphNode *);
-
-/* Réinitialise la position d'un noeud de graphique. */
-void g_graph_node_reset_position(GGraphNode *);
-
-/* Définit les abscisses relatives du contenu d'un noeud. */
-void g_graph_node_prepare_x_line(GGraphNode *node, GGraphNode *nodes);
-
-/* Applique une position finale au noeud. */
-void g_graph_node_apply_position(GGraphNode *);
-
-/* Altère la position du noeud d'encapsulation. */
-void g_graph_node_set_x_position(GGraphNode *, gint);
-
-/* Prépare la position du noeud pour l'alignement des liens. */
-void g_graph_node_set_pending_position(GGraphNode *, PendingPositionFlags, pending_position);
-
-/* Indique la position du noeud pour l'alignement des liens. */
-void g_graph_node_get_pending_position(GGraphNode *, PendingPositionFlags *, pending_position *);
-
-/* Fournit la position du noeud d'encapsulation. */
-void g_graph_node_get_position(const GGraphNode *, gint *, gint *);
-
-#define g_graph_node_has_x_position(node)           \
-    ({                                              \
-        gint _x;                                    \
-        g_graph_node_get_position(node, &_x, NULL); \
-        _x != UNINITIALIZED_NODE_POS;               \
-    })
-
-/* Espace constitué, entièrement ou non. */
-GtkAllocation g_graph_node_get_allocation(const GGraphNode *);
-
-/* Parcourt tous les noeuds graphiques dans un ordre donné. */
-bool g_graph_node_visit_nodes(GGraphNode *, graph_node_visitor_cb, void *);
-
-/* Recherche le noeud contenant un autre noeud. */
-GGraphNode *g_graph_node_find_container(GGraphNode *, GGraphNode *);
-
-/* Recherche le noeud contenant un autre noeud à un même niveau. */
-GGraphNode *g_graph_node_find_container_at_same_level(GGraphNode *, GGraphNode *, GGraphNode *);
-
-
-
-/* ----------------------- MANIPULATION D'ENSEMBLES DE NOEUDS ----------------------- */
-
-
-/* Recherche une vue donnée dans une série de vues. */
-GtkBufferView *find_graph_view_by_start_address(GtkBufferView **, size_t, const vmpa2t *);
-
-/* Réalise une conversion de blocs en noeuds. */
-GGraphNode *convert_blocks_into_nodes(GInstrBlock *, GtkBufferView **, size_t);
-
-/* Recherche le noeud contenant une instruction donnée. */
-GGraphNode *_find_node_for_instruction(GGraphNode *, GArchInstruction *, bool);
-
-
-#define find_node_for_first_instruction(nds, ins)     \
-    _find_node_for_instruction(nds, ins, true)
-
-#define find_node_for_last_instruction(nds, ins) \
-    _find_node_for_instruction(nds, ins, false)
-
-
-
-#endif  /* _GRAPH_NODE_H */
diff --git a/src/gtkext/graph/nodes/Makefile.am b/src/gtkext/graph/nodes/Makefile.am
deleted file mode 100755
index 50f26f1..0000000
--- a/src/gtkext/graph/nodes/Makefile.am
+++ /dev/null
@@ -1,15 +0,0 @@
-
-noinst_LTLIBRARIES  = libgtkextgraphnodes.la
-
-libgtkextgraphnodes_la_SOURCES =		\
-	flow.h flow.c						\
-	virtual.h virtual.c
-
-libgtkextgraphnodes_la_LDFLAGS = 
-
-
-AM_CPPFLAGS = $(LIBGTK_CFLAGS) $(LIBXML_CFLAGS)
-
-AM_CFLAGS = $(DEBUG_CFLAGS) $(WARNING_FLAGS) $(COMPLIANCE_FLAGS)
-
-SUBDIRS = 
diff --git a/src/gtkext/graph/nodes/flow.c b/src/gtkext/graph/nodes/flow.c
deleted file mode 100644
index e19cacb..0000000
--- a/src/gtkext/graph/nodes/flow.c
+++ /dev/null
@@ -1,1329 +0,0 @@
-
-/* Chrysalide - Outil d'analyse de fichiers binaires
- * flow.c - encapsulation graphique des blocs d'exécution
- *
- * Copyright (C) 2013 Cyrille Bagard
- *
- *  This file is part of Chrysalide.
- *
- *  OpenIDA is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 3 of the License, or
- *  (at your option) any later version.
- *
- *  OpenIDA is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with Foobar.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-
-#include "flow.h"
-
-
-#include <assert.h>
-#include <malloc.h>
-#include <stdlib.h>
-
-
-#include "../layout.h"
-#include "../node-int.h"
-
-
-
-/* Type d'un accrochage pour lien */
-struct _node_slot_t
-{
-    GArchInstruction *instr;                /* Instruction liée            */
-    size_t group_index;                     /* Rang dans le grp d'origine  */
-
-    InstructionLinkType type;               /* Type de lien à représenter  */
-    size_t slot_index;                      /* Position dans l'accroche    */
-    gint x;                                 /* Abscisse graphique du rendu */
-
-};
-
-/* Encapsulation graphique d'un bloc d'exécution (instance) */
-struct _GFlowNode
-{
-    GGraphNode parent;                      /* A laisser en premier        */
-
-    GFlowBlock *block;                      /* Bloc d'exécution associé    */
-    GtkBufferView *view;                    /* Représentation graphique    */
-
-    node_slot_t *entries;                   /* Positions des pts d'entrées */
-    size_t entries_count;                   /* Nombre de ces points        */
-    node_slot_t *exits;                     /* Positions des pts de sorties*/
-    size_t exits_count;                     /* Nombre de ces points        */
-
-};
-
-/* Encapsulation graphique d'un bloc d'exécution (classe) */
-struct _GFlowNodeClass
-{
-    GGraphNodeClass parent;                 /* A laisser en premier        */
-
-};
-
-
-#define SPACE_BETWEEN_SLOT 15
-
-
-/* Initialise la classe des encapsulations de bloc d'exécution. */
-static void g_flow_node_class_init(GFlowNodeClass *);
-
-/* Initialise une encapsulation de bloc d'exécution. */
-static void g_flow_node_init(GFlowNode *);
-
-/* Supprime toutes les références externes. */
-static void g_flow_node_dispose(GFlowNode *);
-
-/* Procède à la libération totale de la mémoire. */
-static void g_flow_node_finalize(GFlowNode *);
-
-/* Fournit le rang du noeud dans le graphique. */
-static unsigned int g_flow_node_get_rank(const GFlowNode *);
-
-/* Organise le contenu du noeud selon l'axe des abscisses. */
-static void g_flow_node_prepare_x_line(GFlowNode *, GGraphNode *);
-
-/* Parcourt tous les blocs d'instructions dans un ordre donné. */
-static bool g_flow_node_visit_flow_nodes(GFlowNode *, graph_node_visitor_cb, void *);
-
-
-
-/* ------------------------ GESTION DES ACCROCHES D'UN NOEUD ------------------------ */
-
-
-/* Prépare les points d'entrées du noeud. */
-static void g_flow_node_setup_entry_slots(GFlowNode *);
-
-/* Prépare les points de sorties du noeud. */
-static void g_flow_node_setup_exit_slots(GFlowNode *);
-
-/* Etablit un lien entre deux noeuds graphiques. */
-static node_slot_t *g_flow_node_get_slot(const GFlowNode *, bool, GArchInstruction *, size_t);
-
-/* Localise un point d'accroche à un noeud graphique. */
-static gint g_flow_node_get_slot_offset(const GFlowNode *, bool, const node_slot_t *);
-
-
-
-
-/* Indique le type définit par la GLib pour l'encapsulation d'un bloc d'exécution. */
-G_DEFINE_TYPE(GFlowNode, g_flow_node, G_TYPE_GRAPH_NODE);
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : klass = classe à initialiser.                                *
-*                                                                             *
-*  Description : Initialise la classe des encapsulations de bloc d'exécution. *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static void g_flow_node_class_init(GFlowNodeClass *klass)
-{
-    GObjectClass *object;                   /* Autre version de la classe  */
-    GGraphNodeClass *node_class;            /* Version parente de la classe*/
-
-    object = G_OBJECT_CLASS(klass);
-    node_class = G_GRAPH_NODE_CLASS(klass);
-
-    object->dispose = (GObjectFinalizeFunc/* ! */)g_flow_node_dispose;
-    object->finalize = (GObjectFinalizeFunc)g_flow_node_finalize;
-
-    node_class->get_rank = (get_node_rank_fc)g_flow_node_get_rank;
-    node_class->prepare_x = (node_prepare_x_fc)g_flow_node_prepare_x_line;
-    node_class->visit = (visit_flow_nodes_fc)g_flow_node_visit_flow_nodes;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : node = instance à initialiser.                               *
-*                                                                             *
-*  Description : Initialise une encapsulation de bloc d'exécution.            *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static void g_flow_node_init(GFlowNode *node)
-{
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : node = instance d'objet GLib à traiter.                      *
-*                                                                             *
-*  Description : Supprime toutes les références externes.                     *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static void g_flow_node_dispose(GFlowNode *node)
-{
-    size_t i;                               /* Boucle de parcours          */
-
-    g_object_unref(G_OBJECT(node->block));
-    g_object_unref(G_OBJECT(node->view));
-
-    for (i = 0; i < node->entries_count; i++)
-        g_object_unref(G_OBJECT(node->entries[i].instr));
-
-    for (i = 0; i < node->exits_count; i++)
-        g_object_unref(G_OBJECT(node->exits[i].instr));
-
-    G_OBJECT_CLASS(g_flow_node_parent_class)->dispose(G_OBJECT(node));
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : node = instance d'objet GLib à traiter.                      *
-*                                                                             *
-*  Description : Procède à la libération totale de la mémoire.                *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static void g_flow_node_finalize(GFlowNode *node)
-{
-    if (node->entries != NULL)
-        free(node->entries);
-
-    if (node->exits != NULL)
-        free(node->exits);
-
-    G_OBJECT_CLASS(g_flow_node_parent_class)->finalize(G_OBJECT(node));
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : block = bloc d'exécution représenté graphiquement.           *
-*                view  = morceau d'affichage à représenter.                   *
-*                                                                             *
-*  Description : Encapsule graphiquement un bloc d'exécution.                 *
-*                                                                             *
-*  Retour      : Adresse de la structure mise en place.                       *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-GGraphNode *g_flow_node_new(GFlowBlock *block, GtkBufferView *view)
-{
-    GFlowNode *result;                      /* Structure à retourner       */
-    GtkRequisition requisition;             /* Taille à l'écran actuelle   */
-
-    result = g_object_new(G_TYPE_FLOW_NODE, NULL);
-
-    g_object_ref(G_OBJECT(block));
-    g_object_ref(G_OBJECT(view));
-
-    result->block = block;
-    result->view = view;
-
-    gtk_widget_show(GTK_WIDGET(result->view));
-    gtk_widget_size_allocate(GTK_WIDGET(result->view), (GtkAllocation []) { { 0, 0, 100, 100 } });
-
-    gtk_widget_get_preferred_size(GTK_WIDGET(result->view), NULL, &requisition);
-
-    G_GRAPH_NODE(result)->alloc.width = requisition.width;
-    G_GRAPH_NODE(result)->alloc.height = requisition.height;
-
-    g_flow_node_setup_entry_slots(result);
-    g_flow_node_setup_exit_slots(result);
-
-    return G_GRAPH_NODE(result);
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : node = noeud graphique à consulter.                          *
-*                                                                             *
-*  Description : Fournit le rang du noeud dans le graphique.                  *
-*                                                                             *
-*  Retour      : Indice supérieur ou égal à zéro.                             *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static unsigned int g_flow_node_get_rank(const GFlowNode *node)
-{
-    return g_flow_block_get_rank(node->block);
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : node  = noeud d'encapsulation à traiter.                     *
-*                nodes = ensemble des noeuds en place.                        *
-*                                                                             *
-*  Description : Organise le contenu du noeud selon l'axe des abscisses.      *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static void g_flow_node_prepare_x_line(GFlowNode *node, GGraphNode *nodes)
-{
-    GGraphNode *base;                       /* Autre vision de l'instance  */
-    GArchInstruction *last;                 /* Dernière instr. du noeud    */
-    size_t loop_index;                      /* Indice de sortie en boucle  */
-    GFlowNode *target;                      /* Bloc visé par le lien       */
-    node_slot_t *dest_slot;                 /* Accrochage d'arrivée        */
-    pending_position pos;                   /* Position à transmettre      */
-    GFlowNode *target_a;                    /* Bloc visé par le lien #a    */
-    GFlowNode *target_b;                    /* Bloc visé par le lien #b    */
-    unsigned int rank_a;                    /* Indice du rang associé #a   */
-    unsigned int rank_b;                    /* Indice du rang associé #b   */
-    GGraphNode *container;                  /* Conteneur à positionner     */
-
-    base = G_GRAPH_NODE(node);
-
-    g_flow_block_get_boundary(node->block, NULL, &last);
-
-    for (loop_index = 0; loop_index < node->exits_count; loop_index++)
-        if (node->exits[loop_index].type == ILT_LOOP)
-            break;
-
-    switch (node->exits_count - (loop_index == node->exits_count ? 0 : 1))
-    {
-        case 0:
-            break;
-
-        case 1:
-
-            if (loop_index == node->exits_count)
-            {
-                target = G_FLOW_NODE(find_node_for_first_instruction(nodes, node->exits[0].instr));
-
-                /* Cf. commentaire de g_flow_node_link() */
-                if (target == NULL) break;
-
-                dest_slot = g_flow_node_get_slot(target, true,
-                                                 last, node->exits[0].group_index);
-
-            }
-            else
-            {
-                target = G_FLOW_NODE(find_node_for_first_instruction(nodes, node->exits[1].instr));
-
-                /* Cf. commentaire de g_flow_node_link() */
-                if (target == NULL) break;
-
-                dest_slot = g_flow_node_get_slot(target, true,
-                                                 last, node->exits[1].group_index);
-
-            }
-
-            pos.direct_x = g_flow_node_get_slot_offset(target, true, dest_slot);
-            pos.direct_x = (G_GRAPH_NODE(target)->alloc.width / 2) - pos.direct_x;
-
-            pos.direct_x -= (G_GRAPH_NODE(target)->alloc.width - G_GRAPH_NODE(node)->alloc.width) / 2;
-
-            pos.relative_ref = base;
-
-            size_t count_and_skip_loop(GFlowNode *n)
-            {
-                size_t counter;
-
-                for (counter = 0; counter < n->entries_count; counter++)
-                    if (n->entries[counter].type == ILT_LOOP)
-                        break;
-
-                return counter < n->entries_count ? n->entries_count - 1 : n->entries_count;
-
-            }
-
-            if (count_and_skip_loop(target) == 1)
-                g_graph_node_set_pending_position(G_GRAPH_NODE(target), PPF_DIRECT_X, pos);
-
-            break;
-
-        case 2:
-
-            target_a = G_FLOW_NODE(find_node_for_first_instruction(nodes, node->exits[0].instr));
-            target_b = G_FLOW_NODE(find_node_for_first_instruction(nodes, node->exits[1].instr));
-
-            rank_a = g_flow_node_get_rank(target_a);
-            rank_b = g_flow_node_get_rank(target_b);
-
-            if (rank_a == rank_b)
-            {
-                /* On s'assure que le père est centré par rapport aux deux fils */
-
-                pos.left_node = G_GRAPH_NODE(target_a);
-                pos.right_node = G_GRAPH_NODE(target_b);
-
-                /**
-                 * Un pré-condition pour pouvoir s'aligner est que les noeuds
-                 * de références soient traités au préalables pour les positions.
-                 * Sinon les assert() coincent dans g_virtual_node_apply_x_line().
-                 */
-
-                if (g_graph_node_find_container_at_same_level(nodes, base, pos.left_node) != NULL
-                    && g_graph_node_find_container_at_same_level(nodes, base, pos.right_node) != NULL)
-                {
-                    g_graph_node_set_pending_position(base, PPF_MIDDLE_OF, pos);
-                }
-
-                break;
-
-            }
-
-            /* Alignement d'un bloc lié */
-
-            if (rank_a > rank_b)
-            {
-                /* Seuil vertical pour un côté */
-
-                container = g_graph_node_find_container_at_same_level(nodes,
-                                                                      G_GRAPH_NODE(node),
-                                                                      G_GRAPH_NODE(target_b));
-
-                if (container == NULL) container = G_GRAPH_NODE(target_b);
-
-                pos.left_margin = g_flow_node_get_slot_offset(node, false, &node->exits[0]);
-                pos.relative_ref = base;
-                g_graph_node_set_pending_position(container, PPF_LEFT_MARGIN, pos);
-
-                /* Trait vertical de l'autre côté... */
-
-                pos.direct_x = pos.left_margin;
-
-                dest_slot = g_flow_node_get_slot(target_a, true,
-                                                 last, node->exits[0].group_index);
-
-                pos.direct_x -= g_flow_node_get_slot_offset(target_a, true, dest_slot);
-
-                pos.relative_ref = base;
-
-                g_graph_node_set_pending_position(G_GRAPH_NODE(target_a), PPF_DIRECT_X, pos);
-
-            }
-            else
-            {
-                /* Seuil vertical pour un côté */
-
-                container = g_graph_node_find_container_at_same_level(nodes,
-                                                                      G_GRAPH_NODE(node),
-                                                                      G_GRAPH_NODE(target_a));
-
-                if (container == NULL) container = G_GRAPH_NODE(target_a);
-
-                pos.right_margin = g_flow_node_get_slot_offset(node, false, &node->exits[1]);
-                pos.relative_ref = base;
-                g_graph_node_set_pending_position(container, PPF_RIGHT_MARGIN, pos);
-
-                /* Trait vertical de l'autre côté... */
-
-                pos.direct_x = pos.right_margin;
-
-                dest_slot = g_flow_node_get_slot(target_b, true,
-                                                 last, node->exits[1].group_index);
-
-                pos.direct_x -= g_flow_node_get_slot_offset(target_b, true, dest_slot);
-
-                pos.relative_ref = base;
-
-                g_graph_node_set_pending_position(G_GRAPH_NODE(target_b), PPF_DIRECT_X, pos);
-
-            }
-
-            break;
-
-    }
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : node     = noeud graphique démarrant la visite.              *
-*                callback = ensemble de blocs à parcourir.                    *
-*                data     = donnée utilisateur à associer au parcours.        *
-*                                                                             *
-*  Description : Parcourt tous les blocs d'instructions dans un ordre donné.  *
-*                                                                             *
-*  Retour      : true si le parcours a été jusqu'à son terme, false sinon.    *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static bool g_flow_node_visit_flow_nodes(GFlowNode *node, graph_node_visitor_cb callback, void *data)
-{
-    return callback(G_GRAPH_NODE(node), GVS_NODE, data);
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : node = noeud graphique à consulter.                          *
-*                                                                             *
-*  Description : Fournit le bloc basique à l'origine du bloc graphique.       *
-*                                                                             *
-*  Retour      : Bloc brut encapsulé.                                         *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-GFlowBlock *g_flow_node_get_block(const GFlowNode *node)
-{
-    return node->block;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : node  = noeud graphique à consulter.                         *
-*                instr = instruction à considérer.                            *
-*                                                                             *
-*  Description : Précise si le noeud a pour première instruction celle donnée.*
-*                                                                             *
-*  Retour      : true si la première instruction du noeud est celle indiquée. *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-bool g_flow_node_start_with(const GFlowNode *node, GArchInstruction *instr)
-{
-    GArchInstruction *first;                /* Première instr. du noeud    */
-
-    g_flow_block_get_boundary(node->block, &first, NULL);
-
-    return (first == instr);
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : node  = noeud graphique à consulter.                         *
-*                instr = instruction à considérer.                            *
-*                                                                             *
-*  Description : Précise si le noeud a pour dernière instruction celle donnée.*
-*                                                                             *
-*  Retour      : true si la dernière instruction du noeud est celle indiquée. *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-bool g_flow_node_end_with(const GFlowNode *node, GArchInstruction *instr)
-{
-    GArchInstruction *last;                 /* Dernière instr. du noeud    */
-
-    g_flow_block_get_boundary(node->block, NULL, &last);
-
-    return (last == instr);
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : node  = noeud graphique à consulter.                         *
-*                ranks = classement à mettre à jour.                          *
-*                                                                             *
-*  Description : Précise la hauteur minimale requise pour un noeud.           *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-void g_flow_node_register_rank(const GFlowNode *node, GGraphRanks *ranks)
-{
-    unsigned int index;                     /* Indice du rang associé      */
-
-    index = g_flow_node_get_rank(node);
-
-    g_graph_ranks_set_min_height(ranks, index, G_GRAPH_NODE(node)->alloc.height);
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : node  = noeud graphique à mettre à jour.                     *
-*                ranks = classement à consulter.                              *
-*                                                                             *
-*  Description : Définit l'ordonnée de l'espace attribué à un noeud.          *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-void g_flow_node_apply_rank(GFlowNode *node, GGraphRanks *ranks)
-{
-    unsigned int index;                     /* Indice du rang associé      */
-
-    index = g_flow_node_get_rank(node);
-
-    G_GRAPH_NODE(node)->alloc.y = g_graph_ranks_get_y_for_rank(ranks, index);
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : node   = noeud graphique à mettre à jour.                    *
-*                layout = disposition globale du graphique.                   *
-*                nodes  = ensemble des noeuds en place.                       *
-*                                                                             *
-*  Description : Etablit les liaison entre un noeud et ses suivants.          *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-void g_flow_node_link(GFlowNode *node, GGraphLayout *layout, GGraphNode *nodes)
-{
-    GArchInstruction *last;                 /* Dernière instr. du noeud    */
-    size_t i;                               /* Boucle de parcours          */
-    GFlowNode *target;                      /* Bloc visé par le lien       */
-    node_slot_t *dest_slot;                 /* Accrochage d'arrivée        */
-    EdgeColor color;                        /* Couleur du lien à créer     */
-    GGraphEdge *edge;                       /* Lien à mettre en place      */
-
-    g_flow_block_get_boundary(node->block, NULL, &last);
-
-    for (i = 0; i < node->exits_count; i++)
-    {
-        target = G_FLOW_NODE(find_node_for_first_instruction(nodes, node->exits[i].instr));
-
-        /**
-         * Il semblerait que l'adresse ciblée puisse ne correspondre à aucun bloc.
-         * Ce serait le cas pour un saut avec __gmon_start__ sous ARM, à confirmer (TODO).
-         * Référence. : http://stackoverflow.com/questions/12697081/what-is-gmon-start-symbol
-         */
-        if (target == NULL) continue;
-
-        dest_slot = g_flow_node_get_slot(target, true,
-                                         last, node->exits[i].group_index);
-
-        switch (node->exits[i].type)
-        {
-            case ILT_JUMP_IF_TRUE:
-                color = EGC_GREEN;
-                break;
-            case ILT_JUMP_IF_FALSE:
-                color = EGC_RED;
-                break;
-            case ILT_LOOP:
-                color = EGC_BLUE;
-                break;
-            case ILT_CATCH_EXCEPTION:
-                color = EGC_DASHED_GRAY;
-                break;
-            default:
-                color = EGC_DEFAULT;
-                break;
-
-        }
-
-        edge = g_graph_edge_new(node, &node->exits[i], target, dest_slot, color);
-        g_graph_layout_add_edge(layout, edge);
-
-    }
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : node = intermédiaire à consulter.                            *
-*                view = support de destination.                               *
-*                                                                             *
-*  Description : Place un noeud sur son support final.                        *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-void g_flow_node_place(const GFlowNode *node, GtkGraphView *view)
-{
-    gtk_graph_view_put(view, GTK_WIDGET(node->view), &G_GRAPH_NODE(node)->alloc);
-
-}
-
-
-
-/* ---------------------------------------------------------------------------------- */
-/*                          GESTION DES ACCROCHES D'UN NOEUD                          */
-/* ---------------------------------------------------------------------------------- */
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : node = noeud graphique contenant les accrochées indiquées.   *
-*                a    = première accroche à considérer.                       *
-*                b    = seconde accroche à considérer.                        *
-*                                                                             *
-*  Description : Compare deux accroches pour liens entre noeuds.              *
-*                                                                             *
-*  Retour      : Bilan de la comparaison : -1, 0 ou 1.                        *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-int g_flow_node_compare_slots_for_edges(const GFlowNode *node, const node_slot_t *a, gint src_a, const node_slot_t *b, gint src_b)
-{
-    int result;                             /* Bilan à retourner           */
-    GGraphNode *base;                       /* Accès rapides               */
-    gint middle;                            /* Milieu du noeud traité      */
-    gint diff_a;                            /* Distance A <-> centre       */
-    gint diff_b;                            /* Distance B <-> centre       */
-
-
-    /**
-     * On place les extrémités en premier, afin de les traiter en premier.
-     */
-
-    int cmp_slot_indexes(const node_slot_t *a, const node_slot_t *b)
-    {
-        int result;
-
-        if (a->slot_index < b->slot_index)
-            result = 1;
-
-        else if (a->slot_index > b->slot_index)
-            result = -1;
-
-        else
-            result = 0;
-
-        return result;
-
-    }
-
-
-    switch (node->entries_count)
-    {
-        case 0:
-        case 1:
-            assert(0);
-            break;
-
-        case 2:
-
-            /**
-             * Le tri se fait simplement : un accroche à gauche, l'autre à droite.
-             */
-
-            result = cmp_slot_indexes(a, b);
-            break;
-
-        default:
-
-            /**
-             * On donne plus de poids aux accroches éloignées du centre.
-             * Facile quand les accroches sont distribuées d'un même côté, centre
-             * à utiliser dans les calculs sinon.
-             */
-
-            base = G_GRAPH_NODE(node);
-
-            middle = base->alloc.x + (base->alloc.width / 2);
-
-
-            /* Les deux accroches sont à gauche */
-            if (src_a <= middle && src_b <= middle)
-                result = cmp_slot_indexes(b, a);
-
-            /* Les deux accroches sont à droite */
-            else if (src_a > middle && src_b > middle)
-                result = cmp_slot_indexes(a, b);
-
-            /* Les deux accroches sont de chaque côté */
-            else
-            {
-                diff_a = (middle > src_a ? middle - src_a : src_a - middle);
-                diff_b = (middle > src_b ? middle - src_b : src_b - middle);
-
-                if (diff_a < diff_b)
-                    result = 1;
-
-                else if (diff_a > diff_b)
-                    result = -1;
-
-                else
-                    result = 0;
-
-            }
-
-            break;
-
-    }
-
-    return result;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : node = intermédiaire à compléter.                            *
-*                                                                             *
-*  Description : Prépare les points d'entrées du noeud.                       *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static void g_flow_node_setup_entry_slots(GFlowNode *node)
-{
-    GArchInstruction *first;                /* Première instr. du noeud    */
-    GArchInstruction **instrs;              /* Instr. visée par une autre  */
-    InstructionLinkType *types;             /* Type de lien entre lignes   */
-    size_t icount;                          /* Nombre de liens de dest.    */
-    size_t usable;                          /* Nombre de liens utiles ici  */
-    size_t i;                               /* Boucle de parcours          */
-    size_t used;                            /* Nombre de liens utilisés    */
-
-    g_flow_block_get_boundary(node->block, &first, NULL);
-
-    g_arch_instruction_rlock_src(first);
-    icount = g_arch_instruction_get_sources(first, &instrs, &types);
-
-    usable = 0;
-
-    for (i = 0; i < icount; i++)
-        switch (types[i])
-        {
-            case ILT_EXEC_FLOW:
-            case ILT_JUMP:
-            case ILT_CASE_JUMP:
-            case ILT_JUMP_IF_TRUE:
-            case ILT_JUMP_IF_FALSE:
-            case ILT_LOOP:
-            case ILT_CATCH_EXCEPTION:
-                usable++;
-                break;
-
-            default:
-                break;
-
-        }
-
-    if (usable == 0)
-    {
-        node->entries = NULL;
-        node->entries_count = 0;
-    }
-    else
-    {
-        node->entries = (node_slot_t *)calloc(usable, sizeof(node_slot_t));
-        node->entries_count = usable;
-    }
-
-    used = 0;
-
-    for (i = 0; i < icount; i++)
-        switch (types[i])
-        {
-            case ILT_EXEC_FLOW:
-            case ILT_JUMP:
-            case ILT_CASE_JUMP:
-            case ILT_JUMP_IF_TRUE:
-            case ILT_JUMP_IF_FALSE:
-            case ILT_LOOP:
-            case ILT_CATCH_EXCEPTION:
-
-                g_object_ref(instrs[i]);
-                node->entries[used].instr = instrs[i];
-
-                node->entries[used].type = types[i];
-                node->entries[used].group_index = g_arch_instruction_compute_group_index(&instrs[i],
-                                                                                         instrs, icount);
-                node->entries[used].slot_index = used;
-
-                used++;
-
-                break;
-
-            default:
-                break;
-
-        }
-
-    assert(used == usable);
-
-    g_arch_instruction_runlock_src(first);
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : node = intermédiaire à compléter.                            *
-*                                                                             *
-*  Description : Prépare les points de sorties du noeud.                      *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static void g_flow_node_setup_exit_slots(GFlowNode *node)
-{
-    GArchInstruction *last;                 /* Dernière instr. du noeud    */
-    GArchInstruction **instrs;              /* Instr. visée par une autre  */
-    InstructionLinkType *types;             /* Type de lien entre lignes   */
-    size_t icount;                          /* Nombre de liens de dest.    */
-    size_t usable;                          /* Nombre de liens utiles ici  */
-    size_t i;                               /* Boucle de parcours          */
-    size_t used;                            /* Nombre de liens utilisés    */
-
-    g_flow_block_get_boundary(node->block, NULL, &last);
-
-    g_arch_instruction_rlock_dest(last);
-    icount = g_arch_instruction_get_destinations(last, &instrs, &types, NULL);
-
-    usable = 0;
-
-    for (i = 0; i < icount; i++)
-        switch (types[i])
-        {
-            case ILT_EXEC_FLOW:
-            case ILT_JUMP:
-            case ILT_CASE_JUMP:
-            case ILT_JUMP_IF_TRUE:
-            case ILT_JUMP_IF_FALSE:
-            case ILT_LOOP:
-            case ILT_CATCH_EXCEPTION:
-                usable++;
-                break;
-
-            default:
-                break;
-
-        }
-
-    if (usable == 0)
-    {
-        node->exits = NULL;
-        node->exits_count = 0;
-    }
-    else
-    {
-        node->exits = (node_slot_t *)calloc(usable, sizeof(node_slot_t));
-        node->exits_count = usable;
-    }
-
-    used = 0;
-
-    for (i = 0; i < icount; i++)
-        switch (types[i])
-        {
-            case ILT_EXEC_FLOW:
-            case ILT_JUMP:
-            case ILT_CASE_JUMP:
-            case ILT_JUMP_IF_TRUE:
-            case ILT_JUMP_IF_FALSE:
-            case ILT_LOOP:
-            case ILT_CATCH_EXCEPTION:
-
-                g_object_ref(instrs[i]);
-                node->exits[used].instr = instrs[i];
-
-                node->exits[used].type = types[i];
-                node->exits[used].group_index = g_arch_instruction_compute_group_index(&instrs[i],
-                                                                                       instrs, icount);
-                node->exits[used].slot_index = used;
-
-                used++;
-
-                break;
-
-            default:
-                break;
-
-        }
-
-    assert(used == usable);
-
-    g_arch_instruction_runlock_dest(last);
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : node  = noeud graphique à consulter.                         *
-*                entry = indique le type d'accrochage recherché.              *
-*                instr = instruction visée.                                   *
-*                index = indice de groupe pour départager au besoin.          *
-*                                                                             *
-*  Description : Etablit un lien entre deux noeuds graphiques.                *
-*                                                                             *
-*  Retour      : Lien graphique mis en place.                                 *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static node_slot_t *g_flow_node_get_slot(const GFlowNode *node, bool entry, GArchInstruction *instr, size_t index)
-{
-    node_slot_t *result;                    /* Emplacement à retourner     */
-    node_slot_t *list;                      /* Liste à parcourir           */
-    size_t count;                           /* Taille de cette liste       */
-    size_t i;                               /* Boucle de parcours          */
-
-    if (entry)
-    {
-        list = node->entries;
-        count = node->entries_count;
-    }
-    else
-    {
-        list = node->exits;
-        count = node->exits_count;
-    }
-
-    for (i = 0; i < count; i++)
-    {
-        result = list + i;
-
-        if (result->instr == instr/* && result->group_index == index*/)
-            break;
-
-    }
-
-    return (i == count ? NULL : result);
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : node  = noeud graphique à consulter.                         *
-*                entry = indique le type d'accrochage recherché.              *
-*                slot  = accroche dont l'emplacement est à définir.           *
-*                                                                             *
-*  Description : Localise un point d'accroche à un noeud graphique.           *
-*                                                                             *
-*  Retour      : Décallage relatif pour l'accroche fournie.                   *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static gint g_flow_node_get_slot_offset(const GFlowNode *node, bool entry, const node_slot_t *slot)
-{
-    gint result;                            /* Valeur à retourner          */
-    node_slot_t *slots;                     /* Accroches à parcourir       */
-    size_t count;                           /* Nombre de ces points        */
-    gint slots_width;                       /* Largeur des accroches       */
-    gint slots_left;                        /* Abscisse de la première     */
-    size_t index;                           /* Indice de l'accroche visée  */
-
-    if (entry)
-    {
-        slots = node->entries;
-        count = node->entries_count;
-    }
-    else
-    {
-        slots = node->exits;
-        count = node->exits_count;
-    }
-
-    slots_width = (count - 1) * SPACE_BETWEEN_SLOT;
-    slots_left = (G_GRAPH_NODE(node)->alloc.width - slots_width) / 2;
-
-    index = (slot - slots);
-    /* BUG_ON(index >= count); */
-
-    index = slot->slot_index;
-
-    result = slots_left + index * SPACE_BETWEEN_SLOT;
-
-    return result;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : node = intermédiaire à consulter.                            *
-*                nodes = ensemble des noeuds en place.                        *
-*                                                                             *
-*  Description : Réorganise au mieux les points d'accroche d'un noeud.        *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-#include "../../../arch/instruction-int.h"
-void g_flow_node_reorder_slots(const GFlowNode *node, GGraphNode *nodes)
-{
-
-    typedef struct _reordering_params
-    {
-        GdkPoint middle;                    /* Milieu du noeud traité      */
-        bool down_first;                    /* Liens descendants aux bords */
-
-        bool entry;                         /* Zone d'accrochage aux bouts */
-        GArchInstruction *instr;            /* Instruction du bloc courant */
-
-    } reordering_params;
-
-    typedef struct _reordered_slot
-    {
-        const reordering_params *params;    /* Informations partagées      */
-
-        GdkPoint dest;                      /* Position à l'extrémité      */
-
-        size_t orig_index;                  /* Indice d'accroche d'origine */
-
-    } reordered_slot;
-
-
-    GGraphNode *base;                       /* Accès rapides               */
-    reordering_params params;               /* Directives générales        */
-
-
-    int cmp_slots_for_reordering(const reordered_slot *a, const reordered_slot *b)
-    {
-        const reordering_params *params;    /* Informations partagées      */
-        bool on_left_a;                     /* Lien A vers la gauche ?     */
-        bool on_left_b;                     /* Lien B vers la gauche ?     */
-        bool go_down_a;                     /* Lien A vers le bas ?        */
-        bool go_down_b;                     /* Lien B vers le bas ?        */
-
-        params = a->params;
-
-        /* Première distinction : côté par rapport au centre */
-
-        on_left_a = (a->dest.x <= params->middle.x);
-        on_left_b = (b->dest.x <= params->middle.x);
-
-        if (on_left_a && !on_left_b) return -1;
-        else if (!on_left_a && on_left_b) return 1;
-
-        /* On évite les recoupements entre montées et descentes */
-
-        go_down_a = (a->dest.y >= params->middle.y);
-        go_down_b = (b->dest.y >= params->middle.y);
-
-        if (go_down_a && !go_down_b) return (params->down_first ? -1 : 1);
-        else if (!go_down_a && go_down_b) return (params->down_first ? -1 : 1);
-
-        /* Au sein d'une même catégorie, on se base uniquement sur la position */
-
-        return (a->dest.x <= b->dest.x ? -1 : 1);
-
-    }
-
-    void reorder_slots(node_slot_t *slots, size_t count, __compar_fn_t cmp, const reordering_params *params, GGraphNode *nodes)
-    {
-        reordered_slot *rslots;             /* Créneaux réorganisés        */
-        reordered_slot *iter;               /* Boucle de parcours #1       */
-        size_t used;                        /* Nombre de liens valides     */
-        size_t i;                           /* Boucle de parcours #2       */
-        GFlowNode *target;                  /* Bloc visé par le lien       */
-        node_slot_t *dest_slot;             /* Accrochage associé          */
-
-        rslots = (reordered_slot *)calloc(count, sizeof(reordered_slot));
-
-        /* Constitution d'une liste triée */
-
-        iter = rslots;
-        used = 0;
-
-        for (i = 0; i < count; i++)
-        {
-            iter->params = params;
-
-            target = G_FLOW_NODE(_find_node_for_instruction(nodes, slots[i].instr, params->entry));
-
-            /* Cf. commentaire de g_flow_node_link() */
-            if (target == NULL) continue;
-
-            dest_slot = g_flow_node_get_slot(target, params->entry,
-                                             params->instr, slots[i].group_index);
-
-            iter->dest = g_flow_node_get_point_from_slot(target, params->entry, dest_slot);
-
-            iter->orig_index = i;
-
-            iter++;
-            used++;
-
-        }
-
-        /* TODO : utiliser qsort_r, avec params en argument ? */
-        qsort(rslots, used, sizeof(reordered_slot), cmp);
-
-
-
-
-        for (i = 0; i < used; i++)
-        {
-
-
-            if (rslots[i].orig_index != i)
-                printf("Could reorder %zu -> %zu\n", rslots[i].orig_index, i);
-
-            if (rslots[i].orig_index != i)
-                slots[rslots[i].orig_index].slot_index = i;
-
-
-
-        }
-
-        free(rslots);
-
-    }
-
-
-    base = G_GRAPH_NODE(node);
-
-    /* Régorganise les accroches d'entrée */
-
-    if (node->entries_count > 1)
-    {
-        params.middle.x = base->alloc.x + (base->alloc.width / 2);
-        params.middle.y = base->alloc.y;
-
-        params.down_first = true;
-
-        params.entry = false;
-        g_flow_block_get_boundary(node->block, &params.instr, NULL);
-
-        printf(" ### REORDERING ENTRIES OF 0x%08x\n", (unsigned int)params.instr->range.addr.virtual);
-
-        reorder_slots(node->entries, node->entries_count, (__compar_fn_t)cmp_slots_for_reordering, &params, nodes);
-
-    }
-
-    /* Régorganise les accroches de sortie */
-
-    if (node->exits_count > 1)
-    {
-        params.middle.x = base->alloc.x + (base->alloc.width / 2);
-        params.middle.y = base->alloc.y + base->alloc.height;
-
-        params.down_first = false;
-
-        params.entry = true;
-        g_flow_block_get_boundary(node->block, NULL, &params.instr);
-
-        printf(" ### REORDERING EXITS OF 0x%08x\n", (unsigned int)params.instr->range.addr.virtual);
-
-        reorder_slots(node->exits, node->exits_count, (__compar_fn_t)cmp_slots_for_reordering, &params, nodes);
-
-    }
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : node  = noeud graphique à consulter.                         *
-*                entry = indique le type d'accrochage recherché.              *
-*                slot  = accroche dont l'emplacement est à définir.           *
-*                                                                             *
-*  Description : Localise un point d'accroche à un noeud graphique.           *
-*                                                                             *
-*  Retour      : Emplacement réservé pour l'accroche fournie.                 *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-GdkPoint g_flow_node_get_point_from_slot(const GFlowNode *node, bool entry, const node_slot_t *slot)
-{
-    GGraphNode *base;                       /* Accès rapides               */
-    GdkPoint result;                        /* Position à retourner        */
-    node_slot_t *slots;                     /* Accroches à parcourir       */
-    size_t count;                           /* Nombre de ces points        */
-    gint slots_width;                       /* Largeur des accroches       */
-    gint slots_left;                        /* Abscisse de la première     */
-    size_t index;                           /* Indice de l'accroche visée  */
-
-    base = G_GRAPH_NODE(node);
-
-    if (entry)
-    {
-        result.y = base->alloc.y;
-
-        slots = node->entries;
-        count = node->entries_count;
-
-    }
-    else
-    {
-        result.y = base->alloc.y + base->alloc.height;
-
-        slots = node->exits;
-        count = node->exits_count;
-
-    }
-
-    slots_width = (count - 1) * SPACE_BETWEEN_SLOT;
-    slots_left = base->alloc.x + (base->alloc.width - slots_width) / 2;
-
-    index = (slot - slots)/* / sizeof(node_slot_t)*/;
-    /* BUG_ON(index >= count); */
-
-
-    if (count > 1 && entry)
-        printf("  -->> index = %zu vs %zu (max = %zu)\n", index, slot->slot_index, count);
-
-    index = slot->slot_index;
-
-
-    result.x = slots_left + index * SPACE_BETWEEN_SLOT;
-
-    return result;
-
-}
diff --git a/src/gtkext/graph/nodes/flow.h b/src/gtkext/graph/nodes/flow.h
deleted file mode 100644
index 76d0a03..0000000
--- a/src/gtkext/graph/nodes/flow.h
+++ /dev/null
@@ -1,99 +0,0 @@
-
-/* Chrysalide - Outil d'analyse de fichiers binaires
- * flow.h - prototypes pour l'encapsulation graphique des blocs d'exécution
- *
- * Copyright (C) 2013 Cyrille Bagard
- *
- *  This file is part of Chrysalide.
- *
- *  OpenIDA is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 3 of the License, or
- *  (at your option) any later version.
- *
- *  OpenIDA is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with Foobar.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-
-#ifndef _GTKEXT_GRAPH_NODES_FLOW_H
-#define _GTKEXT_GRAPH_NODES_FLOW_H
-
-
-#include "../node.h"
-#include "../../../analysis/blocks/flow.h"
-
-
-
-/* Redéfinition depuis layout.h pour contourner une boucle. */
-typedef struct _GGraphLayout GGraphLayout;
-
-
-
-#define G_TYPE_FLOW_NODE                  (g_flow_node_get_type())
-#define G_FLOW_NODE(obj)                  (G_TYPE_CHECK_INSTANCE_CAST((obj), G_TYPE_FLOW_NODE, GFlowNode))
-#define G_FLOW_NODE_CLASS(klass)          (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_FLOW_NODE, GFlowNodeClass))
-#define G_IS_FLOW_NODE(obj)               (G_TYPE_CHECK_INSTANCE_TYPE((obj), G_TYPE_FLOW_NODE))
-#define G_IS_FLOW_NODE_CLASS(klass)       (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_FLOW_NODE))
-#define G_FLOW_NODE_GET_CLASS(obj)        (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_FLOW_NODE, GFlowNodeClass))
-
-
-/* Type d'un accrochage pour lien */
-typedef struct _node_slot_t node_slot_t;
-
-/* Encapsulation graphique d'un bloc d'exécution (instance) */
-typedef struct _GFlowNode GFlowNode;
-
-/* Encapsulation graphique d'un bloc d'exécution (classe) */
-typedef struct _GFlowNodeClass GFlowNodeClass;
-
-
-/* Indique le type définit par la GLib pour l'encapsulation d'un bloc d'exécution. */
-GType g_flow_node_get_type(void);
-
-/* Encapsule graphiquement un bloc d'exécution. */
-GGraphNode *g_flow_node_new(GFlowBlock *, GtkBufferView *);
-
-/* Fournit le bloc basique à l'origine du bloc graphique. */
-GFlowBlock *g_flow_node_get_block(const GFlowNode *);
-
-/* Précise si le noeud a pour première instruction celle donnée. */
-bool g_flow_node_start_with(const GFlowNode *, GArchInstruction *);
-
-/* Précise si le noeud a pour dernière instruction celle donnée. */
-bool g_flow_node_end_with(const GFlowNode *, GArchInstruction *);
-
-/* Précise la hauteur minimale requise pour un noeud. */
-void g_flow_node_register_rank(const GFlowNode *, GGraphRanks *);
-
-/* Définit l'ordonnée de l'espace attribué à un noeud. */
-void g_flow_node_apply_rank(GFlowNode *, GGraphRanks *);
-
-/* Etablit les liaison entre un noeud et ses suivants. */
-void g_flow_node_link(GFlowNode *, GGraphLayout *, GGraphNode *);
-
-/* Place un noeud sur son support final. */
-void g_flow_node_place(const GFlowNode *, GtkGraphView *);
-
-
-
-/* ------------------------ GESTION DES ACCROCHES D'UN NOEUD ------------------------ */
-
-
-/* Compare deux accroches pour liens entre noeuds. */
-int g_flow_node_compare_slots_for_edges(const GFlowNode *, const node_slot_t *, gint, const node_slot_t *, gint);
-
-/* Réorganise au mieux les points d'accroche d'un noeud. */
-void g_flow_node_reorder_slots(const GFlowNode *, GGraphNode *);
-
-/* Localise un point d'accroche à un noeud graphique. */
-GdkPoint g_flow_node_get_point_from_slot(const GFlowNode *, bool, const node_slot_t *);
-
-
-
-#endif  /* _GTKEXT_GRAPH_NODES_FLOW_H */
diff --git a/src/gtkext/graph/nodes/virtual.c b/src/gtkext/graph/nodes/virtual.c
deleted file mode 100644
index 62f5b42..0000000
--- a/src/gtkext/graph/nodes/virtual.c
+++ /dev/null
@@ -1,990 +0,0 @@
-
-/* Chrysalide - Outil d'analyse de fichiers binaires
- * virtual.c - encapsulation graphique des blocs virtuels
- *
- * Copyright (C) 2013 Cyrille Bagard
- *
- *  This file is part of Chrysalide.
- *
- *  OpenIDA is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 3 of the License, or
- *  (at your option) any later version.
- *
- *  OpenIDA is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with Foobar.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-
-#include "virtual.h"
-
-
-#include <assert.h>
-#include <malloc.h>
-#include <sys/param.h>
-
-
-#include "flow.h"
-#include "../node-int.h"
-
-
-
-/* ----------------------- MANIPULATION DES PORTES VERTICALES ----------------------- */
-
-
-/* Etendue verticale d'un lien */
-typedef struct _reserved_vspan
-{
-    unsigned int r1;                        /* Départ d'une ligne          */
-    unsigned int r2;                        /* Arrivée de cette même ligne */
-
-} reserved_vspan;
-
-/* Lignes de liens verticales au sein d'un même groupe */
-typedef struct _vert_links
-{
-    reserved_vspan *vspans;                 /* Lignes sans chevauchement   */
-    size_t count;                           /* Nombre de ces lignes        */
-
-} vert_links;
-
-
-/* Initialise les futures portées d'un même niveau. */
-static void init_vertical_links(vert_links *);
-
-/* Regarde si des portées verticales se chevauchent ou non. */
-static bool is_intersection_with_vertical_spans(const vert_links *, const reserved_vspan *);
-
-/* Ajoute une réservation à un ensemble de portées verticales. */
-static void extend_vertical_links_spans(vert_links *, const reserved_vspan *);
-
-
-
-/* ---------------------- REPRESENTATIONS DES GROUPES LOGIQUES ---------------------- */
-
-
-/* Représentation d'un étage */
-typedef struct _virtual_level
-{
-    unsigned int rank;                      /* Rang associé à l'étage      */
-
-    GGraphNode **children;                  /* Noeuds englobés             */
-    size_t count;                           /* Quantité de ces noeuds      */
-
-} virtual_level;
-
-/* Encapsulation graphique d'un bloc virtuel (instance) */
-struct _GVirtualNode
-{
-    GGraphNode parent;                      /* A laisser en premier        */
-
-    GVirtualBlock *block;                   /* Bloc virtuel associé        */
-
-    GGraphNode **children;                  /* Noeuds englobés             */
-    size_t count;                           /* Quantité de ces noeuds      */
-    virtual_level *levels;                  /* Différents étages de noeuds */
-    size_t lcount;                          /* Nombre de ces étages        */
-
-    vert_links *left_padding;               /* Espace à gauche pour liens  */
-    vspan_slot_t left_count;                /* Nombre de largeurs réservées*/
-    vert_links *right_padding;              /* Espace à droite pour liens  */
-    vspan_slot_t right_count;               /* Nombre de largeurs réservées*/
-
-};
-
-/* Encapsulation graphique d'un bloc virtuel (classe) */
-struct _GVirtualNodeClass
-{
-    GGraphNodeClass parent;                 /* A laisser en premier        */
-
-};
-
-
-/* Initialise la classe des encapsulations de blocs virtuels. */
-static void g_virtual_node_class_init(GVirtualNodeClass *);
-
-/* Initialise une encapsulation de bloc virtuel. */
-static void g_virtual_node_init(GVirtualNode *);
-
-/* Supprime toutes les références externes. */
-static void g_virtual_node_dispose(GVirtualNode *);
-
-/* Procède à la libération totale de la mémoire. */
-static void g_virtual_node_finalize(GVirtualNode *);
-
-/* Fournit le rang du noeud dans le graphique. */
-static unsigned int g_virtual_node_get_rank(const GVirtualNode *);
-
-/* Réinitialise la position d'un noeud d'encapsulation. */
-static void g_virtual_node_reset_position(GVirtualNode *);
-
-/* Définit les abscisses relatives du contenu d'un noeud. */
-static void g_virtual_node_prepare_x_line(GVirtualNode *, GGraphNode *);
-
-/* Applique une position finale au noeud. */
-static void g_virtual_node_apply_position(GVirtualNode *);
-
-/* Définit les abscisses relatives du contenu d'un noeud. */
-static void g_virtual_node_apply_x_line(GVirtualNode *);
-
-/* Met à jour la largeur interne du noeud. */
-static void g_virtual_node_compute_width(GVirtualNode *);
-
-/* Altère la position du noeud d'encapsulation. */
-static void g_virtual_node_set_position(GVirtualNode *, gint);
-
-/* Parcourt tous les blocs d'instructions dans un ordre donné. */
-static bool g_virtual_node_visit_flow_nodes(GVirtualNode *, graph_node_visitor_cb, void *);
-
-/* Recherche le noeud contenant un autre noeud. */
-static GGraphNode *g_virtual_node_find_container(GVirtualNode *, GGraphNode *);
-
-
-
-/* ---------------------------------------------------------------------------------- */
-/*                         MANIPULATION DES PORTES VERTICALES                         */
-/* ---------------------------------------------------------------------------------- */
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : links = liste à initialiser.                                 *
-*                                                                             *
-*  Description : Initialise les futures portées d'un même niveau.             *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static void init_vertical_links(vert_links *links)
-{
-    links->vspans = NULL;
-    links->count = 0;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : links = liste de portées déjà en place.                      *
-*                vspan = nouvelle portée à insérer quelque part.              *
-*                                                                             *
-*  Description : Regarde si des portées verticales se chevauchent ou non.     *
-*                                                                             *
-*  Retour      : true si les portées peuvent cohabiter, false sinon.          *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static bool is_intersection_with_vertical_spans(const vert_links *links, const reserved_vspan *vspan)
-{
-    bool result;                            /* Bilan d'analyse à retourner */
-    size_t i;                               /* Boucle de parcours          */
-
-    result = false;
-
-    for (i = 0; i < links->count && !result; i++)
-    {
-        if (vspan->r1 < links->vspans[i].r1)
-            result = vspan->r2 >= links->vspans[i].r1;
-
-        else if (vspan->r1 > links->vspans[i].r2)
-            result = vspan->r2 <= links->vspans[i].r2;
-
-        else
-        {
-            result = links->vspans[i].r1 < vspan->r1 && vspan->r1 < links->vspans[i].r2;
-            result |= links->vspans[i].r1 < vspan->r2 && vspan->r2 < links->vspans[i].r2;
-        }
-
-    }
-
-    return result;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : spans = liste de portées déjà en place.                      *
-*                vspan = nouvelle portée à insérer quelque part.              *
-*                                                                             *
-*  Description : Ajoute une réservation à un ensemble de portées verticales.  *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static void extend_vertical_links_spans(vert_links *links, const reserved_vspan *new)
-{
-    links->vspans = (reserved_vspan *)realloc(links->vspans,
-                                              ++links->count * sizeof(reserved_vspan));
-
-    if (new->r1 <= new->r2)
-        links->vspans[links->count - 1] = *new;
-    else
-    {
-        links->vspans[links->count - 1].r1 = new->r2;
-        links->vspans[links->count - 1].r2 = new->r1;
-    }
-
-}
-
-
-
-/* ---------------------------------------------------------------------------------- */
-/*                        REPRESENTATIONS DES GROUPES LOGIQUES                        */
-/* ---------------------------------------------------------------------------------- */
-
-
-/* Indique le type définit par la GLib pour l'encapsulation d'un bloc virtuel. */
-G_DEFINE_TYPE(GVirtualNode, g_virtual_node, G_TYPE_GRAPH_NODE);
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : klass = classe à initialiser.                                *
-*                                                                             *
-*  Description : Initialise la classe des encapsulations de blocs virtuels.   *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static void g_virtual_node_class_init(GVirtualNodeClass *klass)
-{
-    GObjectClass *object;                   /* Autre version de la classe  */
-    GGraphNodeClass *node_class;            /* Version parente de la classe*/
-
-    object = G_OBJECT_CLASS(klass);
-    node_class = G_GRAPH_NODE_CLASS(klass);
-
-    object->dispose = (GObjectFinalizeFunc/* ! */)g_virtual_node_dispose;
-    object->finalize = (GObjectFinalizeFunc)g_virtual_node_finalize;
-
-    node_class->get_rank = (get_node_rank_fc)g_virtual_node_get_rank;
-    node_class->reset_pos = (node_reset_pos_fc)g_virtual_node_reset_position;
-    node_class->prepare_x = (node_prepare_x_fc)g_virtual_node_prepare_x_line;
-    node_class->apply_pos = (node_apply_pos_fc)g_virtual_node_apply_position;
-    node_class->set_pos = (node_set_pos_fc)g_virtual_node_set_position;
-    node_class->visit = (visit_flow_nodes_fc)g_virtual_node_visit_flow_nodes;
-    node_class->contain = (find_container_fc)g_virtual_node_find_container;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : node = instance à initialiser.                               *
-*                                                                             *
-*  Description : Initialise une encapsulation de bloc virtuel.                *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static void g_virtual_node_init(GVirtualNode *node)
-{
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : node = instance d'objet GLib à traiter.                      *
-*                                                                             *
-*  Description : Supprime toutes les références externes.                     *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static void g_virtual_node_dispose(GVirtualNode *node)
-{
-    size_t i;                               /* Boucle de parcours          */
-
-    g_object_unref(G_OBJECT(node->block));
-
-    for (i = 0; i < node->count; i++)
-        g_object_unref(G_OBJECT(node->children[i]));
-
-    if (node->children != NULL)
-        free(node->children);
-
-    G_OBJECT_CLASS(g_virtual_node_parent_class)->dispose(G_OBJECT(node));
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : node = instance d'objet GLib à traiter.                      *
-*                                                                             *
-*  Description : Procède à la libération totale de la mémoire.                *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static void g_virtual_node_finalize(GVirtualNode *node)
-{
-    G_OBJECT_CLASS(g_virtual_node_parent_class)->finalize(G_OBJECT(node));
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : block = bloc virtuel représenté graphiquement.               *
-*                                                                             *
-*  Description : Encapsule graphiquement un bloc virtuel.                     *
-*                                                                             *
-*  Retour      : Adresse de la structure mise en place.                       *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-GGraphNode *g_virtual_node_new(GVirtualBlock *block)
-{
-    GVirtualNode *result;                   /* Structure à retourner       */
-
-    result = g_object_new(G_TYPE_VIRTUAL_NODE, NULL);
-
-    g_object_ref(G_OBJECT(block));
-
-    result->block = block;
-
-    return G_GRAPH_NODE(result);
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : node = noeud graphique à consulter.                          *
-*                                                                             *
-*  Description : Fournit le rang du noeud dans le graphique.                  *
-*                                                                             *
-*  Retour      : Indice supérieur ou égal à zéro.                             *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static unsigned int g_virtual_node_get_rank(const GVirtualNode *node)
-{
-    /* BUG_ON(node->count == 0) */
-
-    return g_graph_node_get_rank(node->children[0]);
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : node = noeud graphique à manipuler.                          *
-*                                                                             *
-*  Description : Réinitialise la position d'un noeud d'encapsulation.         *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static void g_virtual_node_reset_position(GVirtualNode *node)
-{
-    size_t i;                               /* Boucle de parcours          */
-
-    for (i = 0; i < node->count; i++)
-        g_graph_node_reset_position(node->children[i]);
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : node  = noeud d'encapsulation à traiter.                     *
-*                nodes = ensemble des noeuds en place.                        *
-*                                                                             *
-*  Description : Définit les abscisses relatives du contenu d'un noeud.       *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static void g_virtual_node_prepare_x_line(GVirtualNode *node, GGraphNode *nodes)
-{
-    size_t i;                               /* Boucle de parcours          */
-
-    for (i = 0; i < node->count; i++)
-        g_graph_node_prepare_x_line(node->children[i], nodes);
-
-}
-
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : node  = noeud d'encapsulation à traiter.                     *
-*                                                                             *
-*  Description : Applique une position finale au noeud.                       *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static void g_virtual_node_apply_position(GVirtualNode *node)
-{
-    gint min;                               /* Valeur minimale rencontrée  */
-    size_t i;                               /* Boucle de parcours          */
-    gint x_pos;                             /* Nouvelle position #1        */
-    gint offset;                            /* Décallage à faire suivre    */
-
-    g_virtual_node_apply_x_line(node);
-
-    /* Collecte de l'ensemble des positions */
-
-    min = 0;
-
-    for (i = 0; i < node->count; i++)
-    {
-        g_graph_node_get_position(node->children[i], &x_pos, NULL);
-        min = MIN(min, x_pos);
-    }
-
-    /* Espace pour les liens remontants */
-
-    if (node->left_count > 0)
-        offset = EDGE_SLOT_HORIZ_MARGIN + EDGE_HORIZONTAL_MIN_SEP * (node->left_count - 1);
-    else
-        offset = 0;
-
-    /* Ajout du décallage le plus grand */
-
-    offset += -min;
-
-    /* Traitement des sous-noeuds */
-
-    for (i = 0; i < node->count; i++)
-    {
-        /* BUG_ON(node->children[i]->alloc.x != UNINITIALIZED_NODE_POS); */
-
-        g_graph_node_get_position(node->children[i], &x_pos, NULL);
-
-        printf(" == vapply ==  %p : %d + %d -> %d\n",
-               node->children[i], x_pos, offset, (int)(x_pos + offset));
-
-        x_pos += offset;
-
-        g_graph_node_set_x_position(node->children[i], x_pos);
-
-    }
-
-    g_virtual_node_compute_width(node);
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : node = noeud d'encapsulation à traiter.                      *
-*                                                                             *
-*  Description : Définit les abscisses relatives du contenu d'un noeud.       *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static void g_virtual_node_apply_x_line(GVirtualNode *node)
-{
-    size_t i;                               /* Boucle de parcours #1       */
-    virtual_level *level;                   /* Accès rapide                */
-    size_t j;                               /* Boucle de parcours #2       */
-    gint width_sum;                         /* Largeur d'un étage traité   */
-    gint x_pos;                             /* Abscisse à attribuer        */
-    GGraphNode *ref_a;                      /* Accès rapide #1             */
-    GGraphNode *ref_b;                      /* Accès rapide #2             */
-
-    for (i = 0; i < node->lcount; i++)
-    {
-        level = &node->levels[i];
-
-        /* Si l'ensemble de l'étage doit être centré */
-        if (level->children[0]->pending_flag == PPF_NONE)
-        {
-            width_sum = 0;
-
-            for (j = 0; j < level->count; j++)
-            {
-                assert(level->children[j]->pending_flag == PPF_NONE);
-
-                g_graph_node_apply_position(level->children[j]);
-                width_sum += level->children[j]->alloc.width;
-
-            }
-
-            width_sum += NODE_HORIZONTAL_MARGIN * (level->count - 1);
-
-            x_pos = - width_sum / 2;
-
-            for (j = 0; j < level->count; j++)
-            {
-                g_graph_node_set_x_position(level->children[j], x_pos);
-                x_pos += level->children[j]->alloc.width + NODE_HORIZONTAL_MARGIN;
-            }
-
-        }
-
-        else if (level->children[0]->pending_flag == PPF_MIDDLE_OF)
-            continue;
-
-        /* On traite les noeuds individuellement */
-        else
-        {
-            void _apply_rel_position(GGraphNode *child)
-            {
-                switch (node->children[0]->pending_flag)
-                {
-                    case PPF_LEFT_NODE:
-                        if (!g_graph_node_has_x_position(child->pending_pos.left_node))
-                            _apply_rel_position(child->pending_pos.left_node);
-                        break;
-
-                    case PPF_RIGHT_NODE:
-                        if (!g_graph_node_has_x_position(child->pending_pos.right_node))
-                            _apply_rel_position(child->pending_pos.right_node);
-                        break;
-
-                    default:
-                        break;
-
-                }
-
-                g_graph_node_apply_position(child);
-
-            }
-
-            for (j = 0; j < level->count; j++)
-                if (!g_graph_node_has_x_position(level->children[j]))
-                    _apply_rel_position(level->children[j]);
-
-        }
-
-    }
-
-    for (i = 0; i < node->lcount; i++)
-    {
-        level = &node->levels[i];
-
-        /* Si l'ensemble de l'étage doit être centré */
-        if (level->children[0]->pending_flag == PPF_MIDDLE_OF)
-        {
-            ref_a = level->children[0]->pending_pos.left_node;
-            ref_b = level->children[0]->pending_pos.right_node;
-
-            assert(g_graph_node_has_x_position(ref_a));
-            assert(g_graph_node_has_x_position(ref_b));
-
-            if (ref_a->alloc.x < ref_b->alloc.x)
-            {
-                ref_b = level->children[0]->pending_pos.left_node;
-                ref_a = level->children[0]->pending_pos.right_node;
-            }
-
-            x_pos = ref_a->alloc.x;
-            x_pos += (ref_b->alloc.x + ref_b->alloc.width - ref_a->alloc.x) / 2;
-            x_pos -= level->children[0]->alloc.width / 2;
-
-            g_graph_node_set_x_position(level->children[0], x_pos);
-
-        }
-
-    }
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : node = noeud graphique à mettre à jour.                      *
-*                                                                             *
-*  Description : Met à jour la largeur interne du noeud.                      *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static void g_virtual_node_compute_width(GVirtualNode *node)
-{
-    GGraphNode *base;                       /* Accès rapides               */
-    size_t i;                               /* Boucle de parcours          */
-    GGraphNode *child;                      /* Raccourci confortable       */
-
-    base = G_GRAPH_NODE(node);
-
-    /* Largeur maximale des niveaux */
-
-    base->alloc.width = 0;
-
-    for (i = 0; i < node->lcount; i++)
-    {
-        child = node->levels[i].children[node->levels[i].count - 1];
-
-        base->alloc.width = MAX(base->alloc.width, child->alloc.x + child->alloc.width);
-
-    }
-
-    /* Bordures gauche et droite   */
-
-    if (node->left_count > 0)
-    {
-        base->alloc.width += EDGE_SLOT_HORIZ_MARGIN;
-        base->alloc.width += (node->left_count - 1) * EDGE_HORIZONTAL_MIN_SEP;
-    }
-
-    if (node->right_count > 0)
-    {
-        base->alloc.width += EDGE_SLOT_HORIZ_MARGIN;
-        base->alloc.width += (node->right_count - 1) * EDGE_HORIZONTAL_MIN_SEP;
-    }
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : node = noeud graphique à manipuler.                          *
-*                x    = éventuelle abscisse à intégrer.                       *
-*                                                                             *
-*  Description : Altère la position du noeud d'encapsulation.                 *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static void g_virtual_node_set_position(GVirtualNode *node, gint x)
-{
-    GGraphNode *base;                       /* Autre version de l'instance */
-    gint offset;                            /* Décallage à faire suivre    */
-    size_t i;                               /* Boucle de parcours          */
-    gint x_pos;                             /* Nouvelle position #1        */
-
-    base = G_GRAPH_NODE(node);
-
-    if (base->alloc.x == UNINITIALIZED_NODE_POS)
-        offset = x;
-    else
-        offset = x - base->alloc.x;
-
-    for (i = 0; i < node->count; i++)
-    {
-        /* BUG_ON(node->children[i]->alloc.x != UNINITIALIZED_NODE_POS); */
-
-        g_graph_node_get_position(node->children[i], &x_pos, NULL);
-        x_pos += offset;
-
-        g_graph_node_set_x_position(node->children[i], x_pos);
-
-    }
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : node     = noeud graphique démarrant la visite.              *
-*                callback = ensemble de blocs à parcourir.                    *
-*                data     = donnée utilisateur à associer au parcours.        *
-*                                                                             *
-*  Description : Parcourt tous les blocs d'instructions dans un ordre donné.  *
-*                                                                             *
-*  Retour      : true si le parcours a été jusqu'à son terme, false sinon.    *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static bool g_virtual_node_visit_flow_nodes(GVirtualNode *node, graph_node_visitor_cb callback, void *data)
-{
-    bool result;                            /* Bilan à retourner           */
-    size_t i;                               /* Boucle de parcours          */
-
-    result = callback(G_GRAPH_NODE(node), GVS_ENTER, data);
-
-    for (i = 0; i < node->count && result; i++)
-        result = g_graph_node_visit_nodes(node->children[i], callback, data);
-
-    if (result)
-        result = callback(G_GRAPH_NODE(node), GVS_EXIT, data);
-
-    return result;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : nodes  = noeud à consulter.                                  *
-*                target = élément à retrouver dans l'ensemble de noeuds.      *
-*                                                                             *
-*  Description : Recherche le noeud contenant un autre noeud.                 *
-*                                                                             *
-*  Retour      : Noeud trouvé ou NULL si aucun.                               *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static GGraphNode *g_virtual_node_find_container(GVirtualNode *node, GGraphNode *target)
-{
-    GGraphNode *result;                     /* Trouvaille à retourner      */
-    size_t i;                               /* Boucle de parcours          */
-
-    result = NULL;
-
-    for (i = 0; i < node->count && result == NULL; i++)
-    {
-        if (node->children[i] == target)
-            result = G_GRAPH_NODE(node);
-        else
-            result = g_graph_node_find_container(node->children[i], target);
-    }
-
-    return result;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : node  = noeud d'encapsulation à compléter.                   *
-*                child = sous-noeud à insérer.                                *
-*                                                                             *
-*  Description : Ajoute un noeud au groupe courant.                           *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-void g_virtual_node_add_child(GVirtualNode *node, GGraphNode *child)
-{
-    unsigned int rank;                      /* Rang de l'enfant            */
-    virtual_level *level;                   /* Niveau d'intégration        */
-    size_t i;                               /* Boucle de parcours          */
-
-    /* Liste globale */
-
-    node->children = (GGraphNode **)realloc(node->children,
-                                              ++node->count * sizeof(GGraphNode *));
-
-    node->children[node->count - 1] = child;
-
-    g_object_ref(G_OBJECT(child));
-
-    /* Intégration dans l'étage correspondant */
-
-    rank = g_graph_node_get_rank(child);
-
-    level = NULL;
-
-    for (i = 0; i < node->lcount && level == NULL; i++)
-        if (node->levels[i].rank == rank)
-            level = &node->levels[i];
-
-    if (level == NULL)
-    {
-        node->levels = (virtual_level *)realloc(node->levels,
-                                                ++node->lcount * sizeof(virtual_level));
-        level = &node->levels[node->lcount - 1];
-
-        level->rank = rank;
-        level->children = NULL;
-        level->count = 0;
-
-    }
-
-    level->children = (GGraphNode **)realloc(level->children,
-                                             ++level->count * sizeof(GGraphNode *));
-
-    level->children[level->count - 1] = child;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : node  = noeud d'encapsulation à consulter.                   *
-*                                                                             *
-*  Description : Compte le nombre de noeuds contenus dans le groupe courant.  *
-*                                                                             *
-*  Retour      : Quantité normalement non nulle.                              *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-size_t g_virtual_node_count_children(const GVirtualNode *node)
-{
-    return node->count;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : node  = noeud d'encapsulation à consulter.                   *
-*                index = indice du sous-bloc recherché.                       *
-*                                                                             *
-*  Description : Renvoie un des noeuds contenus dans le groupe courant.       *
-*                                                                             *
-*  Retour      : Un des blocs du groupe.                                      *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-GGraphNode *g_virtual_node_get_child(const GVirtualNode *node, size_t index)
-{
-    if (index >= node->count)
-        return NULL;
-
-    else
-        return node->children[index];
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : node = groupe de noeuds à mettre à jour.                     *
-*                r1   = début de la portée à réserver.                        *
-*                r2   = fin de la portée à réserver.                          *
-*                left = désignation de la zone à traiter.                     *
-*                                                                             *
-*  Description : Réserve une portion de largeur pour un lien.                 *
-*                                                                             *
-*  Retour      : Indice de la largeur adaptée et réservée.                    *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-vspan_slot_t g_virtual_node_reserve_span(GVirtualNode *node, unsigned int r1, unsigned int r2, bool left)
-{
-    vspan_slot_t result;                    /* Identifiant à retourner     */
-    reserved_vspan vspan;                   /* Portée à constituer         */
-    vert_links **list;                      /* Liste à parcourir           */
-    vspan_slot_t *count;                    /* Taille de cette liste       */
-
-    vspan.r1 = r1;
-    vspan.r2 = r2;
-
-    if (left)
-    {
-        list = &node->left_padding;
-        count = &node->left_count;
-    }
-    else
-    {
-        list = &node->right_padding;
-        count = &node->right_count;
-    }
-
-    for (result = 0; result < *count; result++)
-        if (!is_intersection_with_vertical_spans(&(*list)[result], &vspan))
-            break;
-
-    if (result == *count)
-    {
-        *list = (vert_links *)realloc(*list, ++(*count) * sizeof(vert_links));
-        init_vertical_links(&(*list)[result]);
-    }
-
-    extend_vertical_links_spans(&(*list)[result], &vspan);
-
-    return result;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : node = conteneur de noeuds à consulter.                      *
-*                slot = numérod de la réservation.                            *
-*                left = désignation de la zone à traiter.                     *
-*                                                                             *
-*  Description : Fournit la position horizontale obtenue par réservation.     *
-*                                                                             *
-*  Retour      : Abscisse à utiliser.                                         *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-gint g_virtual_node_get_x_for_vspan_slot(const GVirtualNode *node, vspan_slot_t slot, bool left)
-{
-    gint result;                            /* Position à retourner        */
-    GtkAllocation alloc;                    /* Taille totale requise       */
-
-    alloc = G_GRAPH_NODE(node)->alloc;
-
-    if (left)
-    {
-        /*BUG_ON(slot >= node->left_count) */
-
-        result = -(node->left_count - 1) * EDGE_HORIZONTAL_MIN_SEP/* + EDGE_SLOT_HORIZ_MARGIN*/;
-        result += (slot * EDGE_HORIZONTAL_MIN_SEP/* + EDGE_SLOT_HORIZ_MARGIN*/);
-
-        result += alloc.x;
-
-    }
-    else
-    {
-        /*BUG_ON(slot >= node->right_count) */
-
-        result = /*EDGE_SLOT_HORIZ_MARGIN + */slot * EDGE_HORIZONTAL_MIN_SEP;
-
-        result += alloc.x + alloc.width/* - EDGE_SLOT_HORIZ_MARGIN*/;
-        if (node->right_count > 0)
-            result -= (node->right_count - 1) * EDGE_HORIZONTAL_MIN_SEP;
-
-        /* On pense à la largeur du trait... */
-        result -= 2;
-
-    }
-
-    return result;
-
-}
diff --git a/src/gtkext/graph/nodes/virtual.h b/src/gtkext/graph/nodes/virtual.h
deleted file mode 100644
index 7f32591..0000000
--- a/src/gtkext/graph/nodes/virtual.h
+++ /dev/null
@@ -1,77 +0,0 @@
-
-/* Chrysalide - Outil d'analyse de fichiers binaires
- * virtual.h - prototypes pour l'encapsulation graphique des blocs virtuels
- *
- * Copyright (C) 2013 Cyrille Bagard
- *
- *  This file is part of Chrysalide.
- *
- *  OpenIDA is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 3 of the License, or
- *  (at your option) any later version.
- *
- *  OpenIDA is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with Foobar.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-
-#ifndef _GTKEXT_GRAPH_NODES_VIRTUAL_H
-#define _GTKEXT_GRAPH_NODES_VIRTUAL_H
-
-
-#include "../node.h"
-#include "../../../analysis/blocks/virtual.h"
-
-
-/* Indice d'une hauteur au sein des rangs */
-typedef size_t vspan_slot_t;
-
-/* Indice non initilisé */
-#define UNINITIALIZED_VSPAN_SLOT (~((vspan_slot_t)0))
-
-
-#define G_TYPE_VIRTUAL_NODE                  (g_virtual_node_get_type())
-#define G_VIRTUAL_NODE(obj)                  (G_TYPE_CHECK_INSTANCE_CAST((obj), G_TYPE_VIRTUAL_NODE, GVirtualNode))
-#define G_VIRTUAL_NODE_CLASS(klass)          (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_VIRTUAL_NODE, GVirtualNodeClass))
-#define G_IS_VIRTUAL_NODE(obj)               (G_TYPE_CHECK_INSTANCE_TYPE((obj), G_TYPE_VIRTUAL_NODE))
-#define G_IS_VIRTUAL_NODE_CLASS(klass)       (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_VIRTUAL_NODE))
-#define G_VIRTUAL_NODE_GET_CLASS(obj)        (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_VIRTUAL_NODE, GVirtualNodeClass))
-
-
-/* Encapsulation graphique d'un bloc virtuel (instance) */
-typedef struct _GVirtualNode GVirtualNode;
-
-/* Encapsulation graphique d'un bloc virtuel (classe) */
-typedef struct _GVirtualNodeClass GVirtualNodeClass;
-
-
-/* Indique le type définit par la GLib pour l'encapsulation d'un bloc virtuel. */
-GType g_virtual_node_get_type(void);
-
-/* Encapsule graphiquement un bloc virtuel. */
-GGraphNode *g_virtual_node_new(GVirtualBlock *);
-
-/* Ajoute un noeud au groupe courant. */
-void g_virtual_node_add_child(GVirtualNode *, GGraphNode *);
-
-/* Compte le nombre de noeuds contenus dans le groupe courant. */
-size_t g_virtual_node_count_children(const GVirtualNode *);
-
-/* Renvoie un des noeuds contenus dans le groupe courant. */
-GGraphNode *g_virtual_node_get_child(const GVirtualNode *, size_t);
-
-/* Réserve une portion de largeur pour un lien. */
-vspan_slot_t g_virtual_node_reserve_span(GVirtualNode *, unsigned int, unsigned int, bool);
-
-/* Fournit la position horizontale obtenue par réservation. */
-gint g_virtual_node_get_x_for_vspan_slot(const GVirtualNode *, vspan_slot_t, bool);
-
-
-
-#endif  /* _GTKEXT_GRAPH_NODES_VIRTUAL_H */
diff --git a/src/gtkext/graph/params.h b/src/gtkext/graph/params.h
deleted file mode 100644
index 9d26426..0000000
--- a/src/gtkext/graph/params.h
+++ /dev/null
@@ -1,84 +0,0 @@
-
-/* Chrysalide - Outil d'analyse de fichiers binaires
- * params.h - prototypes pour la modulation des paramètres de rendu
- *
- * Copyright (C) 2013 Cyrille Bagard
- *
- *  This file is part of Chrysalide.
- *
- *  OpenIDA is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 3 of the License, or
- *  (at your option) any later version.
- *
- *  OpenIDA is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with Foobar.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-
-#ifndef _GTKEXT_GRAPH_PARAMS_H
-#define _GTKEXT_GRAPH_PARAMS_H
-
-
-
-
-/* Coordonnés d'un noeud non initialisées */
-#define UNINITIALIZED_NODE_POS G_MININT
-
-
-/**
- * Paramètres à l'échelle du graphique.
- */
-
-/* Bordures supérieure et inférieure des graphiques */
-#define GRAPH_VERTICAL_MARGIN 15
-
-/* Bordures gauche et droite des graphiques */
-#define GRAPH_HORIZONTAL_MARGIN 15
-
-
-/**
- * Paramètres à l'échelle du noeud.
- */
-
-
-
-
-
-#define NODE_LEFT_MARGIN 25
-#define NODE_TOP_MARGIN 55      /* TODO : supprimer */
-
-
-
-
-
-
-/* Séparations minimales entre deux liens */
-#define EDGE_HORIZONTAL_MIN_SEP 10
-#define EDGE_VERTICAL_MIN_SEP 10
-
-/* Séparations minimales entre un lien et un noeud */
-#define EDGE_SLOT_HORIZ_MARGIN 20
-#define EDGE_SLOT_VERT_MARGIN 20
-
-/* Séparations minimales entre un noeud et un autre */
-#define NODE_HORIZONTAL_MARGIN 20
-#define NODE_VERTICAL_MARGIN 35
-
-
-
-
-#define SLOT_VERT_SEP EDGE_SLOT_VERT_MARGIN   /* TODO : remplacer */
-
-#define ARROW_LENGHT 10
-#define ARROW_DEGREES 10
-
-
-
-
-#endif  /* _GTKEXT_GRAPH_PARAMS_H */
diff --git a/src/gtkext/graph/ranks.c b/src/gtkext/graph/ranks.c
deleted file mode 100644
index e1f6688..0000000
--- a/src/gtkext/graph/ranks.c
+++ /dev/null
@@ -1,695 +0,0 @@
-
-/* Chrysalide - Outil d'analyse de fichiers binaires
- * ranks.c - calcul de l'ordonnée des différents classements
- *
- * Copyright (C) 2013 Cyrille Bagard
- *
- *  This file is part of Chrysalide.
- *
- *  OpenIDA is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 3 of the License, or
- *  (at your option) any later version.
- *
- *  OpenIDA is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with Foobar.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-
-#include "ranks.h"
-
-
-#include <malloc.h>
-#include <sys/param.h>
-
-
-#include "params.h"
-
-
-
-/* ---------------------- MANIPULATION DES PORTES HORIZONTALES ---------------------- */
-
-
-/* Etendue horizontale d'un lien */
-typedef struct _reserved_hspan
-{
-    gint x1;                                /* Départ d'une ligne          */
-    gint x2;                                /* Arrivée de cette même ligne */
-
-} reserved_hspan;
-
-/* Lignes de liens d'un même niveau */
-typedef struct _links_spans
-{
-    reserved_hspan *hspans;                 /* Lignes sans chevauchement   */
-    size_t count;                           /* Nombre de ces lignes        */
-
-} links_spans;
-
-
-/* Initialise les futures portées d'un même niveau. */
-static void init_links_spans(links_spans *);
-
-/* Regarde si des portées horizontales se chevauchent ou non. */
-static bool is_intersection_with_spans(const links_spans *, const reserved_hspan *);
-
-/* Ajoute une réservation à un ensemble de portées horizontales. */
-static void extend_links_spans(links_spans *, const reserved_hspan *);
-
-
-
-/* ------------------------ GESTION D'UN ETAGE DE CLASSEMENT ------------------------ */
-
-
-/* Information relatives à un rang de classement */
-typedef struct _rank_props
-{
-    links_spans *top_spans;                 /* Niveaux de lignes supérieurs*/
-    hspan_slot_t top_count;                 /* Nbre des niveaux de lignes  */
-    links_spans *bottom_spans;              /* Niveaux de lignes inférieurs*/
-    hspan_slot_t bottom_count;              /* Nbre des niveaux de lignes  */
-
-    gint height;                            /* Hauteur minimale            */
-    gint y;                                 /* Ordonnée finale             */
-
-} rank_props;
-
-
-/* Réserve une portion de hauteur pour un lien. */
-static hspan_slot_t reserve_span_in_rank_props(rank_props *, gint, gint, bool);
-
-/*  Calcule la position verticale du rang de classement. */
-static gint compute_rank_props_y_pos(rank_props *, gint *, gint);
-
-/* Fournit la position verticale obtenue par réservation. */
-static gint get_y_for_rank_props_hspan_slot(const rank_props *, hspan_slot_t, bool);
-
-
-
-/* ------------------------- CLASSEMENT VERTICAL DES NOEUDS ------------------------- */
-
-
-/* Calcul de l'ordonnée des différents classements (instance) */
-struct _GGraphRanks
-{
-    GObject parent;                         /* A laisser en premier        */
-
-    rank_props *props;                      /* Propriétés des rangs        */
-    unsigned int count;                     /* Nombre de rangs présents    */
-
-    gint height;                            /* Hauteur totale du graphique */
-
-};
-
-/* Calcul de l'ordonnée des différents classements (classe) */
-struct _GGraphRanksClass
-{
-    GObjectClass parent;                    /* A laisser en premier        */
-
-};
-
-
-/* Initialise la classe de calcul de l'ordonnée des classements. */
-static void g_graph_ranks_class_init(GGraphRanksClass *);
-
-/* Initialise un calcul de l'ordonnée des classements. */
-static void g_graph_ranks_init(GGraphRanks *);
-
-/* Supprime toutes les références externes. */
-static void g_graph_ranks_dispose(GGraphRanks *);
-
-/* Procède à la libération totale de la mémoire. */
-static void g_graph_ranks_finalize(GGraphRanks *);
-
-
-
-/* ---------------------------------------------------------------------------------- */
-/*                        MANIPULATION DES PORTES HORIZONTALES                        */
-/* ---------------------------------------------------------------------------------- */
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : spans = liste à initialiser.                                 *
-*                                                                             *
-*  Description : Initialise les futures portées d'un même niveau.             *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static void init_links_spans(links_spans *spans)
-{
-    spans->hspans = NULL;
-    spans->count = 0;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : spans = liste de portées déjà en place.                      *
-*                hspan = nouvelle portée à insérer quelque part.              *
-*                                                                             *
-*  Description : Regarde si des portées horizontales se chevauchent ou non.   *
-*                                                                             *
-*  Retour      : true si les portées peuvent cohabiter, false sinon.          *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static bool is_intersection_with_spans(const links_spans *spans, const reserved_hspan *hspan)
-{
-    bool result;                            /* Bilan d'analyse à retourner */
-    size_t i;                               /* Boucle de parcours          */
-
-    result = false;
-
-    for (i = 0; i < spans->count && !result; i++)
-    {
-        if (hspan->x1 < spans->hspans[i].x1)
-            result = hspan->x2 >= spans->hspans[i].x1;
-
-        else if (hspan->x1 > spans->hspans[i].x2)
-            result = hspan->x2 <= spans->hspans[i].x2;
-
-        else
-        {
-            result = spans->hspans[i].x1 < hspan->x1 && hspan->x1 < spans->hspans[i].x2;
-            result |= spans->hspans[i].x1 < hspan->x2 && hspan->x2 < spans->hspans[i].x2;
-        }
-
-    }
-
-    return result;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : spans = liste de portées déjà en place.                      *
-*                hspan = nouvelle portée à insérer quelque part.              *
-*                                                                             *
-*  Description : Ajoute une réservation à un ensemble de portées horizontales.*
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static void extend_links_spans(links_spans *spans, const reserved_hspan *new)
-{
-    spans->hspans = (reserved_hspan *)realloc(spans->hspans,
-                                              ++spans->count * sizeof(reserved_hspan));
-
-    if (new->x1 <= new->x2)
-        spans->hspans[spans->count - 1] = *new;
-    else
-    {
-        spans->hspans[spans->count - 1].x1 = new->x2;
-        spans->hspans[spans->count - 1].x2 = new->x1;
-    }
-
-}
-
-
-
-/* ---------------------------------------------------------------------------------- */
-/*                          GESTION D'UN ETAGE DE CLASSEMENT                          */
-/* ---------------------------------------------------------------------------------- */
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : props = propriétés de rang à mettre à jour.                  *
-*                                                                             *
-*  Description : Supprime les portions de hauteur pour un lien.               *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static void reset_spans_in_rank_props(rank_props *props)
-{
-    hspan_slot_t i;                         /* Boucle de parcours          */
-
-    for (i = 0; i < props->top_count; i++)
-        if (props->top_spans[i].hspans != NULL)
-            free(props->top_spans[i].hspans);
-
-    if (props->top_spans != NULL)
-    {
-        free(props->top_spans);
-        props->top_spans = NULL;
-        props->top_count = 0;
-    }
-
-    for (i = 0; i < props->bottom_count; i++)
-        if (props->bottom_spans[i].hspans != NULL)
-            free(props->bottom_spans[i].hspans);
-
-    if (props->bottom_spans != NULL)
-    {
-        free(props->bottom_spans);
-        props->bottom_spans = NULL;
-        props->bottom_count = 0;
-    }
-
-    props->y = 0;
-    props->height = 0;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : props = propriétés de rang à mettre à jour.                  *
-*                x1    = début de la portée à réserver.                       *
-*                x2    = fin de la portée à réserver.                         *
-*                top   = désignation de la zone à traiter.                    *
-*                                                                             *
-*  Description : Réserve une portion de hauteur pour un lien.                 *
-*                                                                             *
-*  Retour      : Indice de la hauteur adaptée et réservée.                    *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static hspan_slot_t reserve_span_in_rank_props(rank_props *props, gint x1, gint x2, bool top)
-{
-    hspan_slot_t result;                    /* Indice à retourner          */
-    reserved_hspan hspan;                   /* Portée à constituer         */
-    links_spans **list;                     /* Liste à parcourir           */
-    hspan_slot_t *count;                    /* Taille de cette liste       */
-
-    hspan.x1 = x1;
-    hspan.x2 = x2;
-
-    if (top)
-    {
-        list = &props->top_spans;
-        count = &props->top_count;
-    }
-    else
-    {
-        list = &props->bottom_spans;
-        count = &props->bottom_count;
-    }
-
-    for (result = 0; result < *count; result++)
-        if (!is_intersection_with_spans(&(*list)[result], &hspan))
-            break;
-
-    if (result == *count)
-    {
-        *list = (links_spans *)realloc(*list, ++(*count) * sizeof(links_spans));
-        init_links_spans(&(*list)[result]);
-    }
-
-    extend_links_spans(&(*list)[result], &hspan);
-
-    return result;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : props       = propriétés de rang à mettre à jour.            *
-*                y           = ordonnée courante à faire évoluer.             *
-*                last_bottom = espace inférieur requis du niveau précédent.   *
-*                                                                             *
-*  Description : Calcule la position verticale du rang de classement.         *
-*                                                                             *
-*  Retour      : Espace inférieur nécessaire au niveau de classement.         *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static gint compute_rank_props_y_pos(rank_props *props, gint *y, gint last_bottom)
-{
-    gint result;                            /* Espace Sud à retourner      */
-    gint top_margin;                        /* Espace Nord nécessaire      */
-
-    /* Espace supérieur pour les liens */
-
-    top_margin = last_bottom;
-
-    if (props->top_count > 0)
-    {
-        top_margin += props->top_count * EDGE_VERTICAL_MIN_SEP;
-        top_margin += EDGE_SLOT_VERT_MARGIN;
-    }
-
-    /**
-     * L'espace vertical entre les noeuds n'a lieu d'être qu'en présence de noeuds !
-     */
-    top_margin = MAX(top_margin, (*y > 0 && props->height > 0 ? NODE_VERTICAL_MARGIN : 0));
-
-    /* Position des noeuds */
-
-    props->y = *y + top_margin;
-    *y = props->y + props->height;
-
-    /* Espace inférieur pour les liens */
-
-    /**
-     * Fournit une marge minimum : si des liens autres que boucles partent de ce rang,
-     * il ne sont pas enregistrés à ce niveau, mais ont besoin d'espace quand même.
-     * On prend néanmoins garde aux rangs terminaux, potentiellement vides.
-     */
-    result = (props->height > 0 ? EDGE_SLOT_VERT_MARGIN : 0);
-
-    if (props->bottom_count > 0)
-        result += props->bottom_count * EDGE_VERTICAL_MIN_SEP;
-
-    return result;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : props = propriétés de rang à consulter.                      *
-*                slot  = numérod de la réservation.                           *
-*                top   = désignation de la zone à traiter.                    *
-*                                                                             *
-*  Description : Fournit la position verticale obtenue par réservation.       *
-*                                                                             *
-*  Retour      : Ordonnée à utiliser.                                         *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static gint get_y_for_rank_props_hspan_slot(const rank_props *props, hspan_slot_t slot, bool top)
-{
-    gint result;                            /* Ordonnée à retourner        */
-
-    result = EDGE_SLOT_VERT_MARGIN + slot * EDGE_VERTICAL_MIN_SEP;
-
-    if (top)
-        result = props->y - result;
-    else
-        result += props->y + props->height;
-
-    return result;
-
-}
-
-
-
-/* ---------------------------------------------------------------------------------- */
-/*                           CLASSEMENT VERTICAL DES NOEUDS                           */
-/* ---------------------------------------------------------------------------------- */
-
-
-/* Indique le type définit par la GLib pour le calcul de l'ordonnée des classements. */
-G_DEFINE_TYPE(GGraphRanks, g_graph_ranks, G_TYPE_OBJECT);
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : klass = classe à initialiser.                                *
-*                                                                             *
-*  Description : Initialise la classe de calcul de l'ordonnée des classements.*
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static void g_graph_ranks_class_init(GGraphRanksClass *klass)
-{
-    GObjectClass *object;                   /* Autre version de la classe  */
-
-    object = G_OBJECT_CLASS(klass);
-
-    object->dispose = (GObjectFinalizeFunc/* ! */)g_graph_ranks_dispose;
-    object->finalize = (GObjectFinalizeFunc)g_graph_ranks_finalize;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : ranks = instance à initialiser.                              *
-*                                                                             *
-*  Description : Initialise un calcul de l'ordonnée des classements.          *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static void g_graph_ranks_init(GGraphRanks *ranks)
-{
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : node = instance d'objet GLib à traiter.                      *
-*                                                                             *
-*  Description : Supprime toutes les références externes.                     *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static void g_graph_ranks_dispose(GGraphRanks *ranks)
-{
-    G_OBJECT_CLASS(g_graph_ranks_parent_class)->dispose(G_OBJECT(ranks));
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : ranks = instance d'objet GLib à traiter.                     *
-*                                                                             *
-*  Description : Procède à la libération totale de la mémoire.                *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static void g_graph_ranks_finalize(GGraphRanks *ranks)
-{
-    if (ranks->props != NULL)
-        free(ranks->props);
-
-    G_OBJECT_CLASS(g_graph_ranks_parent_class)->finalize(G_OBJECT(ranks));
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : count = nombre de rangs dans le classement au total.         *
-*                                                                             *
-*  Description : Prépare de quoi se définir au mieux les ordonnées des noeuds.*
-*                                                                             *
-*  Retour      : Adresse de la structure mise en place.                       *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-GGraphRanks *g_graph_ranks_new(unsigned int count)
-{
-    GGraphRanks *result;                    /* Structure à retourner       */
-
-    result = g_object_new(G_TYPE_GRAPH_RANKS, NULL);
-
-    result->count = count;
-    result->props = (rank_props *)calloc(count, sizeof(rank_props));
-
-    return result;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : ranks  = ensemble des rangs de classement à manipuler.       *
-*                index  = indice du rang visé.                                *
-*                height = hauteur minimale requise pour le rang donné.        *
-*                                                                             *
-*  Description : Note une hauteur minimale requise pour un rang du classement.*
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-void g_graph_ranks_set_min_height(GGraphRanks *ranks, unsigned int index, gint height)
-{
-    /*BUG_ON(index >= ranks->count) */
-
-    ranks->props[index].height = MAX(ranks->props[index].height, height);
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : ranks = ensemble des rangs de classement à consulter.        *
-*                                                                             *
-*  Description : Fournit la hauteur requise pour l'affichage des rangs.       *
-*                                                                             *
-*  Retour      : Hauteur nécessaire en pixel.                                 *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-gint g_graph_ranks_get_height(const GGraphRanks *ranks)
-{
-    return ranks->height;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : ranks = ensemble des rangs à mettre à jour.                  *
-*                                                                             *
-*  Description : Supprime toutes les réservations faites pour les liens.      *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-void g_graph_ranks_reset_reservations(GGraphRanks *ranks)
-{
-    unsigned int i;                         /* Boucle de parcours          */
-
-    for (i = 0; i < ranks->count; i++)
-        reset_spans_in_rank_props(&ranks->props[i]);
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : ranks = ensemble des rangs à mettre à jour.                  *
-*                index = indice du rang visé.                                 *
-*                x1    = début de la portée à réserver.                       *
-*                x2    = fin de la portée à réserver.                         *
-*                top   = désignation de la zone à traiter.                    *
-*                                                                             *
-*  Description : Réserve une portion de hauteur pour un lien.                 *
-*                                                                             *
-*  Retour      : Indice de la hauteur adaptée et réservée.                    *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-hspan_slot_t g_graph_ranks_reserve_span(GGraphRanks *ranks, unsigned int index, gint x1, gint x2, bool top)
-{
-    /*BUG_ON(index >= ranks->count) */
-
-    return reserve_span_in_rank_props(&ranks->props[index], x1, x2, top);
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : ranks = ensemble des rangs de classement à manipuler.        *
-*                                                                             *
-*  Description : Calcule l'ordonnée finale de chaque rang du classement.      *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-void g_graph_ranks_compute_y_line(GGraphRanks *ranks)
-{
-    gint last_bottom;                       /* Espace minimal à transmettre*/
-    gint y;                                 /* Ordonnée courante à proposer*/
-    size_t i;                               /* Boucle de parcours          */
-
-    last_bottom = GRAPH_VERTICAL_MARGIN;
-    y = 0;
-
-    for (i = 0; i < ranks->count; i++)
-        last_bottom = compute_rank_props_y_pos(&ranks->props[i], &y, last_bottom);
-
-    ranks->height = y + last_bottom + GRAPH_VERTICAL_MARGIN;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : ranks  = ensemble des rangs de classement à consulter.       *
-*                index  = indice du rang visé.                                *
-*                                                                             *
-*  Description : Fournit la position verticale correspondant à un rang donné. *
-*                                                                             *
-*  Retour      : Ordonnée à utiliser.                                         *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-gint g_graph_ranks_get_y_for_rank(const GGraphRanks *ranks, unsigned int index)
-{
-    /*BUG_ON(index >= ranks->count) */
-
-    return ranks->props[index].y;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : ranks = ensemble des rangs de classement à consulter.        *
-*                index = indice du rang visé.                                 *
-*                slot  = numérod de la réservation.                           *
-*                top   = désignation de la zone à traiter.                    *
-*                                                                             *
-*  Description : Fournit la position verticale obtenue par réservation.       *
-*                                                                             *
-*  Retour      : Ordonnée à utiliser.                                         *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-gint g_graph_ranks_get_y_for_hspan_slot(const GGraphRanks *ranks, unsigned int index, hspan_slot_t slot, bool top)
-{
-    /*BUG_ON(index >= ranks->count) */
-
-    return get_y_for_rank_props_hspan_slot(&ranks->props[index], slot, top);
-
-}
diff --git a/src/gtkext/graph/ranks.h b/src/gtkext/graph/ranks.h
deleted file mode 100644
index da7e54f..0000000
--- a/src/gtkext/graph/ranks.h
+++ /dev/null
@@ -1,82 +0,0 @@
-
-/* Chrysalide - Outil d'analyse de fichiers binaires
- * ranks.h - prototypes pour le calcul de l'ordonnée des différents classements
- *
- * Copyright (C) 2013 Cyrille Bagard
- *
- *  This file is part of Chrysalide.
- *
- *  OpenIDA is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 3 of the License, or
- *  (at your option) any later version.
- *
- *  OpenIDA is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with Foobar.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-
-#ifndef _GTKEXT_GRAPH_RANKS_H
-#define _GTKEXT_GRAPH_RANKS_H
-
-
-#include <glib-object.h>
-#include <stdbool.h>
-
-
-/* Indice d'une hauteur au sein des rangs */
-typedef size_t hspan_slot_t;
-
-/* Indice non initilisé */
-#define UNINITIALIZED_HSPAN_SLOT (~((hspan_slot_t)0))
-
-
-#define G_TYPE_GRAPH_RANKS               g_graph_ranks_get_type()
-#define G_GRAPH_RANKS(obj)               (G_TYPE_CHECK_INSTANCE_CAST((obj), g_graph_ranks_get_type(), GGraphRanks))
-#define G_IS_GRAPH_RANKS(obj)            (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_graph_ranks_get_type()))
-#define G_GRAPH_RANKS_GET_IFACE(inst)    (G_TYPE_INSTANCE_GET_INTERFACE((inst), g_graph_ranks_get_type(), GGraphRanksIface))
-#define G_GRAPH_RANKS_GET_CLASS(obj)     (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_GRAPH_RANKS, GGraphRanksClass))
-
-
-/* Calcul de l'ordonnée des différents classements (instance) */
-typedef struct _GGraphRanks GGraphRanks;
-
-/* Calcul de l'ordonnée des différents classements (classe) */
-typedef struct _GGraphRanksClass GGraphRanksClass;
-
-
-/* Indique le type définit par la GLib pour le calcul de l'ordonnée des classements. */
-GType g_graph_ranks_get_type(void);
-
-/* Prépare de quoi se définir au mieux les ordonnées des noeuds. */
-GGraphRanks *g_graph_ranks_new(unsigned int);
-
-/* Note une hauteur minimale requise pour un rang du classement. */
-void g_graph_ranks_set_min_height(GGraphRanks *, unsigned int, gint);
-
-/* Fournit la hauteur requise pour l'affichage des rangs. */
-gint g_graph_ranks_get_height(const GGraphRanks *);
-
-/* Supprime toutes les réservations faites pour les liens. */
-void g_graph_ranks_reset_reservations(GGraphRanks *);
-
-/* Réserve une portion de hauteur pour un lien. */
-hspan_slot_t g_graph_ranks_reserve_span(GGraphRanks *, unsigned int, gint, gint, bool);
-
-/* Calcule l'ordonnée finale de chaque rang du classement. */
-void g_graph_ranks_compute_y_line(GGraphRanks *);
-
-/* Fournit la position verticale correspondant à un rang donné. */
-gint g_graph_ranks_get_y_for_rank(const GGraphRanks *, unsigned int);
-
-/* Fournit la position verticale obtenue par réservation. */
-gint g_graph_ranks_get_y_for_hspan_slot(const GGraphRanks *, unsigned int, hspan_slot_t, bool);
-
-
-
-#endif  /* _GTKEXT_GRAPH_RANKS_H */