Reduced the quantity of arguments used to deal with lines.

1 files changed, 55 insertions, 89 deletions

diff --git a/src/glibext/bufferline.c b/src/glibext/bufferline.c
index b9413e2..2f694dd 100644
--- a/src/glibext/bufferline.c
+++ b/src/glibext/bufferline.c
@@ -65,15 +65,6 @@ struct _GBufferLine
     content_origin *origins;                /* Mémorisation des origines   */
     size_t ocount;                          /* Nombre de ces mémorisations */
 
-    union
-    {
-        struct
-        {
-            gint max_widths[BLC_COUNT];     /* Taille cachée des colonnes  */
-            gint merged_width;              /* Largeur cumulée avant fusion*/
-        };
-    };
-
 };
 
 /* Représentation de fragments de texte en ligne (classe) */
@@ -568,7 +559,7 @@ void g_buffer_line_append_text(GBufferLine *line, size_t column, const char *tex
 
     if (creator != NULL)
     {
-        line->origins = (content_origin *)realloc(line->origins, ++line->ocount * sizeof(content_origin));
+        line->origins = realloc(line->origins, ++line->ocount * sizeof(content_origin));
 
         origin = &line->origins[line->ocount - 1];
 
@@ -984,43 +975,6 @@ void g_buffer_line_collect_widths(GBufferLine *line, line_width_summary *summary
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : line    = ligne à venir consulter.                           *
-*                index   = indice de la colonne visée.                        *
-*                summary = résumé des largeurs maximales.                     *
-*                offsets = décalages supplémentaires à appliquer.             *
-*                                                                             *
-*  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 line_width_summary *summary, const line_width_summary *offsets)
-{
-    gint result;                            /* Largeur à retourner         */
-
-    assert(index < BLC_COUNT);
-
-    if (index >= line->merge_start)
-        result = get_column_width(&line->columns[index]);
-
-    else
-        result = summary->max_widths[index];
-
-    if (result < offsets->max_widths[index])
-        result = offsets->max_widths[index];
-
-    return result;
-
-}
-
-
-
-
-/******************************************************************************
-*                                                                             *
 *  Paramètres  : line  = ligne à venir consulter.                             *
 *                coord = coordonnées interne du segment à retrouver.          *
 *                                                                             *
@@ -1049,7 +1003,8 @@ line_segment *g_buffer_line_get_segment_from_coord(const GBufferLine *line, cons
 /******************************************************************************
 *                                                                             *
 *  Paramètres  : line    = ligne à venir consulter.                           *
-*                summary = résumé des largeurs maximales.                     *
+*                index   = indice de ligne associé.                           *
+*                tracker = gestionnaire de largeur à consulter au besoin.     *
 *                options = règles d'affichage des colonnes modulables.        *
 *                offsets = décalages supplémentaires à appliquer.             *
 *                base    = position jusqu'au segment trouvé. [OUT]            *
@@ -1066,12 +1021,13 @@ line_segment *g_buffer_line_get_segment_from_coord(const GBufferLine *line, cons
 *                                                                             *
 ******************************************************************************/
 
-bool g_buffer_line_get_coord_at(const GBufferLine *line, const line_width_summary *summary, const GDisplayOptions *options, const line_width_summary *offsets, gint *base, gint *offset, GdkScrollDirection dir, bool force, col_coord_t *coord)
+bool g_buffer_line_get_coord_at(const GBufferLine *line, size_t index, GWidthTracker *tracker, const GDisplayOptions *options, gint *base, gint *offset, GdkScrollDirection dir, bool force, col_coord_t *coord)
 {
     bool result;                            /* Bilan à retourner           */
     BufferLineColumn last;                  /* Dernière colonne remplie    */
     gint last_base;                         /* Dernière abscisse associée  */
-    size_t count;                           /* Qté de colonnes en option   */
+    size_t col_count;                       /* Qté de colonnes présentes   */
+    size_t opt_count;                       /* Qté de colonnes en option   */
     size_t i;                               /* Boucle de parcours          */
     gint width;                             /* Largeur d'une colonne donnée*/
     gint limit;                             /* Limite d'appartenance       */
@@ -1087,11 +1043,12 @@ bool g_buffer_line_get_coord_at(const GBufferLine *line, const line_width_summar
 
     /* On cible déjà la colonne idéale */
 
-    count = g_display_options_count(options);
+    col_count = g_width_tracker_count_columns(tracker);
+    opt_count = g_display_options_count(options);
 
-    for (i = 0; i < BLC_COUNT; i++)
+    for (i = 0; i < col_count; i++)
     {
-        if (i < count)
+        if (i < opt_count)
         {
             if (!g_display_options_get(options, i))
                 continue;
@@ -1106,12 +1063,12 @@ bool g_buffer_line_get_coord_at(const GBufferLine *line, const line_width_summar
 
         if (i < line->merge_start)
         {
-            width = g_buffer_line_compute_max_width(line, i, summary, offsets);
+            width = g_width_tracker_get_local_column_width(tracker, index, i, opt_count);
 
             /* Si la colonne n'est absolument pas visible, on ne s'arrête pas dessus ! */
             if (width == 0) continue;
 
-            if ((i + 1) < BLC_COUNT) limit = width + COL_MARGIN / 2;
+            if ((i + 1) < col_count) limit = width + COL_MARGIN / 2;
             else limit = width;
 
             if (*offset <= limit) break;
@@ -1140,7 +1097,7 @@ bool g_buffer_line_get_coord_at(const GBufferLine *line, const line_width_summar
 
     /* Si l'abscisse fournie tombe encore dans une colonne... */
 
-    if (i < BLC_COUNT)
+    if (i < col_count)
     {
         /* Il y a bien du contenu dans cette colonne */
 
@@ -1176,11 +1133,11 @@ bool g_buffer_line_get_coord_at(const GBufferLine *line, const line_width_summar
 
                 old_base = *base;
 
-                for (i++; i < BLC_COUNT && !result; i++)
+                for (i++; i < col_count && !result; i++)
                 {
                     if ((i - 1) < line->merge_start)
                     {
-                        width = g_buffer_line_compute_max_width(line, i - 1, summary, offsets);
+                        width = g_width_tracker_get_local_column_width(tracker, index, i - 1, opt_count);
 
                         if (width > 0)
                             *base += (width + COL_MARGIN);
@@ -1208,13 +1165,13 @@ bool g_buffer_line_get_coord_at(const GBufferLine *line, const line_width_summar
 
     }
 
-    else /* if (i == BLC_COUNT) */
+    else /* if (i == col_count) */
     {
         if (force)
         {
  use_right_border:
 
-            if (last != BLC_COUNT)
+            if (last != col_count)
             {
                 result = get_line_column_last_content_index(&line->columns[last], &coord->index);
 
@@ -1237,7 +1194,7 @@ bool g_buffer_line_get_coord_at(const GBufferLine *line, const line_width_summar
                 *base = 0;
                 *offset = 0;
 
-                coord->column = BLC_COUNT;
+                coord->column = col_count;
                 coord->index = -1;
 
             }
@@ -1256,9 +1213,9 @@ bool g_buffer_line_get_coord_at(const GBufferLine *line, const line_width_summar
 /******************************************************************************
 *                                                                             *
 *  Paramètres  : line    = ligne à venir consulter.                           *
-*                summary = résumé des largeurs maximales.                     *
+*                index   = indice de ligne associé.                           *
+*                tracker = gestionnaire de largeur à consulter au besoin.     *
 *                options = règles d'affichage des colonnes modulables.        *
-*                offsets = décalages supplémentaires à appliquer.             *
 *                base    = position jusqu'au segment trouvé. [OUT]            *
 *                offset  = position à la colonne visée. [OUT]                 *
 *                dir     = direction d'un éventuel déplacement en cours.      *
@@ -1272,13 +1229,13 @@ bool g_buffer_line_get_coord_at(const GBufferLine *line, const line_width_summar
 *                                                                             *
 ******************************************************************************/
 
-line_segment *g_buffer_line_get_segment_at(const GBufferLine *line, const line_width_summary *summary, const GDisplayOptions *options, const line_width_summary *offsets, gint *base, gint *offset, GdkScrollDirection dir, bool force)
+line_segment *g_buffer_line_get_segment_at(const GBufferLine *line, size_t index, GWidthTracker *tracker, const GDisplayOptions *options, gint *base, gint *offset, GdkScrollDirection dir, bool force)
 {
     line_segment *result;                   /* Trouvaille à retourner      */
     col_coord_t coord;                      /* Emplacement du contenu visé */
     bool status;                            /* Bilan de la localisation    */
 
-    status = g_buffer_line_get_coord_at(line, summary, options, offsets, base, offset, dir, force, &coord);
+    status = g_buffer_line_get_coord_at(line, index, tracker, options, base, offset, dir, force, &coord);
 
     if (status)
         result = g_buffer_line_get_segment_from_coord(line, &coord);
@@ -1293,9 +1250,9 @@ line_segment *g_buffer_line_get_segment_at(const GBufferLine *line, const line_w
 /******************************************************************************
 *                                                                             *
 *  Paramètres  : line    = ligne à venir consulter.                           *
-*                summary = résumé des largeurs maximales.                     *
+*                index   = indice de ligne associé.                           *
+*                tracker = gestionnaire de largeur à consulter au besoin.     *
 *                options = règles d'affichage des colonnes modulables.        *
-*                offsets = décalages supplémentaires à appliquer.             *
 *                base    = position jusqu'au segment trouvé. [OUT]            *
 *                offset  = position à la colonne visée. [OUT]                 *
 *                dir     = direction d'un éventuel déplacement en cours.      *
@@ -1309,7 +1266,7 @@ line_segment *g_buffer_line_get_segment_at(const GBufferLine *line, const line_w
 *                                                                             *
 ******************************************************************************/
 
-GObject *g_buffer_line_get_creator_at(const GBufferLine *line, const line_width_summary *summary, const GDisplayOptions *options, const line_width_summary *offsets, gint *base, gint *offset, GdkScrollDirection dir, bool force)
+GObject *g_buffer_line_get_creator_at(const GBufferLine *line, size_t index, GWidthTracker *tracker, const GDisplayOptions *options, gint *base, gint *offset, GdkScrollDirection dir, bool force)
 {
     GObject *result;                        /* Trouvaille à retourner      */
     col_coord_t target;                     /* Emplacement du contenu visé */
@@ -1319,7 +1276,7 @@ GObject *g_buffer_line_get_creator_at(const GBufferLine *line, const line_width_
 
     result = NULL;
 
-    status = g_buffer_line_get_coord_at(line, summary, options, offsets, base, offset, dir, force, &target);
+    status = g_buffer_line_get_coord_at(line, index, tracker, options, base, offset, dir, force, &target);
 
     if (status)
     {
@@ -1345,10 +1302,10 @@ GObject *g_buffer_line_get_creator_at(const GBufferLine *line, const line_width_
 /******************************************************************************
 *                                                                             *
 *  Paramètres  : line    = ligne à venir consulter.                           *
+*                index   = indice de ligne associé.                           *
 *                coord   = cordonnées à consulter puis renseigner. [OUT]      *
-*                summary = résumé des largeurs maximales.                     *
+*                tracker = gestionnaire de largeur à consulter au besoin.     *
 *                options = règles d'affichage des colonnes modulables.        *
-*                offsets = décalages supplémentaires à appliquer.             *
 *                dir     = orientation des recherches.                        *
 *                offset  = décalage pour amener à l'extrémité nouvelle. [OUT] *
 *                                                                             *
@@ -1360,28 +1317,31 @@ GObject *g_buffer_line_get_creator_at(const GBufferLine *line, const line_width_
 *                                                                             *
 ******************************************************************************/
 
-bool g_buffer_line_find_near_coord(const GBufferLine *line, col_coord_t *coord, const line_width_summary *summary, const GDisplayOptions *options, const line_width_summary *offsets, GdkScrollDirection dir, gint *offset)
+bool g_buffer_line_find_near_coord(const GBufferLine *line, size_t index, col_coord_t *coord, GWidthTracker *tracker, const GDisplayOptions *options, GdkScrollDirection dir, gint *offset)
 {
     bool result;                            /* Bilan à retourner           */
-    size_t count;                           /* Qté de colonnes en option   */
+    size_t col_count;                       /* Qté de colonnes présentes   */
     size_t i;                               /* Boucle de parcours #1       */
+    size_t opt_count;                       /* Qté de colonnes en option   */
     bool displayed;                         /* Confort de lecture          */
     size_t k;                               /* Boucle de parcours #2       */
     gint width;                             /* Largeur d'une colonne donnée*/
 
     result = false;
 
+    col_count = g_width_tracker_count_columns(tracker);
+
     /* Recherche dans la colonne de départ */
 
     i = coord->column;
 
-    if (i == BLC_COUNT) return false;
+    if (i == col_count) return false;
 
     result = find_near_segment(&line->columns[i], &coord->index, dir);
 
     /* Recherche dans la direction des colonnes voisines */
 
-    count = g_display_options_count(options);
+    opt_count = g_display_options_count(options);
 
     if (!result)
         switch (dir)
@@ -1392,9 +1352,9 @@ bool g_buffer_line_find_near_coord(const GBufferLine *line, col_coord_t *coord,
                 if (i == 0) break;
 
                 /* On s'assure que la colonne précédente est visible et peuplée */
-                for (; i > BLC_FIRST && !result; i--)
+                for (; i > 0 && !result; i--)
                 {
-                    displayed = (i <= count ? g_display_options_get(options, i - 1) : true);
+                    displayed = (i <= opt_count ? g_display_options_get(options, i - 1) : true);
 
                     if (displayed)
                     {
@@ -1412,9 +1372,9 @@ bool g_buffer_line_find_near_coord(const GBufferLine *line, col_coord_t *coord,
             case GDK_SCROLL_RIGHT:
 
                 /* On s'assure que la colonne suivante est visible et peuplée */
-                for (; (i + 1) < BLC_COUNT && !result; i++)
+                for (; (i + 1) < col_count && !result; i++)
                 {
-                    displayed = ((i + 1) < count ? g_display_options_get(options, i + 1) : true);
+                    displayed = ((i + 1) < opt_count ? g_display_options_get(options, i + 1) : true);
 
                     if (displayed)
                     {
@@ -1442,11 +1402,15 @@ bool g_buffer_line_find_near_coord(const GBufferLine *line, col_coord_t *coord,
 
         for (k = 0; k < i; k++)
         {
-            displayed = (k < count ? g_display_options_get(options, k) : true);
+            displayed = (k < opt_count ? g_display_options_get(options, k) : true);
 
             if (displayed)
             {
-                width = g_buffer_line_compute_max_width(line, k, summary, offsets);
+
+                if (k >= line->merge_start)
+                    width = get_column_width(&line->columns[index]);
+                else
+                    width = g_width_tracker_get_local_column_width(tracker, index, k, opt_count);
 
                 if (width > 0)
                 {
@@ -1483,12 +1447,12 @@ bool g_buffer_line_find_near_coord(const GBufferLine *line, col_coord_t *coord,
 /******************************************************************************
 *                                                                             *
 *  Paramètres  : line    = ligne de texte à manipuler.                        *
+*                index   = indice de ligne associé.                           *
 *                cairo   = contexte graphique à utiliser pour les pinceaux.   *
-*                summary = résumé des largeurs maximales.                     *
 *                x_init  = abscisse du point d'impression de départ.          *
 *                y       = ordonnée du point d'impression.                    *
+*                tracker = gestionnaire de largeur à consulter au besoin.     *
 *                options = règles d'affichage des colonnes modulables.        *
-*                offsets = décalages supplémentaires à appliquer.             *
 *                list    = liste de contenus à mettre en évidence.            *
 *                                                                             *
 *  Description : Imprime la ligne de texte représentée.                       *
@@ -1499,12 +1463,13 @@ bool g_buffer_line_find_near_coord(const GBufferLine *line, col_coord_t *coord,
 *                                                                             *
 ******************************************************************************/
 
-void g_buffer_line_draw(GBufferLine *line, cairo_t *cairo, const line_width_summary *summary, gint x_init, gint y, const GDisplayOptions *options, const line_width_summary *offsets, const segcnt_list *list)
+void g_buffer_line_draw(GBufferLine *line, size_t index, cairo_t *cairo, gint x_init, gint y, GWidthTracker *tracker, const GDisplayOptions *options, const segcnt_list *list)
 {
     GBufferLineClass *class;                /* Stockage de briques de base */
     bool has_src_surface;                   /* Note une présence définie   */
     gint x;                                 /* Point de départ d'impression*/
-    size_t count;                           /* Qté de colonnes en option   */
+    size_t col_count;                       /* Qté de colonnes présentes   */
+    size_t opt_count;                       /* Qté de colonnes en option   */
     size_t i;                               /* Boucle de parcours          */
     gint max_width;                         /* Largeur maximale de colonne */
 
@@ -1532,11 +1497,12 @@ void g_buffer_line_draw(GBufferLine *line, cairo_t *cairo, const line_width_summ
 
     x = x_init;
 
-    count = g_display_options_count(options);
+    col_count = g_width_tracker_count_columns(tracker);
+    opt_count = g_display_options_count(options);
 
-    for (i = 0; i < BLC_COUNT; i++)
+    for (i = 0; i < col_count; i++)
     {
-        if (i < count)
+        if (i < opt_count)
         {
             if (!g_display_options_get(options, i))
                 continue;
@@ -1546,7 +1512,7 @@ void g_buffer_line_draw(GBufferLine *line, cairo_t *cairo, const line_width_summ
 
         if (i < line->merge_start)
         {
-            max_width = g_buffer_line_compute_max_width(line, i, summary, offsets);
+            max_width = g_width_tracker_get_local_column_width(tracker, index, i, opt_count);
 
             if (max_width > 0)
                 x += max_width + COL_MARGIN;