summaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/graph/dot.c6
-rw-r--r--src/graph/dot.h2
-rw-r--r--src/graph/layout.c2
-rw-r--r--src/graph/node.c12
-rw-r--r--src/graph/node.h6
-rw-r--r--src/gtkext/gtkbinview-int.h17
-rw-r--r--src/gtkext/gtkbinview.c143
-rw-r--r--src/gtkext/gtkblockview.c260
-rw-r--r--src/gtkext/gtkgraphview.c183
-rw-r--r--src/gtkext/gtkgraphview.h3
10 files changed, 541 insertions, 93 deletions
diff --git a/src/graph/dot.c b/src/graph/dot.c
index 9f8e3b3..27e60bc 100644
--- a/src/graph/dot.c
+++ b/src/graph/dot.c
@@ -132,7 +132,7 @@ void delete_graph_layout(graph_layout *layout)
/******************************************************************************
* *
* Paramètres : layout = graphique à supprimer de la mémoire. *
-* fixed = support de destination. *
+* view = support de destination. *
* nodes = liste de noeuds à traiter. *
* count = taille de la liste. *
* *
@@ -144,7 +144,7 @@ void delete_graph_layout(graph_layout *layout)
* *
******************************************************************************/
-void place_nodes_of_graph_layout(const graph_layout *layout, GtkFixed *fixed, GGraphNode **nodes, size_t count)
+void place_nodes_of_graph_layout(const graph_layout *layout, GtkGraphView *view, GGraphNode **nodes, size_t count)
{
int height; /* Hauteur du graphique */
node_t *iter; /* Boucle de parcours */
@@ -158,7 +158,7 @@ void place_nodes_of_graph_layout(const graph_layout *layout, GtkFixed *fixed, GG
printf(" pos :: (%d ; %d)\n", iter->u.coord.x, height - iter->u.coord.y);
node = find_graph_node_by_name(nodes, count, iter->name);
- g_graph_node_place(node, fixed, iter->u.coord.x, height - iter->u.coord.y);
+ g_graph_node_place(node, view, iter->u.coord.x, height - iter->u.coord.y);
}
}
diff --git a/src/graph/dot.h b/src/graph/dot.h
index 630c1cb..47550a8 100644
--- a/src/graph/dot.h
+++ b/src/graph/dot.h
@@ -41,7 +41,7 @@ graph_layout *create_graph_layout(char *);
void delete_graph_layout(graph_layout *);
/* Place tous les éléments du graphique à l'écran. */
-void place_nodes_of_graph_layout(const graph_layout *, GtkFixed *, GGraphNode **, size_t);
+void place_nodes_of_graph_layout(const graph_layout *, GtkGraphView *, GGraphNode **, size_t);
/* Charge la définition de tous les liens graphiques. */
GtkLinkRenderer **create_links_from_graph_layout(const graph_layout *, size_t *);
diff --git a/src/graph/layout.c b/src/graph/layout.c
index 0b4a6c6..667074b 100644
--- a/src/graph/layout.c
+++ b/src/graph/layout.c
@@ -92,7 +92,7 @@ bool build_graph_view(GtkGraphView *view, GtkBinView **views, size_t count)
/* Affichage du graphique */
- place_nodes_of_graph_layout(layout, GTK_FIXED(view), nodes, count);
+ place_nodes_of_graph_layout(layout, view, nodes, count);
links = create_links_from_graph_layout(layout, &links_count);
gtk_graph_view_attach_links(view, links, links_count);
diff --git a/src/graph/node.c b/src/graph/node.c
index e6427d8..09cfe30 100644
--- a/src/graph/node.c
+++ b/src/graph/node.c
@@ -223,10 +223,10 @@ char *g_graph_node_register_for_dot(const GGraphNode *node, char *cmds)
/******************************************************************************
* *
-* Paramètres : node = intermédiaire à consulter. *
-* fixed = support de destination. *
-* x = abscisse du point d'intégration. *
-* y = ordonnée du point d'intégration. *
+* Paramètres : node = intermédiaire à consulter. *
+* view = support de destination. *
+* x = abscisse du point d'intégration. *
+* y = ordonnée du point d'intégration. *
* *
* Description : Place le morceau de code de l'intermédiaire à l'écran. *
* *
@@ -236,7 +236,7 @@ char *g_graph_node_register_for_dot(const GGraphNode *node, char *cmds)
* *
******************************************************************************/
-void g_graph_node_place(const GGraphNode *node, GtkFixed *fixed, gint x, gint y)
+void g_graph_node_place(const GGraphNode *node, GtkGraphView *view, gint x, gint y)
{
GtkRequisition requisition; /* Taille à l'écran actuelle */
@@ -245,7 +245,7 @@ void g_graph_node_place(const GGraphNode *node, GtkFixed *fixed, gint x, gint y)
x -= requisition.width / 2;
y -= requisition.height / 2;
- gtk_fixed_put(fixed, GTK_WIDGET(node->view), x, y);
+ gtk_graph_view_put(view, GTK_WIDGET(node->view), x, y);
}
diff --git a/src/graph/node.h b/src/graph/node.h
index 456e236..4998553 100644
--- a/src/graph/node.h
+++ b/src/graph/node.h
@@ -25,10 +25,8 @@
#define _GRAPH_NODE_H
-#include <gtk/gtkfixed.h>
-
-
#include "../gtkext/gtkbinview.h"
+#include "../gtkext/gtkgraphview.h"
@@ -59,7 +57,7 @@ GGraphNode *g_graph_node_new(GtkBinView *);
char *g_graph_node_register_for_dot(const GGraphNode *, char *);
/* Place le morceau de code de l'intermédiaire à l'écran. */
-void g_graph_node_place(const GGraphNode *, GtkFixed *, gint , gint);
+void g_graph_node_place(const GGraphNode *, GtkGraphView *, gint , gint);
diff --git a/src/gtkext/gtkbinview-int.h b/src/gtkext/gtkbinview-int.h
index e785bab..ab72a84 100644
--- a/src/gtkext/gtkbinview-int.h
+++ b/src/gtkext/gtkbinview-int.h
@@ -33,6 +33,9 @@
+/* Réagit à un défilement quelconque. */
+typedef void (* scroll_fc) (GtkBinView *);
+
/* Définit les lignes à associer à la représentation. */
typedef void (* set_rendering_lines_fc) (GtkBinView *, GRenderingLine *, GRenderingLine *);
@@ -47,6 +50,9 @@ struct _GtkBinView
{
GtkFixed parent; /* A laisser en premier */
+ GtkAdjustment *hadjustment; /* Barre de défilement horiz. */
+ GtkAdjustment *vadjustment; /* Barre de défilement vert. */
+
GdkGC *gc; /* Contexte graphique du rendu */
bool show_border; /* Affichage d'une bordure ? */
@@ -56,6 +62,7 @@ struct _GtkBinView
GRenderingLine *lines; /* Contenu à représenter */
GRenderingLine *last; /* Dernière ligne associée */
+ scroll_fc scroll; /* Défilement du contenu */
set_rendering_lines_fc set_lines; /* Association des lignes */
define_main_address_fc define_address; /* Sélection externe d'adresse */
get_addr_coordinates_fc get_coordinates;/* Conversion adresse <-> pos. */
@@ -68,10 +75,20 @@ struct _GtkBinViewClass
/* Signaux */
+ void (* set_scroll_adjustments) (GtkBinView *, GtkAdjustment *, GtkAdjustment *);
+
void (* lines_set) (GtkBinView *);
};
+/* Calcule la surface pleine utilisable pour la vue. */
+void gtk_bin_view_compute_allocation(GtkBinView *, GtkAllocation *);
+
+/* S'assure que la valeur de défilement actuelle est valable. */
+void gtk_bin_view_reclamp_adjustment(GtkAdjustment *, gboolean *);
+
+
+
#endif /* _GTKEXT_GTKBINVIEW_INT_H */
diff --git a/src/gtkext/gtkbinview.c b/src/gtkext/gtkbinview.c
index 147a59c..0a9ce6e 100644
--- a/src/gtkext/gtkbinview.c
+++ b/src/gtkext/gtkbinview.c
@@ -25,9 +25,12 @@
#include "gtkbinview-int.h"
+#include "iodamarshal.h"
+/* Enregistrement les défilements à associer au composant GTK. */
+static void gtk_binview_set_scroll_adjustments(GtkBinView *, GtkAdjustment *, GtkAdjustment *);
/* Encadre la construction graphique initiale de la visualisation. */
static void gtk_bin_view_realize(GtkWidget *);
@@ -35,6 +38,8 @@ static void gtk_bin_view_realize(GtkWidget *);
/* Met à jour l'affichage de la visualisation de code binaire. */
static gboolean gtk_bin_view_expose(GtkBinView *, GdkEventExpose *);
+/* Prend acte d'un nouveau défilement. */
+static void gtk_bin_view_adj_value_changed(GtkAdjustment *, GtkBinView *);
@@ -68,6 +73,19 @@ static void gtk_binview_class_init(GtkBinViewClass *class)
widget_class->realize = gtk_bin_view_realize;
widget_class->expose_event = gtk_bin_view_expose;
+ class->set_scroll_adjustments = gtk_binview_set_scroll_adjustments;
+
+ widget_class->set_scroll_adjustments_signal =
+ g_signal_new(("set_scroll_adjustments"),
+ GTK_TYPE_BIN_VIEW,
+ G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
+ G_STRUCT_OFFSET(GtkBinViewClass, set_scroll_adjustments),
+ NULL, NULL,
+ g_cclosure_user_marshal_VOID__OBJECT_OBJECT,
+ G_TYPE_NONE, 2,
+ GTK_TYPE_ADJUSTMENT,
+ GTK_TYPE_ADJUSTMENT);
+
g_signal_new("lines-set",
GTK_TYPE_BIN_VIEW,
G_SIGNAL_RUN_LAST,
@@ -81,6 +99,34 @@ static void gtk_binview_class_init(GtkBinViewClass *class)
/******************************************************************************
* *
+* Paramètres : view = vue à compléter. *
+* hadjustment = nouveau défilement horizontal à intégrer. *
+* vadjustment = nouveau défilement vertical à intégrer. *
+* *
+* Description : Enregistrement les défilements à associer au composant GTK. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void gtk_binview_set_scroll_adjustments(GtkBinView *view, GtkAdjustment *hadjustment, GtkAdjustment *vadjustment)
+{
+ view->hadjustment = hadjustment;
+ view->vadjustment = vadjustment;
+
+ g_signal_connect(hadjustment, "value_changed",
+ G_CALLBACK(gtk_bin_view_adj_value_changed), view);
+
+ g_signal_connect(vadjustment, "value_changed",
+ G_CALLBACK(gtk_bin_view_adj_value_changed), view);
+
+}
+
+
+/******************************************************************************
+* *
* Paramètres : view = composant GTK à initialiser. *
* *
* Description : Procède à l'initialisation de l'afficheur de morceaux. *
@@ -205,6 +251,96 @@ static gboolean gtk_bin_view_expose(GtkBinView *view, GdkEventExpose *event)
}
+/******************************************************************************
+* *
+* Paramètres : view = composant GTK à consulter. *
+* alloc = étendue à accorder à la vue. *
+* *
+* Description : Calcule la surface pleine utilisable pour la vue. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+void gtk_bin_view_compute_allocation(GtkBinView *view, GtkAllocation *alloc)
+{
+ GtkWidget *widget; /* Autre version de la vue */
+ GtkAllocation *allocation; /* Raccourci d'utilisation #1 */
+ gint border_width; /* Raccourci d'utilisation #2 */
+
+ widget = GTK_WIDGET(view);
+ allocation = &widget->allocation;
+ border_width = GTK_CONTAINER(view)->border_width;
+
+ alloc->x = 0;
+ alloc->y = 0;
+
+ /*
+ if (viewport->shadow_type != GTK_SHADOW_NONE)
+ {
+ alloc->x = widget->style->xthickness;
+ alloc->y = widget->style->ythickness;
+ }
+ */
+
+ alloc->width = MAX(1, allocation->width - alloc->x * 2 - border_width * 2);
+ alloc->height = MAX(1, allocation->height - alloc->y * 2 - border_width * 2);
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : adj = valeurs de défilement à consulter. *
+* changed = note une mise à jour de valeur. [OUT] *
+* *
+* Description : S'assure que la valeur de défilement actuelle est valable. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+void gtk_bin_view_reclamp_adjustment(GtkAdjustment *adj, gboolean *changed)
+{
+ gdouble value; /* Valeur actuelle */
+
+ value = adj->value;
+
+ value = CLAMP(value, 0, adj->upper - adj->page_size);
+
+ if (value != adj->value)
+ {
+ adj->value = value;
+ *changed = TRUE;
+ }
+ else *changed = FALSE;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : adj = défilement à l'origine de l'action. *
+* view = composant GTK à redessiner. *
+* *
+* Description : Prend acte d'un nouveau défilement. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void gtk_bin_view_adj_value_changed(GtkAdjustment *adj, GtkBinView *view)
+{
+ view->scroll(view);
+
+}
+
/******************************************************************************
* *
@@ -432,7 +568,6 @@ void gtk_bin_view_scroll_to_address(GtkBinView *view, vmpa_t addr)
{
gint x; /* Abscisse à garantir */
gint y; /* Ordonnée à garantir */
- GtkViewport *support; /* Support avec défilements */
GtkAdjustment *adj; /* Défilement à mettre à jour */
if (view->define_address != NULL)
@@ -440,16 +575,14 @@ void gtk_bin_view_scroll_to_address(GtkBinView *view, vmpa_t addr)
if (view->get_coordinates(view, addr, &x, &y))
{
- support = GTK_VIEWPORT(gtk_widget_get_parent(GTK_WIDGET(view)));
-
- adj = gtk_viewport_get_hadjustment(support);
+ adj = view->hadjustment;
if (x > (adj->upper - adj->page_size))
x = adj->upper - adj->page_size;
gtk_adjustment_set_value(adj, x);
- adj = gtk_viewport_get_vadjustment(support);
+ adj = view->vadjustment;
if (y > (adj->upper - adj->page_size))
y = adj->upper - adj->page_size;
diff --git a/src/gtkext/gtkblockview.c b/src/gtkext/gtkblockview.c
index 0a23317..a79b3ff 100644
--- a/src/gtkext/gtkblockview.c
+++ b/src/gtkext/gtkblockview.c
@@ -153,13 +153,21 @@ gtk_text_view2_set_attributes_from_style (GtkTextAttributes *values,
/* Procède à l'initialisation de l'afficheur d'un bloc binaire. */
static void gtk_block_view_init(GtkBlockView *);
-
-
/* Encadre la construction graphique initiale de la visualisation. */
static void gtk_block_view_realize(GtkWidget *);
+/* Fournit la taille de composant requise pour un plein rendu. */
+static void gtk_block_view_size_request(GtkWidget *, GtkRequisition *);
+
+/* S'adapte à la surface concédée par le composant parent. */
+static void gtk_block_view_size_allocate(GtkWidget *, GtkAllocation *);
+
+
+/* Réagit à un défilement quelconque. */
+static void gtk_block_view_scroll(GtkBlockView *);
+
/* Définit les lignes du bloc de représentation. */
static void gtk_block_view_set_rendering_lines(GtkBlockView *, GRenderingLine *, GRenderingLine *);
@@ -191,9 +199,6 @@ static bool gtk_block_view_get_address_coordinates(const GtkBlockView *, vmpa_t,
static void gtk_block_view_class_init(GtkBlockViewClass *klass);
-static void gtk_block_view_init(GtkBlockView *cpu);
-static void gtk_block_view_size_request(GtkWidget *widget,
- GtkRequisition *requisition);
static void gtk_block_view_size_allocate(GtkWidget *widget,
GtkAllocation *allocation);
@@ -203,6 +208,8 @@ static gboolean gtk_block_view_button_press(GtkWidget *, GdkEventButton *event);
/* Met à jour l'affichage de la vue sous forme de bloc. */
static gboolean gtk_block_view_expose(GtkWidget *, GdkEventExpose *);
+
+
static void gtk_block_view_destroy(GtkObject *object);
@@ -480,6 +487,7 @@ static void gtk_block_view_init(GtkBlockView *view)
binview = GTK_BIN_VIEW(view);
+ binview->scroll = (scroll_fc)gtk_block_view_scroll;
binview->set_lines = (set_rendering_lines_fc)gtk_block_view_set_rendering_lines;
binview->get_coordinates = (get_addr_coordinates_fc)gtk_block_view_get_address_coordinates;
@@ -531,7 +539,7 @@ static void gtk_block_view_init(GtkBlockView *view)
style->left_margin = 10;
style->right_margin = 10;
- style->wrap_mode = GTK_WRAP_WORD;
+ style->wrap_mode = GTK_WRAP_NONE;
style->justification = GTK_JUSTIFY_LEFT;
style->direction = gtk_widget_get_direction(view);
@@ -544,49 +552,11 @@ static void gtk_block_view_init(GtkBlockView *view)
//gtk_text_layout_get_size (GTK_BLOCK_VIEW(view)->layout, &width, &height);
- gtk_text_layout_set_screen_width (GTK_BLOCK_VIEW(view)->layout,
- MAX (1, 1000));
-
}
}
-
-static void
-gtk_block_view_size_request(GtkWidget *widget,
- GtkRequisition *requisition)
-{
- g_return_if_fail(widget != NULL);
- g_return_if_fail(GTK_IS_BLOCK_VIEW(widget));
- g_return_if_fail(requisition != NULL);
-
- requisition->width = 80;
- requisition->height = 100;
-}
-
-
-static void
-gtk_block_view_size_allocate(GtkWidget *widget,
- GtkAllocation *allocation)
-{
- g_return_if_fail(widget != NULL);
- g_return_if_fail(GTK_IS_BLOCK_VIEW(widget));
- g_return_if_fail(allocation != NULL);
-
- widget->allocation = *allocation;
-
- if (GTK_WIDGET_REALIZED(widget)) {
- gdk_window_move_resize(
- widget->window,
- allocation->x, allocation->y,
- allocation->width, allocation->height
- );
- }
-}
-
-
-
/******************************************************************************
* *
* Paramètres : widget = composant GTK à redessiner. *
@@ -615,6 +585,101 @@ static void gtk_block_view_realize(GtkWidget *widget)
}
+/******************************************************************************
+* *
+* Paramètres : widget = composant GTK à consulter. *
+* requisition = dimensions souhaitées. [OUT] *
+* *
+* Description : Fournit la taille de composant requise pour un plein rendu. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void gtk_block_view_size_request(GtkWidget *widget, GtkRequisition *requisition)
+{
+ gtk_text_layout_get_size(GTK_BLOCK_VIEW(widget)->layout,
+ &requisition->width, &requisition->height);
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : view = 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_block_view_size_allocate(GtkWidget *widget, GtkAllocation *allocation)
+{
+ GtkBinView *view; /* Autre version du composant */
+ gint width; /* Largeur de l'objet actuelle */
+ gint height; /* Hauteur de l'objet actuelle */
+ GtkAllocation valloc; /* Surface utilisable */
+ gboolean changed; /* Changement de valeur ? */
+
+ /* Mise à jour GTK */
+
+ widget->allocation = *allocation;
+
+ if (GTK_WIDGET_REALIZED(widget))
+ gdk_window_move_resize(widget->window,
+ allocation->x, allocation->y,
+ allocation->width, allocation->height);
+
+ view = GTK_BIN_VIEW(widget);
+
+ if (view->hadjustment == NULL || view->vadjustment == NULL)
+ return;
+
+ gtk_text_layout_get_size(GTK_BLOCK_VIEW(view)->layout, &width, &height);
+
+ gtk_bin_view_compute_allocation(view, &valloc);
+
+ /* Défilement horizontal */
+
+ view->hadjustment->page_size = valloc.width;
+ view->hadjustment->step_increment = valloc.width * 0.1;
+ view->hadjustment->page_increment = valloc.width * 0.9;
+
+ view->hadjustment->upper = MAX(width, valloc.width);
+
+ gtk_bin_view_reclamp_adjustment(view->hadjustment, &changed);
+
+ gtk_adjustment_changed(view->hadjustment);
+
+ if (changed)
+ gtk_adjustment_value_changed(view->hadjustment);
+
+ /* Défilement vertical */
+
+ view->vadjustment->page_size = valloc.height;
+ view->vadjustment->step_increment = GTK_BLOCK_VIEW(view)->line_height;
+ view->vadjustment->page_increment = view->vadjustment->step_increment * 10.0;
+
+ view->vadjustment->upper = MAX(height, valloc.height);
+
+ gtk_bin_view_reclamp_adjustment(view->vadjustment, &changed);
+
+ gtk_adjustment_changed(view->vadjustment);
+
+ if (changed)
+ gtk_adjustment_value_changed(view->vadjustment);
+
+}
+
+
+
+
static gboolean gtk_block_view_button_press(GtkWidget *widget, GdkEventButton *event)
{
gboolean result; /* Décision à retourner */
@@ -682,20 +747,67 @@ void gtk_block_view_update_margin(GRenderingLine *line, GtkBlockView *view)
* *
* Description : Met à jour l'affichage de la vue sous forme de bloc. *
* *
-* Retour : FALSE pour poursuivre la propagation de l'événement. *
+* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
-static gboolean gtk_block_view_expose(GtkWidget *widget, GdkEventExpose *event)
+static void gtk_block_view_compute_fake_coord(GtkBlockView *view, gint *x, gint *y)
+{
+ if (GTK_BIN_VIEW(view)->hadjustment != NULL)
+ *x -= gtk_adjustment_get_value(GTK_BIN_VIEW(view)->hadjustment);
+
+ if (GTK_BIN_VIEW(view)->vadjustment != NULL)
+ *y += gtk_adjustment_get_value(GTK_BIN_VIEW(view)->vadjustment);
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : view = composant GTK à redessiner. *
+* event = informations liées à l'événement. *
+* *
+* Description : Met à jour l'affichage de la vue sous forme de bloc. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void gtk_block_view_compute_real_coord(GtkBlockView *view, gint *x, gint *y)
{
- GtkBlockView *view;
+ if (GTK_BIN_VIEW(view)->hadjustment != NULL)
+ *x += gtk_adjustment_get_value(GTK_BIN_VIEW(view)->hadjustment);
+
+ if (GTK_BIN_VIEW(view)->vadjustment != NULL)
+ *y -= gtk_adjustment_get_value(GTK_BIN_VIEW(view)->vadjustment);
+
+}
- //GtkWidget *widget; /* Autre version du composant */
+/******************************************************************************
+* *
+* Paramètres : view = composant GTK à redessiner. *
+* event = informations liées à l'événement. *
+* *
+* Description : Met à jour l'affichage de la vue sous forme de bloc. *
+* *
+* Retour : FALSE pour poursuivre la propagation de l'événement. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static gboolean gtk_block_view_expose(GtkWidget *widget, GdkEventExpose *event)
+{
+ GtkBlockView *view; /* Autre version du composant */
GtkBinView *bview; /* Autre version du composant */
GtkStyle *style; /* Style associé au composant */
+ gint fake_x; /* Abscisse virtuelle */
+ gint fake_y; /* Ordonnée virtuelle */
GtkBinViewClass *parent_class; /* Version pure du parent */
GtkTextIter iter; /* Point d'insertion */
GdkRectangle rect; /* Zone d'un point */
@@ -726,22 +838,22 @@ static gboolean gtk_block_view_expose(GtkWidget *widget, GdkEventExpose *event)
style = gtk_widget_get_style(GTK_WIDGET(view));
-
- //gtk_widget_get_size_request(widget, &width, &height);
-
+ fake_x = 0;
+ fake_y = 0;
+ gtk_block_view_compute_fake_coord(view, &fake_x, &fake_y);
/* Dessin de la marge gauche */
gdk_gc_set_foreground(bview->gc, &style->mid[GTK_WIDGET_STATE(widget)]);
gdk_draw_rectangle(GDK_DRAWABLE(widget->window), bview->gc, TRUE,
- 0, event->area.y, view->left_margin, event->area.y + event->area.height);
+ fake_x, event->area.y, view->left_margin, event->area.y + event->area.height);
gdk_gc_set_foreground(bview->gc, &style->dark[GTK_WIDGET_STATE(widget)]);
gdk_draw_line(GDK_DRAWABLE(widget->window), bview->gc,
- view->left_margin, event->area.y,
- view->left_margin, event->area.y + event->area.height);
+ fake_x + view->left_margin, event->area.y,
+ fake_x + view->left_margin, event->area.y + event->area.height);
/* Eventuelle bordure globale */
@@ -751,11 +863,13 @@ static gboolean gtk_block_view_expose(GtkWidget *widget, GdkEventExpose *event)
/* Informations individuelles des lignes */
- gtk_text_layout_get_line_at_y(view->layout, &iter, event->area.y, NULL);
+ gtk_text_layout_get_line_at_y(view->layout, &iter, fake_y, NULL);
gtk_text_layout_get_iter_location(view->layout, &iter, &rect);
- while (rect.y < (event->area.y + event->area.height))
+ while (rect.y < (fake_y + event->area.height))
{
+ gtk_block_view_compute_real_coord(view, &rect.x, &rect.y);
+
mark = gtk_text_iter_get_marks(&iter)->data;
line = g_object_get_data(G_OBJECT(mark), "line");
@@ -770,7 +884,7 @@ static gboolean gtk_block_view_expose(GtkWidget *widget, GdkEventExpose *event)
else pixbuf = NULL;
if (pixbuf != NULL)
- gdk_draw_pixbuf(GDK_DRAWABLE(widget->window), bview->gc, pixbuf, 0, 0, 10, rect.y,
+ gdk_draw_pixbuf(GDK_DRAWABLE(widget->window), bview->gc, pixbuf, 0, 0, fake_x + 10, rect.y,
gdk_pixbuf_get_width(pixbuf), gdk_pixbuf_get_height(pixbuf),
GDK_RGB_DITHER_NORMAL, 0, 0);
@@ -779,7 +893,7 @@ static gboolean gtk_block_view_expose(GtkWidget *widget, GdkEventExpose *event)
{
pixbuf = GTK_BLOCK_VIEW_GET_CLASS(view)->entry_pix;
- gdk_draw_pixbuf(GDK_DRAWABLE(widget->window), bview->gc, pixbuf, 0, 0, 10, rect.y,
+ gdk_draw_pixbuf(GDK_DRAWABLE(widget->window), bview->gc, pixbuf, 0, 0, fake_x + 10, rect.y,
gdk_pixbuf_get_width(pixbuf), gdk_pixbuf_get_height(pixbuf),
GDK_RGB_DITHER_NORMAL, 0, 0);
@@ -792,17 +906,10 @@ static gboolean gtk_block_view_expose(GtkWidget *widget, GdkEventExpose *event)
/* Impression du désassemblage */
-
- gtk_text_layout_set_screen_width (GTK_BLOCK_VIEW(bview)->layout,
- MAX (1, 1000));
-
-
-
gtk_text_layout_draw(GTK_BLOCK_VIEW(bview)->layout, widget, GDK_DRAWABLE(widget->window),
- NULL, view->left_text, 0, event->area.x, event->area.y,
+ NULL, -fake_x + view->left_text, fake_y, event->area.x, event->area.y,
event->area.width, event->area.height, &child_exposes);
-
gdk_window_end_paint(GDK_DRAWABLE(widget->window));
return TRUE;
@@ -810,6 +917,8 @@ static gboolean gtk_block_view_expose(GtkWidget *widget, GdkEventExpose *event)
}
+
+
static void
gtk_block_view_destroy(GtkObject *object)
{
@@ -903,6 +1012,25 @@ void gtk_block_view_set_format(GtkBlockView *view, const exe_format *format)
/******************************************************************************
* *
* Paramètres : view = composant GTK à mettre à jour. *
+* *
+* Description : Réagit à un défilement quelconque. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void gtk_block_view_scroll(GtkBlockView *view)
+{
+ gtk_widget_queue_draw(GTK_WIDGET(view));
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : view = composant GTK à mettre à jour. *
* lines = informations à intégrer. *
* last = dernière ligne à intégrer ou NULL pour toutes. *
* *
diff --git a/src/gtkext/gtkgraphview.c b/src/gtkext/gtkgraphview.c
index d62cc33..34e0e80 100644
--- a/src/gtkext/gtkgraphview.c
+++ b/src/gtkext/gtkgraphview.c
@@ -38,6 +38,9 @@
struct _GtkGraphView
{
GtkBinView parent; /* A laisser en premier */
+ GtkFixed *support; /* Support des vues en bloc */
+
+ GtkRequisition requisition; /* Espace requis d'affichage */
vmpa_t start; /* Début de la portion vue */
vmpa_t end; /* Fin de la portion affichée */
@@ -68,12 +71,21 @@ static void gtk_graph_view_class_init(GtkGraphViewClass *);
/* Initialise une instance d'afficheur de code en graphique. */
static void gtk_graph_view_init(GtkGraphView *);
+/* Fournit la taille de composant requise pour un plein rendu. */
+static void gtk_graph_view_size_request(GtkWidget *, GtkRequisition *);
+
+/* S'adapte à la surface concédée par le composant parent. */
+static void gtk_graph_view_size_allocate(GtkWidget *, GtkAllocation *);
+
/* Met à jour l'affichage de la vue sous forme graphique. */
-static gboolean gtk_graph_view_expose(GtkGraphView *, GdkEventExpose *);
+static gboolean gtk_graph_view_expose(GtkWidget *, GdkEventExpose *, GtkGraphView *);
/* Supprime tout contenu de l'afficheur de code en graphique. */
static void gtk_graph_view_reset(GtkGraphView *);
+/* Réagit à un défilement quelconque. */
+static void gtk_graph_view_scroll(GtkGraphView *);
+
/* Définit les lignes du graphique de représentation. */
static void gtk_graph_view_set_rendering_lines(GtkGraphView *, GRenderingLine *, GRenderingLine *);
@@ -112,7 +124,8 @@ static void gtk_graph_view_class_init(GtkGraphViewClass *klass)
widget_class = (GtkWidgetClass *)klass;
- widget_class->expose_event = gtk_graph_view_expose;
+ widget_class->size_request = gtk_graph_view_size_request;
+ widget_class->size_allocate = gtk_graph_view_size_allocate;
}
@@ -132,13 +145,28 @@ static void gtk_graph_view_class_init(GtkGraphViewClass *klass)
static void gtk_graph_view_init(GtkGraphView *view)
{
GtkBinView *binview; /* Instance parente */
+ GdkColor white; /* Couleur de fond normale */
binview = GTK_BIN_VIEW(view);
+ binview->scroll = (scroll_fc)gtk_graph_view_scroll;
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_fixed_set_has_window(view->support, TRUE);
+
+ g_signal_connect(G_OBJECT(view->support), "expose-event",
+ G_CALLBACK(gtk_graph_view_expose), view);
+
+ gtk_widget_show(GTK_WIDGET(view->support));
+
+ gdk_color_white(gtk_widget_get_colormap(GTK_WIDGET(view->support)), &white);
+ gtk_widget_modify_bg(GTK_WIDGET(view->support), GTK_STATE_NORMAL, &white);
+
+ gtk_fixed_put(GTK_FIXED(view), GTK_WIDGET(view->support), 0, 0);
+
view->mutex = g_mutex_new();
view->cond = g_cond_new();
@@ -147,6 +175,98 @@ static void gtk_graph_view_init(GtkGraphView *view)
/******************************************************************************
* *
+* Paramètres : widget = composant GTK à consulter. *
+* requisition = dimensions souhaitées. [OUT] *
+* *
+* Description : Fournit la taille de composant requise pour un plein rendu. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+static void gtk_graph_view_size_request(GtkWidget *widget, GtkRequisition *requisition)
+{
+ gpointer fixed_class; /* Classe parente */
+ GtkGraphView *view; /* Autre vision du composant */
+
+ fixed_class = g_type_class_peek_parent(GTK_GRAPH_VIEW_GET_CLASS(widget));
+
+ GTK_WIDGET_CLASS(fixed_class)->size_request(GTK_FIXED(widget), requisition);
+
+ view = GTK_GRAPH_VIEW(widget);
+
+ if (view->requisition.width == 0 && view->requisition.height == 0)
+ view->requisition = *requisition;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : view = 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)
+{
+ gpointer fixed_class; /* Classe parente */
+ GtkBinView *view; /* Autre version du composant */
+ GtkAllocation valloc; /* Surface utilisable */
+ gboolean changed; /* Changement de valeur ? */
+
+ /* Mise à jour GTK */
+
+ fixed_class = g_type_class_peek_parent(GTK_GRAPH_VIEW_GET_CLASS(widget));
+
+ GTK_WIDGET_CLASS(fixed_class)->size_allocate(GTK_FIXED(widget), allocation);
+
+ view = GTK_BIN_VIEW(widget);
+
+ gtk_bin_view_compute_allocation(view, &valloc);
+
+ /* Défilement horizontal */
+
+ view->hadjustment->page_size = valloc.width;
+ view->hadjustment->step_increment = valloc.width * 0.1;
+ view->hadjustment->page_increment = valloc.width * 0.9;
+
+ view->hadjustment->upper = MAX(GTK_GRAPH_VIEW(view)->requisition.width, valloc.width);
+
+ gtk_bin_view_reclamp_adjustment(view->hadjustment, &changed);
+
+ gtk_adjustment_changed(view->hadjustment);
+
+ if (changed)
+ gtk_adjustment_value_changed(view->hadjustment);
+
+ /* Défilement vertical */
+
+ view->vadjustment->page_size = valloc.height;
+ view->vadjustment->step_increment = valloc.width * 0.1;
+ view->vadjustment->page_increment = valloc.width * 0.9;
+
+ view->vadjustment->upper = MAX(GTK_GRAPH_VIEW(view)->requisition.height, valloc.height);
+
+ gtk_bin_view_reclamp_adjustment(view->vadjustment, &changed);
+
+ gtk_adjustment_changed(view->vadjustment);
+
+ if (changed)
+ gtk_adjustment_value_changed(view->vadjustment);
+
+}
+
+
+/******************************************************************************
+* *
* Paramètres : - *
* *
* Description : Crée un nouveau composant pour l'affichage en graphique. *
@@ -171,8 +291,9 @@ GtkWidget* gtk_graph_view_new(void)
/******************************************************************************
* *
-* Paramètres : view = composant GTK à redessiner. *
-* event = informations liées à l'événement. *
+* Paramètres : widget = composant GTK à redessiner. *
+* event = informations liées à l'événement. *
+* view = support maître à consulter. *
* *
* Description : Met à jour l'affichage de la vue sous forme graphique. *
* *
@@ -182,13 +303,13 @@ GtkWidget* gtk_graph_view_new(void)
* *
******************************************************************************/
-static gboolean gtk_graph_view_expose(GtkGraphView *view, GdkEventExpose *event)
+static gboolean gtk_graph_view_expose(GtkWidget *widget, GdkEventExpose *event, GtkGraphView *view)
{
size_t i; /* Boucle de parcours */
for (i = 0; i < view->links_count; i++)
gtk_link_renderer_draw(view->links[i],
- GDK_DRAWABLE(GTK_WIDGET(view)->window),
+ GDK_DRAWABLE(widget->window),
GTK_BIN_VIEW(view)->gc);
return FALSE;
@@ -212,6 +333,9 @@ static void gtk_graph_view_reset(GtkGraphView *view)
{
size_t i; /* Boucle de parcours */
+ view->requisition.width = 0;
+ view->requisition.height = 0;
+
view->start = 0;
view->end = 0;
@@ -247,6 +371,28 @@ static void gtk_graph_view_reset(GtkGraphView *view)
+
+/******************************************************************************
+* *
+* Paramètres : view = composant GTK à mettre à jour. *
+* *
+* Description : Réagit à un défilement quelconque. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void gtk_graph_view_scroll(GtkGraphView *view)
+{
+ gtk_fixed_move(GTK_FIXED(view), GTK_WIDGET(view->support),
+ -GTK_BIN_VIEW(view)->hadjustment->value,
+ -GTK_BIN_VIEW(view)->vadjustment->value);
+
+}
+
+
/******************************************************************************
* *
* Paramètres : view = composant GTK à mettre à jour. *
@@ -322,7 +468,7 @@ static void gtk_graph_view_define_main_address(GtkGraphView *view, vmpa_t addr)
view->childs = gtk_graph_view_load_nodes(view, GTK_BIN_VIEW(view)->binary, first, last);
- build_graph_view(GTK_FIXED(view), view->childs, view->childs_count);
+ build_graph_view(view, view->childs, view->childs_count);
break;
@@ -507,6 +653,29 @@ static void notify_graph_view(GtkBinView *view, GtkGraphView *parent)
/******************************************************************************
* *
+* 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, gint x, gint y)
+{
+ gtk_fixed_put(view->support, widget, x, y);
+
+}
+
+
+/******************************************************************************
+* *
* Paramètres : view = composant GTK à mettre à jour. *
* links = liens graphiques entre les blocs à intégrer. *
* count = quantité de ces liens graphiques. *
diff --git a/src/gtkext/gtkgraphview.h b/src/gtkext/gtkgraphview.h
index 1d0c2ab..3706343 100644
--- a/src/gtkext/gtkgraphview.h
+++ b/src/gtkext/gtkgraphview.h
@@ -54,6 +54,9 @@ GType gtk_graph_view_get_type(void);
/* Crée un nouveau composant pour l'affichage en graphique. */
GtkWidget* gtk_graph_view_new(void);
+/* Place une vue sous forme de bloc dans le graphique. */
+void gtk_graph_view_put(GtkGraphView *, GtkWidget *, gint, gint);
+
/* Définit les liens graphiques à présenter avec la vue. */
void gtk_graph_view_attach_links(GtkGraphView *, GtkLinkRenderer **, size_t);