?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Updated Spanish translation
[anjuta-git-plugin.git] / plugins / profiler / gprof-call-graph-view.c
blob766cdcfd4853bc40bde28bda2b4e52ed555b34d6
1 /* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 4; tab-width: 4 -*- */
2 /*
3 * gprof-call-graph-view.c
4 * Copyright (C) James Liggett 2006 <jrliggett@cox.net>
5 *
6 * gprof-call-graph-view.c is free software.
7 *
8 * You may redistribute it and/or modify it under the terms of the
9 * GNU General Public License, as published by the Free Software
10 * Foundation; either version 2, or (at your option) any later version.
11 *
12 * plugin.c is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
15 * See the GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with plugin.c. See the file "COPYING". If not,
19 * write to: The Free Software Foundation, Inc.,
20 * 51 Franklin Street, Fifth Floor,
21 * Boston, MA 02110-1301, USA.
22 */
23
24 #include "gprof-call-graph-view.h"
25 #include <glib/gi18n-lib.h>
26
27 struct _GProfCallGraphViewPriv
28 {
29 GladeXML *gxml;
30 GtkListStore *functions_list_store;
31 GtkListStore *called_list_store;
32 GtkListStore *called_by_list_store;
33 GHashTable *functions_iter_table; /* Map functions names to list iters */
34 };
35
36 /* Function list columsns */
37 enum
38 {
39 FUNCTIONS_COL_RECURSIVE = 0,
40 FUNCTIONS_COL_NAME,
41 FUNCTIONS_COL_TIME,
42 FUNCTIONS_COL_SELF,
43 FUNCTIONS_COL_CHILDREN,
44 FUNCTIONS_COL_CALLS,
45 FUNCTIONS_NUM_COLS
46 };
47
48 /* Called list columsns (also used by the Called By list) */
49 enum
50 {
51 CALLED_COL_RECURSIVE = 0,
52 CALLED_COL_NAME,
53 CALLED_COL_SELF,
54 CALLED_COL_CHILDREN,
55 CALLED_COL_CALLS,
56 CALLED_NUM_COLS
57 };
58
59 /* Add an item to Called/Called by lists */
60 static void gprof_call_graph_view_add_list_item (GProfCallGraphView *self,
61 GtkListStore *store,
62 GProfCallGraphBlockEntry *entry,
63 GtkTreeIter *iter)
64 {
65 GProfProfileData *data;
66 GProfCallGraph *call_graph;
67 GProfCallGraphBlock *block;
68
69 data = gprof_view_get_data (GPROF_VIEW (self));
70 call_graph = gprof_profile_data_get_call_graph (data);
71
72 gtk_list_store_append (store, iter);
73 gtk_list_store_set (store, iter, CALLED_COL_NAME,
74 gprof_call_graph_block_entry_get_name (entry),
75 CALLED_COL_SELF,
76 gprof_call_graph_block_entry_get_self_sec (entry),
77 CALLED_COL_CHILDREN,
78 gprof_call_graph_block_entry_get_child_sec (entry),
79 CALLED_COL_CALLS,
80 gprof_call_graph_block_entry_get_calls (entry),
81 -1);
82
83 block = gprof_call_graph_find_block (call_graph,
84 gprof_call_graph_block_entry_get_name (entry));
85
86
87 if (block)
88 {
89 if (gprof_call_graph_block_is_recursive (block))
90 gtk_list_store_set (store, iter, CALLED_COL_RECURSIVE,
91 GTK_STOCK_REFRESH);
92 }
93
94 }
95
96 /* Function selection callback */
97 static gboolean
98 on_function_selected (GtkTreeSelection *selection, GtkTreeModel *model,
99 GtkTreePath *path, gboolean path_currently_selected,
100 gpointer user_data)
101 {
102 GProfCallGraphView *self;
103 GProfProfileData *data;
104 GProfCallGraph *call_graph;
105 GProfCallGraphBlock *block;
106 GProfCallGraphBlockEntry *current_entry;
107 GtkWidget *called_list_view;
108 GtkWidget *called_by_list_view;
109 GList *entry_iter;
110 GtkTreeIter list_iter;
111 gchar *selected_function_name;
112
113 self = GPROF_CALL_GRAPH_VIEW (user_data);
114 data = gprof_view_get_data (GPROF_VIEW (self));
115 call_graph = gprof_profile_data_get_call_graph (data);
116 called_list_view = glade_xml_get_widget (self->priv->gxml,
117 "called_list_view");
118 called_by_list_view = glade_xml_get_widget (self->priv->gxml,
119 "called_by_list_view");
120
121 gtk_tree_model_get_iter (model, &list_iter, path);
122 gtk_tree_model_get (model, &list_iter, FUNCTIONS_COL_NAME,
123 &selected_function_name, -1);
124
125 if (selected_function_name)
126 {
127 g_object_ref (self->priv->called_list_store);
128 g_object_ref (self->priv->called_by_list_store);
129
130 gtk_tree_view_set_model (GTK_TREE_VIEW (called_list_view), NULL);
131 gtk_tree_view_set_model (GTK_TREE_VIEW (called_by_list_view), NULL);
132 gtk_list_store_clear (self->priv->called_list_store);
133 gtk_list_store_clear (self->priv->called_by_list_store);
134
135 block = gprof_call_graph_find_block (call_graph,
136 selected_function_name);
137 current_entry = gprof_call_graph_block_get_first_child (block,
138 &entry_iter);
139
140 g_free (selected_function_name);
141
142 while (current_entry)
143 {
144 gprof_call_graph_view_add_list_item (self,
145 self->priv->called_list_store,
146 current_entry, &list_iter);
147
148 current_entry = gprof_call_graph_block_entry_get_next (entry_iter,
149 &entry_iter);
150 }
151
152 current_entry = gprof_call_graph_block_get_first_parent (block,
153 &entry_iter);
154
155 while (current_entry)
156 {
157 gprof_call_graph_view_add_list_item (self,
158 self->priv->called_by_list_store,
159 current_entry, &list_iter);
160
161 current_entry = gprof_call_graph_block_entry_get_next (entry_iter,
162 &entry_iter);
163 }
164
165 gtk_tree_view_set_model (GTK_TREE_VIEW (called_list_view),
166 GTK_TREE_MODEL (self->priv->called_list_store));
167 gtk_tree_view_set_model (GTK_TREE_VIEW (called_by_list_view),
168 GTK_TREE_MODEL (self->priv->called_by_list_store));
169 g_object_unref (self->priv->called_list_store);
170 g_object_unref (self->priv->called_by_list_store);
171
172 /* Set up search colums again */
173 gtk_tree_view_set_search_column (GTK_TREE_VIEW (called_list_view),
174 CALLED_COL_NAME);
175 gtk_tree_view_set_search_column (GTK_TREE_VIEW (called_by_list_view),
176 CALLED_COL_NAME);
177 }
178
179 return TRUE;
180 }
181
182 /* Select a function in the Functions list by name */
183 static void
184 gprof_call_graph_view_select_function (GProfCallGraphView *self, gchar *name)
185 {
186 GtkWidget *functions_list_view;
187 GtkTreeSelection *functions_list_selection;
188 GtkTreeIter *functions_list_iter;
189 GtkTreePath *functions_list_path;
190
191 functions_list_view = glade_xml_get_widget (self->priv->gxml,
192 "functions_list_view");
193 functions_list_selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (functions_list_view));
194
195 functions_list_iter = g_hash_table_lookup (self->priv->functions_iter_table,
196 name);
197
198 if (functions_list_iter)
199 {
200 gtk_tree_selection_select_iter (functions_list_selection,
201 functions_list_iter);
202 functions_list_path = gtk_tree_model_get_path (GTK_TREE_MODEL (self->priv->functions_list_store),
203 functions_list_iter);
204 gtk_tree_view_scroll_to_cell (GTK_TREE_VIEW (functions_list_view),
205 functions_list_path, NULL, TRUE, 0.5,
206 0.0);
207
208 gtk_tree_path_free (functions_list_path);
209
210 }
211 }
212
213 static void
214 on_functions_list_view_row_activated (GtkTreeView *list_view,
215 GtkTreePath *path,
216 GtkTreeViewColumn *col,
217 gpointer user_data)
218 {
219 GProfView *self;
220 GtkTreeIter list_iter;
221 GtkTreeModel *model;
222 gchar *selected_function_name;
223
224 self = GPROF_VIEW (user_data);
225 model = gtk_tree_view_get_model (list_view);
226
227 if (gtk_tree_model_get_iter (model, &list_iter, path))
228 {
229 gtk_tree_model_get (model,
230 &list_iter, CALLED_COL_NAME,
231 &selected_function_name, -1);
232
233 gprof_view_show_symbol_in_editor (self, selected_function_name);
234
235 g_free (selected_function_name);
236 }
237 }
238
239 /* Called/Called By list row activation callbacks */
240 static void on_called_list_view_row_activated (GtkTreeView *list_view,
241 GtkTreePath *path,
242 GtkTreeViewColumn *col,
243 gpointer user_data)
244 {
245 GProfCallGraphView *self;
246 GtkTreeIter list_iter;
247 GtkTreeModel *model;
248 gchar *selected_function_name;
249
250 self = GPROF_CALL_GRAPH_VIEW (user_data);
251 model = gtk_tree_view_get_model (list_view);
252
253 if (gtk_tree_model_get_iter (model, &list_iter, path))
254 {
255 gtk_tree_model_get (model,
256 &list_iter, CALLED_COL_NAME,
257 &selected_function_name, -1);
258
259 gprof_call_graph_view_select_function (self, selected_function_name);
260
261 g_free (selected_function_name);
262 }
263 }
264
265 static void
266 gprof_call_graph_view_create_columns (GProfCallGraphView *self)
267 {
268 GtkTreeViewColumn *col;
269 GtkCellRenderer *renderer;
270 GtkWidget *functions_list_view;
271 GtkWidget *called_list_view;
272 GtkWidget *called_by_list_view;
273
274 functions_list_view = glade_xml_get_widget (self->priv->gxml,
275 "functions_list_view");
276 called_list_view = glade_xml_get_widget (self->priv->gxml,
277 "called_list_view");
278 called_by_list_view = glade_xml_get_widget (self->priv->gxml,
279 "called_by_list_view");
280
281 /* The Functions list will have all fields; all others have everything
282 * except a time field. */
283
284 /* Recursive icon */
285 col = gtk_tree_view_column_new ();
286 gtk_tree_view_append_column (GTK_TREE_VIEW (functions_list_view), col);
287 renderer = gtk_cell_renderer_pixbuf_new ();
288 gtk_tree_view_column_pack_start (col, renderer, TRUE);
289 gtk_tree_view_column_add_attribute (col, renderer, "stock-id",
290 FUNCTIONS_COL_RECURSIVE);
291 gtk_tree_view_column_set_reorderable (col, TRUE);
292
293 col = gtk_tree_view_column_new ();
294 gtk_tree_view_append_column (GTK_TREE_VIEW (called_list_view), col);
295 renderer = gtk_cell_renderer_pixbuf_new ();
296 gtk_tree_view_column_pack_start (col, renderer, TRUE);
297 gtk_tree_view_column_add_attribute (col, renderer, "stock-id",
298 CALLED_COL_RECURSIVE);
299 gtk_tree_view_column_set_reorderable (col, TRUE);
300
301
302 col = gtk_tree_view_column_new ();
303 gtk_tree_view_append_column (GTK_TREE_VIEW (called_by_list_view), col);
304 renderer = gtk_cell_renderer_pixbuf_new ();
305 gtk_tree_view_column_pack_start (col, renderer, TRUE);
306 gtk_tree_view_column_add_attribute (col, renderer, "stock-id",
307 CALLED_COL_RECURSIVE);
308 gtk_tree_view_column_set_reorderable (col, TRUE);
309
310 /* Function Name */
311 col = gtk_tree_view_column_new ();
312 gtk_tree_view_column_set_title (col, _("Function Name"));
313 gtk_tree_view_append_column (GTK_TREE_VIEW (functions_list_view), col);
314 renderer = gtk_cell_renderer_text_new ();
315 gtk_tree_view_column_pack_start (col, renderer, TRUE);
316 gtk_tree_view_column_add_attribute (col, renderer, "text",
317 FUNCTIONS_COL_NAME);
318 gtk_tree_view_column_set_resizable (col, TRUE);
319 gtk_tree_view_column_set_reorderable (col, TRUE);
320
321 col = gtk_tree_view_column_new ();
322 gtk_tree_view_column_set_title (col, _("Function Name"));
323 gtk_tree_view_append_column (GTK_TREE_VIEW (called_list_view), col);
324 renderer = gtk_cell_renderer_text_new ();
325 gtk_tree_view_column_pack_start (col, renderer, TRUE);
326 gtk_tree_view_column_add_attribute (col, renderer, "text",
327 CALLED_COL_NAME);
328 gtk_tree_view_column_set_resizable (col, TRUE);
329 gtk_tree_view_column_set_reorderable (col, TRUE);
330
331 col = gtk_tree_view_column_new ();
332 gtk_tree_view_column_set_title (col, _("Function Name"));
333 gtk_tree_view_append_column (GTK_TREE_VIEW (called_by_list_view), col);
334 renderer = gtk_cell_renderer_text_new ();
335 gtk_tree_view_column_pack_start (col, renderer, TRUE);
336 gtk_tree_view_column_add_attribute (col, renderer, "text",
337 CALLED_COL_NAME);
338 gtk_tree_view_column_set_resizable (col, TRUE);
339 gtk_tree_view_column_set_reorderable (col, TRUE);
340
341
342 /* Time */
343 col = gtk_tree_view_column_new ();
344 gtk_tree_view_column_set_title (col, _("Time"));
345 gtk_tree_view_append_column (GTK_TREE_VIEW (functions_list_view), col);
346
347 renderer = gtk_cell_renderer_text_new ();
348 gtk_tree_view_column_pack_start (col, renderer, TRUE);
349 gtk_tree_view_column_add_attribute (col, renderer, "text",
350 FUNCTIONS_COL_TIME);
351 gtk_tree_view_column_set_resizable (col, TRUE);
352 gtk_tree_view_column_set_reorderable (col, TRUE);
353
354 /* Self */
355 col = gtk_tree_view_column_new ();
356
357 /* Total amount of time spent in this function, excluding those it calla.
358 * This is the same as the "Seconds" field in the flat profile. */
359 gtk_tree_view_column_set_title (col, _("Self"));
360 gtk_tree_view_append_column (GTK_TREE_VIEW (functions_list_view), col);
361 renderer = gtk_cell_renderer_text_new ();
362 gtk_tree_view_column_pack_start (col, renderer, TRUE);
363 gtk_tree_view_column_add_attribute (col, renderer, "text",
364 FUNCTIONS_COL_SELF);
365 gtk_tree_view_column_set_resizable (col, TRUE);
366 gtk_tree_view_column_set_reorderable (col, TRUE);
367
368 col = gtk_tree_view_column_new ();
369
370 /* Time spent in a subroutine of a function. */
371 gtk_tree_view_column_set_title (col, _("Self"));
372 gtk_tree_view_append_column (GTK_TREE_VIEW (called_list_view), col);
373 renderer = gtk_cell_renderer_text_new ();
374 gtk_tree_view_column_pack_start (col, renderer, TRUE);
375 gtk_tree_view_column_add_attribute (col, renderer, "text",
376 CALLED_COL_SELF);
377 gtk_tree_view_column_set_resizable (col, TRUE);
378 gtk_tree_view_column_set_reorderable (col, TRUE);
379
380 col = gtk_tree_view_column_new ();
381
382 /* Time spent in this function when it was called by its caller */
383 gtk_tree_view_column_set_title (col, _("Self"));
384 gtk_tree_view_append_column (GTK_TREE_VIEW (called_by_list_view), col);
385 renderer = gtk_cell_renderer_text_new ();
386 gtk_tree_view_column_pack_start (col, renderer, TRUE);
387 gtk_tree_view_column_add_attribute (col, renderer, "text",
388 CALLED_COL_SELF);
389 gtk_tree_view_column_set_resizable (col, TRUE);
390 gtk_tree_view_column_set_reorderable (col, TRUE);
391
392 /* Children */
393 col = gtk_tree_view_column_new ();
394 gtk_tree_view_column_set_title (col, _("Children"));
395 gtk_tree_view_append_column (GTK_TREE_VIEW (functions_list_view), col);
396 renderer = gtk_cell_renderer_text_new ();
397 gtk_tree_view_column_pack_start (col, renderer, TRUE);
398 gtk_tree_view_column_add_attribute (col, renderer, "text",
399 FUNCTIONS_COL_CHILDREN);
400 gtk_tree_view_column_set_resizable (col, TRUE);
401 gtk_tree_view_column_set_reorderable (col, TRUE);
402
403 col = gtk_tree_view_column_new ();
404 gtk_tree_view_column_set_title (col, _("Children"));
405 gtk_tree_view_append_column (GTK_TREE_VIEW (called_list_view), col);
406 renderer = gtk_cell_renderer_text_new ();
407 gtk_tree_view_column_pack_start (col, renderer, TRUE);
408 gtk_tree_view_column_add_attribute (col, renderer, "text",
409 CALLED_COL_CHILDREN);
410 gtk_tree_view_column_set_resizable (col, TRUE);
411 gtk_tree_view_column_set_reorderable (col, TRUE);
412
413 col = gtk_tree_view_column_new ();
414 gtk_tree_view_column_set_title (col, _("Children"));
415 gtk_tree_view_append_column (GTK_TREE_VIEW (called_by_list_view), col);
416 renderer = gtk_cell_renderer_text_new ();
417 gtk_tree_view_column_pack_start (col, renderer, TRUE);
418 gtk_tree_view_column_add_attribute (col, renderer, "text",
419 CALLED_COL_CHILDREN);
420 gtk_tree_view_column_set_resizable (col, TRUE);
421 gtk_tree_view_column_set_reorderable (col, TRUE);
422
423 /* Calls */
424 col = gtk_tree_view_column_new ();
425 gtk_tree_view_column_set_title (col, _("Calls"));
426 gtk_tree_view_append_column (GTK_TREE_VIEW (functions_list_view), col);
427 renderer = gtk_cell_renderer_text_new ();
428 gtk_tree_view_column_pack_start (col, renderer, TRUE);
429 gtk_tree_view_column_add_attribute (col, renderer, "text",
430 FUNCTIONS_COL_CALLS);
431 gtk_tree_view_column_set_resizable (col, TRUE);
432 gtk_tree_view_column_set_reorderable (col, TRUE);
433
434 col = gtk_tree_view_column_new ();
435 gtk_tree_view_column_set_title (col, _("Calls"));
436 gtk_tree_view_append_column (GTK_TREE_VIEW (called_list_view), col);
437 renderer = gtk_cell_renderer_text_new ();
438 gtk_tree_view_column_pack_start (col, renderer, TRUE);
439 gtk_tree_view_column_add_attribute (col, renderer, "text",
440 CALLED_COL_CALLS);
441 gtk_tree_view_column_set_resizable (col, TRUE);
442 gtk_tree_view_column_set_reorderable (col, TRUE);
443
444 col = gtk_tree_view_column_new ();
445 gtk_tree_view_column_set_title (col, _("Calls"));
446 gtk_tree_view_append_column (GTK_TREE_VIEW (called_by_list_view), col);
447 renderer = gtk_cell_renderer_text_new ();
448 gtk_tree_view_column_pack_start (col, renderer, TRUE);
449 gtk_tree_view_column_add_attribute (col, renderer, "text",
450 CALLED_COL_CALLS);
451 gtk_tree_view_column_set_resizable (col, TRUE);
452 gtk_tree_view_column_set_reorderable (col, TRUE);
453
454 /* Model setup */
455 gtk_tree_view_set_model (GTK_TREE_VIEW (functions_list_view),
456 GTK_TREE_MODEL (self->priv->functions_list_store));
457 g_object_unref (self->priv->functions_list_store);
458
459 gtk_tree_view_set_model (GTK_TREE_VIEW (called_list_view),
460 GTK_TREE_MODEL (self->priv->called_list_store));
461 g_object_unref (self->priv->called_list_store);
462
463 gtk_tree_view_set_model (GTK_TREE_VIEW (called_by_list_view),
464 GTK_TREE_MODEL (self->priv->called_by_list_store));
465 g_object_unref (self->priv->called_by_list_store);
466
467
468 }
469
470 static void
471 gprof_call_graph_view_init (GProfCallGraphView *self)
472 {
473 GtkWidget *functions_list_view;
474 GtkWidget *called_list_view;
475 GtkWidget *called_by_list_view;
476 GtkWidget *called_jump_to_button;
477 GtkWidget *called_by_jump_to_button;
478 GtkTreeSelection *functions_list_selection;
479
480 self->priv = g_new0 (GProfCallGraphViewPriv, 1);
481
482 self->priv->gxml = glade_xml_new (PACKAGE_DATA_DIR
483 "/glade/profiler-call-graph.glade",
484 NULL, NULL);
485 self->priv->functions_list_store = gtk_list_store_new (FUNCTIONS_NUM_COLS,
486 G_TYPE_STRING,
487 G_TYPE_STRING,
488 G_TYPE_FLOAT,
489 G_TYPE_FLOAT,
490 G_TYPE_FLOAT,
491 G_TYPE_STRING);
492
493 self->priv->called_list_store = gtk_list_store_new (CALLED_NUM_COLS,
494 G_TYPE_STRING,
495 G_TYPE_STRING,
496 G_TYPE_FLOAT,
497 G_TYPE_FLOAT,
498 G_TYPE_STRING);
499
500 self->priv->called_by_list_store = gtk_list_store_new (CALLED_NUM_COLS,
501 G_TYPE_STRING,
502 G_TYPE_STRING,
503 G_TYPE_FLOAT,
504 G_TYPE_FLOAT,
505 G_TYPE_STRING);
506
507 gprof_call_graph_view_create_columns (self);
508
509 functions_list_view = glade_xml_get_widget (self->priv->gxml,
510 "functions_list_view");
511 called_list_view = glade_xml_get_widget (self->priv->gxml,
512 "called_list_view");
513 called_by_list_view = glade_xml_get_widget (self->priv->gxml,
514 "called_by_list_view");
515
516 /* Function selection */
517 functions_list_selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (functions_list_view));
518 gtk_tree_selection_set_select_function (functions_list_selection,
519 on_function_selected,
520 (gpointer) self, NULL);
521
522 /* Jump to button callbacks */
523 called_jump_to_button = glade_xml_get_widget (self->priv->gxml,
524 "called_jump_to_button");
525 called_by_jump_to_button = glade_xml_get_widget (self->priv->gxml,
526 "called_by_jump_to_button");
527
528 g_signal_connect (functions_list_view, "row-activated",
529 G_CALLBACK (on_functions_list_view_row_activated),
530 (gpointer) self);
531 g_signal_connect (called_list_view, "row-activated",
532 G_CALLBACK (on_called_list_view_row_activated),
533 (gpointer) self);
534 g_signal_connect (called_by_list_view, "row-activated",
535 G_CALLBACK (on_called_list_view_row_activated),
536 (gpointer) self);
537 }
538
539 static void
540 gprof_call_graph_view_finalize (GObject *obj)
541 {
542 GProfCallGraphView *self;
543
544 self = (GProfCallGraphView *) obj;
545
546 g_object_unref (self->priv->gxml);
547
548 if (self->priv->functions_iter_table)
549 g_hash_table_destroy (self->priv->functions_iter_table);
550
551 g_free (self->priv);
552 }
553
554 static void
555 gprof_call_graph_view_class_init (GProfCallGraphViewClass *klass)
556 {
557 GObjectClass *object_class;
558 GProfViewClass *view_class;
559
560 object_class = (GObjectClass *) klass;
561 view_class = GPROF_VIEW_CLASS (klass);
562
563 object_class->finalize = gprof_call_graph_view_finalize;
564 view_class->refresh = gprof_call_graph_view_refresh;
565 view_class->get_widget = gprof_call_graph_view_get_widget;
566 }
567
568 GType
569 gprof_call_graph_view_get_type (void)
570 {
571 static GType obj_type = 0;
572
573 if (!obj_type)
574 {
575 static const GTypeInfo obj_info =
576 {
577 sizeof (GProfCallGraphViewClass),
578 (GBaseInitFunc) NULL,
579 (GBaseFinalizeFunc) NULL,
580 (GClassInitFunc) gprof_call_graph_view_class_init,
581 (GClassFinalizeFunc) NULL,
582 NULL, /* class_data */
583 sizeof (GProfCallGraphView),
584 0, /* n_preallocs */
585 (GInstanceInitFunc) gprof_call_graph_view_init,
586 NULL /* value_table */
587 };
588 obj_type = g_type_register_static (GPROF_VIEW_TYPE,
589 "GProfCallGraphView", &obj_info, 0);
590 }
591 return obj_type;
592 }
593
594 GProfCallGraphView *
595 gprof_call_graph_view_new (GProfProfileData *profile_data,
596 IAnjutaSymbolManager *symbol_manager,
597 IAnjutaDocumentManager *document_manager)
598 {
599 GProfCallGraphView *view;
600
601 view = g_object_new (GPROF_CALL_GRAPH_VIEW_TYPE, NULL);
602 gprof_view_set_data (GPROF_VIEW (view), profile_data);
603 gprof_view_set_symbol_manager (GPROF_VIEW (view), symbol_manager);
604 gprof_view_set_document_manager (GPROF_VIEW (view), document_manager);
605
606 return view;
607 }
608
609 void
610 gprof_call_graph_view_refresh (GProfView *view)
611 {
612 GProfCallGraphView *self;
613 GtkWidget *functions_list_view;
614 GtkWidget *called_list_view;
615 GtkWidget *called_by_list_view;
616 GProfProfileData *data;
617 GProfCallGraph *call_graph;
618 GProfCallGraphBlock *current_block;
619 GProfCallGraphBlockEntry *primary_entry;
620 GList *block_iter;
621 GtkTreeIter list_iter;
622
623 self = GPROF_CALL_GRAPH_VIEW (view);
624 data = gprof_view_get_data (view);
625 call_graph = gprof_profile_data_get_call_graph (data);
626
627 functions_list_view = glade_xml_get_widget (self->priv->gxml,
628 "functions_list_view");
629 called_list_view = glade_xml_get_widget (self->priv->gxml,
630 "called_list_view");
631 called_by_list_view = glade_xml_get_widget (self->priv->gxml,
632 "called_by_list_view");
633
634 /* Clear all lists and repopulate the functions list. The two others won't
635 * be repopulated until a user selects a function from the Functions list */
636 g_object_ref (self->priv->functions_list_store);
637 g_object_ref (self->priv->called_list_store);
638 g_object_ref (self->priv->called_by_list_store);
639
640 gtk_tree_view_set_model (GTK_TREE_VIEW (functions_list_view), NULL);
641 gtk_tree_view_set_model (GTK_TREE_VIEW (called_list_view), NULL);
642 gtk_tree_view_set_model (GTK_TREE_VIEW (called_by_list_view), NULL);
643 gtk_list_store_clear (self->priv->functions_list_store);
644 gtk_list_store_clear (self->priv->called_list_store);
645 gtk_list_store_clear (self->priv->called_by_list_store);
646
647 gtk_tree_view_set_model (GTK_TREE_VIEW (called_list_view),
648 GTK_TREE_MODEL (self->priv->called_list_store));
649 gtk_tree_view_set_model (GTK_TREE_VIEW (called_by_list_view),
650 GTK_TREE_MODEL (self->priv->called_by_list_store));
651
652 g_object_unref (self->priv->called_list_store);
653 g_object_unref (self->priv->called_by_list_store);
654
655 current_block = gprof_call_graph_get_first_block (call_graph, &block_iter);
656
657 /* Rebuild the Functions iter table. This table maps function names to
658 * GtkTreeIters in the functions list to be used by the Jump to buttons
659 * next to the Called and Called by lists. When a user selects a function
660 * in either of these lists, that function should be selected in the
661 * functions list. */
662 if (self->priv->functions_iter_table)
663 g_hash_table_destroy (self->priv->functions_iter_table);
664
665 self->priv->functions_iter_table = g_hash_table_new_full (g_str_hash,
666 g_str_equal, NULL,
667 g_free);
668
669 while (current_block)
670 {
671 primary_entry = gprof_call_graph_block_get_primary_entry (current_block);
672
673 gtk_list_store_append (self->priv->functions_list_store, &list_iter);
674 gtk_list_store_set (self->priv->functions_list_store, &list_iter,
675 FUNCTIONS_COL_NAME,
676 gprof_call_graph_block_entry_get_name (primary_entry),
677 FUNCTIONS_COL_TIME,
678 gprof_call_graph_block_entry_get_time_perc (primary_entry),
679 FUNCTIONS_COL_SELF,
680 gprof_call_graph_block_entry_get_self_sec (primary_entry),
681 FUNCTIONS_COL_CHILDREN,
682 gprof_call_graph_block_entry_get_child_sec (primary_entry),
683 FUNCTIONS_COL_CALLS,
684 gprof_call_graph_block_entry_get_calls (primary_entry),
685 -1);
686
687 if (gprof_call_graph_block_is_recursive (current_block))
688 {
689 gtk_list_store_set (self->priv->functions_list_store, &list_iter,
690 FUNCTIONS_COL_RECURSIVE,
691 GTK_STOCK_REFRESH, -1);
692 }
693
694 /* Add the current iter to the Functions iter lookup table */
695 g_hash_table_insert (self->priv->functions_iter_table,
696 gprof_call_graph_block_entry_get_name (primary_entry),
697 g_memdup (&list_iter, sizeof (GtkTreeIter)));
698
699 current_block = gprof_call_graph_block_get_next (block_iter,
700 &block_iter);
701 }
702
703 gtk_tree_view_set_model (GTK_TREE_VIEW (functions_list_view),
704 GTK_TREE_MODEL (self->priv->functions_list_store));
705
706 g_object_unref (self->priv->functions_list_store);
707
708 /* Set search column on Functions list */
709 gtk_tree_view_set_search_column (GTK_TREE_VIEW (functions_list_view),
710 FUNCTIONS_COL_NAME);
711 }
712
713 GtkWidget *
714 gprof_call_graph_view_get_widget (GProfView *view)
715 {
716 GProfCallGraphView *self;
717
718 self = GPROF_CALL_GRAPH_VIEW (view);
719
720 return glade_xml_get_widget (self->priv->gxml, "call_graph_vbox");
721 }
Anjuta IDE Git Plugin Development Tree