Provided a clean way to run delayed tasks.

git-svn-id: svn://svn.gna.org/svn/chrysalide/trunk@109 abbe820e-26c8-41b2-8c08-b7b2b41f8b0a

11 files changed, 581 insertions, 252 deletions

diff --git a/src/Makefile.am b/src/Makefile.am
index 3685409..95eff37 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -1,5 +1,5 @@
 
-lib_LTLIBRARIES = liboidadisass.la liboidagtkext.la liboidagui.la liboidaplugin.la
+lib_LTLIBRARIES = liboidadisass.la liboidaglibext.la liboidagtkext.la liboidagui.la liboidaplugin.la
 
 bin_PROGRAMS=openida
 
@@ -22,12 +22,22 @@ liboidadisass_la_LIBADD =						\
 	format/libformat.la
 
 
+#--- liboidaglibext
+
+liboidaglibext_la_SOURCES =
+
+liboidaglibext_la_LDFLAGS = $(LIBGTK_LIBS) $(LIBGRAPH_LIBS)
+
+liboidaglibext_la_LIBADD =						\
+	glibext/libglibext.la
+
+
 #--- liboidagtkext
 
 liboidagtkext_la_SOURCES =
 
 liboidagtkext_la_LDFLAGS = $(LIBGTK_LIBS) $(LIBGRAPH_LIBS)		\
-	-L.libs -loidadisass
+	-L.libs -loidadisass -loidaglibext
 
 liboidagtkext_la_LIBADD =						\
 	graph/libgraph.la							\
@@ -99,4 +109,4 @@ openida_LDADD = $(LIBINTL) 				\
 
 # gtkext doit être traité en premier, à cause des marshals GLib
 
-SUBDIRS = gtkext analysis arch format common debug graph panel plugins
+SUBDIRS = glibext gtkext analysis arch format common debug graph panel plugins
diff --git a/src/analysis/binary.c b/src/analysis/binary.c
index c21b554..8cec72a 100644
--- a/src/analysis/binary.c
+++ b/src/analysis/binary.c
@@ -41,6 +41,7 @@
 #include "line_prologue.h"
 #include "prototype.h"
 #include "../common/extstr.h"
+#include "../glibext/delayed.h"
 #include "../format/format.h"
 #include "../panel/log.h"
 #include "../plugins/pglist.h"
@@ -101,7 +102,7 @@ bin_t *map_binary_file(const char *, off_t *);
 GRenderingLine *build_binary_prologue(const char *, const uint8_t *, off_t);
 
 /* Acquitte la fin d'un désasemblage différé et complet. */
-void ack_completed_disassembly(GDelayedManager *, GOpenidaBinary *, GRenderingLine *, GOpenidaBinary *);
+void ack_completed_disassembly(GDisassManager *, GOpenidaBinary *, GRenderingLine *, GOpenidaBinary *);
 
 
 
@@ -312,24 +313,22 @@ bool g_openida_binary_save(const GOpenidaBinary *binary, xmlDocPtr xdoc, xmlXPat
 
 void g_openida_binary_analyse(GOpenidaBinary *binary)
 {
-    GDelayedManager *manager;               /* Gestionnaire de différés    */
+    GDisassManager *manager;                /* Gestionnaire de différés    */
     GBinPart **parts;                       /* Parties d'élément binaire   */
     size_t parts_count;                     /* Nombre de ces parties       */
+    GDelayedDisassembly *disass;            /* Désassemblage à mener       */
 
-    manager = get_delayed_manager();
+    manager = get_disassembly_manager();
 
     parts = g_exe_format_get_parts(binary->format, &parts_count);
     qsort(parts, parts_count, sizeof(GBinPart *), g_binary_part_compare);
 
+    disass = g_delayed_disassembly_new(binary, parts, parts_count);
 
     g_signal_connect(manager, "disassembly-completed",
                      G_CALLBACK(ack_completed_disassembly), binary);
 
-    g_delayed_manager_schedule_disassembly(manager, binary, parts, parts_count);
-
-
-
-
+    g_delayed_queue_schedule_work(G_WORK_QUEUE(manager), G_DELAYED_WORK(disass));
 
 }
 
@@ -605,7 +604,7 @@ GRenderingLine *build_binary_prologue(const char *filename, const uint8_t *data,
 *                                                                             *
 ******************************************************************************/
 
-void ack_completed_disassembly(GDelayedManager *manager, GOpenidaBinary *binary, GRenderingLine *lines, GOpenidaBinary *user)
+void ack_completed_disassembly(GDisassManager *manager, GOpenidaBinary *binary, GRenderingLine *lines, GOpenidaBinary *user)
 {
     GRenderingLine *line;                   /* "Première" ligne de rendu   */
     GPluginModule **pglist;                 /* Liste de greffons           */
diff --git a/src/analysis/delayed.c b/src/analysis/delayed.c
index 6ec03e8..0d02d39 100644
--- a/src/analysis/delayed.c
+++ b/src/analysis/delayed.c
@@ -24,13 +24,11 @@
 #include "delayed.h"
 
 
-#include <malloc.h>
-
-
 #include "line_code.h"
 #include "line_comment.h"
 #include "../common/dllist.h"
 #include "../format/format.h"
+#include "../glibext/delayed-int.h"
 #include "../gtkext/gtkextstatusbar.h"
 #include "../gtkext/iodamarshal.h"
 
@@ -43,75 +41,75 @@
 
 
 
-/* Ensembles binaires à désassembler */
-typedef struct _disassembly_task
+/* ------------------------ DESASSEMBLAGE DE BINAIRE DIFFERE ------------------------ */
+
+
+/* Ensembles binaires à désassembler (instance) */
+struct _GDelayedDisassembly
 {
-    GOpenidaBinary *owner;                  /* Destinataire final          */
+    GDelayedWork parent;                    /* A laisser en premier        */
 
-    DL_LIST_ITEM(link);                     /* Lien vers les maillons      */
+    GOpenidaBinary *binary;                 /* Destinataire final          */
 
     GBinPart **parts;                       /* Parties binaires à traiter  */
     size_t count;                           /* Nombre de ces parties       */
 
-} disassembly_task;
-
+};
 
-#define disassembly_task_list_add_tail(new, head) dl_list_add_tail(new, head, disassembly_task, link)
-#define disassembly_task_list_del(item, head) dl_list_del(item, head, disassembly_task, link)
+/* Ensembles binaires à désassembler (classe) */
+struct _GDelayedDisassemblyClass
+{
+    GDelayedWorkClass parent;               /* A laisser en premier        */
 
+};
 
-/* Crée un tâche de désassemblage différé. */
-static disassembly_task *create_disassembly_task(GOpenidaBinary *, GBinPart **, size_t);
 
-/* Efface une tâche de désassemblage de la mémoire. */
-static void delete_disassembly_task(disassembly_task *);
+/* Initialise la classe des tâches de désassemblage différé. */
+static void g_delayed_disassembly_class_init(GDelayedDisassemblyClass *);
 
+/* Initialise une tâche de désassemblage différé. */
+static void g_delayed_disassembly_init(GDelayedDisassembly *);
 
 
 
+/* ------------------------- GESTION DES ANALYSES DIFFEREES ------------------------- */
 
 
 /* Gestionnaire des analyses différées (instance) */
-struct _GDelayedManager
+struct _GDisassManager
 {
-    GObject parent;                         /* A laisser en premier        */
+    GWorkQueue parent;                      /* A laisser en premier        */
 
     GtkExtStatusBar *statusbar;             /* Barre de statut principale  */
 
-    disassembly_task *disassemblies;        /* Binaires à désassembler     */
-    GMutex *disass_mutex;                   /* Verrou pour l'accès         */
-    GCond *disass_cond;                     /* Réveil pour un traitement   */
-
-    GThread *disassemble;                   /* Procédures de désassemblage */
-
 };
 
 /* Gestionnaire des analyses différées (classe) */
-struct _GDelayedManagerClass
+struct _GDisassManagerClass
 {
-    GObjectClass parent;                    /* A laisser en premier        */
+    GWorkQueueClass parent;                 /* A laisser en premier        */
 
     /* Signaux */
 
-    void (* disassembly_completed) (GDelayedManager *, GOpenidaBinary *, GRenderingLine *);
+    void (* disassembly_completed) (GDisassManager *, GOpenidaBinary *, GRenderingLine *);
 
 };
 
 
 /* Initialise la classe des gestionnaires d'analyses différées. */
-static void g_delayed_manager_class_init(GDelayedManagerClass *);
+static void g_disassembly_manager_class_init(GDisassManagerClass *);
 
 /* Initialise un gestionnaire d'analyses différées. */
-static void g_delayed_manager_init(GDelayedManager *);
+static void g_disassembly_manager_init(GDisassManager *);
 
 /* Crée un gestionnaire d'analyses différées. */
-static GDelayedManager *g_delayed_manager_new(GObject *);
+static GDisassManager *g_disassembly_manager_new(GObject *);
 
 /* Assure le désassemblage en différé. */
-static void *process_disassemblies(GDelayedManager *);
+static void process_disassemblies(GDisassManager *, GDelayedDisassembly *);
 
 /* Procède au désassemblage basique d'un contenu binaire. */
-static GRenderingLine *disassemble_binary_parts(disassembly_task *, GBinRoutine **, size_t, GtkExtStatusBar *, guint);
+static GRenderingLine *disassemble_binary_parts(GDelayedDisassembly *, GBinRoutine **, size_t, GtkExtStatusBar *, guint);
 
 /* Etablit les liens entres les différentes lignes de code. */
 static void establish_links_between_lines(GRenderingLine *, GBinRoutine **, size_t, GtkExtStatusBar *, guint);
@@ -124,48 +122,38 @@ static vmpa_t find_best_ending_address_for_routine(GRenderingLine *, size_t, con
 
 
 
+/* ---------------------------------------------------------------------------------- */
+/*                          DESASSEMBLAGE DE BINAIRE DIFFERE                          */
+/* ---------------------------------------------------------------------------------- */
 
 
-
+/* Indique le type défini pour les tâches de désassemblage différé. */
+G_DEFINE_TYPE(GDelayedDisassembly, g_delayed_disassembly, G_TYPE_DELAYED_WORK);
 
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : owner = binaire chargé en attente des résultats.             *
-*                parts = parties binaires à désassembler.                     *
-*                count = nombre de parties à traiter.                         *
+*  Paramètres  : klass = classe à initialiser.                                *
 *                                                                             *
-*  Description : Crée un tâche de désassemblage différé.                      *
+*  Description : Initialise la classe des tâches de désassemblage différé.    *
 *                                                                             *
-*  Retour      : Tâche créée.                                                 *
+*  Retour      : -                                                            *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-static disassembly_task *create_disassembly_task(GOpenidaBinary *owner, GBinPart **parts, size_t count)
+static void g_delayed_disassembly_class_init(GDelayedDisassemblyClass *klass)
 {
-    disassembly_task *result;               /* Tâche à retourner           */
-
-    result = (disassembly_task *)calloc(1, sizeof(disassembly_task));
-
-    result->owner = owner;
-
-    DL_LIST_ITEM_INIT(&result->link);
-
-    result->parts = parts;
-    result->count = count;
-
-    return result;
 
 }
 
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : task = tâche à libérer de la mémoire.                        *
+*  Paramètres  : disass = instance à initialiser.                             *
 *                                                                             *
-*  Description : Efface une tâche de désassemblage de la mémoire.             *
+*  Description : Initialise une tâche de désassemblage différé.               *
 *                                                                             *
 *  Retour      : -                                                            *
 *                                                                             *
@@ -173,34 +161,50 @@ static disassembly_task *create_disassembly_task(GOpenidaBinary *owner, GBinPart
 *                                                                             *
 ******************************************************************************/
 
-static void delete_disassembly_task(disassembly_task *task)
+static void g_delayed_disassembly_init(GDelayedDisassembly *disass)
 {
-    /* TODO
-    result->parts = parts;
-    result->count = count;
-    */
-
-    free(task);
 
 }
 
 
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : binary = binaire chargé en attente des résultats.            *
+*                parts  = parties binaires à désassembler.                    *
+*                count  = nombre de parties à traiter.                        *
+*                                                                             *
+*  Description : Crée une tâche de désassemblage différé.                     *
+*                                                                             *
+*  Retour      : Tâche créée.                                                 *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
 
+GDelayedDisassembly *g_delayed_disassembly_new(GOpenidaBinary *binary, GBinPart **parts, size_t count)
+{
+    GDelayedDisassembly *result;            /* Tâche à retourner           */
 
+    result = g_object_new(G_TYPE_DELAYED_DISASSEMBLY, NULL);
 
+    result->binary = binary;
 
+    result->parts = parts;
+    result->count = count;
 
+    return result;
 
+}
 
 
 
-
-
-
+/* ---------------------------------------------------------------------------------- */
+/*                           GESTION DES ANALYSES DIFFEREES                           */
+/* ---------------------------------------------------------------------------------- */
 
 
 /* Indique le type défini pour le gestionnaire des analyses différées. */
-G_DEFINE_TYPE(GDelayedManager, g_delayed_manager, G_TYPE_OBJECT);
+G_DEFINE_TYPE(GDisassManager, g_disassembly_manager, G_TYPE_WORK_QUEUE);
 
 
 /******************************************************************************
@@ -215,12 +219,12 @@ G_DEFINE_TYPE(GDelayedManager, g_delayed_manager, G_TYPE_OBJECT);
 *                                                                             *
 ******************************************************************************/
 
-static void g_delayed_manager_class_init(GDelayedManagerClass *klass)
+static void g_disassembly_manager_class_init(GDisassManagerClass *klass)
 {
     g_signal_new("disassembly-completed",
-                 G_TYPE_DELAYED_MANAGER,
+                 G_TYPE_DISASS_MANAGER,
                  G_SIGNAL_RUN_LAST,
-                 G_STRUCT_OFFSET(GDelayedManagerClass, disassembly_completed),
+                 G_STRUCT_OFFSET(GDisassManagerClass, disassembly_completed),
                  NULL, NULL,
                  g_cclosure_user_marshal_VOID__OBJECT_OBJECT,
                  G_TYPE_NONE, 2, G_TYPE_OPENIDA_BINARY, G_TYPE_RENDERING_LINE);
@@ -240,8 +244,13 @@ static void g_delayed_manager_class_init(GDelayedManagerClass *klass)
 *                                                                             *
 ******************************************************************************/
 
-static void g_delayed_manager_init(GDelayedManager *manager)
+static void g_disassembly_manager_init(GDisassManager *manager)
 {
+    GWorkQueue *parent;                     /* Instance parente            */
+
+    parent = G_WORK_QUEUE(manager);
+
+    parent->process = (process_work_fc)process_disassemblies;
 
 }
 
@@ -258,116 +267,76 @@ static void g_delayed_manager_init(GDelayedManager *manager)
 *                                                                             *
 ******************************************************************************/
 
-static GDelayedManager *g_delayed_manager_new(GObject *ref)
+static GDisassManager *g_disassembly_manager_new(GObject *ref)
 {
-    GDelayedManager *result;                /* Adresse à retourner         */
-    GError *error;                          /* Bilan de création de thread */
+    GDisassManager *result;                 /* Adresse à retourner         */
 
-    result = g_object_new(G_TYPE_DELAYED_MANAGER, NULL);
+    result = g_object_new(G_TYPE_DISASS_MANAGER, NULL);
 
     result->statusbar = g_object_get_data(ref, "statusbar");
 
-    result->disass_mutex = g_mutex_new();
-    if (result->disass_mutex == NULL)
-        goto dmn_error;
-
-    result->disass_cond = g_cond_new();
-    if (result->disass_cond == NULL)
-        goto dmn_error;
-
-    result->disassemble = g_thread_create((GThreadFunc)process_disassemblies, result, FALSE, &error);
-    if (!result->disassemble)
-        goto dmn_error;
-
     return result;
 
- dmn_error:
-
-    /* TODO */
-
-    return NULL;
-
 }
 
 
 /******************************************************************************
 *                                                                             *
 *  Paramètres  : manager = gestionnaire des actions à mener.                  *
+*                disass  = analyse à mener.                                   *
 *                                                                             *
 *  Description : Assure le désassemblage en différé.                          *
 *                                                                             *
-*  Retour      : Bilan de l'opération.                                        *
+*  Retour      : -                                                            *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-static void *process_disassemblies(GDelayedManager *manager)
+static void process_disassemblies(GDisassManager *manager, GDelayedDisassembly *disass)
 {
-    disassembly_task *task;                 /* Désassemblage à effectuer   */
     GBinRoutine **routines;                 /* Liste des routines trouvées */
     size_t routines_count;                  /* Nombre de ces routines      */
     guint id;                               /* Identifiant de statut       */
     GRenderingLine *lines;                  /* Nouvelles lignes de rendu   */
 
-    while (1)
-    {
-        g_mutex_lock(manager->disass_mutex);
-
-        if (dl_list_empty(manager->disassemblies))
-            g_cond_wait(manager->disass_cond, manager->disass_mutex);
-
-        task = manager->disassemblies;
-        disassembly_task_list_del(task, &manager->disassemblies);
-
-        g_mutex_unlock(manager->disass_mutex);
+    routines = g_binary_format_get_routines(G_BIN_FORMAT(g_openida_binary_get_format(disass->binary)), &routines_count);
+    qsort(routines, routines_count, sizeof(GBinRoutine *), g_binary_routine_rcompare);
 
-        routines = g_binary_format_get_routines(G_BIN_FORMAT(g_openida_binary_get_format(task->owner)), &routines_count);
-        qsort(routines, routines_count, sizeof(GBinRoutine *), g_binary_routine_rcompare);
+    /* Première étape */
 
-        /* Première étape */
+    id = gtk_extended_status_bar_push(manager->statusbar, _("Disassembling..."), true);
 
-        id = gtk_extended_status_bar_push(manager->statusbar, _("Disassembling..."), true);
+    lines = disassemble_binary_parts(disass, routines, routines_count, manager->statusbar, id);
 
-        lines = disassemble_binary_parts(task, routines, routines_count,
-                                         manager->statusbar, id);
+    gtk_extended_status_bar_remove(manager->statusbar, id);
 
-        gtk_extended_status_bar_remove(manager->statusbar, id);
+    /* Seconde étape */
 
-        /* Seconde étape */
+    id = gtk_extended_status_bar_push(manager->statusbar, _("Establishing links..."), true);
 
-        id = gtk_extended_status_bar_push(manager->statusbar, _("Establishing links..."), true);
+    establish_links_between_lines(lines, routines, routines_count, manager->statusbar, id);
 
-        establish_links_between_lines(lines, routines, routines_count,
-                                      manager->statusbar, id);
+    gtk_extended_status_bar_remove(manager->statusbar, id);
 
-        gtk_extended_status_bar_remove(manager->statusbar, id);
+    /* Troisième  étape */
 
-        /* Troisième  étape */
+    id = gtk_extended_status_bar_push(manager->statusbar, _("Finding remaining limits..."), true);
 
-        id = gtk_extended_status_bar_push(manager->statusbar, _("Finding remaining limits..."), true);
+    limit_all_routines(lines, routines, routines_count, manager->statusbar, id);
 
-        limit_all_routines(lines, routines, routines_count,
-                           manager->statusbar, id);
+    gtk_extended_status_bar_remove(manager->statusbar, id);
 
-        gtk_extended_status_bar_remove(manager->statusbar, id);
+    /* Fin */
 
-        /* Fin */
-
-        g_signal_emit_by_name(manager, "disassembly-completed", task->owner, lines);
-
-        delete_disassembly_task(task);
-
-    }
-
-    return NULL;
+    g_signal_emit_by_name(manager, "disassembly-completed", disass->binary, lines);
 
 }
 
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : task      = tâche à l'origine du traitement.                 *
+*  Paramètres  : disass    = tâche à l'origine du traitement.                 *
 *                routines  = prototypes existants à insérer.                  *
 *                count     = quantité de ces prototypes.                      *
 *                statusbar = barre de statut avec progression à mettre à jour.*
@@ -381,7 +350,7 @@ static void *process_disassemblies(GDelayedManager *manager)
 *                                                                             *
 ******************************************************************************/
 
-static GRenderingLine *disassemble_binary_parts(disassembly_task *task, GBinRoutine **routines, size_t count, GtkExtStatusBar *statusbar, guint id)
+static GRenderingLine *disassemble_binary_parts(GDelayedDisassembly *disass, GBinRoutine **routines, size_t count, GtkExtStatusBar *statusbar, guint id)
 {
     GRenderingLine *result;                 /* Ligne de rendu à retourner  */
     GArchProcessor *proc;                   /* Architecture du binaire     */
@@ -403,25 +372,25 @@ static GRenderingLine *disassemble_binary_parts(disassembly_task *task, GBinRout
 
     result = NULL;
 
-    proc = get_arch_processor_from_format(g_openida_binary_get_format(task->owner));
-    options = g_openida_binary_get_options(task->owner);
-    bin_data = g_openida_binary_get_data(task->owner, NULL);
+    proc = get_arch_processor_from_format(g_openida_binary_get_format(disass->binary));
+    options = g_openida_binary_get_options(disass->binary);
+    bin_data = g_openida_binary_get_data(disass->binary, NULL);
 
     /* Préparation du suivi de la progression */
 
     sum = 0;
 
-    for (i = 0; i < task->count; i++)
+    for (i = 0; i < disass->count; i++)
     {
-        g_binary_part_get_values(task->parts[i], NULL, &len, NULL);
+        g_binary_part_get_values(disass->parts[i], NULL, &len, NULL);
         sum += len;
     }
 
     done = 0;
 
-    for (i = 0; i < task->count; i++)
+    for (i = 0; i < disass->count; i++)
     {
-        g_binary_part_get_values(task->parts[i], &pos, &len, &base);
+        g_binary_part_get_values(disass->parts[i], &pos, &len, &base);
 
         /* Décodage des instructions */
 
@@ -695,48 +664,6 @@ static vmpa_t find_best_ending_address_for_routine(GRenderingLine *line, size_t
 }
 
 
-
-
-
-
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : manager = gestionnaire des actions à mener.                  *
-*                binary  = élément binaire concerné par la procédure.         *
-*                parts   = blocs binaires à désassembler.                     *
-*                count   = quantité de ces blocs binaires.                    *
-*                                                                             *
-*  Description : Place un nouveau désassemblage en attente.                   *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-void g_delayed_manager_schedule_disassembly(GDelayedManager *manager, GOpenidaBinary *binary, GBinPart **parts, size_t count)
-{
-    disassembly_task *task;                 /* Nouveau désassemblage       */
-
-    task = create_disassembly_task(binary, parts, count);
-
-    g_mutex_lock(manager->disass_mutex);
-
-    disassembly_task_list_add_tail(task, &manager->disassemblies);
-
-    g_cond_signal(manager->disass_cond);
-
-    g_mutex_unlock(manager->disass_mutex);
-
-}
-
-
-
-
-
-
 /******************************************************************************
 *                                                                             *
 *  Paramètres  : manager = nouveau gestionnaire à mémoriser ou NULL.          *
@@ -749,9 +676,9 @@ void g_delayed_manager_schedule_disassembly(GDelayedManager *manager, GOpenidaBi
 *                                                                             *
 ******************************************************************************/
 
-GDelayedManager *_get_delayed_manager(GDelayedManager *manager)
+GDisassManager *_get_disassembly_manager(GDisassManager *manager)
 {
-    static GDelayedManager *result = NULL;  /* Singleton à retourner       */
+    static GDisassManager *result = NULL;   /* Singleton à retourner       */
 
     if (manager != NULL)
         result = manager;
@@ -773,14 +700,14 @@ GDelayedManager *_get_delayed_manager(GDelayedManager *manager)
 *                                                                             *
 ******************************************************************************/
 
-bool init_delayed_manager(GObject *ref)
+bool init_disassembly_manager(GObject *ref)
 {
-    GDelayedManager *manager;               /* Singleton à mettre en place */
+    GDisassManager *manager;                /* Singleton à mettre en place */
 
-    manager = g_delayed_manager_new(ref);
+    manager = g_disassembly_manager_new(ref);
 
     if (manager != NULL)
-        _get_delayed_manager(manager);
+        _get_disassembly_manager(manager);
 
     return (manager != NULL);
 
diff --git a/src/analysis/delayed.h b/src/analysis/delayed.h
index 437f968..c543f0b 100644
--- a/src/analysis/delayed.h
+++ b/src/analysis/delayed.h
@@ -36,38 +36,61 @@
 
 
 
-#define G_TYPE_DELAYED_MANAGER               g_delayed_manager_get_type()
-#define G_DELAYED_MANAGER(obj)               (G_TYPE_CHECK_INSTANCE_CAST((obj), g_delayed_manager_get_type(), GDelayedManager))
-#define G_IS_DELAYED_MANAGER(obj)            (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_delayed_manager_get_type()))
-#define G_DELAYED_MANAGER_GET_IFACE(inst)    (G_TYPE_INSTANCE_GET_INTERFACE((inst), g_delayed_manager_get_type(), GDelayedManagerIface))
-#define G_DELAYED_MANAGER_GET_CLASS(obj)     (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_DELAYED_MANAGER, GDelayedManagerClass))
+/* ------------------------ DESASSEMBLAGE DE BINAIRE DIFFERE ------------------------ */
 
 
-/* Gestionnaire des analyses différées (instance) */
-typedef struct _GDelayedManager GDelayedManager;
+#define G_TYPE_DELAYED_DISASSEMBLY               g_delayed_disassembly_get_type()
+#define G_DELAYED_DISASSEMBLY(obj)               (G_TYPE_CHECK_INSTANCE_CAST((obj), g_delayed_disassembly_get_type(), GDelayedDisassembly))
+#define G_IS_DELAYED_DISASSEMBLY(obj)            (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_delayed_disassembly_get_type()))
+#define G_DELAYED_DISASSEMBLY_CLASS(klass)       (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_DELAYED_DISASSEMBLY, GDelayedDisassemblyClass))
+#define G_IS_DELAYED_DISASSEMBLY_CLASS(klass)    (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_DELAYED_DISASSEMBLY))
+#define G_DELAYED_DISASSEMBLY_GET_CLASS(obj)     (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_DELAYED_DISASSEMBLY, GDelayedDisassemblyClass))
 
-/* Gestionnaire des analyses différées (classe) */
-typedef struct _GDelayedManagerClass GDelayedManagerClass;
 
+/* Ensembles binaires à désassembler (instance) */
+typedef struct _GDelayedDisassembly GDelayedDisassembly;
+
+/* Ensembles binaires à désassembler (classe) */
+typedef struct _GDelayedDisassemblyClass GDelayedDisassemblyClass;
 
-/* Indique le type défini pour le gestionnaire des analyses différées. */
-GType g_delayed_manager_get_type(void);
 
-/* Place un nouveau désassemblage en attente. */
-void g_delayed_manager_schedule_disassembly(GDelayedManager *, GOpenidaBinary *, GBinPart **, size_t);
 
+/* Indique le type défini pour les tâches de désassemblage différé. */
+GType g_delayed_disassembly_get_type(void);
 
+/* Crée une tâche de désassemblage différé. */
+GDelayedDisassembly *g_delayed_disassembly_new(GOpenidaBinary *, GBinPart **, size_t);
 
 
 
-#define get_delayed_manager() _get_delayed_manager(NULL)
+/* ------------------------- GESTION DES ANALYSES DIFFEREES ------------------------- */
 
 
+#define G_TYPE_DISASS_MANAGER               g_disassembly_manager_get_type()
+#define G_DISASS_MANAGER(obj)               (G_TYPE_CHECK_INSTANCE_CAST((obj), g_disassembly_manager_get_type(), GDisassManager))
+#define G_IS_DISASS_MANAGER(obj)            (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_disassembly_manager_get_type()))
+#define G_DISASS_MANAGER_GET_IFACE(inst)    (G_TYPE_INSTANCE_GET_INTERFACE((inst), g_disassembly_manager_get_type(), GDisassManagerIface))
+#define G_DISASS_MANAGER_GET_CLASS(obj)     (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_DISASS_MANAGER, GDisassManagerClass))
+
+
+/* Gestionnaire des analyses différées (instance) */
+typedef struct _GDisassManager GDisassManager;
+
+/* Gestionnaire des analyses différées (classe) */
+typedef struct _GDisassManagerClass GDisassManagerClass;
+
+
+#define get_disassembly_manager() _get_disassembly_manager(NULL)
+
+
+/* Indique le type défini pour le gestionnaire des analyses différées. */
+GType g_disassembly_manager_get_type(void);
+
 /* Fournit le gestionnaire d'analyse en différé courant. */
-GDelayedManager *_get_delayed_manager(GDelayedManager *);
+GDisassManager *_get_disassembly_manager(GDisassManager *);
 
 /* Procède au chargement du gestionnaire d'analyse différées. */
-bool init_delayed_manager(GObject *);
+bool init_disassembly_manager(GObject *);
 
 
 
diff --git a/src/glibext/Makefile.am b/src/glibext/Makefile.am
new file mode 100644
index 0000000..334b49a
--- /dev/null
+++ b/src/glibext/Makefile.am
@@ -0,0 +1,17 @@
+
+noinst_LTLIBRARIES  = libglibext.la
+
+libglibext_la_SOURCES =					\
+	delayed-int.h						\
+	delayed.h delayed.c
+
+libglibext_la_LDFLAGS = 
+
+
+INCLUDES = $(LIBGTK_CFLAGS) $(LIBXML_CFLAGS)
+
+AM_CPPFLAGS = 
+
+AM_CFLAGS = $(DEBUG_CFLAGS) $(WARNING_FLAGS) $(COMPLIANCE_FLAGS)
+
+SUBDIRS = 
diff --git a/src/glibext/delayed-int.h b/src/glibext/delayed-int.h
new file mode 100644
index 0000000..7fb8f3a
--- /dev/null
+++ b/src/glibext/delayed-int.h
@@ -0,0 +1,82 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * delayed-int.h - définitions internes pour la gestion des travaux différés
+ *
+ * Copyright (C) 2009 Cyrille Bagard
+ *
+ *  This file is part of OpenIDA.
+ *
+ *  OpenIDA is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  OpenIDA is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Foobar.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#include "delayed.h"
+
+
+#include "../common/dllist.h"
+
+
+
+/* -------------------------- TACHE DIFFEREE DANS LE TEMPS -------------------------- */
+
+
+/* Travail différé (instance) */
+struct _GDelayedWork
+{
+    GObject parent;                         /* A laisser en premier        */
+
+    DL_LIST_ITEM(link);                     /* Lien vers les maillons      */
+
+};
+
+/* Travail différé (classe) */
+struct _GDelayedWorkClass
+{
+    GObjectClass parent;                    /* A laisser en premier        */
+
+};
+
+
+#define delayed_work_list_add_tail(new, head) dl_list_add_tail(new, head, GDelayedWork, link)
+#define delayed_work_list_del(item, head) dl_list_del(item, head, GDelayedWork, link)
+
+
+
+/* ------------------------- TRAITEMENT DE TACHES DIFFEREES ------------------------- */
+
+
+/* Effectue le traitement d'une tâche donnée. */
+typedef void (* process_work_fc) (GWorkQueue *, GDelayedWork *);
+
+
+/* Gestionnaire des travaux différés (instance) */
+struct _GWorkQueue
+{
+    GObject parent;                         /* A laisser en premier        */
+
+    GDelayedWork *works;                    /* Tâches à mener à bien       */
+    GMutex *mutex;                          /* Verrou pour l'accès         */
+    GCond *cond;                            /* Réveil pour un traitement   */
+
+    GThread *thread;                        /* Procédure de traitement     */
+    process_work_fc process;                /* Coeur du traitement         */
+
+};
+
+/* Gestionnaire des travaux différés (classe) */
+struct _GWorkQueueClass
+{
+    GObjectClass parent;                    /* A laisser en premier        */
+
+};
diff --git a/src/glibext/delayed.c b/src/glibext/delayed.c
new file mode 100644
index 0000000..4388b2c
--- /dev/null
+++ b/src/glibext/delayed.c
@@ -0,0 +1,226 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * delayed.c - gestion des travaux différés
+ *
+ * Copyright (C) 2009 Cyrille Bagard
+ *
+ *  This file is part of OpenIDA.
+ *
+ *  OpenIDA is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  OpenIDA is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Foobar.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#include "delayed.h"
+
+
+#include "delayed-int.h"
+
+
+
+/* -------------------------- TACHE DIFFEREE DANS LE TEMPS -------------------------- */
+
+
+/* Initialise la classe des travaux différés. */
+static void g_delayed_work_class_init(GDelayedWorkClass *);
+
+/* Initialise une instance de travail différé. */
+static void g_delayed_work_init(GDelayedWork *);
+
+
+
+/* ------------------------- TRAITEMENT DE TACHES DIFFEREES ------------------------- */
+
+
+/* Initialise la classe des travaux différés. */
+static void g_work_queue_class_init(GWorkQueueClass *);
+
+/* Initialise une instance de gestionnaire de travaux différés. */
+static void g_work_queue_init(GWorkQueue *);
+
+/* Assure le traitement en différé. */
+static void *g_work_queue_process(GWorkQueue *);
+
+
+
+/* ---------------------------------------------------------------------------------- */
+/*                            TACHE DIFFEREE DANS LE TEMPS                            */
+/* ---------------------------------------------------------------------------------- */
+
+
+/* Indique le type défini pour les travaux différés. */
+G_DEFINE_TYPE(GDelayedWork, g_delayed_work, G_TYPE_OBJECT);
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : klass = classe à initialiser.                                *
+*                                                                             *
+*  Description : Initialise la classe des travaux différés.                   *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_delayed_work_class_init(GDelayedWorkClass *klass)
+{
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : work = instance à initialiser.                               *
+*                                                                             *
+*  Description : Initialise une instance de travail différé.                  *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_delayed_work_init(GDelayedWork *work)
+{
+
+}
+
+
+
+/* ---------------------------------------------------------------------------------- */
+/*                           TRAITEMENT DE TACHES DIFFEREES                           */
+/* ---------------------------------------------------------------------------------- */
+
+
+/* Indique le type défini pour le gestionnaire des travaux différés. */
+G_DEFINE_TYPE(GWorkQueue, g_work_queue, G_TYPE_OBJECT);
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : klass = classe à initialiser.                                *
+*                                                                             *
+*  Description : Initialise la classe des travaux différés.                   *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_work_queue_class_init(GWorkQueueClass *klass)
+{
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : queue = instance à initialiser.                              *
+*                                                                             *
+*  Description : Initialise une instance de gestionnaire de travaux différés. *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_work_queue_init(GWorkQueue *queue)
+{
+    GError *error;                          /* Bilan de création de thread */
+
+    queue->mutex = g_mutex_new();
+    if (queue->mutex == NULL)
+        goto gwqi_error;
+
+    queue->cond = g_cond_new();
+    if (queue->cond == NULL)
+        goto gwqi_error;
+
+    queue->thread = g_thread_create((GThreadFunc)g_work_queue_process, queue, FALSE, &error);
+    if (!queue->thread)
+        goto gwqi_error;
+
+ gwqi_error:
+
+    /* TODO */ return;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : queue = gestionnaire des actions à mener.                    *
+*                                                                             *
+*  Description : Assure le traitement en différé.                             *
+*                                                                             *
+*  Retour      : Bilan de l'opération.                                        *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void *g_work_queue_process(GWorkQueue *queue)
+{
+    GDelayedWork *work;                     /* Traitement à mener          */
+
+    while (1)
+    {
+        g_mutex_lock(queue->mutex);
+
+        if (dl_list_empty(queue->works))
+            g_cond_wait(queue->cond, queue->mutex);
+
+        work = queue->works;
+        delayed_work_list_del(work, &queue->works);
+
+        g_mutex_unlock(queue->mutex);
+
+        queue->process(queue, work);
+
+        /* TODO : delete work */
+
+    }
+
+    return NULL;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : queu = gestionnaire des actions à mener.                     *
+*                work = nouvelle tâche à programmer, puis effectuer.          *
+*                                                                             *
+*  Description : Place une nouvelle tâche en attente.                         *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+void g_delayed_queue_schedule_work(GWorkQueue *queue, GDelayedWork *work)
+{
+    g_mutex_lock(queue->mutex);
+
+    delayed_work_list_add_tail(work, &queue->works);
+
+    g_cond_signal(queue->cond);
+
+    g_mutex_unlock(queue->mutex);
+
+}
diff --git a/src/glibext/delayed.h b/src/glibext/delayed.h
new file mode 100644
index 0000000..d1e3967
--- /dev/null
+++ b/src/glibext/delayed.h
@@ -0,0 +1,81 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * delayed.h - prototypes pour la gestion des travaux différés
+ *
+ * Copyright (C) 2009 Cyrille Bagard
+ *
+ *  This file is part of OpenIDA.
+ *
+ *  OpenIDA is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  OpenIDA is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Foobar.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#ifndef _GLIBEXT_DELAYED_H
+#define _GLIBEXT_DELAYED_H
+
+
+#include <glib-object.h>
+
+
+
+/* -------------------------- TACHE DIFFEREE DANS LE TEMPS -------------------------- */
+
+
+#define G_TYPE_DELAYED_WORK               g_delayed_work_get_type()
+#define G_DELAYED_WORK(obj)               (G_TYPE_CHECK_INSTANCE_CAST((obj), g_delayed_work_get_type(), GDelayedWork))
+#define G_IS_DELAYED_WORK(obj)            (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_delayed_work_get_type()))
+#define G_DELAYED_WORK_CLASS(klass)       (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_DELAYED_WORK, GDelayedWorkClass))
+#define G_IS_DELAYED_WORK_CLASS(klass)    (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_DELAYED_WORK))
+#define G_DELAYED_WORK_GET_CLASS(obj)     (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_DELAYED_WORK, GDelayedWorkClass))
+
+
+/* Travail différé (instance) */
+typedef struct _GDelayedWork GDelayedWork;
+
+/* Travail différé (classe) */
+typedef struct _GDelayedWorkClass GDelayedWorkClass;
+
+
+/* Indique le type défini pour les travaux différés. */
+GType g_delayed_work_get_type(void);
+
+
+
+/* ------------------------- TRAITEMENT DE TACHES DIFFEREES ------------------------- */
+
+
+#define G_TYPE_WORK_QUEUE               g_work_queue_get_type()
+#define G_WORK_QUEUE(obj)               (G_TYPE_CHECK_INSTANCE_CAST((obj), g_work_queue_get_type(), GWorkQueue))
+#define G_IS_WORK_QUEUE(obj)            (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_work_queue_get_type()))
+#define G_WORK_QUEUE_CLASS(klass)       (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_WORK_QUEUE, GWorkQueueClass))
+#define G_IS_WORK_QUEUE_CLASS(klass)    (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_WORK_QUEUE))
+#define G_WORK_QUEUE_GET_CLASS(obj)     (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_WORK_QUEUE, GWorkQueueClass))
+
+
+/* Gestionnaire des travaux différés (instance) */
+typedef struct _GWorkQueue GWorkQueue;
+
+/* Gestionnaire des travaux différés (classe) */
+typedef struct _GWorkQueueClass GWorkQueueClass;
+
+
+/* Indique le type défini pour le gestionnaire des travaux différés. */
+GType g_work_queue_get_type(void);
+
+/* Place une nouvelle tâche en attente. */
+void g_delayed_queue_schedule_work(GWorkQueue *, GDelayedWork *);
+
+
+
+#endif  /* _GLIBEXT_DELAYED_H */
diff --git a/src/gtkext/gtkblockview.c b/src/gtkext/gtkblockview.c
index 99825f0..7161762 100644
--- a/src/gtkext/gtkblockview.c
+++ b/src/gtkext/gtkblockview.c
@@ -628,15 +628,7 @@ static void gtk_block_view_set_rendering_lines(GtkBlockView *view, GRenderingLin
     {
         g_signal_connect(iter, "rendering-line-flags-changed",
                          G_CALLBACK(gtk_block_view_update_margin), view);
-    }
-
-    g_rendering_line_update_bin_len(GTK_BIN_VIEW(view)->lines,
-                                    GTK_BIN_VIEW(view)->last, view->rendering);
 
-    for (iter = GTK_BIN_VIEW(view)->lines;
-         iter != NULL;
-         iter = g_rendering_line_get_next_iter(GTK_BIN_VIEW(view)->lines, iter, GTK_BIN_VIEW(view)->last))
-    {
         if (iter != GTK_BIN_VIEW(view)->lines)
         {
             gtk_text_buffer_get_end_iter(view->buffer, &pos);
diff --git a/src/gtkext/gtkgraphview.c b/src/gtkext/gtkgraphview.c
index a6d4dd5..cc2d930 100644
--- a/src/gtkext/gtkgraphview.c
+++ b/src/gtkext/gtkgraphview.c
@@ -253,35 +253,7 @@ static void gtk_graph_view_reset(GtkGraphView *view)
 
 static void gtk_graph_view_set_rendering_lines(GtkGraphView *view, GRenderingLine *lines, GRenderingLine *last)
 {
-    GRenderingLine *mainl;
-
-    view->childs = (GtkBinView **)calloc(2, sizeof(GtkBinView *));
-    view->childs_count = 2;
-
-    view->childs[0] = GTK_BIN_VIEW(gtk_block_view_new(MRD_GRAPH));
-
-    gtk_widget_show(GTK_WIDGET(view->childs[0]));
-    gtk_fixed_put(GTK_FIXED(view), GTK_WIDGET(view->childs[0]), 50, 50);
-
-
-    gtk_bin_view_set_rendering_lines(view->childs[0], GTK_BIN_VIEW(view)->binary, lines, lines);
-
-
-
-    mainl = g_rendering_line_find_by_address(lines, last, 0x08048434);
-
-    printf("mainl : %p\n", mainl);
-
-
-    view->childs[1] = GTK_BIN_VIEW(gtk_block_view_new(MRD_GRAPH));
-
-    gtk_widget_show(GTK_WIDGET(view->childs[1]));
-    gtk_fixed_put(GTK_FIXED(view), GTK_WIDGET(view->childs[1]), 100, 450);
-
-
-    gtk_bin_view_set_rendering_lines(view->childs[1], GTK_BIN_VIEW(view)->binary, mainl, mainl);
-
-
+    gtk_graph_view_reset(view);
 
 }
 
diff --git a/src/main.c b/src/main.c
index e1572d5..6466948 100644
--- a/src/main.c
+++ b/src/main.c
@@ -99,7 +99,7 @@ int main(int argc, char **argv)
     editor = create_editor();
     gtk_widget_show(editor);
 
-    init_delayed_manager(G_OBJECT(editor));
+    init_disassembly_manager(G_OBJECT(editor));
 
     init_all_plugins(G_OBJECT(editor));