Rewritten the whole API dealing with panels.

5 files changed, 637 insertions, 113 deletions

diff --git a/plugins/pychrysalide/gui/constants.c b/plugins/pychrysalide/gui/constants.c
index 3cd943c..0930f41 100644
--- a/plugins/pychrysalide/gui/constants.c
+++ b/plugins/pychrysalide/gui/constants.c
@@ -53,6 +53,7 @@ bool define_panel_item_constants(PyTypeObject *type)
 
     result = add_const_to_group(values, "INVALID", PIP_INVALID);
     if (result) result = add_const_to_group(values, "SINGLETON", PIP_SINGLETON);
+    if (result) result = add_const_to_group(values, "PERSISTENT_SINGLETON", PIP_PERSISTENT_SINGLETON);
     if (result) result = add_const_to_group(values, "BINARY_VIEW", PIP_BINARY_VIEW);
     if (result) result = add_const_to_group(values, "OTHER", PIP_OTHER);
     if (result) result = add_const_to_group(values, "COUNT", PIP_COUNT);
diff --git a/plugins/pychrysalide/gui/core/items.c b/plugins/pychrysalide/gui/core/items.c
index ce3eaee..95842fc 100644
--- a/plugins/pychrysalide/gui/core/items.c
+++ b/plugins/pychrysalide/gui/core/items.c
@@ -66,29 +66,36 @@ static PyObject *py_items_update_project(PyObject *, PyObject *);
 *                                                                             *
 ******************************************************************************/
 
-static PyObject *py_items_find_editor_item_by_key(PyObject *self, PyObject *args)
+static PyObject *py_items_find_editor_item_by_type(PyObject *self, PyObject *args)
 {
     PyObject *result;                       /* Trouvaille à retourner      */
-    const char *key;                        /* Objet des recherches        */
+    GType type;                             /* Type d'élément à traiter    */
     int ret;                                /* Bilan de lecture des args.  */
     GEditorItem *found;                     /* Instance retrouvée ou NULL  */
 
-#define ITEMS_FIND_EDITOR_ITEM_BY_KEY_METHOD PYTHON_METHOD_DEF          \
-(                                                                       \
-    find_editor_item_by_key, "key",                                     \
-    METH_VARARGS, py_items,                                             \
-    "Find the editor component belonging to a given key."               \
-    "\n"                                                                \
-    "The key has to be provided as a simple (short) string, and the"    \
-    " result is a pychrysalide.gui.EditorItem instance or None if no"   \
-    " component is found for the given key."                            \
+#define ITEMS_FIND_EDITOR_ITEM_BY_TYPE_METHOD PYTHON_METHOD_DEF     \
+(                                                                   \
+    find_editor_item_by_type, "cls",                                \
+    METH_VARARGS, py_items,                                         \
+    "Find the editor component belonging to a given class."         \
+    "\n"                                                            \
+    "The provided *cls* has to be an pychrysalide.gui.EditorItem"   \
+    " derived class."                                               \
+    "\n"                                                            \
+    "The result is an pychrysalide.gui.EditorItem instance or None" \
+    " if no component is found for the given key."                  \
 )
 
-    ret = PyArg_ParseTuple(args, "s", &key);
+    ret = PyArg_ParseTuple(args, "O&", convert_to_gtype, &type);
     if (!ret) return NULL;
 
+    if (!g_type_is_a(type, G_TYPE_EDITOR_ITEM))
+    {
+        PyErr_SetString(PyExc_TypeError, "the argument must be a class derived from pychrysalide.gui.EditorItem");
+        return NULL;
+    }
 
-    found = find_editor_item_by_key(key);
+    found = find_editor_item_by_type(type);
 
     if (found == NULL)
     {
@@ -276,7 +283,7 @@ bool populate_gui_core_module_with_items(void)
     PyObject *module;                       /* Module à recompléter        */
 
     static PyMethodDef py_items_methods[] = {
-        ITEMS_FIND_EDITOR_ITEM_BY_KEY_METHOD,
+        ITEMS_FIND_EDITOR_ITEM_BY_TYPE_METHOD,
         ITEMS_CHANGE_CURRENT_CONTENT_METHOD,
         ITEMS_CHANGE_CURRENT_VIEW_METHOD,
         ITEMS_UPDATE_CURRENT_VIEW_METHOD,
diff --git a/plugins/pychrysalide/gui/core/panels.c b/plugins/pychrysalide/gui/core/panels.c
index 2a3c275..4fdc3f2 100644
--- a/plugins/pychrysalide/gui/core/panels.c
+++ b/plugins/pychrysalide/gui/core/panels.c
@@ -58,38 +58,59 @@ static PyObject *py_panels_register_panel(PyObject *, PyObject *);
 
 static PyObject *py_panels_register_panel(PyObject *self, PyObject *args)
 {
-    GPanelItem *item;                       /* Panneau à traiter           */
-    GGenConfig *config;                     /* Configuration à consulter   */
+    GType type;                             /* Type de panneau à traiter   */
     int ret;                                /* Bilan de lecture des args.  */
-
-#define PANELS_REGISTER_PANEL_METHOD PYTHON_METHOD_DEF              \
-(                                                                   \
-    register_panel, "panel",                                        \
-    METH_VARARGS, py_panels,                                        \
-    "Register a panel for the GUI."                                 \
-    "\n"                                                            \
-    "The provided panel has to be a pychrysalide.gui.PanelItem"     \
-    " instance."                                                    \
+    PyObject *meta;                         /* Type _GObjectMetaBase       */
+    PyObject *instance;                     /* Initialisation forcée       */
+
+#define PANELS_REGISTER_PANEL_METHOD PYTHON_METHOD_DEF          \
+(                                                               \
+    register_panel, "cls",                                      \
+    METH_VARARGS, py_panels,                                    \
+    "Register a panel class for the GUI."                       \
+    "\n"                                                        \
+    "The provided *cls* has to be a pychrysalide.gui.PanelItem" \
+    " derived class."                                           \
 )
 
-    config = NULL;
+    ret = PyArg_ParseTuple(args, "O&", convert_to_gtype, &type);
+    if (!ret) return NULL;
+
+    if (!g_type_is_a(type, G_TYPE_PANEL_ITEM))
+    {
+        PyErr_SetString(PyExc_TypeError, "the argument must be a class derived from pychrysalide.gui.PanelItem");
+        return NULL;
+    }
+
+    /**
+     * Si la classe transmise n'a jamais été utilisée pour créer une instance,
+     * py_panel_item_new() n'a donc jamais été exécutée et le type dynamique
+     * associé au panneau n'a jamais été initialisé par Chrysalide.
+     *
+     * Cette création dynamique de type est donc forcée ici.
+     */
 
-    ret = PyArg_ParseTuple(args, "O&", convert_to_panel_item, &item);
+    ret = PyArg_ParseTuple(args, "O", &meta);
     if (!ret) return NULL;
 
-    if (config == NULL)
-        config = get_main_configuration();
+    instance = PyObject_CallObject(meta, NULL);
+
+    if (instance == NULL)
+    {
+        PyErr_SetString(PyExc_TypeError, "the argument must be a class derived from pychrysalide.gui.PanelItem");
+        return NULL;
+    }
 
-    register_panel_item(item, config);
+    Py_DECREF(instance);
 
     /**
-     * Si Python ne voit plus la variable représentant le panneau utilisée,
-     * il va la supprimer, ce qui va supprimer le composant GTK.
-     *
-     * On sera donc en situation de Use-After-Free, dont les conséquences
-     * arrivent très vite.
+     * Rechargement du type, afin d'obtenir la version dynamique avec certitude.
      */
-    pygobject_new(G_OBJECT(item));
+
+    ret = PyArg_ParseTuple(args, "O&", convert_to_gtype, &type);
+    if (!ret) return NULL;
+
+    register_panel_item(type, get_main_configuration());
 
     Py_RETURN_NONE;
 
diff --git a/plugins/pychrysalide/gui/item.c b/plugins/pychrysalide/gui/item.c
index 2e32167..2046587 100644
--- a/plugins/pychrysalide/gui/item.c
+++ b/plugins/pychrysalide/gui/item.c
@@ -73,7 +73,7 @@
 
 
 /* Fournit le nom interne attribué à l'élément réactif. */
-static char *py_editor_item_get_key_wrapper(const GEditorItem *);
+static char *py_editor_item_get_key_wrapper(const GEditorItemClass *);
 
 /* Fournit le composant GTK associé à l'élément réactif. */
 static GtkWidget *py_editor_item_get_widget_wrapper(const GEditorItem *);
@@ -141,7 +141,7 @@ void py_editor_item_init_gclass(GEditorItemClass *class, gpointer unused)
 
 /******************************************************************************
 *                                                                             *
-*  Paramètres  : item = instance à consulter.                                 *
+*  Paramètres  : class = classe à consulter.                                  *
 *                                                                             *
 *  Description : Fournit le nom interne attribué à l'élément réactif.         *
 *                                                                             *
@@ -151,31 +151,31 @@ void py_editor_item_init_gclass(GEditorItemClass *class, gpointer unused)
 *                                                                             *
 ******************************************************************************/
 
-static char *py_editor_item_get_key_wrapper(const GEditorItem *item)
+static char *py_editor_item_get_key_wrapper(const GEditorItemClass *class)
 {
     char *result;                           /* Désignation à retourner     */
     PyGILState_STATE gstate;                /* Sauvegarde d'environnement  */
-    PyObject *pyobj;                        /* Objet Python concerné       */
+    PyTypeObject *pytype;                   /* Classe Python concernée     */
     PyObject *pykey;                        /* Clef en objet Python        */
     int ret;                                /* Bilan d'une conversion      */
 
 #define EDITOR_ITEM_KEY_ATTRIB_WRAPPER PYTHON_GETTER_WRAPPER_DEF    \
 (                                                                   \
-    _key,                                                          \
+    _key,                                                           \
     "Provide the internal name to use for the editor item.\n"       \
     "\n"                                                            \
-    "The result has to be a string."                                \
+    "The value has to be a string."                                 \
 )
 
     result = NULL;
 
     gstate = PyGILState_Ensure();
 
-    pyobj = pygobject_new(G_OBJECT(item));
+    pytype = pygobject_lookup_class(G_TYPE_FROM_CLASS(class));
 
-    if (PyObject_HasAttrString(pyobj, "_key"))
+    if (PyObject_HasAttrString((PyObject *)pytype, "_key"))
     {
-        pykey = PyObject_GetAttrString(pyobj, "_key");
+        pykey = PyObject_GetAttrString((PyObject *)pytype, "_key");
 
         if (pykey != NULL)
         {
@@ -190,8 +190,6 @@ static char *py_editor_item_get_key_wrapper(const GEditorItem *item)
 
     }
 
-    Py_DECREF(pyobj);
-
     PyGILState_Release(gstate);
 
     return result;
@@ -226,7 +224,7 @@ static GtkWidget *py_editor_item_get_widget_wrapper(const GEditorItem *item)
     _widget,                                                            \
     "Provide the Gtk widget base involved in the editor item.\n"        \
     "\n"                                                                \
-    "The result has to be a Gtk.Widget instance."                       \
+    "The value has to be a Gtk.Widget instance."                        \
 )
 
     result = NULL;
@@ -574,11 +572,11 @@ static PyObject *py_editor_item_get_key(PyObject *self, void *closure)
 #define EDITOR_ITEM_KEY_ATTRIB PYTHON_GET_DEF_FULL      \
 (                                                       \
     key, py_editor_item,                                \
-    "Internal name given to the editor item."              \
+    "Internal string name given to the editor item."    \
 )
 
     item = G_EDITOR_ITEM(pygobject_get(self));
-    key = g_editor_item_get_key(item);
+    key = g_editor_item_class_get_key(G_EDITOR_ITEM_GET_CLASS(item));
 
     if (key != NULL)
     {
diff --git a/plugins/pychrysalide/gui/panel.c b/plugins/pychrysalide/gui/panel.c
index d9a2bc5..160a7a3 100644
--- a/plugins/pychrysalide/gui/panel.c
+++ b/plugins/pychrysalide/gui/panel.c
@@ -50,9 +50,24 @@
 /* Accompagne la création d'une instance dérivée en Python. */
 static PyObject *py_panel_item_new(PyTypeObject *, PyObject *, PyObject *);
 
-/* Initialise la classe des panneaux pour l'interface graphique. */
+/* Initialise la classe des panneaux graphiques de l'éditeur. */
 static void py_panel_item_init_gclass(GPanelItemClass *, gpointer);
 
+/* Fournit une indication sur la personnalité du panneau. */
+static PanelItemPersonality py_panel_item_class_get_personality_wrapper(const GPanelItemClass *);
+
+/* Fournit une indication d'accroche du panneau au démarrage. */
+static bool py_panel_item_class_dock_at_startup_wrapper(const GPanelItemClass *);
+
+/* Détermine si un panneau peut être filtré. */
+static bool py_panel_item_class_can_search_wrapper(const GPanelItemClass *);
+
+/* Indique le chemin initial de la localisation d'un panneau. */
+static char *py_panel_item_class_get_path_wrapper(const GPanelItemClass *);
+
+/* Indique la définition d'un éventuel raccourci clavier. */
+static char *py_panel_item_class_get_key_bindings_wrapper(const GPanelItemClass *);
+
 /* Initialise une instance sur la base du dérivé de GObject. */
 static int py_panel_item_init(PyObject *self, PyObject *args, PyObject *kwds);
 
@@ -67,18 +82,30 @@ static PyObject *py_panel_item_dock(PyObject *, PyObject *);
 /* Supprime un panneau de l'ensemble affiché. */
 static PyObject *py_panel_item_undock(PyObject *, PyObject *);
 
-/* Fournit le chemin d'accès à utiliser pour les encapsulations. */
-static PyObject *py_panel_item_get_named_widget(PyObject *, void *);
-
 /* Fournit une indication sur la personnalité du panneau. */
 static PyObject *py_panel_item_get_personality(PyObject *, void *);
 
+/* Fournit une indication d'accroche du panneau au démarrage. */
+static PyObject *py_panel_item_get_dock_at_startup(PyObject *, void *);
+
+/*  Définit si le composant repose sur un support de l'éditeur. */
+static int py_panel_item_set_dock_at_startup(PyObject *, PyObject *, void *);
+
+/* Détermine si un panneau peut être filtré. */
+static PyObject *py_panel_item_can_search(PyObject *, void *);
+
 /* Fournit le chemin d'accès à utiliser pour les encapsulations. */
 static PyObject *py_panel_item_get_path(PyObject *, void *);
 
 /* Définit le chemin d'accès à utiliser pour les encapsulations. */
 static int py_panel_item_set_path(PyObject *, PyObject *, void *);
 
+/* Indique la définition d'un éventuel raccourci clavier. */
+static PyObject *py_panel_item_get_key_bindings(PyObject *, void *);
+
+/* Fournit le chemin d'accès à utiliser pour les encapsulations. */
+static PyObject *py_panel_item_get_named_widget(PyObject *, void *);
+
 /* Indique si le composant repose sur un support de l'éditeur. */
 static PyObject *py_panel_item_get_docked(PyObject *, void *);
 
@@ -157,7 +184,7 @@ static PyObject *py_panel_item_new(PyTypeObject *type, PyObject *args, PyObject
 *  Paramètres  : class  = classe à initialiser.                               *
 *                unused = données non utilisées ici.                          *
 *                                                                             *
-*  Description : Initialise la classe des panneaux pour l'interface graphique.*
+*  Description : Initialise la classe des panneaux graphiques de l'éditeur.   *
 *                                                                             *
 *  Retour      : -                                                            *
 *                                                                             *
@@ -169,6 +196,317 @@ static void py_panel_item_init_gclass(GPanelItemClass *class, gpointer unused)
 {
     py_editor_item_init_gclass(G_EDITOR_ITEM_CLASS(class), NULL);
 
+    class->get_personality = py_panel_item_class_get_personality_wrapper;
+    class->dock_at_startup = py_panel_item_class_dock_at_startup_wrapper;
+    class->can_search = py_panel_item_class_can_search_wrapper;
+    class->get_path = py_panel_item_class_get_path_wrapper;
+    class->get_bindings = py_panel_item_class_get_key_bindings_wrapper;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : class = classe à consulter.                                  *
+*                                                                             *
+*  Description : Fournit une indication sur la personnalité du panneau.       *
+*                                                                             *
+*  Retour      : Identifiant lié à la nature du panneau.                      *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static PanelItemPersonality py_panel_item_class_get_personality_wrapper(const GPanelItemClass *class)
+{
+    PanelItemPersonality result;            /* Personnalité à retourner    */
+    PyGILState_STATE gstate;                /* Sauvegarde d'environnement  */
+    PyTypeObject *pytype;                   /* Classe Python concernée     */
+    PyObject *value;                        /* Valeur d'attribut en Python */
+    int ret;                                /* Bilan d'une conversion      */
+
+#define PANEL_ITEM_PERSONALITY_ATTRIB_WRAPPER PYTHON_GETTER_WRAPPER_DEF     \
+(                                                                           \
+    _personality,                                                           \
+    "Abstract attribute defining the initial rule for handling panel"       \
+    " creation.\n"                                                          \
+    "\n"                                                                    \
+    "The result has to be a pychrysalide.gui.PanelItem.PanelItemPersonality"\
+    " value.\n"                                                             \
+    "\n"                                                                    \
+    "The default value is *PanelItem.PanelItemPersonality.SINGLETON*."      \
+)
+
+    result = PIP_SINGLETON;
+
+    gstate = PyGILState_Ensure();
+
+    pytype = pygobject_lookup_class(G_TYPE_FROM_CLASS(class));
+
+    if (PyObject_HasAttrString((PyObject *)pytype, "_personality"))
+    {
+        value = PyObject_GetAttrString((PyObject *)pytype, "_personality");
+
+        if (value != NULL)
+        {
+            ret = convert_to_panel_item_personality(value, &result);
+
+            if (ret != 1)
+            {
+                PyErr_Clear();
+                result = PIP_OTHER;
+            }
+
+            Py_DECREF(value);
+
+        }
+
+    }
+
+    PyGILState_Release(gstate);
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : class = classe à consulter.                                  *
+*                                                                             *
+*  Description : Fournit une indication d'accroche du panneau au démarrage.   *
+*                                                                             *
+*  Retour      : true si le panneau doit être affiché de prime abord.         *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static bool py_panel_item_class_dock_at_startup_wrapper(const GPanelItemClass *class)
+{
+    bool result;                            /* Statut à retourner          */
+    PyGILState_STATE gstate;                /* Sauvegarde d'environnement  */
+    PyTypeObject *pytype;                   /* Classe Python concernée     */
+    PyObject *value;                        /* Valeur d'attribut en Python */
+    int ret;                                /* Bilan d'une conversion      */
+
+#define PANEL_ITEM_DOCK_AT_STARTUP_ATTRIB_WRAPPER PYTHON_GETTER_WRAPPER_DEF \
+(                                                                           \
+    _dock_at_startup,                                                       \
+    "Abstract attribute defining if the panel should get docked"            \
+    " automatically at startup.\n"                                          \
+    "\n"                                                                    \
+    "The value has to be a boolean value: *True* or *False*.\n"             \
+    "\n"                                                                    \
+    "The default value is *True*."                                          \
+)
+
+    result = true;
+
+    gstate = PyGILState_Ensure();
+
+    pytype = pygobject_lookup_class(G_TYPE_FROM_CLASS(class));
+
+    if (PyObject_HasAttrString((PyObject *)pytype, "_dock_at_startup"))
+    {
+        value = PyObject_GetAttrString((PyObject *)pytype, "_dock_at_startup");
+
+        if (value != NULL)
+        {
+            ret = PyBool_Check(value);
+
+            if (ret)
+                result = (value == Py_True);
+
+            Py_DECREF(value);
+
+        }
+
+    }
+
+    PyGILState_Release(gstate);
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : class = classe à consulter.                                  *
+*                                                                             *
+*  Description : Détermine si un panneau peut être filtré.                    *
+*                                                                             *
+*  Retour      : Bilan de la consultation.                                    *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static bool py_panel_item_class_can_search_wrapper(const GPanelItemClass *class)
+{
+    bool result;                            /* Statut à retourner          */
+    PyGILState_STATE gstate;                /* Sauvegarde d'environnement  */
+    PyTypeObject *pytype;                   /* Classe Python concernée     */
+    PyObject *value;                        /* Valeur d'attribut en Python */
+    int ret;                                /* Bilan d'une conversion      */
+
+#define PANEL_ITEM_CAN_SEARCH_ATTRIB_WRAPPER PYTHON_GETTER_WRAPPER_DEF  \
+(                                                                       \
+    _can_search,                                                        \
+    "Abstract attribute defining if the panel contains content which"   \
+    " can get searched.\n"                                              \
+    "\n"                                                                \
+    "The value has to be a boolean value: *True* or *False*.\n"         \
+    "\n"                                                                \
+    "The default value is *False*."                                     \
+)
+
+    result = false;
+
+    gstate = PyGILState_Ensure();
+
+    pytype = pygobject_lookup_class(G_TYPE_FROM_CLASS(class));
+
+    if (PyObject_HasAttrString((PyObject *)pytype, "_can_search"))
+    {
+        value = PyObject_GetAttrString((PyObject *)pytype, "_can_search");
+
+        if (value != NULL)
+        {
+            ret = PyBool_Check(value);
+
+            if (ret)
+                result = (value == Py_True);
+
+            Py_DECREF(value);
+
+        }
+
+    }
+
+    PyGILState_Release(gstate);
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : class = classe à consulter.                                  *
+*                                                                             *
+*  Description : Indique le chemin initial de la localisation d'un panneau.   *
+*                                                                             *
+*  Retour      : Chemin fixé associé à la position initiale.                  *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static char *py_panel_item_class_get_path_wrapper(const GPanelItemClass *class)
+{
+    char *result;                           /* Désignation à retourner     */
+    PyGILState_STATE gstate;                /* Sauvegarde d'environnement  */
+    PyTypeObject *pytype;                   /* Classe Python concernée     */
+    PyObject *value;                        /* Valeur d'attribut en Python */
+    int ret;                                /* Bilan d'une conversion      */
+
+#define PANEL_ITEM_PATH_ATTRIB_WRAPPER PYTHON_GETTER_WRAPPER_DEF    \
+(                                                                   \
+    _path,                                                          \
+    "Abstract attribute used to provide the path to the initial"    \
+    " location of the panel item.\n"                                \
+    "\n"                                                            \
+    "The value has to be a string."                                 \
+)
+
+    result = NULL;
+
+    gstate = PyGILState_Ensure();
+
+    pytype = pygobject_lookup_class(G_TYPE_FROM_CLASS(class));
+
+    if (PyObject_HasAttrString((PyObject *)pytype, "_path"))
+    {
+        value = PyObject_GetAttrString((PyObject *)pytype, "_path");
+
+        if (value != NULL)
+        {
+            ret = PyUnicode_Check(value);
+
+            if (ret)
+                result = strdup(PyUnicode_AsUTF8(value));
+
+            Py_DECREF(value);
+
+        }
+
+    }
+
+    PyGILState_Release(gstate);
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : class = classe à consulter.                                  *
+*                                                                             *
+*  Description : Indique la définition d'un éventuel raccourci clavier.       *
+*                                                                             *
+*  Retour      : Description d'un raccourci ou NULL si aucun de défini.       *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static char *py_panel_item_class_get_key_bindings_wrapper(const GPanelItemClass *class)
+{
+    char *result;                           /* Désignation à retourner     */
+    PyGILState_STATE gstate;                /* Sauvegarde d'environnement  */
+    PyTypeObject *pytype;                   /* Classe Python concernée     */
+    PyObject *value;                        /* Valeur d'attribut en Python */
+    int ret;                                /* Bilan d'une conversion      */
+
+#define PANEL_ITEM_BINDINGS_ATTRIB_WRAPPER PYTHON_GETTER_WRAPPER_DEF    \
+(                                                                       \
+    _key_bindings,                                                      \
+    "Abstract attribute used to provide an optional key bindings as"    \
+    " shortcuts for the panel item.\n"                                  \
+    "\n"                                                                \
+    "The value has to be a string."                                     \
+)
+
+    result = NULL;
+
+    gstate = PyGILState_Ensure();
+
+    pytype = pygobject_lookup_class(G_TYPE_FROM_CLASS(class));
+
+    if (PyObject_HasAttrString((PyObject *)pytype, "_key_bindings"))
+    {
+        value = PyObject_GetAttrString((PyObject *)pytype, "_key_bindings");
+
+        if (value != NULL)
+        {
+            ret = PyUnicode_Check(value);
+
+            if (ret)
+                result = strdup(PyUnicode_AsUTF8(value));
+
+            Py_DECREF(value);
+
+        }
+
+    }
+
+    PyGILState_Release(gstate);
+
+    return result;
+
 }
 
 
@@ -188,55 +526,50 @@ static void py_panel_item_init_gclass(GPanelItemClass *class, gpointer unused)
 
 static int py_panel_item_init(PyObject *self, PyObject *args, PyObject *kwds)
 {
-    PanelItemPersonality personality;       /* Nature du panneau           */
     GNamedWidget *widget;                   /* Composant visuel du panneau */
-    int startup;                            /* Recommandation au démarrage */
-    const char *path;                       /* Placement à l'affichage     */
     int ret;                                /* Bilan de lecture des args.  */
     GPanelItem *panel;                      /* Panneau à manipuler         */
 
-    static char *kwlist[] = { "personality", "widget", "dock", "path", NULL };
-
 #define PANEL_ITEM_DOC                                                          \
     "PanelItem is an abstract class for panels available in the main GUI"       \
     " interface.\n"                                                             \
     "\n"                                                                        \
     "Instances can be created using the following constructor:\n"               \
     "\n"                                                                        \
-    "    PanelItem(personality, widget, dock, path)"                            \
+    "    PanelItem(widget)"                                                     \
     "\n"                                                                        \
     "Where:\n"                                                                  \
-    "* personality defines how many instances of the panels can be created"     \
-    " at the same time.\n"                                                      \
     "* widget is an implementation of the pychrysalide.glibext.NamedWidget"     \
     " interface (see pychrysalide.gtkext.BuiltNamedWidget for a ready-to-use"   \
     " helper).\n"                                                               \
-    "* dock defines if the panel is docked by default.\n"                       \
-    "* path states the location of the panel inside the main GUI.\n"            \
-    "\n"                                                                        \
-    "The easiest way to pass all this information is probably to use a"         \
-    " transitional dictionary inside the panel *__init__()* constructor:\n"     \
-    "\n"                                                                        \
-    "    params = {\n"                                                          \
-    "        'personality' : PanelItemPersonality.PIP_SINGLETON,\n"             \
-    "        'widget' : my_named_widget_instance,\n"                            \
-    "        'dock' : True,\n"                                                  \
-    "        'path' : 'MES'\n"                                                  \
-    "    }\n"                                                                   \
-    "    super(MyPanel, self).__init__(**params)\n"                             \
     "\n"                                                                        \
     "The PanelItem definition handles internally the supply of the *_widget*"   \
     " attribute for pychrysalide.gui.EditorItem.\n"                             \
     "\n"                                                                        \
+    "Several items have to be defined as class attribute in the final class:\n" \
+    "* pychrysalide.gui.PanelItem._path: path to the initial location of the"   \
+    " panel item;\n"                                                            \
+    "* pychrysalide.gui.PanelItem._key_bindings: optional shortcut to show the" \
+    " relative panel.\n"                                                        \
+    "\n"                                                                        \
+    "Some extra items offer default values and thus may be defined as class"    \
+    " attribute in the final class:\n"                                          \
+    "* pychrysalide.gui.PanelItem._personality: rule for the panel creation;\n" \
+    "* pychrysalide.gui.PanelItem._dock_at_startup: *True* if the panel should" \
+    " get docked automatically at startup;\n"                                   \
+    "* pychrysalide.gui.PanelItem._can_search: True if the panel contains"      \
+    " content which can get searched.\n"                                        \
+    "\n"                                                                        \
     "For more details about the panel path, please refer to"                    \
-    " pychrysalide.gtkext.GtkDockable."
+    " pychrysalide.gtkext.GtkDockable.\n"                                       \
+    "\n"                                                                        \
+    "Because panels aim to be created on demand by the Chrysalide core, calls"  \
+    " to the *__init__* constructor of this abstract object must expect no"     \
+    " particular argument."
 
     /* Récupération des paramètres */
 
-    ret = PyArg_ParseTupleAndKeywords(args, kwds, "O&O&ps", kwlist,
-                                      convert_to_panel_item_personality, &personality,
-                                      convert_to_named_widget, &widget,
-                                      &startup, &path);
+    ret = PyArg_ParseTuple(args, "O&", convert_to_named_widget, &widget);
     if (!ret) return -1;
 
     /* Initialisation d'un objet GLib */
@@ -248,8 +581,6 @@ static int py_panel_item_init(PyObject *self, PyObject *args, PyObject *kwds)
 
     panel = G_PANEL_ITEM(pygobject_get(self));
 
-    panel->personality = personality;
-
     /**
      * Si Python ne voit plus la variable représentant le panneau utilisée,
      * il va la supprimer, ce qui va supprimer le composant GTK.
@@ -260,9 +591,6 @@ static int py_panel_item_init(PyObject *self, PyObject *args, PyObject *kwds)
     panel->widget = widget;
     g_object_ref(G_OBJECT(widget));
 
-    panel->dock_at_startup = startup;
-    panel->path = strdup(path);
-
     return 0;
 
 }
@@ -345,32 +673,31 @@ static PyObject *py_panel_item_undock(PyObject *self, PyObject *args)
 *  Paramètres  : self    = objet Python concerné par l'appel.                 *
 *                closure = non utilisé ici.                                   *
 *                                                                             *
-*  Description : Fournit le chemin d'accès à utiliser pour les encapsulations.*
+*  Description : Fournit une indication sur la personnalité du panneau.       *
 *                                                                             *
-*  Retour      : Chemin d'accès défini.                                       *
+*  Retour      : Identifiant lié à la nature du panneau.                      *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-static PyObject *py_panel_item_get_named_widget(PyObject *self, void *closure)
+static PyObject *py_panel_item_get_personality(PyObject *self, void *closure)
 {
     PyObject *result;                       /* Valeur à retourner          */
     GPanelItem *item;                       /* Panneau à consulter         */
-    GNamedWidget *widget;                   /* Composant nommé à transférer*/
+    PanelItemPersonality personality;       /* Valeur native à convertir   */
 
-#define PANEL_ITEM_NAMED_WIDGET_ATTRIB PYTHON_GET_DEF_FULL  \
-(                                                           \
-    named_widget, py_panel_item,                            \
-    "Named widget as core component of the panel item."     \
+#define PANEL_ITEM_PERSONALITY_ATTRIB PYTHON_GET_DEF_FULL       \
+(                                                               \
+    personality, py_panel_item,                                 \
+    "Rule for handling panel creations, as a"                   \
+    " pychrysalide.gui.PanelItem.PanelItemPersonality value."   \
 )
 
     item = G_PANEL_ITEM(pygobject_get(self));
-    widget = gtk_panel_item_get_named_widget(item);
-
-    result = pygobject_new(G_OBJECT(widget));
+    personality = gtk_panel_item_class_get_personality(G_PANEL_ITEM_GET_CLASS(item));
 
-    g_object_unref(G_OBJECT(widget));
+    result = cast_with_constants_group_from_type(get_python_panel_item_type(), "PanelItemPersonality", personality);
 
     return result;
 
@@ -382,31 +709,102 @@ static PyObject *py_panel_item_get_named_widget(PyObject *self, void *closure)
 *  Paramètres  : self    = objet Python concerné par l'appel.                 *
 *                closure = non utilisé ici.                                   *
 *                                                                             *
-*  Description : Fournit une indication sur la personnalité du panneau.       *
+*  Description : Fournit une indication d'accroche du panneau au démarrage.   *
 *                                                                             *
-*  Retour      : Identifiant lié à la nature du panneau.                      *
+*  Retour      : True si le panneau doit être affiché de prime abord.         *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-static PyObject *py_panel_item_get_personality(PyObject *self, void *closure)
+static PyObject *py_panel_item_get_dock_at_startup(PyObject *self, void *closure)
 {
     PyObject *result;                       /* Valeur à retourner          */
     GPanelItem *item;                       /* Panneau à consulter         */
-    PanelItemPersonality personality;       /* Valeur native à convertir   */
+    bool state;                             /* Indication d'ancrage        */
+
+#define PANEL_ITEM_DOCK_AT_STARTUP_ATTRIB PYTHON_GETSET_DEF_FULL        \
+(                                                                       \
+    dock_at_startup, py_panel_item,                                     \
+    "Tell or define if the panel should get docked automatically at"    \
+    " startup.\n"                                                       \
+    "\n"                                                                \
+    "This state is a boolean value: *True* or *False*."                 \
+)
 
-#define PANEL_ITEM_PERSONALITY_ATTRIB PYTHON_GET_DEF_FULL       \
-(                                                               \
-    personality, py_panel_item,                                 \
-    "Rule for handling panel creations, as a"                   \
-    " pychrysalide.gui.PanelItem.PanelItemPersonality value."   \
+    item = G_PANEL_ITEM(pygobject_get(self));
+    state = gtk_panel_item_class_dock_at_startup(G_PANEL_ITEM_GET_CLASS(item));
+
+    result = state ? Py_True : Py_False;
+    Py_INCREF(result);
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : self    = objet Python concerné par l'appel.                 *
+*                value   = valeur fournie à intégrer ou prendre en compte.    *
+*                closure = adresse non utilisée ici.                          *
+*                                                                             *
+*  Description : Définit si le composant repose sur un support de l'éditeur.  *
+*                                                                             *
+*  Retour      : Bilan de l'opération.                                        *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static int py_panel_item_set_dock_at_startup(PyObject *self, PyObject *value, void *closure)
+{
+    GPanelItem *item;                       /* Panneau à manipuler         */
+
+    if (!PyBool_Check(value))
+        return -1;
+
+    item = G_PANEL_ITEM(pygobject_get(self));
+
+    g_panel_item_set_dock_at_startup(item, value == Py_True);
+
+    return 0;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : self    = objet Python concerné par l'appel.                 *
+*                closure = non utilisé ici.                                   *
+*                                                                             *
+*  Description : Détermine si un panneau peut être filtré.                    *
+*                                                                             *
+*  Retour      : Bilan de la consultation.                                    *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static PyObject *py_panel_item_can_search(PyObject *self, void *closure)
+{
+    PyObject *result;                       /* Valeur à retourner          */
+    GPanelItem *item;                       /* Panneau à consulter         */
+    bool status;                            /* Capacité de recherche       */
+
+#define PANEL_ITEM_CAN_SEARCH_ATTRIB PYTHON_CAN_DEF_FULL                \
+(                                                                       \
+    search, py_panel_item,                                              \
+    "Define if the panel contains content which can get searched.\n"    \
+    "\n"                                                                \
+    "The result is a boolean value: *True* or *False*.\n"               \
 )
 
     item = G_PANEL_ITEM(pygobject_get(self));
-    personality = gtk_panel_item_get_personality(item);
+    status = gtk_panel_item_class_can_search(G_PANEL_ITEM_GET_CLASS(item));
 
-    result = cast_with_constants_group_from_type(get_python_panel_item_type(), "PanelItemPersonality", personality);
+    result = status ? Py_True : Py_False;
+    Py_INCREF(result);
 
     return result;
 
@@ -430,19 +828,23 @@ static PyObject *py_panel_item_get_path(PyObject *self, void *closure)
 {
     PyObject *result;                       /* Valeur à retourner          */
     GPanelItem *item;                       /* Panneau à consulter         */
-    const char *path;                       /* Chemin d'accès courant      */
+    char *path;                             /* Chemin d'accès courant      */
 
 #define PANEL_ITEM_PATH_ATTRIB PYTHON_GETSET_DEF_FULL       \
 (                                                           \
     path, py_panel_item,                                    \
     "Get or define the current path of the panel item."     \
+    "\n"                                                    \
+    "The path is defined as a string."                      \
 )
 
     item = G_PANEL_ITEM(pygobject_get(self));
-    path = gtk_panel_item_get_path(item);
+    path = gtk_panel_item_class_get_path(G_PANEL_ITEM_GET_CLASS(item));
 
     result = PyUnicode_FromString(path);
 
+    free(path);
+
     return result;
 
 }
@@ -486,6 +888,91 @@ static int py_panel_item_set_path(PyObject *self, PyObject *value, void *closure
 *  Paramètres  : self    = objet Python concerné par l'appel.                 *
 *                closure = non utilisé ici.                                   *
 *                                                                             *
+*  Description : Indique la définition d'un éventuel raccourci clavier.       *
+*                                                                             *
+*  Retour      : Description d'un raccourci ou None si aucun de défini.       *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static PyObject *py_panel_item_get_key_bindings(PyObject *self, void *closure)
+{
+    PyObject *result;                       /* Valeur à retourner          */
+    GPanelItem *item;                       /* Panneau à consulter         */
+    char *bindings;                         /* Raccourci clavier éventuel  */
+
+#define PANEL_ITEM_KEY_BINDINGS_ATTRIB PYTHON_GET_DEF_FULL          \
+(                                                                   \
+    key_bindings, py_panel_item,                                    \
+    "Shortcuts for displaying the panel, as a string, or *None* if" \
+    " no binding is defined."                                       \
+)
+
+    item = G_PANEL_ITEM(pygobject_get(self));
+    bindings = gtk_panel_item_class_get_key_bindings(G_PANEL_ITEM_GET_CLASS(item));
+
+    if (bindings != NULL)
+    {
+        result = PyUnicode_FromString(bindings);
+        free(bindings);
+    }
+    else
+    {
+        result = Py_None;
+        Py_INCREF(result);
+    }
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : self    = objet Python concerné par l'appel.                 *
+*                closure = non utilisé ici.                                   *
+*                                                                             *
+*  Description : Fournit le chemin d'accès à utiliser pour les encapsulations.*
+*                                                                             *
+*  Retour      : Chemin d'accès défini.                                       *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static PyObject *py_panel_item_get_named_widget(PyObject *self, void *closure)
+{
+    PyObject *result;                       /* Valeur à retourner          */
+    GPanelItem *item;                       /* Panneau à consulter         */
+    GNamedWidget *widget;                   /* Composant nommé à transférer*/
+
+#define PANEL_ITEM_NAMED_WIDGET_ATTRIB PYTHON_GET_DEF_FULL  \
+(                                                           \
+    named_widget, py_panel_item,                            \
+    "Named widget as core component of the panel item.\n"   \
+    "\n"                                                    \
+    "The result is an implementation of the"                \
+    " pychrysalide.glibext.NamedWidget interface."          \
+)
+
+    item = G_PANEL_ITEM(pygobject_get(self));
+    widget = gtk_panel_item_get_named_widget(item);
+
+    result = pygobject_new(G_OBJECT(widget));
+
+    g_object_unref(G_OBJECT(widget));
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : self    = objet Python concerné par l'appel.                 *
+*                closure = non utilisé ici.                                   *
+*                                                                             *
 *  Description : Indique si le composant repose sur un support de l'éditeur.  *
 *                                                                             *
 *  Retour      : True si le composant est bien incrusté quelque part.         *
@@ -503,7 +990,9 @@ static PyObject *py_panel_item_get_docked(PyObject *self, void *closure)
 #define PANEL_ITEM_DOCKED_ATTRIB PYTHON_GET_DEF_FULL    \
 (                                                       \
     docked, py_panel_item,                              \
-    "Dock status of the panel item."                    \
+    "Dock status of the panel item.\n"                  \
+    "\n"                                                \
+    "The result is a boolean value: *True* or *False*." \
 )
 
     item = G_PANEL_ITEM(pygobject_get(self));
@@ -538,9 +1027,17 @@ PyTypeObject *get_python_panel_item_type(void)
     };
 
     static PyGetSetDef py_panel_item_getseters[] = {
-        PANEL_ITEM_NAMED_WIDGET_ATTRIB,
+        PANEL_ITEM_PERSONALITY_ATTRIB_WRAPPER,
+        PANEL_ITEM_DOCK_AT_STARTUP_ATTRIB_WRAPPER,
+        PANEL_ITEM_CAN_SEARCH_ATTRIB_WRAPPER,
+        PANEL_ITEM_PATH_ATTRIB_WRAPPER,
+        PANEL_ITEM_BINDINGS_ATTRIB_WRAPPER,
         PANEL_ITEM_PERSONALITY_ATTRIB,
+        PANEL_ITEM_DOCK_AT_STARTUP_ATTRIB,
+        PANEL_ITEM_CAN_SEARCH_ATTRIB,
         PANEL_ITEM_PATH_ATTRIB,
+        PANEL_ITEM_KEY_BINDINGS_ATTRIB,
+        PANEL_ITEM_NAMED_WIDGET_ATTRIB,
         PANEL_ITEM_DOCKED_ATTRIB,
         { NULL }
     };