Given their own structure to rendering options.

12 files changed, 512 insertions, 87 deletions

diff --git a/src/glibext/Makefile.am b/src/glibext/Makefile.am
index 9efc138..f2292d9 100644
--- a/src/glibext/Makefile.am
+++ b/src/glibext/Makefile.am
@@ -13,6 +13,7 @@ libglibext_la_SOURCES =					\
 	gbuffercache.h gbuffercache.c		\
 	gbufferline.h gbufferline.c			\
 	gbufferview.h gbufferview.c			\
+	gdisplayoptions.h gdisplayoptions.c	\
 	glinecursor-int.h					\
 	glinecursor.h glinecursor.c			\
 	gloadedpanel-int.h					\
diff --git a/src/glibext/gbuffercache.c b/src/glibext/gbuffercache.c
index 91f3a6d..7293e7c 100644
--- a/src/glibext/gbuffercache.c
+++ b/src/glibext/gbuffercache.c
@@ -1415,7 +1415,7 @@ void g_buffer_cache_collect_widths(GBufferCache *cache, size_t index, line_width
 *                first    = première ligne à dessiner.                        *
 *                last     = dernière ligne à dessiner.                        *
 *                area     = position et surface à traiter.                    *
-*                display  = règles d'affichage des colonnes modulables.       *
+*                options  = règles d'affichage des colonnes modulables.       *
 *                selected = ordonnée d'une ligne sélectionnée ou NULL.        *
 *                list     = liste de contenus à mettre en évidence.           *
 *                                                                             *
@@ -1427,7 +1427,7 @@ void g_buffer_cache_collect_widths(GBufferCache *cache, size_t index, line_width
 *                                                                             *
 ******************************************************************************/
 
-void g_buffer_cache_draw(const GBufferCache *cache, cairo_t *cr, size_t first, size_t last, const cairo_rectangle_int_t *area, const bool *display, const gint *selected, const segcnt_list *list)
+void g_buffer_cache_draw(const GBufferCache *cache, cairo_t *cr, size_t first, size_t last, const cairo_rectangle_int_t *area, const GDisplayOptions *options, const gint *selected, const segcnt_list *list)
 {
     GBufferCacheClass *class;               /* Classe des tampons          */
     gint y;                                 /* Point de départ en ordonnée */
@@ -1465,7 +1465,7 @@ void g_buffer_cache_draw(const GBufferCache *cache, cairo_t *cr, size_t first, s
 
             line = get_cache_info_line(info, i, cache->content);
 
-            g_buffer_line_draw(line, cr, &summary, class->text_pos, y, display, list);
+            g_buffer_line_draw(line, cr, &summary, class->text_pos, y, options, list);
 
             g_object_unref(G_OBJECT(line));
 
diff --git a/src/glibext/gbuffercache.h b/src/glibext/gbuffercache.h
index 453588e..7a0d250 100644
--- a/src/glibext/gbuffercache.h
+++ b/src/glibext/gbuffercache.h
@@ -30,6 +30,7 @@
 #include <gdk/gdk.h>
 
 
+#include "gdisplayoptions.h"
 #include "gwidthtracker.h"
 #include "linegen.h"
 
@@ -102,7 +103,7 @@ GBufferLine *g_buffer_cache_find_line_by_index(const GBufferCache *, size_t);
 void g_buffer_cache_collect_widths(GBufferCache *, size_t, line_width_summary *);
 
 /* Imprime une partie choisie du tampon contenant des lignes. */
-void g_buffer_cache_draw(const GBufferCache *, cairo_t *, size_t, size_t, const cairo_rectangle_int_t *, const bool *, const gint *, const segcnt_list *);
+void g_buffer_cache_draw(const GBufferCache *, cairo_t *, size_t, size_t, const cairo_rectangle_int_t *, const GDisplayOptions *, const gint *, const segcnt_list *);
 
 /* Indique l'indice correspondant à une adresse donnée. */
 size_t _g_buffer_cache_find_index_by_cursor(const GBufferCache *, const GLineCursor *, bool, size_t, size_t);
diff --git a/src/glibext/gbufferline.c b/src/glibext/gbufferline.c
index 95af21a..39ef0ce 100644
--- a/src/glibext/gbufferline.c
+++ b/src/glibext/gbufferline.c
@@ -1050,7 +1050,7 @@ const line_segment *g_buffer_line_get_segment_from_coord(const GBufferLine *line
 *                                                                             *
 *  Paramètres  : line    = ligne à venir consulter.                           *
 *                summary = résumé des largeurs maximales.                     *
-*                display = règles d'affichage des colonnes modulables.        *
+*                options = 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.      *
@@ -1065,12 +1065,13 @@ const line_segment *g_buffer_line_get_segment_from_coord(const GBufferLine *line
 *                                                                             *
 ******************************************************************************/
 
-bool g_buffer_line_get_coord_at(const GBufferLine *line, const line_width_summary *summary, const bool *display, gint *base, gint *offset, GdkScrollDirection dir, bool force, col_coord_t *coord)
+bool g_buffer_line_get_coord_at(const GBufferLine *line, const line_width_summary *summary, 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  */
-    BufferLineColumn i;                     /* Boucle de parcours          */
+    size_t 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       */
     gint consumed;                          /* Distance vers le segment    */
@@ -1085,9 +1086,15 @@ 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);
+
     for (i = 0; i < BLC_COUNT; i++)
     {
-        if (i < BLC_DISPLAY && !display[i]) continue;
+        if (i < count)
+        {
+            if (!g_display_options_get(options, i))
+                continue;
+        }
 
         /* Mémorisation de la dernière colonne contenant quelque chose... */
         if (get_column_width(&line->columns[i]) > 0)
@@ -1249,7 +1256,7 @@ 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.                     *
-*                display = règles d'affichage des colonnes modulables.        *
+*                options = 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.      *
@@ -1263,13 +1270,13 @@ bool g_buffer_line_get_coord_at(const GBufferLine *line, const line_width_summar
 *                                                                             *
 ******************************************************************************/
 
-const line_segment *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)
+const line_segment *g_buffer_line_get_segment_at(const GBufferLine *line, const line_width_summary *summary, const GDisplayOptions *options, gint *base, gint *offset, GdkScrollDirection dir, bool force)
 {
     const 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, display, base, offset, dir, force, &coord);
+    status = g_buffer_line_get_coord_at(line, summary, options, base, offset, dir, force, &coord);
 
     if (status)
         result = g_buffer_line_get_segment_from_coord(line, &coord);
@@ -1285,7 +1292,7 @@ const line_segment *g_buffer_line_get_segment_at(const GBufferLine *line, const
 *                                                                             *
 *  Paramètres  : line    = ligne à venir consulter.                           *
 *                summary = résumé des largeurs maximales.                     *
-*                display = règles d'affichage des colonnes modulables.        *
+*                options = 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.      *
@@ -1299,7 +1306,7 @@ const line_segment *g_buffer_line_get_segment_at(const GBufferLine *line, const
 *                                                                             *
 ******************************************************************************/
 
-GObject *g_buffer_line_get_creator_at(const GBufferLine *line, const line_width_summary *summary, const bool *display, gint *base, gint *offset, GdkScrollDirection dir, bool force)
+GObject *g_buffer_line_get_creator_at(const GBufferLine *line, const line_width_summary *summary, const GDisplayOptions *options, gint *base, gint *offset, GdkScrollDirection dir, bool force)
 {
     GObject *result;                        /* Trouvaille à retourner      */
     col_coord_t target;                     /* Emplacement du contenu visé */
@@ -1309,7 +1316,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, display, base, offset, dir, force, &target);
+    status = g_buffer_line_get_coord_at(line, summary, options, base, offset, dir, force, &target);
 
     if (status)
     {
@@ -1337,7 +1344,7 @@ GObject *g_buffer_line_get_creator_at(const GBufferLine *line, const line_width_
 *  Paramètres  : line    = ligne à venir consulter.                           *
 *                coord   = cordonnées à consulter puis renseigner. [OUT]      *
 *                summary = résumé des largeurs maximales.                     *
-*                display = règles d'affichage des colonnes modulables.        *
+*                options = règles d'affichage des colonnes modulables.        *
 *                dir     = orientation des recherches.                        *
 *                offset  = décalage pour amener à l'extrémité nouvelle. [OUT] *
 *                                                                             *
@@ -1349,12 +1356,13 @@ 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 bool *display, GdkScrollDirection dir, gint *offset)
+bool g_buffer_line_find_near_coord(const GBufferLine *line, col_coord_t *coord, const line_width_summary *summary, const GDisplayOptions *options, GdkScrollDirection dir, gint *offset)
 {
     bool result;                            /* Bilan à retourner           */
-    BufferLineColumn i;                     /* Boucle de parcours #1       */
+    size_t count;                           /* Qté de colonnes en option   */
+    size_t i;                               /* Boucle de parcours #1       */
     bool displayed;                         /* Confort de lecture          */
-    BufferLineColumn k;                     /* Boucle de parcours #2       */
+    size_t k;                               /* Boucle de parcours #2       */
     gint width;                             /* Largeur d'une colonne donnée*/
 
     result = false;
@@ -1369,6 +1377,8 @@ bool g_buffer_line_find_near_coord(const GBufferLine *line, col_coord_t *coord,
 
     /* Recherche dans la direction des colonnes voisines */
 
+    count = g_display_options_count(options);
+
     if (!result)
         switch (dir)
         {
@@ -1380,7 +1390,7 @@ bool g_buffer_line_find_near_coord(const GBufferLine *line, col_coord_t *coord,
                 /* On s'assure que la colonne précédente est visible et peuplée */
                 for (; i > BLC_FIRST && !result; i--)
                 {
-                    displayed = (i <= BLC_DISPLAY ? display[i - 1] : true);
+                    displayed = (i <= count ? g_display_options_get(options, i - 1) : true);
 
                     if (displayed)
                     {
@@ -1400,7 +1410,7 @@ bool g_buffer_line_find_near_coord(const GBufferLine *line, col_coord_t *coord,
                 /* On s'assure que la colonne suivante est visible et peuplée */
                 for (; (i + 1) < BLC_COUNT && !result; i++)
                 {
-                    displayed = ((i + 1) < BLC_DISPLAY ? display[i + 1] : true);
+                    displayed = ((i + 1) < count ? g_display_options_get(options, i + 1) : true);
 
                     if (displayed)
                     {
@@ -1428,7 +1438,7 @@ bool g_buffer_line_find_near_coord(const GBufferLine *line, col_coord_t *coord,
 
         for (k = 0; k < i; k++)
         {
-            displayed = (k < BLC_DISPLAY ? display[k] : true);
+            displayed = (k < count ? g_display_options_get(options, k) : true);
 
             if (displayed)
             {
@@ -1473,7 +1483,7 @@ bool g_buffer_line_find_near_coord(const GBufferLine *line, col_coord_t *coord,
 *                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.        *
+*                options = règles d'affichage des colonnes modulables.        *
 *                list    = liste de contenus à mettre en évidence.            *
 *                                                                             *
 *  Description : Imprime la ligne de texte représentée.                       *
@@ -1484,12 +1494,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 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 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*/
-    BufferLineColumn i;                     /* Boucle de parcours          */
+    size_t count;                           /* Qté de colonnes en option   */
+    size_t i;                               /* Boucle de parcours          */
     gint max_width;                         /* Largeur maximale de colonne */
 
     if (line->flags != BLF_NONE && line->flags != BLF_HAS_CODE)
@@ -1516,9 +1527,15 @@ void g_buffer_line_draw(GBufferLine *line, cairo_t *cairo, const line_width_summ
 
     x = x_init;
 
+    count = g_display_options_count(options);
+
     for (i = 0; i < BLC_COUNT; i++)
     {
-        if (i < BLC_DISPLAY && !display[i]) continue;
+        if (i < count)
+        {
+            if (!g_display_options_get(options, i))
+                continue;
+        }
 
         draw_line_column_segments(&line->columns[i], cairo, x, y, list);
 
diff --git a/src/glibext/gbufferline.h b/src/glibext/gbufferline.h
index 835c0dd..21b3ec9 100644
--- a/src/glibext/gbufferline.h
+++ b/src/glibext/gbufferline.h
@@ -29,6 +29,7 @@
 #include <stdbool.h>
 
 
+#include "gdisplayoptions.h"
 #include "linesegment.h"
 #include "../analysis/content.h"
 #include "../arch/vmpa.h"
@@ -198,19 +199,19 @@ gint g_buffer_line_compute_max_width(const GBufferLine *, BufferLineColumn, cons
 const line_segment *g_buffer_line_get_segment_from_coord(const GBufferLine *, const col_coord_t *);
 
 /* Fournit les coordonnées correspondant à une abscisse donnée. */
-bool g_buffer_line_get_coord_at(const GBufferLine *, const line_width_summary *, const bool *, gint *, gint *, GdkScrollDirection, bool, col_coord_t *);
+bool g_buffer_line_get_coord_at(const GBufferLine *, const line_width_summary *, const GDisplayOptions *, gint *, gint *, GdkScrollDirection, bool, col_coord_t *);
 
 /* Donne le segment présent à une abscisse donnée. */
-const line_segment *g_buffer_line_get_segment_at(const GBufferLine *, const line_width_summary *, const bool *, gint *, gint *, GdkScrollDirection, bool);
+const line_segment *g_buffer_line_get_segment_at(const GBufferLine *, const line_width_summary *, const GDisplayOptions *, gint *, gint *, GdkScrollDirection, bool);
 
 /* Donne le créateur présent à une abscisse donnée. */
-GObject *g_buffer_line_get_creator_at(const GBufferLine *, const line_width_summary *, const bool *, gint *, gint *, GdkScrollDirection, bool);
+GObject *g_buffer_line_get_creator_at(const GBufferLine *, const line_width_summary *, const GDisplayOptions *, gint *, gint *, GdkScrollDirection, bool);
 
 /* Fournit des coordonnées voisines selon une direction donnée. */
-bool g_buffer_line_find_near_coord(const GBufferLine *, col_coord_t *, const line_width_summary *, const bool *, GdkScrollDirection, gint *);
+bool g_buffer_line_find_near_coord(const GBufferLine *, col_coord_t *, const line_width_summary *, const GDisplayOptions *, GdkScrollDirection, gint *);
 
 /* Imprime la ligne de texte représentée. */
-void g_buffer_line_draw(GBufferLine *, cairo_t *, const line_width_summary *, gint, gint, const bool *, const segcnt_list *);
+void g_buffer_line_draw(GBufferLine *, cairo_t *, const line_width_summary *, gint, gint, const GDisplayOptions *, const segcnt_list *);
 
 
 
diff --git a/src/glibext/gbufferview.c b/src/glibext/gbufferview.c
index c5bd81e..f3b0147 100644
--- a/src/glibext/gbufferview.c
+++ b/src/glibext/gbufferview.c
@@ -77,10 +77,10 @@ static void g_buffer_view_finalize(GBufferView *);
 static void on_buffer_cache_size_changed(const GBufferCache *, bool, size_t, size_t, GBufferView *);
 
 /* Calcule la position idéale de curseur pour un point donné. */
-bool _g_buffer_view_compute_caret_full(GBufferView *, gint, GBufferLine *, size_t, const bool *, cairo_rectangle_int_t *, GLineCursor **);
+bool _g_buffer_view_compute_caret_full(GBufferView *, gint, GBufferLine *, size_t, const GDisplayOptions *, cairo_rectangle_int_t *, GLineCursor **);
 
 /* Déplace le curseur au sein d'une vue de tampon. */
-static bool _g_buffer_view_move_caret(GBufferView *, const GBufferLine *, size_t, cairo_rectangle_int_t *, bool, GdkScrollDirection, const bool *);
+static bool _g_buffer_view_move_caret(GBufferView *, const GBufferLine *, size_t, cairo_rectangle_int_t *, bool, GdkScrollDirection, const GDisplayOptions *);
 
 
 /* Fournit la ligne présente à une ordonnée donnée. */
@@ -488,7 +488,7 @@ bool g_buffer_view_get_restrictions(const GBufferView *view, GLineCursor **start
 /******************************************************************************
 *                                                                             *
 *  Paramètres  : view    = visualisation à consulter.                         *
-*                display = règles d'affichage des colonnes modulables.        *
+*                options = règles d'affichage des colonnes modulables.        *
 *                                                                             *
 *  Description : Fournit la largeur requise par une visualisation.            *
 *                                                                             *
@@ -498,13 +498,13 @@ bool g_buffer_view_get_restrictions(const GBufferView *view, GLineCursor **start
 *                                                                             *
 ******************************************************************************/
 
-gint g_buffer_view_get_width(GBufferView *view, const bool *display)
+gint g_buffer_view_get_width(GBufferView *view, const GDisplayOptions *options)
 {
     gint result;                            /* Taille à retourner          */
 
     result = g_buffer_cache_get_text_position(view->cache);
 
-    result += g_width_tracker_get_width(view->tracker, display);
+    result += g_width_tracker_get_width(view->tracker, options);
 
     return result;
 
@@ -514,7 +514,7 @@ gint g_buffer_view_get_width(GBufferView *view, const bool *display)
 /******************************************************************************
 *                                                                             *
 *  Paramètres  : view    = visualisation à consulter.                         *
-*                display = règles d'affichage des colonnes modulables.        *
+*                options = règles d'affichage des colonnes modulables.        *
 *                                                                             *
 *  Description : Fournit la largeur requise pour dépasser les marges gauches. *
 *                                                                             *
@@ -524,13 +524,13 @@ gint g_buffer_view_get_width(GBufferView *view, const bool *display)
 *                                                                             *
 ******************************************************************************/
 
-gint g_buffer_view_get_margin(GBufferView *view, const bool *display)
+gint g_buffer_view_get_margin(GBufferView *view, const GDisplayOptions *options)
 {
     gint result;                            /* Taille à retourner          */
 
     result = g_buffer_cache_get_text_position(view->cache);
 
-    result += g_width_tracker_get_margin(view->tracker, display);
+    result += g_width_tracker_get_margin(view->tracker, options);
 
     return result;
 
@@ -578,7 +578,7 @@ gint g_buffer_view_get_height(const GBufferView *view)
 *  Paramètres  : view    = vue de tampon à mettre à jour.                     *
 *                x       = abscisse proposée pour le nouvel emplacement.      *
 *                y       = ordonnée proposée pour le nouvel emplacement.      *
-*                display = règles d'affichage des colonnes modulables.        *
+*                options = règles d'affichage des colonnes modulables.        *
 *                caret   = position du curseur à construire. [OUT]            *
 *                cursor  = emplacement correspondant à cette position. [OUT]  *
 *                                                                             *
@@ -590,7 +590,7 @@ gint g_buffer_view_get_height(const GBufferView *view)
 *                                                                             *
 ******************************************************************************/
 
-bool g_buffer_view_compute_caret_full(GBufferView *view, gint x, gint y, const bool *display, cairo_rectangle_int_t *caret, GLineCursor **cursor)
+bool g_buffer_view_compute_caret_full(GBufferView *view, gint x, gint y, const GDisplayOptions *options, cairo_rectangle_int_t *caret, GLineCursor **cursor)
 {
     bool result;                            /* Bilan à retourner           */
     gint lheight;                           /* Hauteur d'une ligne         */
@@ -615,7 +615,7 @@ bool g_buffer_view_compute_caret_full(GBufferView *view, gint x, gint y, const b
 
     /* Calcul d'une position */
 
-    result = _g_buffer_view_compute_caret_full(view, x, line, index, display, caret, cursor);
+    result = _g_buffer_view_compute_caret_full(view, x, line, index, options, caret, cursor);
 
     g_object_unref(G_OBJECT(line));
 
@@ -632,7 +632,7 @@ bool g_buffer_view_compute_caret_full(GBufferView *view, gint x, gint y, const b
 *                x       = abscisse proposée pour le nouvel emplacement.      *
 *                line    = ligne correspondant à la position.                 *
 *                index   = indice de cette même ligne dans le tampon.         *
-*                display = règles d'affichage des colonnes modulables.        *
+*                options = règles d'affichage des colonnes modulables.        *
 *                caret   = position du curseur à construire. [OUT]            *
 *                cursor  = emplacement correspondant à cette position. [OUT]  *
 *                                                                             *
@@ -644,7 +644,7 @@ bool g_buffer_view_compute_caret_full(GBufferView *view, gint x, gint y, const b
 *                                                                             *
 ******************************************************************************/
 
-bool _g_buffer_view_compute_caret_full(GBufferView *view, gint x, GBufferLine *line, size_t index, const bool *display, cairo_rectangle_int_t *caret, GLineCursor **cursor)
+bool _g_buffer_view_compute_caret_full(GBufferView *view, gint x, GBufferLine *line, size_t index, const GDisplayOptions *options, cairo_rectangle_int_t *caret, GLineCursor **cursor)
 {
     bool result;                            /* Bilan à retourner           */
     gint text_pos;                          /* Abscisse de départ du texte */
@@ -668,7 +668,7 @@ bool _g_buffer_view_compute_caret_full(GBufferView *view, gint x, GBufferLine *l
 
     x -= text_pos;
 
-    status = g_buffer_line_get_coord_at(line, &summary, display, &base, &x,
+    status = g_buffer_line_get_coord_at(line, &summary, options, &base, &x,
                                         GDK_SCROLL_LEFT, true, (col_coord_t []) { { 0 } });
 
     if (!status)
@@ -704,7 +704,7 @@ bool _g_buffer_view_compute_caret_full(GBufferView *view, gint x, GBufferLine *l
 *                caret   = position du curseur à faire évoluer.               *
 *                ctrl    = indique la demande d'un parcours rapide.           *
 *                dir     = direction du parcours.                             *
-*                display = règles d'affichage des colonnes modulables.        *
+*                options = règles d'affichage des colonnes modulables.        *
 *                                                                             *
 *  Description : Déplace le curseur au sein d'une vue de tampon.              *
 *                                                                             *
@@ -714,7 +714,7 @@ bool _g_buffer_view_compute_caret_full(GBufferView *view, gint x, GBufferLine *l
 *                                                                             *
 ******************************************************************************/
 
-static bool _g_buffer_view_move_caret(GBufferView *view, const GBufferLine *line, size_t index, cairo_rectangle_int_t *caret, bool ctrl, GdkScrollDirection dir, const bool *display)
+static bool _g_buffer_view_move_caret(GBufferView *view, const GBufferLine *line, size_t index, cairo_rectangle_int_t *caret, bool ctrl, GdkScrollDirection dir, const GDisplayOptions *options)
 {
     bool result;                            /* Bilan à retourner           */
     gint text_pos;                          /* Abscisse de départ du texte */
@@ -740,7 +740,7 @@ static bool _g_buffer_view_move_caret(GBufferView *view, const GBufferLine *line
 
     /* Déplacement au sein du segment courant ? */
 
-    result = g_buffer_line_get_coord_at(line, &summary, display, &base, &offset, dir, false, &coord);
+    result = g_buffer_line_get_coord_at(line, &summary, options, &base, &offset, dir, false, &coord);
 
     if (result)
     {
@@ -756,7 +756,7 @@ static bool _g_buffer_view_move_caret(GBufferView *view, const GBufferLine *line
     {
         base = 0;
 
-        result = g_buffer_line_find_near_coord(line, &coord, &summary, display, dir, &offset);
+        result = g_buffer_line_find_near_coord(line, &coord, &summary, options, dir, &offset);
 
     }
 
@@ -777,7 +777,7 @@ static bool _g_buffer_view_move_caret(GBufferView *view, const GBufferLine *line
 *  Paramètres  : view    = vue de tampon à mettre à jour.                     *
 *                ctrl    = indique la demande d'un parcours rapide.           *
 *                dir     = direction du parcours.                             *
-*                display = règles d'affichage des colonnes modulables.        *
+*                options = règles d'affichage des colonnes modulables.        *
 *                caret   = position du curseur à faire évoluer. [OUT]         *
 *                cursor  = emplacement correspondant à cette position. [OUT]  *
 *                                                                             *
@@ -789,7 +789,7 @@ static bool _g_buffer_view_move_caret(GBufferView *view, const GBufferLine *line
 *                                                                             *
 ******************************************************************************/
 
-bool g_buffer_view_move_caret(GBufferView *view, bool ctrl, GdkScrollDirection dir, const bool *display, cairo_rectangle_int_t *caret, GLineCursor **cursor)
+bool g_buffer_view_move_caret(GBufferView *view, bool ctrl, GdkScrollDirection dir, const GDisplayOptions *options, cairo_rectangle_int_t *caret, GLineCursor **cursor)
 {
     bool result;                            /* Bilan à retourner           */
     size_t index;                           /* Indice de ligne de tampon   */
@@ -817,7 +817,7 @@ bool g_buffer_view_move_caret(GBufferView *view, bool ctrl, GdkScrollDirection d
                 index--;
 
                 other = g_buffer_cache_find_line_by_index(view->cache, index);
-                result = _g_buffer_view_compute_caret_full(view, caret->x, other, index, display, caret, cursor);
+                result = _g_buffer_view_compute_caret_full(view, caret->x, other, index, options, caret, cursor);
                 g_object_unref(G_OBJECT(other));
 
             }
@@ -831,7 +831,7 @@ bool g_buffer_view_move_caret(GBufferView *view, bool ctrl, GdkScrollDirection d
                 index++;
 
                 other = g_buffer_cache_find_line_by_index(view->cache, index);
-                result = _g_buffer_view_compute_caret_full(view, caret->x, other, index, display, caret, cursor);
+                result = _g_buffer_view_compute_caret_full(view, caret->x, other, index, options, caret, cursor);
                 g_object_unref(G_OBJECT(other));
 
             }
@@ -840,7 +840,7 @@ bool g_buffer_view_move_caret(GBufferView *view, bool ctrl, GdkScrollDirection d
 
         case GDK_SCROLL_LEFT:
 
-            moved = _g_buffer_view_move_caret(view, line, index, caret, ctrl, GDK_SCROLL_LEFT, display);
+            moved = _g_buffer_view_move_caret(view, line, index, caret, ctrl, GDK_SCROLL_LEFT, options);
 
             if (moved)
             {
@@ -853,7 +853,7 @@ bool g_buffer_view_move_caret(GBufferView *view, bool ctrl, GdkScrollDirection d
                 index--;
 
                 other = g_buffer_cache_find_line_by_index(view->cache, index);
-                result = _g_buffer_view_compute_caret_full(view, INT_MAX, other, index, display, caret, cursor);
+                result = _g_buffer_view_compute_caret_full(view, INT_MAX, other, index, options, caret, cursor);
                 g_object_unref(G_OBJECT(other));
 
             }
@@ -862,7 +862,7 @@ bool g_buffer_view_move_caret(GBufferView *view, bool ctrl, GdkScrollDirection d
 
         case GDK_SCROLL_RIGHT:
 
-            moved = _g_buffer_view_move_caret(view, line, index, caret, ctrl, GDK_SCROLL_RIGHT, display);
+            moved = _g_buffer_view_move_caret(view, line, index, caret, ctrl, GDK_SCROLL_RIGHT, options);
 
             if (moved)
             {
@@ -877,7 +877,7 @@ bool g_buffer_view_move_caret(GBufferView *view, bool ctrl, GdkScrollDirection d
                 text_pos = g_buffer_cache_get_text_position(view->cache);
 
                 other = g_buffer_cache_find_line_by_index(view->cache, index);
-                result = _g_buffer_view_compute_caret_full(view, text_pos, other, index, display, caret, cursor);
+                result = _g_buffer_view_compute_caret_full(view, text_pos, other, index, options, caret, cursor);
                 g_object_unref(G_OBJECT(other));
 
             }
@@ -909,7 +909,7 @@ bool g_buffer_view_move_caret(GBufferView *view, bool ctrl, GdkScrollDirection d
 *  Paramètres  : view    = vue de tampon à mettre à jour.                     *
 *                x       = abscisse de la zone principale à traiter.          *
 *                y       = ordonnée de la zone principale à traiter.          *
-*                display = règles d'affichage des colonnes modulables.        *
+*                options = règles d'affichage des colonnes modulables.        *
 *                                                                             *
 *  Description : Trouve le créateur à l'origine d'un emplacement donné.       *
 *                                                                             *
@@ -919,7 +919,7 @@ bool g_buffer_view_move_caret(GBufferView *view, bool ctrl, GdkScrollDirection d
 *                                                                             *
 ******************************************************************************/
 
-GObject *g_buffer_view_find_creator(GBufferView *view, gint x, gint y, const bool *display)
+GObject *g_buffer_view_find_creator(GBufferView *view, gint x, gint y, const GDisplayOptions *options)
 {
     GObject *result;                        /* Trouvaille à faire remonter */
     gint text_pos;                          /* Abscisse de départ du texte */
@@ -957,7 +957,7 @@ GObject *g_buffer_view_find_creator(GBufferView *view, gint x, gint y, const boo
 
     x -= text_pos;
 
-    result = g_buffer_line_get_creator_at(line, &summary, display, (gint []) { 0 }, &x, GDK_SCROLL_LEFT, false);
+    result = g_buffer_line_get_creator_at(line, &summary, options, (gint []) { 0 }, &x, GDK_SCROLL_LEFT, false);
 
     g_object_unref(G_OBJECT(line));
 
@@ -1002,7 +1002,7 @@ bool g_buffer_view_unhighlight_segments(GBufferView *view)
 *  Paramètres  : view    = vue de tampon à mettre à jour.                     *
 *                x       = abscisse de la zone principale à traiter.          *
 *                y       = ordonnée de la zone principale à traiter.          *
-*                display = règles d'affichage des colonnes modulables.        *
+*                options = règles d'affichage des colonnes modulables.        *
 *                                                                             *
 *  Description : Surligne tous les segments similaires à celui sous la souris.*
 *                                                                             *
@@ -1012,7 +1012,7 @@ bool g_buffer_view_unhighlight_segments(GBufferView *view)
 *                                                                             *
 ******************************************************************************/
 
-bool g_buffer_view_highlight_segments(GBufferView *view, gint x, gint y, const bool *display)
+bool g_buffer_view_highlight_segments(GBufferView *view, gint x, gint y, const GDisplayOptions *options)
 {
     bool result;                            /* Besoin à faire remonter     */
     gint text_pos;                          /* Abscisse de départ du texte */
@@ -1056,7 +1056,7 @@ bool g_buffer_view_highlight_segments(GBufferView *view, gint x, gint y, const b
 
     x -= text_pos;
 
-    segment = g_buffer_line_get_segment_at(line, &summary, display,
+    segment = g_buffer_line_get_segment_at(line, &summary, options,
                                            (gint []) { 0 }, &x, GDK_SCROLL_LEFT, true);
 
     g_object_unref(G_OBJECT(line));
@@ -1082,7 +1082,7 @@ bool g_buffer_view_highlight_segments(GBufferView *view, gint x, gint y, const b
 *                cr       = contexte graphique dédié à la procédure.          *
 *                virt_y   = ordonnée réelle du point 0 à l'écran.             *
 *                area     = position et surface à traiter.                    *
-*                display  = règles d'affichage des colonnes modulables.       *
+*                options  = règles d'affichage des colonnes modulables.       *
 *                selected = ordonnée d'une ligne sélectionnée ou NULL.        *
 *                                                                             *
 *  Description : Imprime la visualisation du tampon de lignes quelconques.    *
@@ -1093,7 +1093,7 @@ bool g_buffer_view_highlight_segments(GBufferView *view, gint x, gint y, const b
 *                                                                             *
 ******************************************************************************/
 
-void g_buffer_view_draw(const GBufferView *view, cairo_t *cr, gint virt_y, const cairo_rectangle_int_t *area, const bool *display, gint *selected)
+void g_buffer_view_draw(const GBufferView *view, cairo_t *cr, gint virt_y, const cairo_rectangle_int_t *area, const GDisplayOptions *options, gint *selected)
 {
     gint line_height;                       /* Hauteur d'une ligne         */
     gint cr_y;                              /* Ordonnée pour le dessin     */
@@ -1128,7 +1128,7 @@ void g_buffer_view_draw(const GBufferView *view, cairo_t *cr, gint virt_y, const
     if (selected != NULL)
         *selected -= cr_y;
 
-    g_buffer_cache_draw(view->cache, cr, first, last, area, display, selected, view->highlighted);
+    g_buffer_cache_draw(view->cache, cr, first, last, area, options, selected, view->highlighted);
 
 }
 
diff --git a/src/glibext/gbufferview.h b/src/glibext/gbufferview.h
index 6b5ef45..04e4bbb 100644
--- a/src/glibext/gbufferview.h
+++ b/src/glibext/gbufferview.h
@@ -29,6 +29,7 @@
 
 
 #include "gbuffercache.h"
+#include "gdisplayoptions.h"
 
 
 
@@ -65,10 +66,10 @@ bool g_buffer_view_get_restrictions(const GBufferView *, GLineCursor **, GLineCu
 
 
 /* Fournit la largeur requise par une visualisation. */
-gint g_buffer_view_get_width(GBufferView *, const bool *);
+gint g_buffer_view_get_width(GBufferView *, const GDisplayOptions *);
 
 /* Fournit la largeur requise pour dépasser les marges gauches. */
-gint g_buffer_view_get_margin(GBufferView *, const bool *);
+gint g_buffer_view_get_margin(GBufferView *, const GDisplayOptions *);
 
 /* Fournit la hauteur requise par une visualisation. */
 gint g_buffer_view_get_height(const GBufferView *);
@@ -78,15 +79,15 @@ gint g_buffer_view_get_height(const GBufferView *);
 
 
 /* Calcule la position idéale de curseur pour un point donné. */
-bool g_buffer_view_compute_caret_full(GBufferView *, gint, gint, const bool *, cairo_rectangle_int_t *, GLineCursor **);
+bool g_buffer_view_compute_caret_full(GBufferView *, gint, gint, const GDisplayOptions *, cairo_rectangle_int_t *, GLineCursor **);
 
 /* Déplace le curseur au sein d'une vue de tampon. */
-bool g_buffer_view_move_caret(GBufferView *, bool, GdkScrollDirection, const bool *, cairo_rectangle_int_t *, GLineCursor **);
+bool g_buffer_view_move_caret(GBufferView *, bool, GdkScrollDirection, const GDisplayOptions *, cairo_rectangle_int_t *, GLineCursor **);
 
 
 
 /* Trouve le créateur à l'origine d'un emplacement donné. */
-GObject *g_buffer_view_find_creator(GBufferView *, gint, gint, const bool *);
+GObject *g_buffer_view_find_creator(GBufferView *, gint, gint, const GDisplayOptions *);
 
 
 
@@ -94,10 +95,10 @@ GObject *g_buffer_view_find_creator(GBufferView *, gint, gint, const bool *);
 bool g_buffer_view_unhighlight_segments(GBufferView *);
 
 /* Surligne tous les segments similaires à celui sous la souris. */
-bool g_buffer_view_highlight_segments(GBufferView *, gint, gint, const bool *);
+bool g_buffer_view_highlight_segments(GBufferView *, gint, gint, const GDisplayOptions *);
 
 /* Imprime la visualisation du tampon de lignes quelconques. */
-void g_buffer_view_draw(const GBufferView *, cairo_t *, gint, const cairo_rectangle_int_t *, const bool *, gint *);
+void g_buffer_view_draw(const GBufferView *, cairo_t *, gint, const cairo_rectangle_int_t *, const GDisplayOptions *, gint *);
 
 
 
diff --git a/src/glibext/gdisplayoptions.c b/src/glibext/gdisplayoptions.c
new file mode 100644
index 0000000..8641f59
--- /dev/null
+++ b/src/glibext/gdisplayoptions.c
@@ -0,0 +1,323 @@
+
+/* Chrysalide - Outil d'analyse de fichiers binaires
+ * gdisplayoptions.h - options de rendus des lignes de code
+ *
+ * Copyright (C) 2018 Cyrille Bagard
+ *
+ *  This file is part of Chrysalide.
+ *
+ *  Chrysalide is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  Chrysalide is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Chrysalide.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#include "gdisplayoptions.h"
+
+
+#include <assert.h>
+#include <malloc.h>
+#include <string.h>
+
+
+#include "chrysamarshal.h"
+
+
+
+/* Options de représentation (instance) */
+struct _GDisplayOptions
+{
+    GObject parent;                         /* A laisser en premier        */
+
+    char **names;                           /* Désignations des options    */
+    bool *values;                           /* Valeurs des options         */
+    size_t count;                           /* Nombre de ces options       */
+
+};
+
+/* Options de représentation (classe) */
+struct _GDisplayOptionsClass
+{
+    GObjectClass parent;                    /* A laisser en premier        */
+
+    /* Signaux */
+
+    void (* value_changed) (const GDisplayOptions *, gsize, gboolean);
+
+};
+
+
+/* Initialise la classe des options pour le rendu des lignes. */
+static void g_display_options_class_init(GDisplayOptionsClass *);
+
+/* Initialise une instance d'options pour le rendu des lignes. */
+static void g_display_options_init(GDisplayOptions *);
+
+/* Supprime toutes les références externes. */
+static void g_display_options_dispose(GDisplayOptions *);
+
+/* Procède à la libération totale de la mémoire. */
+static void g_display_options_finalize(GDisplayOptions *);
+
+
+
+/* Indique le type définit pour une ligne de représentation. */
+G_DEFINE_TYPE(GDisplayOptions, g_display_options, G_TYPE_OBJECT);
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : klass = classe à initialiser.                                *
+*                                                                             *
+*  Description : Initialise la classe des options pour le rendu des lignes.   *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_display_options_class_init(GDisplayOptionsClass *klass)
+{
+    GObjectClass *object;                   /* Autre version de la classe  */
+
+    object = G_OBJECT_CLASS(klass);
+
+    object->dispose = (GObjectFinalizeFunc/* ! */)g_display_options_dispose;
+    object->finalize = (GObjectFinalizeFunc)g_display_options_finalize;
+
+    /**
+     * Note : il n'existe pas de G_TYPE_GSIZE.
+     *
+     * Or la documentation précise :
+     *
+     *    typedef unsigned long gsize;
+     *
+     */
+
+    g_signal_new("value-changed",
+                 G_TYPE_DISPLAY_OPTIONS,
+                 G_SIGNAL_RUN_LAST,
+                 G_STRUCT_OFFSET(GDisplayOptionsClass, value_changed),
+                 NULL, NULL,
+                 g_cclosure_user_marshal_VOID__ULONG_BOOLEAN,
+                 G_TYPE_NONE, 2, G_TYPE_ULONG, G_TYPE_BOOLEAN);
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : options = instance à initialiser.                            *
+*                                                                             *
+*  Description : Initialise une instance d'options pour le rendu des lignes.  *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_display_options_init(GDisplayOptions *options)
+{
+    options->names = NULL;
+    options->values = NULL;
+    options->count = 0;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : options = instance d'objet GLib à traiter.                   *
+*                                                                             *
+*  Description : Supprime toutes les références externes.                     *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_display_options_dispose(GDisplayOptions *options)
+{
+    G_OBJECT_CLASS(g_display_options_parent_class)->dispose(G_OBJECT(options));
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : options = instance d'objet GLib à traiter.                   *
+*                                                                             *
+*  Description : Procède à la libération totale de la mémoire.                *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_display_options_finalize(GDisplayOptions *options)
+{
+    size_t i;                               /* Boucle de parcours          */
+
+    for (i = 0; i < options->count; i++)
+        free(options->names[i]);
+
+    if (options->names != NULL)
+        free(options->names);
+
+    if (options->values != NULL)
+        free(options->values);
+
+    G_OBJECT_CLASS(g_display_options_parent_class)->finalize(G_OBJECT(options));
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : -                                                            *
+*                                                                             *
+*  Description : Crée un un groupe d'options pour le rendu des lignes.        *
+*                                                                             *
+*  Retour      : Adresse de la structure mise en place.                       *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GDisplayOptions *g_display_options_new(void)
+{
+    GDisplayOptions *result;              /* Structure à retourner       */
+
+    result = g_object_new(G_TYPE_DISPLAY_OPTIONS, NULL);
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : options = options à consulter.                               *
+*                                                                             *
+*  Description : Dénombre la quantité d'options représentées.                 *
+*                                                                             *
+*  Retour      : Quantité positive ou nulle.                                  *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+size_t g_display_options_count(const GDisplayOptions *options)
+{
+    size_t result;                          /* Quantité à retourner        */
+
+    result = options->count;
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : options = options à compléter.                               *
+*                name    = désignation humaine de la nouvelle option.         *
+*                value   = valeur initiale de l'option à ajouter.             *
+*                                                                             *
+*  Description : Ajoute une nouvelle option à l'ensemble.                     *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+void g_display_options_add(GDisplayOptions *options, const char *name, bool value)
+{
+    options->count++;
+
+    options->names = (char **)realloc(options->names, options->count * sizeof(char *));
+    options->values = (bool *)realloc(options->values, options->count * sizeof(bool));
+
+    options->names[options->count - 1] = strdup(name);
+    options->values[options->count - 1] = value;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : options = options à consulter.                               *
+*                index   = indice de l'option concernée.                      *
+*                                                                             *
+*  Description : Fournit la valeur d'une option donnée.                       *
+*                                                                             *
+*  Retour      : Valeur attribuée.                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+bool g_display_options_get(const GDisplayOptions *options, size_t index)
+{
+    bool result;                            /* Valeur à renvoyer           */
+
+    assert(index < options->count);
+
+    if (index < options->count)
+        result = options->values[index];
+
+    else
+        result = false;
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : options = options à mettre à jour.                           *
+*                index   = indice de l'option concernée.                      *
+*                value   = nouvelle valeur à intégrer.                        *
+*                                                                             *
+*  Description : Définit la valeur d'une option donnée.                       *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+void g_display_options_set(GDisplayOptions *options, size_t index, bool value)
+{
+    bool changed;                           /* Note un changement          */
+
+    assert(index < options->count);
+
+    if (index < options->count)
+    {
+        changed = (options->values[index] != value);
+        options->values[index] = value;
+    }
+
+    else
+        changed = false;
+
+    if (changed)
+        g_signal_emit_by_name(options, "value-changed", index, value);
+
+}
diff --git a/src/glibext/gdisplayoptions.h b/src/glibext/gdisplayoptions.h
new file mode 100644
index 0000000..5697385
--- /dev/null
+++ b/src/glibext/gdisplayoptions.h
@@ -0,0 +1,68 @@
+
+/* Chrysalide - Outil d'analyse de fichiers binaires
+ * gdisplayoptions.h - prototypes pour les options de rendus des lignes de code
+ *
+ * Copyright (C) 2018 Cyrille Bagard
+ *
+ *  This file is part of Chrysalide.
+ *
+ *  Chrysalide is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  Chrysalide is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Chrysalide.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#ifndef _GLIBEXT_GDISPLAYOPTIONS_H
+#define _GLIBEXT_GDISPLAYOPTIONS_H
+
+
+#include <glib-object.h>
+#include <stdbool.h>
+
+
+
+#define G_TYPE_DISPLAY_OPTIONS            g_display_options_get_type()
+#define G_DISPLAY_OPTIONS(obj)            (G_TYPE_CHECK_INSTANCE_CAST((obj), G_TYPE_DISPLAY_OPTIONS, GDisplayOptions))
+#define G_IS_DISPLAY_OPTIONS(obj)         (G_TYPE_CHECK_INSTANCE_TYPE((obj), G_TYPE_DISPLAY_OPTIONS))
+#define G_DISPLAY_OPTIONS_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_DISPLAY_OPTIONS, GDisplayOptionsClass))
+#define G_IS_DISPLAY_OPTIONS_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_DISPLAY_OPTIONS))
+#define G_DISPLAY_OPTIONS_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_DISPLAY_OPTIONS, GDisplayOptionsClass))
+
+
+/* Options de représentation (instance) */
+typedef struct _GDisplayOptions GDisplayOptions;
+
+/* Options de représentation (classe) */
+typedef struct _GDisplayOptionsClass GDisplayOptionsClass;
+
+
+/* Indique le type défini pour des options de représentation. */
+GType g_display_options_get_type(void);
+
+/* Crée un un groupe d'options pour le rendu des lignes. */
+GDisplayOptions *g_display_options_new(void);
+
+/* Dénombre la quantité d'options représentées. */
+size_t g_display_options_count(const GDisplayOptions *);
+
+/* Ajoute une nouvelle option à l'ensemble. */
+void g_display_options_add(GDisplayOptions *, const char *, bool);
+
+/* Fournit la valeur d'une option donnée. */
+bool g_display_options_get(const GDisplayOptions *, size_t);
+
+/* Définit la valeur d'une option donnée. */
+void g_display_options_set(GDisplayOptions *, size_t, bool);
+
+
+
+#endif  /* _GLIBEXT_GDISPLAYOPTIONS_H */
diff --git a/src/glibext/glinecursor.h b/src/glibext/glinecursor.h
index 1cf8d47..4fa93c1 100644
--- a/src/glibext/glinecursor.h
+++ b/src/glibext/glinecursor.h
@@ -21,8 +21,8 @@
  */
 
 
-#ifndef _GLIBEXT_LINECURSOR_H
-#define _GLIBEXT_LINECURSOR_H
+#ifndef _GLIBEXT_GLINECURSOR_H
+#define _GLIBEXT_GLINECURSOR_H
 
 
 #include <glib-object.h>
@@ -106,4 +106,4 @@ bool g_line_cursor_prepare_db_statement(const GLineCursor *, const char *, bound
 
 
 
-#endif  /* _GLIBEXT_LINECURSOR_H */
+#endif  /* _GLIBEXT_GLINECURSOR_H */
diff --git a/src/glibext/gwidthtracker.c b/src/glibext/gwidthtracker.c
index 0741133..44a7ff0 100644
--- a/src/glibext/gwidthtracker.c
+++ b/src/glibext/gwidthtracker.c
@@ -1149,7 +1149,7 @@ void g_width_tracker_get_local_width_summary(GWidthTracker *tracker, size_t inde
 /******************************************************************************
 *                                                                             *
 *  Paramètres  : tracker = suivi de largeurs à consulter.                     *
-*                display = règles d'affichage des colonnes modulables.        *
+*                options = règles d'affichage des colonnes modulables.        *
 *                                                                             *
 *  Description : Fournit la largeur requise par une visualisation.            *
 *                                                                             *
@@ -1159,13 +1159,14 @@ void g_width_tracker_get_local_width_summary(GWidthTracker *tracker, size_t inde
 *                                                                             *
 ******************************************************************************/
 
-gint g_width_tracker_get_width(GWidthTracker *tracker, const bool *display)
+gint g_width_tracker_get_width(GWidthTracker *tracker, const GDisplayOptions *options)
 {
     gint result;                            /* Taille à retourner          */
     const line_width_summary *summary;      /* Accès rapide aux mesures    */
     gint col_width;                         /* Calcul selon les colonnes   */
     gint full_width;                        /* Calcul selon les fusions    */
-    BufferLineColumn i;                     /* Boucle de parcours          */
+    size_t count;                           /* Qté de colonnes en option   */
+    size_t i;                               /* Boucle de parcours          */
 
     g_width_tracker_ensure_valid_required_widths(tracker);
 
@@ -1176,11 +1177,17 @@ gint g_width_tracker_get_width(GWidthTracker *tracker, const bool *display)
     col_width = 0;
     full_width = 0;
 
+    count = g_display_options_count(options);
+
     /* Première méthode */
 
     for (i = 0; i < BLC_COUNT; i++)
     {
-        if (i < BLC_DISPLAY && !display[i]) continue;
+        if (i < count)
+        {
+            if (!g_display_options_get(options, i))
+                continue;
+        }
 
         col_width += summary->max_widths[i];
 
@@ -1191,9 +1198,10 @@ gint g_width_tracker_get_width(GWidthTracker *tracker, const bool *display)
 
     /* Seconde méthode */
 
-    for (i = 0; i < BLC_DISPLAY; i++)
+    for (i = 0; i < count; i++)
     {
-        if (!display[i]) continue;
+        if (!g_display_options_get(options, i))
+            continue;
 
         full_width += summary->max_widths[i] + COL_MARGIN;
 
@@ -1223,11 +1231,12 @@ gint g_width_tracker_get_width(GWidthTracker *tracker, const bool *display)
 *                                                                             *
 ******************************************************************************/
 
-gint g_width_tracker_get_margin(GWidthTracker *tracker, const bool *display)
+gint g_width_tracker_get_margin(GWidthTracker *tracker, const GDisplayOptions *options)
 {
     gint result;                            /* Taille à retourner          */
     const line_width_summary *summary;      /* Accès rapide aux mesures    */
-    BufferLineColumn i;                     /* Boucle de parcours          */
+    size_t count;                           /* Qté de colonnes en option   */
+    size_t i;                               /* Boucle de parcours          */
 
     g_width_tracker_ensure_valid_required_widths(tracker);
 
@@ -1235,9 +1244,12 @@ gint g_width_tracker_get_margin(GWidthTracker *tracker, const bool *display)
 
     summary = &tracker->summary;
 
-    for (i = 0; i < BLC_DISPLAY; i++)
+    count = g_display_options_count(options);
+
+    for (i = 0; i < count; i++)
     {
-        if (!display[i]) continue;
+        if (!g_display_options_get(options, i))
+            continue;
 
         result += summary->max_widths[i] + COL_MARGIN;
 
diff --git a/src/glibext/gwidthtracker.h b/src/glibext/gwidthtracker.h
index 2d9aef6..65e3df2 100644
--- a/src/glibext/gwidthtracker.h
+++ b/src/glibext/gwidthtracker.h
@@ -31,6 +31,7 @@
 
 #include "delayed.h"
 #include "gbufferline.h"
+#include "gdisplayoptions.h"
 
 
 
@@ -84,10 +85,10 @@ const line_width_summary *g_width_tracker_get_width_summary(GWidthTracker *);
 void g_width_tracker_get_local_width_summary(GWidthTracker *, size_t, line_width_summary *);
 
 /* Fournit la largeur requise par une visualisation. */
-gint g_width_tracker_get_width(GWidthTracker *, const bool *);
+gint g_width_tracker_get_width(GWidthTracker *, const GDisplayOptions *);
 
 /* Fournit la largeur requise pour dépasser les marges gauches. */
-gint g_width_tracker_get_margin(GWidthTracker *, const bool *);
+gint g_width_tracker_get_margin(GWidthTracker *, const GDisplayOptions *);