Cleaned the code and handled file binaries properly.

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

59 files changed, 851 insertions, 806 deletions

diff --git a/src/analysis/Makefile.am b/src/analysis/Makefile.am
index e59b648..b5b345f 100755
--- a/src/analysis/Makefile.am
+++ b/src/analysis/Makefile.am
@@ -16,6 +16,7 @@ libanalysis_la_SOURCES =				\
 	variable.h variable.c
 
 libanalysis_la_LIBADD =					\
+	binaries/libanalysisbinaries.la		\
 	decomp/libanalysisdecomp.la			\
 	disass/libanalysisdisass.la
 
@@ -28,4 +29,4 @@ AM_CPPFLAGS =
 
 AM_CFLAGS = $(DEBUG_CFLAGS) $(WARNING_FLAGS) $(COMPLIANCE_FLAGS)
 
-SUBDIRS = decomp disass
+SUBDIRS = binaries decomp disass
diff --git a/src/analysis/binaries/Makefile.am b/src/analysis/binaries/Makefile.am
new file mode 100755
index 0000000..f065070
--- /dev/null
+++ b/src/analysis/binaries/Makefile.am
@@ -0,0 +1,18 @@
+
+noinst_LTLIBRARIES  = libanalysisbinaries.la
+
+libanalysisbinaries_la_SOURCES =		\
+	file.h file.c
+
+libanalysisbinaries_la_LIBADD =	
+
+libanalysisbinaries_la_LDFLAGS = 
+
+
+INCLUDES = $(LIBGTK_CFLAGS) $(LIBXML_CFLAGS)
+
+AM_CPPFLAGS = 
+
+AM_CFLAGS = $(DEBUG_CFLAGS) $(WARNING_FLAGS) $(COMPLIANCE_FLAGS)
+
+SUBDIRS = 
diff --git a/src/analysis/binaries/file.c b/src/analysis/binaries/file.c
new file mode 100644
index 0000000..0be1fd7
--- /dev/null
+++ b/src/analysis/binaries/file.c
@@ -0,0 +1,328 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * file.h - prototypes pour la prise en charge des binaires sous forme de fichier
+ *
+ * Copyright (C) 2012 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 "file.h"
+
+
+#include <string.h>
+
+
+#include "../binary-int.h"
+#include "../../common/extstr.h"
+#include "../../gui/panels/log.h"
+
+
+
+/* Description de fichier binaire (instance) */
+struct _GFileBinary
+{
+    GLoadedBinary parent;                   /* A laisser en premier        */
+
+    char *filename;                         /* Fichier chargé en mémoire   */
+
+};
+
+/* Description de fichier binaire (classe) */
+struct _GFileBinaryClass
+{
+    GLoadedBinaryClass parent;              /* A laisser en premier        */
+
+};
+
+
+/* Initialise la classe des descriptions de fichier binaire. */
+static void g_file_binary_class_init(GFileBinaryClass *);
+
+/* Initialise une description de fichier binaire. */
+static void g_file_binary_init(GFileBinary *);
+
+/* Procède à la libération totale de la mémoire. */
+static void g_file_binary_finalize(GFileBinary *);
+
+/* Ecrit une sauvegarde du binaire dans un fichier XML. */
+static bool g_file_binary_save(const GFileBinary *, xmlDocPtr, xmlXPathContextPtr, const char *);
+
+/* Fournit le fichier correspondant à l'élément binaire. */
+static const char *g_file_binary_get_filename(const GFileBinary *, bool);
+
+
+
+/* Indique le type défini pour une description de fichier binaire. */
+G_DEFINE_TYPE(GFileBinary, g_file_binary, G_TYPE_LOADED_BINARY);
+
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : klass = classe à initialiser.                                *
+*                                                                             *
+*  Description : Initialise la classe des descriptions de fichier binaire.    *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_file_binary_class_init(GFileBinaryClass *klass)
+{
+    GObjectClass *object;                   /* Autre version de la classe  */
+
+    object = G_OBJECT_CLASS(klass);
+
+    object->finalize = (GObjectFinalizeFunc)g_file_binary_finalize;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : binary = instance à initialiser.                             *
+*                                                                             *
+*  Description : Initialise une description de fichier binaire.               *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_file_binary_init(GFileBinary *binary)
+{
+    GLoadedBinary *loaded;                  /* Version parente             */
+
+    loaded = G_LOADED_BINARY(binary);
+
+    loaded->save = (save_binary_fc)g_file_binary_save;
+    loaded->get_filename = (get_binary_filename_fc)g_file_binary_get_filename;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : binary = instance d'objet GLib à traiter.                    *
+*                                                                             *
+*  Description : Procède à la libération totale de la mémoire.                *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_file_binary_finalize(GFileBinary *binary)
+{
+    gpointer obj_class;                     /* Classe parente              */
+
+    free(binary->filename);
+
+    /* On passe le relai */
+
+    obj_class = g_type_class_peek_parent(G_FILE_BINARY_GET_CLASS(binary));
+
+    G_OBJECT_CLASS(obj_class)->finalize(G_OBJECT(binary));
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : filename = nom du fichier à charger.                         *
+*                                                                             *
+*  Description : Charge en mémoire le contenu d'un fichier.                   *
+*                                                                             *
+*  Retour      : Adresse de la représentation ou NULL en cas d'échec.         *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GLoadedBinary *g_file_binary_new_from_file(const char *filename)
+{
+    GFileBinary *result;                    /* Adresse à retourner         */
+    GLoadedBinary *loaded;                  /* Version parente             */
+    char *tmp;                              /* Nom de fichier modifiable   */
+
+    result = g_object_new(G_TYPE_FILE_BINARY, NULL);
+    loaded = G_LOADED_BINARY(result);
+
+    log_variadic_message(LMT_PROCESS, _("Opening '%s' file..."), filename);
+
+    result->filename = strdup(filename);
+
+    tmp = strdup(filename);
+    loaded->format = G_EXE_FORMAT(load_new_format(FMT_EXEC, tmp,
+                                                  &loaded->bin_data, &loaded->bin_length));
+    free(tmp);
+
+    if (loaded->format == NULL)
+    {
+        log_simple_message(LMT_INFO, _("Unknown binary format"));
+        goto lbf_error;
+    }
+
+    switch (g_exe_format_get_target_machine(loaded->format))
+    {
+        case FTM_ARM:
+            log_simple_message(LMT_INFO, _("Detected architecture: ARM"));
+            break;
+        case FTM_DALVIK:
+            log_simple_message(LMT_INFO, _("Detected architecture: Dalvik Virtual Machine"));
+            break;
+        case FTM_JVM:
+            log_simple_message(LMT_INFO, _("Detected architecture: Java Virtual Machine"));
+            break;
+        case FTM_MIPS:
+            log_simple_message(LMT_INFO, _("Detected architecture: Microprocessor without Interlocked Pipeline Stages"));
+            break;
+        case FTM_386:
+            log_simple_message(LMT_INFO, _("Detected architecture: i386"));
+            break;
+        default:
+            log_simple_message(LMT_INFO, _("Unknown architecture"));
+            goto lbf_error;
+            break;
+    }
+
+    loaded->proc = get_arch_processor_from_format(loaded->format);
+
+    return G_LOADED_BINARY(result);
+
+ lbf_error:
+
+    g_object_unref(G_OBJECT(result));
+
+    return NULL;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : context = contexte pour les recherches XPath.                *
+*                path    = chemin d'accès au noeud XML à lire.                *
+*                                                                             *
+*  Description : Charge en mémoire le contenu d'un fichier à partir d'XML.    *
+*                                                                             *
+*  Retour      : Adresse de la représentation ou NULL en cas d'échec.         *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GLoadedBinary *g_file_binary_new_from_xml(xmlXPathContextPtr context, const char *path)
+{
+    GLoadedBinary *result;                  /* Adresse à retourner         */
+    char *access;                           /* Chemin pour une sous-config.*/
+    char *filename;                         /* Chemin du binaire à charger */
+
+    result = NULL;
+
+    /* Chemin du fichier à retrouver */
+
+    access = strdup(path);
+    access = stradd(access, "/Filename");
+
+    filename = get_node_text_value(context, access);
+
+    free(access);
+
+    /* Chargement */
+
+    if (filename != NULL)
+    {
+        result = g_file_binary_new_from_file(filename);
+        free(filename);
+    }
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : binary  = élément binaire à traiter.                         *
+*                xdoc    = structure XML en cours d'édition.                  *
+*                context = contexte à utiliser pour les recherches.           *
+*                path    = chemin d'accès réservé au binaire.                 *
+*                                                                             *
+*  Description : Ecrit une sauvegarde du binaire dans un fichier XML.         *
+*                                                                             *
+*  Retour      : true si l'opération a bien tourné, false sinon.              *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static bool g_file_binary_save(const GFileBinary *binary, xmlDocPtr xdoc, xmlXPathContextPtr context, const char *path)
+{
+    bool result;                            /* Bilan à faire remonter      */
+    char *access;                           /* Chemin d'accès à un élément */
+
+    result = true;
+
+    /* Type */
+
+    result &= add_string_attribute_to_node(xdoc, context, path, "type", "file");
+
+    /* Nom du fichier associé */
+
+    access = strdup(path);
+    access = stradd(access, "/Filename");
+
+    result &= add_content_to_node(xdoc, context, access, binary->filename);
+
+    free(access);
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : binary = élément binaire à consulter.                        *
+*                full   = précise s'il s'agit d'une version longue ou non.    *
+*                                                                             *
+*  Description : Fournit le fichier correspondant à l'élément binaire.        *
+*                                                                             *
+*  Retour      : Nom de fichier avec chemin absolu.                           *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static const char *g_file_binary_get_filename(const GFileBinary *binary, bool full)
+{
+    const char *result;                     /* Description à retourner     */
+
+    if (full)
+        result = binary->filename;
+    else
+        result = strrchr(binary->filename, G_DIR_SEPARATOR) + 1;
+
+    return result;
+
+}
diff --git a/src/analysis/binaries/file.h b/src/analysis/binaries/file.h
new file mode 100644
index 0000000..3bff0a2
--- /dev/null
+++ b/src/analysis/binaries/file.h
@@ -0,0 +1,61 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * file.h - prototypes pour la prise en charge des binaires sous forme de fichier
+ *
+ * Copyright (C) 2012 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 _ANALYSIS_BINARIES_FILE_H
+#define _ANALYSIS_BINARIES_FILE_H
+
+
+#include <glib-object.h>
+
+
+#include "../binary.h"
+#include "../../common/xml.h"
+
+
+
+#define G_TYPE_FILE_BINARY               g_file_binary_get_type()
+#define G_FILE_BINARY(obj)               (G_TYPE_CHECK_INSTANCE_CAST((obj), g_file_binary_get_type(), GFileBinary))
+#define G_IS_FILE_BINARY(obj)            (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_file_binary_get_type()))
+#define G_FILE_BINARY_GET_IFACE(inst)    (G_TYPE_INSTANCE_GET_INTERFACE((inst), g_file_binary_get_type(), GFileBinaryIface))
+#define G_FILE_BINARY_GET_CLASS(obj)     (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_FILE_BINARY, GFileBinaryClass))
+
+
+/* Description de fichier binaire (instance) */
+typedef struct _GFileBinary GFileBinary;
+
+/* Description de fichier binaire (classe) */
+typedef struct _GFileBinaryClass GFileBinaryClass;
+
+
+/* Indique le type défini pour une description de fichier binaire. */
+GType g_file_binary_get_type(void);
+
+/* Charge en mémoire le contenu d'un fichier. */
+GLoadedBinary *g_file_binary_new_from_file(const char *);
+
+/* Charge en mémoire le contenu d'un fichier à partir d'XML. */
+GLoadedBinary *g_file_binary_new_from_xml(xmlXPathContextPtr, const char *);
+
+
+
+#endif  /* _ANALYSIS_BINARIES_FILE_H */
diff --git a/src/analysis/binary-int.h b/src/analysis/binary-int.h
new file mode 100644
index 0000000..c9be0bf
--- /dev/null
+++ b/src/analysis/binary-int.h
@@ -0,0 +1,84 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * binary-int.h - prototypes pour la définition interne des binaires
+ *
+ * Copyright (C) 2012 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 _ANALYSIS_BINARY_INT_H
+#define _ANALYSIS_BINARY_INT_H
+
+
+#include "binary.h"
+
+
+#include "../format/format.h"
+
+
+
+/* Ecrit une sauvegarde du binaire dans un fichier XML. */
+typedef bool (* save_binary_fc) (const GLoadedBinary *, xmlDocPtr, xmlXPathContextPtr, const char *);
+
+/* Fournit le fichier correspondant à l'élément binaire. */
+typedef const char * (* get_binary_filename_fc) (const GLoadedBinary *, bool);
+
+
+/* Description de fichier binaire (instance) */
+struct _GLoadedBinary
+{
+    GObject parent;                         /* A laisser en premier        */
+
+    save_binary_fc save;                    /* Sauvegarde au format XML    */
+    get_binary_filename_fc get_filename;    /* Obtention d'une description */
+
+    off_t bin_length;                       /* Taille des données brutes   */
+    bin_t *bin_data;                        /* Données binaires brutes     */
+
+    GExeFormat *format;                     /* Format du binaire           */
+    GArchProcessor *proc;                   /* Architecture du binaire     */
+
+    BinaryPartModel model;                  /* Modèle de sélection         */
+    GBinPart **parts[BPM_COUNT];            /* Parties binaires à analyser */
+    size_t parts_count[BPM_COUNT];          /* Quantité de ces parties     */
+
+    GArchInstruction *instrs;               /* Instructions d'assemblage   */
+    GCodeBuffer *disass_buffer;             /* Instructions lisibles       */
+    GCodeBuffer **dec_buffers;              /* Sources sous forme de texte */
+    size_t decbuf_count;                    /* Taille des tableaux         */
+    size_t defsrc;                          /* Fichier source principal    */
+
+    bool text_display[2];                   /* Position et code binaire #1 */
+    bool lines_display;                     /* Affichage des lignes        */
+
+};
+
+/* Description de fichier binaire (classe) */
+struct _GLoadedBinaryClass
+{
+    GObjectClass parent;                    /* A laisser en premier        */
+
+    /* Signaux */
+
+    void (* disassembly_done) (GLoadedBinary *);
+
+};
+
+
+
+#endif  /* _ANALYSIS_BINARY_INT_H */
diff --git a/src/analysis/binary.c b/src/analysis/binary.c
index 73070b1..fe8188b 100644
--- a/src/analysis/binary.c
+++ b/src/analysis/binary.c
@@ -24,118 +24,56 @@
 #include "binary.h"
 
 
-#include <fcntl.h>
 #include <malloc.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-#include <unistd.h>
-#include <sys/mman.h>
-#include <sys/stat.h>
 #include <sys/types.h>
 
 #include <i18n.h>
 
 
-#include "line_code.h"          /* TODO : supprimer ? */
-#include "line_comment.h"       /* TODO : supprimer ? */
-#include "line_prologue.h"
+#include "binary-int.h"
 #include "routine.h"
+#include "binaries/file.h"
 #include "decomp/decompiler.h"
 #include "disass/disassembler.h"
-#include "../common/cpp.h"
 #include "../common/extstr.h"
-#include "../debug/break.h"
-#include "../format/format.h"
-#include "../gui/panels/log.h"
-#include "../plugins/pglist.h"  /* TODO : supprimer ? */
-
-
-#include "../format/dbg_format.h"
-
-
 
 
 
 /* ------------------------ DESASSEMBLAGE DE BINAIRE DIFFERE ------------------------ */
 
 
-/* Description de fichier binaire (instance) */
-struct _GOpenidaBinary
-{
-    GObject parent;                         /* A laisser en premier        */
-
-    char *filename;                         /* Fichier chargé en mémoire   */
-
-    off_t bin_length;                       /* Taille des données brutes   */
-    bin_t *bin_data;                        /* Données binaires brutes     */
-
-    GExeFormat *format;                     /* Format du binaire           */
-    GArchProcessor *proc;                   /* Architecture du binaire     */
-
-    BinaryPartModel model;                  /* Modèle de sélection         */
-    GBinPart **parts[BPM_COUNT];            /* Parties binaires à analyser */
-    size_t parts_count[BPM_COUNT];          /* Quantité de ces parties     */
-
-    GRenderingLine *lines;                  /* Lignes de rendu en place    */
-    GRenderingOptions *options;             /* Options de désassemblage    */
-
-    GArchInstruction *instrs;               /* Instructions d'assemblage   */
-    GCodeBuffer *disass_buffer;             /* Instructions lisibles       */
-    GCodeBuffer **dec_buffers;              /* Sources sous forme de texte */
-    size_t decbuf_count;                    /* Taille des tableaux         */
-    size_t defsrc;                          /* Fichier source principal    */
-
-    bool text_display[2];                   /* Position et code binaire #1 */
-    bool lines_display;                     /* Affichage des lignes        */
-
-    GBreakGroup **brk_groups;               /* Groupes de points d'arrêt   */
-    size_t brk_count;                       /* Taille de cette liste       */
-    GBreakGroup *brk_default;               /* Groupe par défaut           */
-
-};
-
-/* Description de fichier binaire (classe) */
-struct _GOpenidaBinaryClass
-{
-    GObjectClass parent;                    /* A laisser en premier        */
-
-    /* Signaux */
-
-    void (* disassembly_done) (GOpenidaBinary *);
-
-};
-
 
 /* Initialise la classe des descriptions de fichier binaire. */
-static void g_openida_binary_class_init(GOpenidaBinaryClass *);
+static void g_loaded_binary_class_init(GLoadedBinaryClass *);
 
 /* Initialise une description de fichier binaire. */
-static void g_openida_binary_init(GOpenidaBinary *);
-
-/* Charge en mémoire le contenu d'un fichier. */
-bin_t *map_binary_file(const char *, off_t *);
-
-/* Acquitte la fin d'un désasemblage différé et complet. */
-void ack_completed_disassembly(void/*GDelayedDisassembly*/ *, GOpenidaBinary *);
+static void g_loaded_binary_init(GLoadedBinary *);
 
+/* Supprime toutes les références externes. */
+static void g_loaded_binary_dispose(GLoadedBinary *);
 
+/* Procède à la libération totale de la mémoire. */
+static void g_loaded_binary_finalize(GLoadedBinary *);
 
+/* Charge les parties intéressantes du binaire à partir d'XML. */
+static bool g_loaded_binary_load_parts_from_xml(GLoadedBinary *, xmlXPathContextPtr, const char *);
 
+/* Ecrit les parties de valeur du binaire dans un fichier XML. */
+static bool g_loaded_binary_save_parts(const GLoadedBinary *, xmlDocPtr, xmlXPathContextPtr, const char *);
 
-/* ------------------------------ ELEMENTS DE DEBOGAGE ------------------------------ */
+/* Acquitte la fin d'un désasemblage différé et complet. */
+void ack_completed_disassembly(void/*GDelayedDisassembly*/ *, GLoadedBinary *);
 
 
-/* Réagit à une nouvelle création de point d'arrêt. */
-static void g_openida_binary_breakpoint_added(GBreakGroup *, GBreakPoint *, GOpenidaBinary *);
 
-/* Réagit à une suppression de point d'arrêt. */
-static void g_openida_binary_breakpoint_removed(GBreakGroup *, GBreakPoint *, GOpenidaBinary *);
 
 
 
 /* Indique le type défini pour une description de fichier binaire. */
-G_DEFINE_TYPE(GOpenidaBinary, g_openida_binary, G_TYPE_OBJECT);
+G_DEFINE_TYPE(GLoadedBinary, g_loaded_binary, G_TYPE_OBJECT);
 
 
 /******************************************************************************
@@ -150,12 +88,19 @@ G_DEFINE_TYPE(GOpenidaBinary, g_openida_binary, G_TYPE_OBJECT);
 *                                                                             *
 ******************************************************************************/
 
-static void g_openida_binary_class_init(GOpenidaBinaryClass *klass)
+static void g_loaded_binary_class_init(GLoadedBinaryClass *klass)
 {
+    GObjectClass *object;                   /* Autre version de la classe  */
+
+    object = G_OBJECT_CLASS(klass);
+
+    object->dispose = (GObjectFinalizeFunc/* ! */)g_loaded_binary_dispose;
+    object->finalize = (GObjectFinalizeFunc)g_loaded_binary_finalize;
+
     g_signal_new("disassembly-done",
-                 G_TYPE_OPENIDA_BINARY,
+                 G_TYPE_LOADED_BINARY,
                  G_SIGNAL_RUN_LAST,
-                 G_STRUCT_OFFSET(GOpenidaBinaryClass, disassembly_done),
+                 G_STRUCT_OFFSET(GLoadedBinaryClass, disassembly_done),
                  NULL, NULL,
                  g_cclosure_marshal_VOID__VOID,
                  G_TYPE_NONE, 0);
@@ -175,133 +120,143 @@ static void g_openida_binary_class_init(GOpenidaBinaryClass *klass)
 *                                                                             *
 ******************************************************************************/
 
-static void g_openida_binary_init(GOpenidaBinary *binary)
+static void g_loaded_binary_init(GLoadedBinary *binary)
 {
     binary->text_display[0] = true;
     binary->text_display[1] = true;
 
     binary->lines_display = true;
 
-    /* FIXME : à replacer ailleurs */
-    g_openida_binary_add_break_group(binary, _("default"));
-
 }
 
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : filename = nom du fichier à charger.                         *
+*  Paramètres  : binary = instance d'objet GLib à traiter.                    *
 *                                                                             *
-*  Description : Charge en mémoire le contenu d'un fichier.                   *
+*  Description : Supprime toutes les références externes.                     *
 *                                                                             *
-*  Retour      : Adresse de la représentation ou NULL en cas d'échec.         *
+*  Retour      : -                                                            *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-GOpenidaBinary *g_openida_binary_new_from_file(const char *filename)
+static void g_loaded_binary_dispose(GLoadedBinary *binary)
 {
-    GOpenidaBinary *result;                 /* Adresse à retourner         */
-    GPluginModule **pglist;                 /* Liste de greffons           */
-    size_t pgcount;                         /* Taille de cette liste       */
-    size_t i;                               /* Boucle de parcours          */
-
+    gpointer obj_class;                     /* Classe parente              */
 
-    char *file = strdup(filename);
+    g_object_unref(G_OBJECT(binary->format));
+    g_object_unref(G_OBJECT(binary->proc));
 
-    result = g_object_new(G_TYPE_OPENIDA_BINARY, NULL);
+    /* TODO... */
 
+    /* On passe le relai */
 
+    obj_class = g_type_class_peek_parent(G_FILE_BINARY_GET_CLASS(binary));
 
+    G_OBJECT_CLASS(obj_class)->dispose(G_OBJECT(binary));
 
-    printf("%s\n", filename);
+}
 
 
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : binary = instance d'objet GLib à traiter.                    *
+*                                                                             *
+*  Description : Procède à la libération totale de la mémoire.                *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
 
-    pglist = get_all_plugins_for_action(PGA_FORMAT_MATCHER, &pgcount);
+static void g_loaded_binary_finalize(GLoadedBinary *binary)
+{
+    gpointer obj_class;                     /* Classe parente              */
 
-    if (pgcount > 0)
-    {
-        printf("===>>>> FOUND :: %d\n", pgcount);
+    /* TODO */
 
+    /* On passe le relai */
 
-        /*
-        for (i = 0; i < pgcount; i++)
-            g_plugin_module_execute_action_on_binary(pglist[i], binary, PGA_CODE_PROCESS);
-        */
-        free(pglist);
+    obj_class = g_type_class_peek_parent(G_FILE_BINARY_GET_CLASS(binary));
 
-    }
+    G_OBJECT_CLASS(obj_class)->finalize(G_OBJECT(binary));
 
+}
 
 
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : context = contexte pour les recherches XPath.                *
+*                path    = chemin d'accès au noeud XML à lire.                *
+*                                                                             *
+*  Description : Charge en mémoire le contenu d'un fichier à partir d'XML.    *
+*                                                                             *
+*  Retour      : Adresse de la représentation ou NULL en cas d'échec.         *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
 
+GLoadedBinary *g_loaded_binary_new_from_xml(xmlXPathContextPtr context, const char *path)
+{
+    GLoadedBinary *result;                  /* Adresse à retourner         */
+    char *type;                             /* Tupe de binaire à charger   */
 
+    result = NULL;
 
+    type = get_node_prop_value(context, path, "type");
 
+    if (strcmp(type, "file") == 0)
+        result = g_loaded_binary_new_from_xml(context, path);
 
+    free(type);
 
-    log_variadic_message(LMT_PROCESS, _("Opening '%s' file..."), filename);
+    if (result == NULL)
+        return NULL;
 
-    result->filename = strdup(filename);
+    if (!g_loaded_binary_load_parts_from_xml(result, context, path))
+        goto glbnfx_error;
 
-    /*
-    result->bin_data = map_binary_file(filename, &result->bin_length);
-    if (result->bin_data == NULL) goto lbf_error;
-    */
+    return result;
 
-    result->format = G_EXE_FORMAT(load_new_format(FMT_EXEC, file,
-                                                  &result->bin_data, &result->bin_length));
-    if (result->format == NULL)
-    {
-        log_simple_message(LMT_INFO, _("Unknown binary format"));
-        goto lbf_error;
-    }
+ glbnfx_error:
 
-    /* FIXME : à déplacer dans arch/... */
-    switch (g_exe_format_get_target_machine(result->format))
-    {
-        case FTM_ARM:
-            log_simple_message(LMT_INFO, _("Detected architecture: ARM"));
-            break;
-        case FTM_DALVIK:
-            log_simple_message(LMT_INFO, _("Detected architecture: Dalvik Virtual Machine"));
-            break;
-        case FTM_JVM:
-            log_simple_message(LMT_INFO, _("Detected architecture: Java Virtual Machine"));
-            break;
-        case FTM_MIPS:
-            log_simple_message(LMT_INFO, _("Detected architecture: Microprocessor without Interlocked Pipeline Stages"));
-            break;
-        case FTM_386:
-            log_simple_message(LMT_INFO, _("Detected architecture: i386"));
-            break;
-        default:
-            log_simple_message(LMT_INFO, _("Unknown architecture"));
-            goto lbf_error;
-            break;
-    }
+    g_object_unref(G_OBJECT(result));
 
-    result->lines = NULL;
+    return NULL;
 
-    result->proc = get_arch_processor_from_format(result->format);
+}
 
-    result->options = g_rendering_options_new(result->format);
 
-    g_rendering_options_show_address(result->options, MRD_BLOCK, true);
-    g_rendering_options_show_code(result->options, MRD_BLOCK, true);
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : binary  = élément binaire à traiter.                         *
+*                xdoc    = structure XML en cours d'édition.                  *
+*                context = contexte à utiliser pour les recherches.           *
+*                path    = chemin d'accès réservé au binaire.                 *
+*                                                                             *
+*  Description : Ecrit une sauvegarde du binaire dans un fichier XML.         *
+*                                                                             *
+*  Retour      : true si l'opération a bien tourné, false sinon.              *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
 
-    g_rendering_options_show_address(result->options, MRD_GRAPH, true);
-    g_rendering_options_show_code(result->options, MRD_GRAPH, false);
+bool g_loaded_binary_save(const GLoadedBinary *binary, xmlDocPtr xdoc, xmlXPathContextPtr context, const char *path)
+{
+    bool result;                            /* Bilan à faire remonter      */
 
-    return result;
+    result = binary->save(binary, xdoc, context, path);
 
- lbf_error:
+    /* Parties à désassembler */
 
-    //unload_binary_file(result);
+    result = g_loaded_binary_save_parts(binary, xdoc, context, path);
 
-    return NULL;
+    return result;
 
 }
 
@@ -311,21 +266,18 @@ GOpenidaBinary *g_openida_binary_new_from_file(const char *filename)
 *  Paramètres  : context = contexte pour les recherches XPath.                *
 *                path    = chemin d'accès au noeud XML à lire.                *
 *                                                                             *
-*  Description : Charge en mémoire le contenu d'un fichier à partir d'XML.    *
+*  Description : Charge les parties intéressantes du binaire à partir d'XML.  *
 *                                                                             *
-*  Retour      : Adresse de la représentation ou NULL en cas d'échec.         *
+*  Retour      : Bilan de l'opération.                                        *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-GOpenidaBinary *g_openida_binary_new_from_xml(xmlXPathContextPtr context, const char *path)
+static bool g_loaded_binary_load_parts_from_xml(GLoadedBinary *binary, xmlXPathContextPtr context, const char *path)
 {
-    GOpenidaBinary *result;                 /* Adresse à retourner         */
-    char *type;                             /* Tupe de binaire à charger   */
-    size_t access_len;                      /* Taille d'un chemin interne  */
+    bool result;                            /* Bilan à retourner           */
     char *access;                           /* Chemin pour une sous-config.*/
-    char *filename;                         /* Chemin du binaire à charger */
     xmlXPathObjectPtr xobjects;             /* Cible d'une recherche       */
     int i;                                  /* Boucle de parcours          */
     GBinPart *part;                         /* Partie binaire à traiter    */
@@ -334,33 +286,6 @@ GOpenidaBinary *g_openida_binary_new_from_xml(xmlXPathContextPtr context, const
 
     result = NULL;
 
-    /* Type */
-
-    type = get_node_prop_value(context, path, "type");
-
-    printf("###type### %s\n", type);
-
-    free(type);
-
-    /* Chemin du fichier à retrouver */
-
-    access = strdup(path);
-    access = stradd(access, "/Filename");
-
-    filename = get_node_text_value(context, access);
-
-    free(access);
-
-    /* Chargement */
-
-    if (filename != NULL)
-    {
-        result = g_openida_binary_new_from_file(filename);
-        free(filename);
-    }
-
-    if (result == NULL) return NULL;
-
     /* Parties à désassembler : default */
 
     access = strdup(path);
@@ -376,29 +301,29 @@ GOpenidaBinary *g_openida_binary_new_from_xml(xmlXPathContextPtr context, const
         {
             g_binary_part_get_values(part, &offset, NULL, NULL);
 
-            if (!g_exe_format_translate_offset_into_address(G_EXE_FORMAT(result->format), offset, &addr))
+            if (!g_exe_format_translate_offset_into_address(G_EXE_FORMAT(binary->format), offset, &addr))
             {
                 g_object_unref(G_OBJECT(part));
                 continue;
             }
 
-            result->parts_count[BPM_DEFAULT]++;
-            result->parts[BPM_DEFAULT] = (GBinPart **)realloc(result->parts[BPM_DEFAULT],
-                                                               result->parts_count[BPM_DEFAULT] * sizeof(GBinPart *));
+            binary->parts_count[BPM_DEFAULT]++;
+            binary->parts[BPM_DEFAULT] = (GBinPart **)realloc(binary->parts[BPM_DEFAULT],
+                                                              binary->parts_count[BPM_DEFAULT] * sizeof(GBinPart *));
 
-            result->parts[BPM_DEFAULT][result->parts_count[BPM_DEFAULT] - 1] = part;
+            binary->parts[BPM_DEFAULT][binary->parts_count[BPM_DEFAULT] - 1] = part;
 
         }
 
     }
 
-    if(xobjects != NULL)    /* FIXME */
+    if(xobjects != NULL)
         xmlXPathFreeObject(xobjects);
 
     free(access);
 
-    qsort(result->parts[BPM_DEFAULT], result->parts_count[BPM_DEFAULT],
-          sizeof(GBinPart *), g_binary_part_compare);
+    qsort(binary->parts[BPM_DEFAULT], binary->parts_count[BPM_DEFAULT],
+          sizeof(GBinPart *), (__compar_fn_t)g_binary_part_compare);
 
     /* Parties à désassembler : routines */
 
@@ -415,30 +340,30 @@ GOpenidaBinary *g_openida_binary_new_from_xml(xmlXPathContextPtr context, const
         {
             g_binary_part_get_values(part, &offset, NULL, NULL);
 
-            if (!g_exe_format_translate_offset_into_address(G_EXE_FORMAT(result->format), offset, &addr))
+            if (!g_exe_format_translate_offset_into_address(G_EXE_FORMAT(binary->format), offset, &addr))
             {
                 g_object_unref(G_OBJECT(part));
                 continue;
             }
             else g_binary_part_set_address(part, addr);
 
-            result->parts_count[BPM_ROUTINES]++;
-            result->parts[BPM_ROUTINES] = (GBinPart **)realloc(result->parts[BPM_ROUTINES],
-                                                               result->parts_count[BPM_ROUTINES] * sizeof(GBinPart *));
+            binary->parts_count[BPM_ROUTINES]++;
+            binary->parts[BPM_ROUTINES] = (GBinPart **)realloc(binary->parts[BPM_ROUTINES],
+                                                               binary->parts_count[BPM_ROUTINES] * sizeof(GBinPart *));
 
-            result->parts[BPM_ROUTINES][result->parts_count[BPM_ROUTINES] - 1] = part;
+            binary->parts[BPM_ROUTINES][binary->parts_count[BPM_ROUTINES] - 1] = part;
 
         }
 
     }
 
-    if(xobjects != NULL)    /* FIXME */
+    if(xobjects != NULL)
         xmlXPathFreeObject(xobjects);
 
     free(access);
 
-    qsort(result->parts[BPM_ROUTINES], result->parts_count[BPM_ROUTINES],
-          sizeof(GBinPart *), g_binary_part_compare);
+    qsort(binary->parts[BPM_ROUTINES], binary->parts_count[BPM_ROUTINES],
+          sizeof(GBinPart *), (__compar_fn_t)g_binary_part_compare);
 
     /* Parties à désassembler : utilisateur */
 
@@ -455,34 +380,29 @@ GOpenidaBinary *g_openida_binary_new_from_xml(xmlXPathContextPtr context, const
         {
             g_binary_part_get_values(part, &offset, NULL, NULL);
 
-            if (!g_exe_format_translate_offset_into_address(G_EXE_FORMAT(result->format), offset, &addr))
+            if (!g_exe_format_translate_offset_into_address(G_EXE_FORMAT(binary->format), offset, &addr))
             {
                 g_object_unref(G_OBJECT(part));
                 continue;
             }
 
-            result->parts_count[BPM_USER]++;
-            result->parts[BPM_USER] = (GBinPart **)realloc(result->parts[BPM_USER],
-                                                               result->parts_count[BPM_USER] * sizeof(GBinPart *));
+            binary->parts_count[BPM_USER]++;
+            binary->parts[BPM_USER] = (GBinPart **)realloc(binary->parts[BPM_USER],
+                                                           binary->parts_count[BPM_USER] * sizeof(GBinPart *));
 
-            result->parts[BPM_USER][result->parts_count[BPM_USER] - 1] = part;
+            binary->parts[BPM_USER][binary->parts_count[BPM_USER] - 1] = part;
 
         }
 
     }
 
-    if(xobjects != NULL)    /* FIXME */
+    if(xobjects != NULL)
         xmlXPathFreeObject(xobjects);
 
     free(access);
 
-    qsort(result->parts[BPM_USER], result->parts_count[BPM_USER],
-          sizeof(GBinPart *), g_binary_part_compare);
-
-
-
-
-
+    qsort(binary->parts[BPM_USER], binary->parts_count[BPM_USER],
+          sizeof(GBinPart *), (__compar_fn_t)g_binary_part_compare);
 
     return result;
 
@@ -496,7 +416,7 @@ GOpenidaBinary *g_openida_binary_new_from_xml(xmlXPathContextPtr context, const
 *                context = contexte à utiliser pour les recherches.           *
 *                path    = chemin d'accès réservé au binaire.                 *
 *                                                                             *
-*  Description : Ecrit une sauvegarde du binaire dans un fichier XML.         *
+*  Description : Ecrit les parties de valeur du binaire dans un fichier XML.  *
 *                                                                             *
 *  Retour      : true si l'opération a bien tourné, false sinon.              *
 *                                                                             *
@@ -504,7 +424,7 @@ GOpenidaBinary *g_openida_binary_new_from_xml(xmlXPathContextPtr context, const
 *                                                                             *
 ******************************************************************************/
 
-bool g_openida_binary_save(const GOpenidaBinary *binary, xmlDocPtr xdoc, xmlXPathContextPtr context, const char *path)
+static bool g_loaded_binary_save_parts(const GLoadedBinary *binary, xmlDocPtr xdoc, xmlXPathContextPtr context, const char *path)
 {
     bool result;                            /* Bilan à faire remonter      */
     char *access;                           /* Chemin d'accès à un élément */
@@ -513,21 +433,6 @@ bool g_openida_binary_save(const GOpenidaBinary *binary, xmlDocPtr xdoc, xmlXPat
 
     result = true;
 
-    /* Type */
-
-    result &= add_string_attribute_to_node(xdoc, context, path, "type", "file");
-
-    /* Nom du fichier associé */
-
-    access = strdup(path);
-    access = stradd(access, "/Filename");
-
-    result &= add_content_to_node(xdoc, context, access, binary->filename);
-
-    free(access);
-
-    /* Parties à désassembler */
-
     if (binary->parts_count[BPM_DEFAULT] > 0)
     {
         access = strdup(path);
@@ -590,9 +495,9 @@ bool g_openida_binary_save(const GOpenidaBinary *binary, xmlDocPtr xdoc, xmlXPat
 *                                                                             *
 ******************************************************************************/
 
-void g_openida_binary_set_parts(GOpenidaBinary *binary, BinaryPartModel model, GBinPart **parts, size_t count)
+void g_loaded_binary_set_parts(GLoadedBinary *binary, BinaryPartModel model, GBinPart **parts, size_t count)
 {
-    qsort(parts, count, sizeof(GBinPart *), g_binary_part_compare);
+    qsort(parts, count, sizeof(GBinPart *), (__compar_fn_t)g_binary_part_compare);
 
     binary->parts[model] = parts;
     binary->parts_count[model] = count;
@@ -614,7 +519,7 @@ void g_openida_binary_set_parts(GOpenidaBinary *binary, BinaryPartModel model, G
 *                                                                             *
 ******************************************************************************/
 
-GBinPart ***g_openida_binary_get_parts(const GOpenidaBinary *binary, BinaryPartModel *model, size_t **count)
+GBinPart ***g_loaded_binary_get_parts(const GLoadedBinary *binary, BinaryPartModel *model, size_t **count)
 {
     *model = binary->model;
     *count = binary->parts_count;
@@ -636,7 +541,7 @@ GBinPart ***g_openida_binary_get_parts(const GOpenidaBinary *binary, BinaryPartM
 *                                                                             *
 ******************************************************************************/
 
-void g_openida_binary_analyse(GOpenidaBinary *binary)
+void g_loaded_binary_analyse(GLoadedBinary *binary)
 {
     GBinPart **parts;                       /* Parties d'élément binaire   */
     size_t parts_count;                     /* Nombre de ces parties       */
@@ -660,7 +565,7 @@ void g_openida_binary_analyse(GOpenidaBinary *binary)
         else
         {
             parts = g_exe_format_get_parts(binary->format, &parts_count);
-            qsort(parts, parts_count, sizeof(GBinPart *), g_binary_part_compare);
+            qsort(parts, parts_count, sizeof(GBinPart *), (__compar_fn_t)g_binary_part_compare);
         }
     }
 
@@ -676,25 +581,7 @@ void g_openida_binary_analyse(GOpenidaBinary *binary)
 /******************************************************************************
 *                                                                             *
 *  Paramètres  : binary = élément binaire à consulter.                        *
-*                                                                             *
-*  Description : Fournit une description humaine d'un élément binaire.        *
-*                                                                             *
-*  Retour      : Chaîne de caractères humainenement lisible de représentation.*
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-const char *g_openida_binary_to_string(const GOpenidaBinary *binary)
-{
-    return binary->filename;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : binary = élément binaire à consulter.                        *
+*                full   = précise s'il s'agit d'une version longue ou non.    *
 *                                                                             *
 *  Description : Fournit le fichier correspondant à l'élément binaire.        *
 *                                                                             *
@@ -704,9 +591,9 @@ const char *g_openida_binary_to_string(const GOpenidaBinary *binary)
 *                                                                             *
 ******************************************************************************/
 
-const char *g_openida_binary_get_filename(const GOpenidaBinary *binary)
+const char *g_loaded_binary_get_filename(const GLoadedBinary *binary, bool full)
 {
-    return binary->filename;
+    return binary->get_filename(binary, full);
 
 }
 
@@ -724,7 +611,7 @@ const char *g_openida_binary_get_filename(const GOpenidaBinary *binary)
 *                                                                             *
 ******************************************************************************/
 
-bin_t *g_openida_binary_get_data(const GOpenidaBinary *binary, off_t *length)
+bin_t *g_loaded_binary_get_data(const GLoadedBinary *binary, off_t *length)
 {
     if (length != NULL)
         *length = binary->bin_length;
@@ -746,7 +633,7 @@ bin_t *g_openida_binary_get_data(const GOpenidaBinary *binary, off_t *length)
 *                                                                             *
 ******************************************************************************/
 
-GExeFormat *g_openida_binary_get_format(const GOpenidaBinary *binary)
+GExeFormat *g_loaded_binary_get_format(const GLoadedBinary *binary)
 {
     return binary->format;
 
@@ -757,63 +644,6 @@ GExeFormat *g_openida_binary_get_format(const GOpenidaBinary *binary)
 *                                                                             *
 *  Paramètres  : binary = élément binaire à consulter.                        *
 *                                                                             *
-*  Description : Fournit les options d'affichage définies pour le binaire.    *
-*                                                                             *
-*  Retour      : Adresse des options d'affichage.                             *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-GRenderingOptions *g_openida_binary_get_options(const GOpenidaBinary *binary)
-{
-    return binary->options;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : binary = élément binaire à consulter.                        *
-*                                                                             *
-*  Description : Donne la racine des lignes de rendu issues du désassemblage. *
-*                                                                             *
-*  Retour      : Lieu d'enregistrement des lignes issues du désassemblage.    *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-GRenderingLine **g_openida_binary_get_lines_root(const GOpenidaBinary *binary)
-{
-    return &binary->lines;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : binary = élément binaire à consulter.                        *
-*                                                                             *
-*  Description : Fournit les lignes de rendu issues du désassemblage.         *
-*                                                                             *
-*  Retour      : Lignes issues du désassemblage.                              *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-GRenderingLine *g_openida_binary_get_lines(const GOpenidaBinary *binary)
-{
-    return binary->lines;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : binary = élément binaire à consulter.                        *
-*                                                                             *
 *  Description : Fournit les instructions issues du désassemblage.            *
 *                                                                             *
 *  Retour      : Instructions issues du désassemblage.                        *
@@ -822,7 +652,7 @@ GRenderingLine *g_openida_binary_get_lines(const GOpenidaBinary *binary)
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *g_openida_binary_get_instructions(const GOpenidaBinary *binary)
+GArchInstruction *g_loaded_binary_get_instructions(const GLoadedBinary *binary)
 {
     return binary->instrs;
 
@@ -841,7 +671,7 @@ GArchInstruction *g_openida_binary_get_instructions(const GOpenidaBinary *binary
 *                                                                             *
 ******************************************************************************/
 
-GCodeBuffer *g_openida_binary_get_disassembled_buffer(const GOpenidaBinary *binary)
+GCodeBuffer *g_loaded_binary_get_disassembled_buffer(const GLoadedBinary *binary)
 {
     return binary->disass_buffer;
 
@@ -860,7 +690,7 @@ GCodeBuffer *g_openida_binary_get_disassembled_buffer(const GOpenidaBinary *bina
 *                                                                             *
 ******************************************************************************/
 
-bool *g_openida_binary_display_addresses_in_text(const GOpenidaBinary *binary)
+bool *g_loaded_binary_display_addresses_in_text(GLoadedBinary *binary)
 {
     return &binary->text_display[0];
 
@@ -879,7 +709,7 @@ bool *g_openida_binary_display_addresses_in_text(const GOpenidaBinary *binary)
 *                                                                             *
 ******************************************************************************/
 
-bool *g_openida_binary_display_code_in_text(const GOpenidaBinary *binary)
+bool *g_loaded_binary_display_code_in_text(GLoadedBinary *binary)
 {
     return &binary->text_display[1];
 
@@ -899,7 +729,7 @@ bool *g_openida_binary_display_code_in_text(const GOpenidaBinary *binary)
 *                                                                             *
 ******************************************************************************/
 
-GCodeBuffer *g_openida_binary_get_decompiled_buffer(const GOpenidaBinary *binary, size_t index)
+GCodeBuffer *g_loaded_binary_get_decompiled_buffer(const GLoadedBinary *binary, size_t index)
 {
     GCodeBuffer *result;                    /* Tampon à retourner          */
 
@@ -926,7 +756,7 @@ GCodeBuffer *g_openida_binary_get_decompiled_buffer(const GOpenidaBinary *binary
 *                                                                             *
 ******************************************************************************/
 
-bool *g_openida_binary_display_decomp_lines(const GOpenidaBinary *binary)
+bool *g_loaded_binary_display_decomp_lines(GLoadedBinary *binary)
 {
     return &binary->lines_display;
 
@@ -935,59 +765,6 @@ bool *g_openida_binary_display_decomp_lines(const GOpenidaBinary *binary)
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : filename = nom du fichier à charger.                         *
-*                length   = taille des données mises en mémoire. [OUT]        *
-*                                                                             *
-*  Description : Charge en mémoire le contenu d'un fichier.                   *
-*                                                                             *
-*  Retour      : Adresse du contenu binaire ou NULL en cas d'échec.           *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-bin_t *map_binary_file(const char *filename, off_t *length)
-{
-    uint8_t *result;                        /* Données à retourner         */
-    int fd;                                 /* Fichier ouvert en lecture   */
-    struct stat info;                       /* Informations sur le fichier */
-    int ret;                                /* Bilan d'un appel            */
-
-    fd = open(filename, 0, O_RDONLY);
-    if (fd == -1)
-    {
-        perror("open()");
-        return NULL;
-    }
-
-    ret = fstat(fd, &info);
-    if (ret == -1)
-    {
-        perror("fstat()");
-        close(fd);
-        return NULL;
-    }
-
-    *length = info.st_size;
-
-    result = (uint8_t *)mmap(NULL, *length, PROT_READ, MAP_PRIVATE, fd, 0);
-    if (result == MAP_FAILED)
-    {
-        perror("mmap()");
-        result = NULL;
-    }
-
-    ret = close(fd);
-    if (ret == -1)
-        perror("close()");
-
-    return result;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
 *  Paramètres  : disass = travail de désassemblage mené à bien.               *
 *                binary = représentation de binaire à l'origine de l'opérat°. *
 *                                                                             *
@@ -999,9 +776,9 @@ bin_t *map_binary_file(const char *filename, off_t *length)
 *                                                                             *
 ******************************************************************************/
 
-void ack_completed_disassembly(void/*GDelayedDisassembly*/ *disass, GOpenidaBinary *binary)
+void ack_completed_disassembly(void/*GDelayedDisassembly*/ *disass, GLoadedBinary *binary)
 {
-    GRenderingLine *line;                   /* "Première" ligne de rendu   */
+    //GRenderingLine *line;                   /* "Première" ligne de rendu   */
 
     size_t i;                               /* Boucle de parcours          */
 
@@ -1040,196 +817,3 @@ void ack_completed_disassembly(void/*GDelayedDisassembly*/ *disass, GOpenidaBina
     g_signal_emit_by_name(binary, "disassembly-done");
 
 }
-
-
-
-/* ---------------------------------------------------------------------------------- */
-/*                                ELEMENTS DE DEBOGAGE                                */
-/* ---------------------------------------------------------------------------------- */
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : binary = représentation de binaire à modifier.               *
-*                name   = éventuel nom à associer au groupe.                  *
-*                                                                             *
-*  Description : Ajoute un nouveau groupe de points d'arrêt au binaire.       *
-*                                                                             *
-*  Retour      : true si l'opération s'est bien effectuée, false sinon.       *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-bool g_openida_binary_add_break_group(GOpenidaBinary *binary, const char *name)
-{
-    bool result;                            /* Bilan à faire remonter      */
-    const char *used;                       /* Désignation à utiliser      */
-    size_t tmp_len;                         /* Longeur maximale à gérer    */
-    char *tmp;                              /* Construction temporaire     */
-    size_t i;                               /* Boucle de parcours          */
-    const char *test;                       /* Nom existant à tester       */
-
-    result = true;
-
-    /* Préparation du nom de scène */
-
-    if (name != NULL) used = name;
-    else
-    {
-        tmp_len = strlen(_("Group")) + 1 + SIZE_T_MAXLEN + 1;
-        tmp = (char *)calloc(tmp_len, sizeof(char));
-
-        snprintf(tmp, tmp_len, "%s %lu", _("Group"), binary->brk_count);
-
-        used = tmp;
-
-    }
-
-    /* Vérification d'unicité */
-
-    for (i = 0; i < binary->brk_count && result; i++)
-    {
-        test = g_break_group_get_name(binary->brk_groups[i]);
-
-        if (test != NULL)
-            result = (strcmp(used, test) != 0);
-
-    }
-
-    /* Mise en place finale */
-
-    if (result)
-    {
-        binary->brk_count++;
-        binary->brk_groups = (GBreakGroup **)realloc(binary->brk_groups,
-                                                     binary->brk_count * sizeof(GBreakGroup *));
-
-        binary->brk_groups[i] = g_break_group_new();
-
-        g_break_group_set_name(binary->brk_groups[i], used);
-
-        if (binary->brk_default == NULL)
-            binary->brk_default = binary->brk_groups[i];
-
-        g_signal_connect(binary->brk_groups[i], "added",
-                         G_CALLBACK(g_openida_binary_breakpoint_added), binary);
-
-        g_signal_connect(binary->brk_groups[i], "removed",
-                         G_CALLBACK(g_openida_binary_breakpoint_removed), binary);
-
-    }
-
-    if (name == NULL) free(tmp);
-
-    return result;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : group  = ensemble de points d'arrêt intervenant.             *
-*                point  = point d'arrêt à l'origine de la procédure.          *
-*                binary = représentation de binaire à modifier.               *
-*                                                                             *
-*  Description : Réagit à une nouvelle création de point d'arrêt.             *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static void g_openida_binary_breakpoint_added(GBreakGroup *group, GBreakPoint *point, GOpenidaBinary *binary)
-{
-    GRenderingLine *line;                   /* Ligne à retrouver           */
-
-    line = g_rendering_line_find_by_address(binary->lines, NULL, 
-                                            g_break_point_get_address(point));
-
-    if (line != NULL)
-        g_rendering_line_toggle_flag(line, RLF_BREAK_POINT);
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : group  = ensemble de points d'arrêt intervenant.             *
-*                point  = point d'arrêt à l'origine de la procédure.          *
-*                binary = représentation de binaire à modifier.               *
-*                                                                             *
-*  Description : Réagit à une suppression de point d'arrêt.                   *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static void g_openida_binary_breakpoint_removed(GBreakGroup *group, GBreakPoint *point, GOpenidaBinary *binary)
-{
-    GRenderingLine *line;                   /* Ligne à retrouver           */
-
-    line = g_rendering_line_find_by_address(binary->lines, NULL, 
-                                            g_break_point_get_address(point));
-
-    if (line != NULL)
-        g_rendering_line_toggle_flag(line, RLF_BREAK_POINT);
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : binary = représentation de binaire à mettre à jour.          *
-*                addr   = adresse mémoire à faire basculer.                   *
-*                                                                             *
-*  Description : Ajoute ou supprime un point d'arrêt dans un binaire.         *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-void g_openida_binary_toggle_breakpoint(GOpenidaBinary *binary, vmpa_t addr)
-{
-    size_t i;                               /* Boucle de parcours          */
-
-    for (i = 0; i < binary->brk_count; i++)
-        if (g_break_group_has_address(binary->brk_groups[i], addr))
-        {
-            g_break_group_toggle_breakpoint(binary->brk_groups[i], addr);
-            break;
-        }
-
-    if (i == binary->brk_count)
-        g_break_group_toggle_breakpoint(binary->brk_default, addr);
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : binary = représentation de binaire à parcourir.              *
-*                func  = fonction à appeler à chaque point trouvé.            *
-*                data  = éventuelle donnée de l'utilisateur à joindre.        *
-*                                                                             *
-*  Description : Parcourt l'ensemble des groupes de points d'arrêt du binaire.*
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-void g_openida_binary_for_each_bp_group(GOpenidaBinary *binary, GExtFunc func, gpointer data)
-{
-    size_t i;                               /* Boucle de parcours          */
-
-    for (i = 0; i < binary->brk_count; i++)
-        func(binary, binary->brk_groups[i], data);
-
-}
diff --git a/src/analysis/binary.h b/src/analysis/binary.h
index 63a9e61..7ff9080 100644
--- a/src/analysis/binary.h
+++ b/src/analysis/binary.h
@@ -32,24 +32,23 @@
 #include "line.h"
 #include "../arch/processor.h"
 #include "../common/xml.h"
-#include "../debug/break.h"
 #include "../format/executable.h"
 #include "../glibext/gcodebuffer.h"
 
 
 
-#define G_TYPE_OPENIDA_BINARY               g_openida_binary_get_type()
-#define G_OPENIDA_BINARY(obj)               (G_TYPE_CHECK_INSTANCE_CAST((obj), g_openida_binary_get_type(), GOpenidaBinary))
-#define G_IS_OPENIDA_BINARY(obj)            (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_openida_binary_get_type()))
-#define G_OPENIDA_BINARY_GET_IFACE(inst)    (G_TYPE_INSTANCE_GET_INTERFACE((inst), g_openida_binary_get_type(), GOpenidaBinaryIface))
-#define G_OPENIDA_BINARY_GET_CLASS(obj)     (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_OPENIDA_BINARY, GOpenidaBinaryClass))
+#define G_TYPE_LOADED_BINARY               g_loaded_binary_get_type()
+#define G_LOADED_BINARY(obj)               (G_TYPE_CHECK_INSTANCE_CAST((obj), g_loaded_binary_get_type(), GLoadedBinary))
+#define G_IS_LOADED_BINARY(obj)            (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_loaded_binary_get_type()))
+#define G_LOADED_BINARY_GET_IFACE(inst)    (G_TYPE_INSTANCE_GET_INTERFACE((inst), g_loaded_binary_get_type(), GLoadedBinaryIface))
+#define G_LOADED_BINARY_GET_CLASS(obj)     (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_LOADED_BINARY, GLoadedBinaryClass))
 
 
 /* Description de fichier binaire (instance) */
-typedef struct _GOpenidaBinary GOpenidaBinary;
+typedef struct _GLoadedBinary GLoadedBinary;
 
 /* Description de fichier binaire (classe) */
-typedef struct _GOpenidaBinaryClass GOpenidaBinaryClass;
+typedef struct _GLoadedBinaryClass GLoadedBinaryClass;
 
 
 /* Modèle de sélection des parties */
@@ -65,78 +64,49 @@ typedef enum _BinaryPartModel
 
 
 /* Indique le type défini pour une description de fichier binaire. */
-GType g_openida_binary_get_type(void);
-
-/* Charge en mémoire le contenu d'un fichier. */
-GOpenidaBinary *g_openida_binary_new_from_file(const char *);
+GType g_loaded_binary_get_type(void);
 
 /* Charge en mémoire le contenu d'un fichier à partir d'XML. */
-GOpenidaBinary *g_openida_binary_new_from_xml(xmlXPathContextPtr, const char *);
+GLoadedBinary *g_loaded_binary_new_from_xml(xmlXPathContextPtr, const char *);
 
 /* Ecrit une sauvegarde du binaire dans un fichier XML. */
-bool g_openida_binary_save(const GOpenidaBinary *, xmlDocPtr, xmlXPathContextPtr, const char *);
+bool g_loaded_binary_save(const GLoadedBinary *, xmlDocPtr, xmlXPathContextPtr, const char *);
 
 /* Définit les parties de binaire à analyser. */
-void g_openida_binary_set_parts(GOpenidaBinary *, BinaryPartModel, GBinPart **, size_t);
+void g_loaded_binary_set_parts(GLoadedBinary *, BinaryPartModel, GBinPart **, size_t);
 
 /* Fournit les parties de binaire analysées. */
-GBinPart ***g_openida_binary_get_parts(const GOpenidaBinary *, BinaryPartModel *, size_t **);
+GBinPart ***g_loaded_binary_get_parts(const GLoadedBinary *, BinaryPartModel *, size_t **);
 
 /* Lance l'analyse d'un élément binaire chargé. */
-void g_openida_binary_analyse(GOpenidaBinary *);
-
-/* Fournit une description humaine d'un élément binaire. */
-const char *g_openida_binary_to_string(const GOpenidaBinary *);
+void g_loaded_binary_analyse(GLoadedBinary *);
 
 /* Fournit le fichier correspondant à l'élément binaire. */
-const char *g_openida_binary_get_filename(const GOpenidaBinary *);
+const char *g_loaded_binary_get_filename(const GLoadedBinary *, bool);
 
 /* Fournit les détails du contenu binaire chargé en mémoire. */
-bin_t *g_openida_binary_get_data(const GOpenidaBinary *, off_t *);
+bin_t *g_loaded_binary_get_data(const GLoadedBinary *, off_t *);
 
 /* Fournit le format de fichier reconnu dans le contenu binaire. */
-GExeFormat *g_openida_binary_get_format(const GOpenidaBinary *);
-
-/* Fournit les options d'affichage définies pour le binaire. */
-GRenderingOptions *g_openida_binary_get_options(const GOpenidaBinary *);
-
-/* Donne la racine des lignes de rendu issues du désassemblage. */
-GRenderingLine **g_openida_binary_get_lines_root(const GOpenidaBinary *);
-
-/* Fournit les lignes de rendu issues du désassemblage. */
-GRenderingLine *g_openida_binary_get_lines(const GOpenidaBinary *);
+GExeFormat *g_loaded_binary_get_format(const GLoadedBinary *);
 
 /* Fournit les instructions issues du désassemblage. */
-GArchInstruction *g_openida_binary_get_instructions(const GOpenidaBinary *);
+GArchInstruction *g_loaded_binary_get_instructions(const GLoadedBinary *);
 
 /* Fournit le tampon associé au contenu assembleur d'un binaire. */
-GCodeBuffer *g_openida_binary_get_disassembled_buffer(const GOpenidaBinary *);
+GCodeBuffer *g_loaded_binary_get_disassembled_buffer(const GLoadedBinary *);
 
 /* Indique si les adresses doivent apparaître dans le rendu. */
-bool *g_openida_binary_display_addresses_in_text(const GOpenidaBinary *);
+bool *g_loaded_binary_display_addresses_in_text(GLoadedBinary *);
 
 /* Indique si le code doit apparaître dans le rendu. */
-bool *g_openida_binary_display_code_in_text(const GOpenidaBinary *);
+bool *g_loaded_binary_display_code_in_text(GLoadedBinary *);
 
 /* Fournit le tampon associé au contenu d'un fichier source. */
-GCodeBuffer *g_openida_binary_get_decompiled_buffer(const GOpenidaBinary *, size_t);
+GCodeBuffer *g_loaded_binary_get_decompiled_buffer(const GLoadedBinary *, size_t);
 
 /* Indique si les lignes doivent apparaître dans le rendu. */
-bool *g_openida_binary_display_decomp_lines(const GOpenidaBinary *);
-
-
-
-/* ------------------------------ ELEMENTS DE DEBOGAGE ------------------------------ */
-
-
-/* Ajoute un nouveau groupe de points d'arrêt au binaire. */
-bool g_openida_binary_add_break_group(GOpenidaBinary *, const char *);
-
-/* Ajoute ou supprime un point d'arrêt dans un binaire. */
-void g_openida_binary_toggle_breakpoint(GOpenidaBinary *, vmpa_t);
-
-/* Parcourt l'ensemble des groupes de points d'arrêt du binaire. */
-void g_openida_binary_for_each_bp_group(GOpenidaBinary *, GExtFunc, gpointer);
+bool *g_loaded_binary_display_decomp_lines(GLoadedBinary *);
 
 
 
diff --git a/src/analysis/decomp/decompiler.c b/src/analysis/decomp/decompiler.c
index 42dc1ff..8e574c0 100644
--- a/src/analysis/decomp/decompiler.c
+++ b/src/analysis/decomp/decompiler.c
@@ -42,7 +42,7 @@
 static void build_decomp_prologue(GCodeBuffer *, const char *);
 
 /* S'assure de la transcription de routines en expressions. */
-static void prepare_all_routines_for_decomp(const GOpenidaBinary *, const char *);
+static void prepare_all_routines_for_decomp(const GLoadedBinary *, const char *);
 
 
 
@@ -127,7 +127,7 @@ static void build_decomp_prologue(GCodeBuffer *buffer, const char *filename)
 *                                                                             *
 ******************************************************************************/
 
-static void prepare_all_routines_for_decomp(const GOpenidaBinary *binary, const char *filename)
+static void prepare_all_routines_for_decomp(const GLoadedBinary *binary, const char *filename)
 {
     GExeFormat *format;                     /* Format du binaire fourni    */
     GArchProcessor *proc;                   /* Architecture du binaire     */
@@ -140,7 +140,7 @@ static void prepare_all_routines_for_decomp(const GOpenidaBinary *binary, const
     GDecContext *context;                   /* Contexte pour la décompil.  */
     GDecInstruction *instr;
 
-    format = g_openida_binary_get_format(binary);
+    format = g_loaded_binary_get_format(binary);
     proc = get_arch_processor_from_format(G_EXE_FORMAT(format));
 
 
@@ -179,7 +179,7 @@ static void prepare_all_routines_for_decomp(const GOpenidaBinary *binary, const
 *                                                                             *
 ******************************************************************************/
 
-GCodeBuffer *decompile_all_from_file(const GOpenidaBinary *binary, const char *filename)
+GCodeBuffer *decompile_all_from_file(const GLoadedBinary *binary, const char *filename)
 {
     GCodeBuffer *result;                    /* Tampon constitué à renvoyer */
     GExeFormat *format;                     /* Format du binaire fourni    */
@@ -195,7 +195,7 @@ GCodeBuffer *decompile_all_from_file(const GOpenidaBinary *binary, const char *f
 
 
 
-    format = g_openida_binary_get_format(binary);
+    format = g_loaded_binary_get_format(binary);
     g_binary_format_decompile(G_BIN_FORMAT(format), result, filename);
 
     return result;
diff --git a/src/analysis/decomp/decompiler.h b/src/analysis/decomp/decompiler.h
index 363ad27..5233b74 100644
--- a/src/analysis/decomp/decompiler.h
+++ b/src/analysis/decomp/decompiler.h
@@ -30,7 +30,7 @@
 
 
 /* Procède à la décompilation des routines d'un fichier donné. */
-GCodeBuffer *decompile_all_from_file(const GOpenidaBinary *, const char *);
+GCodeBuffer *decompile_all_from_file(const GLoadedBinary *, const char *);
 
 
 
diff --git a/src/analysis/disass/disassembler.c b/src/analysis/disass/disassembler.c
index 872dc09..73d75cf 100644
--- a/src/analysis/disass/disassembler.c
+++ b/src/analysis/disass/disassembler.c
@@ -60,7 +60,7 @@ typedef struct _GDelayedDisassembly
 {
     GDelayedWork parent;                    /* A laisser en premier        */
 
-    const GOpenidaBinary *binary;           /* Destinataire final          */
+    const GLoadedBinary *binary;            /* Destinataire final          */
     const GExeFormat *format;               /* Format du binaire représenté*/
 
     GBinPart **parts;                       /* Parties binaires à traiter  */
@@ -89,7 +89,7 @@ static void g_delayed_disassembly_class_init(GDelayedDisassemblyClass *);
 static void g_delayed_disassembly_init(GDelayedDisassembly *);
 
 /* Crée une tâche de désassemblage différé. */
-static GDelayedDisassembly *g_delayed_disassembly_new(const GOpenidaBinary *, GBinPart **, size_t, GCodeBuffer *);
+static GDelayedDisassembly *g_delayed_disassembly_new(const GLoadedBinary *, GBinPart **, size_t, GCodeBuffer *);
 
 /* Assure le désassemblage en différé. */
 static void g_delayed_disassembly_process(GDelayedDisassembly *, GtkExtStatusBar *);
@@ -165,14 +165,14 @@ static void g_delayed_disassembly_init(GDelayedDisassembly *disass)
 *                                                                             *
 ******************************************************************************/
 
-static GDelayedDisassembly *g_delayed_disassembly_new(const GOpenidaBinary *binary, GBinPart **parts, size_t count, GCodeBuffer *buffer)
+static GDelayedDisassembly *g_delayed_disassembly_new(const GLoadedBinary *binary, GBinPart **parts, size_t count, GCodeBuffer *buffer)
 {
     GDelayedDisassembly *result;            /* Tâche à retourner           */
 
     result = g_object_new(G_TYPE_DELAYED_DISASSEMBLY, NULL);
 
     result->binary = binary;
-    result->format = g_openida_binary_get_format(binary);
+    result->format = g_loaded_binary_get_format(binary);
 
     result->parts = parts;
     result->count = count;
@@ -381,7 +381,7 @@ static void build_disass_prologue(GCodeBuffer *buffer, const char *filename, con
 *                                                                             *
 ******************************************************************************/
 
-void disassemble_binary(GOpenidaBinary *binary, GBinPart **parts, size_t parts_count, GArchInstruction **instrs, GCodeBuffer **buffer)
+void disassemble_binary(GLoadedBinary *binary, GBinPart **parts, size_t parts_count, GArchInstruction **instrs, GCodeBuffer **buffer)
 {
     const uint8_t *data;                    /* Données binaires brutes     */
     off_t length;                           /* Quantité de ces données     */
@@ -395,8 +395,8 @@ void disassemble_binary(GOpenidaBinary *binary, GBinPart **parts, size_t parts_c
 
     *buffer = g_code_buffer_new();
 
-    data = g_openida_binary_get_data(binary, &length);
-    build_disass_prologue(*buffer, g_openida_binary_get_filename(binary), data, length);
+    data = g_loaded_binary_get_data(binary, &length);
+    build_disass_prologue(*buffer, g_loaded_binary_get_filename(binary, true), data, length);
 
     disass = g_delayed_disassembly_new(binary, parts, parts_count, *buffer);
 
diff --git a/src/analysis/disass/disassembler.h b/src/analysis/disass/disassembler.h
index 2c5adef..8cca194 100644
--- a/src/analysis/disass/disassembler.h
+++ b/src/analysis/disass/disassembler.h
@@ -31,7 +31,7 @@
 
 
 /* Procède à la décompilation des routines d'un fichier donné. */
-void disassemble_binary(GOpenidaBinary *, GBinPart **parts, size_t parts_count, GArchInstruction **, GCodeBuffer **);
+void disassemble_binary(GLoadedBinary *, GBinPart **parts, size_t parts_count, GArchInstruction **, GCodeBuffer **);
 
 
 
diff --git a/src/analysis/disass/fetch.c b/src/analysis/disass/fetch.c
index 6bd9795..a1df5e3 100644
--- a/src/analysis/disass/fetch.c
+++ b/src/analysis/disass/fetch.c
@@ -45,7 +45,7 @@
 *                                                                             *
 ******************************************************************************/
 
-GArchInstruction *disassemble_binary_parts(const GOpenidaBinary *binary, GBinPart **parts, size_t count, GtkExtStatusBar *statusbar, guint id)
+GArchInstruction *disassemble_binary_parts(const GLoadedBinary *binary, GBinPart **parts, size_t count, GtkExtStatusBar *statusbar, guint id)
 {
     GArchInstruction *result;               /* Liste d'instr. à renvoyer   */
     GBinFormat *format;                     /* Format du fichier binaire   */
@@ -69,9 +69,9 @@ GArchInstruction *disassemble_binary_parts(const GOpenidaBinary *binary, GBinPar
 
     result = NULL;
 
-    format = G_BIN_FORMAT(g_openida_binary_get_format(binary));
+    format = G_BIN_FORMAT(g_loaded_binary_get_format(binary));
     proc = get_arch_processor_from_format(G_EXE_FORMAT(format));
-    bin_data = g_openida_binary_get_data(binary, &bin_length);
+    bin_data = g_loaded_binary_get_data(binary, &bin_length);
 
     /* Préparation du suivi de la progression */
 
diff --git a/src/analysis/disass/fetch.h b/src/analysis/disass/fetch.h
index 09bb584..89c3226 100644
--- a/src/analysis/disass/fetch.h
+++ b/src/analysis/disass/fetch.h
@@ -31,7 +31,7 @@
 
 
 /* Procède au désassemblage basique d'un contenu binaire. */
-GArchInstruction *disassemble_binary_parts(const GOpenidaBinary *, GBinPart **, size_t, GtkExtStatusBar *, guint);
+GArchInstruction *disassemble_binary_parts(const GLoadedBinary *, GBinPart **, size_t, GtkExtStatusBar *, guint);
 
 
 
diff --git a/src/debug/debugger-int.h b/src/debug/debugger-int.h
index f6f51ad..c978731 100644
--- a/src/debug/debugger-int.h
+++ b/src/debug/debugger-int.h
@@ -56,7 +56,7 @@ struct _GBinaryDebugger
 {
     GObject parent;                         /* A laisser en premier        */
 
-    GOpenidaBinary *binary;                 /* Cible à traiter             */
+    GLoadedBinary *binary;                  /* Cible à traiter             */
 
     attach_debugger_fc attach;              /* Démarre le débogueur        */
 
diff --git a/src/debug/debugger.c b/src/debug/debugger.c
index 73b8719..19f4f65 100644
--- a/src/debug/debugger.c
+++ b/src/debug/debugger.c
@@ -108,7 +108,7 @@ static void g_binary_debugger_init(GBinaryDebugger *debugger)
 *                                                                             *
 ******************************************************************************/
 
-GBinaryDebugger *g_new_binary_debugger(DebuggerType type, GOpenidaBinary *binary)
+GBinaryDebugger *g_new_binary_debugger(DebuggerType type, GLoadedBinary *binary)
 {
     GBinaryDebugger *result;
 
diff --git a/src/debug/debugger.h b/src/debug/debugger.h
index 7a6459b..e4c9458 100644
--- a/src/debug/debugger.h
+++ b/src/debug/debugger.h
@@ -85,7 +85,7 @@ typedef struct _GBinaryDebuggerClass GBinaryDebuggerClass;
 GType g_binary_debugger_get_type(void);
 
 /* Crée un nouveau débogueur. */
-GBinaryDebugger *g_new_binary_debugger(DebuggerType, GOpenidaBinary *);
+GBinaryDebugger *g_new_binary_debugger(DebuggerType, GLoadedBinary *);
 
 /* Démarre une procédure de débogage. */
 bool g_binary_debugger_attach(GBinaryDebugger *);
diff --git a/src/debug/jdwp/debugger.c b/src/debug/jdwp/debugger.c
index b416840..d63c068 100644
--- a/src/debug/jdwp/debugger.c
+++ b/src/debug/jdwp/debugger.c
@@ -147,7 +147,7 @@ static void g_java_debugger_init(GJavaDebugger *debugger)
 *                                                                             *
 ******************************************************************************/
 
-GBinaryDebugger *g_java_debugger_new(GOpenidaBinary *binary, void *options)
+GBinaryDebugger *g_java_debugger_new(GLoadedBinary *binary, void *options)
 {
     GBinaryDebugger *result;                /* Débogueur à retourner       */
 
diff --git a/src/debug/jdwp/debugger.h b/src/debug/jdwp/debugger.h
index c19a415..69a1545 100644
--- a/src/debug/jdwp/debugger.h
+++ b/src/debug/jdwp/debugger.h
@@ -51,7 +51,7 @@ typedef struct _GJavaDebuggerClass GJavaDebuggerClass;
 GType g_java_debugger_get_type(void);
 
 /* Crée un débogueur utilisant un serveur Java distant. */
-GBinaryDebugger *g_java_debugger_new(GOpenidaBinary *, void *);
+GBinaryDebugger *g_java_debugger_new(GLoadedBinary *, void *);
 
 
 void test_java(void);
diff --git a/src/debug/remgdb/gdb.c b/src/debug/remgdb/gdb.c
index caff762..681ff00 100644
--- a/src/debug/remgdb/gdb.c
+++ b/src/debug/remgdb/gdb.c
@@ -149,7 +149,7 @@ static void g_gdb_debugger_init(GGdbDebugger *debugger)
 *                                                                             *
 ******************************************************************************/
 
-GBinaryDebugger *g_gdb_debugger_new(GOpenidaBinary *binary, void *options)
+GBinaryDebugger *g_gdb_debugger_new(GLoadedBinary *binary, void *options)
 {
     GBinaryDebugger *result;                /* Débogueur à retourner       */
 
diff --git a/src/debug/remgdb/gdb.h b/src/debug/remgdb/gdb.h
index 6cda59e..30ee2f0 100644
--- a/src/debug/remgdb/gdb.h
+++ b/src/debug/remgdb/gdb.h
@@ -51,7 +51,7 @@ typedef struct _GGdbDebuggerClass GGdbDebuggerClass;
 GType g_gdb_debugger_get_type(void);
 
 /* Crée un débogueur utilisant un serveur GDB distant. */
-GBinaryDebugger *g_gdb_debugger_new(GOpenidaBinary *, void *);
+GBinaryDebugger *g_gdb_debugger_new(GLoadedBinary *, void *);
 
 
 void test_gdb(void);
diff --git a/src/dialogs/add_shellcode.c b/src/dialogs/add_shellcode.c
index 78bfb9d..65e081b 100644
--- a/src/dialogs/add_shellcode.c
+++ b/src/dialogs/add_shellcode.c
@@ -184,7 +184,7 @@ static void export_assistant_cancel(GtkAssistant *assistant, gpointer data)
 
 static void export_assistant_close(GtkAssistant *assistant, GObject *ref)
 {
-    GOpenidaBinary *binary;                 /* Binaire chargé à parcourir  */
+    GLoadedBinary *binary;                  /* Binaire chargé à parcourir  */
     GExeFormat *format;                     /* Format du binaire           */
     GRenderingOptions *options;             /* Options d'exportation       */
     GtkToggleButton *checkbutton;           /* Coche à retrouver           */
@@ -192,9 +192,9 @@ static void export_assistant_close(GtkAssistant *assistant, GObject *ref)
     GtkEntry *entry;                        /* Zone de saisie              */
     const gchar *filename;                  /* Chemin d'accès du fichier   */
 
-    //binary = G_OPENIDA_BINARY(g_object_get_data(ref, "binary"));
+    //binary = G_LOADED_BINARY(g_object_get_data(ref, "binary"));
 
-    format = g_openida_binary_get_format(binary);
+    format = g_loaded_binary_get_format(binary);
     options = g_rendering_options_new(format);
 
     /* Eléments à afficher */
@@ -285,8 +285,8 @@ static void register_bincode_panel(GtkAssistant *assistant)
 
     /* Choix par défaut */
     /*
-    binary = G_OPENIDA_BINARY(g_object_get_data(G_OBJECT(assistant), "binary"));
-    filename = g_openida_binary_get_filename(binary);
+    binary = G_LOADED_BINARY(g_object_get_data(G_OBJECT(assistant), "binary"));
+    filename = g_loaded_binary_get_filename(binary);
 
     gtk_entry_set_text(GTK_ENTRY(entry), filename);
     gtk_entry_append_text(GTK_ENTRY(entry), ".txt");
@@ -611,7 +611,7 @@ static void register_output_panel(GtkAssistant *assistant)
     GtkWidget *combobox;                    /* Sélection du format         */
     GtkWidget *entry;                       /* Zone de saisie de texte     */
     GtkWidget *button;                      /* Sélection de fichier        */
-    GOpenidaBinary *binary;                 /* Binaire chargé à parcourir  */
+    GLoadedBinary *binary;                  /* Binaire chargé à parcourir  */
     const char *filename;                   /* Chemin d'accès par défaut   */
 
     alignment = qck_create_padded_alignment(8, 8, 8, 8);
@@ -661,8 +661,8 @@ static void register_output_panel(GtkAssistant *assistant)
 
     /* Choix par défaut */
     /*
-    binary = G_OPENIDA_BINARY(g_object_get_data(G_OBJECT(assistant), "binary"));
-    filename = g_openida_binary_get_filename(binary);
+    binary = G_LOADED_BINARY(g_object_get_data(G_OBJECT(assistant), "binary"));
+    filename = g_loaded_binary_get_filename(binary);
 
     gtk_entry_set_text(GTK_ENTRY(entry), filename);
     gtk_entry_append_text(GTK_ENTRY(entry), ".txt");
diff --git a/src/dialogs/binparts.c b/src/dialogs/binparts.c
index 054c7bf..14e1422 100644
--- a/src/dialogs/binparts.c
+++ b/src/dialogs/binparts.c
@@ -68,7 +68,7 @@ static void save_current_selection(GtkButton *, GObject *);
 static void close_editor(GtkButton *, GtkWidget *);
 
 /* Charge les parties courantes d'un binaire donné. */
-static void load_binary_current_parts(GOpenidaBinary *binary, GObject *ref);
+static void load_binary_current_parts(GLoadedBinary *binary, GObject *ref);
 
 /* Affiche les parties désassemblées par défaut. */
 static void load_default_parts(GObject *);
@@ -99,7 +99,7 @@ static void on_part_selection_toggle(GtkCellRendererToggle *, gchar *, GObject *
 *                                                                             *
 ******************************************************************************/
 
-GtkWidget *create_sections_dialog(GOpenidaBinary *binary, GtkWindow *parent)
+GtkWidget *create_sections_dialog(GLoadedBinary *binary, GtkWindow *parent)
 {
     GtkWidget *result;                      /* Fenêtre à renvoyer          */
     GObject *ref;                           /* Espace de référencements    */
@@ -345,7 +345,7 @@ static void save_current_selection(GtkButton *button, GObject *ref)
 
 
 
-    GOpenidaBinary *binary;                 /* Binaire à traiter           */
+    GLoadedBinary *binary;                  /* Binaire à traiter           */
 
     GExeFormat *format;                     /* Format associé au binaire   */
     GArchProcessor *proc;                   /* Architecture utilisée       */
@@ -363,9 +363,9 @@ static void save_current_selection(GtkButton *button, GObject *ref)
     off_t offset;                           /* Position dans le binaire    */
 
 
-    binary = G_OPENIDA_BINARY(g_object_get_data(ref, "binary"));
+    binary = G_LOADED_BINARY(g_object_get_data(ref, "binary"));
 
-    format = g_openida_binary_get_format(binary);
+    format = g_loaded_binary_get_format(binary);
     proc = get_arch_processor_from_format(format);
 
 
@@ -402,7 +402,7 @@ static void save_current_selection(GtkButton *button, GObject *ref)
 
     }
 
-    g_openida_binary_set_parts(binary, BPM_ROUTINES, parts, parts_count);
+    g_loaded_binary_set_parts(binary, BPM_ROUTINES, parts, parts_count);
 
 
 
@@ -451,7 +451,7 @@ static void close_editor(GtkButton *button, GtkWidget *widget)
 *                                                                             *
 ******************************************************************************/
 
-static void load_binary_current_parts(GOpenidaBinary *binary, GObject *ref)
+static void load_binary_current_parts(GLoadedBinary *binary, GObject *ref)
 {
     GtkTreeModel *store;                    /* Modèle de représentation    */
     GBinPart ***list;                       /* Tableau de parties choisies */
@@ -472,7 +472,7 @@ static void load_binary_current_parts(GOpenidaBinary *binary, GObject *ref)
 
     store = GTK_TREE_MODEL(g_object_get_data(ref, "store"));
 
-    list = g_openida_binary_get_parts(binary, &model, &count);
+    list = g_loaded_binary_get_parts(binary, &model, &count);
 
     for (i = 0; i < (BPM_COUNT - 1 /* TODO*/); i++)
     {
@@ -535,7 +535,7 @@ static void load_binary_current_parts(GOpenidaBinary *binary, GObject *ref)
 
 static void load_default_parts(GObject *ref)
 {
-    GOpenidaBinary *binary;                 /* Binaire à traiter           */
+    GLoadedBinary *binary;                  /* Binaire à traiter           */
     GtkTreeStore *store;                    /* Modèle de gestion           */
     GExeFormat *format;                     /* Format associé au binaire   */
     GArchProcessor *proc;                   /* Architecture utilisée       */
@@ -550,10 +550,10 @@ static void load_default_parts(GObject *ref)
     char end[VMPA_MAX_SIZE];                /* Version humainement lisible */
     GtkTreeIter iter;                       /* Point d'insertion           */
 
-    binary = G_OPENIDA_BINARY(g_object_get_data(ref, "binary"));
+    binary = G_LOADED_BINARY(g_object_get_data(ref, "binary"));
     store = GTK_TREE_STORE(g_object_get_data(ref, "store"));
 
-    format = g_openida_binary_get_format(binary);
+    format = g_loaded_binary_get_format(binary);
     proc = get_arch_processor_from_format(format);
 
     parts = g_exe_format_get_parts(format, &parts_count);
@@ -609,7 +609,7 @@ static void load_default_parts(GObject *ref)
 
 static void load_routines_parts(GObject *ref)
 {
-    GOpenidaBinary *binary;                 /* Binaire à traiter           */
+    GLoadedBinary *binary;                  /* Binaire à traiter           */
     GtkTreeStore *store;                    /* Modèle de gestion           */
     GExeFormat *format;                     /* Format associé au binaire   */
     GArchProcessor *proc;                   /* Architecture utilisée       */
@@ -623,10 +623,10 @@ static void load_routines_parts(GObject *ref)
     char end[VMPA_MAX_SIZE];                /* Version humainement lisible */
     GtkTreeIter iter;                       /* Point d'insertion           */
 
-    binary = G_OPENIDA_BINARY(g_object_get_data(ref, "binary"));
+    binary = G_LOADED_BINARY(g_object_get_data(ref, "binary"));
     store = GTK_TREE_STORE(g_object_get_data(ref, "store"));
 
-    format = g_openida_binary_get_format(binary);
+    format = g_loaded_binary_get_format(binary);
     proc = get_arch_processor_from_format(format);
 
     routines = g_binary_format_get_routines(G_BIN_FORMAT(format), &routines_count);
diff --git a/src/dialogs/binparts.h b/src/dialogs/binparts.h
index 0880f85..e21d990 100644
--- a/src/dialogs/binparts.h
+++ b/src/dialogs/binparts.h
@@ -33,7 +33,7 @@
 
 
 /* Construit la fenêtre de sélection des sections. */
-GtkWidget *create_sections_dialog(GOpenidaBinary *, GtkWindow *);
+GtkWidget *create_sections_dialog(GLoadedBinary *, GtkWindow *);
 
 
 
diff --git a/src/dialogs/export.c b/src/dialogs/export.c
index e514511..317ada4 100644
--- a/src/dialogs/export.c
+++ b/src/dialogs/export.c
@@ -103,7 +103,7 @@ static void register_content_panel(GtkAssistant *);
 *                                                                             *
 ******************************************************************************/
 
-void run_export_assistant(GOpenidaBinary *binary, GtkWindow *parent)
+void run_export_assistant(GLoadedBinary *binary, GtkWindow *parent)
 {
     GtkWidget *assistant;                   /* Fenêtre à afficher          */
     GObject *ref;                           /* Espace de référencement     */
@@ -170,7 +170,7 @@ static void export_assistant_close(GtkAssistant *assistant, GObject *ref)
     int fd;                                 /* Descripteur de la sortie    */
     struct _export_data *export;            /* Informations à faire suivre */
     GtkToggleButton *checkbutton;           /* Coche à retrouver           */
-    GOpenidaBinary *binary;                 /* Binaire chargé à parcourir  */
+    GLoadedBinary *binary;                  /* Binaire chargé à parcourir  */
     GCodeBuffer *buffer;                    /* Tampon de code à traiter    */
 
     /* Fichier de sortie */
@@ -206,9 +206,9 @@ static void export_assistant_close(GtkAssistant *assistant, GObject *ref)
 
     /* Programmation de la tâche */
 
-    binary = G_OPENIDA_BINARY(g_object_get_data(ref, "binary"));
+    binary = G_LOADED_BINARY(g_object_get_data(ref, "binary"));
 
-    buffer = g_openida_binary_get_disassembled_buffer(binary);
+    buffer = g_loaded_binary_get_disassembled_buffer(binary);
 
     g_buffer_code_scan(buffer, 0, VMPA_MAX, _("Exporting binary lines..."),
                        (process_line_fc)export_buffer_line, export);
@@ -277,7 +277,7 @@ static void register_output_panel(GtkAssistant *assistant)
     GtkWidget *combobox;                    /* Sélection du format         */
     GtkWidget *entry;                       /* Zone de saisie de texte     */
     GtkWidget *button;                      /* Sélection de fichier        */
-    GOpenidaBinary *binary;                 /* Binaire chargé à parcourir  */
+    GLoadedBinary *binary;                  /* Binaire chargé à parcourir  */
     const char *filename;                   /* Chemin d'accès par défaut   */
 
     alignment = qck_create_padded_alignment(8, 8, 8, 8);
@@ -327,8 +327,8 @@ static void register_output_panel(GtkAssistant *assistant)
 
     /* Choix par défaut */
 
-    binary = G_OPENIDA_BINARY(g_object_get_data(G_OBJECT(assistant), "binary"));
-    filename = g_openida_binary_get_filename(binary);
+    binary = G_LOADED_BINARY(g_object_get_data(G_OBJECT(assistant), "binary"));
+    filename = g_loaded_binary_get_filename(binary, true);
 
     gtk_entry_set_text(GTK_ENTRY(entry), filename);
     gtk_editable_insert_text(GTK_EDITABLE(entry), ".txt", -1, (gint []) { strlen(filename) });
diff --git a/src/dialogs/export.h b/src/dialogs/export.h
index c14d05d..3274b12 100644
--- a/src/dialogs/export.h
+++ b/src/dialogs/export.h
@@ -30,7 +30,7 @@
 
 
 /* Crée et affiche un assistant d'aide à l'exportation. */
-void run_export_assistant(GOpenidaBinary *, GtkWindow *);
+void run_export_assistant(GLoadedBinary *, GtkWindow *);
 
 
 
diff --git a/src/dialogs/plugins.c b/src/dialogs/plugins.c
index b5e045b..e74296e 100644
--- a/src/dialogs/plugins.c
+++ b/src/dialogs/plugins.c
@@ -47,7 +47,7 @@
 *                                                                             *
 ******************************************************************************/
 
-GtkWidget *create_plugins_selection_dialog(GOpenidaBinary *binary, GtkWindow *parent)
+GtkWidget *create_plugins_selection_dialog(GLoadedBinary *binary, GtkWindow *parent)
 {
     GtkWidget *result;                      /* Fenêtre à renvoyer          */
     GObject *ref;                           /* Espace de référencements    */
@@ -146,7 +146,6 @@ GtkWidget *create_plugins_selection_dialog(GOpenidaBinary *binary, GtkWindow *pa
     button7 = gtk_button_new();
     gtk_widget_show(button7);
     gtk_container_add(GTK_CONTAINER(vbuttonbox1), button7);
-    GTK_WIDGET_SET_FLAGS(button7, GTK_CAN_DEFAULT);
 
     image3 = gtk_image_new_from_stock("gtk-add", GTK_ICON_SIZE_BUTTON);
     gtk_widget_show(image3);
@@ -155,7 +154,6 @@ GtkWidget *create_plugins_selection_dialog(GOpenidaBinary *binary, GtkWindow *pa
     button8 = gtk_button_new();
     gtk_widget_show(button8);
     gtk_container_add(GTK_CONTAINER(vbuttonbox1), button8);
-    GTK_WIDGET_SET_FLAGS(button8, GTK_CAN_DEFAULT);
 
     image4 = gtk_image_new_from_stock("gtk-remove", GTK_ICON_SIZE_BUTTON);
     gtk_widget_show(image4);
@@ -174,7 +172,6 @@ GtkWidget *create_plugins_selection_dialog(GOpenidaBinary *binary, GtkWindow *pa
     button9 = gtk_button_new();
     gtk_widget_show(button9);
     gtk_container_add(GTK_CONTAINER(vbuttonbox2), button9);
-    GTK_WIDGET_SET_FLAGS(button9, GTK_CAN_DEFAULT);
 
     image5 = gtk_image_new_from_stock("gtk-go-up", GTK_ICON_SIZE_BUTTON);
     gtk_widget_show(image5);
@@ -183,7 +180,6 @@ GtkWidget *create_plugins_selection_dialog(GOpenidaBinary *binary, GtkWindow *pa
     button10 = gtk_button_new();
     gtk_widget_show(button10);
     gtk_container_add(GTK_CONTAINER(vbuttonbox2), button10);
-    GTK_WIDGET_SET_FLAGS(button10, GTK_CAN_DEFAULT);
 
     image6 = gtk_image_new_from_stock("gtk-go-down", GTK_ICON_SIZE_BUTTON);
     gtk_widget_show(image6);
@@ -276,7 +272,6 @@ GtkWidget *create_plugins_selection_dialog(GOpenidaBinary *binary, GtkWindow *pa
     button1 = gtk_button_new();
     gtk_widget_show(button1);
     gtk_container_add(GTK_CONTAINER(hbuttonbox1), button1);
-    GTK_WIDGET_SET_FLAGS(button1, GTK_CAN_DEFAULT);
 
     alignment1 = gtk_alignment_new(0.5, 0.5, 0, 0);
     gtk_widget_show(alignment1);
@@ -297,7 +292,6 @@ GtkWidget *create_plugins_selection_dialog(GOpenidaBinary *binary, GtkWindow *pa
     button2 = gtk_button_new();
     gtk_widget_show(button2);
     gtk_container_add(GTK_CONTAINER(hbuttonbox1), button2);
-    GTK_WIDGET_SET_FLAGS(button2, GTK_CAN_DEFAULT);
 
     alignment2 = gtk_alignment_new(0.5, 0.5, 0, 0);
     gtk_widget_show(alignment2);
diff --git a/src/dialogs/plugins.h b/src/dialogs/plugins.h
index f0ea164..32901fb 100644
--- a/src/dialogs/plugins.h
+++ b/src/dialogs/plugins.h
@@ -33,7 +33,7 @@
 
 
 /* Construit la fenêtre de sélection des sections. */
-GtkWidget *create_plugins_selection_dialog(GOpenidaBinary *, GtkWindow *);
+GtkWidget *create_plugins_selection_dialog(GLoadedBinary *, GtkWindow *);
 
 
 
diff --git a/src/editor.c b/src/editor.c
index 54149ff..3c861d1 100644
--- a/src/editor.c
+++ b/src/editor.c
@@ -119,7 +119,7 @@ void update_debug_menu_items(GObject *, gboolean);
 static void on_dock_item_switch(GtkDockPanel *, GtkWidget *, GObject *);
 
 /* Met en concordance les menus avec l'édition courante. */
-static void refresh_editor_menus(GObject *, GOpenidaBinary *, GtkBinView *);
+static void refresh_editor_menus(GObject *, GLoadedBinary *, GtkBinView *);
 
 
 
@@ -681,10 +681,10 @@ void mcb_open_recent_project(GtkMenuItem *menuitem, GObject *ref)
 
 static void mcb_binary_select_parts(GtkMenuItem *menuitem, GObject *ref)
 {
-    GOpenidaBinary *binary;                 /* Binaire courant à l'écran   */
+    GLoadedBinary *binary;                  /* Binaire courant à l'écran   */
     GtkWidget *dialog;                      /* Boîte de dialogue à montrer */
 
-    binary = G_OPENIDA_BINARY(g_object_get_data(ref, "current_binary"));
+    binary = G_LOADED_BINARY(g_object_get_data(ref, "current_binary"));
 
     dialog = create_sections_dialog(binary, GTK_WINDOW(ref));
     gtk_widget_show(dialog);
@@ -707,10 +707,10 @@ static void mcb_binary_select_parts(GtkMenuItem *menuitem, GObject *ref)
 
 static void mcb_binary_select_plugins(GtkMenuItem *menuitem, GObject *ref)
 {
-    GOpenidaBinary *binary;                 /* Binaire courant à l'écran   */
+    GLoadedBinary *binary;                  /* Binaire courant à l'écran   */
     GtkWidget *dialog;                      /* Boîte de dialogue à montrer */
 
-    binary = G_OPENIDA_BINARY(g_object_get_data(ref, "current_binary"));
+    binary = G_LOADED_BINARY(g_object_get_data(ref, "current_binary"));
 
     dialog = create_plugins_selection_dialog(binary, GTK_WINDOW(ref));
     gtk_widget_show(dialog);
@@ -723,10 +723,10 @@ static void mcb_binary_select_plugins(GtkMenuItem *menuitem, GObject *ref)
 
 void debugger_stopped_cb(GBinaryDebugger *debugger, uint64_t last, uint64_t cur, gpointer data)
 {
-
+#if 0
     GObject *ref;
 
-    GOpenidaBinary *binary;
+    GLoadedBinary *binary;
     GRenderingLine *line;
 
 
@@ -744,7 +744,7 @@ void debugger_stopped_cb(GBinaryDebugger *debugger, uint64_t last, uint64_t cur,
 
     if (last != cur)
     {
-        line = g_rendering_line_find_by_address(g_openida_binary_get_lines(binary), NULL/* FIXME */, last);
+        line = g_rendering_line_find_by_address(g_loaded_binary_get_lines(binary), NULL/* FIXME */, last);
 
         if (line != NULL)
             g_rendering_line_remove_flag(line, RLF_RUNNING_BP);
@@ -754,7 +754,7 @@ void debugger_stopped_cb(GBinaryDebugger *debugger, uint64_t last, uint64_t cur,
 
     printf("bp at 0x%016llx\n", cur);
 
-    line = g_rendering_line_find_by_address(g_openida_binary_get_lines(binary), NULL/* FIXME */, cur);
+    line = g_rendering_line_find_by_address(g_loaded_binary_get_lines(binary), NULL/* FIXME */, cur);
 
     if (line != NULL)
         g_rendering_line_add_flag(line, RLF_RUNNING_BP);
@@ -780,7 +780,7 @@ void debugger_stopped_cb(GBinaryDebugger *debugger, uint64_t last, uint64_t cur,
 
     refresh_registers_panel_with_registers(get_panel(PNT_REGISTERS), values, count);
 
-
+#endif
 
 }
 
@@ -800,7 +800,7 @@ void debugger_stopped_cb(GBinaryDebugger *debugger, uint64_t last, uint64_t cur,
 
 void mcb_debug_start(GtkCheckMenuItem *menuitem, gpointer data)
 {
-    GOpenidaBinary *binary;                 /* Binaire à analyser          */
+    GLoadedBinary *binary;                  /* Binaire à analyser          */
     GBinaryDebugger *debugger;              /* Débogueur offrant l'analyse */
 
 
@@ -968,8 +968,8 @@ void update_debug_menu_items(GObject *ref, gboolean stopped)
 
 static void on_dock_item_switch(GtkDockPanel *panel, GtkWidget *widget, GObject *ref)
 {
-    GOpenidaBinary *old_binary;             /* Ancien binaire édité        */
-    GOpenidaBinary *binary;                 /* Binaire en cours d'édition  */
+    GLoadedBinary *old_binary;              /* Ancien binaire édité        */
+    GLoadedBinary *binary;                  /* Binaire en cours d'édition  */
 
     if (GTK_IS_SCROLLED_WINDOW(widget))
         widget = gtk_bin_get_child(GTK_BIN(widget));
@@ -981,7 +981,7 @@ static void on_dock_item_switch(GtkDockPanel *panel, GtkWidget *widget, GObject
     {
         /* Changement de binaire ? */
 
-        old_binary = G_OPENIDA_BINARY(g_object_get_data(ref, "current_binary"));
+        old_binary = G_LOADED_BINARY(g_object_get_data(ref, "current_binary"));
         binary = gtk_view_panel_get_binary(GTK_VIEW_PANEL(widget));
 
         if (old_binary != binary)
@@ -1015,7 +1015,7 @@ static void on_dock_item_switch(GtkDockPanel *panel, GtkWidget *widget, GObject
 *                                                                             *
 ******************************************************************************/
 
-static void refresh_editor_menus(GObject *ref, GOpenidaBinary *binary, GtkBinView *view)
+static void refresh_editor_menus(GObject *ref, GLoadedBinary *binary, GtkBinView *view)
 {
 #if 0
     GtkCheckMenuItem *menuitem;             /* Menu à coche à traiter      */
diff --git a/src/graph/layout.c b/src/graph/layout.c
index 21f7454..f8afad6 100644
--- a/src/graph/layout.c
+++ b/src/graph/layout.c
@@ -124,7 +124,7 @@ bool build_graph_view(GtkGraphView *view, GtkViewPanel **views, size_t count)
 
 static char *complete_graph_links(const GtkGraphView *view, GtkViewPanel **views, size_t count, char *desc)
 {
-    GOpenidaBinary *binary;                 /* Binaire rattaché aux vues   */
+    GLoadedBinary *binary;                  /* Binaire rattaché aux vues   */
     GArchInstruction *instrs;               /* Instructions pour assembleur*/
     GBufferView *buffer;                    /* Tampon d'une partie de code */
     vmpa_t end;                             /* Adresse finale du tampon    */
@@ -143,7 +143,7 @@ static char *complete_graph_links(const GtkGraphView *view, GtkViewPanel **views
         return desc;
 
     binary = gtk_view_panel_get_binary(views[0]);
-    instrs = g_openida_binary_get_instructions(binary);
+    instrs = g_loaded_binary_get_instructions(binary);
 
     for (i = 0; i < count; i++)
     {
diff --git a/src/gtkext/easygtk.c b/src/gtkext/easygtk.c
index 5218381..510c74f 100644
--- a/src/gtkext/easygtk.c
+++ b/src/gtkext/easygtk.c
@@ -334,7 +334,7 @@ GtkWidget *qck_create_button(GObject *object, const char *name, const char *capt
     GtkWidget *result;                      /* Résultat à renvoyer         */
 
     result = gtk_button_new_with_label(caption);
-    GTK_WIDGET_SET_FLAGS(result, GTK_CAN_DEFAULT);
+    gtk_widget_set_can_default(result, TRUE);
 
     if (G_IS_OBJECT(object) && name != NULL)
     {
@@ -373,7 +373,7 @@ GtkWidget *qck_create_button_from_stock(GObject *object, const char *name, const
     GtkWidget *result;                      /* Résultat à renvoyer         */
 
     result = gtk_button_new_from_stock(stock);
-    GTK_WIDGET_SET_FLAGS(result, GTK_CAN_DEFAULT);
+    gtk_widget_set_can_default(result, TRUE);
 
     if (G_IS_OBJECT(object) && name != NULL)
     {
@@ -413,7 +413,7 @@ GtkWidget *qck_create_button_with_img(GObject *object, const char *name, const c
     GtkWidget *render;                      /* Image à ajouter au bouton   */
 
     result = gtk_button_new();
-    GTK_WIDGET_SET_FLAGS(result, GTK_CAN_DEFAULT);
+    gtk_widget_set_can_default(result, TRUE);
 
     render = gtk_image_new_from_stock(image, GTK_ICON_SIZE_BUTTON);
     gtk_widget_show(render);
diff --git a/src/gtkext/gtkbinview-int.h b/src/gtkext/gtkbinview-int.h
index 94d406f..7091e15 100644
--- a/src/gtkext/gtkbinview-int.h
+++ b/src/gtkext/gtkbinview-int.h
@@ -48,7 +48,7 @@ struct _GtkBinView
 {
     GtkViewPanel parent;                    /* A laisser en premier        */
 
-    GOpenidaBinary *binary;                 /* Contenu binaire affiché     */
+    GLoadedBinary *binary;                  /* Contenu binaire affiché     */
 
     GRenderingLine *lines;                  /* Contenu à représenter       */
     GRenderingLine *last;                   /* Dernière ligne associée     */
diff --git a/src/gtkext/gtkbinview.c b/src/gtkext/gtkbinview.c
index a1657b3..2fe88ad 100644
--- a/src/gtkext/gtkbinview.c
+++ b/src/gtkext/gtkbinview.c
@@ -39,7 +39,7 @@ typedef struct _bv_loading_ack
 
 
 /* Prend acte de l'association d'un binaire chargé. */
-static void gtk_bin_view_attach_binary(GtkBinView *, GOpenidaBinary *);
+static void gtk_bin_view_attach_binary(GtkBinView *, GLoadedBinary *);
 
 /* Prend note de la fin d'une construction d'une visualisation. */
 static void ack_loaded_lines_for_bin_view(GtkBinView *, bv_loading_ack *);
@@ -137,7 +137,7 @@ GtkWidget* gtk_binview_new(void)
 *                                                                             *
 ******************************************************************************/
 
-static void gtk_bin_view_attach_binary(GtkBinView *view, GOpenidaBinary *binary)
+static void gtk_bin_view_attach_binary(GtkBinView *view, GLoadedBinary *binary)
 {
     bv_loading_ack ack;                     /* Informations d'acquitement  */
 
@@ -147,8 +147,10 @@ static void gtk_bin_view_attach_binary(GtkBinView *view, GOpenidaBinary *binary)
 
     g_signal_connect(view, "lines-set", G_CALLBACK(ack_loaded_lines_for_bin_view), &ack);
 
+    /*
     gtk_bin_view_set_rendering_lines(view, binary,
-                                     g_openida_binary_get_lines(binary), NULL);
+                                     g_loaded_binary_get_lines(binary), NULL);
+    */
 
     /* Attente de la fin de construction */
     g_mutex_lock(ack.mutex);
@@ -233,7 +235,7 @@ void gtk_bin_view_show_border(GtkBinView *view, bool show)
 *                                                                             *
 ******************************************************************************/
 
-void gtk_bin_view_set_rendering_lines(GtkBinView *view, GOpenidaBinary *binary, GRenderingLine *lines, GRenderingLine *last)
+void gtk_bin_view_set_rendering_lines(GtkBinView *view, GLoadedBinary *binary, GRenderingLine *lines, GRenderingLine *last)
 {
     view->binary = binary;
 
diff --git a/src/gtkext/gtkbinview.h b/src/gtkext/gtkbinview.h
index b6027a6..165f423 100644
--- a/src/gtkext/gtkbinview.h
+++ b/src/gtkext/gtkbinview.h
@@ -57,7 +57,7 @@ void gtk_bin_view_show_border(GtkBinView *, bool);
 
 
 /* Définit les lignes à associer à la représentation. */
-void gtk_bin_view_set_rendering_lines(GtkBinView *, GOpenidaBinary *, GRenderingLine *, GRenderingLine *);
+void gtk_bin_view_set_rendering_lines(GtkBinView *, GLoadedBinary *, GRenderingLine *, GRenderingLine *);
 
 /* Fournit la liste des lignes associées à la représentation. */
 GRenderingLine *gtk_bin_view_get_lines(const GtkBinView *);
diff --git a/src/gtkext/gtkblockview.c b/src/gtkext/gtkblockview.c
index cd2d99d..398856f 100644
--- a/src/gtkext/gtkblockview.c
+++ b/src/gtkext/gtkblockview.c
@@ -53,7 +53,7 @@ static void gtk_block_view_class_init(GtkBlockViewClass *);
 static void gtk_block_view_init(GtkBlockView *);
 
 /* Prend acte de l'association d'un binaire chargé. */
-static void gtk_block_view_attach_binary(GtkBlockView *, GOpenidaBinary *, bool *, bool *);
+static void gtk_block_view_attach_binary(GtkBlockView *, GLoadedBinary *, bool *, bool *);
 
 
 
@@ -145,11 +145,11 @@ GtkWidget *gtk_block_view_new(void)
 *                                                                             *
 ******************************************************************************/
 
-static void gtk_block_view_attach_binary(GtkBlockView *view, GOpenidaBinary *binary, bool *addr, bool *code)
+static void gtk_block_view_attach_binary(GtkBlockView *view, GLoadedBinary *binary, bool *addr, bool *code)
 {
     GCodeBuffer *buffer;                    /* Tampon par défaut           */
 
-    buffer = g_openida_binary_get_disassembled_buffer(binary);
+    buffer = g_loaded_binary_get_disassembled_buffer(binary);
 
     gtk_buffer_view_attach_buffer(GTK_BUFFER_VIEW(view), g_buffer_view_new(buffer), addr, code);
 
diff --git a/src/gtkext/gtkdockpanel.c b/src/gtkext/gtkdockpanel.c
index 24e99eb..79a4a0e 100644
--- a/src/gtkext/gtkdockpanel.c
+++ b/src/gtkext/gtkdockpanel.c
@@ -67,7 +67,7 @@ static void on_dock_item_content_changed(GDockItem *, GtkWidget *, GtkWidget *,
 static void _gtk_dock_panel_remove_item(GtkDockPanel *, GDockItem *, GtkWidget *);
 
 /* Met à jour le titre du support de panneaux dockables. */
-static gboolean gtk_dock_panel_update_title(GtkNotebook *, GtkNotebookPage *, guint, gpointer);
+static gboolean gtk_dock_panel_update_title(GtkNotebook *, gpointer *, guint, gpointer);
 
 
 
@@ -742,7 +742,7 @@ static void _gtk_dock_panel_remove_item(GtkDockPanel *dpanel, GDockItem *ditem,
 *                                                                             *
 ******************************************************************************/
 
-static gboolean gtk_dock_panel_update_title(GtkNotebook *notebook, GtkNotebookPage *page, guint index, gpointer data)
+static gboolean gtk_dock_panel_update_title(GtkNotebook *notebook, gpointer *page, guint index, gpointer data)
 {
     GDockItem *ditem;                       /* Elément nouvellement actif  */
     const gchar *desc;                      /* Description à afficher      */
diff --git a/src/gtkext/gtkdockstation.c b/src/gtkext/gtkdockstation.c
index a91998e..ba17788 100644
--- a/src/gtkext/gtkdockstation.c
+++ b/src/gtkext/gtkdockstation.c
@@ -40,7 +40,7 @@ static void gtk_dock_station_class_init(GtkDockStationClass *);
 static void gtk_dock_station_init(GtkDockStation *);
 
 /* Met à jour le titre du support de panneaux concentrés. */
-static gboolean gtk_dock_station_switch_panel(GtkNotebook *, GtkNotebookPage *, guint, gpointer);
+static gboolean gtk_dock_station_switch_panel(GtkNotebook *, gpointer *, guint, gpointer);
 
 
 
@@ -173,7 +173,7 @@ GtkWidget *gtk_dock_station_new(void)
 *                                                                             *
 ******************************************************************************/
 
-static gboolean gtk_dock_station_switch_panel(GtkNotebook *notebook, GtkNotebookPage *page, guint index, gpointer data)
+static gboolean gtk_dock_station_switch_panel(GtkNotebook *notebook, gpointer *page, guint index, gpointer data)
 {
     GtkWidget *widget;                      /* Panneau concerné            */
     char *caption;                          /* Texte à redonner            */
diff --git a/src/gtkext/gtkgraphview.c b/src/gtkext/gtkgraphview.c
index 8366c1f..6ce6060 100644
--- a/src/gtkext/gtkgraphview.c
+++ b/src/gtkext/gtkgraphview.c
@@ -87,7 +87,7 @@ static void gtk_graph_view_scroll(GtkGraphView *);
 static void gtk_graph_view_reset(GtkGraphView *);
 
 /* Liste d'éléments du graphique à placer. */
-static GtkViewPanel **gtk_graph_view_load_nodes(GtkGraphView *, GOpenidaBinary *, vmpa_t, vmpa_t);
+static GtkViewPanel **gtk_graph_view_load_nodes(GtkGraphView *, GLoadedBinary *, vmpa_t, vmpa_t);
 
 
 
@@ -319,7 +319,7 @@ static void gtk_graph_view_define_main_address(GtkGraphView *view, vmpa_t addr)
     {
         gtk_graph_view_reset(view);
 
-        format = g_openida_binary_get_format(GTK_VIEW_PANEL(view)->binary);
+        format = g_loaded_binary_get_format(GTK_VIEW_PANEL(view)->binary);
         routines = g_binary_format_get_routines(G_BIN_FORMAT(format), &routines_count);
 
         for (i = 0; i < routines_count; i++)
@@ -533,7 +533,7 @@ static void gtk_graph_view_reset(GtkGraphView *view)
 *                                                                             *
 ******************************************************************************/
 
-static GtkViewPanel **gtk_graph_view_load_nodes(GtkGraphView *view, GOpenidaBinary *binary, vmpa_t start, vmpa_t end)
+static GtkViewPanel **gtk_graph_view_load_nodes(GtkGraphView *view, GLoadedBinary *binary, vmpa_t start, vmpa_t end)
 {
     GtkViewPanel **result;                  /* Liste à retourner           */
     size_t *count;                          /* Nombre d'éléments créés.    */
@@ -551,11 +551,11 @@ static GtkViewPanel **gtk_graph_view_load_nodes(GtkGraphView *view, GOpenidaBina
     count = &view->childs_count;
     *count = 0;
 
-    list = g_openida_binary_get_instructions(binary);
-    buffer = g_openida_binary_get_disassembled_buffer(binary);
+    list = g_loaded_binary_get_instructions(binary);
+    buffer = g_loaded_binary_get_disassembled_buffer(binary);
 
-    addr = g_openida_binary_display_addresses_in_text(binary);
-    code = g_openida_binary_display_code_in_text(binary);
+    addr = g_loaded_binary_display_addresses_in_text(binary);
+    code = g_loaded_binary_display_code_in_text(binary);
 
     first = start;
     last = first;
@@ -718,7 +718,7 @@ static void gtk_graph_view_define_main_address(GtkGraphView *, vmpa_t);
 static bool gtk_graph_view_get_address_coordinates(const GtkGraphView *, vmpa_t, gint *, gint *);
 
 /* Définit la liste complète des éléments du futur graphique. */
-static GtkBinView **gtk_graph_view_load_nodes(GtkGraphView *, GOpenidaBinary *, GRenderingLine *, GRenderingLine *);
+static GtkBinView **gtk_graph_view_load_nodes(GtkGraphView *, GLoadedBinary *, GRenderingLine *, GRenderingLine *);
 
 /* Prend note de la fin d'une construction d'une visualisation. */
 static void notify_graph_view(GtkBinView *, GtkGraphView *);
@@ -870,7 +870,7 @@ static void gtk_graph_view_define_main_address(GtkGraphView *view, vmpa_t addr)
     {
         gtk_graph_view_reset(view);
 
-        format = g_openida_binary_get_format(GTK_BIN_VIEW(view)->binary);
+        format = g_loaded_binary_get_format(GTK_BIN_VIEW(view)->binary);
         routines = g_binary_format_get_routines(G_BIN_FORMAT(format), &routines_count);
 
         for (i = 0; i < routines_count; i++)
@@ -954,7 +954,7 @@ static bool gtk_graph_view_get_address_coordinates(const GtkGraphView *view, vmp
 *                                                                             *
 ******************************************************************************/
 
-static GtkBinView **gtk_graph_view_load_nodes(GtkGraphView *view, GOpenidaBinary *binary, GRenderingLine *first, GRenderingLine *last)
+static GtkBinView **gtk_graph_view_load_nodes(GtkGraphView *view, GLoadedBinary *binary, GRenderingLine *first, GRenderingLine *last)
 {
 #if 0
     GtkBinView **result;                    /* Liste à retourner           */
diff --git a/src/gtkext/gtksourceview.c b/src/gtkext/gtksourceview.c
index 1244bb8..5faed7b 100644
--- a/src/gtkext/gtksourceview.c
+++ b/src/gtkext/gtksourceview.c
@@ -53,7 +53,7 @@ static void gtk_source_view_class_init(GtkSourceViewClass *);
 static void gtk_source_view_init(GtkSourceView *);
 
 /* Prend acte de l'association d'un binaire chargé. */
-static void gtk_source_view_attach_binary(GtkSourceView *, GOpenidaBinary *, bool *, bool *);
+static void gtk_source_view_attach_binary(GtkSourceView *, GLoadedBinary *, bool *, bool *);
 
 
 
@@ -145,11 +145,11 @@ GtkWidget *gtk_source_view_new(void)
 *                                                                             *
 ******************************************************************************/
 
-static void gtk_source_view_attach_binary(GtkSourceView *view, GOpenidaBinary *binary, bool *addr, bool *code)
+static void gtk_source_view_attach_binary(GtkSourceView *view, GLoadedBinary *binary, bool *addr, bool *code)
 {
     GCodeBuffer *buffer;                    /* Tampon par défaut           */
 
-    buffer = g_openida_binary_get_decompiled_buffer(binary, -1);
+    buffer = g_loaded_binary_get_decompiled_buffer(binary, -1);
 
     /* FIXME */
     if (buffer != NULL)
diff --git a/src/gtkext/gtkviewpanel-int.h b/src/gtkext/gtkviewpanel-int.h
index a4edd06..6e6cbaf 100644
--- a/src/gtkext/gtkviewpanel-int.h
+++ b/src/gtkext/gtkviewpanel-int.h
@@ -34,7 +34,7 @@
 
 
 /* Prend acte de l'association d'un binaire chargé. */
-typedef void (* attach_binary_fc) (GtkViewPanel *, GOpenidaBinary *, bool *, bool *);
+typedef void (* attach_binary_fc) (GtkViewPanel *, GLoadedBinary *, bool *, bool *);
 
 /* Réagit à la sélection externe d'une adresse. */
 typedef void (* define_address_fc) (GtkViewPanel *, vmpa_t);
@@ -57,7 +57,7 @@ struct _GtkViewPanel
     GdkGC *gc;                              /* Contexte graphique du rendu */
     bool show_border;                       /* Affichage d'une bordure ?   */
 
-    GOpenidaBinary *binary;                 /* Binaire à visualiser        */
+    GLoadedBinary *binary;                  /* Binaire à visualiser        */
 
     attach_binary_fc attach;                /* Association avec un binaire */
     define_address_fc define;               /* Centrage sur une partie     */
diff --git a/src/gtkext/gtkviewpanel.c b/src/gtkext/gtkviewpanel.c
index 326e4d8..2935458 100644
--- a/src/gtkext/gtkviewpanel.c
+++ b/src/gtkext/gtkviewpanel.c
@@ -246,7 +246,7 @@ static void gtk_view_panel_realize(GtkWidget *widget)
     guint attributes_mask;                  /* Masque de prise en compte   */
     GdkColor white;                         /* Couleur de fond normale     */
 
-    GTK_WIDGET_SET_FLAGS(widget, GTK_REALIZED);
+    gtk_widget_set_realized(widget, TRUE);
 
     attributes.window_type = GDK_WINDOW_CHILD;
     attributes.x = widget->allocation.x;
@@ -356,7 +356,7 @@ void gtk_view_panel_show_border(GtkViewPanel *panel, bool show)
 *                                                                             *
 ******************************************************************************/
 
-void gtk_view_panel_attach_binary(GtkViewPanel *panel, GOpenidaBinary *binary, bool *addr, bool *code)
+void gtk_view_panel_attach_binary(GtkViewPanel *panel, GLoadedBinary *binary, bool *addr, bool *code)
 {
     g_object_ref(G_OBJECT(binary));
     panel->binary = binary;
@@ -468,7 +468,7 @@ void gtk_view_panel_set_code_display(const GtkViewPanel *panel, bool state)
 *                                                                             *
 ******************************************************************************/
 
-GOpenidaBinary *gtk_view_panel_get_binary(const GtkViewPanel *panel)
+GLoadedBinary *gtk_view_panel_get_binary(const GtkViewPanel *panel)
 {
     return panel->binary;
 
diff --git a/src/gtkext/gtkviewpanel.h b/src/gtkext/gtkviewpanel.h
index 12b0e44..f1dd2b7 100644
--- a/src/gtkext/gtkviewpanel.h
+++ b/src/gtkext/gtkviewpanel.h
@@ -54,7 +54,7 @@ GType gtk_view_panel_get_type(void);
 void gtk_view_panel_show_border(GtkViewPanel *, bool);
 
 /* Associe à un panneau d'affichage un binaire chargé. */
-void gtk_view_panel_attach_binary(GtkViewPanel *, GOpenidaBinary *, bool *, bool *);
+void gtk_view_panel_attach_binary(GtkViewPanel *, GLoadedBinary *, bool *, bool *);
 
 /* Indique si les adresses doivent apparaître dans le rendu. */
 bool gtk_view_panel_get_addresses_display(const GtkViewPanel *);
@@ -69,7 +69,7 @@ bool gtk_view_panel_get_code_display(const GtkViewPanel *);
 void gtk_view_panel_set_code_display(const GtkViewPanel *, bool);
 
 /* Fournit le binaire associé à la représentation. */
-GOpenidaBinary *gtk_view_panel_get_binary(const GtkViewPanel *);
+GLoadedBinary *gtk_view_panel_get_binary(const GtkViewPanel *);
 
 /* Indique si la vue contient une addrese donnée. */
 bool gtk_view_panel_contain_address(const GtkViewPanel *, vmpa_t);
diff --git a/src/gui/editem-int.h b/src/gui/editem-int.h
index 0f25147..8ab0c43 100644
--- a/src/gui/editem-int.h
+++ b/src/gui/editem-int.h
@@ -37,7 +37,7 @@
 
 
 /* Réagit à un changement du binaire courant. */
-typedef void (* update_item_binary_fc) (GEditorItem *, GOpenidaBinary *);
+typedef void (* update_item_binary_fc) (GEditorItem *, GLoadedBinary *);
 
 /* Réagit à un changement d'affichage principal de contenu. */
 typedef void (* update_item_view_fc) (GEditorItem *, GtkViewPanel *);
diff --git a/src/gui/editem.c b/src/gui/editem.c
index 18102f4..1d542a3 100644
--- a/src/gui/editem.c
+++ b/src/gui/editem.c
@@ -125,7 +125,7 @@ GtkWidget *g_editor_item_get_widget(const GEditorItem *item)
 *                                                                             *
 ******************************************************************************/
 
-GOpenidaBinary *g_editor_item_get_current_binary(const GEditorItem *item)
+GLoadedBinary *g_editor_item_get_current_binary(const GEditorItem *item)
 {
     return g_object_get_data(item->ref, "current_binary");
 
@@ -189,7 +189,7 @@ void register_editor_item(GEditorItem *item)
 *                                                                             *
 ******************************************************************************/
 
-void change_editor_items_current_binary(GObject *ref, GOpenidaBinary *binary)
+void change_editor_items_current_binary(GObject *ref, GLoadedBinary *binary)
 {
     GEditorItem *iter;                     /* Boucle de parcours          */
 
diff --git a/src/gui/editem.h b/src/gui/editem.h
index 0b9989e..4bb1cd3 100644
--- a/src/gui/editem.h
+++ b/src/gui/editem.h
@@ -60,7 +60,7 @@ GType g_editor_item_get_type(void);
 GtkWidget *g_editor_item_get_widget(const GEditorItem *);
 
 /* Fournit le gestionnaire du binaire courant. */
-GOpenidaBinary *g_editor_item_get_current_binary(const GEditorItem *);
+GLoadedBinary *g_editor_item_get_current_binary(const GEditorItem *);
 
 /* Fournit l'affichage de binaire courant. */
 GtkViewPanel *g_editor_item_get_current_view(const GEditorItem *);
@@ -74,7 +74,7 @@ GtkViewPanel *g_editor_item_get_current_view(const GEditorItem *);
 void register_editor_item(GEditorItem *);
 
 /* Lance une actualisation du fait d'un changement de binaire. */
-void change_editor_items_current_binary(GObject *, GOpenidaBinary *);
+void change_editor_items_current_binary(GObject *, GLoadedBinary *);
 
 /* Lance une actualisation du fait d'un changement de vue. */
 void change_editor_items_current_view(GObject *, GtkViewPanel *);
diff --git a/src/gui/menus/binary.c b/src/gui/menus/binary.c
index ac59444..8699c02 100644
--- a/src/gui/menus/binary.c
+++ b/src/gui/menus/binary.c
@@ -89,7 +89,7 @@ GtkWidget *build_menu_binary(GObject *ref, GtkAccelGroup *accgroup, GMenuBar *ba
 
 static void mcb_binary_export(GtkMenuItem *menuitem, GMenuBar *bar)
 {
-    GOpenidaBinary *binary;                 /* Edition courante            */
+    GLoadedBinary *binary;                  /* Edition courante            */
 
     binary = g_editor_item_get_current_binary(G_EDITOR_ITEM(bar));
 
diff --git a/src/gui/menus/debug.c b/src/gui/menus/debug.c
index 963c095..666a605 100644
--- a/src/gui/menus/debug.c
+++ b/src/gui/menus/debug.c
@@ -93,10 +93,10 @@ GtkWidget *build_menu_debug(GObject *ref, GtkAccelGroup *accgroup)
 
 static void mcb_debug_start_stop(GtkMenuItem *menuitem, GObject *ref)
 {
-    GOpenidaBinary *binary;                 /* Edition courante            */
+    GLoadedBinary *binary;                  /* Edition courante            */
     GBinaryDebugger *debugger;              /* Module prêt à emploi        */
 
-    binary = (GOpenidaBinary *)g_object_get_data(ref, "current_binary");
+    binary = (GLoadedBinary *)g_object_get_data(ref, "current_binary");
     debugger = NULL;//get_main_debugger_for_binary(get_current_openida_project(), binary);
 
     if (debugger == NULL)
diff --git a/src/gui/menus/project.c b/src/gui/menus/project.c
index 96b411b..dbf61bc 100644
--- a/src/gui/menus/project.c
+++ b/src/gui/menus/project.c
@@ -32,6 +32,7 @@
 
 
 #include "../editem-int.h"
+#include "../../analysis/binaries/file.h"
 #include "../../gtkext/easygtk.h"
 
 
@@ -115,7 +116,7 @@ void update_menu_project_for_project(GtkWidget *widget, GStudyProject *project,
     GList *list;                            /* Liste des éléments en place */
     GList *iter;                            /* Boucle de parcours #1       */
     size_t count;                           /* Nombre de binaires attachés */
-    GOpenidaBinary **binaries;              /* Liste de ces binaires       */
+    GLoadedBinary **binaries;               /* Liste de ces binaires       */
     size_t i;                               /* Boucle de parcours #2       */
     const char *desc;                       /* Description à afficher      */
     GtkWidget *submenuitem;                 /* Sous-menu à ajouter         */
@@ -138,7 +139,7 @@ void update_menu_project_for_project(GtkWidget *widget, GStudyProject *project,
 
     for (i = 0; i < count; i++)
     {
-        desc = g_openida_binary_to_string(binaries[i]);
+        desc = g_loaded_binary_get_filename(binaries[i], true);
 
         submenuitem = qck_create_menu_item(NULL, NULL, desc,
                                            G_CALLBACK(mcb_project_remove_binary), project);
@@ -175,7 +176,7 @@ static void mcb_project_add_binary_file(GtkMenuItem *menuitem, GMenuBar *bar)
     GtkWidget *dialog;                      /* Boîte à afficher            */
     char *dir;                              /* Répertoire courant          */
     gchar *filename;                        /* Nom du fichier à intégrer   */
-    GOpenidaBinary *binary;                 /* Représentation chargée      */
+    GLoadedBinary *binary;                  /* Représentation chargée      */
 
     dialog = gtk_file_chooser_dialog_new(_("Open a binary file"),
                                          GTK_WINDOW(G_EDITOR_ITEM(bar)->ref),
@@ -204,13 +205,13 @@ static void mcb_project_add_binary_file(GtkMenuItem *menuitem, GMenuBar *bar)
     {
         filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
 
-        binary = g_openida_binary_new_from_file(filename);
+        binary = g_file_binary_new_from_file(filename);
 
         if (binary != NULL)
         {
             g_signal_connect(binary, "disassembly-done",
                              G_CALLBACK(g_study_project_add_loaded_binary), get_current_project());
-            g_openida_binary_analyse(binary);
+            g_loaded_binary_analyse(binary);
         }
 
         g_free(filename);
@@ -237,9 +238,9 @@ static void mcb_project_add_binary_file(GtkMenuItem *menuitem, GMenuBar *bar)
 
 static void mcb_project_remove_binary(GtkMenuItem *menuitem, GStudyProject *project)
 {
-    GOpenidaBinary *binary;                 /* Binaire à retirer           */
+    GLoadedBinary *binary;                  /* Binaire à retirer           */
 
-    binary = G_OPENIDA_BINARY(g_object_get_data(G_OBJECT(menuitem), "binary"));
+    binary = G_LOADED_BINARY(g_object_get_data(G_OBJECT(menuitem), "binary"));
 
     g_study_project_detach_binary(project, binary);
     g_object_unref(G_OBJECT(binary));
diff --git a/src/gui/menus/view.c b/src/gui/menus/view.c
index e0e7cc4..748df9f 100644
--- a/src/gui/menus/view.c
+++ b/src/gui/menus/view.c
@@ -178,7 +178,7 @@ static void mcb_view_change_support(GtkRadioMenuItem *menuitem, GMenuBar *bar)
     BinaryView view;                        /* Nouvelle vue à présenter    */
     GtkViewPanel *vpanel;                   /* Afficheur effectif de code  */
     GtkWidget *station;                     /* Base du remplacement        */
-    GOpenidaBinary *binary;                 /* Edition courante            */
+    GLoadedBinary *binary;                  /* Edition courante            */
     GtkWidget *scroll;                      /* Nouveau support à utiliser  */
 
     /* On ne traite qu'une seule fois ! */
diff --git a/src/gui/panels/symbols.c b/src/gui/panels/symbols.c
index aea90fe..6cc391f 100644
--- a/src/gui/panels/symbols.c
+++ b/src/gui/panels/symbols.c
@@ -46,7 +46,7 @@ struct _GSymbolsPanel
     GtkTreeView *treeview;                  /* Composant d'affichage       */
     GtkTreeStore *store;                    /* Modèle de gestion           */
 
-    GOpenidaBinary *binary;                 /* Binaire à prendre en compte */
+    GLoadedBinary *binary;                  /* Binaire à prendre en compte */
 
 };
 
@@ -84,7 +84,7 @@ static void g_symbols_panel_init(GSymbolsPanel *);
 static void on_symbols_selection_change(GtkTreeSelection *, GSymbolsPanel *);
 
 /* Réagit à un changement d'affichage principal de contenu. */
-void change_symbols_panel_current_binary(GSymbolsPanel *, GOpenidaBinary *);
+void change_symbols_panel_current_binary(GSymbolsPanel *, GLoadedBinary *);
 
 
 
@@ -383,7 +383,7 @@ static void on_symbols_selection_change(GtkTreeSelection *selection, GSymbolsPan
 *                                                                             *
 ******************************************************************************/
 
-void change_symbols_panel_current_binary(GSymbolsPanel *panel, GOpenidaBinary *binary)
+void change_symbols_panel_current_binary(GSymbolsPanel *panel, GLoadedBinary *binary)
 {
     GtkToggleToolButton *button;            /* Mode de représentation      */
 
@@ -437,7 +437,7 @@ static void reload_symbols_for_new_list_view(GSymbolsPanel *panel)
     char tmp[VMPA_MAX_SIZE];                /* Version humainement lisible */
     GtkTreeIter iter;                       /* Point d'insertion           */
 
-    format = g_openida_binary_get_format(panel->binary);
+    format = g_loaded_binary_get_format(panel->binary);
 
     routines = g_binary_format_get_routines(G_BIN_FORMAT(format), &routines_count);
     qsort(routines, routines_count, sizeof(GBinRoutine *), (__compar_fn_t)g_binary_routine_rcompare);
@@ -590,7 +590,7 @@ static void reload_symbols_for_new_tree_view(GSymbolsPanel *panel)
     GtkTreeIter iter;                       /* Point d'insertion           */
     GdkPixbuf *pixbuf;                      /* Icone pour l'élément inséré */
 
-    format = g_openida_binary_get_format(panel->binary);
+    format = g_loaded_binary_get_format(panel->binary);
 
     routines = g_binary_format_get_routines(G_BIN_FORMAT(format), &routines_count);
     qsort(routines, routines_count, sizeof(GBinRoutine *), (__compar_fn_t)g_binary_routine_rcompare);
diff --git a/src/gui/tb/source.c b/src/gui/tb/source.c
index 2a1a532..109cbfa 100644
--- a/src/gui/tb/source.c
+++ b/src/gui/tb/source.c
@@ -41,7 +41,7 @@
 static GtkWidget *build_source_tb_widget(GObject *);
 
 /* Réagit à un changement du binaire courant. */
-static void update_source_item_binary(GEditorItem *, GOpenidaBinary *);
+static void update_source_item_binary(GEditorItem *, GLoadedBinary *);
 
 /* Réagit à un changement de panneau d'affichage courant. */
 static void update_source_item_view(GEditorItem *, GtkViewPanel *);
@@ -136,7 +136,7 @@ GEditorItem *create_source_tb_item(GObject *ref)
 *                                                                             *
 ******************************************************************************/
 
-static void update_source_item_binary(GEditorItem *item, GOpenidaBinary *binary)
+static void update_source_item_binary(GEditorItem *item, GLoadedBinary *binary)
 {
     GtkComboBox *combo;                     /* Liste de sélection          */
     GtkTreeModel *model;                    /* Gestionnaire d'éléments     */
@@ -160,7 +160,7 @@ static void update_source_item_binary(GEditorItem *item, GOpenidaBinary *binary)
 
     /* Inscriptions */
 
-    format = g_openida_binary_get_format(binary);
+    format = g_loaded_binary_get_format(binary);
     files = g_binary_format_get_source_files(G_BIN_FORMAT(format), &count, &defsrc);
 
     for (i = 0; i < count; i++)
@@ -211,18 +211,18 @@ static void update_source_item_view(GEditorItem *item, GtkViewPanel *view)
 static void change_selected_source(GtkComboBox *widget, GObject *ref)
 {
     gint index;                             /* Nouvelle source ciblée      */
-    GOpenidaBinary *binary;                 /* Binaire chargé courant      */
+    GLoadedBinary *binary;                  /* Binaire chargé courant      */
     GCodeBuffer *buffer;                    /* Nouveau tampon à présenter  */
     GtkBufferView *view;                    /* Afficheur de tampons        */
 
     index = gtk_combo_box_get_active(widget);
 
-    binary = G_OPENIDA_BINARY(g_object_get_data(ref, "current_binary"));
-    buffer = g_openida_binary_get_decompiled_buffer(binary, index);
+    binary = G_LOADED_BINARY(g_object_get_data(ref, "current_binary"));
+    buffer = g_loaded_binary_get_decompiled_buffer(binary, index);
 
     view = GTK_BUFFER_VIEW(g_object_get_data(ref, "current_view"));
     if (GTK_IS_BUFFER_VIEW(view))
         gtk_buffer_view_attach_buffer(view, buffer,
-                                      g_openida_binary_display_decomp_lines(binary), NULL);
+                                      g_loaded_binary_display_decomp_lines(binary), NULL);
 
 }
diff --git a/src/panels/breaks.c b/src/panels/breaks.c
index 31e2217..958d6fb 100644
--- a/src/panels/breaks.c
+++ b/src/panels/breaks.c
@@ -26,6 +26,7 @@
 
 
 #include "panel-int.h"
+#include "../debug/break.h"
 #include "../gtkext/easygtk.h"
 #include "../gtkext/support.h"
 
@@ -42,7 +43,7 @@ struct _GBreaksPanel
     GtkTreeView *treeview;                  /* Composant d'affichage       */
     GtkTreeStore *store;                    /* Modèle de gestion           */
 
-    GOpenidaBinary *binary;                 /* Binaire en cours d'étude    */
+    GLoadedBinary *binary;                  /* Binaire en cours d'étude    */
 
 };
 
@@ -75,13 +76,13 @@ static void g_breaks_panel_class_init(GBreaksPanelClass *);
 static void g_breaks_panel_init(GBreaksPanel *);
 
 /* Réagit à un changement du binaire courant. */
-static void reload_breaks_for_new_binary(GBreaksPanel *, GOpenidaBinary *);
+static void reload_breaks_for_new_binary(GBreaksPanel *, GLoadedBinary *);
 
 
 
 
 /* Intègre à l'affichage un groupe de points d'arrêt. */
-static void add_bp_group_to_breaks_panel(GOpenidaBinary *, GBreakGroup *, GBreaksPanel *);
+static void add_bp_group_to_breaks_panel(GLoadedBinary *, GBreakGroup *, GBreaksPanel *);
 
 /* Réagit à une nouvelle création de point d'arrêt. */
 static void refresh_breaks_panel_on_bp_added(GBreakGroup *, GBreakPoint *, GBreaksPanel *);
@@ -250,14 +251,14 @@ GEditorPanel *g_breaks_panel_new(void)
 *                                                                             *
 ******************************************************************************/
 
-static void reload_breaks_for_new_binary(GBreaksPanel *panel, GOpenidaBinary *binary)
+static void reload_breaks_for_new_binary(GBreaksPanel *panel, GLoadedBinary *binary)
 {
 
     printf("CHNAGE BINARY !\n");
 
     panel->binary = binary;
 
-    g_openida_binary_for_each_bp_group(binary, (GExtFunc)add_bp_group_to_breaks_panel, panel);
+    //g_loaded_binary_for_each_bp_group(binary, (GExtFunc)add_bp_group_to_breaks_panel, panel);
 
 
 }
@@ -289,7 +290,7 @@ static void reload_breaks_for_new_binary(GBreaksPanel *panel, GOpenidaBinary *bi
 *                                                                             *
 ******************************************************************************/
 
-static void add_bp_group_to_breaks_panel(GOpenidaBinary *binary, GBreakGroup *group, GBreaksPanel *panel)
+static void add_bp_group_to_breaks_panel(GLoadedBinary *binary, GBreakGroup *group, GBreaksPanel *panel)
 {
     /* FIXME : bloquer toute émission de signal tant que les ajouts ne sont pas terminés. */
 
@@ -325,7 +326,7 @@ static void refresh_breaks_panel_on_bp_added(GBreakGroup *group, GBreakPoint *po
     char address[VMPA_MAX_SIZE];            /* Conversion de l'adresse     */
     GtkTreeIter iter;                       /* Point d'insertion           */
 
-    format = g_openida_binary_get_format(panel->binary);
+    format = g_loaded_binary_get_format(panel->binary);
     proc = get_arch_processor_from_format(format);
 
     vmpa_to_string(g_break_point_get_address(point),
diff --git a/src/panels/panel-int.h b/src/panels/panel-int.h
index 543c33c..7579eae 100644
--- a/src/panels/panel-int.h
+++ b/src/panels/panel-int.h
@@ -35,7 +35,7 @@
 
 
 /* Réagit à un changement du binaire courant. */
-typedef void (* reload_for_new_binary_fc) (GEditorPanel *, GOpenidaBinary *);
+typedef void (* reload_for_new_binary_fc) (GEditorPanel *, GLoadedBinary *);
 
 /* Réagit à un changement d'affichage principal de contenu. */
 typedef void (* reload_for_new_view_fc) (GEditorPanel *, GtkViewPanel *, bool);
diff --git a/src/panels/panel.c b/src/panels/panel.c
index 5922fe5..4d08b7f 100644
--- a/src/panels/panel.c
+++ b/src/panels/panel.c
@@ -106,7 +106,7 @@ static void g_editor_panel_init(GEditorPanel *panel)
 *                                                                             *
 ******************************************************************************/
 
-void change_current_binary_in_panels(GObject *ref, GOpenidaBinary *binary)
+void change_current_binary_in_panels(GObject *ref, GLoadedBinary *binary)
 {
 
 
@@ -193,7 +193,7 @@ void place_all_panels_in_editor(GtkWidget *top)
 *                                                                             *
 ******************************************************************************/
 
-void notify_panels_of_binary_change(GOpenidaBinary *binary)
+void notify_panels_of_binary_change(GLoadedBinary *binary)
 {
     GEditorPanel *iter;                     /* Boucle de parcours          */
 
diff --git a/src/panels/panel.h b/src/panels/panel.h
index b946222..60ce657 100644
--- a/src/panels/panel.h
+++ b/src/panels/panel.h
@@ -64,7 +64,7 @@ GType g_editor_panel_get_type(void);
 
 
 /* Répercute sur les panneaux un nouveau binaire actif. */
-void change_current_binary_in_panels(GObject *, GOpenidaBinary *);
+void change_current_binary_in_panels(GObject *, GLoadedBinary *);
 
 
 
@@ -77,7 +77,7 @@ void init_internal_panels(void);
 void place_all_panels_in_editor(GtkWidget *);
 
 /* Lance une actualisation du fait d'un changement de binaire. */
-void notify_panels_of_binary_change(GOpenidaBinary *);
+void notify_panels_of_binary_change(GLoadedBinary *);
 
 /* Lance une actualisation du fait d'un changement de vue. */
 void notify_panels_of_view_change(GtkViewPanel *, bool);
diff --git a/src/plugins/plugin-int.h b/src/plugins/plugin-int.h
index 56753e0..9a5c37c 100644
--- a/src/plugins/plugin-int.h
+++ b/src/plugins/plugin-int.h
@@ -47,7 +47,7 @@ typedef PluginAction (* get_plugin_action_fc) (const GPluginModule *);
 typedef MatchingFormatAction (* is_matching_fc) (const GPluginModule *, char **, bin_t **, off_t *);
 
 /* Exécute une action définie sur un binaire chargé. */
-typedef bool (* execute_action_on_binary_fc) (const GPluginModule *, GOpenidaBinary *, PluginAction);
+typedef bool (* execute_action_on_binary_fc) (const GPluginModule *, GLoadedBinary *, PluginAction);
 
 /* Exécute une action relative à un débogueur. */
 typedef bool (* execute_on_debugger_fc) (const GPluginModule *, GBinaryDebugger *, PluginAction);
diff --git a/src/plugins/plugin.c b/src/plugins/plugin.c
index e769df6..0cdcb04 100644
--- a/src/plugins/plugin.c
+++ b/src/plugins/plugin.c
@@ -387,7 +387,7 @@ MatchingFormatAction g_plugin_module_is_matching(const GPluginModule *plugin, ch
 *                                                                             *
 ******************************************************************************/
 
-bool g_plugin_module_execute_action_on_binary(const GPluginModule *plugin, GOpenidaBinary *binary, PluginAction action)
+bool g_plugin_module_execute_action_on_binary(const GPluginModule *plugin, GLoadedBinary *binary, PluginAction action)
 {
     return plugin->exec_on_bin(plugin, binary, action);
 
diff --git a/src/plugins/plugin.h b/src/plugins/plugin.h
index aa90ee1..6fbba4d 100644
--- a/src/plugins/plugin.h
+++ b/src/plugins/plugin.h
@@ -64,7 +64,7 @@ PluginAction g_plugin_module_get_action(const GPluginModule *);
 MatchingFormatAction g_plugin_module_is_matching(const GPluginModule *, char **, bin_t **, off_t *);
 
 /* Exécute une action définie sur un binaire chargé. */
-bool g_plugin_module_execute_action_on_binary(const GPluginModule *, GOpenidaBinary *, PluginAction);
+bool g_plugin_module_execute_action_on_binary(const GPluginModule *, GLoadedBinary *, PluginAction);
 
 /* Exécute une action relative à un débogueur. */
 bool g_plugin_module_handle_debugger(const GPluginModule *, GBinaryDebugger *, PluginAction);
diff --git a/src/project.c b/src/project.c
index 91fe36c..c3c1844 100644
--- a/src/project.c
+++ b/src/project.c
@@ -31,6 +31,7 @@
 
 #include "params.h"
 #include "common/xml.h"
+#include "analysis/binaries/file.h"
 #include "gtkext/easygtk.h"
 #include "gtkext/gtkblockview.h"
 #include "gtkext/gtkdockpanel.h"
@@ -46,7 +47,7 @@
 /* Conservation d'un binaire chargé */
 typedef struct _loaded_binary
 {
-    GOpenidaBinary *binary;                 /* Binaire en question         */
+    GLoadedBinary *binary;                  /* Binaire en question         */
     GtkViewPanel *views[BVW_COUNT];         /* Composants pour l'affichage */
     GtkWidget *scrollwindows[BVW_COUNT];    /* Supports pour l'affichage   */
 
@@ -179,7 +180,7 @@ GStudyProject *g_study_project_open(const char *filename)
     unsigned int i;                         /* Boucle de parcours          */
     size_t access_len;                      /* Taille d'un chemin interne  */
     char *access;                           /* Chemin pour une sous-config.*/
-    GOpenidaBinary *binary;                 /* Représentation à intégrer   */
+    GLoadedBinary *binary;                 /* Représentation à intégrer   */
 
     if (!open_xml_file(filename, &xdoc, &context)) return NULL;
 
@@ -199,7 +200,7 @@ GStudyProject *g_study_project_open(const char *filename)
         access = calloc(access_len, sizeof(char));
         snprintf(access, access_len, "/OpenIDAProject/Binaries/Binary[position()=%u]", i + 1);
 
-        binary = g_openida_binary_new_from_xml(context, access);
+        binary = g_file_binary_new_from_xml(context, access);
 
         free(access);
 
@@ -207,7 +208,7 @@ GStudyProject *g_study_project_open(const char *filename)
         {
             g_signal_connect(binary, "disassembly-done",
                              G_CALLBACK(g_study_project_add_loaded_binary), result);
-            g_openida_binary_analyse(binary);
+            g_loaded_binary_analyse(binary);
         }
 
     }
@@ -260,7 +261,7 @@ bool g_study_project_save(GStudyProject *project, const char *filename)
         access = calloc(access_len, sizeof(char));
         snprintf(access, access_len, "/OpenIDAProject/Binaries/Binary[position()=%zu]", i + 1);
 
-        result = g_openida_binary_save(project->binaries[i]->binary, xdoc, context, access);
+        result = g_loaded_binary_save(project->binaries[i]->binary, xdoc, context, access);
 
         free(access);
 
@@ -316,7 +317,7 @@ const char *g_study_project_get_filename(const GStudyProject *project)
 *                                                                             *
 ******************************************************************************/
 
-void g_study_project_add_loaded_binary(GOpenidaBinary *binary, GStudyProject *project)
+void g_study_project_add_loaded_binary(GLoadedBinary *binary, GStudyProject *project)
 {
     size_t index;                           /* Indice du nouveau binaire   */
 
@@ -343,7 +344,7 @@ void g_study_project_add_loaded_binary(GOpenidaBinary *binary, GStudyProject *pr
 *                                                                             *
 ******************************************************************************/
 
-size_t g_study_project_attach_binary(GStudyProject *project, GOpenidaBinary *binary)
+size_t g_study_project_attach_binary(GStudyProject *project, GLoadedBinary *binary)
 {
     size_t result;                          /* Indice à retourner          */
     loaded_binary *loaded;                  /* Structure à renvoyer        */
@@ -385,8 +386,8 @@ size_t g_study_project_attach_binary(GStudyProject *project, GOpenidaBinary *bin
         loaded->views[i] = GTK_VIEW_PANEL(view);
 
         gtk_view_panel_attach_binary(loaded->views[i], binary,
-                                     g_openida_binary_display_addresses_in_text(binary),
-                                     g_openida_binary_display_code_in_text(binary));
+                                     g_loaded_binary_display_addresses_in_text(binary),
+                                     g_loaded_binary_display_code_in_text(binary));
 
         /* Intégration finale dans un support défilant */
 
@@ -402,9 +403,9 @@ size_t g_study_project_attach_binary(GStudyProject *project, GOpenidaBinary *bin
     /* Support graphique final */
 
     scroll = loaded->scrollwindows[BVW_BLOCK];
-    title = g_openida_binary_to_string(binary);
+    title = g_loaded_binary_get_filename(binary, false);
 
-    loaded->item = g_panel_item_new(strrchr(title, G_DIR_SEPARATOR) + 1, title, scroll, "M");
+    loaded->item = g_panel_item_new(title, title, scroll, "M");
 
     /* Enregistrement dans le projet */
 
@@ -439,7 +440,7 @@ size_t g_study_project_attach_binary(GStudyProject *project, GOpenidaBinary *bin
 *                                                                             *
 ******************************************************************************/
 
-void g_study_project_detach_binary(GStudyProject *project, GOpenidaBinary *binary)
+void g_study_project_detach_binary(GStudyProject *project, GLoadedBinary *binary)
 {
     //GtkDockPanel *dpanel;                   /* Support de panneaux         */
     //GDockItem *ditem;                       /* Support d'affichage utilisé */
@@ -479,7 +480,7 @@ void g_study_project_detach_binary(GStudyProject *project, GOpenidaBinary *binar
 *                                                                             *
 ******************************************************************************/
 
-GtkWidget *g_study_project_get_view_for_binary(const GStudyProject *project, const GOpenidaBinary *binary, BinaryView kind, GtkViewPanel **view)
+GtkWidget *g_study_project_get_view_for_binary(const GStudyProject *project, const GLoadedBinary *binary, BinaryView kind, GtkViewPanel **view)
 {
     GtkWidget *result;                      /* Composant GTK à retourner   */
     size_t i;                               /* Boucle de parcours          */
@@ -557,13 +558,13 @@ static void g_study_project_hide(const GStudyProject *project)
 *                                                                             *
 ******************************************************************************/
 
-GOpenidaBinary **g_study_project_get_binaries(const GStudyProject *project, size_t *count)
+GLoadedBinary **g_study_project_get_binaries(const GStudyProject *project, size_t *count)
 {
-    GOpenidaBinary **result;                /* Tableau à retourner         */
+    GLoadedBinary **result;                 /* Tableau à retourner         */
     size_t i;                               /* Boucle de parcours          */
 
     *count = project->binaries_count;
-    result = (GOpenidaBinary **)calloc(*count, sizeof(GOpenidaBinary *));
+    result = (GLoadedBinary **)calloc(*count, sizeof(GLoadedBinary *));
 
     for (i = 0; i < *count; i++)
     {
diff --git a/src/project.h b/src/project.h
index 3fd3dab..de5badb 100644
--- a/src/project.h
+++ b/src/project.h
@@ -79,22 +79,22 @@ bool g_study_project_save(GStudyProject *, const char *);
 const char *g_study_project_get_filename(const GStudyProject *);
 
 /* Assure l'intégration d'un élément binaire dans un projet. */
-void g_study_project_add_loaded_binary(GOpenidaBinary *, GStudyProject *);
+void g_study_project_add_loaded_binary(GLoadedBinary *, GStudyProject *);
 
 /* Attache un fichier donné à un projet donné. */
-size_t g_study_project_attach_binary(GStudyProject *, GOpenidaBinary *);
+size_t g_study_project_attach_binary(GStudyProject *, GLoadedBinary *);
 
 /* Détache un fichier donné à un projet donné. */
-void g_study_project_detach_binary(GStudyProject *, GOpenidaBinary *);
+void g_study_project_detach_binary(GStudyProject *, GLoadedBinary *);
 
 /* Fournit un support d'affichage donné pour un binaire chargé. */
-GtkWidget *g_study_project_get_view_for_binary(const GStudyProject *, const GOpenidaBinary *, BinaryView, GtkViewPanel **);
+GtkWidget *g_study_project_get_view_for_binary(const GStudyProject *, const GLoadedBinary *, BinaryView, GtkViewPanel **);
 
 /* Met en place un projet à l'écran. */
 void g_study_project_display(const GStudyProject *);
 
 /* Fournit l'ensemble des binaires associés à un projet. */
-GOpenidaBinary **g_study_project_get_binaries(const GStudyProject *, size_t *);
+GLoadedBinary **g_study_project_get_binaries(const GStudyProject *, size_t *);