Simplify panel handling code.

20 files changed, 618 insertions, 2257 deletions

diff --git a/src/gui/Makefile.am b/src/gui/Makefile.am
index 42761c4..be70445 100644
--- a/src/gui/Makefile.am
+++ b/src/gui/Makefile.am
@@ -26,8 +26,6 @@ libgui_la_CFLAGS = $(LIBGTK_CFLAGS) $(LIBXML_CFLAGS)
 
 
 libgui4_la_SOURCES =						\
-	panel-int.h								\
-	panel.h panel.c							\
 	resources.h resources.c					\
 	window-int.h							\
 	window.h window.c
diff --git a/src/gui/core/core.c b/src/gui/core/core.c
index 4a6809c..57a398a 100644
--- a/src/gui/core/core.c
+++ b/src/gui/core/core.c
@@ -2,7 +2,7 @@
 /* Chrysalide - Outil d'analyse de fichiers binaires
  * core.c - chargement et le déchargement du tronc commun pour l'éditeur graphique
  *
- * Copyright (C) 2016-2019 Cyrille Bagard
+ * Copyright (C) 2016-2025 Cyrille Bagard
  *
  *  This file is part of Chrysalide.
  *
@@ -63,7 +63,7 @@ bool load_gui_components(AvailableGuiComponent flags)
 
     if ((flags & AGC_PANELS) != 0 && (__loaded & AGC_PANELS) == 0)
     {
-        result = load_main_panels();
+        result = load_main_framework_panel_definitions();
         if (!result) goto done;
 
         __loaded |= AGC_PANELS;
@@ -93,7 +93,7 @@ void unload_gui_components(AvailableGuiComponent flags)
 {
     if ((flags & AGC_PANELS) != 0 && (__loaded & AGC_PANELS) == 0)
     {
-        unload_all_panels();
+        unload_all_framework_panel_definitions();
 
         __loaded &= ~AGC_PANELS;
 
diff --git a/src/gui/core/panels.c b/src/gui/core/panels.c
index 69ab2aa..4c113b8 100644
--- a/src/gui/core/panels.c
+++ b/src/gui/core/panels.c
@@ -2,7 +2,7 @@
 /* Chrysalide - Outil d'analyse de fichiers binaires
  * panels.c - gestion d'ensemble de tous les panneaux graphiques du framework
  *
- * Copyright (C) 2016-2024 Cyrille Bagard
+ * Copyright (C) 2016-2025 Cyrille Bagard
  *
  *  This file is part of Chrysalide.
  *
@@ -25,25 +25,137 @@
 #include "panels.h"
 
 
+#include <assert.h>
 #include <malloc.h>
+#include <string.h>
+
+
+#include <i18n.h>
 
 
 #include "../panels/binary.h"
+#include "../panels/binary-params.h"
 #include "../panels/welcome.h"
+#include "../../gtkext/launcher.h"
+
+
+
+/* Définition générique complète d'un panneau */
+typedef struct _ext_panel_info_t
+{
+    /* Début des champs copiés de panel_info_t */
+
+    char *category;                         /* Groupe de rassemblement     */
+
+    char *image;                            /* Eventuelle image associée   */
+    char *title;                            /* Désignation humaine         */
+    char *desc;                             /* Description humaine         */
 
+    FrameworkPanelPersonality personality;  /* Comportement attendu        */
+
+    GType panel_type;                       /* Type du panneau représenté  */
+    GType params_type;                      /* Composant de paramètre      */
+
+    /* Fin des champs copiés de panel_info_t */
+
+    GtkTiledPanel *singleton;               /* Conservation des allocations*/
+
+} ext_panel_info_t;
 
 
 /* Liste des panneaux disponibles */
-static GPanelItem **_panels_list = NULL;
+static ext_panel_info_t **_panels_list = NULL;
 static size_t _panels_count = 0;
 
 
+/* Copie une définition basique de panneau graphqiue. */
+static ext_panel_info_t *copy_panel_info(const panel_info_t *);
+
+/* Efface une définition étendue de panneau graphique. */
+static void delete_panel_info(ext_panel_info_t *);
+
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : info = information de base à copier.                         *
+*                                                                             *
+*  Description : Copie une définition basique de panneau graphqiue.           *
+*                                                                             *
+*  Retour      : Structure mémorisant l'ensemble des informations.            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static ext_panel_info_t *copy_panel_info(const panel_info_t *info)
+{
+    ext_panel_info_t *result;               /* Structure à retourner       */
+
+    result = calloc(1, sizeof(ext_panel_info_t));
+
+    if (info->category != NULL)
+        result->category = strdup(info->category);
+
+    if (info->image != NULL)
+        result->image = strdup(info->image);
+
+    result->title = strdup(info->title);
+
+    if (info->desc != NULL)
+        result->desc = strdup(info->desc);
+
+    result->personality = info->personality;
+
+    result->panel_type = info->panel_type;
+    result->params_type = info->params_type;
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : info = informations à supprimer de la mémoire.               *
+*                                                                             *
+*  Description : Efface une définition étendue de panneau graphique.          *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void delete_panel_info(ext_panel_info_t *info)
+{
+    if (info->category != NULL)
+        free(info->category);
+
+    if (info->image != NULL)
+        free(info->image);
+
+    free(info->title);
+
+    if (info->desc != NULL)
+        free(info->desc);
+
+    if (info->singleton != NULL)
+    {
+        assert(info->personality & FPP_SINGLETON);
+        unref_object(info->singleton);
+    }
+
+    free(info);
+
+}
+
 
 /******************************************************************************
 *                                                                             *
 *  Paramètres  : -                                                            *
 *                                                                             *
-*  Description : Charge les principaux panneaux graphiques du framework.      *
+*  Description : Charge les définitions des principaux panneaux du framework. *
 *                                                                             *
 *  Retour      : Bilan de l'opération.                                        *
 *                                                                             *
@@ -51,19 +163,45 @@ static size_t _panels_count = 0;
 *                                                                             *
 ******************************************************************************/
 
-bool load_main_panels(void)
+bool load_main_framework_panel_definitions(void)
 {
     bool result;                            /* Bilan à retourner           */
-
-    result = true;
+    panel_info_t info;                      /* Infos d'enregistrement      */
 
     // TODO register_panel_item(G_TYPE_LOG_PANEL, config);
 
     /* Chargement du panneau de rapport au plus tôt */
     // TODO panel = g_panel_item_new(G_TYPE_LOG_PANEL, NULL);
 
-    register_panel_item(g_binary_panel_new());
-    register_panel_item(g_welcome_panel_new());
+    info.category = "Main";
+
+    info.image = "binfile-symbolic";
+    info.title = _("Binary analysis");
+    info.desc = _("Load a binary content and parse its format if recognized");
+
+    info.personality = FPP_MAIN_PANEL;
+
+    info.panel_type = GTK_TYPE_BINARY_PANEL;
+    info.params_type = GTK_TYPE_BINARY_PARAMETERS;
+
+    result = register_framework_panel_definition(&info);
+    if (!result) goto done;
+
+    info.category = NULL;
+
+    info.image = NULL;
+    info.title = _("Welcome");
+    info.desc = NULL;
+
+    info.personality = FPP_MAIN_PANEL | FPP_SINGLETON;
+
+    info.panel_type = GTK_TYPE_WELCOME_PANEL;
+    info.params_type = G_TYPE_INVALID;
+
+    result = register_framework_panel_definition(&info);
+    if (!result) goto done;
+
+ done:
 
     return result;
 
@@ -82,12 +220,12 @@ bool load_main_panels(void)
 *                                                                             *
 ******************************************************************************/
 
-void unload_all_panels(void)
+void unload_all_framework_panel_definitions(void)
 {
     size_t i;                               /* Boucle de parcours          */
 
     for (i = 0; i < _panels_count; i++)
-        unref_object(_panels_list[i]);
+        delete_panel_info(_panels_list[i]);
 
     _panels_list = NULL;
     _panels_count = 0;
@@ -97,10 +235,9 @@ void unload_all_panels(void)
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : type   = type du composant à présenter à l'affichage.        *
-*                config = configuration à compléter.                          *
+*  Paramètres  : info = information de base à copier.                         *
 *                                                                             *
-*  Description : Enregistre un panneau comme partie intégrante de l'éditeur.  *
+*  Description : Enregistre la définition d'un panneau graphique.             *
 *                                                                             *
 *  Retour      : -                                                            *
 *                                                                             *
@@ -108,11 +245,36 @@ void unload_all_panels(void)
 *                                                                             *
 ******************************************************************************/
 
-void register_panel_item(/* __steal */ GPanelItem *item)
+bool register_framework_panel_definition(const panel_info_t *info)
 {
-    _panels_list = realloc(_panels_list, ++_panels_count * sizeof(GPanelItem *));
+    bool result;                            /* Bilan à retourner           */
+    size_t i;                               /* Boucle de parcours          */
+    ext_panel_info_t *ext_info;             /* Informations conservées     */
+
+    result = false;
 
-    _panels_list[_panels_count - 1] = item;
+    /* Validation */
+
+    for (i = 0; i < _panels_count; i++)
+        if (_panels_list[i]->panel_type == info->panel_type)
+            break;
+
+    if (i < _panels_count)
+        goto done;
+
+    /* Enregistrement */
+
+    ext_info = copy_panel_info(info);
+
+    _panels_list = realloc(_panels_list, ++_panels_count * sizeof(ext_panel_info_t *));
+
+    _panels_list[_panels_count - 1] = ext_info;
+
+    result = true;
+
+ done:
+
+    return result;
 
 }
 
@@ -121,7 +283,7 @@ void register_panel_item(/* __steal */ GPanelItem *item)
 *                                                                             *
 *  Paramètres  : target = type de définition de panneau recherchée.           *
 *                                                                             *
-*  Description : Retrouve la définition d'un type de panneau.                 *
+*  Description : Met en place (au besoin) un panneau graphique unique.        *
 *                                                                             *
 *  Retour      : Instance de définition identifiée ou NULL en cas d'échec.    *
 *                                                                             *
@@ -129,23 +291,27 @@ void register_panel_item(/* __steal */ GPanelItem *item)
 *                                                                             *
 ******************************************************************************/
 
-GPanelItem *find_item_panel_by_type(GType target)
+GtkTiledPanel *get_framework_panel_singleton(GType target)
 {
-    GPanelItem *result;                     /* Instance à renvoyer         */
+    GtkTiledPanel *result;                  /* Instance à renvoyer         */
     size_t i;                               /* Boucle de parcours          */
-    GPanelItem *item;                       /* Définition de panneau       */
+    ext_panel_info_t *info;                 /* Informations conservées     */
 
     result = NULL;
 
     for (i = 0; i < _panels_count; i++)
     {
-        item = _panels_list[i];
+        info = _panels_list[i];
 
-        if (G_OBJECT_TYPE(item) == target)
+        if (info->panel_type == target)
         {
-            result = item;
+            if (info->singleton == NULL)
+                info->singleton = g_object_new(target, NULL);
+
+            result = info->singleton;
             ref_object(result);
             break;
+
         }
 
     }
@@ -157,39 +323,84 @@ GPanelItem *find_item_panel_by_type(GType target)
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : skip   = saute le panneau d'accueil lors du parcours ?       *
-*                handle = routine à appeler pour chaque panneau.              *
-*                data   = données fournies pour accompagner cet appel.        *
+*  Paramètres  : list = liste à compléter.                                    *
 *                                                                             *
-*  Description : Effectue le parcours de tous les panneaux chargés.           *
+*  Description : Intègre une définition de panneau enregistrée.               *
 *                                                                             *
-*  Retour      : true si le parcours a été total, false sinon.                *
+*  Retour      : true pour un parcours complet de la liste des définitions.   *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-bool browse_all_item_panels(bool skip, handle_panel_item_fc handle, void *data)
+void populate_framework_panel_launcher_list(GtkListBox *list)
 {
-    bool result;                            /* Résultat à renvoyer         */
     size_t i;                               /* Boucle de parcours          */
-    GPanelItem *item;                       /* Définition de panneau       */
-
-    result = true;
+    ext_panel_info_t *info;                 /* Informations conservées     */
+    GtkPanelLauncher *launcher;             /* Lanceur à intégrer          */
 
     for (i = 0; i < _panels_count; i++)
     {
-        item = _panels_list[i];
+        info = _panels_list[i];
 
-        if (skip && G_OBJECT_TYPE(item) == G_TYPE_WELCOME_PANEL)
+        if (info->category == NULL)
             continue;
 
-        result = handle(item, data);
+        launcher = gtk_panel_launcher_new(info->image, info->title, info->desc);
+
+        g_object_set_data(G_OBJECT(launcher), "panel_type", GSIZE_TO_POINTER(info->panel_type));
+
+        gtk_list_box_append(list, GTK_WIDGET(launcher));
+
+    }
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : row = lanceur sélectionné.                                   *
+*                                                                             *
+*  Description : Fournit un composant d'édition de paramètres de panneau.     *
+*                                                                             *
+*  Retour      : Composant d'édition de paramètres ou NULL.                   *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GtkWidget *get_framework_panel_parameters(GtkListBoxRow *row)
+{
+    GtkWidget *result;                      /* Composant à retourner       */
+    gpointer *data;                         /* Valeur incrustée            */
+    GType target;                           /* Type de panneau recherché   */
+    ext_panel_info_t *info;                 /* Informations conservées     */
+    size_t i;                               /* Boucle de parcours          */
+
+    data = g_object_get_data(G_OBJECT(row), "panel_type");
+    assert(data != NULL);
+
+    target = GPOINTER_TO_SIZE(data);
 
-        if (!result) break;
+    info = NULL;
+
+    for (i = 0; i < _panels_count; i++)
+    {
+        info = _panels_list[i];
+
+        if (info->panel_type == target)
+            break;
 
     }
 
+    assert(info != NULL);
+    assert(i < _panels_count);
+
+    if (info->params_type == G_TYPE_INVALID)
+        result = NULL;
+    else
+        result = g_object_new(info->params_type, NULL);
+
     return result;
 
 }
diff --git a/src/gui/core/panels.h b/src/gui/core/panels.h
index aaea9e6..4d0ce41 100644
--- a/src/gui/core/panels.h
+++ b/src/gui/core/panels.h
@@ -2,7 +2,7 @@
 /* Chrysalide - Outil d'analyse de fichiers binaires
  * panels.h - prototypes pour la gestion d'ensemble de tous les panneaux graphiques du framework
  *
- * Copyright (C) 2016-2024 Cyrille Bagard
+ * Copyright (C) 2016-2025 Cyrille Bagard
  *
  *  This file is part of Chrysalide.
  *
@@ -26,30 +26,59 @@
 #define _GUI_CORE_PANELS_H
 
 
+#include <glib-object.h>
 #include <stdbool.h>
+#include <gtk/gtk.h>
 
 
-#include "../panel.h"
+#include "../../gtkext/panel.h"
 
 
 
-/* Charge les principaux panneaux graphiques du framework. */
-bool load_main_panels(void);
+/* Types de panneaux pour éditeur */
+typedef enum _FrameworkPanelPersonality
+{
+    FPP_NONE        = (0 << 0),             /* Pas de particularité        */
+
+    FPP_MAIN_PANEL  = (1 << 0),             /* Panneau principal           */
+    FPP_SINGLETON   = (1 << 1),             /* Instance unique             */
+
+} FrameworkPanelPersonality;
+
+/* Définition générique d'un panneau */
+typedef struct _panel_info_t
+{
+    const char *category;                   /* Groupe de rassemblement     */
+
+    const char *image;                      /* Eventuelle image associée   */
+    const char *title;                      /* Désignation humaine         */
+    const char *desc;                       /* Description humaine         */
+
+    FrameworkPanelPersonality personality;  /* Comportement attendu        */
+
+    GType panel_type;                       /* Type du panneau représenté  */
+    GType params_type;                      /* Composant de paramètre      */
+
+} panel_info_t;
+
+
+/* Charge les définitions des principaux panneaux du framework. */
+bool load_main_framework_panel_definitions(void);
 
 /* Décharge tous les panneaux graphiques du framework. */
-void unload_all_panels(void);
+void unload_all_framework_panel_definitions(void);
 
-/* Enregistre un panneau comme partie intégrante de l'éditeur. */
-void register_panel_item(/* __steal */ GPanelItem *);
+/* Enregistre la définition d'un panneau graphique. */
+bool register_framework_panel_definition(const panel_info_t *);
 
-/* Retrouve la définition d'un type de panneau. */
-GPanelItem *find_item_panel_by_type(GType);
+/* Met en place (au besoin) un panneau graphique unique. */
+GtkTiledPanel *get_framework_panel_singleton(GType);
 
-/* Réalise un traitement sur un panneau de l'éditeur. */
-typedef bool (* handle_panel_item_fc) (GPanelItem *, void *);
+/* Intègre une définition de panneau enregistrée. */
+void populate_framework_panel_launcher_list(GtkListBox *);
 
-/* Effectue le parcours de tous les panneaux chargés. */
-bool browse_all_item_panels(bool, handle_panel_item_fc, void *);
+/* Fournit un composant d'édition de paramètres de panneau. */
+GtkWidget *get_framework_panel_parameters(GtkListBoxRow *);
 
 
 
diff --git a/src/gui/panel-int.h b/src/gui/panel-int.h
deleted file mode 100644
index 6a9fcc5..0000000
--- a/src/gui/panel-int.h
+++ /dev/null
@@ -1,74 +0,0 @@
-
-/* Chrysalide - Outil d'analyse de fichiers binaires
- * panel-int.h - prototypes pour les définitions internes liées aux panneaux d'affichage
- *
- * Copyright (C) 2019-2024 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_PANEL_INT_H
-#define _GUI_PANEL_INT_H
-
-
-#include "panel.h"
-
-
-
-/* Fournit une indication sur la personnalité du panneau. */
-typedef PanelItemPersonality (* get_panel_item_personality_cb) (const GPanelItem *);
-
-/* Fournit un composant pour lancer l'activité d'un panneau. */
-typedef GtkPanelLauncher * (* get_panel_item_launcher_cb) (GPanelItem *);
-
-/* Fournit un composant pour paramétrer l'activité d'un panneau. */
-typedef GtkWidget * (* get_panel_item_props_cb) (GPanelItem *);
-
-/* Fournit un composant représentant un panneau graphique. */
-typedef GtkTiledPanel * (* get_panel_item_panel_cb) (GPanelItem *, GtkWidget *);
-
-
-/* Elément réactif pour panneaux de l'éditeur (instance) */
-struct _GPanelItem
-{
-    GObject parent;                         /* A laisser en premier        */
-
-    GtkPanelLauncher *launcher;             /* Eventuel lanceur associé    */
-    GtkWidget *properties;                  /* Propriétés de lancement     */
-
-    GtkTiledPanel **panels;                 /* Instances complètes ouvertes*/
-    size_t pcount;                          /* Quantité de ces instances   */
-
-};
-
-/* Elément réactif pour panneaux de l'éditeur (classe) */
-struct _GPanelItemClass
-{
-    GObjectClass parent;                    /* A laisser en premier        */
-
-    get_panel_item_personality_cb get_personality; /* Fourniture de nature */
-
-    get_panel_item_launcher_cb get_launcher;/* Lancement d'une activité    */
-    get_panel_item_props_cb get_properties; /* Préparation au lancement    */
-    get_panel_item_panel_cb get_panel;      /* Panneau principal           */
-
-};
-
-
-
-#endif  /* _GUI_PANEL_INT_H */
diff --git a/src/gui/panel.c b/src/gui/panel.c
deleted file mode 100644
index a704e63..0000000
--- a/src/gui/panel.c
+++ /dev/null
@@ -1,1207 +0,0 @@
-
-/* Chrysalide - Outil d'analyse de fichiers binaires
- * panel.c - gestion des éléments réactifs spécifiques aux panneaux
- *
- * Copyright (C) 2019-2024 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 "panel.h"
-
-
-#include "panel-int.h"
-
-
-
-/* ---------------------- MANIPULATIONS D'UN PANNEAU GRAPHIQUE ---------------------- */
-
-
-
-
-
-/* Initialise la classe des panneaux graphiques de l'éditeur. */
-static void g_panel_item_class_init(GPanelItemClass *);
-
-/* Initialise une instance de panneau graphique pour l'éditeur. */
-static void g_panel_item_init(GPanelItem *);
-
-/* Supprime toutes les références externes. */
-static void g_panel_item_dispose(GPanelItem *);
-
-/* Procède à la libération totale de la mémoire. */
-static void g_panel_item_finalize(GPanelItem *);
-
-
-
-
-
-/* Indique le type défini pour un élément destiné à un panneau. */
-G_DEFINE_TYPE(GPanelItem, g_panel_item, G_TYPE_OBJECT);
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : class = classe à initialiser.                                *
-*                                                                             *
-*  Description : Initialise la classe des panneaux graphiques de l'éditeur.   *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static void g_panel_item_class_init(GPanelItemClass *class)
-{
-    GObjectClass *object;                   /* Autre version de la classe  */
-
-    object = G_OBJECT_CLASS(class);
-
-    object->dispose = (GObjectFinalizeFunc/* ! */)g_panel_item_dispose;
-    object->finalize = (GObjectFinalizeFunc)g_panel_item_finalize;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : item = instance à initialiser.                               *
-*                                                                             *
-*  Description : Initialise une instance de panneau graphique pour l'éditeur. *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static void g_panel_item_init(GPanelItem *item)
-{
-    //item->docked = false;
-
-    //item->widget = NULL;
-    //item->cached_widget = NULL;
-
-    //item->filter = NULL;
-
-    //g_atomic_int_set(&item->switched, 0);
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : item = instance d'objet GLib à traiter.                      *
-*                                                                             *
-*  Description : Supprime toutes les références externes.                     *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static void g_panel_item_dispose(GPanelItem *item)
-{
-    //g_clear_object(&item->widget);
-    //g_clear_object(&item->cached_widget);
-
-    G_OBJECT_CLASS(g_panel_item_parent_class)->dispose(G_OBJECT(item));
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : item = instance d'objet GLib à traiter.                      *
-*                                                                             *
-*  Description : Procède à la libération totale de la mémoire.                *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static void g_panel_item_finalize(GPanelItem *item)
-{
-    G_OBJECT_CLASS(g_panel_item_parent_class)->finalize(G_OBJECT(item));
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : item = définition de panneau à consulter.                    *
-*                                                                             *
-*  Description : Fournit une indication sur la personnalité du panneau.       *
-*                                                                             *
-*  Retour      : Identifiant lié à la nature du panneau.                      *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-PanelItemPersonality g_panel_item_get_personality(const GPanelItem *item)
-{
-    PanelItemPersonality result;            /* Personnalité à retourner    */
-    GPanelItemClass *class;                 /* Classe à actionner          */
-
-    class = G_PANEL_ITEM_GET_CLASS(item);
-
-    result = class->get_personality(item);
-
-    return result;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : item = définition de panneau à manipuler.                    *
-*                                                                             *
-*  Description : Fournit un composant pour lancer l'activité d'un panneau.    *
-*                                                                             *
-*  Retour      : Composant GTK (déjà ?) mis en place.                         *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-GtkPanelLauncher *g_panel_item_get_launcher(GPanelItem *item)
-{
-    GtkPanelLauncher *result;               /* Composant à retourner       */
-    GPanelItemClass *class;                 /* Classe à actionner          */
-
-    if (item->launcher == NULL)
-    {
-        class = G_PANEL_ITEM_GET_CLASS(item);
-        item->launcher = class->get_launcher(item);
-    }
-
-    result = item->launcher;
-
-    if (result != NULL)
-        ref_object(result);
-
-    return result;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : item = définition de panneau à manipuler.                    *
-*                                                                             *
-*  Description : Fournit un composant pour paramétrer l'activité d'un panneau.*
-*                                                                             *
-*  Retour      : Composant GTK (déjà ?) mis en place.                         *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-GtkWidget *g_panel_item_get_properties(GPanelItem *item)
-{
-    GtkWidget *result;                      /* Composant à retourner       */
-    GPanelItemClass *class;                 /* Classe à actionner          */
-
-    if (item->properties == NULL)
-    {
-        class = G_PANEL_ITEM_GET_CLASS(item);
-        item->properties = class->get_properties(item);
-    }
-
-    result = item->properties;
-
-    if (result != NULL)
-        ref_object(result);
-
-    return result;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : item = définition de panneau à manipuler.                    *
-*                                                                             *
-*  Description : Fournit un composant représentant un panneau graphique.      *
-*                                                                             *
-*  Retour      : Composant GTK (déjà ?) mis en place.                         *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-GtkTiledPanel *g_panel_item_get_panel(GPanelItem *item)
-{
-    GtkTiledPanel *result;                  /* Composant à retourner       */
-    GPanelItemClass *class;                 /* Classe à actionner          */
-
-    if (item->pcount == 0 /* || !singleton */)
-    {
-        class = G_PANEL_ITEM_GET_CLASS(item);
-        result = class->get_panel(item, item->properties);
-
-        if (result != NULL)
-        {
-            item->panels = realloc(item->panels, ++item->pcount * sizeof(GtkTiledPanel *));
-            item->panels[item->pcount - 1] = result;
-        }
-
-    }
-
-    else
-        result = item->panels[item->pcount - 1];
-
-    if (result != NULL)
-        ref_object(result);
-
-    return result;
-
-}
-
-
-
-
-
-
-
-
-
-
-
-
-
-#if 0
-
-
-#include <assert.h>
-#include <stdio.h>
-#include <string.h>
-
-
-#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"
-#include "../plugins/pglist.h"
-
-
-
-/* ------------------------- COEUR DES PANNEAUX D'AFFICHAGE ------------------------- */
-
-
-
-
-/* ------------------------- COEUR D'UN PANNEAU D'AFFICHAGE ------------------------- */
-
-
-/* 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 *);
-
-/* Fournit le nom long du composant encapsulable. */
-static char *gtk_panel_item_get_desc(const GPanelItem *);
-
-/* Détermine si un panneau peut être filtré. */
-static bool gtk_panel_item_can_search(const GPanelItem *);
-
-/* Fournit le composant graphique intégrable dans un ensemble. */
-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 *);
-
-
-
-/* ---------------------- MECANISMES DE MISE A JOUR DE PANNEAU ---------------------- */
-
-
-/* Présente une copie de l'affichage du composant rafraîchi. */
-static gboolean g_panel_item_draw_mask(GtkWidget *, cairo_t *, GPanelItem *);
-
-
-
-/* ---------------------------------------------------------------------------------- */
-/*                           COEUR DES PANNEAUX D'AFFICHAGE                           */
-/* ---------------------------------------------------------------------------------- */
-
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : class = classe à consulter.                                  *
-*                                                                             *
-*  Description : Fournit une indication sur la personnalité du panneau.       *
-*                                                                             *
-*  Retour      : Identifiant lié à la nature unique du panneau.               *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-PanelItemPersonality gtk_panel_item_class_get_personality_singleton(const GPanelItemClass *class)
-{
-    PanelItemPersonality result;            /* Personnalité à retourner    */
-
-    result = PIP_SINGLETON;
-
-    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   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-bool gtk_panel_item_class_dock_at_startup(const GPanelItemClass *class)
-{
-    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
-
-    config = get_main_configuration();
-
-    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;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : class = classe associée à la consultation.                   *
-*                                                                             *
-*  Description : Renvoie false lors d'une consultation de la classe.          *
-*                                                                             *
-*  Retour      : false.                                                       *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-bool gtk_panel_item_class_return_false(const GPanelItemClass *class)
-{
-    bool result;                            /* Statut à retourner          */
-
-    result = false;
-
-    return result;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : class = classe associée à la consultation.                   *
-*                                                                             *
-*  Description : Renvoie true lors d'une consultation de la classe.           *
-*                                                                             *
-*  Retour      : true.                                                        *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-bool gtk_panel_item_class_return_true(const GPanelItemClass *class)
-{
-    bool result;                            /* Statut à retourner          */
-
-    result = true;
-
-    return result;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : class = classe à consulter.                                  *
-*                                                                             *
-*  Description : Détermine si un panneau peut être filtré.                    *
-*                                                                             *
-*  Retour      : Bilan de la consultation.                                    *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-bool gtk_panel_item_class_can_search(const GPanelItemClass *class)
-{
-    bool result;                            /* Statut à retourner          */
-
-    result = class->can_search(class);
-
-    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   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-char *gtk_panel_item_class_get_path(const GPanelItemClass *class)
-{
-    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
-
-    config = get_main_configuration();
-
-    key = gtk_panel_item_class_build_configuration_key(class, "path");
-
-#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;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  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   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-char *gtk_panel_item_class_get_key_bindings(const GPanelItemClass *class)
-{
-    char *result;                           /* Emplacement à retourner     */
-
-    if (class->get_bindings != NULL)
-        result = class->get_bindings(class);
-
-    else
-        result = NULL;
-
-    return result;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  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.   *
-*                                                                             *
-*  Retour      : Chaîne de caractères à libérer après usage.                  *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-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_class_get_key(G_EDITOR_ITEM_CLASS(class));
-
-    asprintf(&result, "gui.panels.%s.%s", attrib, name);
-
-    result = strrpl(result, " ", "_");
-
-    result = strlower(result);
-
-    return result;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : class  = classe de panneau à consulter.                      *
-*                config = configuration à compléter.                          *
-*                                                                             *
-*  Description : Met en place les bases de la configuration d'un panneau.     *
-*                                                                             *
-*  Retour      : Bilan de l'opération.                                        *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-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 ?   */
-    char *path;                             /* Localisation du panneau     */
-
-    key = gtk_panel_item_class_build_configuration_key(class, "dock_at_startup");
-
-    dock_at_startup = class->dock_at_startup(class);
-
-    result = g_generic_config_create_param_if_not_exist(config, key, CPT_BOOLEAN, dock_at_startup);
-
-    free(key);
-
-    if (!result)
-        goto exit;
-
-    key = gtk_panel_item_class_build_configuration_key(class, "path");
-
-    path = class->get_path(class);
-
-    result = g_generic_config_create_param_if_not_exist(config, key, CPT_STRING, path);
-
-    free(path);
-
-    free(key);
-
- exit:
-
-    return result;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : type = type de panneau à mettre en place.                    *
-*                path = emplacement d'affichage ou NULL.                      *
-*                                                                             *
-*  Description : Crée un élément de panneau réactif.                          *
-*                                                                             *
-*  Retour      : Adresse de la structure mise en place.                       *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-GPanelItem *g_panel_item_new(GType type, const char *path)
-{
-    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);
-
-    personality = gtk_panel_item_class_get_personality(class);
-    assert(path != NULL || personality == PIP_PERSISTENT_SINGLETON);
-
-    g_type_class_unref(class);
-
-    if (personality == PIP_PERSISTENT_SINGLETON || personality == PIP_SINGLETON)
-    {
-        result = G_PANEL_ITEM(find_editor_item_by_type(type));
-
-        if (result != NULL)
-            goto singleton;
-
-    }
-
-    result = create_object_from_type(type);
-
-    grid = get_tiled_grid();
-
-    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));
-
-    notify_panel_creation(result);
-
- singleton:
-
-    if (path != NULL)
-    {
-        if (path[0] != '\0')
-            gtk_panel_item_set_path(result, path);
-
-        g_panel_item_dock(result);
-
-    }
-
-    return result;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : item = instance de panneau à consulter.                      *
-*                                                                             *
-*  Description : Indique le composant graphique principal du panneau.         *
-*                                                                             *
-*  Retour      : Composant graphique avec nom constituant le panneau.         *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-GNamedWidget *gtk_panel_item_get_named_widget(const GPanelItem *item)
-{
-    GNamedWidget *result;                   /* Composant nommé à retourner */
-
-    result = item->widget;
-
-    g_object_ref(G_OBJECT(result));
-
-    return result;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : item = instance GTK dont l'interface est à consulter.        *
-*                                                                             *
-*  Description : Fournit le nom court du composant encapsulable.              *
-*                                                                             *
-*  Retour      : Désignation humaine pour titre d'onglet ou de fenêtre.       *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static char *gtk_panel_item_get_name(const GPanelItem *item)
-{
-    char *result;                           /* Désignation à retourner     */
-
-    result = g_named_widget_get_name(G_NAMED_WIDGET(item->widget), false);
-
-    return result;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : item = instance GTK dont l'interface est à consulter.        *
-*                                                                             *
-*  Description : Fournit le nom long du composant encapsulable.               *
-*                                                                             *
-*  Retour      : Désignation humaine pour titre d'onglet ou de fenêtre.       *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static char *gtk_panel_item_get_desc(const GPanelItem *item)
-{
-    char *result;                           /* Description à retourner     */
-
-    result = g_named_widget_get_name(G_NAMED_WIDGET(item->widget), true);
-
-    return result;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  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;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : item = instance GTK dont l'interface est à consulter.        *
-*                                                                             *
-*  Description : Fournit le composant graphique intégrable dans un ensemble.  *
-*                                                                             *
-*  Retour      : Composant graphique prêt à emploi.                           *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static GtkWidget *gtk_panel_item_get_widget(GPanelItem *item)
-{
-    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);
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : item = composant à présenter à l'affichage.                  *
-*                                                                             *
-*  Description : Place un panneau dans l'ensemble affiché.                    *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-void g_panel_item_dock(GPanelItem *item)
-{
-    assert(!item->docked);
-
-    g_signal_emit_by_name(item, "dock-request");
-
-    if (G_PANEL_ITEM_GET_CLASS(item)->ack_dock != NULL)
-        G_PANEL_ITEM_GET_CLASS(item)->ack_dock(item);
-
-    notify_panel_docking(item, true);
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : item = composant d'affichage à mettre à jour.                *
-*                status = nouvel état d'encapsulation.                        *
-*                                                                             *
-*  Description : Définit si le composant repose sur un support de l'éditeur.  *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-void g_panel_item_set_dock_at_startup(GPanelItem *item, bool status)
-{
-    char *key;                              /* Clef d'accès à un paramètre */
-
-    item->docked = status;
-
-    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, status);
-
-    free(key);
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : item = composant d'affichage à consulter.                    *
-*                                                                             *
-*  Description : Indique si le composant repose sur un support de l'éditeur.  *
-*                                                                             *
-*  Retour      : true si le composant est bien incrusté quelque part.         *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-bool g_panel_item_is_docked(const GPanelItem *item)
-{
-    bool result;                            /* Statut à retourner          */
-
-    result = item->docked;
-
-    return result;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : item = composant à retirer de l'affichage.                   *
-*                                                                             *
-*  Description : Supprime un panneau de l'ensemble affiché.                   *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-void g_panel_item_undock(GPanelItem *item)
-{
-    PanelItemPersonality personality;       /* Caractéristique de panneau  */
-
-    assert(item->docked);
-
-    g_signal_emit_by_name(item, "undock-request");
-
-    if (G_PANEL_ITEM_GET_CLASS(item)->ack_undock != NULL)
-        G_PANEL_ITEM_GET_CLASS(item)->ack_undock(item);
-
-    notify_panel_docking(item, false);
-
-    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));
-
-}
-
-
-
-/* ---------------------------------------------------------------------------------- */
-/*                        MECANISMES DE MISE A JOUR DE PANNEAU                        */
-/* ---------------------------------------------------------------------------------- */
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : item = panneau ciblé par une mise à jour.                    *
-*                                                                             *
-*  Description : Obtient le groupe de travail dédié à une mise à jour.        *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-wgroup_id_t g_panel_item_get_group(const GPanelItem *item)
-{
-    wgroup_id_t result;                     /* Identifiant à retourner     */
-
-    result = G_PANEL_ITEM_GET_CLASS(item)->gid;
-
-    return result;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : widget = composant graphique sur lequel dessiner.            *
-*                cr     = contexte graphique pour le dessin.                  *
-*                panel = panneau ciblé par une mise à jour.                   *
-*                                                                             *
-*  Description : Présente une copie de l'affichage du composant rafraîchi.    *
-*                                                                             *
-*  Retour      : FALSE afin de poursuivre les traitements.                    *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static gboolean g_panel_item_draw_mask(GtkWidget *widget, cairo_t *cr, GPanelItem *item)
-{
-    int width;                              /* Largeur du composant actuel */
-    int height;                             /* Hauteur du composant actuel */
-
-    width = gtk_widget_get_allocated_width(widget);
-    height = gtk_widget_get_allocated_height(widget);
-
-    cairo_save(cr);
-
-    cairo_set_source_surface(cr, item->surface, 0, 0);
-    cairo_rectangle(cr, 0, 0, width, height);
-
-    cairo_set_operator(cr, CAIRO_OPERATOR_SOURCE);
-    cairo_fill(cr);
-
-    cairo_restore(cr);
-
-    return FALSE;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : panel = panneau ciblé par une mise à jour.                   *
-*                                                                             *
-*  Description : Bascule l'affichage d'un panneau avant sa mise à jour.       *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-void g_panel_item_switch_to_updating_mask(GPanelItem *item)
-{
-    GtkBuilder *builder;                    /* Constructeur sous-jacent    */
-    GtkWidget *content;                     /* Composant à faire évoluer   */
-    GdkWindow *window;                      /* Fenêtre au contenu à copier */
-    int width;                              /* Largeur du composant actuel */
-    int height;                             /* Hauteur du composant actuel */
-    cairo_t *cr;                            /* Pinceau pour les dessins    */
-    GtkAdjustment *adj;                     /* Défilement éventuel         */
-    GtkStack *stack;                        /* Pile de composants GTK      */
-    GtkWidget *mask;                        /* Masque des travaux          */
-
-    if (g_atomic_int_add(&item->switched, 1) > 0)
-        return;
-
-    /* Copie de l'affichage courant */
-
-    assert(item->surface == NULL);
-
-    builder = gtk_built_named_widget_get_builder(GTK_BUILT_NAMED_WIDGET(item->widget));
-
-    content = GTK_WIDGET(gtk_builder_get_object(builder, "content"));
-
-    window = gtk_widget_get_window(content);
-
-    if (window != NULL)
-    {
-        width = gtk_widget_get_allocated_width(content);
-        height = gtk_widget_get_allocated_height(content);
-
-        item->surface = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, width, height);
-
-        cr = cairo_create(item->surface);
-
-        gdk_cairo_set_source_window(cr, window, 0, 0);
-
-        cairo_paint(cr);
-
-        cairo_destroy(cr);
-
-    }
-
-    /* Sauvegarde de l'éventuelle position */
-
-    if (GTK_IS_SCROLLED_WINDOW(content))
-    {
-        adj = gtk_scrolled_window_get_hadjustment(GTK_SCROLLED_WINDOW(content));
-        item->hadj_value = gtk_adjustment_get_value(adj);
-
-        adj = gtk_scrolled_window_get_vadjustment(GTK_SCROLLED_WINDOW(content));
-        item->vadj_value = gtk_adjustment_get_value(adj);
-
-    }
-
-    /* Opération de basculement effectif */
-
-    stack = GTK_STACK(gtk_builder_get_object(builder, "stack"));
-
-    mask = GTK_WIDGET(gtk_builder_get_object(builder, "mask"));
-
-    gtk_spinner_start(GTK_SPINNER(mask));
-
-    if (item->surface != NULL)
-        g_signal_connect(mask, "draw", G_CALLBACK(g_panel_item_draw_mask), item);
-
-    gtk_stack_set_visible_child(stack, mask);
-
-    g_object_unref(G_OBJECT(builder));
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : panel = panneau ciblé par une mise à jour.                   *
-*                                                                             *
-*  Description : Bascule l'affichage d'un panneau après sa mise à jour.       *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-void g_panel_item_switch_to_updated_content(GPanelItem *item)
-{
-    GtkBuilder *builder;                    /* Constructeur sous-jacent    */
-    GtkWidget *content;                     /* Composant à faire évoluer   */
-    GtkAdjustment *adj;                     /* Défilement éventuel         */
-    GtkStack *stack;                        /* Pile de composants GTK      */
-    GtkWidget *mask;                        /* Masque des travaux          */
-
-    if (g_atomic_int_get(&item->switched) > 1)
-        goto skip;
-
-    /* Restauration d'une éventuelle position */
-
-    builder = gtk_built_named_widget_get_builder(GTK_BUILT_NAMED_WIDGET(item->widget));
-
-    content = GTK_WIDGET(gtk_builder_get_object(builder, "content"));
-
-    if (GTK_IS_SCROLLED_WINDOW(content))
-    {
-        adj = gtk_scrolled_window_get_hadjustment(GTK_SCROLLED_WINDOW(content));
-        gtk_adjustment_set_value(adj, item->hadj_value);
-
-        adj = gtk_scrolled_window_get_vadjustment(GTK_SCROLLED_WINDOW(content));
-        gtk_adjustment_set_value(adj, item->vadj_value);
-
-    }
-
-    /* Opération de basculement effectif */
-
-    stack = GTK_STACK(gtk_builder_get_object(builder, "stack"));
-
-    gtk_stack_set_visible_child(stack, content);
-
-    mask = GTK_WIDGET(gtk_builder_get_object(builder, "mask"));
-
-    g_signal_handlers_disconnect_by_func(mask, G_CALLBACK(g_panel_item_draw_mask), item);
-
-    gtk_spinner_stop(GTK_SPINNER(mask));
-
-    /* Supression de la copie d'affichage */
-
-    if (item->surface != NULL)
-    {
-        cairo_surface_destroy(item->surface);
-        item->surface = NULL;
-    }
-
-    g_object_unref(G_OBJECT(builder));
-
- skip:
-
-    g_atomic_int_dec_and_test(&item->switched);
-
-}
-
-
-#endif
diff --git a/src/gui/panel.h b/src/gui/panel.h
deleted file mode 100644
index b14daa8..0000000
--- a/src/gui/panel.h
+++ /dev/null
@@ -1,149 +0,0 @@
-
-/* Chrysalide - Outil d'analyse de fichiers binaires
- * panel.h - prototypes pour la gestion des éléments réactifs spécifiques aux panneaux
- *
- * Copyright (C) 2019-2024 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_PANEL_H
-#define _GUI_PANEL_H
-
-
-#include <gtk/gtk.h>
-
-
-#include "../glibext/helpers.h"
-#include "../gtkext/panel.h"
-#include "../gtkext/launcher.h"
-
-
-
-#define G_TYPE_PANEL_ITEM (g_panel_item_get_type())
-
-DECLARE_GTYPE(GPanelItem, g_panel_item, G, PANEL_ITEM);
-
-
-/* Types de panneaux pour éditeur */
-typedef enum _PanelItemPersonality
-{
-    PIP_NONE,                               /* Pas de particularité        */
-
-    PIP_MAIN_PANEL,                         /* Panneau principal           */
-    PIP_SINGLETON,                          /* Instance unique             */
-
-    PIP_COUNT
-
-} PanelItemPersonality;
-
-
-/* Fournit une indication sur la personnalité du panneau. */
-PanelItemPersonality g_panel_item_get_personality(const GPanelItem *);
-
-/* Fournit un composant pour lancer l'activité d'un panneau. */
-GtkPanelLauncher *g_panel_item_get_launcher(GPanelItem *);
-
-/* Fournit un composant pour paramétrer l'activité d'un panneau. */
-GtkWidget *g_panel_item_get_properties(GPanelItem *);
-
-/* Fournit un composant représentant un panneau graphique. */
-GtkTiledPanel *g_panel_item_get_panel(GPanelItem *);
-
-
-
-
-
-
-
-
-
-#if 0
-
-
-#include <stdbool.h>
-#include <gtk/gtk.h>
-
-
-#include "../glibext/configuration.h"
-#include "../glibext/named.h"
-
-
-
-#define G_TYPE_PANEL_ITEM            g_panel_item_get_type()
-#define G_PANEL_ITEM(obj)            (G_TYPE_CHECK_INSTANCE_CAST((obj), G_TYPE_PANEL_ITEM, GPanelItem))
-#define G_IS_PANEL_ITEM(obj)         (G_TYPE_CHECK_INSTANCE_TYPE((obj), G_TYPE_PANEL_ITEM))
-#define G_PANEL_ITEM_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_PANEL_ITEM, GPanelItemClass))
-#define G_IS_PANEL_ITEM_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_PANEL_ITEM))
-#define G_PANEL_ITEM_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_PANEL_ITEM, GPanelItemClass))
-
-
-/* Elément réactif pour panneaux de l'éditeur (instance) */
-typedef struct _GPanelItem GPanelItem;
-
-/* Elément réactif pour panneaux de l'éditeur (classe) */
-typedef struct _GPanelItemClass GPanelItemClass;
-
-
-
-
-/* Indique le type défini pour un élément destiné à un panneau. */
-GType g_panel_item_get_type(void);
-
-/* Fournit une indication d'accroche du panneau au démarrage. */
-bool gtk_panel_item_class_dock_at_startup(const GPanelItemClass *);
-
-/* Détermine si un panneau peut être filtré. */
-bool gtk_panel_item_class_can_search(const GPanelItemClass *);
-
-/* Indique le chemin initial de la localisation d'un panneau. */
-char *gtk_panel_item_class_get_path(const GPanelItemClass *);
-
-/* Indique la définition d'un éventuel raccourci clavier. */
-char *gtk_panel_item_class_get_key_bindings(const GPanelItemClass *);
-
-/* 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 *);
-
-/* 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_at_startup(GPanelItem *, bool);
-
-/* Indique si le composant repose sur un support de l'éditeur. */
-bool g_panel_item_is_docked(const GPanelItem *);
-
-/* Supprime un panneau de l'ensemble affiché. */
-void g_panel_item_undock(GPanelItem *);
-
-
-#endif
-
-
-
-#endif  /* _GUI_PANEL_H */
diff --git a/src/gui/panels/Makefile.am b/src/gui/panels/Makefile.am
index 525b1f6..2765405 100644
--- a/src/gui/panels/Makefile.am
+++ b/src/gui/panels/Makefile.am
@@ -38,7 +38,7 @@ IMG_PATH = ../../../data/images
 
 RES_FILES =									\
 	binary.ui								\
-	binary-props.ui							\
+	binary-params.ui						\
 	$(IMG_PATH)/binfile-symbolic.svg		\
 	welcome.ui								\
 	welcome-hints.txt						\
@@ -47,6 +47,8 @@ RES_FILES =									\
 libguipanels4_la_SOURCES =					\
 	binary-int.h							\
 	binary.h binary.c						\
+	binary-params-int.h						\
+	binary-params.h binary-params.c			\
 	resources.h resources.c					\
 	welcome-int.h						 	\
 	welcome.h welcome.c
diff --git a/src/gui/panels/binary-int.h b/src/gui/panels/binary-int.h
index f68da9b..5116f5c 100644
--- a/src/gui/panels/binary-int.h
+++ b/src/gui/panels/binary-int.h
@@ -27,14 +27,10 @@
 
 
 #include "binary.h"
-#include "../panel-int.h"
 #include "../../gtkext/panel-int.h"
 
 
 
-/* ------------------------- COEUR D'UN PANNEAU D'AFFICHAGE ------------------------- */
-
-
 /* Panneau d'accueil par défaut (instance) */
 struct _GtkBinaryPanel
 {
@@ -53,23 +49,4 @@ struct _GtkBinaryPanelClass
 
 
 
-/* ---------------------- MANIPULATIONS D'UN PANNEAU GRAPHIQUE ---------------------- */
-
-
-/* Définition pour gestion par le framework d'un panneau graphique (instance) */
-struct _GBinaryPanel
-{
-    GPanelItem parent;                      /* A laisser en premier        */
-
-};
-
-/* Définition pour gestion par le framework d'un panneau graphique (classe) */
-struct _GBinaryPanelClass
-{
-    GPanelItemClass parent;                 /* A laisser en premier        */
-
-};
-
-
-
 #endif  /* _GUI_PANELS_BINARY_INT_H */
diff --git a/src/gui/panels/binary-params-int.h b/src/gui/panels/binary-params-int.h
new file mode 100644
index 0000000..0fbef24
--- /dev/null
+++ b/src/gui/panels/binary-params-int.h
@@ -0,0 +1,50 @@
+
+/* Chrysalide - Outil d'analyse de fichiers binaires
+ * binary-params-int.h - définitions internes pour l'édition des paramètres initiaux d'un chargement de binaire
+ *
+ * Copyright (C) 2025 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 Chrysalide.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#ifndef _GUI_PANELS_BINARY_PARAMS_INT_H
+#define _GUI_PANELS_BINARY_PARAMS_INT_H
+
+
+#include "binary-params.h"
+
+
+
+/* Composant pour les paramètres de chargement d'un binaire (instance) */
+struct _GtkBinaryParameters
+{
+    GtkGrid parent;                         /* A laisser en premier        */
+
+    GtkEntry *filename;                     /* CHemin d'un binaire         */
+
+};
+
+/* Composant pour les paramètres de chargement d'un binaire (classe) */
+struct _GtkBinaryParametersClass
+{
+    GtkGridClass parent;                    /* A laisser en premier        */
+
+};
+
+
+
+#endif  /* _GUI_PANELS_BINARY_PARAMS_INT_H */
diff --git a/src/gui/panels/binary-params.c b/src/gui/panels/binary-params.c
new file mode 100644
index 0000000..1059761
--- /dev/null
+++ b/src/gui/panels/binary-params.c
@@ -0,0 +1,178 @@
+
+/* Chrysalide - Outil d'analyse de fichiers binaires
+ * binary-params.c - édition des paramètres initiaux d'un chargement de binaire
+ *
+ * Copyright (C) 2025 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 Chrysalide.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#include "binary-params.h"
+
+
+#include "binary.h"
+#include "binary-params-int.h"
+#include "../window.h"
+#include "../../analysis/contents/file.h"
+#include "../../gtkext/helpers.h"
+
+
+
+/* Initialise la classe des composants d'édition de paramètres. */
+static void gtk_binary_parameters_class_init(GtkBinaryParametersClass *);
+
+/* Initialise une instance de composant d'édition de paramètres. */
+static void gtk_binary_parameters_init(GtkBinaryParameters *);
+
+/* Supprime toutes les références externes. */
+static void gtk_binary_parameters_dispose(GObject *);
+
+/* Procède à la libération totale de la mémoire. */
+static void gtk_binary_parameters_finalize(GObject *);
+
+/* Ouvre une boîte de dialogue pour récupérer un fichier. */
+static void gtk_binary_parameters_on_new_file_entry_icon_release(GtkEntry *, GtkEntryIconPosition, GtkBinaryParameters *);
+
+
+
+/* Détermine le type du composant d'édition des paramètres de chargement. */
+G_DEFINE_TYPE(GtkBinaryParameters, gtk_binary_parameters, GTK_TYPE_GRID);
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : class = classe GTK à initialiser.                            *
+*                                                                             *
+*  Description : Initialise la classe des composants d'édition de paramètres. *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void gtk_binary_parameters_class_init(GtkBinaryParametersClass *class)
+{
+    GObjectClass *object;                   /* Plus haut niveau équivalent */
+    GtkWidgetClass *widget;                 /* Classe de haut niveau       */
+
+    object = G_OBJECT_CLASS(class);
+
+    object->dispose = gtk_binary_parameters_dispose;
+    object->finalize = gtk_binary_parameters_finalize;
+
+    widget = GTK_WIDGET_CLASS(class);
+
+    gtk_widget_class_set_template_from_resource(widget, "/re/chrysalide/framework/gui/panels/binary-params.ui");
+
+    gtk_widget_class_bind_template_callback_full(widget, BUILDER_CB(gtk_binary_parameters_on_new_file_entry_icon_release));
+
+    gtk_widget_class_bind_template_child(widget, GtkBinaryParameters, filename);
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : params = composant GTK à initialiser.                        *
+*                                                                             *
+*  Description : Initialise une instance de composant d'édition de paramètres.*
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void gtk_binary_parameters_init(GtkBinaryParameters *params)
+{
+    gtk_widget_init_template(GTK_WIDGET(params));
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : object = instance d'objet GLib à traiter.                    *
+*                                                                             *
+*  Description : Supprime toutes les références externes.                     *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void gtk_binary_parameters_dispose(GObject *object)
+{
+    gtk_widget_dispose_template(GTK_WIDGET(object), GTK_TYPE_BINARY_PARAMETERS);
+
+    G_OBJECT_CLASS(gtk_binary_parameters_parent_class)->dispose(object);
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : object = instance d'objet GLib à traiter.                    *
+*                                                                             *
+*  Description : Procède à la libération totale de la mémoire.                *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void gtk_binary_parameters_finalize(GObject *object)
+{
+    G_OBJECT_CLASS(gtk_binary_parameters_parent_class)->finalize(object);
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : entry    = zone de saisie concernée par l'appel.             *
+*                icon_pos = position de l'icone incrustée dans la zone.       *
+*                params   = composant d'édition des paramètres.               *
+*                                                                             *
+*  Description : Ouvre une boîte de dialogue pour récupérer un fichier.       *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void gtk_binary_parameters_on_new_file_entry_icon_release(GtkEntry *entry, GtkEntryIconPosition icon_pos, GtkBinaryParameters *params)
+{
+    GtkRoot *root;                          /* Racine du composant         */
+    GBinContent *content;                   /* Contenu binaire à afficher  */
+    GtkTiledPanel *tiled;                   /* Panneau d'affichage complet */
+
+    root = gtk_widget_get_root(GTK_WIDGET(entry));
+
+    content = g_file_content_new("/bin/id");
+
+    tiled = gtk_binary_panel_new_for_content(content);
+
+    unref_object(content);
+
+    gtk_framework_window_add(GTK_FRAMEWORK_WINDOW(root), tiled);
+
+}
diff --git a/src/gui/panels/binary-params.h b/src/gui/panels/binary-params.h
new file mode 100644
index 0000000..450da25
--- /dev/null
+++ b/src/gui/panels/binary-params.h
@@ -0,0 +1,41 @@
+
+/* Chrysalide - Outil d'analyse de fichiers binaires
+ * binary-params.h - prototypes pour l'édition des paramètres initiaux d'un chargement de binaire
+ *
+ * Copyright (C) 2025 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 Chrysalide.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#ifndef _GUI_PANELS_BINARY_PARAMS_H
+#define _GUI_PANELS_BINARY_PARAMS_H
+
+
+#include <gtk/gtk.h>
+
+
+#include "../../glibext/helpers.h"
+
+
+
+#define GTK_TYPE_BINARY_PARAMETERS (gtk_binary_parameters_get_type())
+
+DECLARE_GTYPE(GtkBinaryParameters, gtk_binary_parameters, GTK, BINARY_PARAMETERS);
+
+
+
+#endif  /* _GUI_PANELS_BINARY_PARAMS_H */
diff --git a/src/gui/panels/binary-props.ui b/src/gui/panels/binary-params.ui
index bd48ea8..dcbaf7c 100644
--- a/src/gui/panels/binary-props.ui
+++ b/src/gui/panels/binary-params.ui
@@ -1,13 +1,14 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <interface>
 
-    <object class="GtkGrid" id="properties">
+    <template class="GtkBinaryParameters" parent="GtkGrid">
         <property name="margin-bottom">12</property>
         <property name="margin-end">12</property>
         <property name="margin-start">12</property>
         <property name="margin-top">12</property>
         <property name="column-spacing">12</property>
         <property name="row-spacing">8</property>
+
         <child>
             <object class="GtkLabel">
                 <property name="label">Load and analyze a new file:</property>
@@ -18,8 +19,9 @@
                 </layout>
             </object>
         </child>
+
         <child>
-            <object class="GtkEntry" id="new_file">
+            <object class="GtkEntry" id="filename">
                 <property name="secondary-icon-name">document-open-symbolic</property>
                 <property name="placeholder-text">File location</property>
                 <property name="hexpand">TRUE</property>
@@ -31,9 +33,10 @@
                 <style>
                     <class name="background"/>
                 </style>
-                <signal name="icon-release" handler="g_binary_panel_on_new_file_entry_icon_release"/>
+                <signal name="icon-release" handler="gtk_binary_parameters_on_new_file_entry_icon_release"/>
             </object>
         </child>
-    </object>
+
+    </template>
 
 </interface>
diff --git a/src/gui/panels/binary.c b/src/gui/panels/binary.c
index 23426e3..bb98c10 100644
--- a/src/gui/panels/binary.c
+++ b/src/gui/panels/binary.c
@@ -29,8 +29,6 @@
 
 
 #include "binary-int.h"
-#include "../window.h"
-#include "../../analysis/contents/file.h"
 #include "../../gtkext/helpers.h"
 #include "../../gtkext/hexview.h"
 
@@ -46,10 +44,10 @@ static void gtk_binary_panel_class_init(GtkBinaryPanelClass *);
 static void gtk_binary_panel_init(GtkBinaryPanel *);
 
 /* Supprime toutes les références externes. */
-static void gtk_binary_panel_dispose(GtkBinaryPanel *);
+static void gtk_binary_panel_dispose(GObject *);
 
 /* Procède à la libération totale de la mémoire. */
-static void gtk_binary_panel_finalize(GtkBinaryPanel *);
+static void gtk_binary_panel_finalize(GObject *);
 
 
 
@@ -60,43 +58,6 @@ static void gtk_binary_panel_finalize(GtkBinaryPanel *);
 
 
 
-/* ---------------------- MANIPULATIONS D'UN PANNEAU GRAPHIQUE ---------------------- */
-
-
-/* Initialise la classe des panneaux graphiques pour binaires. */
-static void g_binary_panel_class_init(GBinaryPanelClass *);
-
-/* Initialise une instance de panneau graphique pour binaire. */
-static void g_binary_panel_init(GBinaryPanel *);
-
-/* Supprime toutes les références externes. */
-static void g_binary_panel_dispose(GBinaryPanel *);
-
-/* Procède à la libération totale de la mémoire. */
-static void g_binary_panel_finalize(GBinaryPanel *);
-
-
-
-/* --------------------- IMPLEMENTATION DES FONCTIONS DE CLASSE --------------------- */
-
-
-/* Fournit une indication sur la personnalité du panneau. */
-static PanelItemPersonality g_binary_panel_get_personality(const GBinaryPanel *);
-
-/* Fournit un composant pour lancer l'activité d'un panneau. */
-static GtkPanelLauncher *g_binary_panel_get_launcher(GPanelItem *);
-
-/* Fournit un composant pour paramétrer l'activité d'un panneau. */
-static GtkWidget *g_binary_panel_get_properties(GBinaryPanel *);
-
-/* Ouvre une boîte de dialogue pour récupérer un fichier. */
-static void g_binary_panel_on_new_file_entry_icon_release(GtkEntry *, GtkEntryIconPosition, GBinaryPanel *);
-
-/* Fournit un composant représentant un panneau graphique. */
-static GtkTiledPanel *g_binary_panel_get_panel(GBinaryPanel *, GtkWidget *);
-
-
-
 /* ---------------------------------------------------------------------------------- */
 /*                           COEUR D'UN PANNEAU D'AFFICHAGE                           */
 /* ---------------------------------------------------------------------------------- */
@@ -125,8 +86,8 @@ static void gtk_binary_panel_class_init(GtkBinaryPanelClass *class)
 
     object = G_OBJECT_CLASS(class);
 
-    object->dispose = (GObjectFinalizeFunc/* ! */)gtk_binary_panel_dispose;
-    object->finalize = (GObjectFinalizeFunc)gtk_binary_panel_finalize;
+    object->dispose = gtk_binary_panel_dispose;
+    object->finalize = gtk_binary_panel_finalize;
 
     widget = GTK_WIDGET_CLASS(class);
 
@@ -158,7 +119,7 @@ static void gtk_binary_panel_init(GtkBinaryPanel *panel)
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : panel = instance d'objet GLib à traiter.                     *
+*  Paramètres  : object = instance d'objet GLib à traiter.                    *
 *                                                                             *
 *  Description : Supprime toutes les références externes.                     *
 *                                                                             *
@@ -168,18 +129,18 @@ static void gtk_binary_panel_init(GtkBinaryPanel *panel)
 *                                                                             *
 ******************************************************************************/
 
-static void gtk_binary_panel_dispose(GtkBinaryPanel *panel)
+static void gtk_binary_panel_dispose(GObject *object)
 {
-    gtk_widget_dispose_template(GTK_WIDGET(panel), GTK_TYPE_BINARY_PANEL);
+    gtk_widget_dispose_template(GTK_WIDGET(object), GTK_TYPE_BINARY_PANEL);
 
-    G_OBJECT_CLASS(gtk_binary_panel_parent_class)->dispose(G_OBJECT(panel));
+    G_OBJECT_CLASS(gtk_binary_panel_parent_class)->dispose(object);
 
 }
 
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : panel = instance d'objet GLib à traiter.                     *
+*  Paramètres  : object = instance d'objet GLib à traiter.                    *
 *                                                                             *
 *  Description : Procède à la libération totale de la mémoire.                *
 *                                                                             *
@@ -189,9 +150,9 @@ static void gtk_binary_panel_dispose(GtkBinaryPanel *panel)
 *                                                                             *
 ******************************************************************************/
 
-static void gtk_binary_panel_finalize(GtkBinaryPanel *panel)
+static void gtk_binary_panel_finalize(GObject *object)
 {
-    G_OBJECT_CLASS(gtk_binary_panel_parent_class)->finalize(G_OBJECT(panel));
+    G_OBJECT_CLASS(gtk_binary_panel_parent_class)->finalize(object);
 
 }
 
@@ -235,282 +196,3 @@ GtkTiledPanel *gtk_binary_panel_new_for_content(GBinContent *content)
 
 
 
-
-/* ---------------------------------------------------------------------------------- */
-/*                        MANIPULATIONS D'UN PANNEAU GRAPHIQUE                        */
-/* ---------------------------------------------------------------------------------- */
-
-
-/* Indique le type défini pour une manipulation de panneau pour binaires. */
-G_DEFINE_TYPE(GBinaryPanel, g_binary_panel, G_TYPE_PANEL_ITEM);
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : class = classe à initialiser.                                *
-*                                                                             *
-*  Description : Initialise la classe des panneaux graphiques pour binaires.  *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static void g_binary_panel_class_init(GBinaryPanelClass *class)
-{
-    GObjectClass *object;                   /* Autre version de la classe  */
-    GPanelItemClass *panel;                 /* Encore une autre vision...  */
-
-    object = G_OBJECT_CLASS(class);
-
-    object->dispose = (GObjectFinalizeFunc/* ! */)g_binary_panel_dispose;
-    object->finalize = (GObjectFinalizeFunc)g_binary_panel_finalize;
-
-    panel = G_PANEL_ITEM_CLASS(class);
-
-    panel->get_personality = (get_panel_item_personality_cb)g_binary_panel_get_personality;
-    panel->get_launcher = g_binary_panel_get_launcher;
-    panel->get_properties = (get_panel_item_props_cb)g_binary_panel_get_properties;
-    panel->get_panel = (get_panel_item_panel_cb)g_binary_panel_get_panel;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : panel = instance à initialiser.                              *
-*                                                                             *
-*  Description : Initialise une instance de panneau graphique pour binaire.   *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static void g_binary_panel_init(GBinaryPanel *panel)
-{
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : panel = instance d'objet GLib à traiter.                     *
-*                                                                             *
-*  Description : Supprime toutes les références externes.                     *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static void g_binary_panel_dispose(GBinaryPanel *panel)
-{
-    G_OBJECT_CLASS(g_binary_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_binary_panel_finalize(GBinaryPanel *panel)
-{
-    G_OBJECT_CLASS(g_binary_panel_parent_class)->finalize(G_OBJECT(panel));
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : -                                                            *
-*                                                                             *
-*  Description : Constitue une définition de manipulation de panneau.         *
-*                                                                             *
-*  Retour      : Définition de propriétés mise en place.                      *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-GPanelItem *g_binary_panel_new(void)
-{
-    GPanelItem *result;                     /* Structure à retourner       */
-
-    result = g_object_new(G_TYPE_BINARY_PANEL, NULL);
-
-    return result;
-
-}
-
-
-
-/* ---------------------------------------------------------------------------------- */
-/*                       IMPLEMENTATION DES FONCTIONS DE CLASSE                       */
-/* ---------------------------------------------------------------------------------- */
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : panel = définition de panneau à consulter.                   *
-*                                                                             *
-*  Description : Fournit une indication sur la personnalité du panneau.       *
-*                                                                             *
-*  Retour      : Identifiant lié à la nature du panneau.                      *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static PanelItemPersonality g_binary_panel_get_personality(const GBinaryPanel *panel)
-{
-    PanelItemPersonality result;            /* Personnalité à retourner    */
-
-    result = PIP_MAIN_PANEL;
-
-    return result;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : panel = définition de panneau à manipuler.                   *
-*                                                                             *
-*  Description : Fournit un composant pour lancer l'activité d'un panneau.    *
-*                                                                             *
-*  Retour      : Composant GTK (déjà ?) mis en place.                         *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static GtkPanelLauncher *g_binary_panel_get_launcher(GPanelItem *panel)
-{
-    GtkPanelLauncher *result;               /* Composant à retourner       */
-
-    result = gtk_panel_launcher_new("binfile-symbolic",
-                                    _("Binary analysis"),
-                                    _("Load a binary content and parse its format if recognized"));
-
-    return result;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : panel = définition de panneau à manipuler.                   *
-*                                                                             *
-*  Description : Fournit un composant pour paramétrer l'activité d'un panneau.*
-*                                                                             *
-*  Retour      : Composant GTK (déjà ?) mis en place.                         *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static GtkWidget *g_binary_panel_get_properties(GBinaryPanel *panel)
-{
-    GtkWidget *result;                      /* Composant à retourner       */
-    GtkBuilderScope *scope;                 /* Fonctions pour signaux      */
-    GtkBuilderCScope *cscope;               /* Fonctions pour signaux      */
-    GtkBuilder *builder;                    /* Constructeur d'UI           */
-#ifndef NDEBUG
-    gboolean status;                        /* Bilan d'un chargement       */
-#endif
-
-    scope = gtk_builder_cscope_new();
-    cscope = GTK_BUILDER_CSCOPE(scope);
-
-    gtk_builder_cscope_add_callback_symbol(cscope, BUILDER_CB(g_binary_panel_on_new_file_entry_icon_release));
-
-    builder = gtk_builder_new();
-    gtk_builder_set_scope(builder, scope);
-    gtk_builder_set_current_object(builder, G_OBJECT(panel));
-
-#ifndef NDEBUG
-    status = gtk_builder_add_from_resource(builder, "/re/chrysalide/framework/gui/panels/binary-props.ui", NULL);
-    assert(status);
-#else
-    gtk_builder_add_from_resource(builder, "/re/chrysalide/framework/gui/panels/binary-props.ui", NULL);
-#endif
-
-    result = GTK_WIDGET(gtk_builder_get_object(builder, "properties"));
-    ref_object(result);
-
-    unref_object(builder);
-    unref_object(scope);
-
-    return result;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : entry    = zone de saisie concernée par l'appel.             *
-*                icon_pos = position de l'icone incrustée dans la zone.       *
-*                panel    = définition de panneau à manipuler.                *
-*                                                                             *
-*  Description : Ouvre une boîte de dialogue pour récupérer un fichier.       *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static void g_binary_panel_on_new_file_entry_icon_release(GtkEntry *entry, GtkEntryIconPosition icon_pos, GBinaryPanel *panel)
-{
-    GtkRoot *root;                          /* Racine du composant         */
-    GtkTiledPanel *tiled;                   /* Panneau d'affichage complet */
-
-    root = gtk_widget_get_root(GTK_WIDGET(entry));
-
-    tiled = g_binary_panel_get_panel(panel, NULL);
-
-    gtk_framework_window_add(GTK_FRAMEWORK_WINDOW(root), tiled);
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : panel = définition de panneau à manipuler.                   *
-*                props = éventuels éléments graphiques de paramétrages.       *
-*                                                                             *
-*  Description : Fournit un composant représentant un panneau graphique.      *
-*                                                                             *
-*  Retour      : Composant GTK (déjà ?) mis en place.                         *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static GtkTiledPanel *g_binary_panel_get_panel(GBinaryPanel *panel, GtkWidget *props)
-{
-    GtkTiledPanel *result;                  /* Composant à retourner       */
-    GBinContent *content;                   /* Contenu binaire à afficher  */
-
-    content = g_file_content_new("/bin/id");
-
-    result = gtk_binary_panel_new_for_content(content);
-
-    unref_object(content);
-
-    return result;
-
-}
diff --git a/src/gui/panels/binary.h b/src/gui/panels/binary.h
index e92895b..26f8a7d 100644
--- a/src/gui/panels/binary.h
+++ b/src/gui/panels/binary.h
@@ -29,16 +29,12 @@
 #include <gtk/gtk.h>
 
 
-#include "../panel.h"
 #include "../../analysis/content.h"
 #include "../../glibext/helpers.h"
 #include "../../gtkext/panel.h"
 
 
 
-/* ------------------------- COEUR D'UN PANNEAU D'AFFICHAGE ------------------------- */
-
-
 #define GTK_TYPE_BINARY_PANEL (gtk_binary_panel_get_type())
 
 DECLARE_GTYPE(GtkBinaryPanel, gtk_binary_panel, GTK, BINARY_PANEL);
@@ -49,17 +45,4 @@ GtkTiledPanel *gtk_binary_panel_new_for_content(GBinContent *);
 
 
 
-/* ---------------------- MANIPULATIONS D'UN PANNEAU GRAPHIQUE ---------------------- */
-
-
-#define G_TYPE_BINARY_PANEL (g_binary_panel_get_type())
-
-DECLARE_GTYPE(GBinaryPanel, g_binary_panel, G, BINARY_PANEL);
-
-
-/* Constitue une définition de manipulation de panneau. */
-GPanelItem *g_binary_panel_new(void);
-
-
-
 #endif  /* _GUI_PANELS_BINARY_H */
diff --git a/src/gui/panels/gresource.xml b/src/gui/panels/gresource.xml
index 2fecc8c..f49a16f 100644
--- a/src/gui/panels/gresource.xml
+++ b/src/gui/panels/gresource.xml
@@ -2,7 +2,7 @@
 <gresources>
     <gresource prefix="/re/chrysalide/framework/gui/panels">
         <file compressed="true">binary.ui</file>
-        <file compressed="true">binary-props.ui</file>
+        <file compressed="true">binary-params.ui</file>
         <file compressed="true">welcome.ui</file>
         <file compressed="true">welcome-hints.txt</file>
     </gresource>
diff --git a/src/gui/panels/welcome-int.h b/src/gui/panels/welcome-int.h
index d99d316..206bc2c 100644
--- a/src/gui/panels/welcome-int.h
+++ b/src/gui/panels/welcome-int.h
@@ -27,20 +27,15 @@
 
 
 #include "welcome.h"
-#include "../panel-int.h"
 #include "../../gtkext/panel-int.h"
 
 
 
-/* ------------------------- COEUR D'UN PANNEAU D'AFFICHAGE ------------------------- */
-
-
 /* Panneau d'accueil par défaut (instance) */
 struct _GtkWelcomePanel
 {
     GtkTiledPanel parent;                   /* A laisser en premier        */
 
-    GListStore *store;                      /* Données brutes              */
     GtkListBox *list;                       /* Liste de lanceurs           */
     GtkStack *properties;                   /* Premières propriétés        */
 
@@ -62,28 +57,5 @@ struct _GtkWelcomePanelClass
 };
 
 
-/* Met en place un nouveau panneau d'accueil. */
-bool gtk_welcome_panel_create(GtkWelcomePanel *);
-
-
-
-/* ---------------------- MANIPULATIONS D'UN PANNEAU GRAPHIQUE ---------------------- */
-
-
-/* Définition pour gestion par le framework d'un panneau graphique (instance) */
-struct _GWelcomePanel
-{
-    GPanelItem parent;                      /* A laisser en premier        */
-
-};
-
-/* Définition pour gestion par le framework d'un panneau graphique (classe) */
-struct _GWelcomePanelClass
-{
-    GPanelItemClass parent;                 /* A laisser en premier        */
-
-};
-
-
 
 #endif  /* _GUI_PANELS_WELCOME_INT_H */
diff --git a/src/gui/panels/welcome.c b/src/gui/panels/welcome.c
index 3cd349f..6fd1304 100644
--- a/src/gui/panels/welcome.c
+++ b/src/gui/panels/welcome.c
@@ -48,16 +48,10 @@ static void gtk_welcome_panel_class_init(GtkWelcomePanelClass *);
 static void gtk_welcome_panel_init(GtkWelcomePanel *);
 
 /* Supprime toutes les références externes. */
-static void gtk_welcome_panel_dispose(GtkWelcomePanel *);
+static void gtk_welcome_panel_dispose(GObject *);
 
 /* Procède à la libération totale de la mémoire. */
-static void gtk_welcome_panel_finalize(GtkWelcomePanel *);
-
-/* Intègre une définition de panneau enregistrée. */
-static bool gtk_welcome_panel_add_launcher(GPanelItem *, GListStore *);
-
-/* Prépare un composant pour représenter une définition. */
-static GtkWidget *gtk_welcome_panel_create_launcher_widget(GPanelItem *, gpointer);
+static void gtk_welcome_panel_finalize(GObject *);
 
 /* Réagit à un changement de sélection de la liste de panneaux. */
 static void gtk_welcome_panel_on_selected_rows_changed(GtkListBox *, GtkWelcomePanel *);
@@ -78,32 +72,6 @@ static void gtk_welcome_panel_on_next_hint_clicked(GtkButton *, GtkWelcomePanel
 
 
 
-/* ---------------------- MANIPULATIONS D'UN PANNEAU GRAPHIQUE ---------------------- */
-
-
-/* Initialise la classe des panneaux graphiques pour binaires. */
-static void g_welcome_panel_class_init(GWelcomePanelClass *);
-
-/* Initialise une instance de panneau graphique pour binaire. */
-static void g_welcome_panel_init(GWelcomePanel *);
-
-/* Supprime toutes les références externes. */
-static void g_welcome_panel_dispose(GWelcomePanel *);
-
-/* Procède à la libération totale de la mémoire. */
-static void g_welcome_panel_finalize(GWelcomePanel *);
-
-
-
-/* --------------------- IMPLEMENTATION DES FONCTIONS DE CLASSE --------------------- */
-
-
-/* Fournit une indication sur la personnalité du panneau. */
-static PanelItemPersonality g_welcome_panel_get_personality(const GWelcomePanel *);
-
-/* Fournit un composant représentant un panneau graphique. */
-static GtkTiledPanel *g_welcome_panel_get_panel(GWelcomePanel *, GtkWidget *);
-
 
 
 /* ---------------------------------------------------------------------------------- */
@@ -134,8 +102,8 @@ static void gtk_welcome_panel_class_init(GtkWelcomePanelClass *class)
 
     object = G_OBJECT_CLASS(class);
 
-    object->dispose = (GObjectFinalizeFunc/* ! */)gtk_welcome_panel_dispose;
-    object->finalize = (GObjectFinalizeFunc)gtk_welcome_panel_finalize;
+    object->dispose = gtk_welcome_panel_dispose;
+    object->finalize = gtk_welcome_panel_finalize;
 
     widget = GTK_WIDGET_CLASS(class);
 
@@ -169,13 +137,16 @@ static void gtk_welcome_panel_init(GtkWelcomePanel *panel)
 {
     GBytes *bytes;                          /* Données brutes de ressource */
     const gchar *data;                      /* Données brutes natives      */
+    int min;                                /* Taille à gauche minimale    */
+    GtkConstraintLayout *layout;            /* Disposition fixant la taille*/
+    GtkConstraint *constraint;              /* Contrainte à considérer     */
 
     gtk_widget_init_template(GTK_WIDGET(panel));
 
-    panel->store = g_list_store_new(G_TYPE_PANEL_ITEM);
-
     panel->other_child = NULL;
 
+    /* Chargement des astuces */
+
     bytes = g_resources_lookup_data("/re/chrysalide/framework/gui/panels/welcome-hints.txt",
                                     G_RESOURCE_LOOKUP_FLAGS_NONE, NULL);
     assert(bytes != NULL);
@@ -191,105 +162,9 @@ static void gtk_welcome_panel_init(GtkWelcomePanel *panel)
 
     panel->cur_hint = 0;
 
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : panel = instance d'objet GLib à traiter.                     *
-*                                                                             *
-*  Description : Supprime toutes les références externes.                     *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static void gtk_welcome_panel_dispose(GtkWelcomePanel *panel)
-{
-    gtk_widget_dispose_template(GTK_WIDGET(panel), GTK_TYPE_WELCOME_PANEL);
-
-    g_clear_object(&panel->other_child);
-
-    G_OBJECT_CLASS(gtk_welcome_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 gtk_welcome_panel_finalize(GtkWelcomePanel *panel)
-{
-    G_OBJECT_CLASS(gtk_welcome_panel_parent_class)->finalize(G_OBJECT(panel));
-
-    g_strfreev(panel->raw_hints);
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : -                                                            *
-*                                                                             *
-*  Description : Crée une nouvelle instance de panneau d'accueil.             *
-*                                                                             *
-*  Retour      : Composant GTK mis en place.                                  *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-GtkTiledPanel *gtk_welcome_panel_new(void)
-{
-    GtkTiledPanel *result;                  /* Instance à retourner        */
-
-    result = g_object_new(GTK_TYPE_WELCOME_PANEL, NULL);
-
-    if (!gtk_welcome_panel_create(GTK_WELCOME_PANEL(result)))
-        g_clear_object(&result);
-
-    return result;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : panel = panneau d'accueil à initialiser.                     *
-*                                                                             *
-*  Description : Met en place un nouveau panneau d'accueil.                   *
-*                                                                             *
-*  Retour      : Bilan de l'opération.                                        *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-bool gtk_welcome_panel_create(GtkWelcomePanel *panel)
-{
-    bool result;                            /* Bilan à retourner           */
-    int min;                                /* Taille à gauche minimale    */
-    GtkConstraintLayout *layout;            /* Disposition fixant la taille*/
-    GtkConstraint *constraint;              /* Contrainte à considérer     */
-
     /* Constitution de la liste des démarreurs */
 
-    result = browse_all_item_panels(true, (handle_panel_item_fc)gtk_welcome_panel_add_launcher, panel->store);
-
-    gtk_list_box_bind_model(panel->list, G_LIST_MODEL(panel->store),
-                            (GtkListBoxCreateWidgetFunc)gtk_welcome_panel_create_launcher_widget,
-                            NULL, NULL);
+    populate_framework_panel_launcher_list(panel->list);
 
     /* Dimensionnement de la zone d'astuces */
 
@@ -327,57 +202,57 @@ bool gtk_welcome_panel_create(GtkWelcomePanel *panel)
 
     gtk_label_set_markup(panel->hints, panel->raw_hints[panel->cur_hint]);
 
-    return result;
-
 }
 
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : item  = définition de panneau à intégrer.                    *
-*                store = liste à compléter.                                   *
+*  Paramètres  : object = instance d'objet GLib à traiter.                    *
 *                                                                             *
-*  Description : Intègre une définition de panneau enregistrée.               *
+*  Description : Supprime toutes les références externes.                     *
 *                                                                             *
-*  Retour      : true pour un parcours complet de la liste des définitions.   *
+*  Retour      : -                                                            *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-static bool gtk_welcome_panel_add_launcher(GPanelItem *item, GListStore *store)
+static void gtk_welcome_panel_dispose(GObject *object)
 {
-    bool result;                            /* Poursuite du parcours       */
+    GtkWelcomePanel *panel;                 /* Version spécialisée         */
 
-    result = true;
+    gtk_widget_dispose_template(GTK_WIDGET(object), GTK_TYPE_WELCOME_PANEL);
 
-    g_list_store_append(store, G_OBJECT(item));
+    panel = GTK_WELCOME_PANEL(object);
 
-    return result;
+    g_clear_object(&panel->other_child);
+
+    G_OBJECT_CLASS(gtk_welcome_panel_parent_class)->dispose(object);
 
 }
 
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : item  = définition de panneau à consulter.                   *
-*                unused = adresse non utilisée ici.                           *
+*  Paramètres  : object = instance d'objet GLib à traiter.                    *
 *                                                                             *
-*  Description : Prépare un composant pour représenter une définition.        *
+*  Description : Procède à la libération totale de la mémoire.                *
 *                                                                             *
-*  Retour      : Composant de représentation de définition de panneau.        *
+*  Retour      : -                                                            *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-static GtkWidget *gtk_welcome_panel_create_launcher_widget(GPanelItem *item, gpointer unused)
+static void gtk_welcome_panel_finalize(GObject *object)
 {
-    GtkWidget *result;                      /* Composant GTK à retourner   */
+    GtkWelcomePanel *panel;                 /* Version spécialisée         */
 
-    result = g_panel_item_get_launcher(item);
+    panel = GTK_WELCOME_PANEL(object);
 
-    return result;
+    g_strfreev(panel->raw_hints);
+
+    G_OBJECT_CLASS(gtk_welcome_panel_parent_class)->finalize(object);
 
 }
 
@@ -398,8 +273,6 @@ static GtkWidget *gtk_welcome_panel_create_launcher_widget(GPanelItem *item, gpo
 static void gtk_welcome_panel_on_selected_rows_changed(GtkListBox *box, GtkWelcomePanel *panel)
 {
     GtkListBoxRow *row;                     /* Ligne sélectionnée          */
-    int selected;                           /* Indice de sélection         */
-    GPanelItem *item;                       /* Elément correspondant       */
     GtkWidget *new;                         /* Nouvelles propriétés        */
 
     row = gtk_list_box_get_selected_row(box);
@@ -414,7 +287,7 @@ static void gtk_welcome_panel_on_selected_rows_changed(GtkListBox *box, GtkWelco
         gtk_stack_set_visible_child(panel->properties, panel->def_child);
 
         gtk_stack_remove(panel->properties, panel->other_child);
-        g_clear_object(&panel->other_child);
+        panel->other_child = NULL;
 
     }
 
@@ -423,24 +296,16 @@ static void gtk_welcome_panel_on_selected_rows_changed(GtkListBox *box, GtkWelco
      */
     else
     {
-        selected = gtk_list_box_row_get_index(row);
-        item = g_list_model_get_item(G_LIST_MODEL(panel->store), selected);
-
-        new = g_panel_item_get_properties(item);
-
-        if (new == panel->other_child)
-            unref_object(new);
+        new = get_framework_panel_parameters(row);
+        assert(new != NULL);
 
-        else
+        if (new != panel->other_child)
         {
             gtk_stack_add_child(panel->properties, new);
             gtk_stack_set_visible_child(panel->properties, new);
 
             if (panel->other_child != NULL)
-            {
                 gtk_stack_remove(panel->properties, panel->other_child);
-                g_clear_object(&panel->other_child);
-            }
 
             panel->other_child = new;
 
@@ -513,178 +378,3 @@ static void gtk_welcome_panel_on_next_hint_clicked(GtkButton *button, GtkWelcome
 
 
 
-
-/* ---------------------------------------------------------------------------------- */
-/*                        MANIPULATIONS D'UN PANNEAU GRAPHIQUE                        */
-/* ---------------------------------------------------------------------------------- */
-
-
-/* Indique le type défini pour une manipulation de panneau de bienvenue. */
-G_DEFINE_TYPE(GWelcomePanel, g_welcome_panel, G_TYPE_PANEL_ITEM);
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : class = classe à initialiser.                                *
-*                                                                             *
-*  Description : Initialise la classe des panneaux graphiques pour binaires.  *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static void g_welcome_panel_class_init(GWelcomePanelClass *class)
-{
-    GObjectClass *object;                   /* Autre version de la classe  */
-    GPanelItemClass *panel;                 /* Encore une autre vision...  */
-
-    object = G_OBJECT_CLASS(class);
-
-    object->dispose = (GObjectFinalizeFunc/* ! */)g_welcome_panel_dispose;
-    object->finalize = (GObjectFinalizeFunc)g_welcome_panel_finalize;
-
-    panel = G_PANEL_ITEM_CLASS(class);
-
-    panel->get_personality = (get_panel_item_personality_cb)g_welcome_panel_get_personality;
-    panel->get_panel = (get_panel_item_panel_cb)g_welcome_panel_get_panel;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : panel = instance à initialiser.                              *
-*                                                                             *
-*  Description : Initialise une instance de panneau graphique pour binaire.   *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static void g_welcome_panel_init(GWelcomePanel *panel)
-{
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : panel = instance d'objet GLib à traiter.                     *
-*                                                                             *
-*  Description : Supprime toutes les références externes.                     *
-*                                                                             *
-*  Retour      : -                                                            *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static void g_welcome_panel_dispose(GWelcomePanel *panel)
-{
-    G_OBJECT_CLASS(g_welcome_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_welcome_panel_finalize(GWelcomePanel *panel)
-{
-    G_OBJECT_CLASS(g_welcome_panel_parent_class)->finalize(G_OBJECT(panel));
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : -                                                            *
-*                                                                             *
-*  Description : Constitue une définition de manipulation de panneau.         *
-*                                                                             *
-*  Retour      : Définition de propriétés mise en place.                      *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-GPanelItem *g_welcome_panel_new(void)
-{
-    GPanelItem *result;                     /* Structure à retourner       */
-
-    result = g_object_new(G_TYPE_WELCOME_PANEL, NULL);
-
-    return result;
-
-}
-
-
-
-/* ---------------------------------------------------------------------------------- */
-/*                       IMPLEMENTATION DES FONCTIONS DE CLASSE                       */
-/* ---------------------------------------------------------------------------------- */
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : panel = définition de panneau à consulter.                   *
-*                                                                             *
-*  Description : Fournit une indication sur la personnalité du panneau.       *
-*                                                                             *
-*  Retour      : Identifiant lié à la nature du panneau.                      *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static PanelItemPersonality g_welcome_panel_get_personality(const GWelcomePanel *panel)
-{
-    PanelItemPersonality result;            /* Personnalité à retourner    */
-
-    result = PIP_MAIN_PANEL | PIP_SINGLETON;
-
-    return result;
-
-}
-
-
-/******************************************************************************
-*                                                                             *
-*  Paramètres  : panel = définition de panneau à manipuler.                   *
-*                props = éventuels éléments graphiques de paramétrages.       *
-*                                                                             *
-*  Description : Fournit un composant représentant un panneau graphique.      *
-*                                                                             *
-*  Retour      : Composant GTK (déjà ?) mis en place.                         *
-*                                                                             *
-*  Remarques   : -                                                            *
-*                                                                             *
-******************************************************************************/
-
-static GtkTiledPanel *g_welcome_panel_get_panel(GWelcomePanel *panel, GtkWidget *props)
-{
-    GtkTiledPanel *result;                  /* Composant à retourner       */
-
-    /**
-     * Il n'existe pas de composants de paramètrage pour ce panneau.
-     */
-    assert(props == NULL);
-
-    result = gtk_welcome_panel_new();
-
-    return result;
-
-}
diff --git a/src/gui/panels/welcome.h b/src/gui/panels/welcome.h
index d267f80..d9ea18d 100644
--- a/src/gui/panels/welcome.h
+++ b/src/gui/panels/welcome.h
@@ -29,36 +29,15 @@
 #include <gtk/gtk.h>
 
 
-#include "../panel.h"
 #include "../../glibext/helpers.h"
 #include "../../gtkext/panel.h"
 
 
 
-/* ------------------------- COEUR D'UN PANNEAU D'AFFICHAGE ------------------------- */
-
-
 #define GTK_TYPE_WELCOME_PANEL (gtk_welcome_panel_get_type())
 
 DECLARE_GTYPE(GtkWelcomePanel, gtk_welcome_panel, GTK, WELCOME_PANEL);
 
 
-/* Crée une nouvelle instance de panneau d'accueil. */
-GtkTiledPanel *gtk_welcome_panel_new(void);
-
-
-
-/* ---------------------- MANIPULATIONS D'UN PANNEAU GRAPHIQUE ---------------------- */
-
-
-#define G_TYPE_WELCOME_PANEL (g_welcome_panel_get_type())
-
-DECLARE_GTYPE(GWelcomePanel, g_welcome_panel, G, WELCOME_PANEL);
-
-
-/* Constitue une définition de manipulation de panneau. */
-GPanelItem *g_welcome_panel_new(void);
-
-
 
 #endif  /* _GUI_PANELS_WELCOME_H */
diff --git a/src/gui/window.c b/src/gui/window.c
index a11e8aa..f45cec9 100644
--- a/src/gui/window.c
+++ b/src/gui/window.c
@@ -215,7 +215,6 @@ GtkApplicationWindow *gtk_framework_window_new(GtkApplication *app)
 bool gtk_framework_window_create(GtkFrameworkWindow *window, GtkApplication *app)
 {
     bool result;                            /* Bilan à retourner           */
-    GPanelItem *item;                       /* Définition de panneau       */
     GtkTiledPanel *panel;                   /* Panneau d'affichage         */
     GtkCssProvider *css;                    /* Feuille de style maison     */
 
@@ -225,13 +224,10 @@ bool gtk_framework_window_create(GtkFrameworkWindow *window, GtkApplication *app
 
     /* Inclusion d'un écran d'accueil */
 
-    item = find_item_panel_by_type(G_TYPE_WELCOME_PANEL);
+    panel = get_framework_panel_singleton(GTK_TYPE_WELCOME_PANEL);
 
-    panel = g_panel_item_get_panel(item);
     gtk_framework_window_add(window, panel);
 
-    unref_object(item);
-
     /* Chargement des extensions de thème */
 
     css = gtk_css_provider_new();