/* Chrysalide - Outil d'analyse de fichiers binaires * gtkgraphview.c - affichage de morceaux de code sous forme graphique * * Copyright (C) 2009-2014 Cyrille Bagard * * This file is part of Chrysalide. * * OpenIDA 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. * * OpenIDA 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 Foobar. If not, see . */ #include "gtkgraphview.h" #include "gtkblockview.h" #include "gtkbufferview.h" #include "gtkviewpanel-int.h" #include "graph/layout.h" #include "../analysis/blocks/flow.h" #include "../gui/editem.h" /* Composant d'affichage sous forme graphique (instance) */ struct _GtkGraphView { GtkViewPanel parent; /* A laisser en premier */ GtkFixed *support; /* Support des vues en bloc */ GBinRoutine *routine; /* Routine en cours d'affichage*/ vmpa_t start; /* Début de la portion vue */ /* FIXME : à garder ? */ vmpa_t end; /* Fin de la portion affichée */ /* FIXME : à garder ? */ GtkViewPanel **children; /* Liste des sous-blocs */ GtkAllocation *allocs; /* Emplacements prévisibles */ size_t children_count; /* Taille de cette liste */ GGraphLayout *layout; /* Disposition en graphique */ GtkLinkRenderer **links; /* Liste des liens graphiques */ size_t links_count; /* Nombre de ces liens */ }; /* Composant d'affichage sous forme graphique (classe) */ struct _GtkGraphViewClass { GtkViewPanelClass parent; /* A laisser en premier */ }; /* Initialise la classe générique des graphiques de code. */ static void gtk_graph_view_class_init(GtkGraphViewClass *); /* Initialise une instance d'afficheur de code en graphique. */ static void gtk_graph_view_init(GtkGraphView *); /* Indique les dimensions de travail du composant d'affichage. */ static void gtk_graph_view_compute_requested_size(GtkGraphView *, gint *, gint *); /* Réagit à un défilement chez une barre associée au composant. */ static void gtk_graph_view_adjust_scroll_value(GtkGraphView *, GtkAdjustment *, GtkOrientation); /* Met à jour l'affichage de la vue sous forme graphique. */ static gboolean gtk_graph_view_draw(GtkWidget *, cairo_t *, GtkGraphView *); /* Actualise les besoins internes avant un redimensionnement. */ static void gtk_graph_view_prepare_resize(GtkGraphView *); /* Réagit à la sélection externe d'une adresse. */ static void gtk_graph_view_define_main_address(GtkGraphView *, const vmpa2t *); /* Indique la position d'affichage d'une adresse donnée. */ static bool gtk_graph_view_get_address_coordinates(const GtkGraphView *, const vmpa2t *addr, gint *x, gint *y, ScrollPositionTweak tweak); /* Place en cache un rendu destiné à l'aperçu graphique rapide. */ static void gtk_graph_view_cache_glance(GtkGraphView *, cairo_t *, const GtkAllocation *, double); /* Supprime tout contenu de l'afficheur de code en graphique. */ static void gtk_graph_view_reset(GtkGraphView *); /* Définit la liste complète des éléments du futur graphique. * * * * Retour : Liste d'éléments du graphique à placer. */ static GtkViewPanel **gtk_graph_view_load_nodes(GtkGraphView *, GLoadedBinary *, const GBinRoutine *); /* Détermine le type du composant d'affichage en graphique. */ G_DEFINE_TYPE(GtkGraphView, gtk_graph_view, GTK_TYPE_VIEW_PANEL) /****************************************************************************** * * * Paramètres : class = classe GTK à initialiser. * * * * Description : Initialise la classe générique des graphiques de code. * * * * Retour : - * * * * Remarques : - * * * ******************************************************************************/ static void gtk_graph_view_class_init(GtkGraphViewClass *class) { GtkWidgetClass *widget_class; /* Classe version Widget */ GtkViewPanelClass *panel_class; /* Classe parente */ widget_class = GTK_WIDGET_CLASS(class); panel_class = GTK_VIEW_PANEL_CLASS(class); panel_class->compute_size = (compute_requested_size_fc)gtk_graph_view_compute_requested_size; panel_class->adjust = (adjust_scroll_value_fc)gtk_graph_view_adjust_scroll_value; panel_class->define = (define_address_fc)gtk_graph_view_define_main_address; panel_class->get_coordinates = (get_addr_coordinates_fc)gtk_graph_view_get_address_coordinates; } /****************************************************************************** * * * Paramètres : view = instance GTK à initialiser. * * * * Description : Initialise une instance d'afficheur de code en graphique. * * * * Retour : - * * * * Remarques : - * * * ******************************************************************************/ static void gtk_graph_view_init(GtkGraphView *view) { GtkViewPanel *viewpanel; /* Instance parente #1 */ //GtkBinView *binview; /* Instance parente #2 */ GdkColor white; /* Couleur de fond normale */ viewpanel = GTK_VIEW_PANEL(view); viewpanel->resize = (prepare_resize_fc)gtk_graph_view_prepare_resize; ////////viewpanel->get_coordinates = (get_addr_coordinates_fc)gtk_graph_view_get_address_coordinates; viewpanel->cache_glance = (cache_glance_fc)gtk_graph_view_cache_glance; //binview = GTK_BIN_VIEW(view); //binview->set_lines = (set_rendering_lines_fc)gtk_graph_view_set_rendering_lines; //binview->define_address = (define_main_address_fc)gtk_graph_view_define_main_address; //binview->get_coordinates = (get_addr_coordinates_fc)gtk_graph_view_get_address_coordinates; view->support = GTK_FIXED(gtk_fixed_new()); gtk_widget_set_has_window(GTK_WIDGET(view->support), TRUE); gtk_widget_set_can_focus(GTK_WIDGET(view->support), TRUE); g_signal_connect(G_OBJECT(view->support), "draw", G_CALLBACK(gtk_graph_view_draw), view); gtk_widget_show(GTK_WIDGET(view->support)); gtk_fixed_put(GTK_FIXED(view), GTK_WIDGET(view->support), 0, 0); //view->mutex = g_mutex_new(); //view->cond = g_cond_new(); } /****************************************************************************** * * * Paramètres : view = composant GTK à consulter. * * width = largeur requise à renseigner ou NULL. [OUT] * * height = hauteur requise à renseigner ou NULL. [OUT] * * * * Description : Indique les dimensions de travail du composant d'affichage. * * * * Retour : - * * * * Remarques : - * * * ******************************************************************************/ static void gtk_graph_view_compute_requested_size(GtkGraphView *view, gint *width, gint *height) { GtkRequisition requisition; /* Taille requise */ if (width != NULL && view->layout != NULL) { g_graph_layout_size_request(view->layout, &requisition); *width = requisition.width; } if (height != NULL && view->layout != NULL) { g_graph_layout_size_request(view->layout, &requisition); *height = requisition.height; } } /****************************************************************************** * * * Paramètres : view = panneau d'affichage concerné. * * adj = défilement dont une valeur a changé. * * orientation = indication sur le défilement à traiter. * * * * Description : Réagit à un défilement chez une barre associée au composant. * * * * Retour : - * * * * Remarques : - * * * ******************************************************************************/ static void gtk_graph_view_adjust_scroll_value(GtkGraphView *view, GtkAdjustment *adj, GtkOrientation orientation) { gint fake_x; /* Abscisse virtuelle */ gint fake_y; /* Ordonnée virtuelle */ fake_x = 0; fake_y = 0; gtk_buffer_view_compute_fake_coord(view, &fake_x, &fake_y); printf("fake :: (%d ; %d)\n", fake_x, fake_y); gtk_fixed_move(GTK_FIXED(view), GTK_WIDGET(view->support), fake_x, -fake_y); } /****************************************************************************** * * * Paramètres : widget = composant GTK à redessiner. * * cr = contexte graphique associé à l'événement. * * view = support maître à consulter. * * * * Description : Met à jour l'affichage de la vue sous forme graphique. * * * * Retour : FALSE pour poursuivre la propagation de l'événement. * * * * Remarques : - * * * ******************************************************************************/ static gboolean gtk_graph_view_draw(GtkWidget *widget, cairo_t *cr, GtkGraphView *view) { if (view->layout != NULL) g_graph_layout_draw(view->layout, cr, true); return FALSE; } /****************************************************************************** * * * Paramètres : view = composant GTK à mettre à jour. * * * * Description : Actualise les besoins internes avant un redimensionnement. * * * * Retour : - * * * * Remarques : - * * * ******************************************************************************/ static void gtk_graph_view_prepare_resize(GtkGraphView *view) { size_t i; /* Boucle de parcours */ if (view->children_count > 0) { for (i = 0; i < view->children_count; i++) gtk_widget_queue_resize(GTK_WIDGET(view->children[i])); /* build_graph_view(view, g_binary_routine_get_basic_blocks(view->routine), view->children, view->children_count); */ g_graph_layout_refresh(view->layout); g_graph_layout_place(view->layout, view); change_editor_items_current_view_content(GTK_VIEW_PANEL(view)); } } /****************************************************************************** * * * Paramètres : view = composant GTK à mettre à jour. * * addr = adresse sélectionnée de manière externe. * * * * Description : Réagit à la sélection externe d'une adresse. * * * * Retour : - * * * * Remarques : - * * * ******************************************************************************/ static void gtk_graph_view_define_main_address(GtkGraphView *view, const vmpa2t *addr) { bool need_update; /* Mise à jour du contenu ? */ const mrange_t *range; /* Couverture courante */ GExeFormat *format; /* Type de fichier chargé */ GBinRoutine **routines; /* Liste des routines trouvées */ size_t routines_count; /* Nombre de ces routines */ size_t i; /* Boucle de parcours */ gint width; /* Largeur idéale du composant */ gint height; /* Hauteur idéale du composant */ if (view->routine == NULL) need_update = true; else { range = g_binary_routine_get_range(view->routine); need_update = !mrange_contains_addr(range, addr); } if (need_update) { gtk_graph_view_reset(view); format = g_loaded_binary_get_format(GTK_VIEW_PANEL(view)->binary); routines = g_binary_format_get_routines(G_BIN_FORMAT(format), &routines_count); for (i = 0; i < routines_count; i++) { range = g_binary_routine_get_range(routines[i]); if (mrange_contains_addr(range, addr)) { view->routine = routines[i]; g_object_ref(G_OBJECT(view->routine)); view->children = gtk_graph_view_load_nodes(view, GTK_VIEW_PANEL(view)->binary, routines[i]); view->allocs = (GtkAllocation *)calloc(view->children_count, sizeof(GtkAllocation)); /* build_graph_view(view, g_binary_routine_get_basic_blocks(view->routine), view->children, view->children_count); */ view->layout = g_graph_layout_new(g_binary_routine_get_basic_blocks(view->routine), view->children, view->children_count); g_graph_layout_place(view->layout, view); break; } } gtk_graph_view_compute_requested_size(view, &width, &height); gtk_widget_size_allocate(view->support, (GtkAllocation []){ { 0, 0, width, height } }); change_editor_items_current_view_content(GTK_VIEW_PANEL(view)); } } /****************************************************************************** * * * Paramètres : view = composant GTK à consulter. * * addr = adresse à présenter à l'écran. * * x = position horizontale au sein du composant. [OUT] * * y = position verticale au sein du composant. [OUT] * * tweak = adaptation finale à effectuer. * * * * Description : Indique la position d'affichage d'une adresse donnée. * * * * Retour : true si l'adresse fait partie du composant, false sinon. * * * * Remarques : - * * * ******************************************************************************/ static bool gtk_graph_view_get_address_coordinates(const GtkGraphView *view, const vmpa2t *addr, gint *x, gint *y, ScrollPositionTweak tweak) { /* TODO */ return false; } /****************************************************************************** * * * Paramètres : view = composant GTK à manipuler. * * cairo = assistant pour la création de rendus. * * area = taille de la surface réduite à disposition. * * scale = échelle vis à vis de la taille réelle. * * * * Description : Place en cache un rendu destiné à l'aperçu graphique rapide. * * * * Retour : - * * * * Remarques : - * * * ******************************************************************************/ static void gtk_graph_view_cache_glance(GtkGraphView *view, cairo_t *cairo, const GtkAllocation *area, double scale) { size_t i; /* Boucle de parcours */ GtkAllocation sub_area; /* Emplacement réservé */ for (i = 0; i < view->children_count; i++) { sub_area.x = view->allocs[i].x * scale; sub_area.y = view->allocs[i].y * scale; sub_area.width = view->allocs[i].width * scale + 1; sub_area.height = view->allocs[i].height * scale + 1; gtk_view_panel_cache_glance(view->children[i], cairo, &sub_area, scale); } cairo_scale(cairo, scale, scale); if (view->layout != NULL) g_graph_layout_draw(view->layout, cairo, false); } /****************************************************************************** * * * Paramètres : - * * * * Description : Crée un nouveau composant pour l'affichage en graphique. * * * * Retour : - * * * * Remarques : - * * * ******************************************************************************/ GtkWidget *gtk_graph_view_new(void) { return g_object_new(GTK_TYPE_GRAPH_VIEW, NULL); } /****************************************************************************** * * * Paramètres : view = composant GTK à mettre à jour. * * widget = composant GTK à insérer. * * x = abscisse du point d'insertion. * * y = ordonnée du point d'insertion. * * * * Description : Place une vue sous forme de bloc dans le graphique. * * * * Retour : Plutôt que de redéfinir *toutes* les méthodes de * * GtkContainer, on étend ! * * * * Remarques : - * * * ******************************************************************************/ void gtk_graph_view_put(GtkGraphView *view, GtkWidget *widget, const GtkAllocation *alloc) { size_t i; /* Boucle de parcours */ GtkWidget *parent; /* Parent en cas de réajustemt.*/ for (i = 0; i < view->children_count; i++) if (GTK_WIDGET(view->children[i]) == widget) { view->allocs[i] = *alloc; break; } parent = gtk_widget_get_parent(widget); if (parent != NULL) { g_object_ref(G_OBJECT(widget)); gtk_container_remove(GTK_CONTAINER(parent), widget); } gtk_fixed_put(view->support, widget, alloc->x, alloc->y); if (parent != NULL) g_object_unref(G_OBJECT(widget)); } /****************************************************************************** * * * Paramètres : view = composant GTK à mettre à jour. * * links = liens graphiques entre les blocs à intégrer. * * count = quantité de ces liens graphiques. * * * * Description : Définit les liens graphiques à présenter avec la vue. * * * * Retour : - * * * * Remarques : - * * * ******************************************************************************/ void gtk_graph_view_attach_links(GtkGraphView *view, GtkLinkRenderer **links, size_t count) { view->links = links; view->links_count = count; } /****************************************************************************** * * * Paramètres : view = instance GTK à réinitialiser. * * * * Description : Supprime tout contenu de l'afficheur de code en graphique. * * * * Retour : - * * * * Remarques : - * * * ******************************************************************************/ static void gtk_graph_view_reset(GtkGraphView *view) { size_t i; /* Boucle de parcours */ view->start = VMPA_MAX; view->end = VMPA_MAX; /* for (i = 0; i < view->links_count; i++) gtk_object_destroy(GTK_OBJECT(view->links[i])); if (view->links_count > 0) { free(view->links); view->links = NULL; view->links_count = 0; } */ for (i = 0; i < view->children_count; i++) gtk_widget_destroy(GTK_WIDGET(view->children[i])); if (view->children_count > 0) { free(view->children); view->children = NULL; free(view->allocs); view->allocs = NULL; view->children_count = 0; } } /****************************************************************************** * * * Paramètres : view = composant d'affichage GTK à mettre à jour. * * routine = routine à présenter via ledit composant. * * * * Description : Définit la liste complète des éléments du futur graphique. * * * * Retour : Liste d'éléments du graphique à placer. * * * * Remarques : - * * * ******************************************************************************/ static GtkViewPanel **gtk_graph_view_load_nodes(GtkGraphView *view, GLoadedBinary *binary, const GBinRoutine *routine) { GtkViewPanel **result; /* Liste à retourner */ GCodeBuffer *buffer; /* Tampon brut à découper */ size_t *count; /* Nombre d'éléments créés. */ GInstrBlock *main_block; /* Premier bloc rattaché */ GInstrBlock **blocks; /* Liste des blocs basiques */ size_t i; /* Boucle de parcours */ vmpa2t first; /* Début d'un groupe de lignes */ vmpa2t last; /* Fin d'un groupe de lignes */ GBufferView *subview; /* Partie affichée du tampon */ buffer = g_loaded_binary_get_disassembled_buffer(binary); count = &view->children_count; main_block = g_binary_routine_get_basic_blocks(routine); blocks = NULL; *count = 0; g_instr_block_list_all_blocks(main_block, &blocks, count); result = (GtkViewPanel **)calloc(*count, sizeof(GtkViewPanel *)); for (i = 0; i < *count; i++) { result[i] = GTK_VIEW_PANEL(gtk_block_view_new()); gtk_widget_show(GTK_WIDGET(result[i])); gtk_view_panel_attach_binary(result[i], binary, BVW_BLOCK); gtk_view_panel_show_border(result[i], true); g_flow_block_get_boundary_addresses(G_FLOW_BLOCK(blocks[i]), &first, &last); subview = g_buffer_view_new(buffer); g_buffer_view_restrict(subview, &first, &last); gtk_buffer_view_attach_buffer(GTK_BUFFER_VIEW(result[i]), subview); } return result; }