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