From 1e3fa9b79ebe55698e2aa7d5484baec7e8400a8f Mon Sep 17 00:00:00 2001 From: Cyrille Bagard 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 #include #include @@ -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 #include -#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 = "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("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 = "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("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 = "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("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 + + +#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 +#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