Handled all width measures per view in a dedicated manager.

1 files changed, 435 insertions, 529 deletions

diff --git a/src/glibext/gbufferline.c b/src/glibext/gbufferline.c
index 65e73d0..7e518cc 100644
--- a/src/glibext/gbufferline.c
+++ b/src/glibext/gbufferline.c
@@ -911,304 +911,6 @@ void g_buffer_line_fill_for_instr(GBufferLine *line, MemoryDataSize psize, Memor
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : line       = ligne à venir consulter.                        *
-*                max_widths = largeurs de colonne à respecter.                *
-*                display    = règles d'affichage des colonnes modulables.     *
-*                base       = position jusqu'au segment trouvé. [OUT]         *
-*                offset     = position à la colonne visée. [OUT]              *
-*                dir        = direction d'un éventuel déplacement en cours.   *
-*                force      = accepte les segments en bordure au pire.        *
-*                                                                             *
-*  Description : Donne le segment présent à une abscisse donnée.              *
-*                                                                             *
-*  Retour      : Segment trouvé ou NULL si hors borne.                        *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-GBufferSegment *g_buffer_line_get_segment_at(const GBufferLine *line, const gint max_widths[BLC_COUNT], const bool *display, gint *base, gint *offset, GdkScrollDirection dir, bool force)
-{
-    GBufferSegment *result;                 /* Trouvaille à retourner      */
-    BufferLineColumn last;                  /* Dernière colonne remplie    */
-    gint last_base;                         /* Dernière abscisse associée  */
-    BufferLineColumn i;                     /* Boucle de parcours          */
-    gint width;                             /* Largeur d'une colonne donnée*/
-
-    gint limit;
-
-    gint consumed;                          /* Distance vers le segment    */
-    gint old_base;                          /* Somme de toutes les largeurs*/
-
-    result = NULL;
-
-    *base = 0;
-
-    last = BLC_COUNT;
-
-    //sum = 0;
-
-    printf("---------------\n");
-
-    /* On cible déjà la colonne idéale */
-
-    for (i = 0; i < BLC_COUNT; i++)
-    {
-        printf(" @ (%d) x=%d  width=%d  max=%d  display ? %d\n",
-               i, *offset, get_column_width(&line->columns[i]), max_widths[i], i < BLC_DISPLAY ? display[i] : true);
-
-
-        if (i < BLC_DISPLAY && !display[i]) continue;
-
-        /* Mémorisation de la dernière colonne contenant quelque chose... */
-        if (get_column_width(&line->columns[i]) > 0)
-        {
-            last = i;
-            last_base = *base;
-        }
-
-        if (i < line->merge_start)
-        {
-            width = g_buffer_line_compute_max_width(line, i, max_widths);
-
-            if ((i + 1) < BLC_COUNT) limit = width + COL_MARGIN / 2;
-            else limit = width;
-
-            if (*offset <= limit) break;
-            else
-            {
-                *offset -= width + COL_MARGIN;
-                *base += width + COL_MARGIN;
-            }
-
-        }
-        else
-        {
-            width = get_column_width(&line->columns[i]);
-
-            if (*offset <= width) break;
-            else
-            {
-                *offset -= width;
-                *base += width;
-            }
-
-        }
-
-
-    }
-
-    printf(" -- get segment at -- found index %u (max=%u)\n", i, BLC_COUNT);
-
-
-    printf("                      last seen = %u\n", last);
-
-
-
-
-
-    if (i < BLC_COUNT)
-    {
-
-        printf(" -- width @ %u : %d\n", i, get_column_width(&line->columns[i]));
-
-        if (get_column_width(&line->columns[i]) > 0)
-        {
-            /**
-             * Si la position était au milieu d'une marge, la sélection a pu pousser
-             * jusqu'à la colonne suivante, plus proche.
-             * Relativment à la base de cette dernière, la position est donc devenue négative.
-             */
-            if (*offset < 0) *offset = 0;
-
-            result = get_segment_at(&line->columns[i], offset, dir, &consumed);
-            *base += consumed;
-        }
-
-        /* La position fournie tombe dans une colonne vide ! */
-        else
-        {
-            if (force || get_column_width(&line->columns[i]) == 0)
-            {
-                result = NULL;
-                *offset = 0;
-
-                old_base = *base;
-
-                for (i++; i < BLC_COUNT && result == NULL; i++)
-                {
-                    printf(" -- update to col %u  -- x = %d\n", i, *offset);
-
-                    if ((i - 1) < line->merge_start)
-                    {
-                        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]);
-
-                    result = get_first_segment(&line->columns[i]);
-
-                }
-
-                printf(" -- final x = %d (result=%p)\n", *offset, result);
-
-                if (result == NULL)
-                {
-                    *base = old_base;
-                    goto use_right_border;
-                }
-
-            }
-
-        }
-
-    }
-
-    else /* if (i == BLC_COUNT) */
-    {
-        if (force && last != BLC_COUNT)
-        {
- use_right_border:
-
-            result = get_last_segment(&line->columns[last]);
-            *base = last_base;
-            *offset = get_column_width(&line->columns[last]);
-
-        }
-        else
-            result = NULL;
-
-    }
-
-    return result;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : line    = ligne à venir consulter.                           *
-*                target  = segment dont un voisin est à retourner.            *
-*                max_widths = largeurs de colonne à respecter.                *
-*                display = règles d'affichage des colonnes modulables.        *
-*                dir     = orientation des recherches.                        *
-*                offset  = décalage pour amener à l'extrémité nouvelle. [OUT] *
-*                                                                             *
-*  Description : Fournit le segment voisin d'un autre segment identifié.      *
-*                                                                             *
-*  Retour      : Segment trouvé dans la ligne ou NULL.                        *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-GBufferSegment *g_buffer_line_find_near_segment(const GBufferLine *line, GBufferSegment *target, const gint max_widths[BLC_COUNT], const bool *display, GdkScrollDirection dir, gint *offset)
-{
-    GBufferSegment *result;                 /* Trouvaille à retourner      */
-    BufferLineColumn i;                     /* Boucle de parcours #1       */
-    bool displayed;                         /* Confort de lecture          */
-    BufferLineColumn k;                     /* Boucle de parcours #2       */
-
-    result = NULL;
-
-    /* Recherche dans la colonne de départ */
-
-    for (i = 0; i < BLC_COUNT; i++)
-        if (column_has_segment(&line->columns[i], target, NULL))
-            break;
-
-    if (i == BLC_COUNT) return NULL;
-
-    result = find_near_segment(&line->columns[i], target, dir);
-    if (result != NULL) return result;
-
-    /* Recherche dans la direction des colonnes voisines */
-
-    if (result == NULL)
-        switch (dir)
-        {
-            case GDK_SCROLL_LEFT:
-
-                /* Si on a atteint la première colonne sans trouver... */
-                if (i == 0) break;
-
-                /* On s'assure que la colonne précédente est visible et peuplée */
-                for (; i > BLC_FIRST && result == NULL; i--)
-                {
-                    displayed = (i <= BLC_DISPLAY ? display[i - 1] : true);
-
-                    if (displayed)
-                        result = get_last_segment(&line->columns[i - 1]);
-
-                }
-
-                break;
-
-            case GDK_SCROLL_RIGHT:
-
-                /* Si on a atteint la dernière colonne sans trouver... */
-                /*if (i == BLC_COUNT) break;*/
-
-                /* On s'assure que la colonne suivante est visible et peuplée */
-                for (; (i + 1) < BLC_COUNT && result == NULL; i++)
-                {
-                    displayed = ((i + 1) < BLC_DISPLAY ? display[i + 1] : true);
-
-                    if (displayed)
-                        result = get_first_segment(&line->columns[i + 1]);
-
-                }
-
-                break;
-
-        default:
-            break;
-
-    }
-
-    /* Calcul de la position finale */
-
-    if (result != NULL)
-    {
-        *offset = 0;
-
-        for (k = 0; k < i; k++)
-        {
-            displayed = (k < BLC_DISPLAY ? display[k] : true);
-
-            if (displayed)
-            {
-                *offset += g_buffer_line_compute_max_width(line, k, max_widths);
-                if (k < line->merge_start) *offset += COL_MARGIN;
-            }
-
-        }
-
-        switch (dir)
-        {
-            case GDK_SCROLL_LEFT:
-                *offset += get_column_width(&line->columns[i]);
-                break;
-
-            case GDK_SCROLL_RIGHT:
-                /**offset += 0;*/
-                break;
-
-            default:
-                break;
-
-        }
-
-    }
-
-    return result;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
 *  Paramètres  : line   = ligne à venir consulter.                            *
 *                column = indice de la colonne visée par les recherches.      *
 *                                                                             *
@@ -1456,111 +1158,97 @@ void g_buffer_line_delete_text(GBufferLine *line, BufferLineColumn first, Buffer
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : line    = ligne à venir consulter/compléter.                 *
-*                manager = ligne de départ d'un groupe de ligne.              *
+*  Paramètres  : line = ligne à venir consulter.                              *
 *                                                                             *
-*  Description : Retient les largeurs d'une ligne si maximales.               *
+*  Description : Fournit la colonne à partir de laquelle une fusion opère.    *
 *                                                                             *
-*  Retour      : -                                                            *
+*  Retour      : Début de la première (et unique) zone globale.               *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-void g_buffer_line_update_max_widths(GBufferLine *line, GBufferLine *manager)
+BufferLineColumn g_buffer_line_get_merge_start(const GBufferLine *line)
 {
-    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       */
-
-    /* Réinitialisation ? */
+    return line->merge_start;
 
-    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;
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : line  = ligne à venir compléter.                             *
+*                start = début de la première (et unique) zone globale.       *
+*                                                                             *
+*  Description : Définit la colonne à partir de laquelle la fusion opère.     *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
 
-    }
+void g_buffer_line_start_merge_at(GBufferLine *line, BufferLineColumn start)
+{
+    if (start == BLC_LAST_USED)
+        line->merge_start = line->last_used;
     else
-    {
-        assert((line->flags & BLF_WIDTH_MANAGER) == 0);
-
-        old = line->manager;
-
-        g_object_ref(G_OBJECT(manager));
-        line->manager = manager;
-
-        if (old != NULL)
-            g_object_unref(G_OBJECT(old));
+        line->merge_start = start;
 
-    }
+}
 
-    /* Mises à jour */
 
-    merged_width = 0;
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : line = ligne à venir compléter.                              *
+*                flag = propriété à intégrer.                                 *
+*                                                                             *
+*  Description : Ajoute une propriété particulière à une ligne donnée.        *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
 
-    for (i = 0; i < BLC_COUNT; i++)
+void g_buffer_line_add_flag(GBufferLine *line, BufferLineFlags flag)
+{
+    if ((line->flags & flag) == 0)
     {
-        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;
+        g_signal_emit_by_name(line, "flip-flag", line->flags, flag);
 
-        }
+        line->flags |= flag;
 
     }
 
-    if (line->merge_start != BLC_COUNT)
-        manager->merged_width = MAX(manager->merged_width, merged_width);
-
 }
 
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : line         = ligne à venir consulter.                      *
+*  Paramètres  : line = ligne à venir consulter.                              *
 *                                                                             *
-*  Description : Renvoie la ligne comptabilisant les largeurs pour un groupe. *
+*  Description : Renseigne sur les propriétés particulières liées à une ligne.*
 *                                                                             *
-*  Retour      : Ligne considérée comme la gestionnaire d'un ensemble.        *
+*  Retour      : Propriétés intégrées.                                        *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-GBufferLine *g_buffer_line_get_width_manager(GBufferLine *line)
+BufferLineFlags g_buffer_line_get_flags(const GBufferLine *line)
 {
-    GBufferLine *result;                    /* Gestionnaire à retourner    */
-
-    if (line->flags & BLF_WIDTH_MANAGER)
-        result = line;
-    else
-        result = line->manager;
-
-    return result;
+    return line->flags;
 
 }
 
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : line         = ligne à venir consulter.                      *
-*                max_widths   = tableau résumant les largeurs maximales. [OUT]*
-*                merged_width = largeur maximale en cas de fusion. |OUT]      *
+*  Paramètres  : line = ligne à venir compléter.                              *
+*                flag = propriété à supprimer.                                *
 *                                                                             *
-*  Description : Filtre des largeurs de lignes et ne garde que les maximales. *
+*  Description : Retire une propriété particulière à une ligne donnée.        *
 *                                                                             *
 *  Retour      : -                                                            *
 *                                                                             *
@@ -1568,190 +1256,492 @@ GBufferLine *g_buffer_line_get_width_manager(GBufferLine *line)
 *                                                                             *
 ******************************************************************************/
 
-void g_buffer_line_apply_max_widths(GBufferLine *line, gint *max_widths, gint *merged_width)
+void g_buffer_line_remove_flag(GBufferLine *line, BufferLineFlags flag)
 {
-    GBufferLine *manager;                   /* Gestionnaire de groupe      */
-    BufferLineColumn i;                     /* Boucle de parcours          */
-
-    manager = g_buffer_line_get_width_manager(line);
+    if ((line->flags & flag) != 0)
+    {
+        g_signal_emit_by_name(line, "flip-flag", line->flags, flag);
 
-    for (i = 0; i < BLC_COUNT; i++)
-        max_widths[i] = MAX(manager->max_widths[i], max_widths[i]);
+        line->flags &= ~flag;
 
-    *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.        *
+*  Paramètres  : line    = ligne de texte à manipuler.                        *
+*                ctx     = éléments à disposition pour l'exportation.         *
+*                type    = type d'exportation attendue.                       *
+*                display = règles d'affichage des colonnes modulables.        *
 *                                                                             *
-*  Description : Fournit la largeur d'une colonne finalement appliquée.       *
+*  Description : Exporte la ligne de texte représentée.                       *
 *                                                                             *
-*  Retour      : Largeur globale ou spécifique, selon l'indice communiqué.    *
+*  Retour      : -                                                            *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-gint g_buffer_line_compute_max_width(const GBufferLine *line, BufferLineColumn index, const gint *max_widths)
+void g_buffer_line_export(GBufferLine *line, buffer_export_context *ctx, BufferExportType type, const bool *display)
 {
-    gint result;                            /* Largeur à retourner         */
-    //GBufferLine *manager;                   /* Gestionnaire de groupe      */
-
-    assert(index < BLC_COUNT);
+    BufferLineColumn i;                     /* Boucle de parcours          */
+    int col_span;                           /* Fusion de colonnes ?        */
 
-    if (index >= line->merge_start)
-        result = get_column_width(&line->columns[index]);
+    switch (type)
+    {
+        case BET_HTML:
+            dprintf(ctx->fd, "\t<TR>\n");
+            break;
+        default:
+            break;
+    }
 
-    else
+    for (i = 0; i < BLC_COUNT; i++)
     {
-        if (index < BLC_ASSEMBLY)
-            result = max_widths[index];
+        if (i < BLC_DISPLAY && !display[i]) continue;
 
-        else
+        switch (type)
         {
-            //manager = g_buffer_line_get_width_manager(line);
+            case BET_TEXT:
+                if (i > 0) dprintf(ctx->fd, "%s", ctx->sep);
+                break;
+            default:
+                break;
+        }
 
-            if (line->flags & BLF_WIDTH_MANAGER)
-                result = line->max_widths[index];
-            else
-                result = line->manager->max_widths[index];
+        /**
+         * Pour la signification des différentes valeurs assignées,
+         * se référer au code de export_segments_of_column().
+         *
+         * En gros :
+         *   - 1  = rien de spécial.
+         *   - >1 = il s'agit de la première cellule fusionnée de la ligne.
+         *   - 0  = fusion déjà faite, on ne peut que rajouter du contenu dedans.
+         *   - <1 = il s'agit de la dernière cellule fusionnée de la ligne.
+         *
+         * On considère qu'une fusion ne peut pas se réaliser sur la dernière
+         * cellule uniquement (ce qui a du sens : c'est inutile).
+         */
 
-        }
+        if (i < line->merge_start)
+            col_span = 1;
+
+        else if (i == line->merge_start)
+            col_span = BLC_COUNT - i;
+
+        else
+            col_span = ((i + 1) == BLC_COUNT ? -1 : 0);
+
+        export_segments_of_column(&line->columns[i], ctx, type, col_span);
 
     }
 
-    return result;
+    switch (type)
+    {
+        case BET_TEXT:
+            dprintf(ctx->fd, "\n");
+            break;
+        case BET_HTML:
+            dprintf(ctx->fd, "</TR>\n");
+            break;
+        default:
+            break;
+    }
 
 }
 
 
+
+/*----------------------------------------------------------------------------------- */
+/*                         MANIPULATION DES LARGEURS REQUISES                         */
+/* ---------------------------------------------------------------------------------- */
+
+
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : line = ligne à venir consulter.                              *
+*  Paramètres  : line    = ligne à venir consulter.                           *
+*                summary = largeurs maximales à faire évoluer.                *
 *                                                                             *
-*  Description : Fournit la colonne à partir de laquelle une fusion opère.    *
+*  Description : Fait remonter les largeurs requises par une ligne donnée.    *
 *                                                                             *
-*  Retour      : Début de la première (et unique) zone globale.               *
+*  Retour      : -                                                            *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-BufferLineColumn g_buffer_line_get_merge_start(const GBufferLine *line)
+void g_buffer_line_collect_widths(GBufferLine *line, line_width_summary *summary)
 {
-    return line->merge_start;
+    gint merged_width;                      /* Largeur cumulée avant fusion*/
+    BufferLineColumn i;                     /* Boucle de parcours          */
+    gint width;                             /* Largeur d'une colonne       */
+
+    merged_width = 0;
+
+    for (i = 0; i < BLC_COUNT; i++)
+    {
+        width = get_column_width(&line->columns[i]);
+
+        if (i < line->merge_start)
+            summary->max_widths[i] = MAX(summary->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)
+        summary->merged_width = MAX(summary->merged_width, merged_width);
 
 }
 
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : line  = ligne à venir compléter.                             *
-*                start = début de la première (et unique) zone globale.       *
+*  Paramètres  : line    = ligne à venir consulter.                           *
+*                index   = indice de la colonne visée.                        *
+*                summary = résumé des largeurs maximales.                     *
 *                                                                             *
-*  Description : Définit la colonne à partir de laquelle la fusion opère.     *
+*  Description : Fournit la largeur d'une colonne finalement appliquée.       *
 *                                                                             *
-*  Retour      : -                                                            *
+*  Retour      : Largeur globale ou spécifique, selon l'indice communiqué.    *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-void g_buffer_line_start_merge_at(GBufferLine *line, BufferLineColumn start)
+gint g_buffer_line_compute_max_width(const GBufferLine *line, BufferLineColumn index, const line_width_summary *summary)
 {
-    if (start == BLC_LAST_USED)
-        line->merge_start = line->last_used;
+    gint result;                            /* Largeur à retourner         */
+
+    assert(index < BLC_COUNT);
+
+    if (index >= line->merge_start)
+        result = get_column_width(&line->columns[index]);
+
     else
-        line->merge_start = start;
+        result = summary->max_widths[index];
+
+    return result;
 
 }
 
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : line = ligne à venir compléter.                              *
-*                flag = propriété à intégrer.                                 *
+*  Paramètres  : line    = ligne à venir consulter.                           *
+*                summary = résumé des largeurs maximales.                     *
+*                display = règles d'affichage des colonnes modulables.        *
+*                base    = position jusqu'au segment trouvé. [OUT]            *
+*                offset  = position à la colonne visée. [OUT]                 *
+*                dir     = direction d'un éventuel déplacement en cours.      *
+*                force   = accepte les segments en bordure au pire.           *
 *                                                                             *
-*  Description : Ajoute une propriété particulière à une ligne donnée.        *
+*  Description : Donne le segment présent à une abscisse donnée.              *
 *                                                                             *
-*  Retour      : -                                                            *
+*  Retour      : Segment trouvé ou NULL si hors borne.                        *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-void g_buffer_line_add_flag(GBufferLine *line, BufferLineFlags flag)
+GBufferSegment *g_buffer_line_get_segment_at(const GBufferLine *line, const line_width_summary *summary, const bool *display, gint *base, gint *offset, GdkScrollDirection dir, bool force)
 {
-    if ((line->flags & flag) == 0)
+    GBufferSegment *result;                 /* Trouvaille à retourner      */
+    BufferLineColumn last;                  /* Dernière colonne remplie    */
+    gint last_base;                         /* Dernière abscisse associée  */
+    BufferLineColumn i;                     /* Boucle de parcours          */
+    gint width;                             /* Largeur d'une colonne donnée*/
+
+    gint limit;
+
+    gint consumed;                          /* Distance vers le segment    */
+    gint old_base;                          /* Somme de toutes les largeurs*/
+
+    result = NULL;
+
+    *base = 0;
+
+    last = BLC_COUNT;
+
+    //sum = 0;
+
+    printf("---------------\n");
+
+    /* On cible déjà la colonne idéale */
+
+    for (i = 0; i < BLC_COUNT; i++)
     {
-        g_signal_emit_by_name(line, "flip-flag", line->flags, flag);
+        printf(" @ (%d) x=%d  width=%d  max=%d  display ? %d\n",
+               i, *offset, get_column_width(&line->columns[i]), summary->max_widths[i], i < BLC_DISPLAY ? display[i] : true);
+
+
+        if (i < BLC_DISPLAY && !display[i]) continue;
+
+        /* Mémorisation de la dernière colonne contenant quelque chose... */
+        if (get_column_width(&line->columns[i]) > 0)
+        {
+            last = i;
+            last_base = *base;
+        }
+
+        if (i < line->merge_start)
+        {
+            width = g_buffer_line_compute_max_width(line, i, summary);
+
+            if ((i + 1) < BLC_COUNT) limit = width + COL_MARGIN / 2;
+            else limit = width;
+
+            if (*offset <= limit) break;
+            else
+            {
+                *offset -= width + COL_MARGIN;
+                *base += width + COL_MARGIN;
+            }
+
+        }
+        else
+        {
+            width = get_column_width(&line->columns[i]);
+
+            if (*offset <= width) break;
+            else
+            {
+                *offset -= width;
+                *base += width;
+            }
+
+        }
 
-        line->flags |= flag;
 
     }
 
-}
+    printf(" -- get segment at -- found index %u (max=%u)\n", i, BLC_COUNT);
 
 
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : line = ligne à venir consulter.                              *
-*                                                                             *
-*  Description : Renseigne sur les propriétés particulières liées à une ligne.*
-*                                                                             *
-*  Retour      : Propriétés intégrées.                                        *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
+    printf("                      last seen = %u\n", last);
 
-BufferLineFlags g_buffer_line_get_flags(const GBufferLine *line)
-{
-    return line->flags;
+
+
+
+
+    if (i < BLC_COUNT)
+    {
+
+        printf(" -- width @ %u : %d\n", i, get_column_width(&line->columns[i]));
+
+        if (get_column_width(&line->columns[i]) > 0)
+        {
+            /**
+             * Si la position était au milieu d'une marge, la sélection a pu pousser
+             * jusqu'à la colonne suivante, plus proche.
+             * Relativment à la base de cette dernière, la position est donc devenue négative.
+             */
+            if (*offset < 0) *offset = 0;
+
+            result = get_segment_at(&line->columns[i], offset, dir, &consumed);
+            *base += consumed;
+        }
+
+        /* La position fournie tombe dans une colonne vide ! */
+        else
+        {
+            if (force || get_column_width(&line->columns[i]) == 0)
+            {
+                result = NULL;
+                *offset = 0;
+
+                old_base = *base;
+
+                for (i++; i < BLC_COUNT && result == NULL; i++)
+                {
+                    printf(" -- update to col %u  -- x = %d\n", i, *offset);
+
+                    if ((i - 1) < line->merge_start)
+                    {
+                        width = g_buffer_line_compute_max_width(line, i - 1, summary);
+                        *base += (width + COL_MARGIN);
+                    }
+                    else
+                        *base += get_column_width(&line->columns[i - 1]);
+
+                    result = get_first_segment(&line->columns[i]);
+
+                }
+
+                printf(" -- final x = %d (result=%p)\n", *offset, result);
+
+                if (result == NULL)
+                {
+                    *base = old_base;
+                    goto use_right_border;
+                }
+
+            }
+
+        }
+
+    }
+
+    else /* if (i == BLC_COUNT) */
+    {
+        if (force && last != BLC_COUNT)
+        {
+ use_right_border:
+
+            result = get_last_segment(&line->columns[last]);
+            *base = last_base;
+            *offset = get_column_width(&line->columns[last]);
+
+        }
+        else
+            result = NULL;
+
+    }
+
+    return result;
 
 }
 
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : line = ligne à venir compléter.                              *
-*                flag = propriété à supprimer.                                *
+*  Paramètres  : line    = ligne à venir consulter.                           *
+*                target  = segment dont un voisin est à retourner.            *
+*                summary = résumé des largeurs maximales.                     *
+*                display = règles d'affichage des colonnes modulables.        *
+*                dir     = orientation des recherches.                        *
+*                offset  = décalage pour amener à l'extrémité nouvelle. [OUT] *
 *                                                                             *
-*  Description : Retire une propriété particulière à une ligne donnée.        *
+*  Description : Fournit le segment voisin d'un autre segment identifié.      *
 *                                                                             *
-*  Retour      : -                                                            *
+*  Retour      : Segment trouvé dans la ligne ou NULL.                        *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-void g_buffer_line_remove_flag(GBufferLine *line, BufferLineFlags flag)
+GBufferSegment *g_buffer_line_find_near_segment(const GBufferLine *line, GBufferSegment *target, const line_width_summary *summary, const bool *display, GdkScrollDirection dir, gint *offset)
 {
-    if ((line->flags & flag) != 0)
+    GBufferSegment *result;                 /* Trouvaille à retourner      */
+    BufferLineColumn i;                     /* Boucle de parcours #1       */
+    bool displayed;                         /* Confort de lecture          */
+    BufferLineColumn k;                     /* Boucle de parcours #2       */
+
+    result = NULL;
+
+    /* Recherche dans la colonne de départ */
+
+    for (i = 0; i < BLC_COUNT; i++)
+        if (column_has_segment(&line->columns[i], target, NULL))
+            break;
+
+    if (i == BLC_COUNT) return NULL;
+
+    result = find_near_segment(&line->columns[i], target, dir);
+    if (result != NULL) return result;
+
+    /* Recherche dans la direction des colonnes voisines */
+
+    if (result == NULL)
+        switch (dir)
+        {
+            case GDK_SCROLL_LEFT:
+
+                /* Si on a atteint la première colonne sans trouver... */
+                if (i == 0) break;
+
+                /* On s'assure que la colonne précédente est visible et peuplée */
+                for (; i > BLC_FIRST && result == NULL; i--)
+                {
+                    displayed = (i <= BLC_DISPLAY ? display[i - 1] : true);
+
+                    if (displayed)
+                        result = get_last_segment(&line->columns[i - 1]);
+
+                }
+
+                break;
+
+            case GDK_SCROLL_RIGHT:
+
+                /* Si on a atteint la dernière colonne sans trouver... */
+                /*if (i == BLC_COUNT) break;*/
+
+                /* On s'assure que la colonne suivante est visible et peuplée */
+                for (; (i + 1) < BLC_COUNT && result == NULL; i++)
+                {
+                    displayed = ((i + 1) < BLC_DISPLAY ? display[i + 1] : true);
+
+                    if (displayed)
+                        result = get_first_segment(&line->columns[i + 1]);
+
+                }
+
+                break;
+
+        default:
+            break;
+
+    }
+
+    /* Calcul de la position finale */
+
+    if (result != NULL)
     {
-        g_signal_emit_by_name(line, "flip-flag", line->flags, flag);
+        *offset = 0;
 
-        line->flags &= ~flag;
+        for (k = 0; k < i; k++)
+        {
+            displayed = (k < BLC_DISPLAY ? display[k] : true);
+
+            if (displayed)
+            {
+                *offset += g_buffer_line_compute_max_width(line, k, summary);
+                if (k < line->merge_start) *offset += COL_MARGIN;
+            }
+
+        }
+
+        switch (dir)
+        {
+            case GDK_SCROLL_LEFT:
+                *offset += get_column_width(&line->columns[i]);
+                break;
+
+            case GDK_SCROLL_RIGHT:
+                /**offset += 0;*/
+                break;
+
+            default:
+                break;
+
+        }
 
     }
 
+    return result;
+
 }
 
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : line       = ligne de texte à manipuler.                     *
-*                cairo      = contexte graphique à utiliser pour les pinceaux.*
-*                max_widths = largeurs de colonne à respecter.                *
-*                x_init     = abscisse du point d'impression de départ.       *
-*                y          = ordonnée du point d'impression.                 *
-*                display    = règles d'affichage des colonnes modulables.     *
-*                list       = liste de contenus à mettre en évidence.         *
+*  Paramètres  : line    = ligne de texte à manipuler.                        *
+*                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.                    *
+*                display = règles d'affichage des colonnes modulables.        *
+*                list    = liste de contenus à mettre en évidence.            *
 *                                                                             *
 *  Description : Imprime la ligne de texte représentée.                       *
 *                                                                             *
@@ -1761,7 +1751,7 @@ void g_buffer_line_remove_flag(GBufferLine *line, BufferLineFlags flag)
 *                                                                             *
 ******************************************************************************/
 
-void g_buffer_line_draw(GBufferLine *line, cairo_t *cairo, const gint max_widths[BLC_COUNT], gint x_init, gint y, const bool *display, const segcnt_list *list)
+void g_buffer_line_draw(GBufferLine *line, cairo_t *cairo, const line_width_summary *summary, gint x_init, gint y, const bool *display, const segcnt_list *list)
 {
     GBufferLineClass *class;                /* Stockage de briques de base */
     bool has_src_surface;                   /* Note une présence définie   */
@@ -1801,7 +1791,7 @@ void g_buffer_line_draw(GBufferLine *line, cairo_t *cairo, const gint max_widths
 
         if (i < line->merge_start)
         {
-            max_width = g_buffer_line_compute_max_width(line, i, max_widths);
+            max_width = g_buffer_line_compute_max_width(line, i, summary);
 
             x += max_width + COL_MARGIN;
 
@@ -1810,87 +1800,3 @@ void g_buffer_line_draw(GBufferLine *line, cairo_t *cairo, const gint max_widths
     }
 
 }
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : line    = ligne de texte à manipuler.                        *
-*                ctx     = éléments à disposition pour l'exportation.         *
-*                type    = type d'exportation attendue.                       *
-*                display = règles d'affichage des colonnes modulables.        *
-*                                                                             *
-*  Description : Exporte la ligne de texte représentée.                       *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-void g_buffer_line_export(GBufferLine *line, buffer_export_context *ctx, BufferExportType type, const bool *display)
-{
-    BufferLineColumn i;                     /* Boucle de parcours          */
-    int col_span;                           /* Fusion de colonnes ?        */
-
-    switch (type)
-    {
-        case BET_HTML:
-            dprintf(ctx->fd, "\t<TR>\n");
-            break;
-        default:
-            break;
-    }
-
-    for (i = 0; i < BLC_COUNT; i++)
-    {
-        if (i < BLC_DISPLAY && !display[i]) continue;
-
-        switch (type)
-        {
-            case BET_TEXT:
-                if (i > 0) dprintf(ctx->fd, "%s", ctx->sep);
-                break;
-            default:
-                break;
-        }
-
-        /**
-         * Pour la signification des différentes valeurs assignées,
-         * se référer au code de export_segments_of_column().
-         *
-         * En gros :
-         *   - 1  = rien de spécial.
-         *   - >1 = il s'agit de la première cellule fusionnée de la ligne.
-         *   - 0  = fusion déjà faite, on ne peut que rajouter du contenu dedans.
-         *   - <1 = il s'agit de la dernière cellule fusionnée de la ligne.
-         *
-         * On considère qu'une fusion ne peut pas se réaliser sur la dernière
-         * cellule uniquement (ce qui a du sens : c'est inutile).
-         */
-
-        if (i < line->merge_start)
-            col_span = 1;
-
-        else if (i == line->merge_start)
-            col_span = BLC_COUNT - i;
-
-        else
-            col_span = ((i + 1) == BLC_COUNT ? -1 : 0);
-
-        export_segments_of_column(&line->columns[i], ctx, type, col_span);
-
-    }
-
-    switch (type)
-    {
-        case BET_TEXT:
-            dprintf(ctx->fd, "\n");
-            break;
-        case BET_HTML:
-            dprintf(ctx->fd, "</TR>\n");
-            break;
-        default:
-            break;
-    }
-
-}