/* 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.
*
* 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 Foobar. If not, see .
*/
#include "gtkgraphview.h"
#include
#include "gtkblockview.h"
#include "gtkbufferview.h"
#include "gtkdisplaypanel-int.h"
#include "graph/cluster.h"
#include "../analysis/blocks/flow.h"
#include "../format/format.h"
#include "../gui/editem.h"
/* Composant d'affichage sous forme graphique (instance) */
struct _GtkGraphView
{
GtkDisplayPanel parent; /* A laisser en premier */
GtkWidget *support; /* Support des vues en bloc */
GtkWidget *extender; /* Force la taille du support */
GBinRoutine *routine; /* Routine en cours d'affichage*/
segcnt_list *highlighted; /* Segments mis en évidence */
GtkBufferView **children; /* Liste des sous-blocs */
GtkAllocation *allocs; /* Emplacements prévisibles */
size_t children_count; /* Taille de cette liste */
//GGraphLayout *layout; /* Disposition en graphique */
GGraphCluster *cluster; /* Disposition en graphique */
GGraphEdge **edges; /* Liens entre les noeuds */
size_t edges_count; /* Quantité de ces liens */
gdouble start_x; /* Abscisse du point de souris */
gdouble start_y; /* Ordonnée du point de souris */
bool big_enough; /* Capacités de déplacement ? */
gdouble ref_h; /* Position horizontale de ref.*/
gdouble ref_v; /* Position verticale de ref. */
};
/* Composant d'affichage sous forme graphique (classe) */
struct _GtkGraphViewClass
{
GtkDisplayPanelClass parent; /* A laisser en premier */
};
/* Profondeur de l'ombre */
#define SHADOW_SIZE 4
/* 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 *);
/* Supprime toutes les références externes. */
static void gtk_graph_view_dispose(GtkGraphView *);
/* Procède à la libération totale de la mémoire. */
static void gtk_graph_view_finalize(GtkGraphView *);
/* S'adapte à la surface concédée par le composant parent. */
static void gtk_graph_view_size_allocate(GtkWidget *, GtkAllocation *);
/* Centre si possible le contenu du panneau d'affichage. */
static void gtk_graph_view_update_support_margins(GtkGraphView *, const GtkAllocation *);
/* 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 *);
/* Assure la gestion des clics de souris sur le composant. */
static gboolean gtk_graph_view_button_press(GtkWidget *, GdkEventButton *, GtkGraphView *);
/* Assure la gestion des clics de souris sur le composant. */
static gboolean gtk_graph_view_button_release(GtkWidget *, GdkEventButton *, GtkGraphView *);
/* Assure la suivi des déplacements de souris sur le composant. */
static gboolean gtk_graph_view_motion_notify(GtkWidget *, GdkEventMotion *, 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 courante du curseur. */
static const vmpa2t *gtk_graph_view_get_caret_location(const GtkGraphView *);
/* 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);
/* Déplace le curseur à un emplacement défini. */
static bool gtk_graph_view_move_caret_to(GtkGraphView *, gint, gint);
/* 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. */
static GtkBufferView **gtk_graph_view_load_nodes(GtkGraphView *, GLoadedBinary *, const GBinRoutine *);
/* Notifie un changement de surbrillance au sein d'un noeud. */
static void gtk_graph_view_changed_highlights(GtkBlockView *, GtkGraphView *);
/* Notifie une incapacité de déplacement au sein d'un noeud. */
static void gtk_graph_view_reach_caret_limit(GtkBufferView *, GdkScrollDirection, GtkGraphView *);
/* Détermine le type du composant d'affichage en graphique. */
G_DEFINE_TYPE(GtkGraphView, gtk_graph_view, GTK_TYPE_DISPLAY_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)
{
GObjectClass *object; /* Autre version de la classe */
GtkWidgetClass *widget_class; /* Classe de haut niveau */
GtkDisplayPanelClass *panel_class; /* Classe parente */
object = G_OBJECT_CLASS(class);
object->dispose = (GObjectFinalizeFunc/* ! */)gtk_graph_view_dispose;
object->finalize = (GObjectFinalizeFunc)gtk_graph_view_finalize;
widget_class = GTK_WIDGET_CLASS(class);
widget_class->size_allocate = gtk_graph_view_size_allocate;
panel_class = GTK_DISPLAY_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_caret_loc = (get_caret_location_fc)gtk_graph_view_get_caret_location;
panel_class->get_coordinates = (get_addr_coordinates_fc)gtk_graph_view_get_address_coordinates;
panel_class->move_caret_to = (move_caret_to_fc)gtk_graph_view_move_caret_to;
panel_class->cache_glance = (cache_glance_fc)gtk_graph_view_cache_glance;
}
/******************************************************************************
* *
* 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)
{
GtkDisplayPanel *panel; /* Instance parente #1 */
//GtkBinView *binview; /* Instance parente #2 */
panel = GTK_DISPLAY_PANEL(view);
panel->resize = (prepare_resize_fc)gtk_graph_view_prepare_resize;
////////viewpanel->get_coordinates = (get_addr_coordinates_fc)gtk_graph_view_get_address_coordinates;
//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_new();
gtk_widget_set_has_window(view->support, TRUE);
gtk_widget_set_can_focus(view->support, TRUE);
g_signal_connect(G_OBJECT(view->support), "draw",
G_CALLBACK(gtk_graph_view_draw), view);
g_signal_connect(G_OBJECT(view->support), "button-press-event",
G_CALLBACK(gtk_graph_view_button_press), view);
g_signal_connect(G_OBJECT(view->support), "button-release-event",
G_CALLBACK(gtk_graph_view_button_release), view);
g_signal_connect(G_OBJECT(view->support), "motion-notify-event",
G_CALLBACK(gtk_graph_view_motion_notify), view);
gtk_widget_add_events(view->support,
GDK_BUTTON_MOTION_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK);
gtk_widget_show(view->support);
gtk_fixed_put(GTK_FIXED(view), view->support, 0, 0);
//view->mutex = g_mutex_new();
//view->cond = g_cond_new();
view->extender = gtk_fixed_new();
gtk_widget_set_margin_end(view->extender, 1);
gtk_widget_set_margin_top(view->extender, 1);
gtk_widget_show(view->extender);
view->cluster = NULL;
}
/******************************************************************************
* *
* Paramètres : view = instance d'objet GLib à traiter. *
* *
* Description : Supprime toutes les références externes. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
static void gtk_graph_view_dispose(GtkGraphView *view)
{
g_object_unref(G_OBJECT(view->extender));
if (view->cluster != NULL)
{
g_object_unref(G_OBJECT(view->cluster));
view->cluster = NULL;
}
G_OBJECT_CLASS(gtk_graph_view_parent_class)->dispose(G_OBJECT(view));
}
/******************************************************************************
* *
* Paramètres : view = instance d'objet GLib à traiter. *
* *
* Description : Procède à la libération totale de la mémoire. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
static void gtk_graph_view_finalize(GtkGraphView *view)
{
G_OBJECT_CLASS(gtk_graph_view_parent_class)->finalize(G_OBJECT(view));
}
/******************************************************************************
* *
* Paramètres : widget = composant GTK à mettre à jour. *
* allocation = étendue accordée à la vue. *
* *
* Description : S'adapte à la surface concédée par le composant parent. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
static void gtk_graph_view_size_allocate(GtkWidget *widget, GtkAllocation *allocation)
{
GtkGraphView *view; /* Autre version du composant */
GTK_WIDGET_CLASS(gtk_graph_view_parent_class)->size_allocate(widget, allocation);
view = GTK_GRAPH_VIEW(widget);
gtk_graph_view_update_support_margins(view, allocation);
}
/******************************************************************************
* *
* Paramètres : view = panneau dont le contenu est à déplacer. *
* allocation = étendue accordée à la vue. *
* *
* Description : Centre si possible le contenu du panneau d'affichage. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
static void gtk_graph_view_update_support_margins(GtkGraphView *view, const GtkAllocation *allocation)
{
gint width; /* Largeur totale du support */
gint height; /* Hauteur totale du support */
gint start; /* Bordure horizontale */
gint top; /* Bordure verticale */
gtk_graph_view_compute_requested_size(view, &width, &height);
if (width > allocation->width)
start = 0;
else
start = (allocation->width - width) / 2;
if (height > allocation->height)
top = 0;
else
top = (allocation->height - height) / 2;
gtk_widget_set_margin_start(view->support, start);
gtk_widget_set_margin_top(view->support, top);
}
/******************************************************************************
* *
* 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)
{
GtkAllocation needed; /* Taille requise */
gint rwidth; /* Largeur demandée */
gint rheight; /* Hauteur demandée */
if (view->cluster != NULL)
{
g_graph_cluster_compute_needed_alloc(view->cluster, &needed);
assert(needed.x == 0 && needed.y == 0);
/* TODO : marges ou centrage */
}
else
{
needed.width = 0;
needed.height = 0;
}
if (width != NULL) *width = needed.width + SHADOW_SIZE;
if (height != NULL) *height = needed.height + SHADOW_SIZE;
}
/******************************************************************************
* *
* 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_display_panel_compute_fake_coord(GTK_DISPLAY_PANEL(view), &fake_x, &fake_y);
gtk_fixed_move(GTK_FIXED(view), 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)
{
size_t i; /* Boucle de parcours */
void draw_shadow(GtkWidget *child, gpointer unused)
{
GtkAllocation alloc; /* Emplacement de l'enfant */
gint j; /* Boucle de parcours */
cairo_pattern_t *pattern; /* Zones d'application */
gtk_widget_get_allocation(child, &alloc);
for (j = 1; j < SHADOW_SIZE; j++)
{
cairo_push_group(cr);
gtk_display_panel_define_border_path(GTK_DISPLAY_PANEL(child), cr, alloc.x + j, alloc.y + j);
cairo_set_source_rgba(cr, 0.0, 0.0, 0.0, 1.0);
cairo_fill(cr);
cairo_set_operator(cr, CAIRO_OPERATOR_SOURCE);
gtk_display_panel_define_border_path(GTK_DISPLAY_PANEL(child), cr, alloc.x, alloc.y);
cairo_set_source_rgba(cr, 0.0, 0.0, 0.0, 0.0);
cairo_fill(cr);
pattern = cairo_pop_group(cr);
cairo_set_source_rgba(cr, 0.0, 0.0, 0.0, 0.3);
cairo_mask(cr, pattern);
cairo_fill(cr);
cairo_pattern_destroy(pattern);
}
}
gtk_container_foreach(GTK_CONTAINER(view->support), (GtkCallback)draw_shadow, NULL);
for (i = 0; i < view->edges_count; i++)
g_graph_edge_draw(view->edges[i], cr, true);
/*
if (view->layout != NULL)
g_graph_layout_draw(view->layout, cr, true);
*/
return FALSE;
}
/******************************************************************************
* *
* Paramètres : widget = composant GTK visé par l'opération. *
* event = informations liées à l'événement. *
* view = support maître à consulter. *
* *
* Description : Assure la gestion des clics de souris sur le composant. *
* *
* Retour : FALSE pour poursuivre la propagation de l'événement. *
* *
* Remarques : - *
* *
******************************************************************************/
static gboolean gtk_graph_view_button_press(GtkWidget *widget, GdkEventButton *event, GtkGraphView *view)
{
gboolean result; /* Poursuite à faire suivre */
GtkScrolledWindow *support; /* Support défilant associé */
GtkAdjustment *hadj; /* Gestionnaire du défilement */
GtkAdjustment *vadj; /* Gestionnaire du défilement */
GdkCursor *cursor; /* Pointeur pour la surface */
result = FALSE;
if (event->button == 1)
{
support = GTK_SCROLLED_WINDOW(gtk_widget_get_parent(GTK_WIDGET(view)));
hadj = gtk_scrolled_window_get_hadjustment(support);
vadj = gtk_scrolled_window_get_vadjustment(support);
view->big_enough = (gtk_adjustment_get_upper(hadj) > gtk_adjustment_get_page_size(hadj)
|| gtk_adjustment_get_upper(vadj) > gtk_adjustment_get_page_size(vadj));
if (view->big_enough)
{
view->start_x = event->x_root;
view->start_y = event->y_root;
view->ref_h = gtk_adjustment_get_value(hadj);
view->ref_v = gtk_adjustment_get_value(vadj);
cursor = gdk_cursor_new(GDK_FLEUR);
gdk_window_set_cursor(gtk_widget_get_window(widget), cursor);
g_object_unref(G_OBJECT(cursor));
result = TRUE;
}
}
return result;
}
/******************************************************************************
* *
* Paramètres : widget = composant GTK visé par l'opération. *
* event = informations liées à l'événement. *
* view = support maître à consulter. *
* *
* Description : Assure la gestion des clics de souris sur le composant. *
* *
* Retour : FALSE pour poursuivre la propagation de l'événement. *
* *
* Remarques : - *
* *
******************************************************************************/
static gboolean gtk_graph_view_button_release(GtkWidget *widget, GdkEventButton *event, GtkGraphView *view)
{
if (event->button == 1 && view->big_enough)
gdk_window_set_cursor(gtk_widget_get_window(widget), NULL);
return FALSE;
}
/******************************************************************************
* *
* Paramètres : widget = composant GTK visé par l'opération. *
* event = informations liées à l'événement. *
* view = support maître à consulter. *
* *
* Description : Assure la suivi des déplacements de souris sur le composant. *
* *
* Retour : FALSE pour poursuivre la propagation de l'événement. *
* *
* Remarques : - *
* *
******************************************************************************/
static gboolean gtk_graph_view_motion_notify(GtkWidget *widget, GdkEventMotion *event, GtkGraphView *view)
{
gdouble diff_x; /* Evolution sur les abscisses */
gdouble diff_y; /* Evolution sur les ordonnées */
GtkScrolledWindow *support; /* Support défilant associé */
GtkAdjustment *hadj; /* Gestionnaire du défilement */
GtkAdjustment *vadj; /* Gestionnaire du défilement */
gdouble value; /* Nouvelle valeur bornée */
if (event->state & GDK_BUTTON1_MASK && view->big_enough)
{
diff_x = view->start_x - event->x_root;
diff_y = view->start_y - event->y_root;
support = GTK_SCROLLED_WINDOW(gtk_widget_get_parent(GTK_WIDGET(view)));
hadj = gtk_scrolled_window_get_hadjustment(support);
vadj = gtk_scrolled_window_get_vadjustment(support);
value = CLAMP(view->ref_h + diff_x, gtk_adjustment_get_lower(hadj),
gtk_adjustment_get_upper(hadj) - gtk_adjustment_get_page_size(hadj));
gtk_adjustment_set_value(hadj, value);
value = CLAMP(view->ref_v + diff_y, gtk_adjustment_get_lower(vadj),
gtk_adjustment_get_upper(vadj) - gtk_adjustment_get_page_size(vadj));
gtk_adjustment_set_value(vadj, value);
}
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]));
/*
g_graph_layout_refresh(view->layout);
g_graph_layout_place(view->layout, view);
*/
change_editor_items_current_view_content(GTK_DISPLAY_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 right; /* Abscisse du coin droit */
gint bottom; /* Ordonnée du coin inférieur */
GtkAllocation allocation; /* Espace alloué au panneau */
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_DISPLAY_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->highlighted = init_segment_content_list();
/*
view->children = gtk_graph_view_load_nodes(view, GTK_DISPLAY_PANEL(view)->binary,
routines[i]);
view->allocs = (GtkAllocation *)calloc(view->children_count,
sizeof(GtkAllocation));
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);
*/
do
{
GBlockList *list;
list = g_binary_routine_get_basic_blocks(routines[i]);
#if 0
view->cluster = g_graph_cluster_new(GTK_DISPLAY_PANEL(view)->binary,
list, 0/* FIXME */, view->highlighted);
#endif
view->cluster = bootstrap_graph_cluster(GTK_DISPLAY_PANEL(view)->binary,
list, view->highlighted);
g_graph_cluster_place(view->cluster, view);
/**
* Comme la taille du support ne peut pas être forcée et
* étendue pour comprendre les ombres, on place un composant
* minuscule à l'extrémité de ce support.
*/
gtk_graph_view_compute_requested_size(view, &right, &bottom);
g_object_ref(G_OBJECT(view->extender));
gtk_fixed_put(GTK_FIXED(view->support), view->extender, right, bottom);
/**
* Si possible, on centre le contenu obtenu.
*/
gtk_widget_get_allocation(GTK_WIDGET(view), &allocation);
gtk_graph_view_update_support_margins(view, &allocation);
}
while (0);
break;
}
}
change_editor_items_current_view_content(GTK_DISPLAY_PANEL(view));
g_object_unref(G_OBJECT(format));
}
}
/******************************************************************************
* *
* Paramètres : view = composant GTK à manipuler. *
* *
* Description : Indique la position courante du curseur. *
* *
* Retour : Emplacement courant du curseur ou NULL si aucun. *
* *
* Remarques : - *
* *
******************************************************************************/
static const vmpa2t *gtk_graph_view_get_caret_location(const GtkGraphView *view)
{
return NULL; /* FIXME */
}
/******************************************************************************
* *
* 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. *
* x = abscisse proposée pour le nouvel emplacement. *
* y = ordonnée proposée pour le nouvel emplacement. *
* *
* Description : Déplace le curseur à un emplacement défini. *
* *
* Retour : true si un traitement a été effectué, false sinon. *
* *
* Remarques : - *
* *
******************************************************************************/
static bool gtk_graph_view_move_caret_to(GtkGraphView *view, gint x, gint y)
{
bool result; /* Bilan à retourner */
size_t i; /* Boucle de parcours */
GtkDisplayPanel *panel; /* Autre vision d'enfance */
gint sub_x; /* Abscisse relative à l'enfant*/
gint sub_y; /* Ordonnée relative à l'enfant*/
result = false;
for (i = 0; i < view->children_count; i++)
{
if (x < view->allocs[i].x || x >= (view->allocs[i].x + view->allocs[i].width)) continue;
if (y < view->allocs[i].y || y >= (view->allocs[i].y + view->allocs[i].height)) continue;
panel = GTK_DISPLAY_PANEL(view->children[i]);
sub_x = x - view->allocs[i].x;
sub_y = y - view->allocs[i].y;
result = GTK_DISPLAY_PANEL_GET_CLASS(panel)->move_caret_to(panel, sub_x, sub_y);
break;
}
return result;
}
/******************************************************************************
* *
* 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_display_panel_cache_glance(GTK_DISPLAY_PANEL(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(GTK_FIXED(view->support), widget, alloc->x, alloc->y);
/*
if (parent != NULL)
g_object_unref(G_OBJECT(widget));
*/
}
/******************************************************************************
* *
* Paramètres : view = composant GTK à mettre à jour. *
* edge = lien entre noeuds à conserver. *
* *
* Description : Intègre un lien entre blocs graphiques dans l'afficheur. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
void gtk_graph_view_add_edge(GtkGraphView *view, GGraphEdge *edge)
{
view->edges = (GGraphEdge **)realloc(view->edges,
++view->edges_count * sizeof(GGraphEdge *));
view->edges[view->edges_count - 1] = edge;
}
/******************************************************************************
* *
* 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 */
void detach_all_blocks(GtkWidget *widget, GtkContainer *container)
{
gtk_container_remove(container, widget);
}
gtk_container_foreach(GTK_CONTAINER(view->support), (GtkCallback)detach_all_blocks, view->support);
if (view->cluster != NULL)
{
g_object_unref(G_OBJECT(view->cluster));
view->cluster = NULL;
}
for (i = 0; i < view->edges_count; i++)
g_object_unref(G_OBJECT(view->edges[i]));
if (view->edges_count > 0)
{
free(view->edges);
view->edges = NULL;
view->edges_count = 0;
}
/*
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;
}
*/
if (view->highlighted)
exit_segment_content_list(view->highlighted);
for (i = 0; i < view->children_count; i++)
{
g_signal_handlers_disconnect_by_func(view->children[i], gtk_graph_view_reach_caret_limit, view);
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 GtkBufferView **gtk_graph_view_load_nodes(GtkGraphView *view, GLoadedBinary *binary, const GBinRoutine *routine)
{
GtkBufferView **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 = (GtkBufferView **)calloc(*count, sizeof(GtkBufferView *));
for (i = 0; i < *count; i++)
{
result[i] = GTK_BUFFER_VIEW(gtk_block_view_new());
g_signal_connect(result[i], "reach-limit", G_CALLBACK(gtk_graph_view_reach_caret_limit), view);
g_signal_connect(result[i], "highlight-changed", G_CALLBACK(gtk_graph_view_changed_highlights), view);
gtk_widget_show(GTK_WIDGET(result[i]));
gtk_display_panel_attach_binary(GTK_DISPLAY_PANEL(result[i]), binary, BVW_GRAPH);
gtk_display_panel_show_border(GTK_DISPLAY_PANEL(result[i]), true);
g_flow_block_get_boundary_addresses(G_FLOW_BLOCK(blocks[i]), &first, &last);
subview = g_buffer_view_new(buffer, view->highlighted);
g_buffer_view_restrict(subview, &first, &last);
gtk_buffer_view_attach_buffer(result[i], subview);
}
return result;
}
/******************************************************************************
* *
* Paramètres : node = composant d'affichage GTK impliqué dans la procédure. *
* view = support graphique de tous les noeuds. *
* *
* Description : Notifie un changement de surbrillance au sein d'un noeud. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
static void gtk_graph_view_changed_highlights(GtkBlockView *node, GtkGraphView *view)
{
size_t i; /* Boucle de parcours */
for (i = 0; i < view->children_count; i++)
{
if (view->children[i] == GTK_BUFFER_VIEW(node))
continue;
gtk_widget_queue_draw(GTK_WIDGET(view->children[i]));
}
}
/******************************************************************************
* *
* Paramètres : node = composant d'affichage GTK impliqué dans la procédure. *
* dir = direction du déplacement souhaité et impossible. *
* view = support graphique de tous les noeuds. *
* *
* Description : Notifie une incapacité de déplacement au sein d'un noeud. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
static void gtk_graph_view_reach_caret_limit(GtkBufferView *node, GdkScrollDirection dir, GtkGraphView *view)
{
GBufferView *bview; /* Vue d'un tampon global */
vmpa2t first; /* Début d'un groupe de lignes */
vmpa2t last; /* Fin d'un groupe de lignes */
const mrange_t *range; /* Couverture courante */
GArchProcessor *proc; /* Processeur pour instructions*/
vmpa2t iaddr; /* Adresse du prochain saut */
instr_iter_t *iter; /* Boucle de parcours */
GArchInstruction *instr; /* Instruction à venir visiter */
#ifndef NDEBUG
bool is_return; /* Est-ce une instruc. finale ?*/
#endif
size_t i; /* Boucle de parcours */
bool updated; /* Besoin d'une mise à jour ? */
/* Détermination de l'instruction à cibler */
bview = gtk_buffer_view_get_buffer(node);
g_buffer_view_get_restrictions(bview, &first, &last);
range = g_binary_routine_get_range(view->routine);
proc = g_loaded_binary_get_processor(GTK_DISPLAY_PANEL(view)->binary);
init_vmpa(&iaddr, VMPA_NO_PHYSICAL, VMPA_NO_VIRTUAL);
#ifndef NDEBUG
is_return = false;
#endif
switch (dir)
{
case GDK_SCROLL_LEFT:
case GDK_SCROLL_UP:
if (cmp_vmpa(get_mrange_addr(range), &first) != 0)
{
iter = g_arch_processor_get_iter_from_address(proc, &first);
if (iter != NULL)
{
instr = get_instruction_iterator_prev(iter);
if (instr != NULL)
{
/* TODO : boucler si !HAS_CODE */
if (mrange_contains_addr(range, &iaddr))
copy_vmpa(&iaddr, get_mrange_addr(g_arch_instruction_get_range(instr)));
g_object_unref(G_OBJECT(instr));
}
delete_instruction_iterator(iter);
}
}
break;
case GDK_SCROLL_RIGHT:
case GDK_SCROLL_DOWN:
iter = g_arch_processor_get_iter_from_address(proc, &last);
if (iter != NULL)
{
#ifndef NDEBUG
instr = get_instruction_iterator_current(iter);
if (instr != NULL)
{
is_return = (g_arch_instruction_get_flags(instr) & AIF_RETURN_POINT);
g_object_unref(G_OBJECT(instr));
}
#endif
instr = get_instruction_iterator_next(iter);
if (instr != NULL)
{
/* TODO : boucler si !HAS_CODE */
copy_vmpa(&iaddr, get_mrange_addr(g_arch_instruction_get_range(instr)));
if (!mrange_contains_addr(range, &iaddr))
init_vmpa(&iaddr, VMPA_NO_PHYSICAL, VMPA_NO_VIRTUAL);
g_object_unref(G_OBJECT(instr));
}
delete_instruction_iterator(iter);
}
break;
case GDK_SCROLL_SMOOTH:
assert(0); /* Argument jamais généré */
break;
}
g_object_unref(G_OBJECT(proc));
/* Recherche du bloc parent */
/* FIXME : valid ! */
if (iaddr.physical == VMPA_NO_PHYSICAL && iaddr.virtual == VMPA_NO_VIRTUAL)
return;
for (i = 0; i < view->children_count; i++)
{
bview = gtk_buffer_view_get_buffer(view->children[i]);
g_buffer_view_get_restrictions(bview, &first, &last);
if (cmp_vmpa(&first, &iaddr) <= 0 && cmp_vmpa(&iaddr, &last) <= 0)
{
assert(node != view->children[i]);
break;
}
}
assert(i < view->children_count || is_return);
/* Affichage du nouveau curseur */
/**
* Il se peut qu'aucune adresse suivante ne soit disponible : c'est typiquement
* le cas sous ARM, avec les valeurs brutes référencées dans le code. Ces valeurs
* sont incluses dans la surface couverte par la routine concernée, mais ne sont
* pas intégrées dans les blocs basiques associés.
*/
if (i == view->children_count)
return;
gtk_widget_grab_focus(GTK_WIDGET(view->children[i]));
switch (dir)
{
case GDK_SCROLL_LEFT:
updated = gtk_buffer_view_move_caret_to(view->children[i], false, NULL);
break;
case GDK_SCROLL_UP:
break;
case GDK_SCROLL_RIGHT:
updated = gtk_buffer_view_move_caret_to(view->children[i], true, NULL);
break;
case GDK_SCROLL_DOWN:
break;
case GDK_SCROLL_SMOOTH:
assert(0); /* Argument jamais généré */
break;
}
/* TODO : scrolling... */
}