diff options
Diffstat (limited to 'src/glibext')
| -rw-r--r-- | src/glibext/gbufferline.c | 324 | ||||
| -rw-r--r-- | src/glibext/gbufferline.h | 11 | ||||
| -rw-r--r-- | src/glibext/gbuffersegment.c | 64 | ||||
| -rw-r--r-- | src/glibext/gbuffersegment.h | 3 | ||||
| -rw-r--r-- | src/glibext/gcodebuffer.c | 292 | ||||
| -rw-r--r-- | src/glibext/gcodebuffer.h | 4 |
6 files changed, 593 insertions, 105 deletions
diff --git a/src/glibext/gbufferline.c b/src/glibext/gbufferline.c index cb5c267..6970dac 100644 --- a/src/glibext/gbufferline.c +++ b/src/glibext/gbufferline.c @@ -56,13 +56,19 @@ typedef struct _buffer_line_column static void reset_column(buffer_line_column *); /* Fournit la quantité de pixels requise pour l'impression. */ -static gint get_column_width(buffer_line_column *); +static gint get_column_width(const buffer_line_column *); /* Ajoute un fragment de texte à une colonne de ligne. */ static void add_segment_to_column(buffer_line_column *, GBufferSegment *); +#define get_first_segment(col) ((col)->count > 0 ? (col)->segments[0] : NULL) +#define get_last_segment(col) ((col)->count > 0 ? (col)->segments[(col)->count - 1] : NULL) + /* Donne le segment d'une colonne présent à une abscisse donnée. */ -static GBufferSegment *get_segment_at(const buffer_line_column *, gint *, bool); +static GBufferSegment *get_segment_at(const buffer_line_column *, gint *, GdkScrollDirection); + +/* Fournit le segment voisin d'un autre segment identifié. */ +static GBufferSegment *find_near_segment(const buffer_line_column *, GBufferSegment *, GdkScrollDirection, bool *); /* Met en surbrillance des segments similaires. */ GSList *highlight_all_same_segments(const buffer_line_column *, GSList *, const GBufferSegment *); @@ -129,7 +135,7 @@ static void g_buffer_line_init(GBufferLine *); static void reset_column(buffer_line_column *column) { - column->max_width = -1; + column->max_width = 0; } @@ -146,19 +152,8 @@ static void reset_column(buffer_line_column *column) * * ******************************************************************************/ -static gint get_column_width(buffer_line_column *column) +static gint get_column_width(const buffer_line_column *column) { - size_t i; /* Boucle de parcours */ - - if (column->max_width == -1) - { - column->max_width = 0; - - for (i = 0; i < column->count; i++) - column->max_width += g_buffer_segment_get_width(column->segments[i]); - - } - return column->max_width; } @@ -189,6 +184,8 @@ static void add_segment_to_column(buffer_line_column *column, GBufferSegment *se column->segments[column->count - 1] = segment; + column->max_width += g_buffer_segment_get_width(segment); + } @@ -196,7 +193,7 @@ static void add_segment_to_column(buffer_line_column *column, GBufferSegment *se * * * Paramètres : column = colonne de ligne de texte à consulter. * * x = position de recherche à ajuster. [OUT] * -* force = accepte les segments en bordure au pire. * +* dir = direction d'un éventuel déplacement en cours. * * * * Description : Donne le segment d'une colonne présent à une abscisse donnée.* * * @@ -206,19 +203,37 @@ static void add_segment_to_column(buffer_line_column *column, GBufferSegment *se * * ******************************************************************************/ -static GBufferSegment *get_segment_at(const buffer_line_column *column, gint *x, bool force) +static GBufferSegment *get_segment_at(const buffer_line_column *column, gint *x, GdkScrollDirection dir) { GBufferSegment *result; /* Trouvaille à retourner */ size_t i; /* Boucle de parcours */ gint width; /* Largeur à retirer */ + bool included; /* Appartenance à une largeur ?*/ result = NULL; + printf(" == gs@ == count = %d width = %d\n", + column->count, get_column_width(column)); + for (i = 0; i < column->count && result == NULL; i++) { width = g_buffer_segment_get_width(column->segments[i]); - if (width > *x || ((i + 1) == column->count && force)) + printf(" -s- |%d| -> x=%d w=%d\n", i, *x, width); + + /** + * Soit une limite entre deux segments A et B : + * + * - dans le cas d'un déplacement vers la gauche, on part de cette limite + * pour progresser à l'intérieur de A. Donc la limite fait partie de A. + * + * - dans le cas d'un déplacement vers la droite, on part de cette limite + * pour progresser à l'intérieur de B. Donc la limite ne fait pas partie de A. + */ + if (dir == GDK_SCROLL_LEFT) included = (width >= *x); + else included = (width > *x); + + if (included || (i + 1) == column->count) result = column->segments[i]; else @@ -226,6 +241,59 @@ static GBufferSegment *get_segment_at(const buffer_line_column *column, gint *x, } + printf(" == gs@ == > segment = %p\n", result); + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : column = colonne de ligne de texte à consulter. * +* target = segment dont un voisin est à retourner. * +* dir = orientation des recherches. * +* out = renvoie vers une bordure extérieur au besoin. [OUT] * +* * +* Description : Fournit le segment voisin d'un autre segment identifié. * +* * +* Retour : Segment trouvé ou NULL si hors borne ou inconnu. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static GBufferSegment *find_near_segment(const buffer_line_column *column, GBufferSegment *target, GdkScrollDirection dir, bool *out) +{ + GBufferSegment *result; /* Trouvaille à retourner */ + size_t i; /* Boucle de parcours */ + + result = NULL; + *out = false; + + for (i = 0; i < column->count; i++) + if (column->segments[i] == target) break; + + if (i < column->count) + switch (dir) + { + case GDK_SCROLL_LEFT: + *out = (i == 0); + if (!*out) + result = column->segments[i - 1]; + break; + + case GDK_SCROLL_RIGHT: + *out = ((i + 1) == column->count); + if (!*out) + result = column->segments[i + 1]; + break; + + default: + break; + + } + return result; } @@ -518,7 +586,9 @@ void g_buffer_line_add_segment(GBufferLine *line, BufferLineColumn index, GBuffe * * * Paramètres : line = ligne à venir consulter. * * max_widths = largeurs de colonne à respecter. * +* display = règles d'affichage des colonnes modulables. * * x = position à la colonne visée. [OUT] * +* dir = direction d'un éventuel déplacement en cours. * * force = accepte les segments en bordure au pire. * * * * Description : Donne le segment présent à une abscisse donnée. * @@ -529,30 +599,120 @@ void g_buffer_line_add_segment(GBufferLine *line, BufferLineColumn index, GBuffe * * ******************************************************************************/ -GBufferSegment *g_buffer_line_get_segment_at(const GBufferLine *line, const gint max_widths[BLC_COUNT], gint *x, bool force) +GBufferSegment *g_buffer_line_get_segment_at(const GBufferLine *line, const gint max_widths[BLC_COUNT], const bool *display, gint *x, GdkScrollDirection dir, bool force) { GBufferSegment *result; /* Trouvaille à retourner */ + gint old; /* Valeur d'origine de position*/ + BufferLineColumn last; /* Dernière colonne remplie */ + gint last_x; /* Dernière abscisse associée */ BufferLineColumn i; /* Boucle de parcours */ + gint width; /* Largeur d'une colonne donnée*/ result = NULL; + old = *x; + last = BLC_COUNT; + last_x = *x; /* Pour GCC */ + + printf(" {{ ADDR }} 0x%08x\n", line->range.addr.physical); + + + + for (i = 0; i < BLC_COUNT; i++) { - /* FIXME : addr/code */ + printf(" @ (%d) x=%d width=%d max=%d display ? %d\n", + i, *x, get_column_width(&line->columns[i]), max_widths[i], i < BLC_DISPLAY ? display[i] : true); + + + if (i < BLC_DISPLAY && !display[i]) continue; + + /* Mémorisation de la dernière colonne contenant quelque chose... */ + if (get_column_width(&line->columns[i]) > 0) + { + last = i; + last_x = *x; + } + + if (i < line->merge_start) + { + width = max_widths[i]; + + if (*x <= width) break; + else *x -= (max_widths[i] + COL_MARGIN); + + } + else + { + width = get_column_width(&line->columns[i]); + + if (*x <= width) break; + else *x -= width; + + } - if (*x < max_widths[i]) break; - else *x -= (max_widths[i] + COL_MARGIN); } - if (i == BLC_COUNT && force) + printf(" -- get segment at -- found index %u (max=%u)\n", i, BLC_COUNT); + + + printf(" last seen = %u\n", last); + + + + if (force) { - i = BLC_COUNT - 1; - *x += (max_widths[i] + COL_MARGIN); + if (i == BLC_COUNT) + { + + /* Re-calcul des largeurs cumulées */ + + if (last == BLC_COUNT) i = BLC_COUNT; + else + { + *x = old; + + for (i = 0; i < last; i++) + { + if (i < line->merge_start) + *x -= (max_widths[i] + COL_MARGIN); + else + *x -= get_column_width(&line->columns[i]); + } + + } + + + printf(" -- get segment at -- last index %u (max=%u) -->> x = %d\n", i, BLC_COUNT, *x); + + + + } + + /* Si on s'est arrêté sur un champ vide... */ + else if (i != last) + { + i = last; + *x = last_x; + } + } + + + + if (i < BLC_COUNT) - result = get_segment_at(&line->columns[i], x, force); + result = get_segment_at(&line->columns[i], x, dir); + + + if (result == NULL) + printf(" -- get segment at -- found nothing...\n"); + else + printf(" -- get segment at -- found %p '%s'...\n", result, g_buffer_segment_get_text(result)); + + return result; @@ -561,33 +721,117 @@ GBufferSegment *g_buffer_line_get_segment_at(const GBufferLine *line, const gint /****************************************************************************** * * -* Paramètres : line = ligne à venir consulter. * -* caret = position du curseur à faire évoluer. * -* ctrl = indique la demande d'un parcours rapide. * -* dir = direction du parcours. * -* phys = indique si les positions doivent être affichées. * -* virt = indique si les adresses doivent être affichées. * -* code = indique si le code binaire doit être affiché. * +* Paramètres : line = ligne à venir consulter. * +* target = segment dont un voisin est à retourner. * +* max_widths = largeurs de colonne à respecter. XXXXXXXXXXXXXXX * +* display = règles d'affichage des colonnes modulables. * +* dir = orientation des recherches. * +* offset = décalage pour amener à l'extrémité voisine. [OUT] * * * -* Description : Déplace le curseur au sein d'une vue de tampon. * +* Description : Fournit le segment voisin d'un autre segment identifié. * * * -* Retour : true si un déplacement a été effectué, false sinon. * +* Retour : Segment trouvé dans la ligne ou NULL. * * * * Remarques : - * * * ******************************************************************************/ -bool g_buffer_line_move_caret(const GBufferLine *line, GdkRectangle *caret, bool ctrl, GdkScrollDirection dir, bool phys, bool virt, bool code) +GBufferSegment *g_buffer_line_find_near_segment(const GBufferLine *line, GBufferSegment *target, const gint max_widths[BLC_COUNT], const bool *display, GdkScrollDirection dir, gint *offset) { + GBufferSegment *result; /* Trouvaille à retourner */ + BufferLineColumn i; /* Boucle de parcours */ + bool out; /* Présence de cible en bordure*/ - /* TODO : utiliser les arguments booléens */ + result = NULL; + *offset = 0; + + for (i = 0; i < BLC_COUNT && result == NULL; i++) + { + if (i < BLC_DISPLAY && !display[i]) continue; + + result = find_near_segment(&line->columns[i], target, dir, &out); + + printf(" [%d] near seg = %p (out ? %d)\n", i, result, out); + + if (result != NULL) break; + + if (out) + { + switch (dir) + { + case GDK_SCROLL_LEFT: + + gblfns_loop_left: + + /* On s'assure que la colonne précédente est visible */ + if (i <= BLC_DISPLAY) + for (; i > BLC_FIRST; i--) + if (display[i - 1]) break; + + if (i > BLC_FIRST) result = get_last_segment(&line->columns[i - 1]); + + printf(" [near] (%d) %p\n", i, result); + + if (result == NULL && i > BLC_FIRST) + { + printf(" [loop] %u -> %u\n", i, i - 1); + i--; + *offset -= (max_widths[i] + COL_MARGIN); + goto gblfns_loop_left; + } + + if (result != NULL) + *offset += g_buffer_segment_get_width(result) - max_widths[i - 1] - COL_MARGIN; + + break; - caret->x += (dir == GDK_SCROLL_RIGHT ? 10 : -10); + case GDK_SCROLL_RIGHT: - return true; + gblfns_loop_right: + /* On s'assure que la colonne suivante est visible */ + for (; (i + 1) < BLC_DISPLAY; i++) + if (display[i + 1]) break; - return false; + if ((i + 1) < BLC_COUNT) result = get_first_segment(&line->columns[i + 1]); + + + printf(" [near] (%d) %p\n", i, result); + + if (result == NULL && (i + 1) < BLC_COUNT) + { + printf(" [loop] %u -> %u\n", i, i + 1); + *offset += (max_widths[i] + COL_MARGIN); + printf(" -- add %d ~> %d\n", max_widths[i], *offset); + i++; + goto gblfns_loop_right; + } + + if (result != NULL) + { + *offset -= g_buffer_segment_get_width(target); + *offset += max_widths[i] + COL_MARGIN; + printf(" -- add %d ~> %d\n", max_widths[i], *offset); + } + + + /* + if (result != NULL) + *offset += max_widths[i + 1] - g_buffer_segment_get_width(result) + COL_MARGIN; + */ + + break; + + default: + break; + + } + + } + + } + + return result; } diff --git a/src/glibext/gbufferline.h b/src/glibext/gbufferline.h index 8e436d9..5a45fe2 100644 --- a/src/glibext/gbufferline.h +++ b/src/glibext/gbufferline.h @@ -69,6 +69,9 @@ typedef enum _BufferLineColumn } BufferLineColumn; +/* Première colonne de l'ensemble */ +#define BLC_FIRST BLC_PHYSICAL + /* Première colonne toujours affichée */ #define BLC_DISPLAY BLC_ASSEMBLY_HEAD @@ -96,11 +99,11 @@ void g_buffer_line_fill_for_instr(GBufferLine *, MemoryDataSize, MemoryDataSize, /* Ajoute un fragment de texte à une colonne de ligne. */ void g_buffer_line_add_segment(GBufferLine *, BufferLineColumn, GBufferSegment *) __attribute__ ((deprecated)); -/* Déplace le curseur au sein d'une vue de tampon. */ -bool g_buffer_line_move_caret(const GBufferLine *, GdkRectangle *, bool, GdkScrollDirection, bool, bool, bool); - /* Donne le segment présent à une abscisse donnée. */ -GBufferSegment *g_buffer_line_get_segment_at(const GBufferLine *, const gint [BLC_COUNT], gint *, bool); +GBufferSegment *g_buffer_line_get_segment_at(const GBufferLine *, const gint [BLC_COUNT], const bool *, gint *, GdkScrollDirection, bool); + +/* Fournit le segment voisin d'un autre segment identifié. */ +GBufferSegment *g_buffer_line_find_near_segment(const GBufferLine *, GBufferSegment *, const gint [BLC_COUNT], const bool *, GdkScrollDirection, gint *); /* Met en surbrillance des segments similaires. */ GSList *g_buffer_line_highlight_all_same_segments(const GBufferLine *, GSList *, const GBufferSegment *); diff --git a/src/glibext/gbuffersegment.c b/src/glibext/gbuffersegment.c index c96b092..0c31b9c 100644 --- a/src/glibext/gbuffersegment.c +++ b/src/glibext/gbuffersegment.c @@ -406,6 +406,70 @@ gint g_buffer_segment_get_caret_position(const GBufferSegment *segment, gint x) /****************************************************************************** * * * Paramètres : segment = fragment de texte à manipuler. * +* x = position du curseur à faire évoluer. [OUT] * +* ctrl = indique la demande d'un parcours rapide. * +* dir = direction du parcours. * +* * +* Description : Déplace le curseur au sein d'un segment de tampon. * +* * +* Retour : true si un déplacement a été effectué, false sinon. * +* * +* Remarques : - * +* * +******************************************************************************/ + +bool g_buffer_segment_move_caret(const GBufferSegment *segment, gint *x, bool ctrl, GdkScrollDirection dir) +{ + bool result; /* Bilan d'opération à renvoyer*/ + gint width; /* Largeur du segment */ + gint char_width; /* Largeur de police fixe */ + + result = false; + + width = g_buffer_segment_get_width(segment); + char_width = width / strlen(segment->text); + + if (dir == GDK_SCROLL_LEFT) + { + printf(">>>>> left ::: x=%d width=%d char=%d\n", *x, width, char_width); + + if (*x > width) *x = width + char_width; + + if (*x == 0) goto gbsmc_done; + + if (ctrl) *x = 0; + else *x = MAX(0, *x - char_width); + + result = true; + + } + + else if (dir == GDK_SCROLL_RIGHT) + { + + printf(">>>>> right ::: x=%d width=%d char=%d\n", *x, width, char_width); + + if (*x == width) goto gbsmc_done; + + if (ctrl) *x = width; + else *x = MIN(width, *x + char_width); + + result = true; + + } + + gbsmc_done: + + printf(">>>>> result ::: %d\n", result); + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : segment = fragment de texte à manipuler. * * style = style de rendu pour le segment. * * * * Description : Module l'apparence finale du composant. * diff --git a/src/glibext/gbuffersegment.h b/src/glibext/gbuffersegment.h index d570e89..bb82bba 100644 --- a/src/glibext/gbuffersegment.h +++ b/src/glibext/gbuffersegment.h @@ -120,6 +120,9 @@ gint g_buffer_segment_get_width(const GBufferSegment *); /* Fournit la position idéale pour un marqueur. */ gint g_buffer_segment_get_caret_position(const GBufferSegment *, gint); +/* Déplace le curseur au sein d'un segment de tampon. */ +bool g_buffer_segment_move_caret(const GBufferSegment *, gint *, bool, GdkScrollDirection); + /* Module l'apparence finale du composant. */ void g_buffer_segment_set_style(GBufferSegment *, SegRenderingStyle); diff --git a/src/glibext/gcodebuffer.c b/src/glibext/gcodebuffer.c index 1ea8f69..eab418e 100644 --- a/src/glibext/gcodebuffer.c +++ b/src/glibext/gcodebuffer.c @@ -24,6 +24,7 @@ #include "gcodebuffer.h" +#include <limits.h> #include <malloc.h> #include <string.h> @@ -123,10 +124,10 @@ static void g_code_buffer_class_init(GCodeBufferClass *); static void g_code_buffer_init(GCodeBuffer *); /* Convertit une adresse en indice de ligne. */ -static size_t _g_code_buffer_get_index_from_address(const GCodeBuffer *, vmpa_t, bool); +static size_t _g_code_buffer_get_index_from_address(const GCodeBuffer *, const vmpa2t *, bool); /* Convertit une adresse en indice de ligne. */ -static size_t g_code_buffer_get_index_from_address(GCodeBuffer *, vmpa_t, bool); +static size_t g_code_buffer_get_index_from_address(GCodeBuffer *, const vmpa2t *, bool); @@ -407,7 +408,7 @@ GCodeBuffer *g_code_buffer_new(BufferLineColumn main) * * ******************************************************************************/ -static size_t _g_code_buffer_get_index_from_address(const GCodeBuffer *buffer, vmpa_t addr, bool first) +static size_t _g_code_buffer_get_index_from_address(const GCodeBuffer *buffer, const vmpa2t *addr, bool first) { size_t result; /* Indice à retourner */ @@ -451,7 +452,7 @@ static size_t _g_code_buffer_get_index_from_address(const GCodeBuffer *buffer, v * * ******************************************************************************/ -static size_t g_code_buffer_get_index_from_address(GCodeBuffer *buffer, vmpa_t addr, bool first) +static size_t g_code_buffer_get_index_from_address(GCodeBuffer *buffer, const vmpa2t *addr, bool first) { size_t result; /* Indice à retourner */ @@ -1074,11 +1075,12 @@ gint g_buffer_view_get_height(const GBufferView *view) /****************************************************************************** * * -* Paramètres : view = vue de tampon à mettre à jour. * -* line = ligne correspondant à la position. * -* index = indice de cette même ligne dans le tampon. * -* x = abscisse de la zone principale à traiter. * -* caret = position du curseur à construire. [OUT] * +* Paramètres : view = vue de tampon à mettre à jour. * +* line = ligne correspondant à la position. * +* index = indice de cette même ligne dans le tampon. * +* x = abscisse de la zone principale à traiter. * +* display = règles d'affichage des colonnes modulables. * +* caret = position du curseur à construire. [OUT] * * * * Description : Calcule la position idéale de curseur pour un point donné. * * * @@ -1088,7 +1090,7 @@ gint g_buffer_view_get_height(const GBufferView *view) * * ******************************************************************************/ -const vmpa2t *g_buffer_view_compute_caret(GBufferView *view, GBufferLine *line, size_t index, gint x, GdkRectangle *caret) +const vmpa2t *g_buffer_view_compute_caret(GBufferView *view, GBufferLine *line, size_t index, gint x, const bool *display, GdkRectangle *caret) { gint tmp_x; /* Copie de travail modifiable */ GBufferSegment *segment; /* Segment visé par le pointeur*/ @@ -1099,9 +1101,16 @@ const vmpa2t *g_buffer_view_compute_caret(GBufferView *view, GBufferLine *line, tmp_x -= view->left_text; if (tmp_x < 0) return NULL; - segment = g_buffer_line_get_segment_at(line, view->max_widths, &tmp_x, true); + segment = g_buffer_line_get_segment_at(line, view->max_widths, display, &tmp_x, GDK_SCROLL_LEFT, true); + if (segment == NULL) printf(" -- no segment\n"); if (segment == NULL) return NULL; + printf("\n[BASE] tronc = %d reste = %d dernier = %d largeur = %d\n", + x - tmp_x, tmp_x, g_buffer_segment_get_caret_position(segment, tmp_x), + g_buffer_segment_get_width(segment)); + + printf(" '%s'\n", g_buffer_segment_get_text(segment)); + caret->x = (x - tmp_x) + g_buffer_segment_get_caret_position(segment, tmp_x); first = g_code_buffer_get_index_from_address(view->buffer, view->start, true); @@ -1110,20 +1119,147 @@ const vmpa2t *g_buffer_view_compute_caret(GBufferView *view, GBufferLine *line, caret->width = 2; caret->height = view->line_height; - return NULL;///g_buffer_line_get_address(line); + return get_mrange_addr(g_buffer_line_get_range(line)); } /****************************************************************************** * * -* Paramètres : view = vue de tampon à mettre à jour. * -* caret = position du curseur à faire évoluer. * -* ctrl = indique la demande d'un parcours rapide. * -* dir = direction du parcours. * -* phys = indique si les positions doivent être affichées. * -* virt = indique si les adresses doivent être affichées. * -* code = indique si le code binaire doit être affiché. * +* Paramètres : line = ligne à venir consulter. * +* 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. * +* * +* Description : Déplace le curseur au sein d'une vue de tampon. * +* * +* Retour : true si un déplacement a été effectué, false sinon. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static bool _g_buffer_view_move_caret(GBufferView *view, const GBufferLine *line, GdkRectangle *caret, bool ctrl, GdkScrollDirection dir, const bool *display) +{ + bool result; + + gint tmp_x; /* Copie de travail modifiable */ + GBufferSegment *segment; /* Segment visé par le pointeur*/ + size_t first; /* Première ligne intégrée */ + + gint ref_x; + + + gint offset; + + + + tmp_x = caret->x; + + tmp_x -= view->left_text; + if (tmp_x < 0) return false; + + segment = g_buffer_line_get_segment_at(line, view->max_widths, display, &tmp_x, dir, false); + + if (segment == NULL) printf(" ===== NO SEG...\n"); + + if (segment == NULL) return false; + + + printf(" ====== FIRST SEG :: %p ('%s')\n", segment, g_buffer_segment_get_text(segment)); + + + + ref_x = tmp_x; + + + + //if (dir == GDK_SCROLL_LEFT || dir == GDK_SCROLL_RIGHT) + result = g_buffer_segment_move_caret(segment, &tmp_x, ctrl, dir); + //else + //result = true; + + printf(" ====== MOVE 1 ? %d\n", result); + + + if (!result) + { + + + segment = g_buffer_line_find_near_segment(line, segment, view->max_widths, display, dir, &offset); + + + printf(" ====== NEAR SEG :: %p ('%s')\n", segment, segment ? g_buffer_segment_get_text(segment) : NULL); + + if (segment != NULL) + { + //tmp_x = /*ref_x + */g_buffer_segment_get_width(segment); + + + //ref_x = tmp_x; + ref_x = tmp_x = 0; + + + ref_x = 0; + tmp_x = offset; + + + result = true; + //result = g_buffer_segment_move_caret(segment, &tmp_x, ctrl, dir); + + /* + if (result) + caret->x -= COL_MARGIN; + */ + + printf(" ====== MOVE 2 ? %d (offset=%d)\n", result, offset); + + + } + + + } + + + if (result) + printf(" ====== NEW CARET: %d -> %d\n", caret->x, caret->x + (tmp_x - ref_x)); + else + printf(" ====== NO NEW CARET!\n"); + + + + if (result) + caret->x += (tmp_x - ref_x); + + + + return result; + + + //bool g_buffer_segment_move_caret(const GBufferSegment *segment, gint *x, bool ctrl, GdkScrollDirection dir) + + + + /* TODO : utiliser les arguments booléens */ + + caret->x += (dir == GDK_SCROLL_RIGHT ? 10 : -10); + + return true; + + + return false; + +} + + +/****************************************************************************** +* * +* Paramètres : view = vue de tampon à mettre à jour. * +* 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. * * * * Description : Déplace le curseur au sein d'une vue de tampon. * * * @@ -1133,9 +1269,12 @@ const vmpa2t *g_buffer_view_compute_caret(GBufferView *view, GBufferLine *line, * * ******************************************************************************/ -vmpa_t g_buffer_view_move_caret(GBufferView *view, GdkRectangle *caret, bool ctrl, GdkScrollDirection dir, bool phys, bool virt, bool code) +const vmpa2t *g_buffer_view_move_caret(GBufferView *view, GdkRectangle *caret, bool ctrl, GdkScrollDirection dir, const bool *display) { - bool result; /* Actualisation à renvoyer */ + vmpa2t *result; /* Actualisation à renvoyer */ + GBufferLine *line; /* Ligne sous le pointeur */ + + bool computed; /* Récursivité pris en compte */ gint lheight; /* Hauteur d'une ligne */ gint left_pos; /* Retour à la ligne */ @@ -1143,11 +1282,34 @@ vmpa_t g_buffer_view_move_caret(GBufferView *view, GdkRectangle *caret, bool ctr BufferLineColumn i; /* Boucle de parcours */ size_t first; /* Première ligne intégrée */ size_t last; /* Dernière ligne intégrée */ - GBufferLine *line; /* Ligne sous le pointeur */ - result = VMPA_INVALID; + size_t index; /* Indice de ligne de tampon */ + + + bool moved; /* Mémorisation d'une évolut° */ + + + + + + + gint tmp_x; /* Copie de travail modifiable */ + GBufferSegment *segment; /* Segment visé par le pointeur*/ + + + + result = NULL; computed = false; + + + line = g_buffer_view_find_line_at(view, caret->y, &index); + if (line == NULL) return NULL; + + + lheight = g_buffer_view_get_line_height(view); + + switch (dir) { case GDK_SCROLL_UP: @@ -1157,12 +1319,17 @@ vmpa_t g_buffer_view_move_caret(GBufferView *view, GdkRectangle *caret, bool ctr case GDK_SCROLL_LEFT: case GDK_SCROLL_RIGHT: left_pos = view->left_text; - if (phys) left_pos += view->max_widths[BLC_PHYSICAL] + COL_MARGIN; - if (virt) left_pos += view->max_widths[BLC_VIRTUAL] + COL_MARGIN; - if (code) left_pos += view->max_widths[BLC_BINARY] + COL_MARGIN; + if (display[BLC_PHYSICAL]) left_pos += view->max_widths[BLC_PHYSICAL] + COL_MARGIN; + if (display[BLC_VIRTUAL]) left_pos += view->max_widths[BLC_VIRTUAL] + COL_MARGIN; + if (display[BLC_BINARY]) left_pos += view->max_widths[BLC_BINARY] + COL_MARGIN; right_pos = left_pos; for (i = BLC_ASSEMBLY_HEAD; i < BLC_COUNT; i++) right_pos += view->max_widths[i] + COL_MARGIN; + + + + left_pos = view->left_text; + break; default: /* GDK_SCROLL_SMOOTH */ break; @@ -1171,58 +1338,56 @@ vmpa_t g_buffer_view_move_caret(GBufferView *view, GdkRectangle *caret, bool ctr first = g_code_buffer_get_index_from_address(view->buffer, view->start, true); last = g_code_buffer_get_index_from_address(view->buffer, view->end, false); + first = 0; + switch (dir) { case GDK_SCROLL_UP: - result = (caret->y >= (first * lheight)); - if (result) - caret->y -= lheight; + + if (index > first) + { + line = view->buffer->lines[index - 1]; + result = g_buffer_view_compute_caret(view, line, index - 1, caret->x, display, caret); + } + break; case GDK_SCROLL_DOWN: - result = ((caret->y + lheight) < (last * lheight)); - if (result) - caret->y += lheight; + + if (index < last) + { + line = view->buffer->lines[index + 1]; + result = g_buffer_view_compute_caret(view, line, index + 1, caret->x, display, caret); + } + break; case GDK_SCROLL_LEFT: - line = g_buffer_view_find_line_at(view, caret->y, NULL); + + line = g_buffer_view_find_line_at(view, caret->y, &index); if (line == NULL) break; - result = g_buffer_line_move_caret(line, caret, ctrl, GDK_SCROLL_LEFT, phys, virt, code); + moved = _g_buffer_view_move_caret(view, line, caret, ctrl, GDK_SCROLL_LEFT, display); - if (caret->x < left_pos) + if (!moved && index > first) { - caret->x = right_pos; - - result = g_buffer_view_move_caret(view, caret, ctrl, GDK_SCROLL_UP, phys, virt, code); - - if (result == VMPA_INVALID) - caret->x = left_pos; - else - computed = true; - + line = view->buffer->lines[index - 1]; + result = g_buffer_view_compute_caret(view, line, index - 1, INT_MAX, display, caret); } break; case GDK_SCROLL_RIGHT: - line = g_buffer_view_find_line_at(view, caret->y, NULL); + + line = g_buffer_view_find_line_at(view, caret->y, &index); if (line == NULL) break; - result = g_buffer_line_move_caret(line, caret, ctrl, GDK_SCROLL_RIGHT, phys, virt, code); + moved = _g_buffer_view_move_caret(view, line, caret, ctrl, GDK_SCROLL_RIGHT, display); - if (!result) + if (!moved && index < last) { - caret->x = left_pos; - - result = g_buffer_view_move_caret(view, caret, ctrl, GDK_SCROLL_DOWN, phys, virt, code); - - if (result == VMPA_INVALID) - caret->x = right_pos; - else - computed = true; - + line = view->buffer->lines[index + 1]; + result = g_buffer_view_compute_caret(view, line, index + 1, left_pos, display, caret); } break; @@ -1232,8 +1397,16 @@ vmpa_t g_buffer_view_move_caret(GBufferView *view, GdkRectangle *caret, bool ctr } + + printf(" --- CARET --- moved = %d index = %d result = %p\n", + moved, index, result); + + + + /* if (result && !computed) - /*result = g_buffer_view_compute_caret(view, caret->x, caret->y, caret, NULL)*/; + result = g_buffer_view_compute_caret(view, caret->x, caret->y, caret, display, NULL); + */ return result; @@ -1292,6 +1465,7 @@ bool g_buffer_view_unhighlight_segments(GBufferView *view) void g_buffer_view_highlight_segments(GBufferView *view, gint x, gint y) { +#if 0 /* FIXME : inclusion des champs adresses/code */ GBufferLine *line; /* Ligne sous le pointeur */ GBufferSegment *segment; /* Segment visé par le pointeur*/ bool need_redraw; /* Besoin d'actualisation ? */ @@ -1305,7 +1479,7 @@ void g_buffer_view_highlight_segments(GBufferView *view, gint x, gint y) x -= view->left_text; if (x < 0) return; - segment = g_buffer_line_get_segment_at(line, view->max_widths, &x, false); + segment = g_buffer_line_get_segment_at(line, view->max_widths, &x, GDK_SCROLL_LEFT, false); printf(" ... seg @%d ? %p\n", x, segment); if (segment == NULL) return; @@ -1330,7 +1504,7 @@ void g_buffer_view_highlight_segments(GBufferView *view, gint x, gint y) if (need_redraw) g_signal_emit_by_name(view, "need-redraw"); - +#endif } diff --git a/src/glibext/gcodebuffer.h b/src/glibext/gcodebuffer.h index 1387eb9..ece7c59 100644 --- a/src/glibext/gcodebuffer.h +++ b/src/glibext/gcodebuffer.h @@ -129,10 +129,10 @@ gint g_buffer_view_get_width(GBufferView *, const bool *); gint g_buffer_view_get_height(const GBufferView *); /* Calcule la position idéale de curseur pour un point donné. */ -const vmpa2t *g_buffer_view_compute_caret(GBufferView *, GBufferLine *, size_t, gint, GdkRectangle *); +const vmpa2t *g_buffer_view_compute_caret(GBufferView *, GBufferLine *, size_t, gint, const bool *, GdkRectangle *); /* Déplace le curseur au sein d'une vue de tampon. */ -vmpa_t g_buffer_view_move_caret(GBufferView *, GdkRectangle *, bool, GdkScrollDirection, bool, bool, bool); +const vmpa2t *g_buffer_view_move_caret(GBufferView *, GdkRectangle *, bool, GdkScrollDirection, const bool *); /* Supprime toute mise en évidence de segments. */ bool g_buffer_view_unhighlight_segments(GBufferView *); |