Updated the move entry from database items.

8 files changed, 598 insertions, 0 deletions

diff --git a/src/glibext/gbinarycursor.c b/src/glibext/gbinarycursor.c
index c614058..0c2a197 100644
--- a/src/glibext/gbinarycursor.c
+++ b/src/glibext/gbinarycursor.c
@@ -28,6 +28,9 @@
 
 
 
+/* ----------------------- FONCTIONNALITES D'UN SUIVI DE BASE ----------------------- */
+
+
 /* Suivi de positions dans un panneau de chargement (instance) */
 struct _GBinaryCursor
 {
@@ -57,12 +60,45 @@ static void g_binary_cursor_dispose(GBinaryCursor *);
 /* Procède à la libération totale de la mémoire. */
 static void g_binary_cursor_finalize(GBinaryCursor *);
 
+/* Réalise la copie d'un suivi d'emplacements. */
+static GLineCursor *g_binary_cursor_duplicate(const GBinaryCursor *);
+
 /* Compare deux suivis d'emplacements. */
 static int g_binary_cursor_compare(const GBinaryCursor *, const GBinaryCursor *);
 
 /* Détermine si un suivi d'emplacement est valide ou non. */
 static bool g_binary_cursor_is_valid(const GBinaryCursor *);
 
+/* Construit une étiquette de représentation d'un suivi. */
+static char *g_binary_cursor_build_label(const GBinaryCursor *);
+
+
+
+/* ---------------------- ENCADREMENT DES TRANSFERTS DE DONEES ---------------------- */
+
+
+/* Exporte la définition d'un emplacement dans un flux réseau. */
+static bool g_binary_cursor_serialize(const GBinaryCursor *, packed_buffer *);
+
+/* Importe la définition d'un emplacement depuis un flux réseau. */
+static bool g_binary_cursor_unserialize(GBinaryCursor *, packed_buffer *);
+
+
+
+/* ------------------------- LIENS AVEC UNE BASE DE DONNEES ------------------------- */
+
+
+/* Charge les valeurs utiles pour une localisation. */
+static bool g_binary_cursor_load(GBinaryCursor *, const char *, const bound_value *, size_t);
+
+/* Constitue les champs destinés à une insertion / modification. */
+static bool g_binary_cursor_prepare_db_statement(const GBinaryCursor *, const char *, bound_value **, size_t *);
+
+
+
+/* ---------------------------------------------------------------------------------- */
+/*                         FONCTIONNALITES D'UN SUIVI DE BASE                         */
+/* ---------------------------------------------------------------------------------- */
 
 
 /* Détermine le type du gestionnaire de largeurs associées aux lignes. */
@@ -93,8 +129,18 @@ static void g_binary_cursor_class_init(GBinaryCursorClass *class)
 
     line = G_LINE_CURSOR_CLASS(class);
 
+    line->duplicate = (duplicate_cursor_fc)g_binary_cursor_duplicate;
     line->compare = (compare_cursor_fc)g_binary_cursor_compare;
     line->is_valid = (is_cursor_valid_fc)g_binary_cursor_is_valid;
+    line->build_label = (build_cursor_label_fc)g_binary_cursor_build_label;
+
+    line->serialize = (serialize_cursor_fc)g_binary_cursor_serialize;
+    line->unserialize = (unserialize_cursor_fc)g_binary_cursor_unserialize;
+
+    line->create_db = (create_cursor_db_table_fc)g_binary_cursor_create_db_table;
+    line->setup_load = (setup_cursor_load_fc)g_binary_cursor_setup_load;
+    line->load = (load_cursor_fc)g_binary_cursor_load;
+    line->prepare = (prepare_cursor_db_statement_fc)g_binary_cursor_prepare_db_statement;
 
 }
 
@@ -181,6 +227,31 @@ GLineCursor *g_binary_cursor_new(void)
 
 /******************************************************************************
 *                                                                             *
+*  Paramètres  : cursor = suivi d'emplacement à dupliquer.                    *
+*                                                                             *
+*  Description : Réalise la copie d'un suivi d'emplacements.                  *
+*                                                                             *
+*  Retour      : Nouvelle instance copiée.                                    *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static GLineCursor *g_binary_cursor_duplicate(const GBinaryCursor *cursor)
+{
+    GLineCursor *result;                    /* Instance à retourner        */
+
+    result = g_binary_cursor_new();
+
+    g_binary_cursor_update(G_BINARY_CURSOR(cursor), &cursor->addr);
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
 *  Paramètres  : cursor = premier suivi d'emplacement à comparer.             *
 *                other  = second suivi d'emplacement à comparer.              *
 *                                                                             *
@@ -228,6 +299,32 @@ static bool g_binary_cursor_is_valid(const GBinaryCursor *cursor)
 
 /******************************************************************************
 *                                                                             *
+*  Paramètres  : cursor = suivi d'emplacement à consulter.                    *
+*                                                                             *
+*  Description : Construit une étiquette de représentation d'un suivi.        *
+*                                                                             *
+*  Retour      : Etiquette à libérer de la mémoire après usage.               *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static char *g_binary_cursor_build_label(const GBinaryCursor *cursor)
+{
+    char *result;                           /* Etiquette à retourner       */
+    VMPA_BUFFER(loc);                       /* Indication de position      */
+
+    vmpa2_to_string(&cursor->addr, MDS_UNDEFINED, loc, NULL);
+
+    result = strdup(loc);
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
 *  Paramètres  : cursor = suivi de positions à mettre à jour.                 *
 *                addr   = emplacement dans le binaire visé.                   *
 *                                                                             *
@@ -264,3 +361,163 @@ void g_binary_cursor_get_info(GBinaryCursor *cursor, vmpa2t *addr)
     copy_vmpa(addr, &cursor->addr);
 
 }
+
+
+
+/* ---------------------------------------------------------------------------------- */
+/*                        ENCADREMENT DES TRANSFERTS DE DONEES                        */
+/* ---------------------------------------------------------------------------------- */
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : cursor = suivi de positions à sauvegarder.                   *
+*                pbuf   = paquet de données où venir inscrire les infos.      *
+*                                                                             *
+*  Description : Exporte la définition d'un emplacement dans un flux réseau.  *
+*                                                                             *
+*  Retour      : Bilan de l'opération.                                        *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static bool g_binary_cursor_serialize(const GBinaryCursor *cursor, packed_buffer *pbuf)
+{
+    bool result;                            /* Bilan à retourner           */
+
+    result = pack_vmpa(&cursor->addr, pbuf);
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : cursor = suivi de positions à charger. [OUT]                 *
+*                pbuf = paquet de données où venir inscrire les infos.        *
+*                                                                             *
+*  Description : Importe la définition d'un emplacement depuis un flux réseau.*
+*                                                                             *
+*  Retour      : Bilan de l'opération.                                        *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static bool g_binary_cursor_unserialize(GBinaryCursor *cursor, packed_buffer *pbuf)
+{
+    bool result;                            /* Bilan à retourner           */
+
+    result = unpack_vmpa(&cursor->addr, pbuf);
+
+    return result;
+
+}
+
+
+
+/* ---------------------------------------------------------------------------------- */
+/*                           LIENS AVEC UNE BASE DE DONNEES                           */
+/* ---------------------------------------------------------------------------------- */
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : base = tronc commun pour les champs de la base de données.   *
+*                                                                             *
+*  Description : Donne les éléments requis pour la construction d'une table.  *
+*                                                                             *
+*  Retour      : Partie de requête à insérer dans la requête globale.         *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+char *g_binary_cursor_create_db_table(const char *base)
+{
+    char *result;                           /* Requête à retourner         */
+
+    result = create_vmpa_db_table(base);
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : base   = tronc commun pour les champs de la base de données. *
+*                values = tableau d'éléments à compléter. [OUT]               *
+*                count  = nombre de descriptions renseignées. [OUT]           *
+*                                                                             *
+*  Description : Décrit les colonnes utiles à un chargement de données.       *
+*                                                                             *
+*  Retour      : Bilan de l'opération.                                        *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+bool g_binary_cursor_setup_load(const char *base, bound_value **values, size_t *count)
+{
+    bool result;                            /* Bilan à renvoyer            */
+
+    result = setup_load_for_vmpa(base, values, count);
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : cursor = suivi de positions dont la définition est à définir.*
+*                base   = tronc commun pour les champs de la base de données. *
+*                values = tableau d'éléments à consulter.                     *
+*                count  = nombre de descriptions renseignées.                 *
+*                                                                             *
+*  Description : Charge les valeurs utiles pour une localisation.             *
+*                                                                             *
+*  Retour      : Bilan de l'opération.                                        *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static bool g_binary_cursor_load(GBinaryCursor *cursor, const char *base, const bound_value *values, size_t count)
+{
+    bool result;                            /* Bilan à renvoyer            */
+
+    result = load_vmpa(&cursor->addr, base, values, count);
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : cursor = suivi de positions à traiter.                       *
+*                base   = tronc commun pour les champs de la base de données. *
+*                values = couples de champs et de valeurs à lier. [OUT]       *
+*                count  = nombre de ces couples. [OUT]                        *
+*                                                                             *
+*  Description : Constitue les champs destinés à une insertion / modification.*
+*                                                                             *
+*  Retour      : Bilan de l'opération : succès ou non.                        *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static bool g_binary_cursor_prepare_db_statement(const GBinaryCursor *cursor, const char *base, bound_value **values, size_t *count)
+{
+    bool result;                            /* Bilan à renvoyer            */
+
+    result = prepare_vmpa_db_statement(&cursor->addr, base, values, count);
+
+    return result;
+
+}
diff --git a/src/glibext/gbinarycursor.h b/src/glibext/gbinarycursor.h
index e6617b6..9846c59 100644
--- a/src/glibext/gbinarycursor.h
+++ b/src/glibext/gbinarycursor.h
@@ -33,6 +33,9 @@
 
 
 
+/* ----------------------- FONCTIONNALITES D'UN SUIVI DE BASE ----------------------- */
+
+
 #define G_TYPE_BINARY_CURSOR            (g_binary_cursor_get_type())
 #define G_BINARY_CURSOR(obj)            (G_TYPE_CHECK_INSTANCE_CAST((obj), G_TYPE_BINARY_CURSOR, GBinaryCursor))
 #define G_BINARY_CURSOR_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_BINARY_CURSOR, GBinaryCursorClass))
@@ -62,4 +65,15 @@ void g_binary_cursor_get_info(GBinaryCursor *, vmpa2t *);
 
 
 
+/* ------------------------- LIENS AVEC UNE BASE DE DONNEES ------------------------- */
+
+
+/* Donne les éléments requis pour la construction d'une table. */
+char *g_binary_cursor_create_db_table(const char *);
+
+/* Décrit les colonnes utiles à un chargement de données. */
+bool g_binary_cursor_setup_load(const char *, bound_value **, size_t *);
+
+
+
 #endif  /* _GLIBEXT_BINARYCURSOR_H */
diff --git a/src/glibext/glinecursor-int.h b/src/glibext/glinecursor-int.h
index 2c56331..b38e22e 100644
--- a/src/glibext/glinecursor-int.h
+++ b/src/glibext/glinecursor-int.h
@@ -29,12 +29,36 @@
 
 
 
+/* Réalise la copie d'un suivi d'emplacements. */
+typedef GLineCursor * (* duplicate_cursor_fc) (const GLineCursor *);
+
 /* Compare deux suivis d'emplacements. */
 typedef int (* compare_cursor_fc) (const GLineCursor *, const GLineCursor *);
 
 /* Détermine si un suivi d'emplacement est valide ou non. */
 typedef bool (* is_cursor_valid_fc) (const GLineCursor *);
 
+/* Construit une étiquette de représentation d'un suivi. */
+typedef char * (* build_cursor_label_fc) (const GLineCursor *);
+
+/* Exporte la définition d'un emplacement dans un flux réseau. */
+typedef bool (* serialize_cursor_fc) (const GLineCursor *, packed_buffer *);
+
+/* Importe la définition d'un emplacement depuis un flux réseau. */
+typedef bool (* unserialize_cursor_fc) (GLineCursor *, packed_buffer *);
+
+/* Donne les éléments requis pour la construction d'une table. */
+typedef char *(* create_cursor_db_table_fc) (const char *);
+
+/* Décrit les colonnes utiles à un chargement de données. */
+typedef bool (* setup_cursor_load_fc) (const char *, bound_value **, size_t *);
+
+/* Charge les valeurs utiles pour une localisation. */
+typedef bool (* load_cursor_fc) (GLineCursor *, const char *, const bound_value *, size_t);
+
+/* Constitue les champs destinés à une insertion / modification. */
+typedef bool (* prepare_cursor_db_statement_fc) (const GLineCursor *, const char *, bound_value **, size_t *);
+
 
 /* Suivi de positions dans un panneau de chargement (instance) */
 struct _GLineCursor
@@ -48,8 +72,18 @@ struct _GLineCursorClass
 {
     GObjectClass parent;                    /* A laisser en premier        */
 
+    duplicate_cursor_fc duplicate;          /* Copie de curseur            */
     compare_cursor_fc compare;              /* Comparaison d'emplacements  */
     is_cursor_valid_fc is_valid;            /* Certificat de validité      */
+    build_cursor_label_fc build_label;      /* Obtention d'une étiquette   */
+
+    serialize_cursor_fc serialize;          /* Sauvegarde d'un emplacement */
+    unserialize_cursor_fc unserialize;      /* Chargement d'un emplacement */
+
+    create_cursor_db_table_fc create_db;    /* Création de table           */
+    setup_cursor_load_fc setup_load;        /* Préparation du chargement   */
+    load_cursor_fc load;                    /* Chargement de valeurs       */
+    prepare_cursor_db_statement_fc prepare; /* Préparation d'enregistrement*/
 
 };
 
diff --git a/src/glibext/glinecursor.c b/src/glibext/glinecursor.c
index b4f5811..0245ebd 100644
--- a/src/glibext/glinecursor.c
+++ b/src/glibext/glinecursor.c
@@ -31,6 +31,9 @@
 
 
 
+/* ----------------------- FONCTIONNALITES D'UN SUIVI DE BASE ----------------------- */
+
+
 /* Procède à l'initialisation d'une classe de suivi de position. */
 static void g_line_cursor_class_init(GLineCursorClass *);
 
@@ -45,6 +48,11 @@ static void g_line_cursor_finalize(GLineCursor *);
 
 
 
+/* ---------------------------------------------------------------------------------- */
+/*                         FONCTIONNALITES D'UN SUIVI DE BASE                         */
+/* ---------------------------------------------------------------------------------- */
+
+
 /* Détermine le type du gestionnaire de largeurs associées aux lignes. */
 G_DEFINE_TYPE(GLineCursor, g_line_cursor, G_TYPE_OBJECT);
 
@@ -131,6 +139,29 @@ static void g_line_cursor_finalize(GLineCursor *cursor)
 
 /******************************************************************************
 *                                                                             *
+*  Paramètres  : cursor = suivi d'emplacement à dupliquer.                    *
+*                                                                             *
+*  Description : Réalise la copie d'un suivi d'emplacements.                  *
+*                                                                             *
+*  Retour      : Nouvelle instance copiée.                                    *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GLineCursor *g_line_cursor_duplicate(const GLineCursor *cursor)
+{
+    GLineCursor *result;                    /* Instance à retourner        */
+
+    result = G_LINE_CURSOR_GET_CLASS(cursor)->duplicate(cursor);
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
 *  Paramètres  : cursor = premier suivi d'emplacement à comparer.             *
 *                other  = second suivi d'emplacement à comparer.              *
 *                                                                             *
@@ -176,3 +207,188 @@ bool g_line_cursor_is_valid(const GLineCursor *cursor)
     return result;
 
 }
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : cursor = suivi d'emplacement à consulter.                    *
+*                                                                             *
+*  Description : Construit une étiquette de représentation d'un suivi.        *
+*                                                                             *
+*  Retour      : Etiquette à libérer de la mémoire après usage.               *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+char *g_line_cursor_build_label(const GLineCursor *cursor)
+{
+    char *result;                           /* Etiquette à retourner       */
+
+    result = G_LINE_CURSOR_GET_CLASS(cursor)->build_label(cursor);
+
+    return result;
+
+}
+
+
+
+/* ---------------------------------------------------------------------------------- */
+/*                        ENCADREMENT DES TRANSFERTS DE DONEES                        */
+/* ---------------------------------------------------------------------------------- */
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : cursor = suivi de positions à sauvegarder.                   *
+*                pbuf   = paquet de données où venir inscrire les infos.      *
+*                                                                             *
+*  Description : Exporte la définition d'un emplacement dans un flux réseau.  *
+*                                                                             *
+*  Retour      : Bilan de l'opération.                                        *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+bool g_line_cursor_serialize(const GLineCursor *cursor, packed_buffer *pbuf)
+{
+    bool result;                            /* Bilan à retourner           */
+
+    result = G_LINE_CURSOR_GET_CLASS(cursor)->serialize(cursor, pbuf);
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : cursor = suivi de positions à charger. [OUT]                 *
+*                pbuf = paquet de données où venir inscrire les infos.        *
+*                                                                             *
+*  Description : Importe la définition d'un emplacement depuis un flux réseau.*
+*                                                                             *
+*  Retour      : Bilan de l'opération.                                        *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+bool g_line_cursor_unserialize(GLineCursor *cursor, packed_buffer *pbuf)
+{
+    bool result;                            /* Bilan à retourner           */
+
+    result = G_LINE_CURSOR_GET_CLASS(cursor)->unserialize(cursor, pbuf);
+
+    return result;
+
+}
+
+
+
+/* ---------------------------------------------------------------------------------- */
+/*                           LIENS AVEC UNE BASE DE DONNEES                           */
+/* ---------------------------------------------------------------------------------- */
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : cursor = suivi de positions à traiter.                       *
+*                base   = tronc commun pour les champs de la base de données. *
+*                                                                             *
+*  Description : Donne les éléments requis pour la construction d'une table.  *
+*                                                                             *
+*  Retour      : Partie de requête à insérer dans la requête globale.         *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+char *g_line_cursor_create_db_table(const GLineCursor *cursor, const char *base)
+{
+    char *result;                           /* Requête à retourner         */
+
+    result = G_LINE_CURSOR_GET_CLASS(cursor)->create_db(base);
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : cursor = suivi de positions à traiter.                       *
+*                base   = tronc commun pour les champs de la base de données. *
+*                values = tableau d'éléments à compléter. [OUT]               *
+*                count  = nombre de descriptions renseignées. [OUT]           *
+*                                                                             *
+*  Description : Décrit les colonnes utiles à un chargement de données.       *
+*                                                                             *
+*  Retour      : Bilan de l'opération.                                        *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+bool g_line_cursor_setup_load(const GLineCursor *cursor, const char *base, bound_value **values, size_t *count)
+{
+    bool result;                            /* Bilan à renvoyer            */
+
+    result = G_LINE_CURSOR_GET_CLASS(cursor)->setup_load(base, values, count);
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : cursor = suivi de positions dont la définition est à définir.*
+*                base   = tronc commun pour les champs de la base de données. *
+*                values = tableau d'éléments à consulter.                     *
+*                count  = nombre de descriptions renseignées.                 *
+*                                                                             *
+*  Description : Charge les valeurs utiles pour une localisation.             *
+*                                                                             *
+*  Retour      : Bilan de l'opération.                                        *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+bool g_line_cursor_load(GLineCursor *cursor, const char *base, const bound_value *values, size_t count)
+{
+    bool result;                            /* Bilan à renvoyer            */
+
+    result = G_LINE_CURSOR_GET_CLASS(cursor)->load(cursor, base, values, count);
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : cursor = suivi de positions à traiter.                       *
+*                base   = tronc commun pour les champs de la base de données. *
+*                values = couples de champs et de valeurs à lier. [OUT]       *
+*                count  = nombre de ces couples. [OUT]                        *
+*                                                                             *
+*  Description : Constitue les champs destinés à une insertion / modification.*
+*                                                                             *
+*  Retour      : Bilan de l'opération : succès ou non.                        *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+bool g_line_cursor_prepare_db_statement(const GLineCursor *cursor, const char *base, bound_value **values, size_t *count)
+{
+    bool result;                            /* Bilan à renvoyer            */
+
+    result = G_LINE_CURSOR_GET_CLASS(cursor)->prepare(cursor, base, values, count);
+
+    return result;
+
+}
diff --git a/src/glibext/glinecursor.h b/src/glibext/glinecursor.h
index 823adca..d9c16c4 100644
--- a/src/glibext/glinecursor.h
+++ b/src/glibext/glinecursor.h
@@ -29,6 +29,13 @@
 #include <stdbool.h>
 
 
+#include "../common/packed.h"
+#include "../common/sqlite.h"
+
+
+
+/* ----------------------- FONCTIONNALITES D'UN SUIVI DE BASE ----------------------- */
+
 
 #define G_TYPE_LINE_CURSOR            (g_line_cursor_get_type())
 #define G_LINE_CURSOR(obj)            (G_TYPE_CHECK_INSTANCE_CAST((obj), G_TYPE_LINE_CURSOR, GLineCursor))
@@ -48,12 +55,46 @@ typedef struct _GLineCursorClass GLineCursorClass;
 /* Détermine le type du suivi de positions dans un panneau de chargement. */
 GType g_line_cursor_get_type(void);
 
+/* Réalise la copie d'un suivi d'emplacements. */
+GLineCursor *g_line_cursor_duplicate(const GLineCursor *);
+
 /* Compare deux suivis d'emplacements. */
 int g_line_cursor_compare(const GLineCursor *, const GLineCursor *);
 
 /* Détermine si un suivi d'emplacement est valide ou non. */
 bool g_line_cursor_is_valid(const GLineCursor *);
 
+/* Construit une étiquette de représentation d'un suivi. */
+char *g_line_cursor_build_label(const GLineCursor *);
+
+
+
+/* ---------------------- ENCADREMENT DES TRANSFERTS DE DONEES ---------------------- */
+
+
+/* Exporte la définition d'un emplacement dans un flux réseau. */
+bool g_line_cursor_serialize(const GLineCursor *, packed_buffer *);
+
+/* Importe la définition d'un emplacement depuis un flux réseau. */
+bool g_line_cursor_unserialize(GLineCursor *, packed_buffer *);
+
+
+
+/* ------------------------- LIENS AVEC UNE BASE DE DONNEES ------------------------- */
+
+
+/* Donne les éléments requis pour la construction d'une table. */
+char *g_line_cursor_create_db_table(const GLineCursor *, const char *);
+
+/* Décrit les colonnes utiles à un chargement de données. */
+bool g_line_cursor_setup_load(const GLineCursor *, const char *, bound_value **, size_t *);
+
+/* Charge les valeurs utiles pour une localisation. */
+bool g_line_cursor_load(GLineCursor *, const char *, const bound_value *, size_t);
+
+/* Constitue les champs destinés à une insertion / modification. */
+bool g_line_cursor_prepare_db_statement(const GLineCursor *, const char *, bound_value **, size_t *);
+
 
 
 #endif  /* _GLIBEXT_LINECURSOR_H */
diff --git a/src/glibext/gloadedpanel-int.h b/src/glibext/gloadedpanel-int.h
index b26ca06..dbe9c0c 100644
--- a/src/glibext/gloadedpanel-int.h
+++ b/src/glibext/gloadedpanel-int.h
@@ -58,6 +58,10 @@ struct _GLoadedPanelIface
 
     cache_loaded_glance_fc cache_glance;    /* Cache de la mignature       */
 
+    /* Signaux */
+
+    void (* move_request) (GLoadedPanel *, const GLineCursor *, gboolean);
+
 };
 
 
diff --git a/src/glibext/gloadedpanel.c b/src/glibext/gloadedpanel.c
index 5f43821..8bf750a 100644
--- a/src/glibext/gloadedpanel.c
+++ b/src/glibext/gloadedpanel.c
@@ -24,6 +24,7 @@
 #include "gloadedpanel.h"
 
 
+#include "chrysamarshal.h"
 #include "gloadedpanel-int.h"
 
 
@@ -51,6 +52,13 @@ G_DEFINE_INTERFACE(GLoadedPanel, g_loaded_panel, G_TYPE_OBJECT)
 
 static void g_loaded_panel_default_init(GLoadedPanelInterface *iface)
 {
+    g_signal_new("move-request",
+                 G_TYPE_LOADED_PANEL,
+                 G_SIGNAL_RUN_LAST,
+                 G_STRUCT_OFFSET(GLoadedPanelIface, move_request),
+                 NULL, NULL,
+                 g_cclosure_user_marshal_VOID__OBJECT_BOOLEAN,
+                 G_TYPE_NONE, 2, G_TYPE_LINE_CURSOR, G_TYPE_BOOLEAN);
 
 }
 
@@ -159,6 +167,27 @@ void g_loaded_panel_set_cursor(GLoadedPanel *panel, const GLineCursor *cursor)
 
 /******************************************************************************
 *                                                                             *
+*  Paramètres  : panel  = composant GTK à manipuler.                          *
+*                cursor = emplacement à cibler pour un déplacement.           *
+*                save   = le changement est-il majeur ?                       *
+*                                                                             *
+*  Description : Demande à qui veut répondre un déplacement du curseur.       *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+void g_loaded_panel_request_move(GLoadedPanel *panel, const GLineCursor *cursor, gboolean save)
+{
+    g_signal_emit_by_name(panel, "move-request", cursor, save);
+
+}
+
+
+/******************************************************************************
+*                                                                             *
 *  Paramètres  : panel = composant GTK à manipuler.                           *
 *                cairo = assistant pour la création de rendus.                *
 *                area  = taille de la surface réduite à disposition.          *
diff --git a/src/glibext/gloadedpanel.h b/src/glibext/gloadedpanel.h
index 5d22cdb..ffdb35b 100644
--- a/src/glibext/gloadedpanel.h
+++ b/src/glibext/gloadedpanel.h
@@ -64,6 +64,9 @@ GLineCursor *g_loaded_panel_get_cursor(const GLoadedPanel *);
 /* Définit le position courante dans un panneau de chargement. */
 void g_loaded_panel_set_cursor(GLoadedPanel *, const GLineCursor *);
 
+/* Demande à qui veut répondre un déplacement du curseur. */
+void g_loaded_panel_request_move(GLoadedPanel *, const GLineCursor *, gboolean);
+
 /* Place en cache un rendu destiné à l'aperçu graphique rapide. */
 void g_loaded_panel_cache_glance(GLoadedPanel *, cairo_t *, const GtkAllocation *, double);