summaryrefslogtreecommitdiff
path: root/src/glibext
diff options
context:
space:
mode:
Diffstat (limited to 'src/glibext')
-rw-r--r--src/glibext/buffercache.c21
-rw-r--r--src/glibext/buffercache.h4
-rw-r--r--src/glibext/bufferline.c144
-rw-r--r--src/glibext/bufferline.h22
-rw-r--r--src/glibext/bufferview.c67
-rw-r--r--src/glibext/bufferview.h10
-rw-r--r--src/glibext/generators/hex.c15
-rw-r--r--src/glibext/widthtracker.c155
-rw-r--r--src/glibext/widthtracker.h27
9 files changed, 249 insertions, 216 deletions
diff --git a/src/glibext/buffercache.c b/src/glibext/buffercache.c
index 16d96dc..bfc2360 100644
--- a/src/glibext/buffercache.c
+++ b/src/glibext/buffercache.c
@@ -537,7 +537,7 @@ static void g_buffer_cache_init(GBufferCache *cache)
cache->count = 0;
cache->used = 0;
- cache->tracker = g_width_tracker_new(cache);
+ cache->tracker = NULL;
}
@@ -620,7 +620,8 @@ static void g_buffer_cache_finalize(GBufferCache *cache)
/******************************************************************************
* *
-* Paramètres : content = éventuel contenu binaire brut à référencer. *
+* Paramètres : content = éventuel contenu binaire brut à référencer. *
+* col_count = quantité maximale de colonnes à considérer. *
* *
* Description : Crée un nouveau composant de tampon pour code désassemblé. *
* *
@@ -630,7 +631,7 @@ static void g_buffer_cache_finalize(GBufferCache *cache)
* *
******************************************************************************/
-GBufferCache *g_buffer_cache_new(GBinContent *content)
+GBufferCache *g_buffer_cache_new(GBinContent *content, size_t col_count)
{
GBufferCache *result; /* Composant à retourner */
@@ -642,6 +643,8 @@ GBufferCache *g_buffer_cache_new(GBinContent *content)
g_object_ref(G_OBJECT(content));
}
+ result->tracker = g_width_tracker_new(result, col_count);
+
return result;
}
@@ -786,9 +789,6 @@ GWidthTracker *g_buffer_cache_get_width_tracker(const GBufferCache *cache)
}
-
-
-
/******************************************************************************
* *
* Paramètres : cache = instance GLib à consulter. *
@@ -1439,7 +1439,6 @@ void g_buffer_cache_collect_widths(GBufferCache *cache, size_t index, line_width
* last = dernière ligne à dessiner. *
* area = position et surface à traiter. *
* options = règles d'affichage des colonnes modulables. *
-* offsets = décalages supplémentaires à appliquer. *
* selected = ordonnée d'une ligne sélectionnée ou NULL. *
* list = liste de contenus à mettre en évidence. *
* *
@@ -1451,14 +1450,13 @@ 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 GDisplayOptions *options, const line_width_summary *offsets, 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 */
bool wait_selection; /* Sélection déjà passée ? */
size_t i; /* Boucle de parcours */
cache_info *info; /* Accès direct à une ligne */
- line_width_summary summary; /* Résumé concis des largeurs */
GBufferLine *line; /* Ligne à venir dessiner */
class = G_BUFFER_CACHE_GET_CLASS(cache);
@@ -1484,12 +1482,9 @@ void g_buffer_cache_draw(const GBufferCache *cache, cairo_t *cr, size_t first, s
info = &cache->lines[i];
- if (i == first || (g_buffer_cache_get_line_flags(cache, i) & BLF_WIDTH_MANAGER))
- g_width_tracker_get_local_width_summary(cache->tracker, i, &summary);
-
line = get_cache_info_line(info, i, cache->content);
- g_buffer_line_draw(line, cr, &summary, class->text_pos, y, options, offsets, list);
+ g_buffer_line_draw(line, i, cr, class->text_pos, y, cache->tracker, options, list);
g_object_unref(G_OBJECT(line));
diff --git a/src/glibext/buffercache.h b/src/glibext/buffercache.h
index 5094b53..70154a0 100644
--- a/src/glibext/buffercache.h
+++ b/src/glibext/buffercache.h
@@ -58,7 +58,7 @@ typedef struct _GBufferCacheClass GBufferCacheClass;
GType g_buffer_cache_get_type(void);
/* Crée un nouveau composant de tampon pour code désassemblé. */
-GBufferCache *g_buffer_cache_new(GBinContent *);
+GBufferCache *g_buffer_cache_new(GBinContent *, size_t);
/* Indique l'éventuel contenu binaire associé au cache. */
GBinContent *g_buffer_cache_get_content(const GBufferCache *);
@@ -114,7 +114,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 GDisplayOptions *, const line_width_summary *, 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/bufferline.c b/src/glibext/bufferline.c
index b9413e2..2f694dd 100644
--- a/src/glibext/bufferline.c
+++ b/src/glibext/bufferline.c
@@ -65,15 +65,6 @@ struct _GBufferLine
content_origin *origins; /* Mémorisation des origines */
size_t ocount; /* Nombre de ces mémorisations */
- union
- {
- struct
- {
- gint max_widths[BLC_COUNT]; /* Taille cachée des colonnes */
- gint merged_width; /* Largeur cumulée avant fusion*/
- };
- };
-
};
/* Représentation de fragments de texte en ligne (classe) */
@@ -568,7 +559,7 @@ void g_buffer_line_append_text(GBufferLine *line, size_t column, const char *tex
if (creator != NULL)
{
- line->origins = (content_origin *)realloc(line->origins, ++line->ocount * sizeof(content_origin));
+ line->origins = realloc(line->origins, ++line->ocount * sizeof(content_origin));
origin = &line->origins[line->ocount - 1];
@@ -984,43 +975,6 @@ void g_buffer_line_collect_widths(GBufferLine *line, line_width_summary *summary
/******************************************************************************
* *
-* Paramètres : line = ligne à venir consulter. *
-* index = indice de la colonne visée. *
-* summary = résumé des largeurs maximales. *
-* offsets = décalages supplémentaires à appliquer. *
-* *
-* Description : Fournit la largeur d'une colonne finalement appliquée. *
-* *
-* Retour : Largeur globale ou spécifique, selon l'indice communiqué. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-gint g_buffer_line_compute_max_width(const GBufferLine *line, BufferLineColumn index, const line_width_summary *summary, const line_width_summary *offsets)
-{
- gint result; /* Largeur à retourner */
-
- assert(index < BLC_COUNT);
-
- if (index >= line->merge_start)
- result = get_column_width(&line->columns[index]);
-
- else
- result = summary->max_widths[index];
-
- if (result < offsets->max_widths[index])
- result = offsets->max_widths[index];
-
- return result;
-
-}
-
-
-
-
-/******************************************************************************
-* *
* Paramètres : line = ligne à venir consulter. *
* coord = coordonnées interne du segment à retrouver. *
* *
@@ -1049,7 +1003,8 @@ line_segment *g_buffer_line_get_segment_from_coord(const GBufferLine *line, cons
/******************************************************************************
* *
* Paramètres : line = ligne à venir consulter. *
-* summary = résumé des largeurs maximales. *
+* index = indice de ligne associé. *
+* tracker = gestionnaire de largeur à consulter au besoin. *
* options = règles d'affichage des colonnes modulables. *
* offsets = décalages supplémentaires à appliquer. *
* base = position jusqu'au segment trouvé. [OUT] *
@@ -1066,12 +1021,13 @@ line_segment *g_buffer_line_get_segment_from_coord(const GBufferLine *line, cons
* *
******************************************************************************/
-bool g_buffer_line_get_coord_at(const GBufferLine *line, const line_width_summary *summary, const GDisplayOptions *options, const line_width_summary *offsets, gint *base, gint *offset, GdkScrollDirection dir, bool force, col_coord_t *coord)
+bool g_buffer_line_get_coord_at(const GBufferLine *line, size_t index, GWidthTracker *tracker, const GDisplayOptions *options, gint *base, gint *offset, GdkScrollDirection dir, bool force, col_coord_t *coord)
{
bool result; /* Bilan à retourner */
BufferLineColumn last; /* Dernière colonne remplie */
gint last_base; /* Dernière abscisse associée */
- size_t count; /* Qté de colonnes en option */
+ size_t col_count; /* Qté de colonnes présentes */
+ size_t opt_count; /* Qté de colonnes en option */
size_t i; /* Boucle de parcours */
gint width; /* Largeur d'une colonne donnée*/
gint limit; /* Limite d'appartenance */
@@ -1087,11 +1043,12 @@ bool g_buffer_line_get_coord_at(const GBufferLine *line, const line_width_summar
/* On cible déjà la colonne idéale */
- count = g_display_options_count(options);
+ col_count = g_width_tracker_count_columns(tracker);
+ opt_count = g_display_options_count(options);
- for (i = 0; i < BLC_COUNT; i++)
+ for (i = 0; i < col_count; i++)
{
- if (i < count)
+ if (i < opt_count)
{
if (!g_display_options_get(options, i))
continue;
@@ -1106,12 +1063,12 @@ bool g_buffer_line_get_coord_at(const GBufferLine *line, const line_width_summar
if (i < line->merge_start)
{
- width = g_buffer_line_compute_max_width(line, i, summary, offsets);
+ width = g_width_tracker_get_local_column_width(tracker, index, i, opt_count);
/* Si la colonne n'est absolument pas visible, on ne s'arrête pas dessus ! */
if (width == 0) continue;
- if ((i + 1) < BLC_COUNT) limit = width + COL_MARGIN / 2;
+ if ((i + 1) < col_count) limit = width + COL_MARGIN / 2;
else limit = width;
if (*offset <= limit) break;
@@ -1140,7 +1097,7 @@ bool g_buffer_line_get_coord_at(const GBufferLine *line, const line_width_summar
/* Si l'abscisse fournie tombe encore dans une colonne... */
- if (i < BLC_COUNT)
+ if (i < col_count)
{
/* Il y a bien du contenu dans cette colonne */
@@ -1176,11 +1133,11 @@ bool g_buffer_line_get_coord_at(const GBufferLine *line, const line_width_summar
old_base = *base;
- for (i++; i < BLC_COUNT && !result; i++)
+ for (i++; i < col_count && !result; i++)
{
if ((i - 1) < line->merge_start)
{
- width = g_buffer_line_compute_max_width(line, i - 1, summary, offsets);
+ width = g_width_tracker_get_local_column_width(tracker, index, i - 1, opt_count);
if (width > 0)
*base += (width + COL_MARGIN);
@@ -1208,13 +1165,13 @@ bool g_buffer_line_get_coord_at(const GBufferLine *line, const line_width_summar
}
- else /* if (i == BLC_COUNT) */
+ else /* if (i == col_count) */
{
if (force)
{
use_right_border:
- if (last != BLC_COUNT)
+ if (last != col_count)
{
result = get_line_column_last_content_index(&line->columns[last], &coord->index);
@@ -1237,7 +1194,7 @@ bool g_buffer_line_get_coord_at(const GBufferLine *line, const line_width_summar
*base = 0;
*offset = 0;
- coord->column = BLC_COUNT;
+ coord->column = col_count;
coord->index = -1;
}
@@ -1256,9 +1213,9 @@ bool g_buffer_line_get_coord_at(const GBufferLine *line, const line_width_summar
/******************************************************************************
* *
* Paramètres : line = ligne à venir consulter. *
-* summary = résumé des largeurs maximales. *
+* index = indice de ligne associé. *
+* tracker = gestionnaire de largeur à consulter au besoin. *
* options = règles d'affichage des colonnes modulables. *
-* offsets = décalages supplémentaires à appliquer. *
* base = position jusqu'au segment trouvé. [OUT] *
* offset = position à la colonne visée. [OUT] *
* dir = direction d'un éventuel déplacement en cours. *
@@ -1272,13 +1229,13 @@ bool g_buffer_line_get_coord_at(const GBufferLine *line, const line_width_summar
* *
******************************************************************************/
-line_segment *g_buffer_line_get_segment_at(const GBufferLine *line, const line_width_summary *summary, const GDisplayOptions *options, const line_width_summary *offsets, gint *base, gint *offset, GdkScrollDirection dir, bool force)
+line_segment *g_buffer_line_get_segment_at(const GBufferLine *line, size_t index, GWidthTracker *tracker, const GDisplayOptions *options, gint *base, gint *offset, GdkScrollDirection dir, bool force)
{
line_segment *result; /* Trouvaille à retourner */
col_coord_t coord; /* Emplacement du contenu visé */
bool status; /* Bilan de la localisation */
- status = g_buffer_line_get_coord_at(line, summary, options, offsets, base, offset, dir, force, &coord);
+ status = g_buffer_line_get_coord_at(line, index, tracker, options, base, offset, dir, force, &coord);
if (status)
result = g_buffer_line_get_segment_from_coord(line, &coord);
@@ -1293,9 +1250,9 @@ line_segment *g_buffer_line_get_segment_at(const GBufferLine *line, const line_w
/******************************************************************************
* *
* Paramètres : line = ligne à venir consulter. *
-* summary = résumé des largeurs maximales. *
+* index = indice de ligne associé. *
+* tracker = gestionnaire de largeur à consulter au besoin. *
* options = règles d'affichage des colonnes modulables. *
-* offsets = décalages supplémentaires à appliquer. *
* base = position jusqu'au segment trouvé. [OUT] *
* offset = position à la colonne visée. [OUT] *
* dir = direction d'un éventuel déplacement en cours. *
@@ -1309,7 +1266,7 @@ line_segment *g_buffer_line_get_segment_at(const GBufferLine *line, const line_w
* *
******************************************************************************/
-GObject *g_buffer_line_get_creator_at(const GBufferLine *line, const line_width_summary *summary, const GDisplayOptions *options, const line_width_summary *offsets, gint *base, gint *offset, GdkScrollDirection dir, bool force)
+GObject *g_buffer_line_get_creator_at(const GBufferLine *line, size_t index, GWidthTracker *tracker, const GDisplayOptions *options, gint *base, gint *offset, GdkScrollDirection dir, bool force)
{
GObject *result; /* Trouvaille à retourner */
col_coord_t target; /* Emplacement du contenu visé */
@@ -1319,7 +1276,7 @@ GObject *g_buffer_line_get_creator_at(const GBufferLine *line, const line_width_
result = NULL;
- status = g_buffer_line_get_coord_at(line, summary, options, offsets, base, offset, dir, force, &target);
+ status = g_buffer_line_get_coord_at(line, index, tracker, options, base, offset, dir, force, &target);
if (status)
{
@@ -1345,10 +1302,10 @@ GObject *g_buffer_line_get_creator_at(const GBufferLine *line, const line_width_
/******************************************************************************
* *
* Paramètres : line = ligne à venir consulter. *
+* index = indice de ligne associé. *
* coord = cordonnées à consulter puis renseigner. [OUT] *
-* summary = résumé des largeurs maximales. *
+* tracker = gestionnaire de largeur à consulter au besoin. *
* options = règles d'affichage des colonnes modulables. *
-* offsets = décalages supplémentaires à appliquer. *
* dir = orientation des recherches. *
* offset = décalage pour amener à l'extrémité nouvelle. [OUT] *
* *
@@ -1360,28 +1317,31 @@ GObject *g_buffer_line_get_creator_at(const GBufferLine *line, const line_width_
* *
******************************************************************************/
-bool g_buffer_line_find_near_coord(const GBufferLine *line, col_coord_t *coord, const line_width_summary *summary, const GDisplayOptions *options, const line_width_summary *offsets, GdkScrollDirection dir, gint *offset)
+bool g_buffer_line_find_near_coord(const GBufferLine *line, size_t index, col_coord_t *coord, GWidthTracker *tracker, const GDisplayOptions *options, GdkScrollDirection dir, gint *offset)
{
bool result; /* Bilan à retourner */
- size_t count; /* Qté de colonnes en option */
+ size_t col_count; /* Qté de colonnes présentes */
size_t i; /* Boucle de parcours #1 */
+ size_t opt_count; /* Qté de colonnes en option */
bool displayed; /* Confort de lecture */
size_t k; /* Boucle de parcours #2 */
gint width; /* Largeur d'une colonne donnée*/
result = false;
+ col_count = g_width_tracker_count_columns(tracker);
+
/* Recherche dans la colonne de départ */
i = coord->column;
- if (i == BLC_COUNT) return false;
+ if (i == col_count) return false;
result = find_near_segment(&line->columns[i], &coord->index, dir);
/* Recherche dans la direction des colonnes voisines */
- count = g_display_options_count(options);
+ opt_count = g_display_options_count(options);
if (!result)
switch (dir)
@@ -1392,9 +1352,9 @@ bool g_buffer_line_find_near_coord(const GBufferLine *line, col_coord_t *coord,
if (i == 0) break;
/* On s'assure que la colonne précédente est visible et peuplée */
- for (; i > BLC_FIRST && !result; i--)
+ for (; i > 0 && !result; i--)
{
- displayed = (i <= count ? g_display_options_get(options, i - 1) : true);
+ displayed = (i <= opt_count ? g_display_options_get(options, i - 1) : true);
if (displayed)
{
@@ -1412,9 +1372,9 @@ bool g_buffer_line_find_near_coord(const GBufferLine *line, col_coord_t *coord,
case GDK_SCROLL_RIGHT:
/* On s'assure que la colonne suivante est visible et peuplée */
- for (; (i + 1) < BLC_COUNT && !result; i++)
+ for (; (i + 1) < col_count && !result; i++)
{
- displayed = ((i + 1) < count ? g_display_options_get(options, i + 1) : true);
+ displayed = ((i + 1) < opt_count ? g_display_options_get(options, i + 1) : true);
if (displayed)
{
@@ -1442,11 +1402,15 @@ bool g_buffer_line_find_near_coord(const GBufferLine *line, col_coord_t *coord,
for (k = 0; k < i; k++)
{
- displayed = (k < count ? g_display_options_get(options, k) : true);
+ displayed = (k < opt_count ? g_display_options_get(options, k) : true);
if (displayed)
{
- width = g_buffer_line_compute_max_width(line, k, summary, offsets);
+
+ if (k >= line->merge_start)
+ width = get_column_width(&line->columns[index]);
+ else
+ width = g_width_tracker_get_local_column_width(tracker, index, k, opt_count);
if (width > 0)
{
@@ -1483,12 +1447,12 @@ bool g_buffer_line_find_near_coord(const GBufferLine *line, col_coord_t *coord,
/******************************************************************************
* *
* Paramètres : line = ligne de texte à manipuler. *
+* index = indice de ligne associé. *
* cairo = contexte graphique à utiliser pour les pinceaux. *
-* summary = résumé des largeurs maximales. *
* x_init = abscisse du point d'impression de départ. *
* y = ordonnée du point d'impression. *
+* tracker = gestionnaire de largeur à consulter au besoin. *
* options = règles d'affichage des colonnes modulables. *
-* offsets = décalages supplémentaires à appliquer. *
* list = liste de contenus à mettre en évidence. *
* *
* Description : Imprime la ligne de texte représentée. *
@@ -1499,12 +1463,13 @@ bool g_buffer_line_find_near_coord(const GBufferLine *line, col_coord_t *coord,
* *
******************************************************************************/
-void g_buffer_line_draw(GBufferLine *line, cairo_t *cairo, const line_width_summary *summary, gint x_init, gint y, const GDisplayOptions *options, const line_width_summary *offsets, const segcnt_list *list)
+void g_buffer_line_draw(GBufferLine *line, size_t index, cairo_t *cairo, gint x_init, gint y, GWidthTracker *tracker, const GDisplayOptions *options, const segcnt_list *list)
{
GBufferLineClass *class; /* Stockage de briques de base */
bool has_src_surface; /* Note une présence définie */
gint x; /* Point de départ d'impression*/
- size_t count; /* Qté de colonnes en option */
+ size_t col_count; /* Qté de colonnes présentes */
+ size_t opt_count; /* Qté de colonnes en option */
size_t i; /* Boucle de parcours */
gint max_width; /* Largeur maximale de colonne */
@@ -1532,11 +1497,12 @@ void g_buffer_line_draw(GBufferLine *line, cairo_t *cairo, const line_width_summ
x = x_init;
- count = g_display_options_count(options);
+ col_count = g_width_tracker_count_columns(tracker);
+ opt_count = g_display_options_count(options);
- for (i = 0; i < BLC_COUNT; i++)
+ for (i = 0; i < col_count; i++)
{
- if (i < count)
+ if (i < opt_count)
{
if (!g_display_options_get(options, i))
continue;
@@ -1546,7 +1512,7 @@ void g_buffer_line_draw(GBufferLine *line, cairo_t *cairo, const line_width_summ
if (i < line->merge_start)
{
- max_width = g_buffer_line_compute_max_width(line, i, summary, offsets);
+ max_width = g_width_tracker_get_local_column_width(tracker, index, i, opt_count);
if (max_width > 0)
x += max_width + COL_MARGIN;
diff --git a/src/glibext/bufferline.h b/src/glibext/bufferline.h
index 95db203..a7982d0 100644
--- a/src/glibext/bufferline.h
+++ b/src/glibext/bufferline.h
@@ -31,6 +31,7 @@
#include "gdisplayoptions.h"
#include "linesegment.h"
+#include "widthtracker.h"
#include "../analysis/content.h"
#include "../arch/vmpa.h"
@@ -172,14 +173,6 @@ void g_buffer_line_export(GBufferLine *, buffer_export_context *, BufferExportTy
/* ----------------------- MANIPULATION DES LARGEURS REQUISES ----------------------- */
-/* Mémorisation des largeurs pour un groupe de lignes */
-typedef struct _line_width_summary
-{
- gint max_widths[BLC_COUNT]; /* Taille cachée des colonnes */
- gint merged_width; /* Largeur cumulée avant fusion*/
-
-} line_width_summary;
-
/* Identification d'un contenu de colonne */
typedef struct _col_coord_t
{
@@ -192,26 +185,23 @@ typedef struct _col_coord_t
/* Fait remonter les largeurs requises par une ligne donnée. */
void g_buffer_line_collect_widths(GBufferLine *, line_width_summary *);
-/* Fournit la largeur d'une colonne finalement appliquée. */
-gint g_buffer_line_compute_max_width(const GBufferLine *, BufferLineColumn, const line_width_summary *, const line_width_summary *);
-
/* Fournit le segment présent à une position donnée. */
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 GDisplayOptions *, const line_width_summary *, gint *, gint *, GdkScrollDirection, bool, col_coord_t *);
+bool g_buffer_line_get_coord_at(const GBufferLine *, size_t, GWidthTracker *, const GDisplayOptions *, gint *, gint *, GdkScrollDirection, bool, col_coord_t *);
/* Donne le segment présent à une abscisse donnée. */
-line_segment *g_buffer_line_get_segment_at(const GBufferLine *, const line_width_summary *, const GDisplayOptions *, const line_width_summary *, gint *, gint *, GdkScrollDirection, bool);
+line_segment *g_buffer_line_get_segment_at(const GBufferLine *, size_t, GWidthTracker *, 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 GDisplayOptions *, const line_width_summary *, gint *, gint *, GdkScrollDirection, bool);
+GObject *g_buffer_line_get_creator_at(const GBufferLine *, size_t, GWidthTracker *, 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 GDisplayOptions *, const line_width_summary *, GdkScrollDirection, gint *);
+bool g_buffer_line_find_near_coord(const GBufferLine *, size_t, col_coord_t *, GWidthTracker *, 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 GDisplayOptions *, const line_width_summary *, const segcnt_list *);
+void g_buffer_line_draw(GBufferLine *, size_t, cairo_t *, gint, gint, GWidthTracker *, const GDisplayOptions *, const segcnt_list *);
diff --git a/src/glibext/bufferview.c b/src/glibext/bufferview.c
index e40715e..769cd8b 100644
--- a/src/glibext/bufferview.c
+++ b/src/glibext/bufferview.c
@@ -76,10 +76,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 GDisplayOptions *, const line_width_summary *, cairo_rectangle_int_t *, GLineCursor **);
+static 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 GDisplayOptions *, const line_width_summary *);
+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. */
@@ -598,7 +598,6 @@ gint g_buffer_view_get_height(const GBufferView *view)
* x = abscisse proposée pour le nouvel emplacement. *
* y = ordonnée proposée pour le nouvel emplacement. *
* options = règles d'affichage des colonnes modulables. *
-* offsets = décalages supplémentaires à appliquer. *
* caret = position du curseur à construire. [OUT] *
* cursor = emplacement correspondant à cette position. [OUT] *
* *
@@ -610,7 +609,7 @@ gint g_buffer_view_get_height(const GBufferView *view)
* *
******************************************************************************/
-bool g_buffer_view_compute_caret_full(GBufferView *view, gint x, gint y, const GDisplayOptions *options, const line_width_summary *offsets, 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 */
@@ -635,7 +634,7 @@ bool g_buffer_view_compute_caret_full(GBufferView *view, gint x, gint y, const G
/* Calcul d'une position */
- result = _g_buffer_view_compute_caret_full(view, x, line, index, options, offsets, caret, cursor);
+ result = _g_buffer_view_compute_caret_full(view, x, line, index, options, caret, cursor);
g_object_unref(G_OBJECT(line));
@@ -653,7 +652,6 @@ bool g_buffer_view_compute_caret_full(GBufferView *view, gint x, gint y, const G
* line = ligne correspondant à la position. *
* index = indice de cette même ligne dans le tampon. *
* options = règles d'affichage des colonnes modulables. *
-* offsets = décalages supplémentaires à appliquer. *
* caret = position du curseur à construire. [OUT] *
* cursor = emplacement correspondant à cette position. [OUT] *
* *
@@ -665,11 +663,10 @@ bool g_buffer_view_compute_caret_full(GBufferView *view, gint x, gint y, const G
* *
******************************************************************************/
-bool _g_buffer_view_compute_caret_full(GBufferView *view, gint x, GBufferLine *line, size_t index, const GDisplayOptions *options, const line_width_summary *offsets, cairo_rectangle_int_t *caret, GLineCursor **cursor)
+static 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 */
- line_width_summary summary; /* Résumé concis des largeurs */
gint base; /* Position absolue de segment */
bool status; /* Bilan de la localisation */
gint lheight; /* Hauteur d'une ligne */
@@ -685,11 +682,9 @@ bool _g_buffer_view_compute_caret_full(GBufferView *view, gint x, GBufferLine *l
/* Calcul d'une position */
- g_width_tracker_get_local_width_summary(view->tracker, index, &summary);
-
x -= text_pos;
- status = g_buffer_line_get_coord_at(line, &summary, options, offsets, &base, &x,
+ status = g_buffer_line_get_coord_at(line, index, view->tracker, options, &base, &x,
GDK_SCROLL_LEFT, true, (col_coord_t []) { { 0 } });
if (!status)
@@ -726,7 +721,6 @@ bool _g_buffer_view_compute_caret_full(GBufferView *view, gint x, GBufferLine *l
* ctrl = indique la demande d'un parcours rapide. *
* dir = direction du parcours. *
* options = règles d'affichage des colonnes modulables. *
-* offsets = décalages supplémentaires à appliquer. *
* *
* Description : Déplace le curseur au sein d'une vue de tampon. *
* *
@@ -736,12 +730,11 @@ 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 GDisplayOptions *options, const line_width_summary *offsets)
+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 */
gint offset; /* Point de travail modifiable */
- line_width_summary summary; /* Résumé concis des largeurs */
gint base; /* Position absolue de segment */
col_coord_t coord; /* Coordonnées en interne */
line_segment *segment; /* Bribe de texte trouvée */
@@ -758,11 +751,9 @@ static bool _g_buffer_view_move_caret(GBufferView *view, const GBufferLine *line
offset = caret->x - text_pos;
- g_width_tracker_get_local_width_summary(view->tracker, index, &summary);
-
/* Déplacement au sein du segment courant ? */
- result = g_buffer_line_get_coord_at(line, &summary, options, offsets, &base, &offset, dir, false, &coord);
+ result = g_buffer_line_get_coord_at(line, index, view->tracker, options, &base, &offset, dir, false, &coord);
if (result)
{
@@ -780,7 +771,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, options, offsets, dir, &offset);
+ result = g_buffer_line_find_near_coord(line, index, &coord, view->tracker, options, dir, &offset);
}
@@ -802,7 +793,6 @@ static bool _g_buffer_view_move_caret(GBufferView *view, const GBufferLine *line
* ctrl = indique la demande d'un parcours rapide. *
* dir = direction du parcours. *
* options = règles d'affichage des colonnes modulables. *
-* offsets = décalages supplémentaires à appliquer. *
* caret = position du curseur à faire évoluer. [OUT] *
* cursor = emplacement correspondant à cette position. [OUT] *
* *
@@ -814,7 +804,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 GDisplayOptions *options, const line_width_summary *offsets, 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 */
@@ -844,8 +834,7 @@ bool g_buffer_view_move_caret(GBufferView *view, bool ctrl, GdkScrollDirection d
other = g_buffer_cache_find_line_by_index(view->cache, index);
assert(other != NULL);
- result = _g_buffer_view_compute_caret_full(view, caret->x, other, index,
- options, offsets, caret, cursor);
+ result = _g_buffer_view_compute_caret_full(view, caret->x, other, index, options, caret, cursor);
g_object_unref(G_OBJECT(other));
@@ -862,8 +851,7 @@ bool g_buffer_view_move_caret(GBufferView *view, bool ctrl, GdkScrollDirection d
other = g_buffer_cache_find_line_by_index(view->cache, index);
assert(other != NULL);
- result = _g_buffer_view_compute_caret_full(view, caret->x, other, index,
- options, offsets, caret, cursor);
+ result = _g_buffer_view_compute_caret_full(view, caret->x, other, index, options, caret, cursor);
g_object_unref(G_OBJECT(other));
@@ -873,7 +861,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, options, offsets);
+ moved = _g_buffer_view_move_caret(view, line, index, caret, ctrl, GDK_SCROLL_LEFT, options);
if (moved)
{
@@ -888,8 +876,7 @@ bool g_buffer_view_move_caret(GBufferView *view, bool ctrl, GdkScrollDirection d
other = g_buffer_cache_find_line_by_index(view->cache, index);
assert(other != NULL);
- result = _g_buffer_view_compute_caret_full(view, INT_MAX, other, index,
- options, offsets, caret, cursor);
+ result = _g_buffer_view_compute_caret_full(view, INT_MAX, other, index, options, caret, cursor);
g_object_unref(G_OBJECT(other));
@@ -899,7 +886,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, options, offsets);
+ moved = _g_buffer_view_move_caret(view, line, index, caret, ctrl, GDK_SCROLL_RIGHT, options);
if (moved)
{
@@ -916,8 +903,7 @@ bool g_buffer_view_move_caret(GBufferView *view, bool ctrl, GdkScrollDirection d
other = g_buffer_cache_find_line_by_index(view->cache, index);
assert(other != NULL);
- result = _g_buffer_view_compute_caret_full(view, text_pos, other, index,
- options, offsets, caret, cursor);
+ result = _g_buffer_view_compute_caret_full(view, text_pos, other, index, options, caret, cursor);
g_object_unref(G_OBJECT(other));
@@ -951,7 +937,6 @@ bool g_buffer_view_move_caret(GBufferView *view, bool ctrl, GdkScrollDirection d
* x = abscisse de la zone principale à traiter. *
* y = ordonnée de la zone principale à traiter. *
* options = règles d'affichage des colonnes modulables. *
-* offsets = décalages supplémentaires à appliquer. *
* *
* Description : Trouve le créateur à l'origine d'un emplacement donné. *
* *
@@ -961,14 +946,13 @@ 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 GDisplayOptions *options, const line_width_summary *offsets)
+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 */
gint lheight; /* Hauteur d'une ligne */
size_t index; /* Indice de ligne de tampon */
GBufferLine *line; /* Ligne à la position courante*/
- line_width_summary summary; /* Résumé concis des largeurs */
result = NULL;
@@ -995,11 +979,9 @@ GObject *g_buffer_view_find_creator(GBufferView *view, gint x, gint y, const GDi
/* Recherche d'un segment et de son empreinte */
- g_width_tracker_get_local_width_summary(view->tracker, index, &summary);
-
x -= text_pos;
- result = g_buffer_line_get_creator_at(line, &summary, options, offsets,
+ result = g_buffer_line_get_creator_at(line, index, view->tracker, options,
(gint []) { 0 }, &x, GDK_SCROLL_LEFT, false);
g_object_unref(G_OBJECT(line));
@@ -1046,7 +1028,6 @@ bool g_buffer_view_unhighlight_segments(GBufferView *view)
* x = abscisse de la zone principale à traiter. *
* y = ordonnée de la zone principale à traiter. *
* options = règles d'affichage des colonnes modulables. *
-* offsets = décalages supplémentaires à appliquer. *
* *
* Description : Surligne tous les segments similaires à celui sous la souris.*
* *
@@ -1056,14 +1037,13 @@ bool g_buffer_view_unhighlight_segments(GBufferView *view)
* *
******************************************************************************/
-bool g_buffer_view_highlight_segments(GBufferView *view, gint x, gint y, const GDisplayOptions *options, const line_width_summary *offsets)
+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 */
gint lheight; /* Hauteur d'une ligne */
size_t index; /* Indice de ligne de tampon */
GBufferLine *line; /* Ligne à la position courante*/
- line_width_summary summary; /* Résumé concis des largeurs */
line_segment *segment; /* Segment sélectionnable */
/* Réinitialisation */
@@ -1096,11 +1076,9 @@ bool g_buffer_view_highlight_segments(GBufferView *view, gint x, gint y, const G
/* Recherche d'un segment et de son empreinte */
- g_width_tracker_get_local_width_summary(view->tracker, index, &summary);
-
x -= text_pos;
- segment = g_buffer_line_get_segment_at(line, &summary, options, offsets,
+ segment = g_buffer_line_get_segment_at(line, index, view->tracker, options,
(gint []) { 0 }, &x, GDK_SCROLL_LEFT, true);
g_object_unref(G_OBJECT(line));
@@ -1130,7 +1108,6 @@ bool g_buffer_view_highlight_segments(GBufferView *view, gint x, gint y, const G
* virt_y = ordonnée réelle du point 0 à l'écran. *
* area = position et surface à traiter. *
* options = règles d'affichage des colonnes modulables. *
-* offsets = décalages supplémentaires à appliquer. *
* selected = ordonnée d'une ligne sélectionnée ou NULL. *
* scale = échelle appliquée à la surface de rendu. *
* export = indique si la vue est en cours d'exportation. *
@@ -1143,7 +1120,7 @@ bool g_buffer_view_highlight_segments(GBufferView *view, gint x, gint y, const G
* *
******************************************************************************/
-void g_buffer_view_draw(const GBufferView *view, cairo_t *cr, gint virt_y, const cairo_rectangle_int_t *area, const GDisplayOptions *options, const line_width_summary *offsets, gint *selected, double scale, bool export)
+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, double scale, bool export)
{
gint line_height; /* Hauteur d'une ligne */
gint cr_y; /* Ordonnée pour le dessin */
@@ -1186,7 +1163,7 @@ void g_buffer_view_draw(const GBufferView *view, cairo_t *cr, gint virt_y, const
else
highlighted = view->highlighted;
- g_buffer_cache_draw(view->cache, cr, first, last, area, options, offsets, selected, highlighted);
+ g_buffer_cache_draw(view->cache, cr, first, last, area, options, selected, highlighted);
if (export)
unref_segment_content_list(highlighted);
diff --git a/src/glibext/bufferview.h b/src/glibext/bufferview.h
index 01da713..43e6293 100644
--- a/src/glibext/bufferview.h
+++ b/src/glibext/bufferview.h
@@ -79,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 GDisplayOptions *, const line_width_summary *, 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 GDisplayOptions *, const line_width_summary *, 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 GDisplayOptions *, const line_width_summary *);
+GObject *g_buffer_view_find_creator(GBufferView *, gint, gint, const GDisplayOptions *);
@@ -95,10 +95,10 @@ GObject *g_buffer_view_find_creator(GBufferView *, gint, gint, const GDisplayOpt
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 GDisplayOptions *, const line_width_summary *);
+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 GDisplayOptions *, const line_width_summary *, gint *, double, bool);
+void g_buffer_view_draw(const GBufferView *, cairo_t *, gint, const cairo_rectangle_int_t *, const GDisplayOptions *, gint *, double, bool);
diff --git a/src/glibext/generators/hex.c b/src/glibext/generators/hex.c
index b261f36..f08d3fb 100644
--- a/src/glibext/generators/hex.c
+++ b/src/glibext/generators/hex.c
@@ -33,6 +33,7 @@
#include "../linegen-int.h"
#include "../linesegment.h"
#include "../../core/params.h"
+#include "../../gtkext/hexdisplay.h"
@@ -504,9 +505,9 @@ static void g_hex_generator_print(GHexGenerator *generator, GBufferLine *line, s
if (i > 0)
{
if (i % 4 == 0)
- g_buffer_line_append_text(line, BLC_BINARY, "\t", 1, RTT_RAW, NULL);
+ g_buffer_line_append_text(line, HLC_BINARY, "\t", 1, RTT_RAW, NULL);
else
- g_buffer_line_append_text(line, BLC_BINARY, " ", 1, RTT_RAW, NULL);
+ g_buffer_line_append_text(line, HLC_BINARY, " ", 1, RTT_RAW, NULL);
}
/* Binaire brut */
@@ -514,26 +515,26 @@ static void g_hex_generator_print(GHexGenerator *generator, GBufferLine *line, s
byte = raw[i];
if (byte == 0x00)
- g_buffer_line_append_text(line, BLC_BINARY, "00", 2, RTT_RAW_NULL, NULL);
+ g_buffer_line_append_text(line, HLC_BINARY, "00", 2, RTT_RAW_NULL, NULL);
else if (byte == 0xff)
- g_buffer_line_append_text(line, BLC_BINARY, ff, 2, RTT_RAW_FULL, NULL);
+ g_buffer_line_append_text(line, HLC_BINARY, ff, 2, RTT_RAW_FULL, NULL);
else
{
tmp[1] = hexa[byte & 0xf];
tmp[0] = hexa[(byte >> 4) & 0xf];
- g_buffer_line_append_text(line, BLC_BINARY, tmp, 2, RTT_RAW, NULL);
+ g_buffer_line_append_text(line, HLC_BINARY, tmp, 2, RTT_RAW, NULL);
}
/* Représentation humaine ? */
if (isgraph(byte) || byte == ' ')
- g_buffer_line_append_text(line, BLC_ASSEMBLY, (char *)raw + i, 1, RTT_PRINTABLE, NULL);
+ g_buffer_line_append_text(line, HLC_TRANSLATION, (char *)raw + i, 1, RTT_PRINTABLE, NULL);
else
- g_buffer_line_append_text(line, BLC_ASSEMBLY, ".", 1, RTT_NOT_PRINTABLE, NULL);
+ g_buffer_line_append_text(line, HLC_TRANSLATION, ".", 1, RTT_NOT_PRINTABLE, NULL);
}
diff --git a/src/glibext/widthtracker.c b/src/glibext/widthtracker.c
index 274b53c..8ecaad0 100644
--- a/src/glibext/widthtracker.c
+++ b/src/glibext/widthtracker.c
@@ -122,10 +122,13 @@ struct _GWidthTracker
GObject parent; /* A laisser en premier */
GBufferCache *cache; /* Ensemble complet de lignes */
+ size_t col_count; /* Nombre maximum de colonnes */
common_metrics *portions; /* Portions représentées */
size_t count; /* Quantité de ces portions */
+ gint *min_widths; /* Largeurs min. à respecter */
+
line_width_summary summary; /* Largeurs requises suivies */
bool cached; /* Mise en cache des calculs */
@@ -457,6 +460,9 @@ static void g_width_tracker_dispose(GWidthTracker *tracker)
static void g_width_tracker_finalize(GWidthTracker *tracker)
{
+ if (tracker->min_widths != NULL)
+ free(tracker->min_widths);
+
G_OBJECT_CLASS(g_width_tracker_parent_class)->finalize(G_OBJECT(tracker));
}
@@ -464,9 +470,8 @@ static void g_width_tracker_finalize(GWidthTracker *tracker)
/******************************************************************************
* *
-* Paramètres : buffer = tampon contenant les lignes à surveiller. *
-* first = adresse contenant l'indice de la première ligne. *
-* last = adresse contenant l'indice de la dernière ligne. *
+* Paramètres : cache = tampon de lignes à lier au futur élément. *
+* col_count = quantité maximale de colonnes à considérer. *
* *
* Description : Crée un nouveau suivi de largeurs au sein de lignes. *
* *
@@ -476,7 +481,7 @@ static void g_width_tracker_finalize(GWidthTracker *tracker)
* *
******************************************************************************/
-GWidthTracker *g_width_tracker_new(GBufferCache *cache)
+GWidthTracker *g_width_tracker_new(GBufferCache *cache, size_t col_count)
{
GWidthTracker *result; /* Composant à retourner */
@@ -485,6 +490,10 @@ GWidthTracker *g_width_tracker_new(GBufferCache *cache)
g_object_ref(G_OBJECT(cache));
result->cache = cache;
+ result->col_count = col_count;
+
+ result->min_widths = calloc(col_count, sizeof(gint));
+
return result;
}
@@ -516,6 +525,8 @@ GWidthTracker *g_width_tracker_new_restricted(const GWidthTracker *template, siz
g_object_ref(G_OBJECT(template->cache));
result->cache = template->cache;
+ result->col_count = template->col_count;
+
start = g_width_tracker_find_metrics(template, first);
assert(start < template->count);
@@ -523,7 +534,7 @@ GWidthTracker *g_width_tracker_new_restricted(const GWidthTracker *template, siz
assert(end < template->count);
result->count = end - start + 1;
- result->portions = (common_metrics *)calloc(result->count, sizeof(common_metrics));
+ result->portions = calloc(result->count, sizeof(common_metrics));
for (i = 0; i < result->count; i++)
memcpy(&result->portions[i], &template->portions[start + i], sizeof(common_metrics));
@@ -540,6 +551,34 @@ GWidthTracker *g_width_tracker_new_restricted(const GWidthTracker *template, siz
g_width_tracker_reset_widths(result, result->count - 1);
}
+ result->min_widths = calloc(template->col_count, sizeof(gint));
+
+ for (i = 0; i < template->col_count; i++)
+ result->min_widths[i] = template->min_widths[i];
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : tracker = gestionnaire de largeurs de lignes à consulter. *
+* *
+* Description : Indique le nombre de colonnes prises en compte. *
+* *
+* Retour : Quantité normalement strictement positive. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+size_t g_width_tracker_count_columns(const GWidthTracker *tracker)
+{
+ size_t result; /* Quantité à retourner */
+
+ result = tracker->col_count;
+
return result;
}
@@ -547,6 +586,29 @@ GWidthTracker *g_width_tracker_new_restricted(const GWidthTracker *template, siz
/******************************************************************************
* *
+* Paramètres : tracker = gestionnaire de largeurs de lignes à mettre jour. *
+* col = indice de colonne visée. *
+* width = largeur minimale à imposer. *
+* *
+* Description : Impose une largeur minimale pour une colonne donnée. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+void g_width_tracker_set_column_min_width(GWidthTracker *tracker, size_t col, gint width)
+{
+ assert(col < tracker->col_count);
+
+ tracker->min_widths[col] = width;
+
+}
+
+
+/******************************************************************************
+* *
* Paramètres : tracker = gestionnaire de suivi à consulter. *
* index = indice d'une ligne dont la portion est inconnue. *
* *
@@ -761,7 +823,7 @@ void g_width_tracker_update_added(GWidthTracker *tracker, size_t index, size_t c
{
assert(index == 0);
- tracker->portions = (common_metrics *)calloc(1, sizeof(common_metrics));
+ tracker->portions = calloc(1, sizeof(common_metrics));
tracker->count = 1;
tracker->portions[0].first = 0;
@@ -805,8 +867,7 @@ void g_width_tracker_update_added(GWidthTracker *tracker, size_t index, size_t c
tracker->count++;
- tracker->portions = (common_metrics *)realloc(tracker->portions,
- tracker->count * sizeof(common_metrics));
+ tracker->portions = realloc(tracker->portions, tracker->count * sizeof(common_metrics));
portion = &tracker->portions[current];
@@ -910,8 +971,7 @@ void g_width_tracker_update_deleted(GWidthTracker *tracker, size_t start, size_t
tracker->count -= (src - dest);
- tracker->portions = (common_metrics *)realloc(tracker->portions,
- tracker->count * sizeof(common_metrics));
+ tracker->portions = realloc(tracker->portions, tracker->count * sizeof(common_metrics));
}
@@ -927,8 +987,7 @@ void g_width_tracker_update_deleted(GWidthTracker *tracker, size_t start, size_t
tracker->count--;
- tracker->portions = (common_metrics *)realloc(tracker->portions,
- tracker->count * sizeof(common_metrics));
+ tracker->portions = realloc(tracker->portions, tracker->count * sizeof(common_metrics));
keep_last = false;
@@ -1002,7 +1061,7 @@ void g_width_tracker_build_initial_cache(GWidthTracker *tracker, wgroup_id_t gid
run_size = compute_run_size(tracker->count, &runs_count);
- updates = (GWidthUpdate **)calloc(runs_count, sizeof(GWidthUpdate *));
+ updates = calloc(runs_count, sizeof(GWidthUpdate *));
queue = get_work_queue();
@@ -1101,27 +1160,6 @@ static void g_width_tracker_ensure_valid_required_widths(GWidthTracker *tracker)
/******************************************************************************
* *
* Paramètres : tracker = suivi de largeurs à consulter. *
-* *
-* Description : Fournit un bon résumé des largeurs en vigueur. *
-* *
-* Retour : Ensemble des largeurs collectées. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-const line_width_summary *g_width_tracker_get_width_summary(GWidthTracker *tracker)
-{
- g_width_tracker_ensure_valid_required_widths(tracker);
-
- return &tracker->summary;
-
-}
-
-
-/******************************************************************************
-* *
-* Paramètres : tracker = suivi de largeurs à consulter. *
* index = indice de la ligne dont la portion est recherchée. *
* summary = ensemble ciblé de largeurs collectées. [OUT] *
* *
@@ -1269,3 +1307,52 @@ gint g_width_tracker_get_margin(GWidthTracker *tracker, const GDisplayOptions *o
return result;
}
+
+
+/******************************************************************************
+* *
+* Paramètres : tracker = suivi de largeurs à consulter. *
+* index = indice de la ligne dont la portion est visée. *
+* col = indice de la colonne visée par l'opération. *
+* opt_count = quantité de colonnes initiales en options. *
+* *
+* Description : Indique la largeur locale d'une colonne donnée. *
+* *
+* Retour : Taille positive ou nulle. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+gint g_width_tracker_get_local_column_width(GWidthTracker *tracker, size_t index, size_t col, size_t opt_count)
+{
+ gint result; /* Largeur à retourner */
+ size_t current; /* Indice de portion visée */
+ const line_width_summary *local; /* Valeurs à intégrer */
+
+ g_width_tracker_ensure_valid_required_widths(tracker);
+
+ assert(col < tracker->col_count);
+
+ if (col < opt_count)
+ {
+ assert(opt_count < tracker->col_count);
+ result = tracker->summary.max_widths[col];
+ }
+
+ else
+ {
+ current = g_width_tracker_find_metrics(tracker, index);
+ assert(current < tracker->count);
+
+ local = g_width_tracker_get_up_to_date_widths(tracker, current);
+
+ result = local->max_widths[col];
+
+ }
+
+ result = MAX(result, tracker->min_widths[col]);
+
+ return result;
+
+}
diff --git a/src/glibext/widthtracker.h b/src/glibext/widthtracker.h
index b7bb8a4..82442ae 100644
--- a/src/glibext/widthtracker.h
+++ b/src/glibext/widthtracker.h
@@ -29,12 +29,23 @@
#include <stdbool.h>
-#include "bufferline.h"
+//#include "bufferline.h"
#include "delayed.h"
#include "gdisplayoptions.h"
+
+/* Mémorisation des largeurs pour un groupe de lignes */
+typedef struct _line_width_summary
+{
+ gint max_widths[10/*BLC_COUNT*/]; /* Taille cachée des colonnes */
+ gint merged_width; /* Largeur cumulée avant fusion*/
+
+} line_width_summary;
+
+
+
/* ---------------------------- RASSEMBLEMENT DE MESURES ---------------------------- */
@@ -61,11 +72,17 @@ typedef struct _GWidthTrackerClass GWidthTrackerClass;
GType g_width_tracker_get_type(void);
/* Crée un nouveau suivi de largeurs au sein de lignes. */
-GWidthTracker *g_width_tracker_new(GBufferCache *);
+GWidthTracker *g_width_tracker_new(GBufferCache *, size_t);
/* Crée un nouveau suivi de largeurs au sein de lignes. */
GWidthTracker *g_width_tracker_new_restricted(const GWidthTracker *, size_t, size_t);
+/* Indique le nombre de colonnes prises en compte. */
+size_t g_width_tracker_count_columns(const GWidthTracker *);
+
+/* Impose une largeur minimale pour une colonne donnée. */
+void g_width_tracker_set_column_min_width(GWidthTracker *, size_t, gint);
+
/* Prend acte d'un changement sur une ligne pour les largeurs. */
void g_width_tracker_update(GWidthTracker *, size_t);
@@ -78,9 +95,6 @@ void g_width_tracker_update_deleted(GWidthTracker *, size_t, size_t);
/* Calcule les largeurs requises par un ensemble de lignes. */
void g_width_tracker_build_initial_cache(GWidthTracker *, wgroup_id_t, GtkStatusStack *);
-/* Fournit un bon résumé des largeurs en vigueur. */
-const line_width_summary *g_width_tracker_get_width_summary(GWidthTracker *);
-
/* Fournit un résumé local des largeurs en vigueur. */
void g_width_tracker_get_local_width_summary(GWidthTracker *, size_t, line_width_summary *);
@@ -90,6 +104,9 @@ 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 GDisplayOptions *);
+/* Indique la largeur locale d'une colonne donnée. */
+gint g_width_tracker_get_local_column_width(GWidthTracker *, size_t, size_t, size_t);
+
#endif /* _GLIBEXT_WIDTHTRACKER_H */