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