Avoided to throw comments too far by defining local columns managers.

1 files changed, 215 insertions, 24 deletions

diff --git a/src/glibext/gbufferline.c b/src/glibext/gbufferline.c
index 7768a0e..c998fce 100644
--- a/src/glibext/gbufferline.c
+++ b/src/glibext/gbufferline.c
@@ -99,6 +99,16 @@ struct _GBufferLine
 
     BufferLineFlags flags;                  /* Drapeaux particuliers       */
 
+    union
+    {
+        struct
+        {
+            gint max_widths[BLC_COUNT];     /* Taille cachée des colonnes  */
+            gint merged_width;              /* Largeur cumulée avant fusion*/
+        };
+        GBufferLine *manager;               /* Représentante d'un groupe   */
+    };
+
 };
 
 /* Représentation de fragments de texte en ligne (classe) */
@@ -122,6 +132,12 @@ static void g_buffer_line_class_init(GBufferLineClass *);
 /* Procède à l'initialisation d'une représentation de fragments. */
 static void g_buffer_line_init(GBufferLine *);
 
+/* Supprime toutes les références externes. */
+static void g_buffer_line_dispose(GBufferLine *);
+
+/* Procède à la libération totale de la mémoire. */
+static void g_buffer_line_finalize(GBufferLine *);
+
 
 
 /* ---------------------------------------------------------------------------------- */
@@ -453,8 +469,14 @@ G_DEFINE_TYPE(GBufferLine, g_buffer_line, G_TYPE_OBJECT);
 
 static void g_buffer_line_class_init(GBufferLineClass *class)
 {
+    GObjectClass *object;                   /* Autre version de la classe  */
     gchar *filename;                        /* Chemin d'accès à utiliser   */
 
+    object = G_OBJECT_CLASS(class);
+
+    object->dispose = (GObjectFinalizeFunc/* ! */)g_buffer_line_dispose;
+    object->finalize = (GObjectFinalizeFunc)g_buffer_line_finalize;
+
     filename = find_pixmap_file("entrypoint.png");
     assert(filename != NULL);
 
@@ -507,6 +529,49 @@ static void g_buffer_line_init(GBufferLine *line)
 
 /******************************************************************************
 *                                                                             *
+*  Paramètres  : line = instance d'objet GLib à traiter.                      *
+*                                                                             *
+*  Description : Supprime toutes les références externes.                     *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_buffer_line_dispose(GBufferLine *line)
+{
+    if (line->flags & BLF_WIDTH_MANAGER)
+        g_object_unref(G_OBJECT(line->manager));
+
+    G_OBJECT_CLASS(g_buffer_line_parent_class)->dispose(G_OBJECT(line));
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : line = instance d'objet GLib à traiter.                      *
+*                                                                             *
+*  Description : Procède à la libération totale de la mémoire.                *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_buffer_line_finalize(GBufferLine *line)
+{
+    /* TODO : segments des colonnes... */
+
+    G_OBJECT_CLASS(g_buffer_line_parent_class)->finalize(G_OBJECT(line));
+
+}
+
+
+/******************************************************************************
+*                                                                             *
 *  Paramètres  : range = emplacement où va se situer la ligne.                *
 *                main  = colonne à référencer comme étant la principale.      *
 *                                                                             *
@@ -792,7 +857,7 @@ GBufferSegment *g_buffer_line_get_segment_at(const GBufferLine *line, const gint
 
         if (i < line->merge_start)
         {
-            width = max_widths[i];
+            width = g_buffer_line_compute_max_width(line, i, max_widths);
 
             if ((i + 1) < BLC_COUNT) limit = width + COL_MARGIN / 2;
             else limit = width;
@@ -863,7 +928,10 @@ GBufferSegment *g_buffer_line_get_segment_at(const GBufferLine *line, const gint
                     printf(" -- update to col %u  -- x = %d\n", i, *offset);
 
                     if ((i - 1) < line->merge_start)
-                        *base += (max_widths[i - 1] + COL_MARGIN);
+                    {
+                        width = g_buffer_line_compute_max_width(line, i - 1, max_widths);
+                        *base += (width + COL_MARGIN);
+                    }
                     else
                         *base += get_column_width(&line->columns[i - 1]);
 
@@ -998,7 +1066,10 @@ GBufferSegment *g_buffer_line_find_near_segment(const GBufferLine *line, GBuffer
             displayed = (k < BLC_DISPLAY ? display[k] : true);
 
             if (displayed)
-                *offset += max_widths[k] + COL_MARGIN;
+            {
+                *offset += g_buffer_line_compute_max_width(line, k, max_widths);
+                if (k < line->merge_start) *offset += COL_MARGIN;
+            }
 
         }
 
@@ -1118,55 +1189,147 @@ char *g_buffer_line_get_text(const GBufferLine *line, BufferLineColumn first, Bu
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : line  = ligne à venir compléter.                             *
-*                index = index de la colonne visée par la procédure.          *
+*  Paramètres  : line    = ligne à venir consulter/compléter.                 *
+*                manager = ligne de départ d'un groupe de ligne.              *
 *                                                                             *
-*  Description : Fournit la largeur requise pour une colonne de ligne donnée. *
+*  Description : Retient les largeurs d'une ligne si maximales.               *
 *                                                                             *
-*  Retour      : Largeur en pixel requise.                                    *
+*  Retour      : -                                                            *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-gint g_buffer_line_get_column_width(GBufferLine *line, BufferLineColumn index)
+void g_buffer_line_update_max_widths(GBufferLine *line, GBufferLine *manager)
 {
-    gint result;                            /* Largeur à retourner         */
+    BufferLineColumn i;                     /* Boucle de parcours          */
+    GBufferLine *old;                       /* Ancienne ligne associée     */
+    gint merged_width;                      /* Largeur cumulée avant fusion*/
+    gint width;                             /* Largeur d'une colonne       */
 
-    if (index >= line->merge_start) result = 0;
-    else result = get_column_width(&line->columns[index]);
+    /* Réinitialisation ? */
 
-    return result;
+    if (line == manager)
+    {
+        assert(line->flags & BLF_WIDTH_MANAGER);
+
+        for (i = 0; i < BLC_COUNT; i++)
+            line->max_widths[i] = 0;
+
+        line->merged_width = 0;
+
+    }
+    else
+    {
+        assert((line->flags & BLF_WIDTH_MANAGER) == 0);
+
+        old = line->manager;
+
+        g_object_ref(G_OBJECT(manager));
+        line->manager = manager;
+
+        g_object_unref(G_OBJECT(old));
+
+    }
+
+    /* Mises à jour */
+
+    merged_width = 0;
+
+    for (i = 0; i < BLC_COUNT; i++)
+    {
+        width = get_column_width(&line->columns[i]);
+
+        if (i < line->merge_start)
+            manager->max_widths[i] = MAX(manager->max_widths[i], width);
+
+        if (i >= BLC_DISPLAY)
+        {
+            merged_width += width;
+
+            if (i < line->merge_start && (i + 1) < BLC_COUNT)
+                merged_width += COL_MARGIN;
+
+        }
+
+    }
+
+    if (line->merge_start != BLC_COUNT)
+        manager->merged_width = MAX(manager->merged_width, merged_width);
 
 }
 
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : line    = ligne à venir compléter.                           *
-*                merge   = précise la première colonne marquant la fusion. [OUT]*
-*                display = règles d'affichage des colonnes modulables.        *
+*  Paramètres  : line         = ligne à venir consulter.                      *
+*                max_widths   = tableau résumant les largeurs maximales. [OUT]*
+*                merged_width = largeur maximale en cas de fusion. |OUT]      *
 *                                                                             *
-*  Description : Fournit la dernière largeur d'une ligne avec fusion.         *
+*  Description : Filtre des largeurs de lignes et ne garde que les maximales. *
 *                                                                             *
-*  Retour      : Largeur en pixel requise.                                    *
+*  Retour      : -                                                            *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-gint g_buffer_line_get_merge_width(GBufferLine *line, BufferLineColumn *merge, const bool *display)
+void g_buffer_line_apply_max_widths(GBufferLine *line, gint *max_widths, gint *merged_width)
+{
+    GBufferLine *manager;                   /* Gestionnaire de groupe      */
+    BufferLineColumn i;                     /* Boucle de parcours          */
+
+    if (line->flags & BLF_WIDTH_MANAGER)
+        manager = line;
+    else
+        manager = line->manager;
+
+    for (i = 0; i < BLC_COUNT; i++)
+        max_widths[i] = MAX(manager->max_widths[i], max_widths[i]);
+
+    *merged_width = MAX(manager->merged_width, *merged_width);
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : line       = ligne à venir consulter.                        *
+*                index      = indice de la colonne visée.                     *
+*                max_widths = tableau résumant les largeurs maximales.        *
+*                                                                             *
+*  Description : Fournit la largeur d'une colonne finalement appliquée.       *
+*                                                                             *
+*  Retour      : Largeur globale ou spécifique, selon l'indice communiqué.    *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+gint g_buffer_line_compute_max_width(const GBufferLine *line, BufferLineColumn index, const gint *max_widths)
 {
     gint result;                            /* Largeur à retourner         */
 
-    result = 0;
+    assert(index < BLC_COUNT);
+
+    if (index >= line->merge_start)
+        result = get_column_width(&line->columns[index]);
+
+    else
+    {
+        if (index < BLC_ASSEMBLY)
+            result = max_widths[index];
 
-    /* TODO : wtf ?! quelle est l'utilité des arguments booléens ? */
+        else
+        {
+            if (line->flags & BLF_WIDTH_MANAGER)
+                result = line->max_widths[index];
+            else
+                result = line->manager->max_widths[index];
 
-    *merge = line->merge_start;
+        }
 
-    if (line->merge_start < BLC_COUNT)
-        result = get_column_width(&line->columns[line->merge_start]);
+    }
 
     return result;
 
@@ -1175,6 +1338,25 @@ gint g_buffer_line_get_merge_width(GBufferLine *line, BufferLineColumn *merge, c
 
 /******************************************************************************
 *                                                                             *
+*  Paramètres  : line = ligne à venir consulter.                              *
+*                                                                             *
+*  Description : Fournit la colonne à partir de laquelle une fusion opère.    *
+*                                                                             *
+*  Retour      : Début de la première (et unique) zone globale.               *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+BufferLineColumn g_buffer_line_get_merge_start(const GBufferLine *line)
+{
+    return line->merge_start;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
 *  Paramètres  : line  = ligne à venir compléter.                             *
 *                start = début de la première (et unique) zone globale.       *
 *                                                                             *
@@ -1290,6 +1472,7 @@ void g_buffer_line_draw(GBufferLine *line, cairo_t *cairo, const gint max_widths
     GBufferLineClass *class;                /* Stockage de briques de base */
     gint x;                                 /* Point de départ d'impression*/
     BufferLineColumn i;                     /* Boucle de parcours          */
+    gint max_width;                         /* Largeur maximale de colonne */
 
     if (line->flags != BLF_NONE && line->flags != BLF_HAS_CODE)
     {
@@ -1300,6 +1483,9 @@ void g_buffer_line_draw(GBufferLine *line, cairo_t *cairo, const gint max_widths
         else if (line->flags & BLF_BOOKMARK)
             cairo_set_source_surface(cairo, class->bookmark_img, 5, y);
 
+        //////////////////
+        cairo_set_source_surface(cairo, class->entrypoint_img, 5, y);
+
         cairo_paint(cairo);
 
     }
@@ -1313,7 +1499,12 @@ void g_buffer_line_draw(GBufferLine *line, cairo_t *cairo, const gint max_widths
         draw_segments_of_column(&line->columns[i], cairo, x, y, list);
 
         if (i < line->merge_start)
-            x += max_widths[i] + COL_MARGIN;
+        {
+            max_width = g_buffer_line_compute_max_width(line, i, max_widths);
+
+            x += max_width + COL_MARGIN;
+
+        }
 
     }