From bea3337108fa5b59b8f6fdbe016d5ed6a6300bc6 Mon Sep 17 00:00:00 2001
From: Cyrille Bagard <nocbos@gmail.com>
Date: Sat, 14 Jul 2018 13:48:54 +0200
Subject: Begun to switch to abstract locations in internal rendering buffers.
---
plugins/pychrysalide/glibext/linegen.c | 12 +++--
src/analysis/db/items/comment.c | 28 ++++++----
src/arch/instruction.c | 28 ++++++----
src/format/symbol.c | 28 ++++++----
src/glibext/gbinarycursor.c | 41 +++++++++++++--
src/glibext/gbinportion.c | 28 ++++++----
src/glibext/gbuffercache.c | 96 +++++++++++++++++++++++-----------
src/glibext/gbuffercache.h | 2 +-
src/glibext/gbufferview.c | 30 +++++------
src/glibext/gbufferview.h | 4 +-
src/glibext/generators/prologue.c | 32 ++++++++----
src/glibext/generators/rborder.c | 32 ++++++++----
src/glibext/glinecursor-int.h | 6 +++
src/glibext/glinecursor.c | 29 ++++++++++
src/glibext/glinecursor.h | 3 ++
src/glibext/linegen-int.h | 4 +-
src/glibext/linegen.c | 12 ++---
src/glibext/linegen.h | 5 +-
src/gtkext/gtkbufferdisplay.c | 24 +++++++--
19 files changed, 314 insertions(+), 130 deletions(-)
diff --git a/plugins/pychrysalide/glibext/linegen.c b/plugins/pychrysalide/glibext/linegen.c
index b6aad6b..8368548 100644
--- a/plugins/pychrysalide/glibext/linegen.c
+++ b/plugins/pychrysalide/glibext/linegen.c
@@ -43,10 +43,10 @@
static PyObject *py_line_generator_count_lines(PyObject *, PyObject *);
/* Retrouve l'emplacement correspondant à une position donnée. */
-static PyObject *py_line_generator_compute_addr(PyObject *, PyObject *);
+//static PyObject *py_line_generator_compute_addr(PyObject *, PyObject *);
/* Détermine si le conteneur s'inscrit dans une plage donnée. */
-static PyObject *py_line_generator_contains_addr(PyObject *, PyObject *);
+//static PyObject *py_line_generator_contains_addr(PyObject *, PyObject *);
/* Renseigne sur les propriétés liées à un générateur. */
static PyObject *py_line_generator_get_flags(PyObject *, PyObject *);
@@ -98,7 +98,7 @@ static PyObject *py_line_generator_count_lines(PyObject *self, PyObject *args)
* Remarques : - *
* *
******************************************************************************/
-
+#if 0
static PyObject *py_line_generator_compute_addr(PyObject *self, PyObject *args)
{
PyObject *result; /* Localisation à retourner */
@@ -121,6 +121,7 @@ static PyObject *py_line_generator_compute_addr(PyObject *self, PyObject *args)
return result;
}
+#endif
/******************************************************************************
@@ -135,7 +136,7 @@ static PyObject *py_line_generator_compute_addr(PyObject *self, PyObject *args)
* Remarques : - *
* *
******************************************************************************/
-
+#if 0
static PyObject *py_line_generator_contains_addr(PyObject *self, PyObject *args)
{
GLineGenerator *generator; /* Version native */
@@ -158,6 +159,7 @@ static PyObject *py_line_generator_contains_addr(PyObject *self, PyObject *args)
Py_RETURN_NONE;
}
+#endif
/******************************************************************************
@@ -329,6 +331,7 @@ PyTypeObject *get_python_line_generator_type(void)
METH_NOARGS,
"count_lines($self, /)\n--\n\nCount the number of lines which can be displayed."
},
+#if 0
{
"compute_addr", py_line_generator_compute_addr,
METH_VARARGS,
@@ -339,6 +342,7 @@ PyTypeObject *get_python_line_generator_type(void)
METH_VARARGS,
"contains_addr($self, addr, index, repeat, /)\n--\n\nTell if the generator contains an address."
},
+#endif
{
"get_flags", py_line_generator_get_flags,
METH_VARARGS,
diff --git a/src/analysis/db/items/comment.c b/src/analysis/db/items/comment.c
index 59fc6b7..394abe2 100644
--- a/src/analysis/db/items/comment.c
+++ b/src/analysis/db/items/comment.c
@@ -38,6 +38,7 @@
#include "../../human/asm/lang.h"
#include "../../../common/array.h"
#include "../../../common/extstr.h"
+#include "../../../glibext/gbinarycursor.h"
#include "../../../glibext/linegen-int.h"
@@ -133,10 +134,10 @@ static void g_db_comment_update_count_lines(GDbComment *);
static size_t g_db_comment_count_lines(const GDbComment *);
/* Retrouve l'emplacement correspondant à une position donnée. */
-static void g_db_comment_compute_addr(const GDbComment *, gint, vmpa2t *, size_t, size_t);
+static void g_db_comment_compute_cursor(const GDbComment *, gint, size_t, size_t, GLineCursor **);
/* Détermine si le conteneur s'inscrit dans une plage donnée. */
-static int g_db_comment_contains_addr(const GDbComment *, const vmpa2t *, size_t, size_t);
+static int g_db_comment_contains_cursor(const GDbComment *, size_t, size_t, const GLineCursor *);
/* Renseigne sur les propriétés liées à un générateur. */
static BufferLineFlags g_db_comment_get_flags(const GDbComment *, size_t, size_t);
@@ -276,8 +277,8 @@ static void g_db_comment_init(GDbComment *comment)
static void g_db_comment_interface_init(GLineGeneratorInterface *iface)
{
iface->count = (linegen_count_lines_fc)g_db_comment_count_lines;
- iface->compute = (linegen_compute_fc)g_db_comment_compute_addr;
- iface->contains = (linegen_contains_fc)g_db_comment_contains_addr;
+ iface->compute = (linegen_compute_fc)g_db_comment_compute_cursor;
+ iface->contains = (linegen_contains_fc)g_db_comment_contains_cursor;
iface->get_flags = (linegen_get_flags_fc)g_db_comment_get_flags;
iface->print = (linegen_print_fc)g_db_comment_print;
@@ -1310,9 +1311,9 @@ static size_t g_db_comment_count_lines(const GDbComment *comment)
* *
* Paramètres : comment = générateur à consulter. *
* x = position géographique sur la ligne concernée. *
-* addr = position en mémoire à analyser. *
* index = indice de cette même ligne dans le tampon global. *
* repeat = indice d'utilisations successives du générateur. *
+* cursor = emplacement à constituer. [OUT] *
* *
* Description : Retrouve l'emplacement correspondant à une position donnée. *
* *
@@ -1322,9 +1323,11 @@ static size_t g_db_comment_count_lines(const GDbComment *comment)
* *
******************************************************************************/
-static void g_db_comment_compute_addr(const GDbComment *comment, gint x, vmpa2t *addr, size_t index, size_t repeat)
+static void g_db_comment_compute_cursor(const GDbComment *comment, gint x, size_t index, size_t repeat, GLineCursor **cursor)
{
- copy_vmpa(addr, &comment->addr);
+ *cursor = g_binary_cursor_new();
+
+ g_binary_cursor_update(G_BINARY_CURSOR(*cursor), &comment->addr);
}
@@ -1332,9 +1335,9 @@ static void g_db_comment_compute_addr(const GDbComment *comment, gint x, vmpa2t
/******************************************************************************
* *
* Paramètres : comment = générateur à consulter. *
-* addr = position en mémoire à analyser. *
* index = indice de cette même ligne dans le tampon global. *
* repeat = indice d'utilisations successives du générateur. *
+* cursor = emplacement à analyser. *
* *
* Description : Détermine si le conteneur s'inscrit dans une plage donnée. *
* *
@@ -1344,11 +1347,16 @@ static void g_db_comment_compute_addr(const GDbComment *comment, gint x, vmpa2t
* *
******************************************************************************/
-static int g_db_comment_contains_addr(const GDbComment *comment, const vmpa2t *addr, size_t index, size_t repeat)
+static int g_db_comment_contains_cursor(const GDbComment *comment, size_t index, size_t repeat, const GLineCursor *cursor)
{
int result; /* Conclusion à retourner */
+ vmpa2t addr; /* Autre emplacement à comparer*/
+
+ assert(G_IS_BINARY_CURSOR(cursor));
+
+ g_binary_cursor_get_info(G_BINARY_CURSOR(cursor), &addr);
- result = cmp_vmpa(addr, &comment->addr);
+ result = cmp_vmpa(&addr, &comment->addr);
return result;
diff --git a/src/arch/instruction.c b/src/arch/instruction.c
index 212b5b5..1fe83b5 100644
--- a/src/arch/instruction.c
+++ b/src/arch/instruction.c
@@ -31,6 +31,7 @@
#include "instruction-int.h"
#include "storage.h"
+#include "../glibext/gbinarycursor.h"
#include "../glibext/linegen-int.h"
@@ -70,10 +71,10 @@ static bool g_arch_instruction_serialize(GArchInstruction *, GAsmStorage *, pack
static size_t g_arch_instruction_count_lines(const GArchInstruction *);
/* Retrouve l'emplacement correspondant à une position donnée. */
-static void g_arch_instruction_compute_addr(const GArchInstruction *, gint, vmpa2t *, size_t, size_t);
+static void g_arch_instruction_compute_cursor(const GArchInstruction *, gint, size_t, size_t, GLineCursor **);
/* Détermine si le conteneur s'inscrit dans une plage donnée. */
-static int g_arch_instruction_contains_addr(const GArchInstruction *, const vmpa2t *, size_t, size_t);
+static int g_arch_instruction_contains_cursor(const GArchInstruction *, size_t, size_t, const GLineCursor *);
/* Renseigne sur les propriétés liées à un générateur. */
static BufferLineFlags g_arch_instruction_get_flags2(const GArchInstruction *, size_t, size_t);
@@ -160,8 +161,8 @@ static void g_arch_instruction_init(GArchInstruction *instr)
static void g_arch_instruction_generator_interface_init(GLineGeneratorInterface *iface)
{
iface->count = (linegen_count_lines_fc)g_arch_instruction_count_lines;
- iface->compute = (linegen_compute_fc)g_arch_instruction_compute_addr;
- iface->contains = (linegen_contains_fc)g_arch_instruction_contains_addr;
+ iface->compute = (linegen_compute_fc)g_arch_instruction_compute_cursor;
+ iface->contains = (linegen_contains_fc)g_arch_instruction_contains_cursor;
iface->get_flags = (linegen_get_flags_fc)g_arch_instruction_get_flags2;
iface->print = (linegen_print_fc)g_arch_instruction_print;
@@ -1452,9 +1453,9 @@ static size_t g_arch_instruction_count_lines(const GArchInstruction *instr)
* *
* Paramètres : instr = générateur à consulter. *
* x = position géographique sur la ligne concernée. *
-* addr = position en mémoire à analyser. *
* index = indice de cette même ligne dans le tampon global. *
* repeat = indice d'utilisations successives du générateur. *
+* cursor = emplacement à constituer. [OUT] *
* *
* Description : Retrouve l'emplacement correspondant à une position donnée. *
* *
@@ -1464,9 +1465,11 @@ static size_t g_arch_instruction_count_lines(const GArchInstruction *instr)
* *
******************************************************************************/
-static void g_arch_instruction_compute_addr(const GArchInstruction *instr, gint x, vmpa2t *addr, size_t index, size_t repeat)
+static void g_arch_instruction_compute_cursor(const GArchInstruction *instr, gint x, size_t index, size_t repeat, GLineCursor **cursor)
{
- copy_vmpa(addr, get_mrange_addr(&instr->range));
+ *cursor = g_binary_cursor_new();
+
+ g_binary_cursor_update(G_BINARY_CURSOR(*cursor), get_mrange_addr(&instr->range));
}
@@ -1474,9 +1477,9 @@ static void g_arch_instruction_compute_addr(const GArchInstruction *instr, gint
/******************************************************************************
* *
* Paramètres : instr = générateur à consulter. *
-* addr = position en mémoire à analyser. *
* index = indice de cette même ligne dans le tampon global. *
* repeat = indice d'utilisations successives du générateur. *
+* cursor = emplacement à analyser. *
* *
* Description : Détermine si le conteneur s'inscrit dans une plage donnée. *
* *
@@ -1486,11 +1489,16 @@ static void g_arch_instruction_compute_addr(const GArchInstruction *instr, gint
* *
******************************************************************************/
-static int g_arch_instruction_contains_addr(const GArchInstruction *instr, const vmpa2t *addr, size_t index, size_t repeat)
+static int g_arch_instruction_contains_cursor(const GArchInstruction *instr, size_t index, size_t repeat, const GLineCursor *cursor)
{
int result; /* Conclusion à retourner */
+ vmpa2t addr; /* Autre emplacement à comparer*/
+
+ assert(G_IS_BINARY_CURSOR(cursor));
+
+ g_binary_cursor_get_info(G_BINARY_CURSOR(cursor), &addr);
- result = cmp_mrange_with_vmpa(&instr->range, addr);
+ result = cmp_mrange_with_vmpa(&instr->range, &addr);
return result;
diff --git a/src/format/symbol.c b/src/format/symbol.c
index 3f8e808..9c8a6e0 100644
--- a/src/format/symbol.c
+++ b/src/format/symbol.c
@@ -30,6 +30,7 @@
#include "symbol-int.h"
+#include "../glibext/gbinarycursor.h"
#include "../glibext/linegen-int.h"
@@ -61,10 +62,10 @@ static void g_binary_symbol_finalize(GBinSymbol *);
static size_t g_binary_symbol_count_lines(const GBinSymbol *);
/* Retrouve l'emplacement correspondant à une position donnée. */
-static void g_binary_symbol_compute_addr(const GBinSymbol *, gint, vmpa2t *, size_t, size_t);
+static void g_binary_symbol_compute_cursor(const GBinSymbol *, gint, size_t, size_t, GLineCursor **);
/* Détermine si le conteneur s'inscrit dans une plage donnée. */
-static int g_binary_symbol_contains_addr(const GBinSymbol *, const vmpa2t *, size_t, size_t);
+static int g_binary_symbol_contains_cursor(const GBinSymbol *, size_t, size_t, const GLineCursor *);
/* Renseigne sur les propriétés liées à un générateur. */
static BufferLineFlags g_binary_symbol_get_flags(const GBinSymbol *, size_t, size_t);
@@ -144,8 +145,8 @@ static void g_binary_symbol_init(GBinSymbol *symbol)
static void g_binary_symbol_interface_init(GLineGeneratorInterface *iface)
{
iface->count = (linegen_count_lines_fc)g_binary_symbol_count_lines;
- iface->compute = (linegen_compute_fc)g_binary_symbol_compute_addr;
- iface->contains = (linegen_contains_fc)g_binary_symbol_contains_addr;
+ iface->compute = (linegen_compute_fc)g_binary_symbol_compute_cursor;
+ iface->contains = (linegen_contains_fc)g_binary_symbol_contains_cursor;
iface->get_flags = (linegen_get_flags_fc)g_binary_symbol_get_flags;
iface->print = (linegen_print_fc)g_binary_symbol_print;
@@ -503,9 +504,9 @@ static size_t g_binary_symbol_count_lines(const GBinSymbol *symbol)
* *
* Paramètres : symbol = générateur à consulter. *
* x = position géographique sur la ligne concernée. *
-* addr = position en mémoire à analyser. *
* index = indice de cette même ligne dans le tampon global. *
* repeat = indice d'utilisations successives du générateur. *
+* cursor = emplacement à constituer. [OUT] *
* *
* Description : Retrouve l'emplacement correspondant à une position donnée. *
* *
@@ -515,9 +516,11 @@ static size_t g_binary_symbol_count_lines(const GBinSymbol *symbol)
* *
******************************************************************************/
-void g_binary_symbol_compute_addr(const GBinSymbol *symbol, gint x, vmpa2t *addr, size_t index, size_t repeat)
+void g_binary_symbol_compute_cursor(const GBinSymbol *symbol, gint x, size_t index, size_t repeat, GLineCursor **cursor)
{
- copy_vmpa(addr, get_mrange_addr(&symbol->range));
+ *cursor = g_binary_cursor_new();
+
+ g_binary_cursor_update(G_BINARY_CURSOR(*cursor), get_mrange_addr(&symbol->range));
}
@@ -525,9 +528,9 @@ void g_binary_symbol_compute_addr(const GBinSymbol *symbol, gint x, vmpa2t *addr
/******************************************************************************
* *
* Paramètres : symbol = générateur à consulter. *
-* addr = position en mémoire à analyser. *
* index = indice de cette même ligne dans le tampon global. *
* repeat = indice d'utilisations successives du générateur. *
+* cursor = emplacement à analyser. *
* *
* Description : Détermine si le conteneur s'inscrit dans une plage donnée. *
* *
@@ -537,9 +540,14 @@ void g_binary_symbol_compute_addr(const GBinSymbol *symbol, gint x, vmpa2t *addr
* *
******************************************************************************/
-static int g_binary_symbol_contains_addr(const GBinSymbol *symbol, const vmpa2t *addr, size_t index, size_t repeat)
+static int g_binary_symbol_contains_cursor(const GBinSymbol *symbol, size_t index, size_t repeat, const GLineCursor *cursor)
{
int result; /* Conclusion à retourner */
+ vmpa2t addr; /* Autre emplacement à comparer*/
+
+ assert(G_IS_BINARY_CURSOR(cursor));
+
+ g_binary_cursor_get_info(G_BINARY_CURSOR(cursor), &addr);
/**
* En tant que générateur, le symbole ne couvre qu'une ou plusieurs lignes
@@ -552,7 +560,7 @@ static int g_binary_symbol_contains_addr(const GBinSymbol *symbol, const vmpa2t
*
*/
- result = cmp_vmpa(addr, get_mrange_addr(&symbol->range));
+ result = cmp_vmpa(&addr, get_mrange_addr(&symbol->range));
return result;
diff --git a/src/glibext/gbinarycursor.c b/src/glibext/gbinarycursor.c
index 3bd7199..470022c 100644
--- a/src/glibext/gbinarycursor.c
+++ b/src/glibext/gbinarycursor.c
@@ -24,11 +24,14 @@
#include "gbinarycursor.h"
+#include "glinecursor-int.h"
+
+
/* Suivi de positions dans un panneau de chargement (instance) */
struct _GBinaryCursor
{
- GObject parent; /* A laisser en premier */
+ GLineCursor parent; /* A laisser en premier */
vmpa2t addr; /* Position mémoire du curseur */
@@ -37,7 +40,7 @@ struct _GBinaryCursor
/* Suivi de positions dans un panneau de chargement (classe) */
struct _GBinaryCursorClass
{
- GObjectClass parent; /* A laisser en premier */
+ GLineCursorClass parent; /* A laisser en premier */
};
@@ -54,10 +57,13 @@ static void g_binary_cursor_dispose(GBinaryCursor *);
/* Procède à la libération totale de la mémoire. */
static void g_binary_cursor_finalize(GBinaryCursor *);
+/* Compare deux suivis d'emplacements. */
+static int g_binary_cursor_compare(const GBinaryCursor *, const GBinaryCursor *);
+
/* Détermine le type du gestionnaire de largeurs associées aux lignes. */
-G_DEFINE_TYPE(GBinaryCursor, g_binary_cursor, G_TYPE_OBJECT);
+G_DEFINE_TYPE(GBinaryCursor, g_binary_cursor, G_TYPE_LINE_CURSOR);
/******************************************************************************
@@ -75,12 +81,17 @@ G_DEFINE_TYPE(GBinaryCursor, g_binary_cursor, G_TYPE_OBJECT);
static void g_binary_cursor_class_init(GBinaryCursorClass *class)
{
GObjectClass *object; /* Autre version de la classe */
+ GLineCursorClass *line; /* Version parente de la classe*/
object = G_OBJECT_CLASS(class);
object->dispose = (GObjectFinalizeFunc/* ! */)g_binary_cursor_dispose;
object->finalize = (GObjectFinalizeFunc)g_binary_cursor_finalize;
+ line = G_LINE_CURSOR_CLASS(class);
+
+ line->compare = (compare_cursor_fc)g_binary_cursor_compare;
+
}
@@ -166,6 +177,30 @@ GLineCursor *g_binary_cursor_new(void)
/******************************************************************************
* *
+* Paramètres : cursor = premier suivi d'emplacement à comparer. *
+* other = second suivi d'emplacement à comparer. *
+* *
+* Description : Compare deux suivis d'emplacements. *
+* *
+* Retour : Bilan de la comparaison. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static int g_binary_cursor_compare(const GBinaryCursor *cursor, const GBinaryCursor *other)
+{
+ int result; /* Bilan à renvoyer */
+
+ result = cmp_vmpa(&cursor->addr, &other->addr);
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
* Paramètres : cursor = suivi de positions à mettre à jour. *
* addr = emplacement dans le binaire visé. *
* *
diff --git a/src/glibext/gbinportion.c b/src/glibext/gbinportion.c
index f99a7cc..2ffe253 100644
--- a/src/glibext/gbinportion.c
+++ b/src/glibext/gbinportion.c
@@ -37,6 +37,7 @@
#include "../analysis/human/asm/lang.h" // TODO : REMME -> format !
#include "../common/extstr.h"
#include "../common/sort.h"
+#include "../glibext/gbinarycursor.h"
#include "../glibext/linegen-int.h"
@@ -102,10 +103,10 @@ static bool g_binary_portion_compute_sub_area(const GBinPortion *, phys_t, const
static size_t g_binary_portion_count_lines(const GBinPortion *);
/* Retrouve l'emplacement correspondant à une position donnée. */
-static void g_binary_portion_compute_addr(const GBinPortion *, gint, vmpa2t *, size_t, size_t);
+static void g_binary_portion_compute_cursor(const GBinPortion *, gint, size_t, size_t, GLineCursor **);
/* Détermine si le conteneur s'inscrit dans une plage donnée. */
-static int g_binary_portion_contains_addr(const GBinPortion *, const vmpa2t *, size_t, size_t);
+static int g_binary_portion_contains_cursor(const GBinPortion *, size_t, size_t, const GLineCursor *);
/* Renseigne sur les propriétés liées à un générateur. */
static BufferLineFlags g_binary_portion_get_flags(const GBinPortion *, size_t, size_t);
@@ -202,8 +203,8 @@ static void g_binary_portion_init(GBinPortion *portion)
static void g_binary_portion_interface_init(GLineGeneratorInterface *iface)
{
iface->count = (linegen_count_lines_fc)g_binary_portion_count_lines;
- iface->compute = (linegen_compute_fc)g_binary_portion_compute_addr;
- iface->contains = (linegen_contains_fc)g_binary_portion_contains_addr;
+ iface->compute = (linegen_compute_fc)g_binary_portion_compute_cursor;
+ iface->contains = (linegen_contains_fc)g_binary_portion_contains_cursor;
iface->get_flags = (linegen_get_flags_fc)g_binary_portion_get_flags;
iface->print = (linegen_print_fc)g_binary_portion_print;
@@ -1040,9 +1041,9 @@ static size_t g_binary_portion_count_lines(const GBinPortion *portion)
* *
* Paramètres : portion = générateur à consulter. *
* x = position géographique sur la ligne concernée. *
-* addr = position en mémoire à analyser. *
* index = indice de cette même ligne dans le tampon global. *
* repeat = indice d'utilisations successives du générateur. *
+* cursor = emplacement à constituer. [OUT] *
* *
* Description : Retrouve l'emplacement correspondant à une position donnée. *
* *
@@ -1052,9 +1053,11 @@ static size_t g_binary_portion_count_lines(const GBinPortion *portion)
* *
******************************************************************************/
-static void g_binary_portion_compute_addr(const GBinPortion *portion, gint x, vmpa2t *addr, size_t index, size_t repeat)
+static void g_binary_portion_compute_cursor(const GBinPortion *portion, gint x, size_t index, size_t repeat, GLineCursor **cursor)
{
- copy_vmpa(addr, get_mrange_addr(&portion->range));
+ *cursor = g_binary_cursor_new();
+
+ g_binary_cursor_update(G_BINARY_CURSOR(*cursor), get_mrange_addr(&portion->range));
}
@@ -1062,9 +1065,9 @@ static void g_binary_portion_compute_addr(const GBinPortion *portion, gint x, vm
/******************************************************************************
* *
* Paramètres : portion = générateur à consulter. *
-* addr = position en mémoire à analyser. *
* index = indice de cette même ligne dans le tampon global. *
* repeat = indice d'utilisations successives du générateur. *
+* cursor = emplacement à analyser. *
* *
* Description : Détermine si le conteneur s'inscrit dans une plage donnée. *
* *
@@ -1074,11 +1077,16 @@ static void g_binary_portion_compute_addr(const GBinPortion *portion, gint x, vm
* *
******************************************************************************/
-static int g_binary_portion_contains_addr(const GBinPortion *portion, const vmpa2t *addr, size_t index, size_t repeat)
+static int g_binary_portion_contains_cursor(const GBinPortion *portion, size_t index, size_t repeat, const GLineCursor *cursor)
{
int result; /* Conclusion à retourner */
+ vmpa2t addr; /* Autre emplacement à comparer*/
+
+ assert(G_IS_BINARY_CURSOR(cursor));
+
+ g_binary_cursor_get_info(G_BINARY_CURSOR(cursor), &addr);
- result = cmp_vmpa(addr, get_mrange_addr(&portion->range));
+ result = cmp_vmpa(&addr, get_mrange_addr(&portion->range));
return result;
diff --git a/src/glibext/gbuffercache.c b/src/glibext/gbuffercache.c
index 66ecf27..a64ec68 100644
--- a/src/glibext/gbuffercache.c
+++ b/src/glibext/gbuffercache.c
@@ -29,6 +29,7 @@
#include <stdlib.h>
+#include "gbinarycursor.h" // REMME
#include "chrysamarshal.h"
@@ -78,7 +79,7 @@ static void extend_cache_info(cache_info *, GLineGenerator *);
static void remove_from_cache_info(cache_info *, GLineGenerator *);
/* Retrouve l'emplacement correspondant à une position de ligne. */
-static void get_cache_info_addr(const cache_info *, size_t, gint, vmpa2t *);
+static void get_cache_info_cursor(const cache_info *, size_t, gint, GLineCursor **);
/* Suivit les variations du compteur de références d'une ligne. */
static void on_line_ref_toggle(cache_info *, GBufferLine *, gboolean);
@@ -352,10 +353,10 @@ static void remove_from_cache_info(cache_info *info, GLineGenerator *generator)
/******************************************************************************
* *
-* Paramètres : info = informations sur une ligne à venir consulter. *
-* index = indice de la ligne visée par la consultation. *
-* x = position géographique sur la ligne concernée. *
-* addr = adresse à renseigner. [OUT] *
+* Paramètres : info = informations sur une ligne à venir consulter. *
+* index = indice de la ligne visée par la consultation. *
+* x = position géographique sur la ligne concernée. *
+* cursor = emplacement à constituer. [OUT] *
* *
* Description : Retrouve l'emplacement correspondant à une position de ligne.*
* *
@@ -365,7 +366,7 @@ static void remove_from_cache_info(cache_info *info, GLineGenerator *generator)
* *
******************************************************************************/
-static void get_cache_info_addr(const cache_info *info, size_t index, gint x, vmpa2t *addr)
+static void get_cache_info_cursor(const cache_info *info, size_t index, gint x, GLineCursor **cursor)
{
const generator_link *generator; /* Générateur retenu */
@@ -374,7 +375,7 @@ static void get_cache_info_addr(const cache_info *info, size_t index, gint x, vm
else
generator = &info->generators[0];
- g_line_generator_compute_addr(generator->instance, x, addr, index, generator->repeat);
+ g_line_generator_compute_cursor(generator->instance, x, index, generator->repeat, cursor);
}
@@ -867,8 +868,9 @@ static size_t g_buffer_cache_compute_repetition(GBufferCache *cache, size_t inde
void g_buffer_cache_insert_at(GBufferCache *cache, size_t index, GLineGenerator *generator, bool before, bool after)
{
#ifndef NDEBUG
- vmpa2t gen_addr; /* Position du générateur */
- vmpa2t line_addr; /* Position de la ligne */
+ GLineCursor *gen_cursor; /* Position du générateur */
+ GLineCursor *line_cursor; /* Position de la ligne */
+ int ret; /* Bilan de comparaison */
#endif
size_t needed; /* Emplacements nécessaires */
size_t i; /* Boucle de parcours */
@@ -879,14 +881,19 @@ void g_buffer_cache_insert_at(GBufferCache *cache, size_t index, GLineGenerator
#ifndef NDEBUG
- g_line_generator_compute_addr(generator, 0, &gen_addr, index, 0);
+ g_line_generator_compute_cursor(generator, 0, index, 0, &gen_cursor);
+
+ get_cache_info_cursor(&cache->lines[index], index, 0, &line_cursor);
+
+ ret = g_line_cursor_compare(gen_cursor, line_cursor);
- get_cache_info_addr(&cache->lines[index], index, 0, &line_addr);
+ g_object_unref(G_OBJECT(gen_cursor));
+ g_object_unref(G_OBJECT(line_cursor));
///////////////////////////////////////
- if (cmp_vmpa(&gen_addr, &line_addr) != 0) return;
+ if (ret != 0) return;
- assert(cmp_vmpa(&gen_addr, &line_addr) == 0);
+ assert(ret == 0);
#endif
@@ -1282,10 +1289,10 @@ void g_buffer_cache_truncate(GBufferCache *cache, size_t max)
/******************************************************************************
* *
-* Paramètres : cache = tampon de lignes à venir consulter. *
-* index = indice de la ligne visée par la consultation. *
-* x = position géographique sur la ligne concernée. *
-* addr = adresse à renseigner. [OUT] *
+* Paramètres : cache = tampon de lignes à venir consulter. *
+* index = indice de la ligne visée par la consultation. *
+* x = position géographique sur la ligne concernée. *
+* cursor = emplacement à constituer. [OUT] *
* *
* Description : Retrouve l'emplacement correspondant à une position de ligne.*
* *
@@ -1295,11 +1302,11 @@ void g_buffer_cache_truncate(GBufferCache *cache, size_t max)
* *
******************************************************************************/
-void g_buffer_cache_get_line_addr(const GBufferCache *cache, size_t index, gint x, vmpa2t *addr)
+void g_buffer_cache_get_line_cursor(const GBufferCache *cache, size_t index, gint x, GLineCursor **cursor)
{
assert(index < cache->used);
- get_cache_info_addr(&cache->lines[index], index, x, addr);
+ get_cache_info_cursor(&cache->lines[index], index, x, cursor);
}
@@ -1489,9 +1496,10 @@ void g_buffer_cache_draw(const GBufferCache *cache, cairo_t *cr, size_t first, s
size_t _g_buffer_cache_find_index_by_addr(const GBufferCache *cache, const vmpa2t *addr, bool first, size_t start, size_t end)
{
size_t result; /* Indice à retourner */
+ GLineCursor *___tmp;
cache_info *found; /* Eventuel élément trouvé */
- int find_containing_generator(const vmpa2t *a, const cache_info *i)
+ int find_containing_generator(const GLineCursor *c, const cache_info *i)
{
const generator_link *generator; /* Générateur retenu */
@@ -1500,12 +1508,17 @@ size_t _g_buffer_cache_find_index_by_addr(const GBufferCache *cache, const vmpa2
else
generator = &i->generators[0];
- return g_line_generator_contains_addr(generator->instance, addr,
- i - cache->lines, generator->repeat);
+ return g_line_generator_contains_cursor(generator->instance,
+ i - cache->lines, generator->repeat, c);
}
- found = (cache_info *)bsearch(addr, &cache->lines[start], end - start + 1,
+
+ ___tmp = g_binary_cursor_new();
+ g_binary_cursor_update(G_BINARY_CURSOR(___tmp), addr);
+
+
+ found = (cache_info *)bsearch(___tmp, &cache->lines[start], end - start + 1,
sizeof(cache_info), (__compar_fn_t)find_containing_generator);
if (found == NULL)
@@ -1523,7 +1536,7 @@ size_t _g_buffer_cache_find_index_by_addr(const GBufferCache *cache, const vmpa2
{
found = &cache->lines[result - 1];
- if (find_containing_generator(addr, found) != 0)
+ if (find_containing_generator(___tmp, found) != 0)
break;
}
@@ -1533,13 +1546,17 @@ size_t _g_buffer_cache_find_index_by_addr(const GBufferCache *cache, const vmpa2
{
found = &cache->lines[result + 1];
- if (find_containing_generator(addr, found) != 0)
+ if (find_containing_generator(___tmp, found) != 0)
break;
}
}
+
+ g_object_unref(G_OBJECT(___tmp));
+
+
return result;
}
@@ -1590,21 +1607,26 @@ size_t g_buffer_cache_find_index_by_addr(const GBufferCache *cache, const vmpa2t
size_t g_buffer_cache_look_for_flag(const GBufferCache *cache, size_t start, BufferLineFlags flag)
{
size_t result; /* Indice de ligne à retourner */
- vmpa2t start_addr; /* Localisation de départ */
+ GLineCursor *init; /* Localisation de départ */
size_t i; /* Boucle de parcours */
- vmpa2t addr; /* Localisation suivante */
+ GLineCursor *next; /* Localisation suivante */
+ int ret; /* Bilan de comparaison */
assert(start < cache->used);
result = start;
- get_cache_info_addr(&cache->lines[start], start, 0, &start_addr);
+ get_cache_info_cursor(&cache->lines[start], start, 0, &init);
for (i = start + 1; i < cache->used; i++)
{
- get_cache_info_addr(&cache->lines[i], i, 0, &addr);
+ get_cache_info_cursor(&cache->lines[i], i, 0, &next);
+
+ ret = g_line_cursor_compare(init, next);
+
+ g_object_unref(G_OBJECT(next));
- if (cmp_vmpa(&start_addr, &addr) != 0)
+ if (ret != 0)
break;
if ((g_buffer_cache_get_line_flags(cache, i) & flag) != 0)
@@ -1615,6 +1637,8 @@ size_t g_buffer_cache_look_for_flag(const GBufferCache *cache, size_t start, Buf
}
+ g_object_unref(G_OBJECT(init));
+
return result;
}
@@ -1641,11 +1665,17 @@ size_t g_buffer_cache_look_for_flag(const GBufferCache *cache, size_t start, Buf
bool g_buffer_cache_get_address_coordinates(const GBufferCache *cache, const vmpa2t *addr, size_t first, size_t last, bool code, gint *x, gint *y)
{
bool result; /* Bilan à retourner */
+ GLineCursor *___tmp;
size_t index; /* Indice de correspondance */
gint lheight; /* Hauteur d'une ligne */
const cache_info *info; /* Infos sur une ligne donnée */
const generator_link *generator; /* Générateur retenu */
+
+ ___tmp = g_binary_cursor_new();
+ g_binary_cursor_update(G_BINARY_CURSOR(___tmp), addr);
+
+
index = _g_buffer_cache_find_index_by_addr(cache, addr, true, first, last);
result = (index < cache->used);
@@ -1672,7 +1702,7 @@ bool g_buffer_cache_get_address_coordinates(const GBufferCache *cache, const vmp
else
generator = &info->generators[0];
- if (!g_line_generator_contains_addr(generator->instance, addr, index + 1, generator->repeat))
+ if (!g_line_generator_contains_cursor(generator->instance, index + 1, generator->repeat, ___tmp))
break;
*y += lheight;
@@ -1681,6 +1711,10 @@ bool g_buffer_cache_get_address_coordinates(const GBufferCache *cache, const vmp
}
+
+ g_object_unref(G_OBJECT(___tmp));
+
+
return result;
}
diff --git a/src/glibext/gbuffercache.h b/src/glibext/gbuffercache.h
index dbd3237..fdf59d7 100644
--- a/src/glibext/gbuffercache.h
+++ b/src/glibext/gbuffercache.h
@@ -90,7 +90,7 @@ void g_buffer_cache_extend_with(GBufferCache *, size_t, GLineGenerator *);
void g_buffer_cache_truncate(GBufferCache *, size_t);
/* Retrouve l'emplacement correspondant à une position de ligne. */
-void g_buffer_cache_get_line_addr(const GBufferCache *, size_t, gint, vmpa2t *);
+void g_buffer_cache_get_line_cursor(const GBufferCache *, size_t, gint, GLineCursor **);
/* Détermine l'ensemble des propriétés attachées à une ligne. */
BufferLineFlags g_buffer_cache_get_line_flags(const GBufferCache *, size_t);
diff --git a/src/glibext/gbufferview.c b/src/glibext/gbufferview.c
index af7d7ac..0eff4d8 100644
--- a/src/glibext/gbufferview.c
+++ b/src/glibext/gbufferview.c
@@ -77,7 +77,7 @@ 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 *, vmpa2t *);
+bool _g_buffer_view_compute_caret_full(GBufferView *, gint, GBufferLine *, size_t, const bool *, 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 *);
@@ -565,7 +565,7 @@ gint g_buffer_view_get_height(const GBufferView *view)
* y = ordonnée proposée pour le nouvel emplacement. *
* display = règles d'affichage des colonnes modulables. *
* caret = position du curseur à construire. [OUT] *
-* addr = adresse correspondant à cette même position. [OUT] *
+* cursor = emplacement correspondant à cette position. [OUT] *
* *
* Description : Calcule la position idéale de curseur pour un point donné. *
* *
@@ -575,7 +575,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, vmpa2t *addr)
+bool g_buffer_view_compute_caret_full(GBufferView *view, gint x, gint y, const bool *display, cairo_rectangle_int_t *caret, GLineCursor **cursor)
{
bool result; /* Bilan à retourner */
gint lheight; /* Hauteur d'une ligne */
@@ -600,7 +600,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, addr);
+ result = _g_buffer_view_compute_caret_full(view, x, line, index, display, caret, cursor);
g_object_unref(G_OBJECT(line));
@@ -619,7 +619,7 @@ bool g_buffer_view_compute_caret_full(GBufferView *view, gint x, gint y, const b
* index = indice de cette même ligne dans le tampon. *
* display = règles d'affichage des colonnes modulables. *
* caret = position du curseur à construire. [OUT] *
-* addr = adresse correspondant à cette même position. [OUT] *
+* cursor = emplacement correspondant à cette position. [OUT] *
* *
* Description : Calcule la position idéale de curseur pour un point donné. *
* *
@@ -629,7 +629,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, vmpa2t *addr)
+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 result; /* Bilan à retourner */
gint text_pos; /* Abscisse de départ du texte */
@@ -670,7 +670,7 @@ bool _g_buffer_view_compute_caret_full(GBufferView *view, gint x, GBufferLine *l
caret->width = 2;
caret->height = lheight;
- g_buffer_cache_get_line_addr(view->cache, index, caret->x, addr);
+ g_buffer_cache_get_line_cursor(view->cache, index, caret->x, cursor);
result = true;
@@ -764,7 +764,7 @@ static bool _g_buffer_view_move_caret(GBufferView *view, const GBufferLine *line
* dir = direction du parcours. *
* display = règles d'affichage des colonnes modulables. *
* caret = position du curseur à faire évoluer. [OUT] *
-* addr = adresse correspondant à cette même position. [OUT] *
+* cursor = emplacement correspondant à cette position. [OUT] *
* *
* Description : Déplace le curseur au sein d'une vue de tampon. *
* *
@@ -774,7 +774,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, vmpa2t *addr)
+bool g_buffer_view_move_caret(GBufferView *view, bool ctrl, GdkScrollDirection dir, const bool *display, cairo_rectangle_int_t *caret, GLineCursor **cursor)
{
bool result; /* Bilan à retourner */
size_t index; /* Indice de ligne de tampon */
@@ -802,7 +802,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, addr);
+ result = _g_buffer_view_compute_caret_full(view, caret->x, other, index, display, caret, cursor);
g_object_unref(G_OBJECT(other));
}
@@ -816,7 +816,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, addr);
+ result = _g_buffer_view_compute_caret_full(view, caret->x, other, index, display, caret, cursor);
g_object_unref(G_OBJECT(other));
}
@@ -829,7 +829,7 @@ bool g_buffer_view_move_caret(GBufferView *view, bool ctrl, GdkScrollDirection d
if (moved)
{
- g_buffer_cache_get_line_addr(view->cache, index, caret->x, addr);
+ g_buffer_cache_get_line_cursor(view->cache, index, caret->x, cursor);
result = true;
}
@@ -838,7 +838,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, addr);
+ result = _g_buffer_view_compute_caret_full(view, INT_MAX, other, index, display, caret, cursor);
g_object_unref(G_OBJECT(other));
}
@@ -851,7 +851,7 @@ bool g_buffer_view_move_caret(GBufferView *view, bool ctrl, GdkScrollDirection d
if (moved)
{
- g_buffer_cache_get_line_addr(view->cache, index, caret->x, addr);
+ g_buffer_cache_get_line_cursor(view->cache, index, caret->x, cursor);
result = true;
}
@@ -862,7 +862,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, addr);
+ result = _g_buffer_view_compute_caret_full(view, text_pos, other, index, display, caret, cursor);
g_object_unref(G_OBJECT(other));
}
diff --git a/src/glibext/gbufferview.h b/src/glibext/gbufferview.h
index ee77212..facc3b7 100644
--- a/src/glibext/gbufferview.h
+++ b/src/glibext/gbufferview.h
@@ -78,10 +78,10 @@ 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 *, vmpa2t *);
+bool g_buffer_view_compute_caret_full(GBufferView *, gint, gint, const bool *, 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 *, vmpa2t *);
+bool g_buffer_view_move_caret(GBufferView *, bool, GdkScrollDirection, const bool *, cairo_rectangle_int_t *, GLineCursor **);
diff --git a/src/glibext/generators/prologue.c b/src/glibext/generators/prologue.c
index 2f4075e..63d326b 100644
--- a/src/glibext/generators/prologue.c
+++ b/src/glibext/generators/prologue.c
@@ -28,6 +28,7 @@
#include <malloc.h>
+#include "../gbinarycursor.h"
#include "../gbufferline.h"
#include "../linegen-int.h"
#include "../linesegment.h"
@@ -74,10 +75,10 @@ static void g_intro_generator_finalize(GIntroGenerator *);
static size_t g_intro_generator_count_lines(const GIntroGenerator *);
/* Retrouve l'emplacement correspondant à une position donnée. */
-static void g_intro_generator_compute_addr(const GIntroGenerator *, gint, vmpa2t *, size_t, size_t);
+static void g_intro_generator_compute_cursor(const GIntroGenerator *, gint, size_t, size_t, GLineCursor **);
/* Détermine si le conteneur s'inscrit dans une plage donnée. */
-static int g_intro_generator_contains_addr(const GIntroGenerator *, const vmpa2t *, size_t, size_t);
+static int g_intro_generator_contains_cursor(const GIntroGenerator *, size_t, size_t, const GLineCursor *);
/* Renseigne sur les propriétés liées à un générateur. */
static BufferLineFlags g_intro_generator_get_flags(const GIntroGenerator *, size_t, size_t);
@@ -151,8 +152,8 @@ static void g_intro_generator_init(GIntroGenerator *generator)
static void g_intro_generator_interface_init(GLineGeneratorInterface *iface)
{
iface->count = (linegen_count_lines_fc)g_intro_generator_count_lines;
- iface->compute = (linegen_compute_fc)g_intro_generator_compute_addr;
- iface->contains = (linegen_contains_fc)g_intro_generator_contains_addr;
+ iface->compute = (linegen_compute_fc)g_intro_generator_compute_cursor;
+ iface->contains = (linegen_contains_fc)g_intro_generator_contains_cursor;
iface->get_flags = (linegen_get_flags_fc)g_intro_generator_get_flags;
iface->print = (linegen_print_fc)g_intro_generator_print;
@@ -284,9 +285,9 @@ static size_t g_intro_generator_count_lines(const GIntroGenerator *generator)
* *
* Paramètres : generator = générateur à consulter. *
* x = position géographique sur la ligne concernée. *
-* addr = position en mémoire à analyser. *
* index = indice de cette même ligne dans le tampon global.*
* repeat = indice d'utilisations successives du générateur. *
+* cursor = emplacement à constituer. [OUT] *
* *
* Description : Retrouve l'emplacement correspondant à une position donnée. *
* *
@@ -296,9 +297,11 @@ static size_t g_intro_generator_count_lines(const GIntroGenerator *generator)
* *
******************************************************************************/
-static void g_intro_generator_compute_addr(const GIntroGenerator *generator, gint x, vmpa2t *addr, size_t index, size_t repeat)
+static void g_intro_generator_compute_cursor(const GIntroGenerator *generator, gint x, size_t index, size_t repeat, GLineCursor **cursor)
{
- copy_vmpa(addr, &generator->addr);
+ *cursor = g_binary_cursor_new();
+
+ g_binary_cursor_update(G_BINARY_CURSOR(*cursor), &generator->addr);
}
@@ -306,9 +309,9 @@ static void g_intro_generator_compute_addr(const GIntroGenerator *generator, gin
/******************************************************************************
* *
* Paramètres : generator = générateur à consulter. *
-* addr = position en mémoire à analyser. *
* index = indice de cette même ligne dans le tampon global.*
* repeat = indice d'utilisations successives du générateur. *
+* cursor = emplacement à analyser. *
* *
* Description : Détermine si le conteneur s'inscrit dans une plage donnée. *
* *
@@ -318,9 +321,18 @@ static void g_intro_generator_compute_addr(const GIntroGenerator *generator, gin
* *
******************************************************************************/
-static int g_intro_generator_contains_addr(const GIntroGenerator *generator, const vmpa2t *addr, size_t index, size_t repeat)
+static int g_intro_generator_contains_cursor(const GIntroGenerator *generator, size_t index, size_t repeat, const GLineCursor *cursor)
{
- return cmp_vmpa(addr, &generator->addr);
+ int result; /* Conclusion à retourner */
+ vmpa2t addr; /* Autre emplacement à comparer*/
+
+ assert(G_IS_BINARY_CURSOR(cursor));
+
+ g_binary_cursor_get_info(G_BINARY_CURSOR(cursor), &addr);
+
+ result = cmp_vmpa(&addr, &generator->addr);
+
+ return result;
}
diff --git a/src/glibext/generators/rborder.c b/src/glibext/generators/rborder.c
index a440377..62c374d 100644
--- a/src/glibext/generators/rborder.c
+++ b/src/glibext/generators/rborder.c
@@ -29,6 +29,7 @@
#include <string.h>
+#include "../gbinarycursor.h"
#include "../gbufferline.h"
#include "../linegen-int.h"
#include "../linesegment.h"
@@ -81,10 +82,10 @@ static void g_border_generator_finalize(GBorderGenerator *);
static size_t g_border_generator_count_lines(const GBorderGenerator *);
/* Retrouve l'emplacement correspondant à une position donnée. */
-static void g_border_generator_compute_addr(const GBorderGenerator *, gint, vmpa2t *, size_t, size_t);
+static void g_border_generator_compute_cursor(const GBorderGenerator *, gint, size_t, size_t, GLineCursor **);
/* Détermine si le conteneur s'inscrit dans une plage donnée. */
-static int g_border_generator_contains_addr(const GBorderGenerator *, const vmpa2t *, size_t, size_t);
+static int g_border_generator_contains_cursor(const GBorderGenerator *, size_t, size_t, const GLineCursor *);
/* Renseigne sur les propriétés liées à un générateur. */
static BufferLineFlags g_border_generator_get_flags(const GBorderGenerator *, size_t, size_t);
@@ -156,8 +157,8 @@ static void g_border_generator_init(GBorderGenerator *generator)
static void g_border_generator_interface_init(GLineGeneratorInterface *iface)
{
iface->count = (linegen_count_lines_fc)g_border_generator_count_lines;
- iface->compute = (linegen_compute_fc)g_border_generator_compute_addr;
- iface->contains = (linegen_contains_fc)g_border_generator_contains_addr;
+ iface->compute = (linegen_compute_fc)g_border_generator_compute_cursor;
+ iface->contains = (linegen_contains_fc)g_border_generator_contains_cursor;
iface->get_flags = (linegen_get_flags_fc)g_border_generator_get_flags;
iface->print = (linegen_print_fc)g_border_generator_print;
@@ -261,9 +262,9 @@ static size_t g_border_generator_count_lines(const GBorderGenerator *generator)
* *
* Paramètres : generator = générateur à consulter. *
* x = position géographique sur la ligne concernée. *
-* addr = position en mémoire à analyser. *
* index = indice de cette même ligne dans le tampon global.*
* repeat = indice d'utilisations successives du générateur. *
+* cursor = emplacement à constituer. [OUT] *
* *
* Description : Retrouve l'emplacement correspondant à une position donnée. *
* *
@@ -273,9 +274,11 @@ static size_t g_border_generator_count_lines(const GBorderGenerator *generator)
* *
******************************************************************************/
-void g_border_generator_compute_addr(const GBorderGenerator *generator, gint x, vmpa2t *addr, size_t index, size_t repeat)
+void g_border_generator_compute_cursor(const GBorderGenerator *generator, gint x, size_t index, size_t repeat, GLineCursor **cursor)
{
- copy_vmpa(addr, &generator->addr);
+ *cursor = g_binary_cursor_new();
+
+ g_binary_cursor_update(G_BINARY_CURSOR(*cursor), &generator->addr);
}
@@ -283,9 +286,9 @@ void g_border_generator_compute_addr(const GBorderGenerator *generator, gint x,
/******************************************************************************
* *
* Paramètres : generator = générateur à consulter. *
-* addr = position en mémoire à analyser. *
* index = indice de cette même ligne dans le tampon global.*
* repeat = indice d'utilisations successives du générateur. *
+* cursor = emplacement à analyser. *
* *
* Description : Détermine si le conteneur s'inscrit dans une plage donnée. *
* *
@@ -295,9 +298,18 @@ void g_border_generator_compute_addr(const GBorderGenerator *generator, gint x,
* *
******************************************************************************/
-static int g_border_generator_contains_addr(const GBorderGenerator *generator, const vmpa2t *addr, size_t index, size_t repeat)
+static int g_border_generator_contains_cursor(const GBorderGenerator *generator, size_t index, size_t repeat, const GLineCursor *cursor)
{
- return cmp_vmpa(addr, &generator->addr);
+ int result; /* Conclusion à retourner */
+ vmpa2t addr; /* Autre emplacement à comparer*/
+
+ assert(G_IS_BINARY_CURSOR(cursor));
+
+ g_binary_cursor_get_info(G_BINARY_CURSOR(cursor), &addr);
+
+ result = cmp_vmpa(&addr, &generator->addr);
+
+ return result;
}
diff --git a/src/glibext/glinecursor-int.h b/src/glibext/glinecursor-int.h
index 411b072..26e5143 100644
--- a/src/glibext/glinecursor-int.h
+++ b/src/glibext/glinecursor-int.h
@@ -29,6 +29,10 @@
+/* Compare deux suivis d'emplacements. */
+typedef int (* compare_cursor_fc) (const GLineCursor *, const GLineCursor *);
+
+
/* Suivi de positions dans un panneau de chargement (instance) */
struct _GLineCursor
{
@@ -41,6 +45,8 @@ struct _GLineCursorClass
{
GObjectClass parent; /* A laisser en premier */
+ compare_cursor_fc compare; /* Comparaison d'emplacements */
+
};
diff --git a/src/glibext/glinecursor.c b/src/glibext/glinecursor.c
index 8ad24bd..52cadea 100644
--- a/src/glibext/glinecursor.c
+++ b/src/glibext/glinecursor.c
@@ -24,6 +24,9 @@
#include "glinecursor.h"
+#include <assert.h>
+
+
#include "glinecursor-int.h"
@@ -124,3 +127,29 @@ static void g_line_cursor_finalize(GLineCursor *cursor)
G_OBJECT_CLASS(g_line_cursor_parent_class)->finalize(G_OBJECT(cursor));
}
+
+
+/******************************************************************************
+* *
+* Paramètres : cursor = premier suivi d'emplacement à comparer. *
+* other = second suivi d'emplacement à comparer. *
+* *
+* Description : Compare deux suivis d'emplacements. *
+* *
+* Retour : Bilan de la comparaison. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+int g_line_cursor_compare(const GLineCursor *cursor, const GLineCursor *other)
+{
+ int result; /* Bilan à renvoyer */
+
+ assert(G_OBJECT_TYPE(cursor) == G_OBJECT_TYPE(other));
+
+ result = G_LINE_CURSOR_GET_CLASS(cursor)->compare(cursor, other);
+
+ return result;
+
+}
diff --git a/src/glibext/glinecursor.h b/src/glibext/glinecursor.h
index e541e66..58bee9c 100644
--- a/src/glibext/glinecursor.h
+++ b/src/glibext/glinecursor.h
@@ -47,6 +47,9 @@ typedef struct _GLineCursorClass GLineCursorClass;
/* Détermine le type du suivi de positions dans un panneau de chargement. */
GType g_line_cursor_get_type(void);
+/* Compare deux suivis d'emplacements. */
+int g_line_cursor_compare(const GLineCursor *, const GLineCursor *);
+
#endif /* _GLIBEXT_LINECURSOR_H */
diff --git a/src/glibext/linegen-int.h b/src/glibext/linegen-int.h
index 1847eba..b903ed7 100644
--- a/src/glibext/linegen-int.h
+++ b/src/glibext/linegen-int.h
@@ -33,10 +33,10 @@
typedef size_t (* linegen_count_lines_fc) (const GLineGenerator *);
/* Retrouve l'emplacement correspondant à une position donnée. */
-typedef void (* linegen_compute_fc) (const GLineGenerator *, gint, vmpa2t *, size_t, size_t);
+typedef void (* linegen_compute_fc) (const GLineGenerator *, gint, size_t, size_t, GLineCursor **);
/* Détermine si le conteneur s'inscrit dans une plage donnée. */
-typedef int (* linegen_contains_fc) (const GLineGenerator *, const vmpa2t *, size_t, size_t);
+typedef int (* linegen_contains_fc) (const GLineGenerator *, size_t, size_t, const GLineCursor *);
/* Renseigne sur les propriétés liées à un générateur. */
typedef BufferLineFlags (* linegen_get_flags_fc) (const GLineGenerator *, size_t, size_t);
diff --git a/src/glibext/linegen.c b/src/glibext/linegen.c
index 6675646..c61fa63 100644
--- a/src/glibext/linegen.c
+++ b/src/glibext/linegen.c
@@ -88,9 +88,9 @@ size_t g_line_generator_count_lines(const GLineGenerator *generator)
* *
* Paramètres : generator = générateur à consulter. *
* x = position géographique sur la ligne concernée. *
-* addr = position en mémoire à analyser. *
* index = indice de cette même ligne dans le tampon global.*
* repeat = indice d'utilisations successives du générateur. *
+* cursor = emplacement à constituer. [OUT] *
* *
* Description : Retrouve l'emplacement correspondant à une position donnée. *
* *
@@ -100,7 +100,7 @@ size_t g_line_generator_count_lines(const GLineGenerator *generator)
* *
******************************************************************************/
-void g_line_generator_compute_addr(const GLineGenerator *generator, gint x, vmpa2t *addr, size_t index, size_t repeat)
+void g_line_generator_compute_cursor(const GLineGenerator *generator, gint x, size_t index, size_t repeat, GLineCursor **cursor)
{
GLineGeneratorIface *iface; /* Interface utilisée */
@@ -111,7 +111,7 @@ void g_line_generator_compute_addr(const GLineGenerator *generator, gint x, vmpa
assert(repeat < g_line_generator_count_lines(generator));
#endif
- iface->compute(generator, x, addr, index, repeat);
+ iface->compute(generator, x, index, repeat, cursor);
}
@@ -119,9 +119,9 @@ void g_line_generator_compute_addr(const GLineGenerator *generator, gint x, vmpa
/******************************************************************************
* *
* Paramètres : generator = générateur à consulter. *
-* addr = position en mémoire à analyser. *
* index = indice de cette même ligne dans le tampon global.*
* repeat = indice d'utilisations successives du générateur. *
+* cursor = emplacement à analyser. *
* *
* Description : Détermine si le conteneur s'inscrit dans une plage donnée. *
* *
@@ -131,7 +131,7 @@ void g_line_generator_compute_addr(const GLineGenerator *generator, gint x, vmpa
* *
******************************************************************************/
-int g_line_generator_contains_addr(const GLineGenerator *generator, const vmpa2t *addr, size_t index, size_t repeat)
+int g_line_generator_contains_cursor(const GLineGenerator *generator, size_t index, size_t repeat, const GLineCursor *cursor)
{
GLineGeneratorIface *iface; /* Interface utilisée */
@@ -142,7 +142,7 @@ int g_line_generator_contains_addr(const GLineGenerator *generator, const vmpa2t
assert(repeat < g_line_generator_count_lines(generator));
#endif
- return iface->contains(generator, addr, index, repeat);
+ return iface->contains(generator, index, repeat, cursor);
}
diff --git a/src/glibext/linegen.h b/src/glibext/linegen.h
index 1fa6dbf..31672a2 100644
--- a/src/glibext/linegen.h
+++ b/src/glibext/linegen.h
@@ -29,6 +29,7 @@
#include "gbufferline.h"
+#include "glinecursor.h"
#include "../analysis/content.h"
@@ -55,10 +56,10 @@ GType g_line_generator_get_type(void) G_GNUC_CONST;
size_t g_line_generator_count_lines(const GLineGenerator *);
/* Retrouve l'emplacement correspondant à une position donnée. */
-void g_line_generator_compute_addr(const GLineGenerator *, gint, vmpa2t *, size_t, size_t);
+void g_line_generator_compute_cursor(const GLineGenerator *, gint, size_t, size_t, GLineCursor **);
/* Détermine si le conteneur s'inscrit dans une plage donnée. */
-int g_line_generator_contains_addr(const GLineGenerator *, const vmpa2t *, size_t, size_t);
+int g_line_generator_contains_cursor(const GLineGenerator *, size_t, size_t, const GLineCursor *);
/* Renseigne sur les propriétés liées à un générateur. */
BufferLineFlags g_line_generator_get_flags(const GLineGenerator *, size_t, size_t);
diff --git a/src/gtkext/gtkbufferdisplay.c b/src/gtkext/gtkbufferdisplay.c
index 45c7193..3ef77b5 100644
--- a/src/gtkext/gtkbufferdisplay.c
+++ b/src/gtkext/gtkbufferdisplay.c
@@ -31,6 +31,7 @@
#include "../core/params.h"
+#include "../glibext/gbinarycursor.h" // REMME
@@ -475,7 +476,8 @@ static gboolean gtk_buffer_display_key_press(GtkWidget *widget, GdkEventKey *eve
GtkBufferDisplay *display; /* Autre version du composant */
GtkDisplayPanel *panel; /* Autre version du composant */
bool ctrl; /* Statut de la touche Contrôle*/
- cairo_rectangle_int_t area; /* Emplacement de curseur */
+ cairo_rectangle_int_t area; /* Emplacement de curseur #1 */
+ GLineCursor *cursor; /* Emplacement de curseur #2 */
vmpa2t addr; /* Adresse du nouveau curseur */
bool status; /* Validité d'un déplacement */
@@ -515,10 +517,15 @@ static gboolean gtk_buffer_display_key_press(GtkWidget *widget, GdkEventKey *eve
ctrl = (event->state & GDK_CONTROL_MASK);
area = display->caret;
- status = g_buffer_view_move_caret(display->view, ctrl, dir, panel->display_options, &area, &addr);
+ status = g_buffer_view_move_caret(display->view, ctrl, dir, panel->display_options, &area, &cursor);
if (status)
{
+ ////////////////////////
+ g_binary_cursor_get_info(G_BINARY_CURSOR(cursor), &addr);
+ g_object_unref(G_OBJECT(cursor));
+ ////////////////////////
+
gtk_buffer_display_relocate_caret(display, &area, &addr);
_gtk_display_panel_scroll_to_address(panel, &addr, SPT_RAW, false);
}
@@ -843,12 +850,21 @@ static bool _gtk_buffer_display_move_caret_to(GtkBufferDisplay *display, gint x,
{
bool result; /* Bilan à retourner */
GtkDisplayPanel *panel; /* Autre version du composant */
- vmpa2t addr; /* Position mémoire associée */
cairo_rectangle_int_t new; /* Nouvel emplacement calculé */
+ GLineCursor *cursor; /* Emplacement de curseur */
+ vmpa2t addr; /* Position mémoire associée */
panel = GTK_DISPLAY_PANEL(display);
- result = g_buffer_view_compute_caret_full(display->view, x, y, panel->display_options, &new, &addr);
+ result = g_buffer_view_compute_caret_full(display->view, x, y, panel->display_options, &new, &cursor);
+
+ ////////////////////////
+ if (result)
+ {
+ g_binary_cursor_get_info(G_BINARY_CURSOR(cursor), &addr);
+ g_object_unref(G_OBJECT(cursor));
+ }
+ ////////////////////////
if (result)
gtk_buffer_display_relocate_caret(display, &new, &addr);
--
cgit v0.11.2-87-g4458