Rewritten the whole API dealing with panels.

53 files changed, 2510 insertions, 843 deletions

diff --git a/plugins/pychrysalide/core.c b/plugins/pychrysalide/core.c
index fad21bf..1ba738d 100644
--- a/plugins/pychrysalide/core.c
+++ b/plugins/pychrysalide/core.c
@@ -69,7 +69,8 @@
 
 DEFINE_CHRYSALIDE_CONTAINER_PLUGIN("PyChrysalide", "Chrysalide bindings to Python",
                                    PACKAGE_VERSION, CHRYSALIDE_WEBSITE("api/python/pychrysalide"),
-                                   NO_REQ, AL(PGA_PLUGIN_INIT, PGA_PLUGIN_EXIT, PGA_NATIVE_LOADED));
+                                   NO_REQ, AL(PGA_PLUGIN_INIT, PGA_PLUGIN_EXIT,
+                                              PGA_NATIVE_LOADED, PGA_TYPE_BUILDING));
 
 
 /* Note la nature du chargement */
@@ -894,6 +895,54 @@ G_MODULE_EXPORT void chrysalide_plugin_on_native_loaded(GPluginModule *plugin, P
 
 /******************************************************************************
 *                                                                             *
+*  Paramètres  : plugin = greffon à manipuler.                                *
+*                action = type d'action attendue.                             *
+*                type   = type d'objet à mettre en place.                     *
+*                                                                             *
+*  Description : Crée une instance à partir d'un type dynamique externe.      *
+*                                                                             *
+*  Retour      : Instance d'objet gérée par l'extension ou NULL.              *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+G_MODULE_EXPORT gpointer chrysalide_plugin_build_type_instance(GPluginModule *plugin, PluginAction action, GType type)
+{
+    gpointer result;                        /* Instance à retourner        */
+    PyThreadState *tstate;                  /* Contexte d'environnement    */
+    PyTypeObject *pytype;                   /* Classe Python concernée     */
+    PyObject *instance;                     /* Initialisation forcée       */
+
+    result = NULL;
+
+    if (!_standalone)
+    {
+        tstate = get_pychrysalide_main_tstate();
+        PyEval_RestoreThread(tstate);
+    }
+
+    pytype = pygobject_lookup_class(type);
+
+    if (pytype != NULL)
+    {
+        instance = PyObject_CallObject((PyObject *)pytype, NULL);
+        assert(instance != NULL);
+
+        result = pygobject_get(instance);
+
+    }
+
+    if (!_standalone)
+        PyEval_SaveThread();
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
 *  Paramètres  : -                                                            *
 *                                                                             *
 *  Description : Fournit les informations du thread principal.                *
diff --git a/plugins/pychrysalide/core.h b/plugins/pychrysalide/core.h
index 368a7c3..0f8b484 100644
--- a/plugins/pychrysalide/core.h
+++ b/plugins/pychrysalide/core.h
@@ -52,6 +52,9 @@ G_MODULE_EXPORT void chrysalide_plugin_exit(GPluginModule *);
 /* Accompagne la fin du chargement des modules natifs. */
 G_MODULE_EXPORT void chrysalide_plugin_on_native_loaded(GPluginModule *, PluginAction);
 
+/* Crée une instance à partir d'un type dynamique externe. */
+G_MODULE_EXPORT gpointer chrysalide_plugin_build_type_instance(GPluginModule *, PluginAction, GType);
+
 /* Fournit les informations du thread principal. */
 PyThreadState *get_pychrysalide_main_tstate(void);
 
diff --git a/plugins/pychrysalide/format/format.c b/plugins/pychrysalide/format/format.c
index 6761392..66d346c 100644
--- a/plugins/pychrysalide/format/format.c
+++ b/plugins/pychrysalide/format/format.c
@@ -235,7 +235,7 @@ static int py_binary_format_init(PyObject *self, PyObject *args, PyObject *kwds)
     " value indicating the endianness of the format.\n"                 \
     "\n"                                                                \
     "Calls to the *__init__* constructor of this abstract object expect"\
-    " no particular argument.\n"
+    " no particular argument."
 
     /* Initialisation d'un objet GLib */
 
diff --git a/plugins/pychrysalide/gui/constants.c b/plugins/pychrysalide/gui/constants.c
index 3cd943c..0930f41 100644
--- a/plugins/pychrysalide/gui/constants.c
+++ b/plugins/pychrysalide/gui/constants.c
@@ -53,6 +53,7 @@ bool define_panel_item_constants(PyTypeObject *type)
 
     result = add_const_to_group(values, "INVALID", PIP_INVALID);
     if (result) result = add_const_to_group(values, "SINGLETON", PIP_SINGLETON);
+    if (result) result = add_const_to_group(values, "PERSISTENT_SINGLETON", PIP_PERSISTENT_SINGLETON);
     if (result) result = add_const_to_group(values, "BINARY_VIEW", PIP_BINARY_VIEW);
     if (result) result = add_const_to_group(values, "OTHER", PIP_OTHER);
     if (result) result = add_const_to_group(values, "COUNT", PIP_COUNT);
diff --git a/plugins/pychrysalide/gui/core/items.c b/plugins/pychrysalide/gui/core/items.c
index ce3eaee..95842fc 100644
--- a/plugins/pychrysalide/gui/core/items.c
+++ b/plugins/pychrysalide/gui/core/items.c
@@ -66,29 +66,36 @@ static PyObject *py_items_update_project(PyObject *, PyObject *);
 *                                                                             *
 ******************************************************************************/
 
-static PyObject *py_items_find_editor_item_by_key(PyObject *self, PyObject *args)
+static PyObject *py_items_find_editor_item_by_type(PyObject *self, PyObject *args)
 {
     PyObject *result;                       /* Trouvaille à retourner      */
-    const char *key;                        /* Objet des recherches        */
+    GType type;                             /* Type d'élément à traiter    */
     int ret;                                /* Bilan de lecture des args.  */
     GEditorItem *found;                     /* Instance retrouvée ou NULL  */
 
-#define ITEMS_FIND_EDITOR_ITEM_BY_KEY_METHOD PYTHON_METHOD_DEF          \
-(                                                                       \
-    find_editor_item_by_key, "key",                                     \
-    METH_VARARGS, py_items,                                             \
-    "Find the editor component belonging to a given key."               \
-    "\n"                                                                \
-    "The key has to be provided as a simple (short) string, and the"    \
-    " result is a pychrysalide.gui.EditorItem instance or None if no"   \
-    " component is found for the given key."                            \
+#define ITEMS_FIND_EDITOR_ITEM_BY_TYPE_METHOD PYTHON_METHOD_DEF     \
+(                                                                   \
+    find_editor_item_by_type, "cls",                                \
+    METH_VARARGS, py_items,                                         \
+    "Find the editor component belonging to a given class."         \
+    "\n"                                                            \
+    "The provided *cls* has to be an pychrysalide.gui.EditorItem"   \
+    " derived class."                                               \
+    "\n"                                                            \
+    "The result is an pychrysalide.gui.EditorItem instance or None" \
+    " if no component is found for the given key."                  \
 )
 
-    ret = PyArg_ParseTuple(args, "s", &key);
+    ret = PyArg_ParseTuple(args, "O&", convert_to_gtype, &type);
     if (!ret) return NULL;
 
+    if (!g_type_is_a(type, G_TYPE_EDITOR_ITEM))
+    {
+        PyErr_SetString(PyExc_TypeError, "the argument must be a class derived from pychrysalide.gui.EditorItem");
+        return NULL;
+    }
 
-    found = find_editor_item_by_key(key);
+    found = find_editor_item_by_type(type);
 
     if (found == NULL)
     {
@@ -276,7 +283,7 @@ bool populate_gui_core_module_with_items(void)
     PyObject *module;                       /* Module à recompléter        */
 
     static PyMethodDef py_items_methods[] = {
-        ITEMS_FIND_EDITOR_ITEM_BY_KEY_METHOD,
+        ITEMS_FIND_EDITOR_ITEM_BY_TYPE_METHOD,
         ITEMS_CHANGE_CURRENT_CONTENT_METHOD,
         ITEMS_CHANGE_CURRENT_VIEW_METHOD,
         ITEMS_UPDATE_CURRENT_VIEW_METHOD,
diff --git a/plugins/pychrysalide/gui/core/panels.c b/plugins/pychrysalide/gui/core/panels.c
index 2a3c275..4fdc3f2 100644
--- a/plugins/pychrysalide/gui/core/panels.c
+++ b/plugins/pychrysalide/gui/core/panels.c
@@ -58,38 +58,59 @@ static PyObject *py_panels_register_panel(PyObject *, PyObject *);
 
 static PyObject *py_panels_register_panel(PyObject *self, PyObject *args)
 {
-    GPanelItem *item;                       /* Panneau à traiter           */
-    GGenConfig *config;                     /* Configuration à consulter   */
+    GType type;                             /* Type de panneau à traiter   */
     int ret;                                /* Bilan de lecture des args.  */
-
-#define PANELS_REGISTER_PANEL_METHOD PYTHON_METHOD_DEF              \
-(                                                                   \
-    register_panel, "panel",                                        \
-    METH_VARARGS, py_panels,                                        \
-    "Register a panel for the GUI."                                 \
-    "\n"                                                            \
-    "The provided panel has to be a pychrysalide.gui.PanelItem"     \
-    " instance."                                                    \
+    PyObject *meta;                         /* Type _GObjectMetaBase       */
+    PyObject *instance;                     /* Initialisation forcée       */
+
+#define PANELS_REGISTER_PANEL_METHOD PYTHON_METHOD_DEF          \
+(                                                               \
+    register_panel, "cls",                                      \
+    METH_VARARGS, py_panels,                                    \
+    "Register a panel class for the GUI."                       \
+    "\n"                                                        \
+    "The provided *cls* has to be a pychrysalide.gui.PanelItem" \
+    " derived class."                                           \
 )
 
-    config = NULL;
+    ret = PyArg_ParseTuple(args, "O&", convert_to_gtype, &type);
+    if (!ret) return NULL;
+
+    if (!g_type_is_a(type, G_TYPE_PANEL_ITEM))
+    {
+        PyErr_SetString(PyExc_TypeError, "the argument must be a class derived from pychrysalide.gui.PanelItem");
+        return NULL;
+    }
+
+    /**
+     * Si la classe transmise n'a jamais été utilisée pour créer une instance,
+     * py_panel_item_new() n'a donc jamais été exécutée et le type dynamique
+     * associé au panneau n'a jamais été initialisé par Chrysalide.
+     *
+     * Cette création dynamique de type est donc forcée ici.
+     */
 
-    ret = PyArg_ParseTuple(args, "O&", convert_to_panel_item, &item);
+    ret = PyArg_ParseTuple(args, "O", &meta);
     if (!ret) return NULL;
 
-    if (config == NULL)
-        config = get_main_configuration();
+    instance = PyObject_CallObject(meta, NULL);
+
+    if (instance == NULL)
+    {
+        PyErr_SetString(PyExc_TypeError, "the argument must be a class derived from pychrysalide.gui.PanelItem");
+        return NULL;
+    }
 
-    register_panel_item(item, config);
+    Py_DECREF(instance);
 
     /**
-     * Si Python ne voit plus la variable représentant le panneau utilisée,
-     * il va la supprimer, ce qui va supprimer le composant GTK.
-     *
-     * On sera donc en situation de Use-After-Free, dont les conséquences
-     * arrivent très vite.
+     * Rechargement du type, afin d'obtenir la version dynamique avec certitude.
      */
-    pygobject_new(G_OBJECT(item));
+
+    ret = PyArg_ParseTuple(args, "O&", convert_to_gtype, &type);
+    if (!ret) return NULL;
+
+    register_panel_item(type, get_main_configuration());
 
     Py_RETURN_NONE;
 
diff --git a/plugins/pychrysalide/gui/item.c b/plugins/pychrysalide/gui/item.c
index 2e32167..2046587 100644
--- a/plugins/pychrysalide/gui/item.c
+++ b/plugins/pychrysalide/gui/item.c
@@ -73,7 +73,7 @@
 
 
 /* Fournit le nom interne attribué à l'élément réactif. */
-static char *py_editor_item_get_key_wrapper(const GEditorItem *);
+static char *py_editor_item_get_key_wrapper(const GEditorItemClass *);
 
 /* Fournit le composant GTK associé à l'élément réactif. */
 static GtkWidget *py_editor_item_get_widget_wrapper(const GEditorItem *);
@@ -141,7 +141,7 @@ void py_editor_item_init_gclass(GEditorItemClass *class, gpointer unused)
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : item = instance à consulter.                                 *
+*  Paramètres  : class = classe à consulter.                                  *
 *                                                                             *
 *  Description : Fournit le nom interne attribué à l'élément réactif.         *
 *                                                                             *
@@ -151,31 +151,31 @@ void py_editor_item_init_gclass(GEditorItemClass *class, gpointer unused)
 *                                                                             *
 ******************************************************************************/
 
-static char *py_editor_item_get_key_wrapper(const GEditorItem *item)
+static char *py_editor_item_get_key_wrapper(const GEditorItemClass *class)
 {
     char *result;                           /* Désignation à retourner     */
     PyGILState_STATE gstate;                /* Sauvegarde d'environnement  */
-    PyObject *pyobj;                        /* Objet Python concerné       */
+    PyTypeObject *pytype;                   /* Classe Python concernée     */
     PyObject *pykey;                        /* Clef en objet Python        */
     int ret;                                /* Bilan d'une conversion      */
 
 #define EDITOR_ITEM_KEY_ATTRIB_WRAPPER PYTHON_GETTER_WRAPPER_DEF    \
 (                                                                   \
-    _key,                                                          \
+    _key,                                                           \
     "Provide the internal name to use for the editor item.\n"       \
     "\n"                                                            \
-    "The result has to be a string."                                \
+    "The value has to be a string."                                 \
 )
 
     result = NULL;
 
     gstate = PyGILState_Ensure();
 
-    pyobj = pygobject_new(G_OBJECT(item));
+    pytype = pygobject_lookup_class(G_TYPE_FROM_CLASS(class));
 
-    if (PyObject_HasAttrString(pyobj, "_key"))
+    if (PyObject_HasAttrString((PyObject *)pytype, "_key"))
     {
-        pykey = PyObject_GetAttrString(pyobj, "_key");
+        pykey = PyObject_GetAttrString((PyObject *)pytype, "_key");
 
         if (pykey != NULL)
         {
@@ -190,8 +190,6 @@ static char *py_editor_item_get_key_wrapper(const GEditorItem *item)
 
     }
 
-    Py_DECREF(pyobj);
-
     PyGILState_Release(gstate);
 
     return result;
@@ -226,7 +224,7 @@ static GtkWidget *py_editor_item_get_widget_wrapper(const GEditorItem *item)
     _widget,                                                            \
     "Provide the Gtk widget base involved in the editor item.\n"        \
     "\n"                                                                \
-    "The result has to be a Gtk.Widget instance."                       \
+    "The value has to be a Gtk.Widget instance."                        \
 )
 
     result = NULL;
@@ -574,11 +572,11 @@ static PyObject *py_editor_item_get_key(PyObject *self, void *closure)
 #define EDITOR_ITEM_KEY_ATTRIB PYTHON_GET_DEF_FULL      \
 (                                                       \
     key, py_editor_item,                                \
-    "Internal name given to the editor item."              \
+    "Internal string name given to the editor item."    \
 )
 
     item = G_EDITOR_ITEM(pygobject_get(self));
-    key = g_editor_item_get_key(item);
+    key = g_editor_item_class_get_key(G_EDITOR_ITEM_GET_CLASS(item));
 
     if (key != NULL)
     {
diff --git a/plugins/pychrysalide/gui/panel.c b/plugins/pychrysalide/gui/panel.c
index d9a2bc5..160a7a3 100644
--- a/plugins/pychrysalide/gui/panel.c
+++ b/plugins/pychrysalide/gui/panel.c
@@ -50,9 +50,24 @@
 /* Accompagne la création d'une instance dérivée en Python. */
 static PyObject *py_panel_item_new(PyTypeObject *, PyObject *, PyObject *);
 
-/* Initialise la classe des panneaux pour l'interface graphique. */
+/* Initialise la classe des panneaux graphiques de l'éditeur. */
 static void py_panel_item_init_gclass(GPanelItemClass *, gpointer);
 
+/* Fournit une indication sur la personnalité du panneau. */
+static PanelItemPersonality py_panel_item_class_get_personality_wrapper(const GPanelItemClass *);
+
+/* Fournit une indication d'accroche du panneau au démarrage. */
+static bool py_panel_item_class_dock_at_startup_wrapper(const GPanelItemClass *);
+
+/* Détermine si un panneau peut être filtré. */
+static bool py_panel_item_class_can_search_wrapper(const GPanelItemClass *);
+
+/* Indique le chemin initial de la localisation d'un panneau. */
+static char *py_panel_item_class_get_path_wrapper(const GPanelItemClass *);
+
+/* Indique la définition d'un éventuel raccourci clavier. */
+static char *py_panel_item_class_get_key_bindings_wrapper(const GPanelItemClass *);
+
 /* Initialise une instance sur la base du dérivé de GObject. */
 static int py_panel_item_init(PyObject *self, PyObject *args, PyObject *kwds);
 
@@ -67,18 +82,30 @@ static PyObject *py_panel_item_dock(PyObject *, PyObject *);
 /* Supprime un panneau de l'ensemble affiché. */
 static PyObject *py_panel_item_undock(PyObject *, PyObject *);
 
-/* Fournit le chemin d'accès à utiliser pour les encapsulations. */
-static PyObject *py_panel_item_get_named_widget(PyObject *, void *);
-
 /* Fournit une indication sur la personnalité du panneau. */
 static PyObject *py_panel_item_get_personality(PyObject *, void *);
 
+/* Fournit une indication d'accroche du panneau au démarrage. */
+static PyObject *py_panel_item_get_dock_at_startup(PyObject *, void *);
+
+/*  Définit si le composant repose sur un support de l'éditeur. */
+static int py_panel_item_set_dock_at_startup(PyObject *, PyObject *, void *);
+
+/* Détermine si un panneau peut être filtré. */
+static PyObject *py_panel_item_can_search(PyObject *, void *);
+
 /* Fournit le chemin d'accès à utiliser pour les encapsulations. */
 static PyObject *py_panel_item_get_path(PyObject *, void *);
 
 /* Définit le chemin d'accès à utiliser pour les encapsulations. */
 static int py_panel_item_set_path(PyObject *, PyObject *, void *);
 
+/* Indique la définition d'un éventuel raccourci clavier. */
+static PyObject *py_panel_item_get_key_bindings(PyObject *, void *);
+
+/* Fournit le chemin d'accès à utiliser pour les encapsulations. */
+static PyObject *py_panel_item_get_named_widget(PyObject *, void *);
+
 /* Indique si le composant repose sur un support de l'éditeur. */
 static PyObject *py_panel_item_get_docked(PyObject *, void *);
 
@@ -157,7 +184,7 @@ static PyObject *py_panel_item_new(PyTypeObject *type, PyObject *args, PyObject
 *  Paramètres  : class  = classe à initialiser.                               *
 *                unused = données non utilisées ici.                          *
 *                                                                             *
-*  Description : Initialise la classe des panneaux pour l'interface graphique.*
+*  Description : Initialise la classe des panneaux graphiques de l'éditeur.   *
 *                                                                             *
 *  Retour      : -                                                            *
 *                                                                             *
@@ -169,6 +196,317 @@ static void py_panel_item_init_gclass(GPanelItemClass *class, gpointer unused)
 {
     py_editor_item_init_gclass(G_EDITOR_ITEM_CLASS(class), NULL);
 
+    class->get_personality = py_panel_item_class_get_personality_wrapper;
+    class->dock_at_startup = py_panel_item_class_dock_at_startup_wrapper;
+    class->can_search = py_panel_item_class_can_search_wrapper;
+    class->get_path = py_panel_item_class_get_path_wrapper;
+    class->get_bindings = py_panel_item_class_get_key_bindings_wrapper;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : class = classe à consulter.                                  *
+*                                                                             *
+*  Description : Fournit une indication sur la personnalité du panneau.       *
+*                                                                             *
+*  Retour      : Identifiant lié à la nature du panneau.                      *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static PanelItemPersonality py_panel_item_class_get_personality_wrapper(const GPanelItemClass *class)
+{
+    PanelItemPersonality result;            /* Personnalité à retourner    */
+    PyGILState_STATE gstate;                /* Sauvegarde d'environnement  */
+    PyTypeObject *pytype;                   /* Classe Python concernée     */
+    PyObject *value;                        /* Valeur d'attribut en Python */
+    int ret;                                /* Bilan d'une conversion      */
+
+#define PANEL_ITEM_PERSONALITY_ATTRIB_WRAPPER PYTHON_GETTER_WRAPPER_DEF     \
+(                                                                           \
+    _personality,                                                           \
+    "Abstract attribute defining the initial rule for handling panel"       \
+    " creation.\n"                                                          \
+    "\n"                                                                    \
+    "The result has to be a pychrysalide.gui.PanelItem.PanelItemPersonality"\
+    " value.\n"                                                             \
+    "\n"                                                                    \
+    "The default value is *PanelItem.PanelItemPersonality.SINGLETON*."      \
+)
+
+    result = PIP_SINGLETON;
+
+    gstate = PyGILState_Ensure();
+
+    pytype = pygobject_lookup_class(G_TYPE_FROM_CLASS(class));
+
+    if (PyObject_HasAttrString((PyObject *)pytype, "_personality"))
+    {
+        value = PyObject_GetAttrString((PyObject *)pytype, "_personality");
+
+        if (value != NULL)
+        {
+            ret = convert_to_panel_item_personality(value, &result);
+
+            if (ret != 1)
+            {
+                PyErr_Clear();
+                result = PIP_OTHER;
+            }
+
+            Py_DECREF(value);
+
+        }
+
+    }
+
+    PyGILState_Release(gstate);
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : class = classe à consulter.                                  *
+*                                                                             *
+*  Description : Fournit une indication d'accroche du panneau au démarrage.   *
+*                                                                             *
+*  Retour      : true si le panneau doit être affiché de prime abord.         *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static bool py_panel_item_class_dock_at_startup_wrapper(const GPanelItemClass *class)
+{
+    bool result;                            /* Statut à retourner          */
+    PyGILState_STATE gstate;                /* Sauvegarde d'environnement  */
+    PyTypeObject *pytype;                   /* Classe Python concernée     */
+    PyObject *value;                        /* Valeur d'attribut en Python */
+    int ret;                                /* Bilan d'une conversion      */
+
+#define PANEL_ITEM_DOCK_AT_STARTUP_ATTRIB_WRAPPER PYTHON_GETTER_WRAPPER_DEF \
+(                                                                           \
+    _dock_at_startup,                                                       \
+    "Abstract attribute defining if the panel should get docked"            \
+    " automatically at startup.\n"                                          \
+    "\n"                                                                    \
+    "The value has to be a boolean value: *True* or *False*.\n"             \
+    "\n"                                                                    \
+    "The default value is *True*."                                          \
+)
+
+    result = true;
+
+    gstate = PyGILState_Ensure();
+
+    pytype = pygobject_lookup_class(G_TYPE_FROM_CLASS(class));
+
+    if (PyObject_HasAttrString((PyObject *)pytype, "_dock_at_startup"))
+    {
+        value = PyObject_GetAttrString((PyObject *)pytype, "_dock_at_startup");
+
+        if (value != NULL)
+        {
+            ret = PyBool_Check(value);
+
+            if (ret)
+                result = (value == Py_True);
+
+            Py_DECREF(value);
+
+        }
+
+    }
+
+    PyGILState_Release(gstate);
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : class = classe à consulter.                                  *
+*                                                                             *
+*  Description : Détermine si un panneau peut être filtré.                    *
+*                                                                             *
+*  Retour      : Bilan de la consultation.                                    *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static bool py_panel_item_class_can_search_wrapper(const GPanelItemClass *class)
+{
+    bool result;                            /* Statut à retourner          */
+    PyGILState_STATE gstate;                /* Sauvegarde d'environnement  */
+    PyTypeObject *pytype;                   /* Classe Python concernée     */
+    PyObject *value;                        /* Valeur d'attribut en Python */
+    int ret;                                /* Bilan d'une conversion      */
+
+#define PANEL_ITEM_CAN_SEARCH_ATTRIB_WRAPPER PYTHON_GETTER_WRAPPER_DEF  \
+(                                                                       \
+    _can_search,                                                        \
+    "Abstract attribute defining if the panel contains content which"   \
+    " can get searched.\n"                                              \
+    "\n"                                                                \
+    "The value has to be a boolean value: *True* or *False*.\n"         \
+    "\n"                                                                \
+    "The default value is *False*."                                     \
+)
+
+    result = false;
+
+    gstate = PyGILState_Ensure();
+
+    pytype = pygobject_lookup_class(G_TYPE_FROM_CLASS(class));
+
+    if (PyObject_HasAttrString((PyObject *)pytype, "_can_search"))
+    {
+        value = PyObject_GetAttrString((PyObject *)pytype, "_can_search");
+
+        if (value != NULL)
+        {
+            ret = PyBool_Check(value);
+
+            if (ret)
+                result = (value == Py_True);
+
+            Py_DECREF(value);
+
+        }
+
+    }
+
+    PyGILState_Release(gstate);
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : class = classe à consulter.                                  *
+*                                                                             *
+*  Description : Indique le chemin initial de la localisation d'un panneau.   *
+*                                                                             *
+*  Retour      : Chemin fixé associé à la position initiale.                  *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static char *py_panel_item_class_get_path_wrapper(const GPanelItemClass *class)
+{
+    char *result;                           /* Désignation à retourner     */
+    PyGILState_STATE gstate;                /* Sauvegarde d'environnement  */
+    PyTypeObject *pytype;                   /* Classe Python concernée     */
+    PyObject *value;                        /* Valeur d'attribut en Python */
+    int ret;                                /* Bilan d'une conversion      */
+
+#define PANEL_ITEM_PATH_ATTRIB_WRAPPER PYTHON_GETTER_WRAPPER_DEF    \
+(                                                                   \
+    _path,                                                          \
+    "Abstract attribute used to provide the path to the initial"    \
+    " location of the panel item.\n"                                \
+    "\n"                                                            \
+    "The value has to be a string."                                 \
+)
+
+    result = NULL;
+
+    gstate = PyGILState_Ensure();
+
+    pytype = pygobject_lookup_class(G_TYPE_FROM_CLASS(class));
+
+    if (PyObject_HasAttrString((PyObject *)pytype, "_path"))
+    {
+        value = PyObject_GetAttrString((PyObject *)pytype, "_path");
+
+        if (value != NULL)
+        {
+            ret = PyUnicode_Check(value);
+
+            if (ret)
+                result = strdup(PyUnicode_AsUTF8(value));
+
+            Py_DECREF(value);
+
+        }
+
+    }
+
+    PyGILState_Release(gstate);
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : class = classe à consulter.                                  *
+*                                                                             *
+*  Description : Indique la définition d'un éventuel raccourci clavier.       *
+*                                                                             *
+*  Retour      : Description d'un raccourci ou NULL si aucun de défini.       *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static char *py_panel_item_class_get_key_bindings_wrapper(const GPanelItemClass *class)
+{
+    char *result;                           /* Désignation à retourner     */
+    PyGILState_STATE gstate;                /* Sauvegarde d'environnement  */
+    PyTypeObject *pytype;                   /* Classe Python concernée     */
+    PyObject *value;                        /* Valeur d'attribut en Python */
+    int ret;                                /* Bilan d'une conversion      */
+
+#define PANEL_ITEM_BINDINGS_ATTRIB_WRAPPER PYTHON_GETTER_WRAPPER_DEF    \
+(                                                                       \
+    _key_bindings,                                                      \
+    "Abstract attribute used to provide an optional key bindings as"    \
+    " shortcuts for the panel item.\n"                                  \
+    "\n"                                                                \
+    "The value has to be a string."                                     \
+)
+
+    result = NULL;
+
+    gstate = PyGILState_Ensure();
+
+    pytype = pygobject_lookup_class(G_TYPE_FROM_CLASS(class));
+
+    if (PyObject_HasAttrString((PyObject *)pytype, "_key_bindings"))
+    {
+        value = PyObject_GetAttrString((PyObject *)pytype, "_key_bindings");
+
+        if (value != NULL)
+        {
+            ret = PyUnicode_Check(value);
+
+            if (ret)
+                result = strdup(PyUnicode_AsUTF8(value));
+
+            Py_DECREF(value);
+
+        }
+
+    }
+
+    PyGILState_Release(gstate);
+
+    return result;
+
 }
 
 
@@ -188,55 +526,50 @@ static void py_panel_item_init_gclass(GPanelItemClass *class, gpointer unused)
 
 static int py_panel_item_init(PyObject *self, PyObject *args, PyObject *kwds)
 {
-    PanelItemPersonality personality;       /* Nature du panneau           */
     GNamedWidget *widget;                   /* Composant visuel du panneau */
-    int startup;                            /* Recommandation au démarrage */
-    const char *path;                       /* Placement à l'affichage     */
     int ret;                                /* Bilan de lecture des args.  */
     GPanelItem *panel;                      /* Panneau à manipuler         */
 
-    static char *kwlist[] = { "personality", "widget", "dock", "path", NULL };
-
 #define PANEL_ITEM_DOC                                                          \
     "PanelItem is an abstract class for panels available in the main GUI"       \
     " interface.\n"                                                             \
     "\n"                                                                        \
     "Instances can be created using the following constructor:\n"               \
     "\n"                                                                        \
-    "    PanelItem(personality, widget, dock, path)"                            \
+    "    PanelItem(widget)"                                                     \
     "\n"                                                                        \
     "Where:\n"                                                                  \
-    "* personality defines how many instances of the panels can be created"     \
-    " at the same time.\n"                                                      \
     "* widget is an implementation of the pychrysalide.glibext.NamedWidget"     \
     " interface (see pychrysalide.gtkext.BuiltNamedWidget for a ready-to-use"   \
     " helper).\n"                                                               \
-    "* dock defines if the panel is docked by default.\n"                       \
-    "* path states the location of the panel inside the main GUI.\n"            \
-    "\n"                                                                        \
-    "The easiest way to pass all this information is probably to use a"         \
-    " transitional dictionary inside the panel *__init__()* constructor:\n"     \
-    "\n"                                                                        \
-    "    params = {\n"                                                          \
-    "        'personality' : PanelItemPersonality.PIP_SINGLETON,\n"             \
-    "        'widget' : my_named_widget_instance,\n"                            \
-    "        'dock' : True,\n"                                                  \
-    "        'path' : 'MES'\n"                                                  \
-    "    }\n"                                                                   \
-    "    super(MyPanel, self).__init__(**params)\n"                             \
     "\n"                                                                        \
     "The PanelItem definition handles internally the supply of the *_widget*"   \
     " attribute for pychrysalide.gui.EditorItem.\n"                             \
     "\n"                                                                        \
+    "Several items have to be defined as class attribute in the final class:\n" \
+    "* pychrysalide.gui.PanelItem._path: path to the initial location of the"   \
+    " panel item;\n"                                                            \
+    "* pychrysalide.gui.PanelItem._key_bindings: optional shortcut to show the" \
+    " relative panel.\n"                                                        \
+    "\n"                                                                        \
+    "Some extra items offer default values and thus may be defined as class"    \
+    " attribute in the final class:\n"                                          \
+    "* pychrysalide.gui.PanelItem._personality: rule for the panel creation;\n" \
+    "* pychrysalide.gui.PanelItem._dock_at_startup: *True* if the panel should" \
+    " get docked automatically at startup;\n"                                   \
+    "* pychrysalide.gui.PanelItem._can_search: True if the panel contains"      \
+    " content which can get searched.\n"                                        \
+    "\n"                                                                        \
     "For more details about the panel path, please refer to"                    \
-    " pychrysalide.gtkext.GtkDockable."
+    " pychrysalide.gtkext.GtkDockable.\n"                                       \
+    "\n"                                                                        \
+    "Because panels aim to be created on demand by the Chrysalide core, calls"  \
+    " to the *__init__* constructor of this abstract object must expect no"     \
+    " particular argument."
 
     /* Récupération des paramètres */
 
-    ret = PyArg_ParseTupleAndKeywords(args, kwds, "O&O&ps", kwlist,
-                                      convert_to_panel_item_personality, &personality,
-                                      convert_to_named_widget, &widget,
-                                      &startup, &path);
+    ret = PyArg_ParseTuple(args, "O&", convert_to_named_widget, &widget);
     if (!ret) return -1;
 
     /* Initialisation d'un objet GLib */
@@ -248,8 +581,6 @@ static int py_panel_item_init(PyObject *self, PyObject *args, PyObject *kwds)
 
     panel = G_PANEL_ITEM(pygobject_get(self));
 
-    panel->personality = personality;
-
     /**
      * Si Python ne voit plus la variable représentant le panneau utilisée,
      * il va la supprimer, ce qui va supprimer le composant GTK.
@@ -260,9 +591,6 @@ static int py_panel_item_init(PyObject *self, PyObject *args, PyObject *kwds)
     panel->widget = widget;
     g_object_ref(G_OBJECT(widget));
 
-    panel->dock_at_startup = startup;
-    panel->path = strdup(path);
-
     return 0;
 
 }
@@ -345,32 +673,31 @@ static PyObject *py_panel_item_undock(PyObject *self, PyObject *args)
 *  Paramètres  : self    = objet Python concerné par l'appel.                 *
 *                closure = non utilisé ici.                                   *
 *                                                                             *
-*  Description : Fournit le chemin d'accès à utiliser pour les encapsulations.*
+*  Description : Fournit une indication sur la personnalité du panneau.       *
 *                                                                             *
-*  Retour      : Chemin d'accès défini.                                       *
+*  Retour      : Identifiant lié à la nature du panneau.                      *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-static PyObject *py_panel_item_get_named_widget(PyObject *self, void *closure)
+static PyObject *py_panel_item_get_personality(PyObject *self, void *closure)
 {
     PyObject *result;                       /* Valeur à retourner          */
     GPanelItem *item;                       /* Panneau à consulter         */
-    GNamedWidget *widget;                   /* Composant nommé à transférer*/
+    PanelItemPersonality personality;       /* Valeur native à convertir   */
 
-#define PANEL_ITEM_NAMED_WIDGET_ATTRIB PYTHON_GET_DEF_FULL  \
-(                                                           \
-    named_widget, py_panel_item,                            \
-    "Named widget as core component of the panel item."     \
+#define PANEL_ITEM_PERSONALITY_ATTRIB PYTHON_GET_DEF_FULL       \
+(                                                               \
+    personality, py_panel_item,                                 \
+    "Rule for handling panel creations, as a"                   \
+    " pychrysalide.gui.PanelItem.PanelItemPersonality value."   \
 )
 
     item = G_PANEL_ITEM(pygobject_get(self));
-    widget = gtk_panel_item_get_named_widget(item);
-
-    result = pygobject_new(G_OBJECT(widget));
+    personality = gtk_panel_item_class_get_personality(G_PANEL_ITEM_GET_CLASS(item));
 
-    g_object_unref(G_OBJECT(widget));
+    result = cast_with_constants_group_from_type(get_python_panel_item_type(), "PanelItemPersonality", personality);
 
     return result;
 
@@ -382,31 +709,102 @@ static PyObject *py_panel_item_get_named_widget(PyObject *self, void *closure)
 *  Paramètres  : self    = objet Python concerné par l'appel.                 *
 *                closure = non utilisé ici.                                   *
 *                                                                             *
-*  Description : Fournit une indication sur la personnalité du panneau.       *
+*  Description : Fournit une indication d'accroche du panneau au démarrage.   *
 *                                                                             *
-*  Retour      : Identifiant lié à la nature du panneau.                      *
+*  Retour      : True si le panneau doit être affiché de prime abord.         *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-static PyObject *py_panel_item_get_personality(PyObject *self, void *closure)
+static PyObject *py_panel_item_get_dock_at_startup(PyObject *self, void *closure)
 {
     PyObject *result;                       /* Valeur à retourner          */
     GPanelItem *item;                       /* Panneau à consulter         */
-    PanelItemPersonality personality;       /* Valeur native à convertir   */
+    bool state;                             /* Indication d'ancrage        */
+
+#define PANEL_ITEM_DOCK_AT_STARTUP_ATTRIB PYTHON_GETSET_DEF_FULL        \
+(                                                                       \
+    dock_at_startup, py_panel_item,                                     \
+    "Tell or define if the panel should get docked automatically at"    \
+    " startup.\n"                                                       \
+    "\n"                                                                \
+    "This state is a boolean value: *True* or *False*."                 \
+)
 
-#define PANEL_ITEM_PERSONALITY_ATTRIB PYTHON_GET_DEF_FULL       \
-(                                                               \
-    personality, py_panel_item,                                 \
-    "Rule for handling panel creations, as a"                   \
-    " pychrysalide.gui.PanelItem.PanelItemPersonality value."   \
+    item = G_PANEL_ITEM(pygobject_get(self));
+    state = gtk_panel_item_class_dock_at_startup(G_PANEL_ITEM_GET_CLASS(item));
+
+    result = state ? Py_True : Py_False;
+    Py_INCREF(result);
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : self    = objet Python concerné par l'appel.                 *
+*                value   = valeur fournie à intégrer ou prendre en compte.    *
+*                closure = adresse non utilisée ici.                          *
+*                                                                             *
+*  Description : Définit si le composant repose sur un support de l'éditeur.  *
+*                                                                             *
+*  Retour      : Bilan de l'opération.                                        *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static int py_panel_item_set_dock_at_startup(PyObject *self, PyObject *value, void *closure)
+{
+    GPanelItem *item;                       /* Panneau à manipuler         */
+
+    if (!PyBool_Check(value))
+        return -1;
+
+    item = G_PANEL_ITEM(pygobject_get(self));
+
+    g_panel_item_set_dock_at_startup(item, value == Py_True);
+
+    return 0;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : self    = objet Python concerné par l'appel.                 *
+*                closure = non utilisé ici.                                   *
+*                                                                             *
+*  Description : Détermine si un panneau peut être filtré.                    *
+*                                                                             *
+*  Retour      : Bilan de la consultation.                                    *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static PyObject *py_panel_item_can_search(PyObject *self, void *closure)
+{
+    PyObject *result;                       /* Valeur à retourner          */
+    GPanelItem *item;                       /* Panneau à consulter         */
+    bool status;                            /* Capacité de recherche       */
+
+#define PANEL_ITEM_CAN_SEARCH_ATTRIB PYTHON_CAN_DEF_FULL                \
+(                                                                       \
+    search, py_panel_item,                                              \
+    "Define if the panel contains content which can get searched.\n"    \
+    "\n"                                                                \
+    "The result is a boolean value: *True* or *False*.\n"               \
 )
 
     item = G_PANEL_ITEM(pygobject_get(self));
-    personality = gtk_panel_item_get_personality(item);
+    status = gtk_panel_item_class_can_search(G_PANEL_ITEM_GET_CLASS(item));
 
-    result = cast_with_constants_group_from_type(get_python_panel_item_type(), "PanelItemPersonality", personality);
+    result = status ? Py_True : Py_False;
+    Py_INCREF(result);
 
     return result;
 
@@ -430,19 +828,23 @@ static PyObject *py_panel_item_get_path(PyObject *self, void *closure)
 {
     PyObject *result;                       /* Valeur à retourner          */
     GPanelItem *item;                       /* Panneau à consulter         */
-    const char *path;                       /* Chemin d'accès courant      */
+    char *path;                             /* Chemin d'accès courant      */
 
 #define PANEL_ITEM_PATH_ATTRIB PYTHON_GETSET_DEF_FULL       \
 (                                                           \
     path, py_panel_item,                                    \
     "Get or define the current path of the panel item."     \
+    "\n"                                                    \
+    "The path is defined as a string."                      \
 )
 
     item = G_PANEL_ITEM(pygobject_get(self));
-    path = gtk_panel_item_get_path(item);
+    path = gtk_panel_item_class_get_path(G_PANEL_ITEM_GET_CLASS(item));
 
     result = PyUnicode_FromString(path);
 
+    free(path);
+
     return result;
 
 }
@@ -486,6 +888,91 @@ static int py_panel_item_set_path(PyObject *self, PyObject *value, void *closure
 *  Paramètres  : self    = objet Python concerné par l'appel.                 *
 *                closure = non utilisé ici.                                   *
 *                                                                             *
+*  Description : Indique la définition d'un éventuel raccourci clavier.       *
+*                                                                             *
+*  Retour      : Description d'un raccourci ou None si aucun de défini.       *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static PyObject *py_panel_item_get_key_bindings(PyObject *self, void *closure)
+{
+    PyObject *result;                       /* Valeur à retourner          */
+    GPanelItem *item;                       /* Panneau à consulter         */
+    char *bindings;                         /* Raccourci clavier éventuel  */
+
+#define PANEL_ITEM_KEY_BINDINGS_ATTRIB PYTHON_GET_DEF_FULL          \
+(                                                                   \
+    key_bindings, py_panel_item,                                    \
+    "Shortcuts for displaying the panel, as a string, or *None* if" \
+    " no binding is defined."                                       \
+)
+
+    item = G_PANEL_ITEM(pygobject_get(self));
+    bindings = gtk_panel_item_class_get_key_bindings(G_PANEL_ITEM_GET_CLASS(item));
+
+    if (bindings != NULL)
+    {
+        result = PyUnicode_FromString(bindings);
+        free(bindings);
+    }
+    else
+    {
+        result = Py_None;
+        Py_INCREF(result);
+    }
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : self    = objet Python concerné par l'appel.                 *
+*                closure = non utilisé ici.                                   *
+*                                                                             *
+*  Description : Fournit le chemin d'accès à utiliser pour les encapsulations.*
+*                                                                             *
+*  Retour      : Chemin d'accès défini.                                       *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static PyObject *py_panel_item_get_named_widget(PyObject *self, void *closure)
+{
+    PyObject *result;                       /* Valeur à retourner          */
+    GPanelItem *item;                       /* Panneau à consulter         */
+    GNamedWidget *widget;                   /* Composant nommé à transférer*/
+
+#define PANEL_ITEM_NAMED_WIDGET_ATTRIB PYTHON_GET_DEF_FULL  \
+(                                                           \
+    named_widget, py_panel_item,                            \
+    "Named widget as core component of the panel item.\n"   \
+    "\n"                                                    \
+    "The result is an implementation of the"                \
+    " pychrysalide.glibext.NamedWidget interface."          \
+)
+
+    item = G_PANEL_ITEM(pygobject_get(self));
+    widget = gtk_panel_item_get_named_widget(item);
+
+    result = pygobject_new(G_OBJECT(widget));
+
+    g_object_unref(G_OBJECT(widget));
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : self    = objet Python concerné par l'appel.                 *
+*                closure = non utilisé ici.                                   *
+*                                                                             *
 *  Description : Indique si le composant repose sur un support de l'éditeur.  *
 *                                                                             *
 *  Retour      : True si le composant est bien incrusté quelque part.         *
@@ -503,7 +990,9 @@ static PyObject *py_panel_item_get_docked(PyObject *self, void *closure)
 #define PANEL_ITEM_DOCKED_ATTRIB PYTHON_GET_DEF_FULL    \
 (                                                       \
     docked, py_panel_item,                              \
-    "Dock status of the panel item."                    \
+    "Dock status of the panel item.\n"                  \
+    "\n"                                                \
+    "The result is a boolean value: *True* or *False*." \
 )
 
     item = G_PANEL_ITEM(pygobject_get(self));
@@ -538,9 +1027,17 @@ PyTypeObject *get_python_panel_item_type(void)
     };
 
     static PyGetSetDef py_panel_item_getseters[] = {
-        PANEL_ITEM_NAMED_WIDGET_ATTRIB,
+        PANEL_ITEM_PERSONALITY_ATTRIB_WRAPPER,
+        PANEL_ITEM_DOCK_AT_STARTUP_ATTRIB_WRAPPER,
+        PANEL_ITEM_CAN_SEARCH_ATTRIB_WRAPPER,
+        PANEL_ITEM_PATH_ATTRIB_WRAPPER,
+        PANEL_ITEM_BINDINGS_ATTRIB_WRAPPER,
         PANEL_ITEM_PERSONALITY_ATTRIB,
+        PANEL_ITEM_DOCK_AT_STARTUP_ATTRIB,
+        PANEL_ITEM_CAN_SEARCH_ATTRIB,
         PANEL_ITEM_PATH_ATTRIB,
+        PANEL_ITEM_KEY_BINDINGS_ATTRIB,
+        PANEL_ITEM_NAMED_WIDGET_ATTRIB,
         PANEL_ITEM_DOCKED_ATTRIB,
         { NULL }
     };
diff --git a/plugins/pychrysalide/helpers.c b/plugins/pychrysalide/helpers.c
index 870035d..894b600 100644
--- a/plugins/pychrysalide/helpers.c
+++ b/plugins/pychrysalide/helpers.c
@@ -1129,6 +1129,45 @@ int forward_pygobjet_init(PyObject *self)
 *  Paramètres  : arg = argument quelconque à tenter de convertir.             *
 *                dst = destination des valeurs récupérées en cas de succès.   *
 *                                                                             *
+*  Description : Tente de convertir en valeur GType.                          *
+*                                                                             *
+*  Retour      : Bilan de l'opération, voire indications supplémentaires.     *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+int convert_to_gtype(PyObject *arg, void *dst)
+{
+    int result;                             /* Bilan à retourner           */
+    GType type;                             /* Type obtenu ou 0            */
+
+    type = pyg_type_from_object(arg);
+
+    switch (type)
+    {
+        case G_TYPE_INVALID:
+            /* L'exception est déjà fixée par Python */
+            result = 0;
+            break;
+
+        default:
+            *((GType *)dst) = type;
+            result = 1;
+            break;
+
+    }
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : arg = argument quelconque à tenter de convertir.             *
+*                dst = destination des valeurs récupérées en cas de succès.   *
+*                                                                             *
 *  Description : Tente de convertir en instance GObject.                      *
 *                                                                             *
 *  Retour      : Bilan de l'opération, voire indications supplémentaires.     *
diff --git a/plugins/pychrysalide/helpers.h b/plugins/pychrysalide/helpers.h
index 428cf92..522986f 100644
--- a/plugins/pychrysalide/helpers.h
+++ b/plugins/pychrysalide/helpers.h
@@ -134,6 +134,9 @@ bool register_python_module_object(PyObject *, PyTypeObject *);
         closure                                         \
     }
 
+#define PYTHON_CAN_DEF_FULL(name, base, doc)            \
+    PYTHON_GETSET_DEF("can_" #name, base ## _can_ ## name, NULL, ATTRIB_RO doc, NULL)
+
 #define PYTHON_IS_DEF_FULL(name, base, doc)             \
     PYTHON_GETSET_DEF("is_" #name, base ## _is_ ## name, NULL, ATTRIB_RO doc, NULL)
 
@@ -223,6 +226,9 @@ bool register_class_for_dynamic_pygobject(GType, PyTypeObject *, PyTypeObject *)
 /* Fait suivre à la partie GObject une initialisation nouvelle. */
 int forward_pygobjet_init(PyObject *);
 
+/* Tente de convertir en valeur GType. */
+int convert_to_gtype(PyObject *, void *);
+
 /* Tente de convertir en instance GObject. */
 int convert_to_gobject(PyObject *, void *);
 
diff --git a/plugins/python/liveconv/panel.py b/plugins/python/liveconv/panel.py
index 6503b7b..6d308d6 100644
--- a/plugins/python/liveconv/panel.py
+++ b/plugins/python/liveconv/panel.py
@@ -13,6 +13,8 @@ class ConvPanel(PanelItem):
 
     _key = 'liveconv'
 
+    _path = 'MES'
+
 
     def __init__(self):
         """Initialize the GUI panel."""
@@ -22,17 +24,7 @@ class ConvPanel(PanelItem):
 
         widget = BuiltNamedWidget('Converter', 'Data live converter', filename)
 
-        params = {
-
-            'personality' : PanelItem.PanelItemPersonality.SINGLETON,
-            'widget' : widget,
-
-            'dock' : True,
-            'path' : 'MES'
-
-        }
-
-        super(ConvPanel, self).__init__(**params)
+        super(ConvPanel, self).__init__(widget)
 
         self._conversions = {
 
diff --git a/plugins/python/liveconv/plugin.py b/plugins/python/liveconv/plugin.py
index eadbea0..8caeb17 100644
--- a/plugins/python/liveconv/plugin.py
+++ b/plugins/python/liveconv/plugin.py
@@ -21,6 +21,4 @@ class LiveConverter(PluginModule):
 
         super(LiveConverter, self).__init__()
 
-        p = ConvPanel()
-
-        core.register_panel(p)
+        core.register_panel(ConvPanel)
diff --git a/src/core/logs.c b/src/core/logs.c
index a723cf7..2769bd5 100644
--- a/src/core/logs.c
+++ b/src/core/logs.c
@@ -29,7 +29,7 @@
 
 
 #include "../common/extstr.h"
-#include "../gui/core/panels.h"
+#include "../gui/core/items.h"
 #include "../gui/panels/log.h"
 
 
@@ -107,11 +107,11 @@ void set_log_verbosity(LogMessageType level)
 
 void log_simple_message(LogMessageType type, const char *msg)
 {
-    GPanelItem *item;                       /* Eventuel affichage présent  */
+    GEditorItem *item;                      /* Eventuel affichage présent  */
 
     if (type >= _verbosity)
     {
-        item = get_panel_item_by_name(PANEL_LOG_ID);
+        item = find_editor_item_by_type(G_TYPE_LOG_PANEL);
 
         if (item != NULL)
         {
diff --git a/src/core/params.c b/src/core/params.c
index 7e6e1ed..25f8991 100644
--- a/src/core/params.c
+++ b/src/core/params.c
@@ -116,6 +116,7 @@ bool load_main_config_parameters(void)
     g_generic_config_create_group(config, "gui.panels.positions", CPT_INTEGER);
 
     g_generic_config_create_group(config, "gui.panels.dock_at_startup", CPT_BOOLEAN);
+    g_generic_config_create_group(config, "gui.panels.path", CPT_STRING);
 
     return true;
 
diff --git a/src/glibext/configuration.c b/src/glibext/configuration.c
index 256513a..c19f7ef 100644
--- a/src/glibext/configuration.c
+++ b/src/glibext/configuration.c
@@ -1541,7 +1541,7 @@ GCfgParam *_g_generic_config_add_param(GGenConfig *config, GCfgParam *param, boo
     if (old != NULL)
     {
         g_clear_object(&param);
-	goto exit;
+        goto exit;
     }
 
     config->params = g_list_append(config->params, param);
diff --git a/src/glibext/configuration.h b/src/glibext/configuration.h
index 13bc1da..49a289b 100644
--- a/src/glibext/configuration.h
+++ b/src/glibext/configuration.h
@@ -234,6 +234,19 @@ GCfgParam *_g_generic_config_add_param(GGenConfig *, GCfgParam *, bool);
     })
 
 
+#define g_generic_config_create_param_if_not_exist(c, p, t, d)  \
+    ({                                                          \
+        GCfgParam *__result;                                    \
+        __result = g_generic_config_search(c, p);               \
+        if (__result == NULL)                                   \
+        {                                                       \
+            __result = g_config_param_new(p, t, d);             \
+            __result = g_generic_config_add_param(c, __result); \
+        }                                                       \
+        __result;                                               \
+    })
+
+
 #define g_generic_config_create_or_udpdate_param(c, p, t, d, v) \
     ({                                                          \
         GCfgParam *__param;                                     \
diff --git a/src/gtkext/tiledgrid.c b/src/gtkext/tiledgrid.c
index 5287352..22b2680 100644
--- a/src/gtkext/tiledgrid.c
+++ b/src/gtkext/tiledgrid.c
@@ -884,11 +884,11 @@ void gtk_tiled_grid_set_default_main_panel(GtkTiledGrid *tgrid, GPanelItem *pane
 
 void gtk_tiled_grid_add(GtkTiledGrid *tgrid, GPanelItem *panel)
 {
-    const char *path;                       /* Chemin d'accès              */
+    char *path;                             /* Chemin d'accès              */
     char *name;                             /* Nom à donner à l'onglet     */
     grid_tile_t *tile;                      /* Tuile d'accueil             */
 
-    path = gtk_panel_item_get_path(panel);
+    path = gtk_panel_item_class_get_path(G_PANEL_ITEM_GET_CLASS(panel));
 
     if (!is_valid_tile_path(path))
     {
@@ -904,7 +904,7 @@ void gtk_tiled_grid_add(GtkTiledGrid *tgrid, GPanelItem *panel)
 
         gtk_dock_station_add_dockable(GTK_DOCK_STATION(tile->widget), GTK_DOCKABLE(panel));
 
-        g_panel_item_set_dock_status(panel, true);
+        g_panel_item_set_dock_at_startup(panel, true);
 
         /* Si c'est la toute première fois... */
         if (gtk_widget_get_parent(tile->widget) == NULL)
@@ -931,6 +931,8 @@ void gtk_tiled_grid_add(GtkTiledGrid *tgrid, GPanelItem *panel)
 
     }
 
+    free(path);
+
 }
 
 
@@ -961,7 +963,7 @@ void gtk_tiled_grid_remove(GtkTiledGrid *tgrid, GPanelItem *panel)
 
     gtk_dock_station_remove_dockable(GTK_DOCK_STATION(station), GTK_DOCKABLE(panel));
 
-    g_panel_item_set_dock_status(panel, false);
+    g_panel_item_set_dock_at_startup(panel, false);
 
     if (gtk_notebook_get_n_pages(GTK_NOTEBOOK(station)) == 0)
     {
diff --git a/src/gui/core/core.c b/src/gui/core/core.c
index 0c1e3f3..ccad3ad 100644
--- a/src/gui/core/core.c
+++ b/src/gui/core/core.c
@@ -30,6 +30,7 @@
 #include "theme.h"
 #include "../menubar.h"
 #include "../menus/view.h"
+#include "../panels/log.h"
 #include "../panels/welcome.h"
 #include "../../core/params.h"
 #include "../../glibext/linesegment.h"
@@ -37,6 +38,11 @@
 
 
 
+/* Charge les panneaux sur la base de la configuration fournie. */
+static bool apply_panel_items_configuration(GPanelItemClass *, GGenConfig *);
+
+
+
 /******************************************************************************
 *                                                                             *
 *  Paramètres  : -                                                            *
@@ -64,7 +70,7 @@ bool load_all_gui_components(void)
      * Charge une liste initiale pour activer les raccourcis clavier.
      */
 
-    bar = G_MENU_BAR(find_editor_item_by_key("menubar"));
+    bar = G_MENU_BAR(find_editor_item_by_type(G_TYPE_MENU_BAR));
 
     builder = get_editor_builder();
 
@@ -83,6 +89,34 @@ bool load_all_gui_components(void)
 
 /******************************************************************************
 *                                                                             *
+*  Paramètres  : class  = classe de panneau enregistré comme existant.        *
+*                config = configuration à charger.                            *
+*                                                                             *
+*  Description : Charge les panneaux sur la base de la configuration fournie. *
+*                                                                             *
+*  Retour      : true, par conformité avec browse_all_item_panels().          *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static bool apply_panel_items_configuration(GPanelItemClass *class, GGenConfig *config)
+{
+    GPanelItem *panel;                      /* Panneau à mettre en place   */
+
+    if (gtk_panel_item_class_dock_at_startup(class))
+    {
+        panel = g_panel_item_new(G_TYPE_FROM_CLASS(class), "");
+        g_object_unref(G_OBJECT(panel));
+    }
+
+    return true;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
 *  Paramètres  : config = configuration globale à utiliser.                   *
 *                                                                             *
 *  Description : Finalise le chargement des éléments graphiques de l'éditeur. *
@@ -111,7 +145,7 @@ bool complete_loading_of_all_gui_components(GGenConfig *config)
 
     grid = get_tiled_grid();
 
-    welcome = get_panel_item_by_name(PANEL_WELCOME_ID);
+    welcome = g_panel_item_new(G_TYPE_WELCOME_PANEL, NULL);
     gtk_tiled_grid_set_default_main_panel(grid, welcome);
     g_object_unref(G_OBJECT(welcome));
 
@@ -127,7 +161,7 @@ bool complete_loading_of_all_gui_components(GGenConfig *config)
      */
 
     if (result)
-        result = _browse_all_item_panels(true, (handle_panel_item_fc)gtk_panel_item_apply_configuration, config);
+        result = _browse_all_item_panels(true, (handle_panel_item_fc)apply_panel_items_configuration, config);
 
     /**
      * Comme la boucle de traitements GTK n'est pas encore lancée, tous les
diff --git a/src/gui/core/items.c b/src/gui/core/items.c
index 9c82100..6c57b7b 100644
--- a/src/gui/core/items.c
+++ b/src/gui/core/items.c
@@ -24,6 +24,7 @@
 #include "items.h"
 
 
+#include <assert.h>
 #include <malloc.h>
 #include <string.h>
 
@@ -33,7 +34,7 @@
 
 
 
-/* Liste des éléments enregistrés */
+/* Liste des éléments en place */
 static GEditorItem **_item_list = NULL;
 static size_t _item_count = 0;
 
@@ -52,7 +53,7 @@ static void track_cursor_on_view_panel(GLoadedPanel *, const GLineCursor *, gpoi
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : -                                                            *
+*  Paramètres  : item = élément de l'interface graphique à intégrer.          *
 *                                                                             *
 *  Description : Procède à l'enregistrement d'un élément reactif de l'éditeur.*
 *                                                                             *
@@ -75,9 +76,9 @@ void register_editor_item(GEditorItem *item)
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : target = désignation de l'élément réactif à retrouver.       *
+*  Paramètres  : target = type de l'élément réactif à retrouver.              *
 *                                                                             *
-*  Description : Retrouve un élément reactif de l'éditeur par son nom clef.   *
+*  Description : Retrouve un élément reactif de l'éditeur par son type.       *
 *                                                                             *
 *  Retour      : Elément retrouvé ou NULL.                                    *
 *                                                                             *
@@ -85,26 +86,24 @@ void register_editor_item(GEditorItem *item)
 *                                                                             *
 ******************************************************************************/
 
-GEditorItem *find_editor_item_by_key(const char *target)
+GEditorItem *find_editor_item_by_type(GType target)
 {
     GEditorItem *result;                    /* Elément à retourner         */
     size_t i;                               /* Boucle de parcours          */
-    char *key;                              /* Nom d'un élément à analyser */
+    GType type;                             /* Type d'un élément analysé   */
 
     result = NULL;
 
     for (i = 0; i < _item_count && result == NULL; i++)
     {
-        key = g_editor_item_get_key(_item_list[i]);
+        type = G_TYPE_FROM_INSTANCE(_item_list[i]);
 
-        if (strcmp(key, target) == 0)
+        if (type == target)
         {
             result = _item_list[i];
             g_object_ref(G_OBJECT(result));
         }
 
-        free(key);
-
     }
 
     return result;
@@ -114,6 +113,37 @@ GEditorItem *find_editor_item_by_key(const char *target)
 
 /******************************************************************************
 *                                                                             *
+*  Paramètres  : item = élément de l'interface graphique à oublier.           *
+*                                                                             *
+*  Description : Retire un des éléments reactifs de l'éditeur.                *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+void unregister_editor_item(GEditorItem *item)
+{
+    size_t i;                               /* Boucle de parcours          */
+
+    for (i = 0; i < _item_count; i++)
+        if (_item_list[i] == item)
+            break;
+
+    assert(i < _item_count);
+
+    g_object_unref(G_OBJECT(item));
+
+    memmove(&_item_list[i], &_item_list[i + 1], (_item_count - i - 1) * sizeof(GEditorItem *));
+
+    _item_list = realloc(_item_list, --_item_count * sizeof(GEditorItem *));
+
+}
+
+
+/******************************************************************************
+*                                                                             *
 *  Paramètres  : content = nouvelle instance de contenu analysé.              *
 *                                                                             *
 *  Description : Lance une actualisation du fait d'un changement de contenu.  *
diff --git a/src/gui/core/items.h b/src/gui/core/items.h
index 7509b3b..39d6991 100644
--- a/src/gui/core/items.h
+++ b/src/gui/core/items.h
@@ -34,8 +34,11 @@
 /* Procède à l'enregistrement d'un élément reactif de l'éditeur. */
 void register_editor_item(GEditorItem *);
 
-/* Retrouve un élément reactif de l'éditeur par son nom clef. */
-GEditorItem *find_editor_item_by_key(const char *);
+/* Retrouve un élément reactif de l'éditeur par son type. */
+GEditorItem *find_editor_item_by_type(GType);
+
+/* Retire un des éléments reactifs de l'éditeur. */
+void unregister_editor_item(GEditorItem *);
 
 /* Lance une actualisation du fait d'un changement de contenu. */
 void change_editor_items_current_content(GLoadedContent *);
diff --git a/src/gui/core/panels.c b/src/gui/core/panels.c
index 8505f37..1b6f604 100644
--- a/src/gui/core/panels.c
+++ b/src/gui/core/panels.c
@@ -25,10 +25,10 @@
 #include "panels.h"
 
 
+#include <assert.h>
 #include <malloc.h>
 
 
-#include "global.h"
 #include "items.h"
 #include "../panel-int.h"
 #include "../panels/bintree.h"
@@ -42,12 +42,12 @@
 #include "../panels/symbols.h"
 #include "../panels/welcome.h"
 #include "../../core/params.h"
-#include "../../gtkext/gtkdockable.h"
 
 
 
-/* Liste des panneaux en place. */
-static GPanelItem *_panels_list = NULL;
+/* Liste des panneaux disponibles */
+static GType *_panels_list = NULL;
+static size_t _panels_count = 0;
 
 
 
@@ -66,46 +66,32 @@ static GPanelItem *_panels_list = NULL;
 void load_main_panels(void)
 {
     GGenConfig *config;                     /* Configuration globale       */
-    GPanelItem *item;                       /* Panneau de base à charger   */
+    GPanelItem *panel;                      /* Panneau à précharger        */
 
     config = get_main_configuration();
 
-    item = g_welcome_panel_new();
-    register_panel_item(item, config);
+    register_panel_item(G_TYPE_LOG_PANEL, config);
 
-    item = g_log_panel_new();
-    register_panel_item(item, config);
+    /* Chargement du panneau de rapport au plus tôt */
+    panel = g_panel_item_new(G_TYPE_LOG_PANEL, NULL);
+    g_object_unref(G_OBJECT(panel));
 
-    item = g_regedit_panel_new();
-    register_panel_item(item, config);
-
-    item = g_symbols_panel_new();
-    register_panel_item(item, config);
-
-    item = g_history_panel_new();
-    register_panel_item(item, config);
-
-    item = g_strings_panel_new();
-    register_panel_item(item, config);
-
-    item = g_glance_panel_new();
-    register_panel_item(item, config);
-
-    item = g_bookmarks_panel_new();
-    register_panel_item(item, config);
-
-    item = g_bintree_panel_new();
-    register_panel_item(item, config);
-
-    item = g_error_panel_new();
-    register_panel_item(item, config);
+    register_panel_item(G_TYPE_WELCOME_PANEL, config);
+    register_panel_item(G_TYPE_REGEDIT_PANEL, config);
+    register_panel_item(G_TYPE_SYMBOLS_PANEL, config);
+    register_panel_item(G_TYPE_HISTORY_PANEL, config);
+    register_panel_item(G_TYPE_STRINGS_PANEL, config);
+    register_panel_item(G_TYPE_GLANCE_PANEL, config);
+    register_panel_item(G_TYPE_BOOKMARKS_PANEL, config);
+    register_panel_item(G_TYPE_BINTREE_PANEL, config);
+    register_panel_item(G_TYPE_ERROR_PANEL, config);
 
 }
 
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : item   = composant à présenter à l'affichage.                *
+*  Paramètres  : type   = type du composant à présenter à l'affichage.        *
 *                config = configuration à compléter.                          *
 *                                                                             *
 *  Description : Enregistre un panneau comme partie intégrante de l'éditeur.  *
@@ -116,46 +102,27 @@ void load_main_panels(void)
 *                                                                             *
 ******************************************************************************/
 
-void register_panel_item(GPanelItem *item, GGenConfig *config)
+void register_panel_item(GType type, GGenConfig *config)
 {
-    GEditorItem *parent;                    /* Autre version de l'élément  */
+    GPanelItemClass *class;                 /* Classe associée au type     */
+#ifndef NDEBUG
+    bool status;                            /* Bilan de mise en place      */
+#endif
 
-    parent = G_EDITOR_ITEM(item);
+    _panels_list = realloc(_panels_list, ++_panels_count * sizeof(GType));
 
-    /* Enregistre correctement le tout */
-    register_editor_item(parent);
-    panels_list_add_tail(item, &_panels_list);
+    _panels_list[_panels_count - 1] = type;
 
-    activate_panel_item(item, config);
+    class = g_type_class_ref(type);
 
-}
+#ifndef NDEBUG
+    status = gtk_panel_item_class_setup_configuration(class, config);
+    assert(status);
+#else
+    gtk_panel_item_class_setup_configuration(class, config);
+#endif
 
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : item   = composant à présenter à l'affichage.                *
-*                config = configuration à compléter.                          *
-*                                                                             *
-*  Description : Intègre un panneau comme partie intégrante de l'éditeur.     *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-void activate_panel_item(GPanelItem *item, GGenConfig *config)
-{
-    GtkTiledGrid *grid;                     /* Composant d'affichage       */
-
-    grid = get_tiled_grid();
-
-    g_signal_connect_swapped(item, "dock-request", G_CALLBACK(gtk_tiled_grid_add), grid);
-    g_signal_connect_swapped(item, "undock-request", G_CALLBACK(gtk_tiled_grid_remove), grid);
-
-    gtk_dockable_setup_dnd(GTK_DOCKABLE(item));
-
-    gtk_panel_item_setup_configuration(item, config);
+    g_type_class_unref(class);
 
 }
 
@@ -177,79 +144,29 @@ void activate_panel_item(GPanelItem *item, GGenConfig *config)
 bool _browse_all_item_panels(bool skip, handle_panel_item_fc handle, void *data)
 {
     bool result;                            /* Résultat à renvoyer         */
-    GPanelItem *welcome;                    /* Panneau d'accueil           */
-    GPanelItem *iter;                       /* Boucle de parcours          */
+    GType type;                             /* Type de panneau à traiter   */
+    size_t i;                               /* Boucle de parcours          */
+    GPanelItemClass *class;                 /* Classe associée au type     */
 
     result = true;
 
-    if (skip)
-        welcome = get_panel_item_by_name(PANEL_WELCOME_ID);
-    else
-        welcome = NULL;
-
-    panels_list_for_each(iter, _panels_list)
+    for (i = 0; i < _panels_count; i++)
     {
-        if (skip && iter == welcome)
-            continue;
+        type = _panels_list[i];
 
-        result = handle(iter, data);
-
-        if (!result) break;
-
-    }
-
-    g_clear_object(&welcome);
-
-    return result;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : name = désignation courte servant de clef.                   *
-*                                                                             *
-*  Description : Recherche un panneau à partir de son nom court.              *
-*                                                                             *
-*  Retour      : Panneau trouvé ou NULL si aucun.                             *
-*                                                                             *
-*  Remarques   : Le parcours peut se faire aussi depuis la classe parente,    *
-*                mais il est plus rapide par ici.                             *
-*                                                                             *
-******************************************************************************/
-
-GPanelItem *get_panel_item_by_name(const char *name)
-{
-    GPanelItem *result;                     /* Trouvaille à retourner      */
-
-    bool look_for_named_panel(GPanelItem *item, GPanelItem **found)
-    {
-        char *key;                          /* Clef à utiliser             */
-        bool status;                        /* Bilan de la comparaison     */
+        if (skip && type == G_TYPE_WELCOME_PANEL)
+            continue;
 
-        key = g_editor_item_get_key(G_EDITOR_ITEM(item));
+        class = g_type_class_ref(type);
 
-        if (strcmp(key, name) == 0)
-        {
-            *found = item;
-            status = false;
-        }
-        else
-            status = true;
+        result = handle(class, data);
 
-        free(key);
+        g_type_class_unref(class);
 
-        return status;
+        if (!result) break;
 
     }
 
-    result = NULL;
-
-    browse_all_item_panels((handle_panel_item_fc)look_for_named_panel, &result);
-
-    if (result != NULL)
-        g_object_ref(G_OBJECT(result));
-
     return result;
 
 }
diff --git a/src/gui/core/panels.h b/src/gui/core/panels.h
index 40c2fbd..3846038 100644
--- a/src/gui/core/panels.h
+++ b/src/gui/core/panels.h
@@ -38,13 +38,10 @@
 void load_main_panels(void);
 
 /* Enregistre un panneau comme partie intégrante de l'éditeur. */
-void register_panel_item(GPanelItem *, GGenConfig *);
-
-/* Intègre un panneau comme partie intégrante de l'éditeur. */
-void activate_panel_item(GPanelItem *, GGenConfig *);
+void register_panel_item(GType, GGenConfig *);
 
 /* Réalise un traitement sur un panneau de l'éditeur. */
-typedef bool (* handle_panel_item_fc) (GPanelItem *, void *);
+typedef bool (* handle_panel_item_fc) (GPanelItemClass *, void *);
 
 /* Effectue le parcours de tous les panneaux chargés. */
 bool _browse_all_item_panels(bool, handle_panel_item_fc, void *);
@@ -52,9 +49,6 @@ bool _browse_all_item_panels(bool, handle_panel_item_fc, void *);
 #define browse_all_item_panels(h, d) \
     _browse_all_item_panels(false, h, d)
 
-/* Recherche un panneau à partir de son nom court. */
-GPanelItem *get_panel_item_by_name(const char *);
-
 
 
 #endif  /* _GUI_CORE_PANELS_H */
diff --git a/src/gui/editor.c b/src/gui/editor.c
index 6e98423..1665ff4 100644
--- a/src/gui/editor.c
+++ b/src/gui/editor.c
@@ -43,6 +43,7 @@
 #include "core/panels.h"
 #include "core/global.h"
 #include "core/items.h"
+#include "panels/view.h"
 #include "tb/portions.h"
 #include "../common/extstr.h"
 #include "../core/global.h"
@@ -117,10 +118,10 @@ static void on_dock_station_created(GtkTiledGrid *, GtkDockStation *, gpointer);
 static void on_dock_item_switch(GtkDockStation *, GtkWidget *, gpointer);
 
 /* Encastre comme demandé un panneau dans l'éditeur. */
-static void dock_panel_into_current_station(GtkCheckMenuItem *, GPanelItem *);
+static void dock_panel_into_current_station(GtkCheckMenuItem *, gpointer);
 
 /* Ajout d'un panneau dans la liste adaptée des menus. */
-static bool add_side_panel_to_menu(GPanelItem *, GtkContainer *);
+static bool add_side_panel_to_menu(GPanelItemClass *, GtkContainer *);
 
 /* Réagit à une demande de menu pour rajouter des panneaux. */
 static void on_dock_menu_request(GtkDockStation *, GtkWidget *, gpointer);
@@ -361,7 +362,7 @@ static void connect_all_editor_signals(GtkBuilder *builder, GObject *obj, const
     {
         if (strncmp(hdl_name, "mcb_", 4) == 0)
         {
-            bar = G_MENU_BAR(find_editor_item_by_key("menubar"));
+            bar = G_MENU_BAR(find_editor_item_by_type(G_TYPE_MENU_BAR));
             arg = bar;
             g_object_unref(G_OBJECT(bar));
         }
@@ -739,7 +740,7 @@ static void on_dock_item_switch(GtkDockStation *station, GtkWidget *widget, gpoi
 /******************************************************************************
 *                                                                             *
 *  Paramètres  : menuitem = élement de menu actionné.                         *
-*                item     = panneau à ajouter à l'interface graphique.        *
+*                type_ptr = type de panneau à mettre en place.                *
 *                                                                             *
 *  Description : Encastre comme demandé un panneau dans l'éditeur.            *
 *                                                                             *
@@ -749,18 +750,21 @@ static void on_dock_item_switch(GtkDockStation *station, GtkWidget *widget, gpoi
 *                                                                             *
 ******************************************************************************/
 
-static void dock_panel_into_current_station(GtkCheckMenuItem *menuitem, GPanelItem *item)
+static void dock_panel_into_current_station(GtkCheckMenuItem *menuitem, gpointer type_ptr)
 {
+    GType type;                             /* Type de panneau considérée  */
     GtkWidget *parent;                      /* Menu parent avec chemin     */
     const char *new_path;                   /* Nouveau chemin à appliquer  */
+    GPanelItem *panel;                      /* Panneau à mettre en place   */
+
+    type = GPOINTER_TO_SIZE(type_ptr);
 
     parent = gtk_widget_get_parent(GTK_WIDGET(menuitem));
 
     new_path = g_object_get_data(G_OBJECT(parent), "path");
 
-    gtk_panel_item_set_path(item, new_path);
-
-    g_panel_item_dock(item);
+    panel = g_panel_item_new(type, new_path);
+    g_object_unref(G_OBJECT(panel));
 
 }
 
@@ -773,47 +777,63 @@ static void dock_panel_into_current_station(GtkCheckMenuItem *menuitem, GPanelIt
 *                                                                             *
 *  Description : Ajout d'un panneau dans la liste adaptée des menus.          *
 *                                                                             *
-*  Retour      : -                                                            *
+*  Retour      : true, par conformité avec browse_all_item_panels().          *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-static bool add_side_panel_to_menu(GPanelItem *panel, GtkContainer *support)
+static bool add_side_panel_to_menu(GPanelItemClass *class, GtkContainer *support)
 {
+    GEditorItem *item;                      /* Instance de panneau en place*/
+    gpointer type_ptr;                      /* Type de panneau traité      */
     char *key;                              /* Désignation de l'entrée     */
     GtkWidget *submenuitem;                 /* Sous-élément de menu        */
-    const char *bindings;                   /* Raccourcis clavier bruts    */
+    char *bindings;                         /* Raccourcis clavier bruts    */
     GtkBuilder *builder;                    /* Constructeur principal      */
 
     /* Profil qui ne cadre pas ? */
 
-    if (gtk_panel_item_get_personality(panel) != PIP_SINGLETON)
+    if (gtk_panel_item_class_get_personality(class) != PIP_SINGLETON)
         goto exit;
 
-    if (g_panel_item_is_docked(panel))
-        goto exit;
+    item = find_editor_item_by_type(G_TYPE_FROM_CLASS(class));
+
+    if (item != NULL)
+    {
+        if (g_panel_item_is_docked(G_PANEL_ITEM(item)))
+            goto exit_ref;
+    }
 
     /* Elément de menu */
 
-    key = g_editor_item_get_key(G_EDITOR_ITEM(panel));
+    type_ptr = GSIZE_TO_POINTER(G_TYPE_FROM_CLASS(class));
+
+    key = g_editor_item_class_get_key(G_EDITOR_ITEM_CLASS(class));
 
     submenuitem = qck_create_menu_item(NULL, NULL, key,
-                                       G_CALLBACK(dock_panel_into_current_station), panel);
+                                       G_CALLBACK(dock_panel_into_current_station), type_ptr);
 
     free(key);
 
-    bindings = gtk_panel_item_get_key_bindings(panel);
+    bindings = gtk_panel_item_class_get_key_bindings(class);
 
     if (bindings != NULL)
     {
         builder = get_editor_builder();
         add_accelerator_to_widget(builder, submenuitem, bindings);
         g_object_unref(G_OBJECT(builder));
+
+        free(bindings);
+
     }
 
     gtk_container_add(support, submenuitem);
 
+ exit_ref:
+
+    g_object_unref(G_OBJECT(item));
+
  exit:
 
     return true;
@@ -838,7 +858,7 @@ static bool add_side_panel_to_menu(GPanelItem *panel, GtkContainer *support)
 static void on_dock_menu_request(GtkDockStation *station, GtkWidget *button, gpointer unused)
 {
     GtkWidget *active;                      /* Composant actif modèle      */
-    GPanelItem *model;                      /* Panneau encapsulé           */
+    GPanelItemClass *model;                 /* Panneau encapsulé           */
     GtkContainer *menu;                     /* Support à retourner         */
     GList *children;                        /* Composants mis en place     */
     GtkWidget *nopanel;                     /* Sous-élément de menu        */
@@ -847,9 +867,9 @@ static void on_dock_menu_request(GtkDockStation *station, GtkWidget *button, gpo
 
     active = gtk_notebook_get_nth_page(GTK_NOTEBOOK(station), 0);
 
-    model = G_PANEL_ITEM(g_object_get_data(G_OBJECT(active), "dockable"));
+    model = G_PANEL_ITEM_GET_CLASS(g_object_get_data(G_OBJECT(active), "dockable"));
 
-    g_object_set_data_full(G_OBJECT(menu), "path", strdup(gtk_panel_item_get_path(model)), free);
+    g_object_set_data_full(G_OBJECT(menu), "path", gtk_panel_item_class_get_path(model), free);
 
     /* Ajout des panneaux uniques */
 
@@ -1012,9 +1032,9 @@ static void on_editor_loaded_content_added(GStudyProject *project, GLoadedConten
     GPanelItem *panel;                      /* Nouveau panneau à integrer  */
     GtkWidget *selected;                    /* Interface de prédilection   */
 
-    panel = g_panel_item_new(PIP_BINARY_VIEW, G_NAMED_WIDGET(content), true, "M");
+    panel = g_view_panel_new(G_NAMED_WIDGET(content));
 
-    register_panel_item(panel, get_main_configuration());
+    register_panel_item(G_TYPE_VIEW_PANEL, get_main_configuration());
 
     selected = g_editor_item_get_widget(G_EDITOR_ITEM(panel));
 
@@ -1111,7 +1131,7 @@ static void remove_loaded_content_from_editor(GtkWidget *widget, GLoadedContent
 
             panel = G_PANEL_ITEM(g_object_get_data(G_OBJECT(tab), "dockable"));
 
-            if (gtk_panel_item_get_personality(panel) != PIP_BINARY_VIEW)
+            if (gtk_panel_item_class_get_personality(G_PANEL_ITEM_GET_CLASS(panel)) != PIP_BINARY_VIEW)
                 continue;
 
             built = get_loaded_panel_from_built_view(tab);
diff --git a/src/gui/item-int.h b/src/gui/item-int.h
index a2a6a65..cce5574 100644
--- a/src/gui/item-int.h
+++ b/src/gui/item-int.h
@@ -34,7 +34,7 @@
 
 
 /* Fournit le nom interne attribué à l'élément réactif. */
-typedef char * (* get_item_key_fc) (const GEditorItem *);
+typedef char * (* get_item_key_fc) (const GEditorItemClass *);
 
 /* Fournit le composant GTK associé à l'élément réactif. */
 typedef GtkWidget * (* get_item_widget_fc)  (const GEditorItem *);
diff --git a/src/gui/item.c b/src/gui/item.c
index 47504d1..73d3ba7 100644
--- a/src/gui/item.c
+++ b/src/gui/item.c
@@ -81,7 +81,7 @@ static void g_editor_item_init(GEditorItem *item)
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : item = instance à consulter.                                 *
+*  Paramètres  : class = classe à consulter.                                  *
 *                                                                             *
 *  Description : Fournit le nom interne attribué à l'élément réactif.         *
 *                                                                             *
@@ -91,16 +91,13 @@ static void g_editor_item_init(GEditorItem *item)
 *                                                                             *
 ******************************************************************************/
 
-char *g_editor_item_get_key(const GEditorItem *item)
+char *g_editor_item_class_get_key(const GEditorItemClass *class)
 {
     char *result;                           /* Description à renvoyer      */
-    GEditorItemClass *klass;                /* Classe correspondante       */
-
-    klass = G_EDITOR_ITEM_GET_CLASS(item);
 
-    assert(klass->get_key != NULL);
+    assert(class->get_key != NULL);
 
-    result = klass->get_key(item);
+    result = class->get_key(class);
 
     return result;
 
diff --git a/src/gui/item.h b/src/gui/item.h
index 81d5b20..dadad50 100644
--- a/src/gui/item.h
+++ b/src/gui/item.h
@@ -55,7 +55,7 @@ typedef struct _GEditorItemClass GEditorItemClass;
 GType g_editor_item_get_type(void);
 
 /* Fournit le nom interne attribué à l'élément réactif. */
-char *g_editor_item_get_key(const GEditorItem *);
+char *g_editor_item_class_get_key(const GEditorItemClass *);
 
 /* Fournit le composant GTK associé à l'élément réactif. */
 GtkWidget *g_editor_item_get_widget(const GEditorItem *);
diff --git a/src/gui/menubar.c b/src/gui/menubar.c
index 5630194..7526a50 100644
--- a/src/gui/menubar.c
+++ b/src/gui/menubar.c
@@ -72,7 +72,7 @@ static void g_menu_bar_dispose(GMenuBar *);
 static void g_menu_bar_finalize(GMenuBar *);
 
 /* Fournit le nom humain attribué à l'élément réactif. */
-static char *g_menu_bar_get_key(const GMenuBar *);
+static char *g_menu_bar_class_get_key(const GMenuBarClass *);
 
 /* Fournit le composant GTK associé à l'élément réactif. */
 static GtkWidget *g_menu_bar_get_widget(GMenuBar *);
@@ -119,7 +119,7 @@ static void g_menu_bar_class_init(GMenuBarClass *klass)
 
     item = G_EDITOR_ITEM_CLASS(klass);
 
-    item->get_key = (get_item_key_fc)g_menu_bar_get_key;
+    item->get_key = (get_item_key_fc)g_menu_bar_class_get_key;
     item->get_widget = (get_item_widget_fc)g_menu_bar_get_widget;
 
     item->change_content = (change_item_content_fc)change_menubar_current_content;
@@ -226,7 +226,7 @@ GEditorItem *g_menu_bar_new(GtkBuilder *builder)
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : bar = instance à consulter.                                  *
+*  Paramètres  : class = classe à consulter.                                  *
 *                                                                             *
 *  Description : Fournit le nom humain attribué à l'élément réactif.          *
 *                                                                             *
@@ -236,7 +236,7 @@ GEditorItem *g_menu_bar_new(GtkBuilder *builder)
 *                                                                             *
 ******************************************************************************/
 
-static char *g_menu_bar_get_key(const GMenuBar *bar)
+static char *g_menu_bar_class_get_key(const GMenuBarClass *class)
 {
     char *result;                           /* Description à renvoyer      */
 
diff --git a/src/gui/menus/view.c b/src/gui/menus/view.c
index d41df92..37db20a 100644
--- a/src/gui/menus/view.c
+++ b/src/gui/menus/view.c
@@ -45,8 +45,25 @@
 
 
 
+/* Retire un sous-menu d'un menu. */
+static void remove_panel_menu_item(GtkWidget *, GtkContainer *);
+
+/* Filtre pour parcours de panneaux */
+typedef struct _panels_loading_filter
+{
+    GMenuBar *bar;                          /* Barre de menus principale   */
+    GtkContainer *support;                  /* Support pour éléments       */
+
+    PanelItemPersonality personality;       /* Nature des éléments attendus*/
+    bool first;                             /* Premier ajout ?             */
+
+} panels_loading_filter;
+
+/* Ajoute un panneau à la liste des panneaux existants. */
+static bool add_side_panel_to_list(GPanelItemClass *, panels_loading_filter *);
+
 /* Réagit avec le menu "Affichage -> Panneaux latéraux -> ...". */
-static void mcb_view_change_panel_docking(GtkCheckMenuItem *, GPanelItem *);
+static void mcb_view_change_panel_docking(GtkCheckMenuItem *, gpointer);
 
 /* Réagit avec le menu "Affichage -> Vue xxx". */
 static void mcb_view_change_support(GtkRadioMenuItem *, gpointer);
@@ -123,10 +140,10 @@ void setup_menu_view_callbacks(GtkBuilder *builder)
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : menuitem = élément de menu sélectionné.                      *
-*                bar      = barre de menu parente.                            *
+*  Paramètres  : widget    = composant graphique à retirer de l'affichage.    *
+*                container = conteneur graphique à vider.                     *
 *                                                                             *
-*  Description : Réagit avec le menu "Affichage -> Panneaux latéraux".        *
+*  Description : Retire un sous-menu d'un menu.                               *
 *                                                                             *
 *  Retour      : -                                                            *
 *                                                                             *
@@ -134,101 +151,140 @@ void setup_menu_view_callbacks(GtkBuilder *builder)
 *                                                                             *
 ******************************************************************************/
 
-void mcb_view_update_side_panels_list(GtkMenuItem *menuitem, GMenuBar *bar)
+static void remove_panel_menu_item(GtkWidget *widget, GtkContainer *container)
 {
-    GtkWidget *menu;                        /* Support pour éléments       */
-    GtkBuilder *builder;                    /* Constructeur principal      */
+    gtk_container_remove(container, widget);
 
-    typedef struct _panels_loading_filter
-    {
-        GtkContainer *support;              /* Support pour éléments       */
+}
 
-        PanelItemPersonality personality;   /* Nature des éléments attendus*/
-        bool first;                         /* Premier ajout ?             */
 
-    } panels_loading_filter;
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : class  = classe de panneau à traiter.                        *
+*                filter = filtre pour le parcours de l'ensemble des panneaux. *
+*                                                                             *
+*  Description : Ajoute un panneau à la liste des panneaux existants.         *
+*                                                                             *
+*  Retour      : true, par conformité avec browse_all_item_panels().          *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
 
-    panels_loading_filter pfilter;          /* Mécanismes de filtrage      */
+static bool add_side_panel_to_list(GPanelItemClass *class, panels_loading_filter *filter)
+{
+    gpointer type_ptr;                      /* Type de panneau traité      */
+    char *key;                              /* Désignation de l'entrée     */
+    GtkWidget *submenuitem;                 /* Sous-élément de menu        */
+    char *bindings;                         /* Raccourcis clavier bruts    */
+    GtkBuilder *builder;                    /* Constructeur principal      */
+    GEditorItem *item;                      /* Instance de panneau en place*/
 
-    menu = gtk_menu_item_get_submenu(menuitem);
+    if (gtk_panel_item_class_get_personality(class) != filter->personality)
+        goto exit;
 
-    /* Réinitialisation */
+    /* Séparation */
 
-    void remove_panel_menu_item(GtkWidget *widget, GtkContainer *container)
+    if (filter->first)
     {
-        gtk_container_remove(container, widget);
+        filter->first = false;
 
-    }
+        submenuitem = qck_create_menu_separator();
+        gtk_container_add(filter->support, submenuitem);
 
-    gtk_container_foreach(GTK_CONTAINER(menu), (GtkCallback)remove_panel_menu_item, menu);
+    }
 
-    /* Ajout des panneaux uniques */
+    /* Elément de menu */
 
-    bool add_side_panel_to_list(GPanelItem *panel, panels_loading_filter *filter)
-    {
-        char *key;                          /* Désignation de l'entrée     */
-        GtkWidget *submenuitem;             /* Sous-élément de menu        */
-        const char *bindings;               /* Raccourcis clavier bruts    */
+    type_ptr = GSIZE_TO_POINTER(G_TYPE_FROM_CLASS(class));
 
-        if (gtk_panel_item_get_personality(panel) != filter->personality)
-            goto aptl_exit;
+    key = g_editor_item_class_get_key(G_EDITOR_ITEM_CLASS(class));
 
-        /* Séparation */
+    submenuitem = qck_create_check_menu_item(NULL, NULL, key,
+                                             G_CALLBACK(mcb_view_change_panel_docking), type_ptr);
 
-        if (filter->first)
-        {
-            filter->first = false;
+    free(key);
 
-            submenuitem = qck_create_menu_separator();
-            gtk_container_add(GTK_CONTAINER(menu), submenuitem);
+    bindings = gtk_panel_item_class_get_key_bindings(class);
 
-        }
+    if (bindings != NULL)
+    {
+        builder = g_menu_bar_get_builder(filter->bar);
+        add_accelerator_to_widget(builder, submenuitem, bindings);
+        g_object_unref(G_OBJECT(builder));
 
-        /* Elément de menu */
+        free(bindings);
 
-        key = g_editor_item_get_key(G_EDITOR_ITEM(panel));
+    }
 
-        submenuitem = qck_create_check_menu_item(NULL, NULL, key,
-                                                 G_CALLBACK(mcb_view_change_panel_docking), panel);
+    gtk_container_add(filter->support, submenuitem);
 
-        free(key);
+    /* Statut de la coche */
 
-        bindings = gtk_panel_item_get_key_bindings(panel);
+    item = find_editor_item_by_type(G_TYPE_FROM_CLASS(class));
 
-        if (bindings != NULL)
+    if (item != NULL)
+    {
+        if (g_panel_item_is_docked(G_PANEL_ITEM(item)))
         {
-            builder = g_menu_bar_get_builder(bar);
-            add_accelerator_to_widget(builder, submenuitem, bindings);
-            g_object_unref(G_OBJECT(builder));
+            g_signal_handlers_disconnect_by_func(submenuitem, G_CALLBACK(mcb_view_change_panel_docking), type_ptr);
+
+            gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(submenuitem), TRUE);
+
+            g_signal_connect(submenuitem, "toggled", G_CALLBACK(mcb_view_change_panel_docking), type_ptr);
+
         }
 
-        gtk_container_add(filter->support, submenuitem);
+        g_object_unref(G_OBJECT(item));
 
-        /* Statut de la coche */
+    }
 
-        if (g_panel_item_is_docked(panel))
-        {
-            g_signal_handlers_disconnect_by_func(submenuitem, G_CALLBACK(mcb_view_change_panel_docking), panel);
+ exit:
 
-            gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(submenuitem), TRUE);
+    return true;
 
-            g_signal_connect(submenuitem, "toggled", G_CALLBACK(mcb_view_change_panel_docking), panel);
+}
 
-        }
 
-     aptl_exit:
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : menuitem = élément de menu sélectionné.                      *
+*                bar      = barre de menu parente.                            *
+*                                                                             *
+*  Description : Réagit avec le menu "Affichage -> Panneaux latéraux".        *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+void mcb_view_update_side_panels_list(GtkMenuItem *menuitem, GMenuBar *bar)
+{
+    GtkWidget *menu;                        /* Support pour éléments       */
+    panels_loading_filter pfilter;          /* Mécanismes de filtrage      */
+
+    menu = gtk_menu_item_get_submenu(menuitem);
 
-        return true;
+    /* Réinitialisation */
 
-    }
+    gtk_container_foreach(GTK_CONTAINER(menu), (GtkCallback)remove_panel_menu_item, menu);
+
+    /* Ajout des panneaux uniques */
 
+    pfilter.bar = bar;
     pfilter.support = GTK_CONTAINER(menu);
 
-    pfilter.personality = PIP_SINGLETON;
+    pfilter.personality = PIP_PERSISTENT_SINGLETON;
     pfilter.first = false;
 
     browse_all_item_panels((handle_panel_item_fc)add_side_panel_to_list, &pfilter);
 
+    pfilter.personality = PIP_SINGLETON;
+    pfilter.first = true;
+
+    browse_all_item_panels((handle_panel_item_fc)add_side_panel_to_list, &pfilter);
+
     pfilter.personality = PIP_OTHER;
     pfilter.first = true;
 
@@ -240,7 +296,7 @@ void mcb_view_update_side_panels_list(GtkMenuItem *menuitem, GMenuBar *bar)
 /******************************************************************************
 *                                                                             *
 *  Paramètres  : menuitem = élément de menu ayant basculé.                    *
-*                bar      = barre de menu parente.                            *
+*                type_ptr = type de panneau à mettre en place.                *
 *                                                                             *
 *  Description : Réagit avec le menu "Affichage -> Panneaux latéraux -> ...". *
 *                                                                             *
@@ -250,9 +306,11 @@ void mcb_view_update_side_panels_list(GtkMenuItem *menuitem, GMenuBar *bar)
 *                                                                             *
 ******************************************************************************/
 
-static void mcb_view_change_panel_docking(GtkCheckMenuItem *menuitem, GPanelItem *item)
+static void mcb_view_change_panel_docking(GtkCheckMenuItem *menuitem, gpointer type_ptr)
 {
-    gboolean active;                        /* Etat de sélection du menu   */
+    GType type;                             /* Type de panneau considérée  */
+    GEditorItem *item;                      /* Instance de panneau en place*/
+    GPanelItem *panel;                      /* Instance de panneau créée   */
 
     /**
      * Comme l'accrochage et le décrochage d'un panneau peuvent se réaliser
@@ -268,12 +326,28 @@ static void mcb_view_change_panel_docking(GtkCheckMenuItem *menuitem, GPanelItem
      * On préfèrera donc se baser sur l'état courant du panneau.
      */
 
-    active = !g_panel_item_is_docked(item);
+    type = GPOINTER_TO_SIZE(type_ptr);
+
+    item = find_editor_item_by_type(type);
+
+    if (item == NULL)
+    {
+        panel = g_panel_item_new(type, "");
+        g_object_unref(G_OBJECT(panel));
+    }
 
-    if (active)
-        g_panel_item_dock(item);
     else
-        g_panel_item_undock(item);
+    {
+        panel = G_PANEL_ITEM(item);
+
+        if (g_panel_item_is_docked(panel))
+            g_panel_item_undock(panel);
+        else
+            g_panel_item_dock(panel);
+
+        g_object_unref(G_OBJECT(item));
+
+    }
 
 }
 
diff --git a/src/gui/panel-int.h b/src/gui/panel-int.h
index 2f7d876..d54dc16 100644
--- a/src/gui/panel-int.h
+++ b/src/gui/panel-int.h
@@ -33,7 +33,6 @@
 
 
 #include "item-int.h"
-#include "../common/dllist.h"
 #include "../glibext/delayed.h"
 
 
@@ -41,6 +40,21 @@
 /* ------------------------- COEUR DES PANNEAUX D'AFFICHAGE ------------------------- */
 
 
+/* Fournit une indication sur la personnalité du panneau. */
+typedef PanelItemPersonality (* get_panel_personality_fc) (const GPanelItemClass *);
+
+/* Fournit une indication d'accroche du panneau au démarrage. */
+typedef bool (* dock_panel_at_startup_fc) (const GPanelItemClass *);
+
+/* Détermine si un panneau peut être filtré. */
+typedef bool (* can_search_panel_fc) (const GPanelItemClass *);
+
+/* Indique le chemin initial de la localisation d'un panneau. */
+typedef char * (* get_panel_path_fc) (const GPanelItemClass *);
+
+/* Indique la définition d'un éventuel raccourci clavier. */
+typedef char * (* get_panel_bindings_fc) (const GPanelItemClass *);
+
 /* Place un panneau dans l'ensemble affiché. */
 typedef void (* ack_dock_process_fc) (GPanelItem *);
 
@@ -56,18 +70,11 @@ struct _GPanelItem
 {
     GEditorItem parent;                     /* A laisser en premier        */
 
-    DL_LIST_ITEM(link);                     /* Maillon de liste chaînée    */
-
-    PanelItemPersonality personality;       /* Nature de l'élément         */
+    bool docked;                            /* Panneau inscrusté ?         */
 
     GNamedWidget *widget;                   /* Composant avec noms         */
     GtkWidget *cached_widget;               /* Composant GTK récupéré      */
 
-    bool dock_at_startup;                   /* Recommandation au démarrage */
-    char *path;                             /* Chemin vers la place idéale */
-
-    bool docked;                            /* Panneau inscrusté ?         */
-
     char *filter;                           /* Eventuel filtre textuel     */
 
     cairo_surface_t *surface;               /* Copie d'écran préalable     */
@@ -82,10 +89,11 @@ struct _GPanelItemClass
 {
     GEditorItemClass parent;                /* A laisser en premier        */
 
-    bool unique;                            /* Panneau instanciable ?      */
-    const char *bindings;                   /* Raccourci clavier éventuel  */
-
-    bool can_search;                        /* Contenu fouillable ?        */
+    get_panel_personality_fc get_personality; /* Fourniture de nature      */
+    dock_panel_at_startup_fc dock_at_startup; /* Recommandation d'accroche */
+    can_search_panel_fc can_search;         /* Contenu fouillable ?        */
+    get_panel_path_fc get_path;             /* Chemin vers la place idéale */
+    get_panel_bindings_fc get_bindings;     /* Raccourci clavier éventuel  */
 
     ack_dock_process_fc ack_dock;           /* Prise en compte d'accroche  */
     ack_undock_process_fc ack_undock;       /* Prise en compte de décroche */
@@ -102,8 +110,14 @@ struct _GPanelItemClass
 };
 
 
-#define panels_list_add_tail(new, head) dl_list_add_tail(new, head, GPanelItem, link) 
-#define panels_list_for_each(pos, head) dl_list_for_each(pos, head, GPanelItem, link) 
+/* Fournit une indication sur la personnalité du panneau. */
+PanelItemPersonality gtk_panel_item_class_get_personality_singleton(const GPanelItemClass *);
+
+/* Renvoie false lors d'une consultation de la classe. */
+bool gtk_panel_item_class_return_false(const GPanelItemClass *);
+
+/* Renvoie true lors d'une consultation de la classe. */
+bool gtk_panel_item_class_return_true(const GPanelItemClass *);
 
 
 
diff --git a/src/gui/panel.c b/src/gui/panel.c
index 18ecbb0..a509f40 100644
--- a/src/gui/panel.c
+++ b/src/gui/panel.c
@@ -31,20 +31,23 @@
 
 
 #include "panel-int.h"
+#include "core/global.h"
+#include "core/items.h"
 #include "../common/extstr.h"
 #include "../core/params.h"
 #include "../gtkext/gtkdockable-int.h"
 #include "../gtkext/named.h"
+#include "../plugins/dt.h"
 
 
 
 /* ------------------------- COEUR DES PANNEAUX D'AFFICHAGE ------------------------- */
 
 
-/* Initialise la classe des éléments réactifs de l'éditeur. */
+/* Initialise la classe des panneaux graphiques de l'éditeur. */
 static void g_panel_item_class_init(GPanelItemClass *);
 
-/* Initialise une instance d'élément réactif pour l'éditeur. */
+/* Initialise une instance de panneau graphique pour l'éditeur. */
 static void g_panel_item_init(GPanelItem *);
 
 /* Procède à l'initialisation de l'interface d'incrustation. */
@@ -56,6 +59,9 @@ static void g_panel_item_dispose(GPanelItem *);
 /* Procède à la libération totale de la mémoire. */
 static void g_panel_item_finalize(GPanelItem *);
 
+/* Construit la chaîne d'accès à un élément de configuration. */
+static char *gtk_panel_item_class_build_configuration_key(const GPanelItemClass *, const char *);
+
 /* Fournit le nom court du composant encapsulable. */
 static char *gtk_panel_item_get_name(const GPanelItem *);
 
@@ -71,9 +77,6 @@ static GtkWidget *gtk_panel_item_get_widget(GPanelItem *);
 /* Démarre l'actualisation du filtrage du contenu. */
 static void gtk_panel_item_update_filtered(GPanelItem *, const char *);
 
-/* Construit la chaîne d'accès à un élément de configuration. */
-static char *gtk_panel_item_build_configuration_key(const GPanelItem *, const char *);
-
 
 
 /* ---------------------- MECANISMES DE MISE A JOUR DE PANNEAU ---------------------- */
@@ -96,9 +99,9 @@ G_DEFINE_TYPE_WITH_CODE(GPanelItem, g_panel_item, G_TYPE_EDITOR_ITEM,
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : klass = classe à initialiser.                                *
+*  Paramètres  : class = classe à initialiser.                                *
 *                                                                             *
-*  Description : Initialise la classe des éléments réactifs de l'éditeur.     *
+*  Description : Initialise la classe des panneaux graphiques de l'éditeur.   *
 *                                                                             *
 *  Retour      : -                                                            *
 *                                                                             *
@@ -106,21 +109,24 @@ G_DEFINE_TYPE_WITH_CODE(GPanelItem, g_panel_item, G_TYPE_EDITOR_ITEM,
 *                                                                             *
 ******************************************************************************/
 
-static void g_panel_item_class_init(GPanelItemClass *klass)
+static void g_panel_item_class_init(GPanelItemClass *class)
 {
     GObjectClass *object;                   /* Autre version de la classe  */
     GEditorItemClass *item;                 /* Encore une autre vision...  */
 
-    object = G_OBJECT_CLASS(klass);
+    object = G_OBJECT_CLASS(class);
 
     object->dispose = (GObjectFinalizeFunc/* ! */)g_panel_item_dispose;
     object->finalize = (GObjectFinalizeFunc)g_panel_item_finalize;
 
-    item = G_EDITOR_ITEM_CLASS(klass);
+    item = G_EDITOR_ITEM_CLASS(class);
 
-    item->get_key = (get_item_key_fc)gtk_panel_item_get_name;
     item->get_widget = (get_item_widget_fc)gtk_panel_item_get_widget;
 
+    class->get_personality = gtk_panel_item_class_get_personality_singleton;
+    class->dock_at_startup = gtk_panel_item_class_return_true;
+    class->can_search = gtk_panel_item_class_return_false;
+
     g_signal_new("dock-request",
                  G_TYPE_PANEL_ITEM,
                  G_SIGNAL_RUN_LAST,
@@ -137,8 +143,6 @@ static void g_panel_item_class_init(GPanelItemClass *klass)
                  g_cclosure_marshal_VOID__VOID,
                  G_TYPE_NONE, 0);
 
-    klass->can_search = false;
-
 }
 
 
@@ -146,7 +150,7 @@ static void g_panel_item_class_init(GPanelItemClass *klass)
 *                                                                             *
 *  Paramètres  : item = instance à initialiser.                               *
 *                                                                             *
-*  Description : Initialise une instance d'élément réactif pour l'éditeur.    *
+*  Description : Initialise une instance de panneau graphique pour l'éditeur. *
 *                                                                             *
 *  Retour      : -                                                            *
 *                                                                             *
@@ -156,9 +160,7 @@ static void g_panel_item_class_init(GPanelItemClass *klass)
 
 static void g_panel_item_init(GPanelItem *item)
 {
-    DL_LIST_ITEM_INIT(&item->link);
-
-    item->personality = PIP_INVALID;
+    item->docked = false;
 
     item->widget = NULL;
     item->cached_widget = NULL;
@@ -230,8 +232,6 @@ static void g_panel_item_dispose(GPanelItem *item)
 
 static void g_panel_item_finalize(GPanelItem *item)
 {
-    free(item->path);
-
     if (item->filter != NULL)
         free(item->filter);
 
@@ -245,33 +245,44 @@ static void g_panel_item_finalize(GPanelItem *item)
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : personality = nature du panneau à mettre en place.           *
-*                widget  = composant avec noms à présenter à l'affichage.     *
-*                startup = chargement au démarrage ?                          *
-*                path    = chemin vers la place idéale pour le futur panneau. *
+*  Paramètres  : class = classe à consulter.                                  *
 *                                                                             *
-*  Description : Crée un élément de panneau réactif.                          *
+*  Description : Fournit une indication sur la personnalité du panneau.       *
 *                                                                             *
-*  Retour      : Adresse de la structure mise en place.                       *
+*  Retour      : Identifiant lié à la nature du panneau.                      *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-GPanelItem *g_panel_item_new(PanelItemPersonality personality, GNamedWidget *widget, bool startup, const char *path)
+PanelItemPersonality gtk_panel_item_class_get_personality(const GPanelItemClass *class)
 {
-    GPanelItem *result;                     /* Structure à retourner       */
+    PanelItemPersonality result;            /* Personnalité à retourner    */
+
+    result = class->get_personality(class);
+
+    return result;
 
-    result = g_object_new(G_TYPE_PANEL_ITEM, NULL);
+}
 
-    assert(personality > PIP_INVALID && personality < PIP_COUNT);
-    result->personality = personality;
 
-    result->widget = widget;
-    g_object_ref(G_OBJECT(widget));
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : class = classe à consulter.                                  *
+*                                                                             *
+*  Description : Fournit une indication sur la personnalité du panneau.       *
+*                                                                             *
+*  Retour      : Identifiant lié à la nature unique du panneau.               *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
 
-    result->dock_at_startup = startup;
-    result->path = strdup(path);
+PanelItemPersonality gtk_panel_item_class_get_personality_singleton(const GPanelItemClass *class)
+{
+    PanelItemPersonality result;            /* Personnalité à retourner    */
+
+    result = PIP_SINGLETON;
 
     return result;
 
@@ -280,23 +291,37 @@ GPanelItem *g_panel_item_new(PanelItemPersonality personality, GNamedWidget *wid
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : item = instance de panneau à consulter.                      *
+*  Paramètres  : class = classe à consulter.                                  *
 *                                                                             *
-*  Description : Indique le composant graphique principal du panneau.         *
+*  Description : Fournit une indication d'accroche du panneau au démarrage.   *
 *                                                                             *
-*  Retour      : Composant graphique avec nom constituant le panneau.         *
+*  Retour      : true si le panneau doit être affiché de prime abord.         *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-GNamedWidget *gtk_panel_item_get_named_widget(const GPanelItem *item)
+bool gtk_panel_item_class_dock_at_startup(const GPanelItemClass *class)
 {
-    GNamedWidget *result;                   /* Composant nommé à retourner */
+    bool result;                            /* Statut à retourner          */
+    GGenConfig *config;                     /* Configuration courante      */
+    char *key;                              /* Clef d'accès à un paramètre */
+#ifndef NDEBUG
+    bool status;                            /* Bilan de consultation       */
+#endif
 
-    result = item->widget;
+    config = get_main_configuration();
 
-    g_object_ref(G_OBJECT(result));
+    key = gtk_panel_item_class_build_configuration_key(class, "dock_at_startup");
+
+#ifndef NDEBUG
+    status = g_generic_config_get_value(config, key, &result);
+    assert(status);
+#else
+    g_generic_config_get_value(config, key, &result);
+#endif
+
+    free(key);
 
     return result;
 
@@ -305,21 +330,21 @@ GNamedWidget *gtk_panel_item_get_named_widget(const GPanelItem *item)
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : item = instance GTK dont l'interface est à consulter.        *
+*  Paramètres  : class = classe associée à la consultation.                   *
 *                                                                             *
-*  Description : Fournit le nom court du composant encapsulable.              *
+*  Description : Renvoie false lors d'une consultation de la classe.          *
 *                                                                             *
-*  Retour      : Désignation humaine pour titre d'onglet ou de fenêtre.       *
+*  Retour      : false.                                                       *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-static char *gtk_panel_item_get_name(const GPanelItem *item)
+bool gtk_panel_item_class_return_false(const GPanelItemClass *class)
 {
-    char *result;                           /* Désignation à retourner     */
+    bool result;                            /* Statut à retourner          */
 
-    result = g_named_widget_get_name(G_NAMED_WIDGET(item->widget), false);
+    result = false;
 
     return result;
 
@@ -328,21 +353,21 @@ static char *gtk_panel_item_get_name(const GPanelItem *item)
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : item = instance GTK dont l'interface est à consulter.        *
+*  Paramètres  : class = classe associée à la consultation.                   *
 *                                                                             *
-*  Description : Fournit le nom long du composant encapsulable.               *
+*  Description : Renvoie true lors d'une consultation de la classe.           *
 *                                                                             *
-*  Retour      : Désignation humaine pour titre d'onglet ou de fenêtre.       *
+*  Retour      : true.                                                        *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-static char *gtk_panel_item_get_desc(const GPanelItem *item)
+bool gtk_panel_item_class_return_true(const GPanelItemClass *class)
 {
-    char *result;                           /* Description à retourner     */
+    bool result;                            /* Statut à retourner          */
 
-    result = g_named_widget_get_name(G_NAMED_WIDGET(item->widget), true);
+    result = true;
 
     return result;
 
@@ -351,7 +376,7 @@ static char *gtk_panel_item_get_desc(const GPanelItem *item)
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : item = instance GTK dont l'interface est à consulter.        *
+*  Paramètres  : class = classe à consulter.                                  *
 *                                                                             *
 *  Description : Détermine si un panneau peut être filtré.                    *
 *                                                                             *
@@ -361,14 +386,11 @@ static char *gtk_panel_item_get_desc(const GPanelItem *item)
 *                                                                             *
 ******************************************************************************/
 
-static bool gtk_panel_item_can_search(const GPanelItem *item)
+bool gtk_panel_item_class_can_search(const GPanelItemClass *class)
 {
-    bool result;                            /* Indication à retourner      */
-    GPanelItemClass *class;                 /* Classe de l'élément visé    */
+    bool result;                            /* Statut à retourner          */
 
-    class = G_PANEL_ITEM_GET_CLASS(item);
-
-    result = class->can_search;
+    result = class->can_search(class);
 
     return result;
 
@@ -377,26 +399,40 @@ static bool gtk_panel_item_can_search(const GPanelItem *item)
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : item = instance GTK dont l'interface est à consulter.        *
+*  Paramètres  : class = classe à consulter.                                  *
 *                                                                             *
-*  Description : Fournit le composant graphique intégrable dans un ensemble.  *
+*  Description : Indique le chemin initial de la localisation d'un panneau.   *
 *                                                                             *
-*  Retour      : Composant graphique prêt à emploi.                           *
+*  Retour      : Chemin fixé associé à la position initiale.                  *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-static GtkWidget *gtk_panel_item_get_widget(GPanelItem *item)
+char *gtk_panel_item_class_get_path(const GPanelItemClass *class)
 {
-    GtkWidget *result;                      /* Composant à retourner       */
+    char *result;                           /* Emplacement à retourner     */
+    GGenConfig *config;                     /* Configuration courante      */
+    char *key;                              /* Clef d'accès à un paramètre */
+    const char *path;                       /* Nouveau chemin de placement */
+#ifndef NDEBUG
+    bool status;                            /* Statut de l'encapsulation   */
+#endif
 
-    if (item->cached_widget == NULL)
-        item->cached_widget = g_named_widget_get_widget(G_NAMED_WIDGET(item->widget));
+    config = get_main_configuration();
 
-    result = item->cached_widget;
+    key = gtk_panel_item_class_build_configuration_key(class, "path");
 
-    g_object_ref(G_OBJECT(result));
+#ifndef NDEBUG
+    status = g_generic_config_get_value(config, key, &path);
+    assert(status);
+#else
+    g_generic_config_get_value(config, key, &path);
+#endif
+
+    free(key);
+
+    result = strdup(path);
 
     return result;
 
@@ -405,33 +441,34 @@ static GtkWidget *gtk_panel_item_get_widget(GPanelItem *item)
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : item = instance GTK dont l'interface est à sollicitée.       *
+*  Paramètres  : class = classe à consulter.                                  *
 *                                                                             *
-*  Description : Démarre l'actualisation du filtrage du contenu.              *
+*  Description : Indique la définition d'un éventuel raccourci clavier.       *
 *                                                                             *
-*  Retour      : -                                                            *
+*  Retour      : Description d'un raccourci ou NULL si aucun de défini.       *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-static void gtk_panel_item_update_filtered(GPanelItem *item, const char *filter)
+char *gtk_panel_item_class_get_key_bindings(const GPanelItemClass *class)
 {
-    assert(gtk_panel_item_can_search(item));
+    char *result;                           /* Emplacement à retourner     */
 
-    if (item->filter != NULL)
-        free(item->filter);
+    if (class->get_bindings != NULL)
+        result = class->get_bindings(class);
 
-    item->filter = (filter ? strdup(filter) : NULL);
+    else
+        result = NULL;
 
-    G_PANEL_ITEM_GET_CLASS(item)->update_filtered(item);
+    return result;
 
 }
 
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : item   = instance GTK à consulter.                           *
+*  Paramètres  : class  = classe du type de panneau à traiter.                *
 *                attrib = élément de configuration à inclure dans le résultat.*
 *                                                                             *
 *  Description : Construit la chaîne d'accès à un élément de configuration.   *
@@ -442,12 +479,12 @@ static void gtk_panel_item_update_filtered(GPanelItem *item, const char *filter)
 *                                                                             *
 ******************************************************************************/
 
-static char *gtk_panel_item_build_configuration_key(const GPanelItem *item, const char *attrib)
+static char *gtk_panel_item_class_build_configuration_key(const GPanelItemClass *class, const char *attrib)
 {
     char *result;                           /* Construction à renvoyer     */
     const char *name;                       /* Nom court du panneau        */
 
-    name = g_editor_item_get_key(G_EDITOR_ITEM(item));
+    name = g_editor_item_class_get_key(G_EDITOR_ITEM_CLASS(class));
 
     asprintf(&result, "gui.panels.%s.%s", attrib, name);
 
@@ -462,10 +499,10 @@ static char *gtk_panel_item_build_configuration_key(const GPanelItem *item, cons
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : item   = instance GTK à consulter.                           *
+*  Paramètres  : class  = classe de panneau à consulter.                      *
 *                config = configuration à compléter.                          *
 *                                                                             *
-*  Description : Met en place les bases de la configuration du panneau.       *
+*  Description : Met en place les bases de la configuration d'un panneau.     *
 *                                                                             *
 *  Retour      : Bilan de l'opération.                                        *
 *                                                                             *
@@ -473,33 +510,42 @@ static char *gtk_panel_item_build_configuration_key(const GPanelItem *item, cons
 *                                                                             *
 ******************************************************************************/
 
-bool gtk_panel_item_setup_configuration(const GPanelItem *item, GGenConfig *config)
+bool gtk_panel_item_class_setup_configuration(const GPanelItemClass *class, GGenConfig *config)
 {
     bool result;                            /* Bilan à retourner           */
     char *key;                              /* Clef d'accès à un paramètre */
+    bool dock_at_startup;                   /* Affichage dès le départ ?   */
     GCfgParam *param;                       /* Paramètre chargé            */
+    char *path;                             /* Localisation du panneau     */
 
     result = true;
 
-    key = gtk_panel_item_build_configuration_key(item, "dock_at_startup");
+    key = gtk_panel_item_class_build_configuration_key(class, "dock_at_startup");
+
+    dock_at_startup = class->dock_at_startup(class);
 
-    param = g_generic_config_create_param(config, key, CPT_BOOLEAN, item->dock_at_startup);
+    param = g_generic_config_create_param_if_not_exist(config, key, CPT_BOOLEAN, dock_at_startup);
+
+    free(key);
 
     if (param == NULL)
     {
         result = false;
-        goto gpisc_exit;
+        goto exit;
     }
 
-    free(key);
+    key = gtk_panel_item_class_build_configuration_key(class, "path");
+
+    path = class->get_path(class);
 
-    key = gtk_panel_item_build_configuration_key(item, "path");
+    param = g_generic_config_create_param_if_not_exist(config, key, CPT_STRING, path);
 
-    param = g_generic_config_create_param(config, key, CPT_STRING, item->path);
     if (param == NULL)
         result = false;
 
- gpisc_exit:
+    free(path);
+
+ exit:
 
     free(key);
 
@@ -510,116 +556,160 @@ bool gtk_panel_item_setup_configuration(const GPanelItem *item, GGenConfig *conf
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : item   = instance GTK à consulter.                           *
-*                config = configuration à charger.                            *
+*  Paramètres  : type = type de panneau à mettre en place.                    *
+*                path = emplacement d'affichage ou NULL.                      *
 *                                                                             *
-*  Description : Charge un panneau sur les bases de la configuration fournie. *
+*  Description : Crée un élément de panneau réactif.                          *
 *                                                                             *
-*  Retour      : true, par conformité avec browse_all_item_panels().          *
+*  Retour      : Adresse de la structure mise en place.                       *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-bool gtk_panel_item_apply_configuration(GPanelItem *item, GGenConfig *config)
+GPanelItem *g_panel_item_new(GType type, const char *path)
 {
-    char *key;                              /* Clef d'accès à un paramètre */
-    const char *new_path;                   /* Nouveau chemin de placement */
-    bool status;                            /* Statut de l'encapsulation   */
+    GPanelItem *result;                     /* Structure à retourner       */
+    GPanelItemClass *class;                 /* Classe associée au type     */
+    PanelItemPersonality personality;       /* Caractéristique de panneau  */
+    GtkTiledGrid *grid;                     /* Composant d'affichage       */
+
+    class = g_type_class_ref(type);
 
-    key = gtk_panel_item_build_configuration_key(item, "path");
+    personality = gtk_panel_item_class_get_personality(class);
+    assert(path != NULL || personality == PIP_PERSISTENT_SINGLETON);
 
-    if (g_generic_config_get_value(config, key, &new_path))
+    g_type_class_unref(class);
+
+    if (personality == PIP_PERSISTENT_SINGLETON || personality == PIP_SINGLETON)
     {
-        free(item->path);
+        result = G_PANEL_ITEM(find_editor_item_by_type(type));
 
-        item->path = strdup(new_path);
+        if (result != NULL)
+            goto singleton;
 
     }
 
-    free(key);
+    result = create_object_from_type(type);
 
-    key = gtk_panel_item_build_configuration_key(item, "dock_at_startup");
+    grid = get_tiled_grid();
 
-    if (g_generic_config_get_value(config, key, &status))
+    g_signal_connect_swapped(result, "dock-request", G_CALLBACK(gtk_tiled_grid_add), grid);
+    g_signal_connect_swapped(result, "undock-request", G_CALLBACK(gtk_tiled_grid_remove), grid);
+
+    gtk_dockable_setup_dnd(GTK_DOCKABLE(result));
+
+    register_editor_item(G_EDITOR_ITEM(result));
+
+ singleton:
+
+    if (path != NULL)
     {
-        item->dock_at_startup = status;
+        if (path[0] != '\0')
+            gtk_panel_item_set_path(result, path);
 
-        if (item->dock_at_startup)
-            g_signal_emit_by_name(item, "dock-request");
+        g_panel_item_dock(result);
 
     }
 
-    free(key);
-
-    return true;
+    return result;
 
 }
 
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : item = instance GTK à consulter.                             *
+*  Paramètres  : item = instance de panneau à consulter.                      *
 *                                                                             *
-*  Description : Fournit une indication sur la personnalité du panneau.       *
+*  Description : Indique le composant graphique principal du panneau.         *
 *                                                                             *
-*  Retour      : Identifiant lié à la nature du panneau.                      *
+*  Retour      : Composant graphique avec nom constituant le panneau.         *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-PanelItemPersonality gtk_panel_item_get_personality(const GPanelItem *item)
+GNamedWidget *gtk_panel_item_get_named_widget(const GPanelItem *item)
 {
-    return item->personality;
+    GNamedWidget *result;                   /* Composant nommé à retourner */
+
+    result = item->widget;
+
+    g_object_ref(G_OBJECT(result));
+
+    return result;
 
 }
 
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : item = instance GTK à consulter.                             *
+*  Paramètres  : item = instance GTK dont l'interface est à consulter.        *
 *                                                                             *
-*  Description : Fournit le chemin d'accès à utiliser pour les encapsulations.*
+*  Description : Fournit le nom court du composant encapsulable.              *
 *                                                                             *
-*  Retour      : Chemin d'accès défini.                                       *
+*  Retour      : Désignation humaine pour titre d'onglet ou de fenêtre.       *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-const char *gtk_panel_item_get_path(const GPanelItem *item)
+static char *gtk_panel_item_get_name(const GPanelItem *item)
 {
-    return item->path;
+    char *result;                           /* Désignation à retourner     */
+
+    result = g_named_widget_get_name(G_NAMED_WIDGET(item->widget), false);
+
+    return result;
 
 }
 
+
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : item = instance GTK à consulter.                             *
-*                path = nouvelle emplacement d'inclusion.                     *
+*  Paramètres  : item = instance GTK dont l'interface est à consulter.        *
 *                                                                             *
-*  Description : Définit le chemin d'accès à utiliser pour les encapsulations.*
+*  Description : Fournit le nom long du composant encapsulable.               *
 *                                                                             *
-*  Retour      : -                                                            *
+*  Retour      : Désignation humaine pour titre d'onglet ou de fenêtre.       *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-void gtk_panel_item_set_path(GPanelItem *item, const char *path)
+static char *gtk_panel_item_get_desc(const GPanelItem *item)
 {
-    char *key;                              /* Clef d'accès à un paramètre */
+    char *result;                           /* Description à retourner     */
 
-    free(item->path);
+    result = g_named_widget_get_name(G_NAMED_WIDGET(item->widget), true);
 
-    item->path = strdup(path);
+    return result;
 
-    key = gtk_panel_item_build_configuration_key(item, "path");
+}
 
-    g_generic_config_set_value(get_main_configuration(), key, item->path);
 
-    free(key);
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : item = instance GTK dont l'interface est à consulter.        *
+*                                                                             *
+*  Description : Détermine si un panneau peut être filtré.                    *
+*                                                                             *
+*  Retour      : Bilan de la consultation.                                    *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static bool gtk_panel_item_can_search(const GPanelItem *item)
+{
+    bool result;                            /* Indication à retourner      */
+    GPanelItemClass *class;                 /* Classe de l'élément visé    */
+
+    class = G_PANEL_ITEM_GET_CLASS(item);
+
+    result = gtk_panel_item_class_can_search(class);
+
+    return result;
 
 }
 
@@ -628,17 +718,81 @@ void gtk_panel_item_set_path(GPanelItem *item, const char *path)
 *                                                                             *
 *  Paramètres  : item = instance GTK dont l'interface est à consulter.        *
 *                                                                             *
-*  Description : Indique la définition d'un éventuel raccourci clavier.       *
+*  Description : Fournit le composant graphique intégrable dans un ensemble.  *
 *                                                                             *
-*  Retour      : Description d'un raccourci ou NULL si aucun de défini.       *
+*  Retour      : Composant graphique prêt à emploi.                           *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-const char *gtk_panel_item_get_key_bindings(const GPanelItem *item)
+static GtkWidget *gtk_panel_item_get_widget(GPanelItem *item)
 {
-    return G_PANEL_ITEM_GET_CLASS(item)->bindings;
+    GtkWidget *result;                      /* Composant à retourner       */
+
+    if (item->cached_widget == NULL)
+        item->cached_widget = g_named_widget_get_widget(G_NAMED_WIDGET(item->widget));
+
+    result = item->cached_widget;
+
+    g_object_ref(G_OBJECT(result));
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : item = instance GTK dont l'interface est à sollicitée.       *
+*                                                                             *
+*  Description : Démarre l'actualisation du filtrage du contenu.              *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void gtk_panel_item_update_filtered(GPanelItem *item, const char *filter)
+{
+    assert(gtk_panel_item_can_search(item));
+
+    if (item->filter != NULL)
+        free(item->filter);
+
+    item->filter = (filter ? strdup(filter) : NULL);
+
+    G_PANEL_ITEM_GET_CLASS(item)->update_filtered(item);
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : item = instance GTK à consulter.                             *
+*                path = nouvelle emplacement d'inclusion.                     *
+*                                                                             *
+*  Description : Définit le chemin d'accès à utiliser pour les encapsulations.*
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+void gtk_panel_item_set_path(GPanelItem *item, const char *path)
+{
+    GGenConfig *config;                     /* Configuration courante      */
+    char *key;                              /* Clef d'accès à un paramètre */
+
+    config = get_main_configuration();
+
+    key = gtk_panel_item_class_build_configuration_key(G_PANEL_ITEM_GET_CLASS(item), "path");
+
+    g_generic_config_set_value(config, key, path);
+
+    free(key);
 
 }
 
@@ -680,16 +834,15 @@ void g_panel_item_dock(GPanelItem *item)
 *                                                                             *
 ******************************************************************************/
 
-void g_panel_item_set_dock_status(GPanelItem *item, bool status)
+void g_panel_item_set_dock_at_startup(GPanelItem *item, bool status)
 {
     char *key;                              /* Clef d'accès à un paramètre */
 
     item->docked = status;
-    item->dock_at_startup = status;
 
-    key = gtk_panel_item_build_configuration_key(item, "dock_at_startup");
+    key = gtk_panel_item_class_build_configuration_key(G_PANEL_ITEM_GET_CLASS(item), "dock_at_startup");
 
-    g_generic_config_set_value(get_main_configuration(), key, item->dock_at_startup);
+    g_generic_config_set_value(get_main_configuration(), key, status);
 
     free(key);
 
@@ -710,7 +863,11 @@ void g_panel_item_set_dock_status(GPanelItem *item, bool status)
 
 bool g_panel_item_is_docked(const GPanelItem *item)
 {
-    return item->docked;
+    bool result;                            /* Status à retourner          */
+
+    result = item->docked;
+
+    return result;
 
 }
 
@@ -729,6 +886,8 @@ bool g_panel_item_is_docked(const GPanelItem *item)
 
 void g_panel_item_undock(GPanelItem *item)
 {
+    PanelItemPersonality personality;       /* Caractéristique de panneau  */
+
     assert(item->docked);
 
     g_signal_emit_by_name(item, "undock-request");
@@ -736,6 +895,11 @@ void g_panel_item_undock(GPanelItem *item)
     if (G_PANEL_ITEM_GET_CLASS(item)->ack_undock != NULL)
         G_PANEL_ITEM_GET_CLASS(item)->ack_undock(item);
 
+    personality = gtk_panel_item_class_get_personality(G_PANEL_ITEM_GET_CLASS(item));
+
+    if (personality != PIP_PERSISTENT_SINGLETON)
+        unregister_editor_item(G_EDITOR_ITEM(item));
+
 }
 
 
diff --git a/src/gui/panel.h b/src/gui/panel.h
index 067f076..de8d2bf 100644
--- a/src/gui/panel.h
+++ b/src/gui/panel.h
@@ -56,6 +56,7 @@ typedef enum _PanelItemPersonality
     PIP_INVALID,                            /* Information non initialisée */
 
     PIP_SINGLETON,                          /* Instance unique             */
+    PIP_PERSISTENT_SINGLETON,               /* Instance unique permanente             */
     PIP_BINARY_VIEW,                        /* Affichage d'un binaire      */
     PIP_OTHER,                              /* Reste du monde              */
 
@@ -67,35 +68,38 @@ typedef enum _PanelItemPersonality
 /* Indique le type défini pour un élément destiné à un panneau. */
 GType g_panel_item_get_type(void);
 
-/* Crée un élément de panneau réactif. */
-GPanelItem *g_panel_item_new(PanelItemPersonality, GNamedWidget *, bool, const char *);
+/* Fournit une indication sur la personnalité du panneau. */
+PanelItemPersonality gtk_panel_item_class_get_personality(const GPanelItemClass *);
 
-/* Indique le composant graphique principal du panneau. */
-GNamedWidget *gtk_panel_item_get_named_widget(const GPanelItem *);
+/* Fournit une indication d'accroche du panneau au démarrage. */
+bool gtk_panel_item_class_dock_at_startup(const GPanelItemClass *);
 
-/* Met en place les bases de la configuration du panneau. */
-bool gtk_panel_item_setup_configuration(const GPanelItem *, GGenConfig *);
+/* Détermine si un panneau peut être filtré. */
+bool gtk_panel_item_class_can_search(const GPanelItemClass *);
 
-/* Charge un panneau sur les bases de la configuration fournie. */
-bool gtk_panel_item_apply_configuration(GPanelItem *, GGenConfig *);
+/* Indique le chemin initial de la localisation d'un panneau. */
+char *gtk_panel_item_class_get_path(const GPanelItemClass *);
 
-/* Fournit une indication sur la personnalité du panneau. */
-PanelItemPersonality gtk_panel_item_get_personality(const GPanelItem *);
+/* Indique la définition d'un éventuel raccourci clavier. */
+char *gtk_panel_item_class_get_key_bindings(const GPanelItemClass *);
 
-/* Fournit le chemin d'accès à utiliser pour les encapsulations. */
-const char *gtk_panel_item_get_path(const GPanelItem *);
+/* Met en place les bases de la configuration du panneau. */
+bool gtk_panel_item_class_setup_configuration(const GPanelItemClass *, GGenConfig *);
+
+/* Crée un élément de panneau réactif. */
+GPanelItem *g_panel_item_new(GType, const char *);
+
+/* Indique le composant graphique principal du panneau. */
+GNamedWidget *gtk_panel_item_get_named_widget(const GPanelItem *);
 
 /* Définit le chemin d'accès à utiliser pour les encapsulations. */
 void gtk_panel_item_set_path(GPanelItem *, const char *);
 
-/* Indique la définition d'un éventuel raccourci clavier. */
-const char *gtk_panel_item_get_key_bindings(const GPanelItem *);
-
 /* Place un panneau dans l'ensemble affiché. */
 void g_panel_item_dock(GPanelItem *);
 
 /* Définit si le composant repose sur un support de l'éditeur. */
-void g_panel_item_set_dock_status(GPanelItem *, bool);
+void g_panel_item_set_dock_at_startup(GPanelItem *, bool);
 
 /* Indique si le composant repose sur un support de l'éditeur. */
 bool g_panel_item_is_docked(const GPanelItem *);
diff --git a/src/gui/panels/Makefile.am b/src/gui/panels/Makefile.am
index 457e507..13c401e 100644
--- a/src/gui/panels/Makefile.am
+++ b/src/gui/panels/Makefile.am
@@ -30,6 +30,7 @@ libguipanels_la_SOURCES =				\
 	symbols.h symbols.c					\
 	updating-int.h						\
 	updating.h updating.c				\
+	view.h view.c						\
 	welcome.h welcome.c
 
 libguipanels_la_LDFLAGS = 
diff --git a/src/gui/panels/bintree.c b/src/gui/panels/bintree.c
index eb2debc..db5e774 100644
--- a/src/gui/panels/bintree.c
+++ b/src/gui/panels/bintree.c
@@ -117,7 +117,10 @@ static void g_bintree_panel_dispose(GBintreePanel *);
 static void g_bintree_panel_finalize(GBintreePanel *);
 
 /* Fournit le nom interne attribué à l'élément réactif. */
-static char *g_bintree_panel_get_key(const GBintreePanel *);
+static char *g_bintree_panel_class_get_key(const GBintreePanelClass *);
+
+/* Indique le chemin initial de la localisation d'un panneau. */
+static char *g_bintree_panel_class_get_path(const GBintreePanelClass *);
 
 /* Modifie la profondeur affichée des portions présentes. */
 static void on_depth_spin_value_changed(GtkSpinButton *, const GBintreePanel *);
@@ -215,7 +218,7 @@ G_DEFINE_TYPE_WITH_CODE(GBintreePanel, g_bintree_panel, G_TYPE_PANEL_ITEM,
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : klass = classe à initialiser.                                *
+*  Paramètres  : class = classe à initialiser.                                *
 *                                                                             *
 *  Description : Initialise la classe des panneaux d'affichage des portions.  *
 *                                                                             *
@@ -225,24 +228,26 @@ G_DEFINE_TYPE_WITH_CODE(GBintreePanel, g_bintree_panel, G_TYPE_PANEL_ITEM,
 *                                                                             *
 ******************************************************************************/
 
-static void g_bintree_panel_class_init(GBintreePanelClass *klass)
+static void g_bintree_panel_class_init(GBintreePanelClass *class)
 {
     GObjectClass *object;                   /* Autre version de la classe  */
     GEditorItemClass *item;                 /* Encore une autre vision...  */
     GPanelItemClass *panel;                 /* Version parente de la classe*/
 
-    object = G_OBJECT_CLASS(klass);
+    object = G_OBJECT_CLASS(class);
 
     object->dispose = (GObjectFinalizeFunc/* ! */)g_bintree_panel_dispose;
     object->finalize = (GObjectFinalizeFunc)g_bintree_panel_finalize;
 
-    item = G_EDITOR_ITEM_CLASS(klass);
+    item = G_EDITOR_ITEM_CLASS(class);
 
-    item->get_key = (get_item_key_fc)g_bintree_panel_get_key;
+    item->get_key = (get_item_key_fc)g_bintree_panel_class_get_key;
 
     item->change_content = (change_item_content_fc)change_bintree_panel_current_content;
 
-    panel = G_PANEL_ITEM_CLASS(klass);
+    panel = G_PANEL_ITEM_CLASS(class);
+
+    panel->get_path = (get_panel_path_fc)g_bintree_panel_class_get_path;
 
     panel->gid = setup_tiny_global_work_group(1);
 
@@ -273,15 +278,10 @@ static void g_bintree_panel_init(GBintreePanel *panel)
 
     pitem = G_PANEL_ITEM(panel);
 
-    pitem->personality = PIP_SINGLETON;
-
     pitem->widget = G_NAMED_WIDGET(gtk_built_named_widget_new_for_panel(_("Binary tree"),
                                                                         _("Tree of the binary layout"),
                                                                         PANEL_BINTREE_ID));
 
-    pitem->dock_at_startup = true;
-    pitem->path = strdup("MEN");
-
     /* Compléments propres */
 
     panel->binary = NULL;
@@ -415,44 +415,44 @@ static void g_bintree_panel_finalize(GBintreePanel *panel)
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : -                                                            *
+*  Paramètres  : class = classe à consulter.                                  *
 *                                                                             *
-*  Description : Crée un panneau présentant l'arborescence des portions.      *
+*  Description : Fournit le nom interne attribué à l'élément réactif.         *
 *                                                                             *
-*  Retour      : Adresse de la structure mise en place.                       *
+*  Retour      : Désignation (courte) de l'élément de l'éditeur.              *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-GPanelItem *g_bintree_panel_new(void)
+static char *g_bintree_panel_class_get_key(const GBintreePanelClass *class)
 {
-    GBintreePanel *result;                  /* Structure à retourner       */
+    char *result;                           /* Description à renvoyer      */
 
-    result = g_object_new(G_TYPE_BINTREE_PANEL, NULL);
+    result = strdup(PANEL_BINTREE_ID);
 
-    return G_PANEL_ITEM(result);
+    return result;
 
 }
 
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : panel = instance à consulter.                                *
+*  Paramètres  : class = classe à consulter.                                  *
 *                                                                             *
-*  Description : Fournit le nom interne attribué à l'élément réactif.         *
+*  Description : Indique le chemin initial de la localisation d'un panneau.   *
 *                                                                             *
-*  Retour      : Désignation (courte) de l'élément de l'éditeur.              *
+*  Retour      : Chemin fixé associé à la position initiale.                  *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-static char *g_bintree_panel_get_key(const GBintreePanel *panel)
+static char *g_bintree_panel_class_get_path(const GBintreePanelClass *class)
 {
-    char *result;                           /* Description à renvoyer      */
+    char *result;                           /* Emplacement à retourner     */
 
-    result = strdup(PANEL_BINTREE_ID);
+    result = strdup("MEN");
 
     return result;
 
@@ -461,6 +461,29 @@ static char *g_bintree_panel_get_key(const GBintreePanel *panel)
 
 /******************************************************************************
 *                                                                             *
+*  Paramètres  : -                                                            *
+*                                                                             *
+*  Description : Crée un panneau présentant l'arborescence des portions.      *
+*                                                                             *
+*  Retour      : Adresse de la structure mise en place.                       *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GPanelItem *g_bintree_panel_new(void)
+{
+    GBintreePanel *result;                  /* Structure à retourner       */
+
+    result = g_object_new(G_TYPE_BINTREE_PANEL, NULL);
+
+    return G_PANEL_ITEM(result);
+
+}
+
+
+/******************************************************************************
+*                                                                             *
 *  Paramètres  : button   = bouton de réglage de l'affichage.                 *
 *                treeview = arborescence dont l'affichage est à moduler.      *
 *                                                                             *
diff --git a/src/gui/panels/bookmarks.c b/src/gui/panels/bookmarks.c
index 46069c1..b57e657 100644
--- a/src/gui/panels/bookmarks.c
+++ b/src/gui/panels/bookmarks.c
@@ -106,7 +106,10 @@ static void g_bookmarks_panel_dispose(GBookmarksPanel *);
 static void g_bookmarks_panel_finalize(GBookmarksPanel *);
 
 /* Fournit le nom interne attribué à l'élément réactif. */
-static char *g_bookmarks_panel_get_key(const GBookmarksPanel *);
+static char *g_bookmarks_panel_class_get_key(const GBookmarksPanelClass *);
+
+/* Indique le chemin initial de la localisation d'un panneau. */
+static char *g_bookmarks_panel_class_get_path(const GBookmarksPanelClass *);
 
 /* Réagit à un changement d'affichage principal de contenu. */
 static void change_bookmarks_panel_current_content(GBookmarksPanel *, GLoadedContent *, GLoadedContent *);
@@ -180,7 +183,7 @@ G_DEFINE_TYPE(GBookmarksPanel, g_bookmarks_panel, G_TYPE_PANEL_ITEM);
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : klass = classe à initialiser.                                *
+*  Paramètres  : class = classe à initialiser.                                *
 *                                                                             *
 *  Description : Initialise la classe des panneaux des paramètres de config.  *
 *                                                                             *
@@ -190,27 +193,29 @@ G_DEFINE_TYPE(GBookmarksPanel, g_bookmarks_panel, G_TYPE_PANEL_ITEM);
 *                                                                             *
 ******************************************************************************/
 
-static void g_bookmarks_panel_class_init(GBookmarksPanelClass *klass)
+static void g_bookmarks_panel_class_init(GBookmarksPanelClass *class)
 {
     GObjectClass *object;                   /* Autre version de la classe  */
     GEditorItemClass *item;                 /* Encore une autre vision...  */
     GPanelItemClass *panel;                 /* Version parente de la classe*/
     gchar *filename;                        /* Chemin d'accès à utiliser   */
 
-    object = G_OBJECT_CLASS(klass);
+    object = G_OBJECT_CLASS(class);
 
     object->dispose = (GObjectFinalizeFunc/* ! */)g_bookmarks_panel_dispose;
     object->finalize = (GObjectFinalizeFunc)g_bookmarks_panel_finalize;
 
-    item = G_EDITOR_ITEM_CLASS(klass);
+    item = G_EDITOR_ITEM_CLASS(class);
 
-    item->get_key = (get_item_key_fc)g_bookmarks_panel_get_key;
+    item->get_key = (get_item_key_fc)g_bookmarks_panel_class_get_key;
 
     item->change_content = (change_item_content_fc)change_bookmarks_panel_current_content;
 
-    panel = G_PANEL_ITEM_CLASS(klass);
+    panel = G_PANEL_ITEM_CLASS(class);
 
-    panel->can_search = true;
+    panel->dock_at_startup = gtk_panel_item_class_return_false;
+    panel->can_search = gtk_panel_item_class_return_true;
+    panel->get_path = (get_panel_path_fc)g_bookmarks_panel_class_get_path;
 
     panel->update_filtered = (update_filtered_fc)update_filtered_bookmarks;
 
@@ -219,7 +224,7 @@ static void g_bookmarks_panel_class_init(GBookmarksPanelClass *klass)
     filename = find_pixmap_file("bookmark.png");
     assert(filename != NULL);
 
-    klass->bookmark_img = cairo_image_surface_create_from_png(filename);
+    class->bookmark_img = cairo_image_surface_create_from_png(filename);
 
     g_free(filename);
 
@@ -249,15 +254,10 @@ static void g_bookmarks_panel_init(GBookmarksPanel *panel)
 
     pitem = G_PANEL_ITEM(panel);
 
-    pitem->personality = PIP_SINGLETON;
-
     pitem->widget = G_NAMED_WIDGET(gtk_built_named_widget_new_for_panel(_("Bookmarks"),
                                                                         _("Bookmarks for the current binary"),
                                                                         PANEL_BOOKMARKS_ID));
 
-    pitem->dock_at_startup = false;
-    pitem->path = strdup("Ms");
-
     /* Représentation graphique */
 
     builder = gtk_built_named_widget_get_builder(GTK_BUILT_NAMED_WIDGET(pitem->widget));
@@ -343,29 +343,44 @@ static void g_bookmarks_panel_finalize(GBookmarksPanel *panel)
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : -                                                            *
+*  Paramètres  : class = classe à consulter.                                  *
 *                                                                             *
-*  Description : Crée un panneau d'affichage des paramètres de configuration. *
+*  Description : Fournit le nom interne attribué à l'élément réactif.         *
 *                                                                             *
-*  Retour      : Adresse de la structure mise en place.                       *
+*  Retour      : Désignation (courte) de l'élément de l'éditeur.              *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-GPanelItem *g_bookmarks_panel_new(void)
+static char *g_bookmarks_panel_class_get_key(const GBookmarksPanelClass *class)
 {
-    GPanelItem *result;                     /* Structure à retourner       */
+    char *result;                           /* Description à renvoyer      */
 
-    result = g_object_new(G_TYPE_BOOKMARKS_PANEL, NULL);
+    result = strdup(PANEL_BOOKMARKS_ID);
 
-    //reload_config_into_treeview(G_BOOKMARKS_PANEL(result), get_main_configuration());
+    return result;
 
+}
 
-    //GDbCollection *g_loaded_binary_find_collection(GLoadedBinary *binary, DBFeatures feature)
 
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : class = classe à consulter.                                  *
+*                                                                             *
+*  Description : Indique le chemin initial de la localisation d'un panneau.   *
+*                                                                             *
+*  Retour      : Chemin fixé associé à la position initiale.                  *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
 
+static char *g_bookmarks_panel_class_get_path(const GBookmarksPanelClass *class)
+{
+    char *result;                           /* Emplacement à retourner     */
 
+    result = strdup("Ms");
 
     return result;
 
@@ -374,21 +389,21 @@ GPanelItem *g_bookmarks_panel_new(void)
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : panel = instance à consulter.                                *
+*  Paramètres  : -                                                            *
 *                                                                             *
-*  Description : Fournit le nom interne attribué à l'élément réactif.         *
+*  Description : Crée un panneau d'affichage des paramètres de configuration. *
 *                                                                             *
-*  Retour      : Désignation (courte) de l'élément de l'éditeur.              *
+*  Retour      : Adresse de la structure mise en place.                       *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-static char *g_bookmarks_panel_get_key(const GBookmarksPanel *panel)
+GPanelItem *g_bookmarks_panel_new(void)
 {
-    char *result;                           /* Description à renvoyer      */
+    GPanelItem *result;                     /* Structure à retourner       */
 
-    result = strdup(PANEL_BOOKMARKS_ID);
+    result = g_object_new(G_TYPE_BOOKMARKS_PANEL, NULL);
 
     return result;
 
diff --git a/src/gui/panels/errors.c b/src/gui/panels/errors.c
index 905d87c..d567511 100644
--- a/src/gui/panels/errors.c
+++ b/src/gui/panels/errors.c
@@ -137,7 +137,10 @@ static void g_error_panel_dispose(GErrorPanel *);
 static void g_error_panel_finalize(GErrorPanel *);
 
 /* Fournit le nom interne attribué à l'élément réactif. */
-static char *g_error_panel_get_key(const GErrorPanel *);
+static char *g_error_panel_class_get_key(const GErrorPanelClass *);
+
+/* Indique le chemin initial de la localisation d'un panneau. */
+static char *g_error_panel_class_get_path(const GErrorPanelClass *);
 
 /* Organise le tri des erreurs présentées. */
 static gint sort_errors_in_panel(GtkTreeModel *, GtkTreeIter *, GtkTreeIter *, gpointer);
@@ -200,7 +203,7 @@ G_DEFINE_TYPE_WITH_CODE(GErrorPanel, g_error_panel, G_TYPE_PANEL_ITEM,
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : klass = classe à initialiser.                                *
+*  Paramètres  : class = classe à initialiser.                                *
 *                                                                             *
 *  Description : Initialise la classe des panneaux d'affichage des erreurs.   *
 *                                                                             *
@@ -210,47 +213,47 @@ G_DEFINE_TYPE_WITH_CODE(GErrorPanel, g_error_panel, G_TYPE_PANEL_ITEM,
 *                                                                             *
 ******************************************************************************/
 
-static void g_error_panel_class_init(GErrorPanelClass *klass)
+static void g_error_panel_class_init(GErrorPanelClass *class)
 {
     GObjectClass *object;                   /* Autre version de la classe  */
     GEditorItemClass *item;                 /* Encore une autre vision...  */
-    gchar *filename;                        /* Chemin d'accès à utiliser   */
     GPanelItemClass *panel;                 /* Version parente de la classe*/
+    gchar *filename;                        /* Chemin d'accès à utiliser   */
 
-    object = G_OBJECT_CLASS(klass);
+    object = G_OBJECT_CLASS(class);
 
     object->dispose = (GObjectFinalizeFunc/* ! */)g_error_panel_dispose;
     object->finalize = (GObjectFinalizeFunc)g_error_panel_finalize;
 
-    item = G_EDITOR_ITEM_CLASS(klass);
+    item = G_EDITOR_ITEM_CLASS(class);
 
-    item->get_key = (get_item_key_fc)g_error_panel_get_key;
+    item->get_key = (get_item_key_fc)g_error_panel_class_get_key;
 
     item->change_content = (change_item_content_fc)change_error_panel_current_content;
 
+    panel = G_PANEL_ITEM_CLASS(class);
+
+    panel->get_path = (get_panel_path_fc)g_error_panel_class_get_path;
+
+    panel->gid = setup_tiny_global_work_group(1);
+
     filename = find_pixmap_file("error_file.png");
     assert(filename != NULL);
 
-    klass->format_img = cairo_image_surface_create_from_png(filename);
+    class->format_img = cairo_image_surface_create_from_png(filename);
 
     filename = find_pixmap_file("error_cpu.png");
     assert(filename != NULL);
 
-    klass->disass_img = cairo_image_surface_create_from_png(filename);
+    class->disass_img = cairo_image_surface_create_from_png(filename);
 
     filename = find_pixmap_file("error_display.png");
     assert(filename != NULL);
 
-    klass->output_img = cairo_image_surface_create_from_png(filename);
+    class->output_img = cairo_image_surface_create_from_png(filename);
 
     g_free(filename);
 
-    panel = G_PANEL_ITEM_CLASS(klass);
-
-    panel->unique = true;
-
-    panel->gid = setup_tiny_global_work_group(1);
-
 }
 
 
@@ -280,15 +283,10 @@ static void g_error_panel_init(GErrorPanel *panel)
 
     pitem = G_PANEL_ITEM(panel);
 
-    pitem->personality = PIP_SINGLETON;
-
     pitem->widget = G_NAMED_WIDGET(gtk_built_named_widget_new_for_panel(_("Errors"),
                                                                         _("Disassembling errors"),
                                                                         PANEL_ERRORS_ID));
 
-    pitem->dock_at_startup = true;
-    pitem->path = strdup("Ms");
-
     /* Compléments propres */
 
     panel->binary = NULL;
@@ -417,44 +415,67 @@ static void g_error_panel_finalize(GErrorPanel *panel)
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : -                                                            *
+*  Paramètres  : class = classe à consulter.                                  *
 *                                                                             *
-*  Description : Crée un panneau présentant la liste des erreurs rencontrées. *
+*  Description : Fournit le nom interne attribué à l'élément réactif.         *
 *                                                                             *
-*  Retour      : Adresse de la structure mise en place.                       *
+*  Retour      : Désignation (courte) de l'élément de l'éditeur.              *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-GPanelItem *g_error_panel_new(void)
+static char *g_error_panel_class_get_key(const GErrorPanelClass *class)
 {
-    GErrorPanel *result;                    /* Structure à retourner       */
+    char *result;                           /* Description à renvoyer      */
 
-    result = g_object_new(G_TYPE_ERROR_PANEL, NULL);
+    result = strdup(PANEL_ERRORS_ID);
 
-    return G_PANEL_ITEM(result);
+    return result;
 
 }
 
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : panel = instance à consulter.                                *
+*  Paramètres  : class = classe à consulter.                                  *
 *                                                                             *
-*  Description : Fournit le nom interne attribué à l'élément réactif.         *
+*  Description : Indique le chemin initial de la localisation d'un panneau.   *
 *                                                                             *
-*  Retour      : Désignation (courte) de l'élément de l'éditeur.              *
+*  Retour      : Chemin fixé associé à la position initiale.                  *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-static char *g_error_panel_get_key(const GErrorPanel *panel)
+static char *g_error_panel_class_get_path(const GErrorPanelClass *class)
 {
-    char *result;                           /* Description à renvoyer      */
+    char *result;                           /* Emplacement à retourner     */
 
-    result = strdup(PANEL_ERRORS_ID);
+    result = strdup("Ms");
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : -                                                            *
+*                                                                             *
+*  Description : Crée un panneau présentant la liste des erreurs rencontrées. *
+*                                                                             *
+*  Retour      : Adresse de la structure mise en place.                       *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GPanelItem *g_error_panel_new(void)
+{
+    GPanelItem *result;                     /* Structure à retourner       */
+
+    result = g_object_new(G_TYPE_ERROR_PANEL, NULL);
 
     return result;
 
diff --git a/src/gui/panels/glance.c b/src/gui/panels/glance.c
index 22d4890..9be8b63 100644
--- a/src/gui/panels/glance.c
+++ b/src/gui/panels/glance.c
@@ -89,7 +89,10 @@ static void g_glance_panel_dispose(GGlancePanel *);
 static void g_glance_panel_finalize(GGlancePanel *);
 
 /* Fournit le nom interne attribué à l'élément réactif. */
-static char *g_glance_panel_get_key(const GGlancePanel *);
+static char *g_glance_panel_class_get_key(const GGlancePanelClass *);
+
+/* Indique le chemin initial de la localisation d'un panneau. */
+static char *g_glance_panel_class_get_path(const GGlancePanelClass *);
 
 /* Lance une actualisation du fait d'un changement de support. */
 static void change_glance_panel_current_view(GGlancePanel *, GLoadedPanel *, GLoadedPanel *);
@@ -129,7 +132,7 @@ G_DEFINE_TYPE(GGlancePanel, g_glance_panel, G_TYPE_PANEL_ITEM);
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : klass = classe à initialiser.                                *
+*  Paramètres  : class = classe à initialiser.                                *
 *                                                                             *
 *  Description : Initialise la classe des panneaux d'aperçu rapide.           *
 *                                                                             *
@@ -139,29 +142,34 @@ G_DEFINE_TYPE(GGlancePanel, g_glance_panel, G_TYPE_PANEL_ITEM);
 *                                                                             *
 ******************************************************************************/
 
-static void g_glance_panel_class_init(GGlancePanelClass *klass)
+static void g_glance_panel_class_init(GGlancePanelClass *class)
 {
     GObjectClass *object;                   /* Autre version de la classe  */
     GEditorItemClass *item;                 /* Encore une autre vision...  */
+    GPanelItemClass *panel;                 /* Version parente de la classe*/
     GtkIconTheme *theme;                    /* Thème GTK offrant des icones*/
 
-    object = G_OBJECT_CLASS(klass);
+    object = G_OBJECT_CLASS(class);
 
     object->dispose = (GObjectFinalizeFunc/* ! */)g_glance_panel_dispose;
     object->finalize = (GObjectFinalizeFunc)g_glance_panel_finalize;
 
-    item = G_EDITOR_ITEM_CLASS(klass);
+    item = G_EDITOR_ITEM_CLASS(class);
 
-    item->get_key = (get_item_key_fc)g_glance_panel_get_key;
+    item->get_key = (get_item_key_fc)g_glance_panel_class_get_key;
 
     item->change_view = (change_item_view_fc)change_glance_panel_current_view;
     item->update_view = (update_item_view_fc)update_glance_panel_view;
 
+    panel = G_PANEL_ITEM_CLASS(class);
+
+    panel->get_path = (get_panel_path_fc)g_glance_panel_class_get_path;
+
     theme = gtk_icon_theme_get_default();
 
-    klass->no_image_32 = gtk_icon_theme_lookup_icon(theme, "image-missing", 32, GTK_ICON_LOOKUP_FORCE_SIZE);
-    klass->no_image_64 = gtk_icon_theme_lookup_icon(theme, "image-missing", 64, GTK_ICON_LOOKUP_FORCE_SIZE);
-    klass->no_image_128 = gtk_icon_theme_lookup_icon(theme, "image-missing", 128, GTK_ICON_LOOKUP_FORCE_SIZE);
+    class->no_image_32 = gtk_icon_theme_lookup_icon(theme, "image-missing", 32, GTK_ICON_LOOKUP_FORCE_SIZE);
+    class->no_image_64 = gtk_icon_theme_lookup_icon(theme, "image-missing", 64, GTK_ICON_LOOKUP_FORCE_SIZE);
+    class->no_image_128 = gtk_icon_theme_lookup_icon(theme, "image-missing", 128, GTK_ICON_LOOKUP_FORCE_SIZE);
 
 }
 
@@ -187,15 +195,10 @@ static void g_glance_panel_init(GGlancePanel *panel)
 
     pitem = G_PANEL_ITEM(panel);
 
-    pitem->personality = PIP_SINGLETON;
-
     pitem->widget = G_NAMED_WIDGET(gtk_built_named_widget_new_for_panel(_("Glance"),
                                                                         _("Glimpse of the display content"),
                                                                         PANEL_GLANCE_ID));
 
-    pitem->dock_at_startup = true;
-    pitem->path = strdup("MEs");
-
     /* Représentation graphique */
 
     builder = gtk_built_named_widget_get_builder(GTK_BUILT_NAMED_WIDGET(pitem->widget));
@@ -260,21 +263,21 @@ static void g_glance_panel_finalize(GGlancePanel *panel)
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : -                                                            *
+*  Paramètres  : class = classe à consulter.                                  *
 *                                                                             *
-*  Description : Crée un panneau d'aperçu rapide.                             *
+*  Description : Fournit le nom interne attribué à l'élément réactif.         *
 *                                                                             *
-*  Retour      : Adresse de la structure mise en place.                       *
+*  Retour      : Désignation (courte) de l'élément de l'éditeur.              *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-GPanelItem *g_glance_panel_new(void)
+static char *g_glance_panel_class_get_key(const GGlancePanelClass *class)
 {
-    GPanelItem *result;                     /* Structure à retourner       */
+    char *result;                           /* Description à renvoyer      */
 
-    result = g_object_new(G_TYPE_GLANCE_PANEL, NULL);
+    result = strdup(PANEL_GLANCE_ID);
 
     return result;
 
@@ -283,21 +286,44 @@ GPanelItem *g_glance_panel_new(void)
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : panel = instance à consulter.                                *
+*  Paramètres  : class = classe à consulter.                                  *
 *                                                                             *
-*  Description : Fournit le nom interne attribué à l'élément réactif.         *
+*  Description : Indique le chemin initial de la localisation d'un panneau.   *
 *                                                                             *
-*  Retour      : Désignation (courte) de l'élément de l'éditeur.              *
+*  Retour      : Chemin fixé associé à la position initiale.                  *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-static char *g_glance_panel_get_key(const GGlancePanel *panel)
+static char *g_glance_panel_class_get_path(const GGlancePanelClass *class)
 {
-    char *result;                           /* Description à renvoyer      */
+    char *result;                           /* Emplacement à retourner     */
 
-    result = strdup(PANEL_GLANCE_ID);
+    result = strdup("MEs");
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : -                                                            *
+*                                                                             *
+*  Description : Crée un panneau d'aperçu rapide.                             *
+*                                                                             *
+*  Retour      : Adresse de la structure mise en place.                       *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GPanelItem *g_glance_panel_new(void)
+{
+    GPanelItem *result;                     /* Structure à retourner       */
+
+    result = g_object_new(G_TYPE_GLANCE_PANEL, NULL);
 
     return result;
 
diff --git a/src/gui/panels/history.c b/src/gui/panels/history.c
index 320babb..79be0dd 100644
--- a/src/gui/panels/history.c
+++ b/src/gui/panels/history.c
@@ -85,7 +85,10 @@ static void g_history_panel_dispose(GHistoryPanel *);
 static void g_history_panel_finalize(GHistoryPanel *);
 
 /* Fournit le nom interne attribué à l'élément réactif. */
-static char *g_history_panel_get_key(const GHistoryPanel *);
+static char *g_history_panel_class_get_key(const GHistoryPanelClass *);
+
+/* Indique le chemin initial de la localisation d'un panneau. */
+static char *g_history_panel_class_get_path(const GHistoryPanelClass *);
 
 /* Réagit à un changement d'affichage principal de contenu. */
 static void change_history_panel_current_content(GHistoryPanel *, GLoadedContent *, GLoadedContent *);
@@ -116,7 +119,7 @@ G_DEFINE_TYPE(GHistoryPanel, g_history_panel, G_TYPE_PANEL_ITEM);
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : klass = classe à initialiser.                                *
+*  Paramètres  : class = classe à initialiser.                                *
 *                                                                             *
 *  Description : Initialise la classe des panneaux d'aperçu de graphiques.    *
 *                                                                             *
@@ -126,22 +129,27 @@ G_DEFINE_TYPE(GHistoryPanel, g_history_panel, G_TYPE_PANEL_ITEM);
 *                                                                             *
 ******************************************************************************/
 
-static void g_history_panel_class_init(GHistoryPanelClass *klass)
+static void g_history_panel_class_init(GHistoryPanelClass *class)
 {
     GObjectClass *object;                   /* Autre version de la classe  */
     GEditorItemClass *item;                 /* Encore une autre vision...  */
+    GPanelItemClass *panel;                 /* Version parente de la classe*/
 
-    object = G_OBJECT_CLASS(klass);
+    object = G_OBJECT_CLASS(class);
 
     object->dispose = (GObjectFinalizeFunc/* ! */)g_history_panel_dispose;
     object->finalize = (GObjectFinalizeFunc)g_history_panel_finalize;
 
-    item = G_EDITOR_ITEM_CLASS(klass);
+    item = G_EDITOR_ITEM_CLASS(class);
 
-    item->get_key = (get_item_key_fc)g_history_panel_get_key;
+    item->get_key = (get_item_key_fc)g_history_panel_class_get_key;
 
     item->change_content = (change_item_content_fc)change_history_panel_current_content;
 
+    panel = G_PANEL_ITEM_CLASS(class);
+
+    panel->get_path = (get_panel_path_fc)g_history_panel_class_get_path;
+
 }
 
 
@@ -167,15 +175,10 @@ static void g_history_panel_init(GHistoryPanel *panel)
 
     pitem = G_PANEL_ITEM(panel);
 
-    pitem->personality = PIP_SINGLETON;
-
     pitem->widget = G_NAMED_WIDGET(gtk_built_named_widget_new_for_panel(_("History"),
                                                                         _("Change history"),
                                                                         PANEL_HISTORY_ID));
 
-    pitem->dock_at_startup = true;
-    pitem->path = strdup("MEN");
-
     /* Représentation graphique */
 
     builder = gtk_built_named_widget_get_builder(GTK_BUILT_NAMED_WIDGET(pitem->widget));
@@ -242,21 +245,21 @@ static void g_history_panel_finalize(GHistoryPanel *panel)
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : -                                                            *
+*  Paramètres  : class = classe à consulter.                                  *
 *                                                                             *
-*  Description : Crée un panneau d'affichage des symboles.                    *
+*  Description : Fournit le nom interne attribué à l'élément réactif.         *
 *                                                                             *
-*  Retour      : Adresse de la structure mise en place.                       *
+*  Retour      : Désignation (courte) de l'élément de l'éditeur.              *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-GPanelItem *g_history_panel_new(void)
+static char *g_history_panel_class_get_key(const GHistoryPanelClass *class)
 {
-    GPanelItem *result;                     /* Structure à retourner       */
+    char *result;                           /* Description à renvoyer      */
 
-    result = g_object_new(G_TYPE_HISTORY_PANEL, NULL);
+    result = strdup(PANEL_HISTORY_ID);
 
     return result;
 
@@ -265,21 +268,44 @@ GPanelItem *g_history_panel_new(void)
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : panel = instance à consulter.                                *
+*  Paramètres  : class = classe à consulter.                                  *
 *                                                                             *
-*  Description : Fournit le nom interne attribué à l'élément réactif.         *
+*  Description : Indique le chemin initial de la localisation d'un panneau.   *
 *                                                                             *
-*  Retour      : Désignation (courte) de l'élément de l'éditeur.              *
+*  Retour      : Chemin fixé associé à la position initiale.                  *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-static char *g_history_panel_get_key(const GHistoryPanel *panel)
+static char *g_history_panel_class_get_path(const GHistoryPanelClass *class)
 {
-    char *result;                           /* Description à renvoyer      */
+    char *result;                           /* Emplacement à retourner     */
 
-    result = strdup(PANEL_HISTORY_ID);
+    result = strdup("MEN");
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : -                                                            *
+*                                                                             *
+*  Description : Crée un panneau d'affichage des symboles.                    *
+*                                                                             *
+*  Retour      : Adresse de la structure mise en place.                       *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GPanelItem *g_history_panel_new(void)
+{
+    GPanelItem *result;                     /* Structure à retourner       */
+
+    result = g_object_new(G_TYPE_HISTORY_PANEL, NULL);
 
     return result;
 
diff --git a/src/gui/panels/log.c b/src/gui/panels/log.c
index 43021cf..d11fbd2 100644
--- a/src/gui/panels/log.c
+++ b/src/gui/panels/log.c
@@ -89,7 +89,16 @@ static void g_log_panel_dispose(GLogPanel *);
 static void g_log_panel_finalize(GLogPanel *);
 
 /* Fournit le nom interne attribué à l'élément réactif. */
-static char *g_log_panel_get_key(const GLogPanel *);
+static char *g_log_panel_class_get_key(const GLogPanelClass *);
+
+/* Fournit une indication sur la personnalité du panneau. */
+static PanelItemPersonality g_log_panel_class_get_personality(const GLogPanelClass *);
+
+/* Indique le chemin initial de la localisation d'un panneau. */
+static char *g_log_panel_class_get_path(const GLogPanelClass *);
+
+/* Indique la définition d'un éventuel raccourci clavier. */
+static char *g_log_panel_class_get_key_bindings(const GLogPanelClass *);
 
 /* Affiche un message dans le journal des messages système. */
 static gboolean log_message(log_data *);
@@ -102,7 +111,7 @@ G_DEFINE_TYPE(GLogPanel, g_log_panel, G_TYPE_PANEL_ITEM);
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : klass = classe à initialiser.                                *
+*  Paramètres  : class = classe à initialiser.                                *
 *                                                                             *
 *  Description : Initialise la classe des panneaux d'affichage des messages.  *
 *                                                                             *
@@ -112,25 +121,26 @@ G_DEFINE_TYPE(GLogPanel, g_log_panel, G_TYPE_PANEL_ITEM);
 *                                                                             *
 ******************************************************************************/
 
-static void g_log_panel_class_init(GLogPanelClass *klass)
+static void g_log_panel_class_init(GLogPanelClass *class)
 {
     GObjectClass *object;                   /* Autre version de la classe  */
     GEditorItemClass *item;                 /* Encore une autre vision...  */
     GPanelItemClass *panel;                 /* Version parente de la classe*/
 
-    object = G_OBJECT_CLASS(klass);
+    object = G_OBJECT_CLASS(class);
 
     object->dispose = (GObjectFinalizeFunc/* ! */)g_log_panel_dispose;
     object->finalize = (GObjectFinalizeFunc)g_log_panel_finalize;
 
-    item = G_EDITOR_ITEM_CLASS(klass);
+    item = G_EDITOR_ITEM_CLASS(class);
 
-    item->get_key = (get_item_key_fc)g_log_panel_get_key;
+    item->get_key = (get_item_key_fc)g_log_panel_class_get_key;
 
-    panel = G_PANEL_ITEM_CLASS(klass);
+    panel = G_PANEL_ITEM_CLASS(class);
 
-    panel->unique = true;
-    panel->bindings = "<Shift>F1";
+    panel->get_personality = (get_panel_personality_fc)g_log_panel_class_get_personality;
+    panel->get_path = (get_panel_path_fc)g_log_panel_class_get_path;
+    panel->get_bindings = (get_panel_bindings_fc)g_log_panel_class_get_key_bindings;
 
 }
 
@@ -155,15 +165,10 @@ static void g_log_panel_init(GLogPanel *panel)
 
     pitem = G_PANEL_ITEM(panel);
 
-    pitem->personality = PIP_SINGLETON;
-
     pitem->widget = G_NAMED_WIDGET(gtk_built_named_widget_new_for_panel(_("Messages"),
                                                                         _("Misc information"),
                                                                         PANEL_LOG_ID));
 
-    pitem->dock_at_startup = true;
-    pitem->path = strdup("Ms");
-
 }
 
 
@@ -207,21 +212,21 @@ static void g_log_panel_finalize(GLogPanel *panel)
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : -                                                            *
+*  Paramètres  : class = classe à consulter.                                  *
 *                                                                             *
-*  Description : Crée un panneau d'affichage des messages système.            *
+*  Description : Fournit le nom interne attribué à l'élément réactif.         *
 *                                                                             *
-*  Retour      : Adresse de la structure mise en place.                       *
+*  Retour      : Désignation (courte) de l'élément de l'éditeur.              *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-GPanelItem *g_log_panel_new(void)
+static char *g_log_panel_class_get_key(const GLogPanelClass *class)
 {
-    GPanelItem *result;                     /* Structure à retourner       */
+    char *result;                           /* Description à renvoyer      */
 
-    result = g_object_new(G_TYPE_LOG_PANEL, NULL);
+    result = strdup(PANEL_LOG_ID);
 
     return result;
 
@@ -230,21 +235,90 @@ GPanelItem *g_log_panel_new(void)
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : panel = instance à consulter.                                *
+*  Paramètres  : class = classe à consulter.                                  *
 *                                                                             *
-*  Description : Fournit le nom interne attribué à l'élément réactif.         *
+*  Description : Fournit une indication sur la personnalité du panneau.       *
 *                                                                             *
-*  Retour      : Désignation (courte) de l'élément de l'éditeur.              *
+*  Retour      : Identifiant lié à la nature unique du panneau.               *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-static char *g_log_panel_get_key(const GLogPanel *panel)
+static PanelItemPersonality g_log_panel_class_get_personality(const GLogPanelClass *class)
 {
-    char *result;                           /* Description à renvoyer      */
+    PanelItemPersonality result;            /* Personnalité à retourner    */
 
-    result = strdup(PANEL_LOG_ID);
+    result = PIP_PERSISTENT_SINGLETON;
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : class = classe à consulter.                                  *
+*                                                                             *
+*  Description : Indique le chemin initial de la localisation d'un panneau.   *
+*                                                                             *
+*  Retour      : Chemin fixé associé à la position initiale.                  *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static char *g_log_panel_class_get_path(const GLogPanelClass *class)
+{
+    char *result;                           /* Emplacement à retourner     */
+
+    result = strdup("Ms");
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : class = classe à consulter.                                  *
+*                                                                             *
+*  Description : Indique la définition d'un éventuel raccourci clavier.       *
+*                                                                             *
+*  Retour      : Description d'un raccourci ou NULL si aucun de défini.       *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static char *g_log_panel_class_get_key_bindings(const GLogPanelClass *class)
+{
+    char *result;                           /* Emplacement à retourner     */
+
+    result = strdup("<Shift>F1");
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : -                                                            *
+*                                                                             *
+*  Description : Crée un panneau d'affichage des messages système.            *
+*                                                                             *
+*  Retour      : Adresse de la structure mise en place.                       *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GPanelItem *g_log_panel_new(void)
+{
+    GPanelItem *result;                     /* Structure à retourner       */
+
+    result = g_object_new(G_TYPE_LOG_PANEL, NULL);
 
     return result;
 
diff --git a/src/gui/panels/regedit.c b/src/gui/panels/regedit.c
index 906d274..585cc22 100644
--- a/src/gui/panels/regedit.c
+++ b/src/gui/panels/regedit.c
@@ -98,7 +98,10 @@ static void g_regedit_panel_dispose(GRegeditPanel *);
 static void g_regedit_panel_finalize(GRegeditPanel *);
 
 /* Fournit le nom interne attribué à l'élément réactif. */
-static char *g_regedit_panel_get_key(const GRegeditPanel *);
+static char *g_regedit_panel_class_get_key(const GRegeditPanelClass *);
+
+/* Indique le chemin initial de la localisation d'un panneau. */
+static char *g_regedit_panel_class_get_path(const GRegeditPanelClass *);
 
 
 
@@ -170,7 +173,7 @@ G_DEFINE_TYPE(GRegeditPanel, g_regedit_panel, G_TYPE_PANEL_ITEM);
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : klass = classe à initialiser.                                *
+*  Paramètres  : class = classe à initialiser.                                *
 *                                                                             *
 *  Description : Initialise la classe des panneaux des paramètres de config.  *
 *                                                                             *
@@ -180,19 +183,25 @@ G_DEFINE_TYPE(GRegeditPanel, g_regedit_panel, G_TYPE_PANEL_ITEM);
 *                                                                             *
 ******************************************************************************/
 
-static void g_regedit_panel_class_init(GRegeditPanelClass *klass)
+static void g_regedit_panel_class_init(GRegeditPanelClass *class)
 {
     GObjectClass *object;                   /* Autre version de la classe  */
     GEditorItemClass *item;                 /* Encore une autre vision...  */
+    GPanelItemClass *panel;                 /* Version parente de la classe*/
 
-    object = G_OBJECT_CLASS(klass);
+    object = G_OBJECT_CLASS(class);
 
     object->dispose = (GObjectFinalizeFunc/* ! */)g_regedit_panel_dispose;
     object->finalize = (GObjectFinalizeFunc)g_regedit_panel_finalize;
 
-    item = G_EDITOR_ITEM_CLASS(klass);
+    item = G_EDITOR_ITEM_CLASS(class);
+
+    item->get_key = (get_item_key_fc)g_regedit_panel_class_get_key;
+
+    panel = G_PANEL_ITEM_CLASS(class);
 
-    item->get_key = (get_item_key_fc)g_regedit_panel_get_key;
+    panel->dock_at_startup = gtk_panel_item_class_return_false;
+    panel->get_path = (get_panel_path_fc)g_regedit_panel_class_get_path;
 
 }
 
@@ -220,15 +229,10 @@ static void g_regedit_panel_init(GRegeditPanel *panel)
 
     pitem = G_PANEL_ITEM(panel);
 
-    pitem->personality = PIP_SINGLETON;
-
     pitem->widget = G_NAMED_WIDGET(gtk_built_named_widget_new_for_panel(_("Configuration"),
                                                                         _("Configuration parameters"),
                                                                         PANEL_REGEDIT_ID));
 
-    pitem->dock_at_startup = false;
-    pitem->path = strdup("M");
-
     /* Représentation graphique */
 
     builder = gtk_built_named_widget_get_builder(GTK_BUILT_NAMED_WIDGET(pitem->widget));
@@ -273,6 +277,10 @@ static void g_regedit_panel_init(GRegeditPanel *panel)
 
     g_object_unref(G_OBJECT(builder));
 
+    /* Actualisation du contenu du panneau */
+
+    reload_config_into_treeview(panel, get_main_configuration());
+
 }
 
 
@@ -322,23 +330,44 @@ static void g_regedit_panel_finalize(GRegeditPanel *panel)
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : -                                                            *
+*  Paramètres  : class = classe à consulter.                                  *
 *                                                                             *
-*  Description : Crée un panneau d'affichage des paramètres de configuration. *
+*  Description : Fournit le nom interne attribué à l'élément réactif.         *
 *                                                                             *
-*  Retour      : Adresse de la structure mise en place.                       *
+*  Retour      : Désignation (courte) de l'élément de l'éditeur.              *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-GPanelItem *g_regedit_panel_new(void)
+static char *g_regedit_panel_class_get_key(const GRegeditPanelClass *class)
 {
-    GPanelItem *result;                     /* Structure à retourner       */
+    char *result;                           /* Description à renvoyer      */
 
-    result = g_object_new(G_TYPE_REGEDIT_PANEL, NULL);
+    result = strdup(PANEL_REGEDIT_ID);
+
+    return result;
+
+}
 
-    reload_config_into_treeview(G_REGEDIT_PANEL(result), get_main_configuration());
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : class = classe à consulter.                                  *
+*                                                                             *
+*  Description : Indique le chemin initial de la localisation d'un panneau.   *
+*                                                                             *
+*  Retour      : Chemin fixé associé à la position initiale.                  *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static char *g_regedit_panel_class_get_path(const GRegeditPanelClass *class)
+{
+    char *result;                           /* Emplacement à retourner     */
+
+    result = strdup("M");
 
     return result;
 
@@ -347,21 +376,21 @@ GPanelItem *g_regedit_panel_new(void)
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : panel = instance à consulter.                                *
+*  Paramètres  : -                                                            *
 *                                                                             *
-*  Description : Fournit le nom interne attribué à l'élément réactif.         *
+*  Description : Crée un panneau d'affichage des paramètres de configuration. *
 *                                                                             *
-*  Retour      : Désignation (courte) de l'élément de l'éditeur.              *
+*  Retour      : Adresse de la structure mise en place.                       *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-static char *g_regedit_panel_get_key(const GRegeditPanel *panel)
+GPanelItem *g_regedit_panel_new(void)
 {
-    char *result;                           /* Description à renvoyer      */
+    GPanelItem *result;                     /* Structure à retourner       */
 
-    result = strdup(PANEL_REGEDIT_ID);
+    result = g_object_new(G_TYPE_REGEDIT_PANEL, NULL);
 
     return result;
 
diff --git a/src/gui/panels/strings.c b/src/gui/panels/strings.c
index 1ad7e8e..33b715b 100644
--- a/src/gui/panels/strings.c
+++ b/src/gui/panels/strings.c
@@ -113,7 +113,13 @@ static void g_strings_panel_dispose(GStringsPanel *);
 static void g_strings_panel_finalize(GStringsPanel *);
 
 /* Fournit le nom interne attribué à l'élément réactif. */
-static char *g_strings_panel_get_key(const GStringsPanel *);
+static char *g_strings_panel_class_get_key(const GStringsPanelClass *);
+
+/* Indique le chemin initial de la localisation d'un panneau. */
+static char *g_strings_panel_class_get_path(const GStringsPanelClass *);
+
+/* Indique la définition d'un éventuel raccourci clavier. */
+static char *g_strings_panel_class_get_key_bindings(const GStringsPanelClass *);
 
 /* Réagit au changement de sélection des chaînes textuelles. */
 static void on_strings_selection_change(GtkTreeSelection *, gpointer);
@@ -233,7 +239,7 @@ G_DEFINE_TYPE_WITH_CODE(GStringsPanel, g_strings_panel, G_TYPE_PANEL_ITEM,
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : klass = classe à initialiser.                                *
+*  Paramètres  : class = classe à initialiser.                                *
 *                                                                             *
 *  Description : Initialise la classe des panneaux d'affichage de chaînes.    *
 *                                                                             *
@@ -243,29 +249,29 @@ G_DEFINE_TYPE_WITH_CODE(GStringsPanel, g_strings_panel, G_TYPE_PANEL_ITEM,
 *                                                                             *
 ******************************************************************************/
 
-static void g_strings_panel_class_init(GStringsPanelClass *klass)
+static void g_strings_panel_class_init(GStringsPanelClass *class)
 {
     GObjectClass *object;                   /* Autre version de la classe  */
     GEditorItemClass *item;                 /* Encore une autre vision...  */
     GPanelItemClass *panel;                 /* Version parente de la classe*/
 
-    object = G_OBJECT_CLASS(klass);
+    object = G_OBJECT_CLASS(class);
 
     object->dispose = (GObjectFinalizeFunc/* ! */)g_strings_panel_dispose;
     object->finalize = (GObjectFinalizeFunc)g_strings_panel_finalize;
 
-    item = G_EDITOR_ITEM_CLASS(klass);
+    item = G_EDITOR_ITEM_CLASS(class);
 
-    item->get_key = (get_item_key_fc)g_strings_panel_get_key;
+    item->get_key = (get_item_key_fc)g_strings_panel_class_get_key;
 
     item->change_content = (change_item_content_fc)change_strings_panel_current_content;
 
-    panel = G_PANEL_ITEM_CLASS(klass);
+    panel = G_PANEL_ITEM_CLASS(class);
 
-    panel->unique = true;
-    panel->bindings = "<Shift>F12";
-
-    panel->can_search = true;
+    panel->dock_at_startup = gtk_panel_item_class_return_false;
+    panel->can_search = gtk_panel_item_class_return_true;
+    panel->get_path = (get_panel_path_fc)g_strings_panel_class_get_path;
+    panel->get_bindings = (get_panel_bindings_fc)g_strings_panel_class_get_key_bindings;
 
     panel->update_filtered = (update_filtered_fc)update_filtered_strings;
 
@@ -301,15 +307,10 @@ static void g_strings_panel_init(GStringsPanel *panel)
 
     pitem = G_PANEL_ITEM(panel);
 
-    pitem->personality = PIP_SINGLETON;
-
     pitem->widget = G_NAMED_WIDGET(gtk_built_named_widget_new_for_panel(_("Strings"),
                                                                         _("Strings contained in the binary"),
                                                                         PANEL_STRINGS_ID));
 
-    pitem->dock_at_startup = false;
-    pitem->path = strdup("Ms");
-
     /* Représentation graphique */
 
     builder = gtk_built_named_widget_get_builder(GTK_BUILT_NAMED_WIDGET(pitem->widget));
@@ -468,21 +469,21 @@ static void g_strings_panel_finalize(GStringsPanel *panel)
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : -                                                            *
+*  Paramètres  : class = classe à consulter.                                  *
 *                                                                             *
-*  Description : Crée un panneau d'affichage des chaînes.                     *
+*  Description : Fournit le nom interne attribué à l'élément réactif.         *
 *                                                                             *
-*  Retour      : Adresse de la structure mise en place.                       *
+*  Retour      : Désignation (courte) de l'élément de l'éditeur.              *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-GPanelItem *g_strings_panel_new(void)
+static char *g_strings_panel_class_get_key(const GStringsPanelClass *class)
 {
-    GPanelItem *result;                     /* Structure à retourner       */
+    char *result;                           /* Description à renvoyer      */
 
-    result = g_object_new(G_TYPE_STRINGS_PANEL, NULL);
+    result = strdup(PANEL_STRINGS_ID);
 
     return result;
 
@@ -491,21 +492,67 @@ GPanelItem *g_strings_panel_new(void)
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : panel = instance à consulter.                                *
+*  Paramètres  : class = classe à consulter.                                  *
 *                                                                             *
-*  Description : Fournit le nom interne attribué à l'élément réactif.         *
+*  Description : Indique le chemin initial de la localisation d'un panneau.   *
 *                                                                             *
-*  Retour      : Désignation (courte) de l'élément de l'éditeur.              *
+*  Retour      : Chemin fixé associé à la position initiale.                  *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-static char *g_strings_panel_get_key(const GStringsPanel *panel)
+static char *g_strings_panel_class_get_path(const GStringsPanelClass *class)
 {
-    char *result;                           /* Description à renvoyer      */
+    char *result;                           /* Emplacement à retourner     */
 
-    result = strdup(PANEL_STRINGS_ID);
+    result = strdup("Ms");
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : class = classe à consulter.                                  *
+*                                                                             *
+*  Description : Indique la définition d'un éventuel raccourci clavier.       *
+*                                                                             *
+*  Retour      : Description d'un raccourci ou NULL si aucun de défini.       *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static char *g_strings_panel_class_get_key_bindings(const GStringsPanelClass *class)
+{
+    char *result;                           /* Emplacement à retourner     */
+
+    result = strdup("<Shift>F12");
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : -                                                            *
+*                                                                             *
+*  Description : Crée un panneau d'affichage des chaînes.                     *
+*                                                                             *
+*  Retour      : Adresse de la structure mise en place.                       *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GPanelItem *g_strings_panel_new(void)
+{
+    GPanelItem *result;                     /* Structure à retourner       */
+
+    result = g_object_new(G_TYPE_STRINGS_PANEL, NULL);
 
     return result;
 
diff --git a/src/gui/panels/symbols.c b/src/gui/panels/symbols.c
index ec554ff..152d705 100644
--- a/src/gui/panels/symbols.c
+++ b/src/gui/panels/symbols.c
@@ -121,7 +121,13 @@ static void g_symbols_panel_dispose(GSymbolsPanel *);
 static void g_symbols_panel_finalize(GSymbolsPanel *);
 
 /* Fournit le nom interne attribué à l'élément réactif. */
-static char *g_symbols_panel_get_key(const GSymbolsPanel *);
+static char *g_symbols_panel_class_get_key(const GSymbolsPanelClass *);
+
+/* Indique le chemin initial de la localisation d'un panneau. */
+static char *g_symbols_panel_class_get_path(const GSymbolsPanelClass *);
+
+/* Indique la définition d'un éventuel raccourci clavier. */
+static char *g_symbols_panel_class_get_key_bindings(const GSymbolsPanelClass *);
 
 /* Bascule d'affichage des symboles en liste. */
 static void on_symbols_list_display_toggle(GtkToggleToolButton *, GSymbolsPanel *);
@@ -240,7 +246,7 @@ G_DEFINE_TYPE_WITH_CODE(GSymbolsPanel, g_symbols_panel, G_TYPE_PANEL_ITEM,
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : klass = classe à initialiser.                                *
+*  Paramètres  : class = classe à initialiser.                                *
 *                                                                             *
 *  Description : Initialise la classe des panneaux d'affichage des symboles.  *
 *                                                                             *
@@ -250,56 +256,56 @@ G_DEFINE_TYPE_WITH_CODE(GSymbolsPanel, g_symbols_panel, G_TYPE_PANEL_ITEM,
 *                                                                             *
 ******************************************************************************/
 
-static void g_symbols_panel_class_init(GSymbolsPanelClass *klass)
+static void g_symbols_panel_class_init(GSymbolsPanelClass *class)
 {
     GObjectClass *object;                   /* Autre version de la classe  */
     GEditorItemClass *item;                 /* Encore une autre vision...  */
     GPanelItemClass *panel;                 /* Version parente de la classe*/
     gchar *filename;                        /* Chemin d'accès à utiliser   */
 
-    object = G_OBJECT_CLASS(klass);
+    object = G_OBJECT_CLASS(class);
 
     object->dispose = (GObjectFinalizeFunc/* ! */)g_symbols_panel_dispose;
     object->finalize = (GObjectFinalizeFunc)g_symbols_panel_finalize;
 
-    item = G_EDITOR_ITEM_CLASS(klass);
+    item = G_EDITOR_ITEM_CLASS(class);
 
-    item->get_key = (get_item_key_fc)g_symbols_panel_get_key;
+    item->get_key = (get_item_key_fc)g_symbols_panel_class_get_key;
 
     item->change_content = (change_item_content_fc)change_symbols_panel_current_content;
 
-    panel = G_PANEL_ITEM_CLASS(klass);
+    panel = G_PANEL_ITEM_CLASS(class);
 
-    panel->unique = true;
-    panel->bindings = "<Shift>F3";
+    panel->get_path = (get_panel_path_fc)g_symbols_panel_class_get_path;
+    panel->get_bindings = (get_panel_bindings_fc)g_symbols_panel_class_get_key_bindings;
 
     panel->gid = setup_tiny_global_work_group(1);
 
     filename = find_pixmap_file("symbol_routine_classic.png");
     assert(filename != NULL);
 
-    klass->routine_img = cairo_image_surface_create_from_png(filename);
+    class->routine_img = cairo_image_surface_create_from_png(filename);
 
     g_free(filename);
 
     filename = find_pixmap_file("symbol_object_classic.png");
     assert(filename != NULL);
 
-    klass->object_img = cairo_image_surface_create_from_png(filename);
+    class->object_img = cairo_image_surface_create_from_png(filename);
 
     g_free(filename);
 
     filename = find_pixmap_file("symbol_package.png");
     assert(filename != NULL);
 
-    klass->package_img = cairo_image_surface_create_from_png(filename);
+    class->package_img = cairo_image_surface_create_from_png(filename);
 
     g_free(filename);
 
     filename = find_pixmap_file("symbol_class_classic.png");
     assert(filename != NULL);
 
-    klass->class_img = cairo_image_surface_create_from_png(filename);
+    class->class_img = cairo_image_surface_create_from_png(filename);
 
     g_free(filename);
 
@@ -331,15 +337,10 @@ static void g_symbols_panel_init(GSymbolsPanel *panel)
 
     pitem = G_PANEL_ITEM(panel);
 
-    pitem->personality = PIP_SINGLETON;
-
     pitem->widget = G_NAMED_WIDGET(gtk_built_named_widget_new_for_panel(_("Symbols"),
                                                                         _("Binary symbols"),
                                                                         PANEL_SYMBOLS_ID));
 
-    pitem->dock_at_startup = true;
-    pitem->path = strdup("MEN");
-
     /* Représentation graphique */
 
     builder = gtk_built_named_widget_get_builder(GTK_BUILT_NAMED_WIDGET(pitem->widget));
@@ -464,21 +465,21 @@ static void g_symbols_panel_finalize(GSymbolsPanel *panel)
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : -                                                            *
+*  Paramètres  : class = classe à consulter.                                  *
 *                                                                             *
-*  Description : Crée un panneau d'affichage des symboles.                    *
+*  Description : Fournit le nom interne attribué à l'élément réactif.         *
 *                                                                             *
-*  Retour      : Adresse de la structure mise en place.                       *
+*  Retour      : Désignation (courte) de l'élément de l'éditeur.              *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-GPanelItem *g_symbols_panel_new(void)
+static char *g_symbols_panel_class_get_key(const GSymbolsPanelClass *class)
 {
-    GPanelItem *result;                     /* Structure à retourner       */
+    char *result;                           /* Description à renvoyer      */
 
-    result = g_object_new(G_TYPE_SYMBOLS_PANEL, NULL);
+    result = strdup(PANEL_SYMBOLS_ID);
 
     return result;
 
@@ -487,21 +488,67 @@ GPanelItem *g_symbols_panel_new(void)
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : panel = instance à consulter.                                *
+*  Paramètres  : class = classe à consulter.                                  *
 *                                                                             *
-*  Description : Fournit le nom interne attribué à l'élément réactif.         *
+*  Description : Indique le chemin initial de la localisation d'un panneau.   *
 *                                                                             *
-*  Retour      : Désignation (courte) de l'élément de l'éditeur.              *
+*  Retour      : Chemin fixé associé à la position initiale.                  *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-static char *g_symbols_panel_get_key(const GSymbolsPanel *panel)
+static char *g_symbols_panel_class_get_path(const GSymbolsPanelClass *class)
 {
-    char *result;                           /* Description à renvoyer      */
+    char *result;                           /* Emplacement à retourner     */
 
-    result = strdup(PANEL_SYMBOLS_ID);
+    result = strdup("MEN");
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : class = classe à consulter.                                  *
+*                                                                             *
+*  Description : Indique la définition d'un éventuel raccourci clavier.       *
+*                                                                             *
+*  Retour      : Description d'un raccourci ou NULL si aucun de défini.       *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static char *g_symbols_panel_class_get_key_bindings(const GSymbolsPanelClass *class)
+{
+    char *result;                           /* Emplacement à retourner     */
+
+    result = strdup("<Shift>F3");
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : -                                                            *
+*                                                                             *
+*  Description : Crée un panneau d'affichage des symboles.                    *
+*                                                                             *
+*  Retour      : Adresse de la structure mise en place.                       *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GPanelItem *g_symbols_panel_new(void)
+{
+    GPanelItem *result;                     /* Structure à retourner       */
+
+    result = g_object_new(G_TYPE_SYMBOLS_PANEL, NULL);
 
     return result;
 
diff --git a/src/gui/panels/view.c b/src/gui/panels/view.c
new file mode 100644
index 0000000..26dc820
--- /dev/null
+++ b/src/gui/panels/view.c
@@ -0,0 +1,261 @@
+
+/* Chrysalide - Outil d'analyse de fichiers binaires
+ * view.c - panneau d'affichage de contenu binaire
+ *
+ * Copyright (C) 2020 Cyrille Bagard
+ *
+ *  This file is part of Chrysalide.
+ *
+ *  Chrysalide 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.
+ *
+ *  Chrysalide 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 this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+
+#include "view.h"
+
+
+#include <string.h>
+
+
+#include "../panel-int.h"
+#include "../../gtkext/named.h"
+
+
+
+/* Panneau d'affichage pour contenu binaire (instance) */
+struct _GViewPanel
+{
+    GPanelItem parent;                      /* A laisser en premier        */
+
+};
+
+/* Panneau d'affichage pour contenu binaire (classe) */
+struct _GViewPanelClass
+{
+    GPanelItemClass parent;                 /* A laisser en premier        */
+
+};
+
+
+/* Initialise la classe des panneaux de contenu binaire. */
+static void g_view_panel_class_init(GViewPanelClass *);
+
+/* Initialise une instance de panneau de contenu binaire. */
+static void g_view_panel_init(GViewPanel *);
+
+/* Supprime toutes les références externes. */
+static void g_view_panel_dispose(GViewPanel *);
+
+/* Procède à la libération totale de la mémoire. */
+static void g_view_panel_finalize(GViewPanel *);
+
+/* Fournit le nom interne attribué à l'élément réactif. */
+static char *g_view_panel_class_get_key(const GViewPanelClass *);
+
+/* Fournit une indication sur la personnalité du panneau. */
+static PanelItemPersonality g_view_panel_class_get_personality(const GViewPanelClass *);
+
+/* Indique le chemin initial de la localisation d'un panneau. */
+static char *g_view_panel_class_get_path(const GViewPanelClass *);
+
+
+
+/* Indique le type défini pour un panneau de contenu binaire. */
+G_DEFINE_TYPE(GViewPanel, g_view_panel, G_TYPE_PANEL_ITEM);
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : class = classe à initialiser.                                *
+*                                                                             *
+*  Description : Initialise la classe des panneaux de contenu binaire.        *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_view_panel_class_init(GViewPanelClass *class)
+{
+    GObjectClass *object;                   /* Autre version de la classe  */
+    GEditorItemClass *item;                 /* Encore une autre vision...  */
+    GPanelItemClass *panel;                 /* Version parente de classe   */
+
+    object = G_OBJECT_CLASS(class);
+
+    object->dispose = (GObjectFinalizeFunc/* ! */)g_view_panel_dispose;
+    object->finalize = (GObjectFinalizeFunc)g_view_panel_finalize;
+
+    item = G_EDITOR_ITEM_CLASS(class);
+
+    item->get_key = (get_item_key_fc)g_view_panel_class_get_key;
+
+    panel = G_PANEL_ITEM_CLASS(class);
+
+    panel->get_personality = (get_panel_personality_fc)g_view_panel_class_get_personality;
+    panel->get_path = (get_panel_path_fc)g_view_panel_class_get_path;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : panel = instance à initialiser.                              *
+*                                                                             *
+*  Description : Initialise une instance de panneau de contenu binaire.       *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_view_panel_init(GViewPanel *panel)
+{
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : panel = instance d'objet GLib à traiter.                     *
+*                                                                             *
+*  Description : Supprime toutes les références externes.                     *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_view_panel_dispose(GViewPanel *panel)
+{
+    G_OBJECT_CLASS(g_view_panel_parent_class)->dispose(G_OBJECT(panel));
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : panel = instance d'objet GLib à traiter.                     *
+*                                                                             *
+*  Description : Procède à la libération totale de la mémoire.                *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_view_panel_finalize(GViewPanel *panel)
+{
+    G_OBJECT_CLASS(g_view_panel_parent_class)->finalize(G_OBJECT(panel));
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : class = classe à consulter.                                  *
+*                                                                             *
+*  Description : Fournit le nom interne attribué à l'élément réactif.         *
+*                                                                             *
+*  Retour      : Désignation (courte) de l'élément de l'éditeur.              *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static char *g_view_panel_class_get_key(const GViewPanelClass *class)
+{
+    char *result;                           /* Description à renvoyer      */
+
+    result = strdup(PANEL_VIEW_ID);
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : class = classe à consulter.                                  *
+*                                                                             *
+*  Description : Fournit une indication sur la personnalité du panneau.       *
+*                                                                             *
+*  Retour      : Identifiant lié à la nature unique du panneau.               *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static PanelItemPersonality g_view_panel_class_get_personality(const GViewPanelClass *class)
+{
+    PanelItemPersonality result;            /* Personnalité à retourner    */
+
+    result = PIP_BINARY_VIEW;
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : class = classe à consulter.                                  *
+*                                                                             *
+*  Description : Indique le chemin initial de la localisation d'un panneau.   *
+*                                                                             *
+*  Retour      : Chemin fixé associé à la position initiale.                  *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static char *g_view_panel_class_get_path(const GViewPanelClass *class)
+{
+    char *result;                           /* Emplacement à retourner     */
+
+    result = strdup("M");
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : widget = composant avec noms à présenter à l'affichage.      *
+*                                                                             *
+*  Description : Crée un panneau pour l'affichage d'un contenu binaire.       *
+*                                                                             *
+*  Retour      : Adresse de la structure mise en place.                       *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GPanelItem *g_view_panel_new(GNamedWidget *widget)
+{
+    GPanelItem *result;                     /* Structure à retourner       */
+
+    result = g_object_new(G_TYPE_VIEW_PANEL, NULL);
+
+    result->widget = widget;
+    g_object_ref(G_OBJECT(widget));
+
+    return result;
+
+}
diff --git a/src/gui/panels/view.h b/src/gui/panels/view.h
new file mode 100644
index 0000000..968bd1c
--- /dev/null
+++ b/src/gui/panels/view.h
@@ -0,0 +1,59 @@
+
+/* Chrysalide - Outil d'analyse de fichiers binaires
+ * view.h - prototypes pour le panneau d'affichage de contenu binaire
+ *
+ * Copyright (C) 2020 Cyrille Bagard
+ *
+ *  This file is part of Chrysalide.
+ *
+ *  Chrysalide 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.
+ *
+ *  Chrysalide 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 this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+
+#ifndef _GUI_PANELS_VIEW_H
+#define _GUI_PANELS_VIEW_H
+
+
+#include "../panel.h"
+
+
+
+#define PANEL_VIEW_ID "binview"
+
+
+#define G_TYPE_VIEW_PANEL               g_view_panel_get_type()
+#define G_VIEW_PANEL(obj)               (G_TYPE_CHECK_INSTANCE_CAST((obj), g_view_panel_get_type(), GViewPanel))
+#define G_IS_VIEW_PANEL(obj)            (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_view_panel_get_type()))
+#define G_VIEW_PANEL_CLASS(klass)       (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_VIEW_PANEL, GViewPanelClass))
+#define G_IS_VIEW_PANEL_CLASS(klass)    (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_VIEW_PANEL))
+#define G_VIEW_PANEL_GET_CLASS(obj)     (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_VIEW_PANEL, GViewPanelClass))
+
+
+/* Panneau d'affichage pour contenu binaire (instance) */
+typedef struct _GViewPanel GViewPanel;
+
+/* Panneau d'affichage pour contenu binaire (classe) */
+typedef struct _GViewPanelClass GViewPanelClass;
+
+
+/* Indique le type défini pour un panneau de contenu binaire. */
+GType g_view_panel_get_type(void);
+
+/*  Crée un panneau pour l'affichage d'un contenu binaire. */
+GPanelItem *g_view_panel_new(GNamedWidget *);
+
+
+
+#endif  /* _GUI_PANELS_VIEW_H */
diff --git a/src/gui/panels/welcome.c b/src/gui/panels/welcome.c
index 24674a7..9192d66 100644
--- a/src/gui/panels/welcome.c
+++ b/src/gui/panels/welcome.c
@@ -97,7 +97,13 @@ static void g_welcome_panel_dispose(GWelcomePanel *);
 static void g_welcome_panel_finalize(GWelcomePanel *);
 
 /* Fournit le nom interne attribué à l'élément réactif. */
-static char *g_welcome_panel_get_key(const GWelcomePanel *);
+static char *g_welcome_panel_class_get_key(const GWelcomePanelClass *);
+
+/* Fournit une indication sur la personnalité du panneau. */
+static PanelItemPersonality g_welcome_panel_class_get_personality(const GWelcomePanelClass *);
+
+/* Indique le chemin initial de la localisation d'un panneau. */
+static char *g_welcome_panel_class_get_path(const GWelcomePanelClass *);
 
 /* Place un panneau dans l'ensemble affiché. */
 static void g_welcome_panel_dock(GWelcomePanel *);
@@ -156,7 +162,7 @@ static void g_welcome_panel_class_init(GWelcomePanelClass *klass)
 {
     GObjectClass *object;                   /* Autre version de la classe  */
     GEditorItemClass *item;                 /* Encore une autre vision...  */
-    GPanelItemClass *parent;                /* Version parente de classe   */
+    GPanelItemClass *panel;                 /* Version parente de classe   */
 
     object = G_OBJECT_CLASS(klass);
 
@@ -165,11 +171,15 @@ static void g_welcome_panel_class_init(GWelcomePanelClass *klass)
 
     item = G_EDITOR_ITEM_CLASS(klass);
 
-    item->get_key = (get_item_key_fc)g_welcome_panel_get_key;
+    item->get_key = (get_item_key_fc)g_welcome_panel_class_get_key;
 
-    parent = G_PANEL_ITEM_CLASS(klass);
+    panel = G_PANEL_ITEM_CLASS(klass);
 
-    parent->ack_dock = (ack_undock_process_fc)g_welcome_panel_dock;
+    panel->get_personality = (get_panel_personality_fc)g_welcome_panel_class_get_personality;
+    panel->dock_at_startup = gtk_panel_item_class_return_false;
+    panel->get_path = (get_panel_path_fc)g_welcome_panel_class_get_path;
+
+    panel->ack_dock = (ack_undock_process_fc)g_welcome_panel_dock;
 
 }
 
@@ -196,21 +206,17 @@ static void g_welcome_panel_init(GWelcomePanel *panel)
     GtkToggleButton *button;                /* Bouton à bascule à traiter  */
     bool state;                             /* Etat de la coche à définir  */
     gchar *filename;                        /* Chemin d'accès à une image  */
+    GtkRecentManager *manager;              /* Gestionnaire global         */
 
     /* Eléments de base */
 
     pitem = G_PANEL_ITEM(panel);
 
-    pitem->personality = PIP_SINGLETON;
-
     pitem->widget = G_NAMED_WIDGET(gtk_built_named_widget_new_for_panel(_("Welcome"),
                                                                         _("Welcome panel"),
                                                                         PANEL_WELCOME_ID));
 
-    pitem->dock_at_startup = false;
-    pitem->path = strdup("M");
-
-    panel->uorigin = !pitem->dock_at_startup;
+    panel->uorigin = !gtk_panel_item_class_dock_at_startup(G_PANEL_ITEM_GET_CLASS(pitem));
 
     /* Représentation graphique */
 
@@ -259,6 +265,18 @@ static void g_welcome_panel_init(GWelcomePanel *panel)
 
     g_object_unref(G_OBJECT(builder));
 
+    /* Actualisation du contenu du panneau */
+
+    manager = get_project_manager();
+
+    g_signal_connect(manager, "changed", G_CALLBACK(on_recent_list_changed), panel);
+
+    g_welcome_panel_reload_project_list(panel, manager);
+
+    g_welcome_panel_load_tips(panel);
+
+    g_welcome_panel_check_version(panel);
+
 }
 
 
@@ -306,55 +324,90 @@ static void g_welcome_panel_finalize(GWelcomePanel *panel)
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : -                                                            *
+*  Paramètres  : class = classe à consulter.                                  *
 *                                                                             *
-*  Description : Crée un panneau d'accueil par défaut.                        *
+*  Description : Fournit le nom interne attribué à l'élément réactif.         *
 *                                                                             *
-*  Retour      : Adresse de la structure mise en place.                       *
+*  Retour      : Désignation (courte) de l'élément de l'éditeur.              *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-GPanelItem *g_welcome_panel_new(void)
+static char *g_welcome_panel_class_get_key(const GWelcomePanelClass *class)
 {
-    GWelcomePanel *result;                  /* Structure à retourner       */
-    GtkRecentManager *manager;              /* Gestionnaire global         */
+    char *result;                           /* Description à renvoyer      */
 
-    result = g_object_new(G_TYPE_WELCOME_PANEL, NULL);
+    result = strdup(PANEL_WELCOME_ID);
 
-    manager = get_project_manager();
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : class = classe à consulter.                                  *
+*                                                                             *
+*  Description : Fournit une indication sur la personnalité du panneau.       *
+*                                                                             *
+*  Retour      : Identifiant lié à la nature unique du panneau.               *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static PanelItemPersonality g_welcome_panel_class_get_personality(const GWelcomePanelClass *class)
+{
+    PanelItemPersonality result;            /* Personnalité à retourner    */
 
-    g_signal_connect(manager, "changed", G_CALLBACK(on_recent_list_changed), result);
+    result = PIP_PERSISTENT_SINGLETON;
 
-    g_welcome_panel_reload_project_list(result, manager);
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : class = classe à consulter.                                  *
+*                                                                             *
+*  Description : Indique le chemin initial de la localisation d'un panneau.   *
+*                                                                             *
+*  Retour      : Chemin fixé associé à la position initiale.                  *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
 
-    g_welcome_panel_load_tips(result);
+static char *g_welcome_panel_class_get_path(const GWelcomePanelClass *class)
+{
+    char *result;                           /* Emplacement à retourner     */
 
-    g_welcome_panel_check_version(result);
+    result = strdup("M");
 
-    return G_PANEL_ITEM(result);
+    return result;
 
 }
 
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : panel = instance à consulter.                                *
+*  Paramètres  : -                                                            *
 *                                                                             *
-*  Description : Fournit le nom interne attribué à l'élément réactif.         *
+*  Description : Crée un panneau d'accueil par défaut.                        *
 *                                                                             *
-*  Retour      : Désignation (courte) de l'élément de l'éditeur.              *
+*  Retour      : Adresse de la structure mise en place.                       *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-static char *g_welcome_panel_get_key(const GWelcomePanel *panel)
+GPanelItem *g_welcome_panel_new(void)
 {
-    char *result;                           /* Description à renvoyer      */
+    GPanelItem *result;                     /* Structure à retourner       */
 
-    result = strdup(PANEL_WELCOME_ID);
+    result = g_object_new(G_TYPE_WELCOME_PANEL, NULL);
 
     return result;
 
diff --git a/src/gui/status.c b/src/gui/status.c
index 79f47ea..6ee990a 100644
--- a/src/gui/status.c
+++ b/src/gui/status.c
@@ -72,7 +72,7 @@ static void g_status_info_dispose(GStatusInfo *);
 static void g_status_info_finalize(GStatusInfo *);
 
 /* Fournit le nom interne attribué à l'élément réactif. */
-static char *g_status_info_get_key(const GStatusInfo *);
+static char *g_status_info_class_get_key(const GStatusInfoClass *);
 
 /* Fournit le composant GTK associé à l'élément réactif. */
 static GtkWidget *g_status_info_get_widget(const GStatusInfo *);
@@ -113,7 +113,7 @@ static void g_status_info_class_init(GStatusInfoClass *klass)
 
     item = G_EDITOR_ITEM_CLASS(klass);
 
-    item->get_key = (get_item_key_fc)g_status_info_get_key;
+    item->get_key = (get_item_key_fc)g_status_info_class_get_key;
     item->get_widget = (get_item_widget_fc)g_status_info_get_widget;
 
     item->track_cursor = (track_cursor_in_view_fc)track_cursor_for_status_info;
@@ -209,7 +209,7 @@ GEditorItem *g_status_info_new(void)
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : info = instance à consulter.                                 *
+*  Paramètres  : class = classe à consulter.                                  *
 *                                                                             *
 *  Description : Fournit le nom interne attribué à l'élément réactif.         *
 *                                                                             *
@@ -219,7 +219,7 @@ GEditorItem *g_status_info_new(void)
 *                                                                             *
 ******************************************************************************/
 
-static char *g_status_info_get_key(const GStatusInfo *info)
+static char *g_status_info_class_get_key(const GStatusInfoClass *class)
 {
     char *result;                           /* Description à renvoyer      */
 
diff --git a/src/gui/tb/portions.c b/src/gui/tb/portions.c
index f8b2b92..64b44db 100644
--- a/src/gui/tb/portions.c
+++ b/src/gui/tb/portions.c
@@ -70,7 +70,7 @@ static void g_portions_tbitem_dispose(GPortionsTbItem *);
 static void g_portions_tbitem_finalize(GPortionsTbItem *);
 
 /* Fournit le nom interne attribué à l'élément réactif. */
-static char *g_portions_tbitem_get_key(const GPortionsTbItem *);
+static char *g_portions_tbitem_class_get_key(const GPortionsTbItemClass *);
 
 /* Fournit le composant GTK associé à l'élément réactif. */
 static GtkWidget *g_portions_tbitem_get_widget(const GPortionsTbItem *);
@@ -111,7 +111,7 @@ static void g_portions_tbitem_class_init(GPortionsTbItemClass *klass)
 
     item = G_EDITOR_ITEM_CLASS(klass);
 
-    item->get_key = (get_item_key_fc)g_portions_tbitem_get_key;
+    item->get_key = (get_item_key_fc)g_portions_tbitem_class_get_key;
     item->get_widget = (get_item_widget_fc)g_portions_tbitem_get_widget;
 
     item->change_content = (change_item_content_fc)change_portions_tbitem_current_content;
@@ -220,7 +220,7 @@ GEditorItem *g_portions_tbitem_new(GObject *ref)
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : item = instance à consulter.                                 *
+*  Paramètres  : class = classe à consulter.                                  *
 *                                                                             *
 *  Description : Fournit le nom interne attribué à l'élément réactif.         *
 *                                                                             *
@@ -230,7 +230,7 @@ GEditorItem *g_portions_tbitem_new(GObject *ref)
 *                                                                             *
 ******************************************************************************/
 
-static char *g_portions_tbitem_get_key(const GPortionsTbItem *item)
+static char *g_portions_tbitem_class_get_key(const GPortionsTbItemClass *item)
 {
     char *result;                           /* Description à renvoyer      */
 
diff --git a/src/plugins/dt.c b/src/plugins/dt.c
index 69bd5df..c476dde 100644
--- a/src/plugins/dt.c
+++ b/src/plugins/dt.c
@@ -29,6 +29,9 @@
 #include <string.h>
 
 
+#include "../plugins/pglist.h"
+
+
 
 /* ------------------------- MODULE DE GESTION DES NOUVEAUX ------------------------- */
 
@@ -482,3 +485,34 @@ GType build_dynamic_type(GType parent, const char *name, GClassInitFunc cinit, g
     return result;
 
 }
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : type = type d'instance à créer.                              *
+*                                                                             *
+*  Description : Crée un objet à partir d'un type, dynamique ou classique.    *
+*                                                                             *
+*  Retour      : Instance d'objet mise en place ou NULL en cas d'erreur.      *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+gpointer create_object_from_type(GType type)
+{
+    GObject *result;                        /* Instance à retourner        */
+
+    result = NULL;
+
+    if (g_dynamic_types_find(_chrysalide_dtypes, type) != NULL)
+        result = build_type_instance(type);
+
+    else
+        result = g_object_new(type, NULL);
+
+    assert(result != NULL);
+
+    return result;
+
+}
diff --git a/src/plugins/dt.h b/src/plugins/dt.h
index 88e17ba..5c92593 100644
--- a/src/plugins/dt.h
+++ b/src/plugins/dt.h
@@ -42,6 +42,9 @@ void exit_chrysalide_dynamic_types(void);
 /* Fournit un identifiant GLib pour un nouveau type. */
 GType build_dynamic_type(GType, const char *, GClassInitFunc, gconstpointer, GInstanceInitFunc);
 
+/* Crée un objet à partir d'un type, dynamique ou classique. */
+gpointer create_object_from_type(GType);
+
 
 
 #endif  /* _PLUGINS_PYCHRYSALIDE_DT_H */
diff --git a/src/plugins/pglist.h b/src/plugins/pglist.h
index ae71458..fd8e30a 100644
--- a/src/plugins/pglist.h
+++ b/src/plugins/pglist.h
@@ -69,6 +69,7 @@ GPluginModule **get_all_plugins_for_action(PluginAction, size_t *);
  */
 
 #define process_all_plugins_for(a, f, ...)                  \
+    do                                                      \
     {                                                       \
         size_t __count;                                     \
         GPluginModule **__list;                             \
@@ -84,12 +85,34 @@ GPluginModule **get_all_plugins_for_action(PluginAction, size_t *);
     }                                                       \
     while (0)
 
+#define process_plugins_while_null(a, f, ...)               \
+    ({                                                      \
+        void *__result;                                     \
+        size_t __count;                                     \
+        GPluginModule **__list;                             \
+        size_t __i;                                         \
+        __result = NULL;                                    \
+        __list = get_all_plugins_for_action(a, &__count);   \
+        for (__i = 0; __i < __count; __i++)                 \
+        {                                                   \
+            if (__result == NULL)                           \
+                __result = f(__list[__i], a, __VA_ARGS__);  \
+            g_object_unref(G_OBJECT(__list[__i]));          \
+        }                                                   \
+        if (__list != NULL)                                 \
+            free(__list);                                   \
+        __result;                                           \
+    })
+
 
 /* DPS_PG_MANAGEMENT */
 
 #define notify_native_loaded \
     process_all_plugins_for(PGA_NATIVE_LOADED, g_plugin_module_notify_native_loaded, NULL)
 
+#define build_type_instance(t) \
+    process_plugins_while_null(PGA_TYPE_BUILDING, g_plugin_module_build_type_instance, t)
+
 /* DPS_SETUP */
 
 #define include_plugin_theme(d, r, c) \
diff --git a/src/plugins/plugin-def.h b/src/plugins/plugin-def.h
index 7895eeb..5a2dc54 100644
--- a/src/plugins/plugin-def.h
+++ b/src/plugins/plugin-def.h
@@ -122,6 +122,9 @@ typedef enum _PluginAction
     /* Fin du chargement des greffons natifs */
     PGA_NATIVE_LOADED = DPC_BASIC | DPS_CORE_MANAGEMENT | DEFINE_PLUGIN_ACTION(0),
 
+    /* Mise en place de type à partir de code externe */
+    PGA_TYPE_BUILDING = DPC_BASIC | DPS_CORE_MANAGEMENT | DEFINE_PLUGIN_ACTION(1),
+
     /**
      * DPC_GUI | DPS_SETUP
      */
diff --git a/src/plugins/plugin-int.h b/src/plugins/plugin-int.h
index 876dc99..129e155 100644
--- a/src/plugins/plugin-int.h
+++ b/src/plugins/plugin-int.h
@@ -45,6 +45,9 @@ typedef bool (* pg_management_fc) (GPluginModule *);
 /* Accompagne la fin du chargement des modules natifs. */
 typedef void (* pg_native_loaded_fc) (GPluginModule *, PluginAction);
 
+/* Crée une instance à partir d'un type dynamique externe. */
+typedef gpointer (* pg_build_instance_fc) (GPluginModule *, PluginAction, GType);
+
 /* Fournit le nom brut associé au greffon. */
 typedef char * (* pg_get_modname_fc) (const GPluginModule *);
 
@@ -99,6 +102,7 @@ struct _GPluginModuleClass
     pg_management_fc exit;                  /* Procédure d'extinction      */
 
     pg_native_loaded_fc native_loaded;      /* Fin des chargements natifs  */
+    pg_build_instance_fc build_instance;    /* Création d'objets           */
 
     pg_get_modname_fc get_modname;          /* Fourniture du nom brut      */
 
diff --git a/src/plugins/plugin.c b/src/plugins/plugin.c
index cc3db70..df593ea 100644
--- a/src/plugins/plugin.c
+++ b/src/plugins/plugin.c
@@ -328,6 +328,10 @@ GPluginModule *g_plugin_module_new(const gchar *filename)
                                 valid = check_plugin_symbol(module, "chrysalide_plugin_on_native_loaded");
                                 break;
 
+                            case PGA_TYPE_BUILDING:
+                                valid = check_plugin_symbol(module, "chrysalide_plugin_build_type_instance");
+                                break;
+
                             default:
                                 log_variadic_message(LMT_WARNING,
                                                      _("Unknown action '0x%02x' in plugin '%s'..."),
@@ -594,6 +598,11 @@ static void g_plugin_module_init_gclass(GPluginModuleClass *class, GModule *modu
                                                    &class->native_loaded);
                                 break;
 
+                            case PGA_TYPE_BUILDING:
+                                load_plugin_symbol(module, "chrysalide_plugin_build_type_instance",
+                                                   &class->build_instance);
+                                break;
+
                             default:
                                 assert(false);
                                 break;
@@ -1206,6 +1215,34 @@ void g_plugin_module_notify_native_loaded(GPluginModule *plugin, PluginAction ac
 
 /******************************************************************************
 *                                                                             *
+*  Paramètres  : plugin = greffon à manipuler.                                *
+*                action = type d'action attendue.                             *
+*                type   = type d'objet à mettre en place.                     *
+*                                                                             *
+*  Description : Crée une instance à partir d'un type dynamique externe.      *
+*                                                                             *
+*  Retour      : Instance d'objet gérée par l'extension ou NULL.              *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+gpointer g_plugin_module_build_type_instance(GPluginModule *plugin, PluginAction action, GType type)
+{
+    gpointer result;                        /* Instance à retourner        */
+    GPluginModuleClass *class;              /* Classe de l'instance active */
+
+    class = G_PLUGIN_MODULE_GET_CLASS(plugin);
+
+    result = class->build_instance(plugin, action, type);
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
 *  Paramètres  : plugin    = greffon à manipuler.                             *
 *                action    = type d'action attendue.                          *
 *                dark      = indique une préférence pour la variante foncée.  *
diff --git a/src/plugins/plugin.h b/src/plugins/plugin.h
index 70687fe..f65d0eb 100644
--- a/src/plugins/plugin.h
+++ b/src/plugins/plugin.h
@@ -108,6 +108,9 @@ void g_plugin_module_log_variadic_message(const GPluginModule *, LogMessageType,
 /* Accompagne la fin du chargement des modules natifs. */
 void g_plugin_module_notify_native_loaded(GPluginModule *, PluginAction, void *);
 
+/* Crée une instance à partir d'un type dynamique externe. */
+gpointer g_plugin_module_build_type_instance(GPluginModule *, PluginAction, GType);
+
 /* Complète une liste de resources pour thème. */
 void g_plugin_module_include_theme(const GPluginModule *, PluginAction, gboolean, char ***, size_t *);