diff options
Diffstat (limited to 'src/gtkext')
| -rw-r--r-- | src/gtkext/Makefile.am | 1 | ||||
| -rw-r--r-- | src/gtkext/gtkdockstation.c | 49 | ||||
| -rw-r--r-- | src/gtkext/tiledgrid.c | 1029 | ||||
| -rw-r--r-- | src/gtkext/tiledgrid.h | 81 |
4 files changed, 1116 insertions, 44 deletions
diff --git a/src/gtkext/Makefile.am b/src/gtkext/Makefile.am index 42905fb..00ce40b 100644 --- a/src/gtkext/Makefile.am +++ b/src/gtkext/Makefile.am @@ -16,6 +16,7 @@ libgtkext_la_SOURCES = \ gtkstatusstack.h gtkstatusstack.c \ rendering.h rendering.c \ support.h support.c \ + tiledgrid.h tiledgrid.c \ tmgt.h tmgt.c libgtkext_la_LIBADD = \ diff --git a/src/gtkext/gtkdockstation.c b/src/gtkext/gtkdockstation.c index 634b007..688fe4b 100644 --- a/src/gtkext/gtkdockstation.c +++ b/src/gtkext/gtkdockstation.c @@ -271,28 +271,15 @@ void gtk_dock_station_add_dockable(GtkDockStation *station, GtkDockable *dockabl GtkWidget *label; /* Etiquette d'onglet */ GtkNotebook *notebook; /* Autre version du composant */ - /* Récupération des éléments utiles */ - widget = gtk_dockable_build_widget(dockable); - if (strcmp(gtk_dockable_get_name(dockable), "History") == 0) - { - GtkRequisition req; - gtk_widget_get_preferred_size(widget, &req, NULL); - fprintf(stderr, "Histo req :: %d x %d\n", req.width, req.height); - } - /* - if (!GTK_IS_SCROLLED_WINDOW(widget) - && ( - strcmp(gtk_dockable_get_name(dockable), "History2") != 0 - ) - ) - widget = gtk_button_new_with_label("123"); - */ + /* Récupération des éléments utiles */ + + widget = gtk_dockable_build_widget(dockable); //widget = gtk_button_new_with_label("123"); gtk_widget_show(widget); @@ -318,7 +305,8 @@ void gtk_dock_station_add_dockable(GtkDockStation *station, GtkDockable *dockabl g_signal_handlers_disconnect_by_func(notebook, G_CALLBACK(gtk_dock_station_switch_panel), station); - gtk_notebook_insert_page(notebook, widget, label, -1); + gtk_notebook_append_page(notebook, widget, label); + gtk_widget_set_tooltip_text(label, desc); if (gtk_notebook_get_n_pages(notebook) > 1) @@ -330,33 +318,6 @@ void gtk_dock_station_add_dockable(GtkDockStation *station, GtkDockable *dockabl if (gtk_notebook_get_n_pages(notebook) > 1) gtk_notebook_set_current_page(notebook, -1); - - // Renéociation des tailles - //gtk_widget_queue_resize(GTK_WIDGET(notebook)); - - - if (false) - { - GtkRequisition req; - - gtk_widget_get_preferred_size(GTK_WIDGET(notebook), &req, NULL); - fprintf(stderr, "=== SUPPORT req :: %d x %d\n", req.width, req.height); - - - gtk_widget_set_size_request(GTK_WIDGET(notebook), req.width, req.height); - - - - } - - - - - - - - - //g_signal_emit_by_name(station, "dock-widget", widget); } diff --git a/src/gtkext/tiledgrid.c b/src/gtkext/tiledgrid.c new file mode 100644 index 0000000..31358f7 --- /dev/null +++ b/src/gtkext/tiledgrid.c @@ -0,0 +1,1029 @@ + +/* Chrysalide - Outil d'analyse de fichiers binaires + * tiledgrid.c - compsoant d'affichage avec des chemins vers les composants contenus + * + * Copyright (C) 2018 Cyrille Bagard + * + * This file is part of Chrysalide. + * + * Chrysalide is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * Chrysalide is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Chrysalide. If not, see <http://www.gnu.org/licenses/>. + */ + + +#include "tiledgrid.h" + + +#include <assert.h> +#include <ctype.h> +#include <malloc.h> +#include <string.h> + + +#include "gtkdockstation.h" +#include "../core/logs.h" + + + +/* -------------------------- GESTION DES TUILES AFFICHEES -------------------------- */ + + +/* Informations concernant une tuile */ +typedef struct _grid_tile_t +{ + struct _grid_tile_t *parent; /* Tuile parente */ + + GtkWidget *widget; /* Support d'affichage */ + + char *path; /* Chemin d'accès */ + + struct _grid_tile_t *children[2]; /* Tuiles encastrées ou 2xNULL */ + +} grid_tile_t; + + +#define IS_LEAF_TILE(t) \ + ({ \ + bool __result; \ + __result = GTK_IS_DOCK_STATION((t)->widget); \ + assert(__result || GTK_IS_PANED((t)->widget)); \ + __result; \ + }) + + +/* Valide un chemin d'accès à une tuile. */ +static bool is_valid_tile_path(const char *); + +/* Crée une tuile finale d'affichage de panneaux. */ +static grid_tile_t *create_leaf_tile(const char *, GtkTiledGrid *); + +/* Crée une tuile intermédiaire d'affichage de panneaux. */ +static grid_tile_t *create_inter_tile(grid_tile_t *, bool, grid_tile_t *, grid_tile_t *); + +/* Supprime une tuile de la mémoire. */ +static void delete_tile(grid_tile_t *); + +/* Calcule la taille comme entre un chemin et celui d'une tuile. */ +static size_t compute_tile_score(const grid_tile_t *, const char *); + +/* Indique la tuile adaptée pour un chemin donné. */ +static grid_tile_t *find_suitable_tile(grid_tile_t **, const char *, GtkTiledGrid *); + +/* Découpe une tuile pour y insérer une zone. */ +static grid_tile_t *split_tile(grid_tile_t **, const char *, char, GtkTiledGrid *); + +/* Tente de mettre la main sur une station d'accueil. */ +static grid_tile_t *find_tile_for_widget(grid_tile_t *, GtkWidget *); + + + +/* --------------------------- INTERFACE DU COMPOSANT GTK --------------------------- */ + + +/* Conteneur pour un affichage en tuiles nommées (instance) */ +struct _GtkTiledGrid +{ + GtkBin parent; /* A laisser en premier */ + + grid_tile_t *tiles; /* Tuiles représentées */ + + GPanelItem *def_panel; /* Panneau principal par défaut*/ + +}; + +/* Conteneur pour un affichage en tuiles nommées (classe) */ +struct _GtkTiledGridClass +{ + GtkBinClass parent; /* A laisser en premier */ + + /* Signaux */ + + void (* station_created) (GtkTiledGrid *, GtkDockStation *, gpointer); + +}; + + +/* Initialise la classe des conteneurs d'affichage en tuiles. */ +static void gtk_tiled_grid_class_init(GtkTiledGridClass *); + +/* Initialise une instance de conteneur d'affichage en tuiles. */ +static void gtk_tiled_grid_init(GtkTiledGrid *); + +/* Supprime toutes les références externes. */ +static void gtk_tiled_grid_dispose(GtkTiledGrid *); + +/* Procède à la libération totale de la mémoire. */ +static void gtk_tiled_grid_finalize(GtkTiledGrid *); + + + +/* ---------------------------------------------------------------------------------- */ +/* GESTION DES TUILES AFFICHEES */ +/* ---------------------------------------------------------------------------------- */ + + +/****************************************************************************** +* * +* Paramètres : path = chemin destiné à sélectionner une tuile. * +* * +* Description : Valide un chemin d'accès à une tuile. * +* * +* Retour : true si le chemin est utilisable, false sinon. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static bool is_valid_tile_path(const char *path) +{ + bool result; /* Bilan à retourner */ + size_t len; /* Taille du chemin */ + size_t i; /* Boucle de parcours */ + char c; /* Caractère de chemin analysé */ + + /** + * M[NESWnesw]* + */ + + len = strlen(path); + + result = (len >= 1); + + if (result) + result = (path[0] == 'M'); + + for (i = 1; i < len && result; i++) + { + c = path[i]; + + if (c == '\0') + break; + + result = (c == 'N' || c == 'n' + || c == 'E' || c == 'e' + || c == 'S' || c == 's' + || c == 'W' || c == 'w'); + + } + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : path = chemin d'accès à la future tuile. * +* Paramètres : tgrid = conteneur d'affichage en tuiles à manipuler. * +* * +* Description : Crée une tuile finale d'affichage de panneaux. * +* * +* Retour : Structure mise en place. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static grid_tile_t *create_leaf_tile(const char *path, GtkTiledGrid *tgrid) +{ + grid_tile_t *result; /* Structure à retourner */ + + result = (grid_tile_t *)malloc(sizeof(grid_tile_t)); + + result->parent = NULL; + + result->widget = gtk_dock_station_new(); + gtk_widget_show(result->widget); + + result->path = strdup(path); + + result->children[0] = NULL; + result->children[1] = NULL; + + g_signal_emit_by_name(tgrid, "station-created", result->widget); + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : parent = tuile parente ou NULL si aucune. * +* horiz = indique le type d'orientation désiré. * +* first = première tuile à intégrer. * +* second = seconde tuile à intégrer. * +* * +* Description : Crée une tuile intermédiaire d'affichage de panneaux. * +* * +* Retour : Structure mise en place. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static grid_tile_t *create_inter_tile(grid_tile_t *parent, bool horiz, grid_tile_t *first, grid_tile_t *second) +{ + grid_tile_t *result; /* Structure à retourner */ + GtkWidget *container; /* Conteneur à vider */ + + result = (grid_tile_t *)malloc(sizeof(grid_tile_t)); + + result->parent = parent; + + if (horiz) + result->widget = gtk_paned_new(GTK_ORIENTATION_HORIZONTAL); + else + result->widget = gtk_paned_new(GTK_ORIENTATION_VERTICAL); + + gtk_widget_show(result->widget); + + result->path = NULL; + + result->children[0] = first; + result->children[1] = second; + + /* Changement de propriétaire */ + + container = gtk_widget_get_parent(first->widget); + + if (container != NULL) + gtk_container_remove(GTK_CONTAINER(container), first->widget); + + g_object_ref(G_OBJECT(first->widget)); + gtk_paned_pack1(GTK_PANED(result->widget), first->widget, TRUE, FALSE); + + container = gtk_widget_get_parent(second->widget); + + if (container != NULL) + gtk_container_remove(GTK_CONTAINER(container), second->widget); + + g_object_ref(G_OBJECT(second->widget)); + gtk_paned_pack2(GTK_PANED(result->widget), second->widget, TRUE, FALSE); + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : tile = tuile à supprimer. * +* * +* Description : Supprime une tuile de la mémoire. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void delete_tile(grid_tile_t *tile) +{ + if (!IS_LEAF_TILE(tile)) + { + delete_tile(tile->children[0]); + delete_tile(tile->children[1]); + } + + else + free(tile->path); + + g_object_unref(G_OBJECT(tile->widget)); + + free(tile); + +} + + +/****************************************************************************** +* * +* Paramètres : tile = tuile à analyser. * +* path = chemin final complet recherché. * +* * +* Description : Calcule la taille comme entre un chemin et celui d'une tuile.* +* * +* Retour : Quantité de caractères communs. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static size_t compute_tile_score(const grid_tile_t *tile, const char *path) +{ + size_t result; /* Nombre de points à renvoyer */ + size_t max; /* Taille du chemin de la tuile*/ + size_t i; /* Boucle de parcours */ + size_t score_0; /* Score du sous-élément #1 */ + size_t score_1; /* Score du sous-élément #2 */ + + if (IS_LEAF_TILE(tile)) + { + max = strlen(tile->path); + + if (strlen(path) < max) + result = 0; + + else + { + result = 0; + + for (i = 0; i < max; i++) + { + if (tolower((unsigned char)tile->path[i]) == tolower((unsigned char)path[i])) + result++; + else + break; + } + + } + + } + else + { + score_0 = compute_tile_score(tile->children[0], path); + score_1 = compute_tile_score(tile->children[1], path); + + result = score_0 > score_1 ? score_0 : score_1; + + } + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : tile = tuile ou NULL si aucune. [OUT] * +* path = chemin d'accès à la tuile visée. * +* tgrid = conteneur d'affichage en tuiles à manipuler. * +* * +* Description : Indique la tuile adaptée pour un chemin donné. * +* * +* Retour : Structure d'acceuil à disposition. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static grid_tile_t *find_suitable_tile(grid_tile_t **tile, const char *path, GtkTiledGrid *tgrid) +{ + grid_tile_t *result; /* Structure à renvoyer */ + size_t best_len; /* Taille du chemin associé */ + size_t score_0; /* Score du sous-élément #1 */ + size_t score_1; /* Score du sous-élément #2 */ + char *sub_path; /* Nouvelle tentative d'accès */ + grid_tile_t **best; /* Direction à prendre */ + unsigned char next; /* Prochaine étape */ + + /* Cas d'école : appel initial */ + if (*tile == NULL) + { + assert(path[0] == 'M' && path[1] == '\0'); + + result = create_leaf_tile("M", tgrid); + *tile = result; + + } + + else + { + if (IS_LEAF_TILE(*tile)) + { + best_len = compute_tile_score(*tile, path); + + assert(best_len > 0); + + if (path[best_len] == '\0') + result = *tile; + + else + result = split_tile(tile, path, path[best_len], tgrid); + + } + + else + { + score_0 = compute_tile_score((*tile)->children[0], path); + score_1 = compute_tile_score((*tile)->children[1], path); + + assert(score_0 > 0 || score_0 > 0); + + if (score_0 == score_1) + { + sub_path = strndup(path, score_0); + + score_0 = compute_tile_score((*tile)->children[0], sub_path); + score_1 = compute_tile_score((*tile)->children[1], sub_path); + + free(sub_path); + + } + + if (score_0 == score_1) + result = split_tile(tile, path, path[score_0], tgrid); + + else + { + if (score_0 > score_1) + { + best = &(*tile)->children[0]; + best_len = score_0; + } + else + { + best = &(*tile)->children[1]; + best_len = score_1; + } + + /** + * Si on vient de tomber une feuille, trois cas de figure : + * - soit c'est elle qui est visée. + * - soit on veut la diviser. + * - soit on veut la diviser en englobant ses voisines. + */ + + if (IS_LEAF_TILE(*best)) + { + assert(best_len <= strlen(path)); + + next = path[best_len]; + + /* Premier cas */ + if (next == '\0') + result = *best; + + else + { + /* Second cas */ + if (islower(next)) + result = find_suitable_tile(best, path, tgrid); + + /* Troisième cas */ + else + result = split_tile(tile, path, next, tgrid); + + } + + } + + else + result = find_suitable_tile(best, path, tgrid); + + } + + } + + } + + assert(IS_LEAF_TILE(result)); + + return result; + +} + +/****************************************************************************** +* * +* Paramètres : tile = tuile à découper en deux. [OUT] * +* path = chemin d'accès à la future tuile. * +* endpoint = désignation de la zone représentée. * +* tgrid = conteneur d'affichage en tuiles à manipuler. * +* * +* Description : Découpe une tuile pour y insérer une zone. * +* * +* Retour : Structure fille mise en place. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static grid_tile_t *split_tile(grid_tile_t **tile, const char *path, char endpoint, GtkTiledGrid *tgrid) +{ + grid_tile_t *result; /* Création à retourner */ + GtkWidget *container; /* Conteneur à vider */ + grid_tile_t *new; /* Nouvelle tuile intermédiaire*/ + + container = gtk_widget_get_parent((*tile)->widget); + + /* Création */ + + result = create_leaf_tile(path, tgrid); + + /* Encapsulation */ + + switch (endpoint) + { + case 'N': + case 'n': + new = create_inter_tile((*tile)->parent, false, result, *tile); + break; + + case 'E': + case 'e': + new = create_inter_tile((*tile)->parent, true, *tile, result); + break; + + case 'S': + case 's': + new = create_inter_tile((*tile)->parent, false, *tile, result); + break; + + case 'W': + case 'w': + new = create_inter_tile((*tile)->parent, true, result, *tile); + break; + + } + + /* Connexions */ + + *tile = new; + + result->parent = new; + + if (container != NULL) + { + g_object_ref(G_OBJECT(new->widget)); + gtk_container_add(GTK_CONTAINER(container), new->widget); + } + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : tile = point de départ des recherches locales. * +* widget = composant graphique à retrouver. * +* * +* Description : Tente de mettre la main sur une station d'accueil. * +* * +* Retour : Eventuelle tuile trouvée ou NULL. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static grid_tile_t *find_tile_for_widget(grid_tile_t *tile, GtkWidget *widget) +{ + grid_tile_t *result; /* Tuile à retourner */ + + if (IS_LEAF_TILE(tile)) + result = tile->widget == widget ? tile : NULL; + + else + { + result = find_tile_for_widget(tile->children[0], widget); + + if (result == NULL) + result = find_tile_for_widget(tile->children[1], widget); + + } + + return result; + +} + + + +/* ---------------------------------------------------------------------------------- */ +/* INTERFACE DU COMPOSANT GTK */ +/* ---------------------------------------------------------------------------------- */ + + +/* Détermine le type du conteneur d'affichage en tuiles nommées. */ +G_DEFINE_TYPE(GtkTiledGrid, gtk_tiled_grid, GTK_TYPE_BIN) + + +/****************************************************************************** +* * +* Paramètres : klass = classe GTK à initialiser. * +* * +* Description : Initialise la classe des conteneurs d'affichage en tuiles. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void gtk_tiled_grid_class_init(GtkTiledGridClass *klass) +{ + GObjectClass *object; /* Autre version de la classe */ + + object = G_OBJECT_CLASS(klass); + + object->dispose = (GObjectFinalizeFunc/* ! */)gtk_tiled_grid_dispose; + object->finalize = (GObjectFinalizeFunc)gtk_tiled_grid_finalize; + + g_signal_new("station-created", + GTK_TYPE_TILED_GRID, + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET(GtkTiledGridClass, station_created), + NULL, NULL, + g_cclosure_marshal_VOID__OBJECT, + G_TYPE_NONE, 1, GTK_TYPE_DOCK_STATION); + +} + + +/****************************************************************************** +* * +* Paramètres : stack = instance GTK à initialiser. * +* * +* Description : Initialise une instance de conteneur d'affichage en tuiles. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void gtk_tiled_grid_init(GtkTiledGrid *tgrid) +{ + tgrid->tiles = NULL; + + tgrid->def_panel = NULL; + +} + + +/****************************************************************************** +* * +* Paramètres : tgrid = instance d'objet GLib à traiter. * +* * +* Description : Supprime toutes les références externes. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void gtk_tiled_grid_dispose(GtkTiledGrid *tgrid) +{ + if (tgrid->tiles != NULL) + { + delete_tile(tgrid->tiles); + tgrid->tiles = NULL; + } + + g_clear_object(&tgrid->def_panel); + + G_OBJECT_CLASS(gtk_tiled_grid_parent_class)->dispose(G_OBJECT(tgrid)); + +} + + +/****************************************************************************** +* * +* Paramètres : tgrid = instance d'objet GLib à traiter. * +* * +* Description : Procède à la libération totale de la mémoire. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void gtk_tiled_grid_finalize(GtkTiledGrid *tgrid) +{ + G_OBJECT_CLASS(gtk_tiled_grid_parent_class)->finalize(G_OBJECT(tgrid)); + +} + + +/****************************************************************************** +* * +* Paramètres : - * +* * +* Description : Crée une nouvelle instance de conteneur avec tuiles. * +* * +* Retour : Composant GTK mis en place. * +* * +* Remarques : - * +* * +******************************************************************************/ + +GtkWidget *gtk_tiled_grid_new(void) +{ + return g_object_new(GTK_TYPE_TILED_GRID, NULL); + +} + + +/****************************************************************************** +* * +* Paramètres : tgrid = conteneur d'affichage en tuiles à consulter. * +* * +* Description : Donne le panneau fourni par défaut pour la zone principale. * +* * +* Retour : Panneau d'affichage par défault ou NULL. * +* * +* Remarques : - * +* * +******************************************************************************/ + +GPanelItem *gtk_tiled_grid_get_default_main_panel(const GtkTiledGrid *tgrid) +{ + GPanelItem *result; /* Panneau à retourner */ + + result = tgrid->def_panel; + + if (result != NULL) + g_object_ref(G_OBJECT(result)); + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : tgrid = conteneur d'affichage en tuiles à modifier. * +* panel = panneau d'affichage par défault ou NULL. * +* * +* Description : Fournit le panneau par défaut pour la zone principale. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +void gtk_tiled_grid_set_default_main_panel(GtkTiledGrid *tgrid, GPanelItem *panel) +{ + GtkWidget *widget; /* Composant GTK à retirer */ + GtkWidget *parent; /* Conteneur à vider */ + grid_tile_t *tile; /* Première tuile d'accueil */ + + if (tgrid->def_panel != NULL) + { + widget = gtk_dockable_build_widget(GTK_DOCKABLE(tgrid->def_panel)); + + parent = gtk_widget_get_parent(widget); + + if (parent != NULL) + gtk_container_remove(GTK_CONTAINER(parent), widget); + + g_object_unref(G_OBJECT(widget)); + + g_object_unref(G_OBJECT(tgrid->def_panel)); + + } + + tgrid->def_panel = panel; + + if (panel != NULL) + { + g_object_ref(G_OBJECT(panel)); + + if (tgrid->tiles == NULL) + gtk_tiled_grid_add(tgrid, panel); + + else + { + tile = find_suitable_tile(&tgrid->tiles, "M", tgrid); + + if (gtk_notebook_get_n_pages(GTK_NOTEBOOK(tile->widget)) == 0) + gtk_tiled_grid_add(tgrid, panel); + + } + + } + +} + + +/****************************************************************************** +* * +* Paramètres : tgrid = conteneur d'affichage en tuiles à modifier. * +* panel = panneau d'affichage à intégrer. * +* * +* Description : Incorpore un nouveau panneau dans le conteneur en tuiles. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +void gtk_tiled_grid_add(GtkTiledGrid *tgrid, GPanelItem *panel) +{ + const char *path; /* Chemin d'accès */ + grid_tile_t *tile; /* Tuile d'accueil */ + + path = gtk_panel_item_get_path(panel); + + if (!is_valid_tile_path(path)) + { + log_variadic_message(LMT_ERROR, _("Invalid path '%s' for panel '%s'"), + path, gtk_dockable_get_name(GTK_DOCKABLE(panel))); + } + + else + { + tile = find_suitable_tile(&tgrid->tiles, path, tgrid); + assert(tile != NULL); + + gtk_dock_station_add_dockable(GTK_DOCK_STATION(tile->widget), GTK_DOCKABLE(panel)); + + g_panel_item_set_dock_status(panel, true); + + /* Si c'est la toute première fois... */ + if (gtk_widget_get_parent(tile->widget) == NULL) + { + assert(tile == tgrid->tiles); + assert(tile->path[0] == 'M' && tile->path[1] == '\0'); + g_object_ref(G_OBJECT(tile->widget)); + gtk_container_add(GTK_CONTAINER(tgrid), tile->widget); + } + + /* Si on n'a plus besoin du panneau par défaut */ + if (tgrid->def_panel != NULL && tile->path[0] == 'M' && tile->path[1] == '\0') + { + /* Si ce n'est pas le panneau qu'on vient de rajouter...*/ + if (panel != tgrid->def_panel) + { + /* Enfin : si ce panneau par défaut est réellement en place */ + if (g_panel_item_is_docked(tgrid->def_panel)) + gtk_tiled_grid_remove(tgrid, tgrid->def_panel); + + } + + } + + } + +} + + +/****************************************************************************** +* * +* Paramètres : tgrid = conteneur d'affichage en tuiles à modifier. * +* panel = panneau d'affichage à supprimer. * +* * +* Description : Retire un panneau dans le conteneur en tuiles. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +void gtk_tiled_grid_remove(GtkTiledGrid *tgrid, GPanelItem *panel) +{ + GtkWidget *station; /* Support courant */ + grid_tile_t *tile; /* Tuile d'accueil */ + + assert(g_panel_item_is_docked(panel)); + + gtk_dockable_decompose(GTK_DOCKABLE(panel), &station); + + tile = find_tile_for_widget(tgrid->tiles, station); + assert(tile != NULL); + + gtk_dock_station_remove_dockable(GTK_DOCK_STATION(station), GTK_DOCKABLE(panel)); + + g_panel_item_set_dock_status(panel, false); + + if (gtk_notebook_get_n_pages(GTK_NOTEBOOK(station)) == 0) + { + //delete_panel_node(node); + + /* Si le panneau par défaut devient nécessaire */ + if (tgrid->def_panel != NULL && tile->path[0] == 'M' && tile->path[1] == '\0') + gtk_tiled_grid_add(tgrid, tgrid->def_panel); + + } + +} + + +/****************************************************************************** +* * +* Paramètres : tgrid = conteneur d'affichage en tuiles à mettre à jour. * +* config = configuration à consulter. * +* * +* Description : Replace les positions des séparateurs de tuiles. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +void gtk_tiled_grid_restore_positions(const GtkTiledGrid *tgrid, GGenConfig *config) +{ + + void visit_tiles_for_restoring(grid_tile_t *tile, const char *vpath) + { + GtkOrientation orientation; /* Direction de la tuile */ + char hint; /* Inutile donc indispensable */ + char *key; /* Clef d'accès à un paramètre */ + gint position; /* Nouvelle position de barre */ + size_t i; /* Boucle de parcours */ + char *child_key; /* Clef d'accès des suivants */ + + if (!IS_LEAF_TILE(tile)) + { + orientation = gtk_orientable_get_orientation(GTK_ORIENTABLE(tile->widget)); + + hint = orientation == GTK_ORIENTATION_HORIZONTAL ? 'h' : 'v'; + + asprintf(&key, "%s%c", vpath, hint); + + if (g_generic_config_get_value(config, key, &position)) + gtk_paned_set_position(GTK_PANED(tile->widget), position); + + for (i = 0; i < 2; i++) + { + asprintf(&child_key, "%s%zu", key, i); + + visit_tiles_for_restoring(tile->children[i], child_key); + + free(child_key); + + } + + free(key); + + } + + } + + + visit_tiles_for_restoring(tgrid->tiles, "gui.panels.positions.R"); + +} + + +/****************************************************************************** +* * +* Paramètres : tgrid = conteneur d'affichage en tuiles à consulter. * +* config = configuration à mettre à jour. * +* * +* Description : Sauvegarde les positions des séparateurs de tuiles. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +void gtk_tiled_grid_save_positions(const GtkTiledGrid *tgrid, GGenConfig *config) +{ + + void visit_tiles_for_saving(grid_tile_t *tile, const char *vpath) + { + GtkOrientation orientation; /* Direction de la tuile */ + char hint; /* Inutile donc indispensable */ + char *key; /* Clef d'accès à un paramètre */ + gint position; /* Nouvelle position de barre */ + size_t i; /* Boucle de parcours */ + char *child_key; /* Clef d'accès des suivants */ + + if (!IS_LEAF_TILE(tile)) + { + orientation = gtk_orientable_get_orientation(GTK_ORIENTABLE(tile->widget)); + + hint = orientation == GTK_ORIENTATION_HORIZONTAL ? 'h' : 'v'; + + asprintf(&key, "%s%c", vpath, hint); + + position = gtk_paned_get_position(GTK_PANED(tile->widget)); + g_generic_config_create_or_udpdate_param(config, key, CPT_INTEGER, -1, position); + + for (i = 0; i < 2; i++) + { + asprintf(&child_key, "%s%zu", key, i); + + visit_tiles_for_saving(tile->children[i], child_key); + + free(child_key); + + } + + free(key); + + } + + } + + + visit_tiles_for_saving(tgrid->tiles, "gui.panels.positions.R"); + +} diff --git a/src/gtkext/tiledgrid.h b/src/gtkext/tiledgrid.h new file mode 100644 index 0000000..25d3b26 --- /dev/null +++ b/src/gtkext/tiledgrid.h @@ -0,0 +1,81 @@ + +/* Chrysalide - Outil d'analyse de fichiers binaires + * tiledgrid.h - prototypes pour un compsoant d'affichage avec des chemins vers les composants contenus + * + * Copyright (C) 2018 Cyrille Bagard + * + * This file is part of Chrysalide. + * + * Chrysalide is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * Chrysalide is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Chrysalide. If not, see <http://www.gnu.org/licenses/>. + */ + + +#ifndef _GTKEXT_TILEDGRID_H +#define _GTKEXT_TILEDGRID_H + + +#include <gtk/gtk.h> + + +#include "../glibext/configuration.h" +#include "../gui/panels/panel.h" + + + +/* --------------------------- INTERFACE DU COMPOSANT GTK --------------------------- */ + + +#define GTK_TYPE_TILED_GRID gtk_tiled_grid_get_type() +#define GTK_TILED_GRID(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), GTK_TYPE_TILED_GRID, GtkTiledGrid)) +#define GTK_IS_TILED_GRID(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), GTK_TYPE_TILED_GRID)) +#define GTK_TILED_GRID_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), GTK_TYPE_TILED_GRID, GtkTiledGridClass)) +#define GTK_IS_TILED_GRID_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), GTK_TYPE_TILED_GRID)) +#define GTK_TILED_GRID_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), GTK_TYPE_TILED_GRID, GtkTiledGridClass)) + + + +/* Conteneur pour un affichage en tuiles nommées (instance) */ +typedef struct _GtkTiledGrid GtkTiledGrid; + +/* Conteneur pour un affichage en tuiles nommées (classe) */ +typedef struct _GtkTiledGridClass GtkTiledGridClass; + + +/* Détermine le type du conteneur d'affichage en tuiles nommées. */ +GType gtk_tiled_grid_get_type(void); + +/* Crée une nouvelle instance de conteneur avec tuiles. */ +GtkWidget *gtk_tiled_grid_new(void); + +/* Donne le panneau fourni par défaut pour la zone principale. */ +GPanelItem *gtk_tiled_grid_get_default_main_panel(const GtkTiledGrid *); + +/* Fournit le panneau par défaut pour la zone principale. */ +void gtk_tiled_grid_set_default_main_panel(GtkTiledGrid *, GPanelItem *); + +/* Incorpore un nouveau panneau dans le conteneur en tuiles. */ +void gtk_tiled_grid_add(GtkTiledGrid *, GPanelItem *); + +/* Retire un panneau dans le conteneur en tuiles. */ +void gtk_tiled_grid_remove(GtkTiledGrid *, GPanelItem *); + +/* Replace les positions des séparateurs de tuiles. */ +void gtk_tiled_grid_restore_positions(const GtkTiledGrid *, GGenConfig *); + +/* Sauvegarde les positions des séparateurs de tuiles. */ +void gtk_tiled_grid_save_positions(const GtkTiledGrid *, GGenConfig *); + + + +#endif /* _GTKEXT_TILEDGRID_H */ |