Rewritten the line buffers using generators and on-demand building to save memory.

4 files changed, 56 insertions, 26 deletions

diff --git a/src/gtkext/graph/cluster.c b/src/gtkext/graph/cluster.c
index 06e06c2..558e3cd 100644
--- a/src/gtkext/graph/cluster.c
+++ b/src/gtkext/graph/cluster.c
@@ -30,8 +30,8 @@
 #include <string.h>
 
 
-#include "../gtkblockview.h"
-#include "../gtkbufferview.h"
+#include "../gtkblockdisplay.h"
+#include "../gtkbufferdisplay.h"
 #include "../gtkdisplaypanel.h"
 #include "../../common/sort.h"
 
@@ -104,7 +104,7 @@ struct _GGraphCluster
     size_t ta_count;                        /* Quantité de ces accroches   */
 
     GBasicBlock *block;                     /* Bloc d'origine représenté   */
-    GtkWidget *view;                        /* Vue graphique associée      */
+    GtkWidget *display;                     /* Vue graphique associée      */
     GtkAllocation alloc;                    /* Emplacement final du bloc   */
 
     leaving_edge **bottom_anchors;          /* Accroches inférieures       */
@@ -255,7 +255,7 @@ static void g_graph_cluster_init(GGraphCluster *cluster)
 static void g_graph_cluster_dispose(GGraphCluster *cluster)
 {
     g_object_unref(G_OBJECT(cluster->block));
-    g_object_unref(G_OBJECT(cluster->view));
+    g_object_unref(G_OBJECT(cluster->display));
 
     G_OBJECT_CLASS(g_graph_cluster_parent_class)->dispose(G_OBJECT(cluster));
 
@@ -301,7 +301,7 @@ GGraphCluster *g_graph_cluster_new(GLoadedBinary *binary, const GBlockList *list
     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      */
+    GBufferCache *cache;                    /* Tampon brut à découper      */
     GBufferView *view;                      /* Partie affichée du tampon   */
     GtkRequisition requisition;             /* Taille à l'écran actuelle   */
 
@@ -312,26 +312,26 @@ GGraphCluster *g_graph_cluster_new(GLoadedBinary *binary, const GBlockList *list
     result->block = g_block_list_get_block(list, index);
     g_object_ref(G_OBJECT(result->block));
 
-    result->view = gtk_block_view_new();
+    result->display = gtk_block_display_new();
 
-    gtk_widget_show(result->view);
-    gtk_display_panel_attach_binary(GTK_DISPLAY_PANEL(result->view), binary, BVW_GRAPH);
+    gtk_widget_show(result->display);
+    gtk_display_panel_attach_binary(GTK_DISPLAY_PANEL(result->display), binary, BVW_GRAPH);
 
-    gtk_display_panel_show_border(GTK_DISPLAY_PANEL(result->view), true);
+    gtk_display_panel_show_border(GTK_DISPLAY_PANEL(result->display), true);
 
     /* Restriction au bloc basique */
 
     g_basic_block_get_boundary_addresses(result->block, &first, &last);
 
-    buffer = g_loaded_binary_get_disassembled_buffer(binary);
+    cache = g_loaded_binary_get_disassembled_cache(binary);
 
-    view = g_buffer_view_new(buffer, highlighted);
+    view = g_buffer_view_new(cache, highlighted);
     g_buffer_view_restrict(view, &first, &last);
-    gtk_buffer_view_attach_buffer(GTK_BUFFER_VIEW(result->view), view);
+    gtk_buffer_display_set_view(GTK_BUFFER_DISPLAY(result->display), view);
 
     /* Détermination d'une position initiale centrée */
 
-    gtk_widget_get_preferred_size(result->view, NULL, &requisition);
+    gtk_widget_get_preferred_size(result->display, NULL, &requisition);
 
     result->alloc.x = -requisition.width / 2;
     result->alloc.y = 0;
@@ -741,7 +741,7 @@ void g_graph_cluster_compute_needed_alloc(const GGraphCluster *cluster, GtkAlloc
 
                 if (needed.x < alloc->x)
                 {
-                    alloc->width += (alloc->x + needed.x);
+                    alloc->width += (alloc->x - needed.x);
                     alloc->x = needed.x;
                 }
 
@@ -765,7 +765,7 @@ void g_graph_cluster_compute_needed_alloc(const GGraphCluster *cluster, GtkAlloc
 
                 if (needed.x < alloc->x)
                 {
-                    alloc->width += (alloc->x + needed.x);
+                    alloc->width += (alloc->x - needed.x);
                     alloc->x = needed.x;
                 }
 
@@ -800,7 +800,7 @@ void g_graph_cluster_compute_needed_alloc(const GGraphCluster *cluster, GtkAlloc
 /******************************************************************************
 *                                                                             *
 *  Paramètres  : cluster = encapsulation à traiter.                           *
-*                view    = support de destination finale.                     *
+*                display = support de destination finale.                     *
 *                                                                             *
 *  Description : Dispose chaque noeud sur la surface de destination donnée.   *
 *                                                                             *
@@ -810,23 +810,23 @@ void g_graph_cluster_compute_needed_alloc(const GGraphCluster *cluster, GtkAlloc
 *                                                                             *
 ******************************************************************************/
 
-void g_graph_cluster_place(GGraphCluster *cluster, GtkGraphView *view)
+void g_graph_cluster_place(GGraphCluster *cluster, GtkGraphDisplay *display)
 {
     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);
+    g_object_ref(G_OBJECT(cluster->display));
+    gtk_graph_display_put(display, cluster->display, &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);
+        gtk_graph_display_add_edge(display, 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);
+            g_graph_cluster_place(cluster->ranks[i].clusters[j], display);
 
 }
 
@@ -1671,9 +1671,9 @@ static GGraphCluster *setup_graph_clusters(GLoadedBinary *binary, const GBlockLi
 
 /******************************************************************************
 *                                                                             *
-*  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.                   *
+*  Paramètres  : blocXXXXXXXXXXXXXXXXXXXXks = ensemble des blocs basiques déjà découpés.          *
+*                views  = morceaux de codXXXXXXXXXXXXXXXXXxe à afficher de façon organisée.     *
+*                count  = quantité de ces morceaux de code.XXXXXXXXXXXXXXXXXX                   *
 *                                                                             *
 *  Description : Construit un graphique à partir de blocs basiques.           *
 *                                                                             *
diff --git a/src/gtkext/graph/cluster.h b/src/gtkext/graph/cluster.h
index d43622b..9c375d3 100644
--- a/src/gtkext/graph/cluster.h
+++ b/src/gtkext/graph/cluster.h
@@ -26,7 +26,7 @@
 
 
 
-#include "../gtkgraphview.h"
+#include "../gtkgraphdisplay.h"
 #include "../../analysis/binary.h"
 #include "../../analysis/disass/block.h"
 
@@ -57,7 +57,7 @@ GGraphCluster *g_graph_cluster_new(GLoadedBinary *, const GBlockList *, size_t,
 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 *);
+void g_graph_cluster_place(GGraphCluster *, GtkGraphDisplay *);
 
 
 
diff --git a/src/gtkext/graph/edge.c b/src/gtkext/graph/edge.c
index 561b9f3..27400a6 100644
--- a/src/gtkext/graph/edge.c
+++ b/src/gtkext/graph/edge.c
@@ -267,6 +267,33 @@ void g_graph_edge_resolve(GGraphEdge *edge)
 
 /******************************************************************************
 *                                                                             *
+*  Paramètres  : edge = ligne de rendu à modifier dans ses positions.         *
+*                dx   = déplacement à effectuer sur l'axe des abscisses.      *
+*                dy   = déplacement à effectuer sur l'axe des ordonnées.      *
+*                                                                             *
+*  Description : Opère un décallage du lien dans une direction donnée.        *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+void g_graph_edge_offset(GGraphEdge *edge, gint dx, gint dy)
+{
+    size_t i;                               /* Boucle de parcours          */
+
+    for (i = 0; i < edge->count; i++)
+    {
+        edge->points[i].x += dx;
+        edge->points[i].y += dy;
+    }
+
+}
+
+
+/******************************************************************************
+*                                                                             *
 *  Paramètres  : edge  = ligne de rendu à manipuler.                          *
 *                cairo = assistant pour le rendu graphique.                   *
 *                arrow = indique le besoin en flèche à l'arrivée.             *
diff --git a/src/gtkext/graph/edge.h b/src/gtkext/graph/edge.h
index f60954c..4c43edb 100644
--- a/src/gtkext/graph/edge.h
+++ b/src/gtkext/graph/edge.h
@@ -81,6 +81,9 @@ void g_graph_edge_get_x_borders(const GGraphEdge *, gint *, gint *);
 /* Détermine les positions finales d'un lien graphique. */
 void g_graph_edge_resolve(GGraphEdge *);
 
+/* Opère un décallage du lien dans une direction donnée. */
+void g_graph_edge_offset(GGraphEdge *, gint, gint);
+
 /* Dessine les liens graphiques enregistrés dans le moteur. */
 void g_graph_edge_draw(const GGraphEdge *, cairo_t *, bool);