?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Check that a given filename is valid before setting it on a GtkFileChooserButton
[anjuta-git-plugin.git] / plugins / symbol-db / symbol-db-view.c
blobf65ab239b18b677c2a05bf533dea1b35409ab7a4
1 /* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 4; tab-width: 4 -*- */
2 /*
3 * anjuta
4 * Copyright (C) Massimo Cora' 2007 <maxcvs@email.it>
5 *
6 * anjuta 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 of the License, or (at your option)
11 * any later version.
12 *
13 * anjuta is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
16 * See the GNU General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License
19 * along with anjuta. If not, write to:
20 * The Free Software Foundation, Inc.,
21 * 51 Franklin Street, Fifth Floor
22 * Boston, MA 02110-1301, USA.
23 */
24
25 #include <glib.h>
26 #include <gdl/gdl-icons.h>
27 #include <libanjuta/resources.h>
28 #include <libanjuta/anjuta-utils.h>
29 #include <libanjuta/anjuta-debug.h>
30 #include "symbol-db-view.h"
31 #include "symbol-db-engine.h"
32 #include "symbol-db-engine-iterator.h"
33 #include "symbol-db-engine-iterator-node.h"
34
35 #define DUMMY_SYMBOL_ID G_MININT32+1
36
37 enum {
38 COLUMN_PIXBUF,
39 COLUMN_NAME,
40 COLUMN_SYMBOL_ID,
41 COLUMN_MAX
42 };
43
44 /* positive ids are used in real database */
45 enum {
46 ROOT_GLOBAL = G_MAXINT32
47 };
48
49 struct _SymbolDBViewPriv
50 {
51 gint insert_handler;
52 gint remove_handler;
53 gint scan_end_handler;
54
55 GtkTreeRowReference *row_ref_global;
56 GTree *nodes_displayed;
57 GTree *waiting_for;
58 GTree *expanding_gfunc_ids;
59 };
60
61 typedef struct _WaitingForSymbol {
62 gint child_symbol_id;
63 gchar *child_symbol_name;
64 const GdkPixbuf *pixbuf;
65
66 } WaitingForSymbol;
67
68 typedef struct _NodeIdleExpand {
69 SymbolDBView *dbv;
70 SymbolDBEngineIterator *iterator;
71 SymbolDBEngine *dbe;
72 GtkTreePath *expanded_path;
73 gint expanded_symbol_id;
74
75 } NodeIdleExpand;
76
77
78 static GtkTreeViewClass *parent_class = NULL;
79 static GHashTable *pixbufs_hash = NULL;
80 static void
81 trigger_on_symbol_inserted (SymbolDBView *dbv, gint symbol_id);
82
83
84 static gint
85 gtree_compare_func (gconstpointer a, gconstpointer b, gpointer user_data)
86 {
87 return (gint)a - (gint)b;
88 }
89
90 static void
91 waiting_for_symbol_destroy (WaitingForSymbol *wfs)
92 {
93 g_return_if_fail (wfs != NULL);
94 g_free (wfs->child_symbol_name);
95 g_free (wfs);
96 }
97
98 static inline gboolean
99 sdb_view_get_iter_from_row_ref (SymbolDBView *dbv, GtkTreeRowReference *row_ref,
100 GtkTreeIter *OUT_iter)
101 {
102 GtkTreePath *path;
103 if (row_ref == NULL)
104 {
105 /* no node displayed found */
106 return FALSE;
107 }
108
109 path = gtk_tree_row_reference_get_path (row_ref);
110 if (path == NULL)
111 {
112 DEBUG_PRINT ("sdb_view_get_iter_from_row_ref (): path is null, something "
113 "went wrong ?!");
114 return FALSE;
115 }
116
117 if (gtk_tree_model_get_iter (gtk_tree_view_get_model (GTK_TREE_VIEW (dbv)),
118 OUT_iter, path) == FALSE)
119 {
120 gtk_tree_path_free (path);
121 return FALSE;
122 }
123 gtk_tree_path_free (path);
124
125 return TRUE;
126 }
127
128
129 static gboolean
130 traverse_free_waiting_for (gpointer key, gpointer value, gpointer data)
131 {
132 if (value == NULL)
133 return FALSE;
134
135 g_slist_foreach ((GSList*)value, (GFunc)waiting_for_symbol_destroy, NULL);
136 g_slist_free ((GSList*)value);
137 return FALSE;
138 }
139
140 void
141 symbol_db_view_clear_cache (SymbolDBView *dbv)
142 {
143 SymbolDBViewPriv *priv;
144 GtkTreeStore *store;
145
146 g_return_if_fail (dbv != NULL);
147
148 priv = dbv->priv;
149
150 store = GTK_TREE_STORE (gtk_tree_view_get_model (GTK_TREE_VIEW (dbv)));
151 if (store != NULL)
152 g_object_unref (store);
153
154 /* this will free alto the priv->row_ref* instances */
155 if (priv->nodes_displayed)
156 {
157 g_tree_destroy (priv->nodes_displayed);
158 priv->nodes_displayed = NULL;
159 }
160
161 /* free the waiting_for structs before destroying the tree itself */
162 if (priv->waiting_for)
163 {
164 g_tree_foreach (priv->waiting_for, traverse_free_waiting_for, NULL);
165 g_tree_destroy (priv->waiting_for);
166 priv->waiting_for = NULL;
167 }
168
169 gtk_tree_view_set_model (GTK_TREE_VIEW (dbv), NULL);
170 }
171
172 static void
173 on_scan_end (SymbolDBEngine *dbe, gpointer data)
174 {
175 SymbolDBView *dbv;
176 SymbolDBViewPriv *priv;
177
178 dbv = SYMBOL_DB_VIEW (data);
179 g_return_if_fail (dbv != NULL);
180 priv = dbv->priv;
181
182 /* void the waiting_for symbols */
183 /* free the waiting_for structs before destroying the tree itself */
184 if (priv->waiting_for)
185 {
186 g_tree_foreach (priv->waiting_for, traverse_free_waiting_for, data);
187 g_tree_destroy (priv->waiting_for);
188
189 /* recreate it because there's a free_all_items function. And the
190 * one proposed by the doc is too complex.. create a list of the items
191 * and reparse them with g_tree_remove...
192 */
193 priv->waiting_for = g_tree_new_full ((GCompareDataFunc)&gtree_compare_func,
194 NULL,
195 NULL,
196 NULL);
197
198 }
199 }
200
201 static inline GtkTreeRowReference *
202 do_add_root_symbol_to_view (SymbolDBView *dbv, const GdkPixbuf *pixbuf,
203 const gchar* symbol_name, gint symbol_id)
204 {
205 SymbolDBViewPriv *priv;
206 GtkTreeStore *store;
207 GtkTreeIter child_iter;
208 GtkTreePath *path;
209 GtkTreeRowReference *row_ref;
210
211 g_return_val_if_fail (dbv != NULL, NULL);
212
213 priv = dbv->priv;
214
215 store = GTK_TREE_STORE (gtk_tree_view_get_model (GTK_TREE_VIEW (dbv)));
216
217 gtk_tree_store_append (store, &child_iter, NULL);
218
219 gtk_tree_store_set (store, &child_iter,
220 COLUMN_PIXBUF, pixbuf,
221 COLUMN_NAME, symbol_name,
222 COLUMN_SYMBOL_ID, symbol_id,
223 -1);
224
225 path = gtk_tree_model_get_path (gtk_tree_view_get_model (GTK_TREE_VIEW (dbv)),
226 &child_iter);
227 row_ref = gtk_tree_row_reference_new (
228 gtk_tree_view_get_model (GTK_TREE_VIEW (dbv)), path);
229 gtk_tree_path_free (path);
230
231 return row_ref;
232 }
233
234 /* before calling this function be sure that parent_symbol_id is already into
235 * nodes_displayed GTree, or this will complain about it and will bail out
236 * with a warning.
237 */
238 static inline GtkTreeRowReference *
239 do_add_child_symbol_to_view (SymbolDBView *dbv, gint parent_symbol_id,
240 const GdkPixbuf *pixbuf, const gchar* symbol_name,
241 gint symbol_id)
242 {
243 SymbolDBViewPriv *priv;
244 GtkTreePath *path;
245 GtkTreeStore *store;
246 GtkTreeIter iter, child_iter;
247 GtkTreeRowReference *row_ref;
248
249 priv = dbv->priv;
250
251 store = GTK_TREE_STORE (gtk_tree_view_get_model (GTK_TREE_VIEW (dbv)));
252
253 /* look up the row ref in the hashtable, then get its associated gtktreeiter */
254 row_ref = g_tree_lookup (priv->nodes_displayed, (gpointer)parent_symbol_id);
255
256 if (sdb_view_get_iter_from_row_ref (dbv, row_ref, &iter) == FALSE)
257 {
258 g_warning ("do_add_symbol_to_view (): something went wrong.");
259 return NULL;
260 }
261
262 /* append a new child &child_iter, with a parent of &iter */
263 gtk_tree_store_append (store, &child_iter, &iter);
264
265 gtk_tree_store_set (store, &child_iter,
266 COLUMN_PIXBUF, pixbuf,
267 COLUMN_NAME, symbol_name,
268 COLUMN_SYMBOL_ID, symbol_id,
269 -1);
270
271 /* grab the row ref and return it */
272 path = gtk_tree_model_get_path (gtk_tree_view_get_model (GTK_TREE_VIEW (dbv)),
273 &child_iter);
274 row_ref = gtk_tree_row_reference_new (gtk_tree_view_get_model (GTK_TREE_VIEW (dbv)),
275 path);
276 gtk_tree_path_free (path);
277 return row_ref;
278 }
279
280
281 static void
282 add_waiting_for_symbol_to_view (SymbolDBView *dbv, WaitingForSymbol *wfs,
283 gint parent_symbol_id)
284 {
285 SymbolDBViewPriv *priv;
286 gint symbol_id_added;
287 GtkTreeRowReference *child_tree_row_ref;
288
289 g_return_if_fail (dbv != NULL);
290 g_return_if_fail (wfs != NULL);
291
292 priv = dbv->priv;
293
294 child_tree_row_ref = do_add_child_symbol_to_view (dbv, parent_symbol_id,
295 wfs->pixbuf, wfs->child_symbol_name, wfs->child_symbol_id);
296
297 symbol_id_added = wfs->child_symbol_id;
298
299 /* add a new entry on gtree 'nodes_displayed' */
300 g_tree_insert (priv->nodes_displayed, (gpointer)wfs->child_symbol_id,
301 child_tree_row_ref);
302
303 /* and now trigger the inserted symbol... (recursive function). */
304 if (wfs->child_symbol_id != parent_symbol_id)
305 trigger_on_symbol_inserted (dbv, wfs->child_symbol_id);
306 }
307
308
309 static void
310 trigger_on_symbol_inserted (SymbolDBView *dbv, gint symbol_id)
311 {
312 SymbolDBViewPriv *priv;
313 GSList *slist;
314 WaitingForSymbol *wfs;
315
316 g_return_if_fail (dbv != NULL);
317
318 priv = dbv->priv;
319
320 /* DEBUG_PRINT ("trigger_on_symbol_inserted (): triggering %d", symbol_id);*/
321
322 /* try to find a waiting for symbol */
323 slist = g_tree_lookup (priv->waiting_for, (gpointer)symbol_id);
324
325 if (slist == NULL)
326 {
327 /* nothing waiting for us */
328 /*DEBUG_PRINT ("trigger_on_symbol_inserted (): no children waiting for us...");*/
329 return;
330 }
331 else {
332 gint i;
333 gint length = g_slist_length (slist);
334
335 /* DEBUG_PRINT ("trigger_on_symbol_inserted (): consuming slist for parent %d",
336 symbol_id);*/
337
338 for (i=0; i < length-1; i++)
339 {
340 wfs = g_slist_nth_data (slist, 0);
341
342 slist = g_slist_remove (slist, wfs);
343
344 add_waiting_for_symbol_to_view (dbv, wfs, symbol_id);
345
346 /* destroy the data structure */
347 waiting_for_symbol_destroy (wfs);
348 }
349
350 /* remove the waiting for key/value */
351 g_tree_remove (priv->waiting_for, (gpointer)symbol_id);
352 g_slist_free (slist);
353 }
354 }
355
356
357 static void
358 add_new_waiting_for (SymbolDBView *dbv, gint parent_symbol_id,
359 const gchar* symbol_name,
360 gint symbol_id, const GdkPixbuf *pixbuf)
361 {
362 SymbolDBViewPriv *priv;
363 gpointer node;
364
365 g_return_if_fail (dbv != NULL);
366 priv = dbv->priv;
367
368 /* check if we already have some children waiting for a
369 * specific father to be inserted, then add this symbol_id to the list
370 * (or create a new one)
371 */
372 WaitingForSymbol *wfs;
373
374 wfs = g_new0 (WaitingForSymbol, 1);
375 wfs->child_symbol_id = symbol_id;
376 wfs->child_symbol_name = g_strdup (symbol_name);
377 wfs->pixbuf = pixbuf;
378
379 node = g_tree_lookup (priv->waiting_for, (gpointer)parent_symbol_id);
380 if (node == NULL)
381 {
382 /* no lists already set. Create one. */
383 GSList *slist;
384 slist = g_slist_alloc ();
385
386 slist = g_slist_prepend (slist, wfs);
387
388 /* add it to the binary tree. */
389 g_tree_insert (priv->waiting_for, (gpointer)parent_symbol_id,
390 slist);
391 }
392 else
393 {
394 /* found a list */
395 GSList *slist;
396 slist = (GSList*)node;
397
398 slist = g_slist_prepend (slist, wfs);
399
400 g_tree_replace (priv->waiting_for, (gpointer)parent_symbol_id,
401 slist);
402 }
403 }
404
405
406 /* Put every GtkTreeView node of the subtree headed by 'parent_subtree_iter'
407 * into a waiting_for GTree.
408 * It's a recursive function.
409 */
410 static void
411 do_recurse_subtree_and_invalidate (SymbolDBView *dbv,
412 GtkTreeIter *parent_subtree_iter,
413 gint parent_id_to_wait_for)
414 {
415 gint curr_symbol_id;
416 const GdkPixbuf *curr_pixbuf;
417 GtkTreeStore *store;
418 gchar *curr_symbol_name;
419
420 SymbolDBViewPriv *priv;
421
422 g_return_if_fail (dbv != NULL);
423
424 priv = dbv->priv;
425 store = GTK_TREE_STORE (gtk_tree_view_get_model (GTK_TREE_VIEW (dbv)));
426
427 gtk_tree_model_get (GTK_TREE_MODEL (store), parent_subtree_iter,
428 COLUMN_SYMBOL_ID, &curr_symbol_id,
429 COLUMN_PIXBUF, &curr_pixbuf,
430 COLUMN_NAME, &curr_symbol_name, /* no strdup required */
431 -1);
432
433 /*DEBUG_PRINT ("do_recurse_subtree_and_invalidate (): curr_symbol_id %d,"
434 "parent_id_to_wait_for %d", curr_symbol_id, parent_id_to_wait_for);*/
435
436 while (gtk_tree_model_iter_has_child (GTK_TREE_MODEL (store),
437 parent_subtree_iter))
438 {
439 GtkTreeIter child;
440 gtk_tree_model_iter_children (GTK_TREE_MODEL (store), &child,
441 parent_subtree_iter);
442
443 /* recurse */
444 do_recurse_subtree_and_invalidate (dbv, &child, curr_symbol_id);
445 }
446
447 /* add to waiting for */
448 add_new_waiting_for (dbv, parent_id_to_wait_for, curr_symbol_name,
449 curr_symbol_id, curr_pixbuf);
450
451 gtk_tree_store_remove (store, parent_subtree_iter);
452 g_tree_remove (priv->nodes_displayed, (gpointer) curr_symbol_id);
453
454 /* don't forget to free this gchar */
455 g_free (curr_symbol_name);
456 }
457
458 /* Add promptly a symbol to the gtktreeview or add it for a later add (waiting
459 * for trigger).
460 */
461 static void
462 prepare_for_adding (SymbolDBView *dbv, gint parent_symbol_id,
463 const gchar* symbol_name, gint symbol_id,
464 const GdkPixbuf *pixbuf, const gchar* kind)
465 {
466 SymbolDBViewPriv *priv;
467
468 g_return_if_fail (dbv != NULL);
469 g_return_if_fail (kind != NULL);
470 priv = dbv->priv;
471
472 /* add to root if parent_symbol_id is <= 0 */
473 if (parent_symbol_id <= 0)
474 {
475 GtkTreeRowReference *curr_tree_row_ref = NULL;
476
477 /* ok, let's check the kind of the symbol. Based on that we'll retrieve
478 * the row_ref. It's quicker to check onlyl the first char than the whole
479 * string.
480 */
481 switch (kind[0])
482 {
483 case 'n': /* namespace */
484 curr_tree_row_ref = do_add_root_symbol_to_view (dbv,
485 pixbuf,
486 symbol_name,
487 symbol_id);
488 break;
489
490 case 'c': /* class */
491 case 's': /* struct */
492 curr_tree_row_ref = do_add_child_symbol_to_view (dbv,
493 ROOT_GLOBAL, pixbuf, symbol_name,
494 symbol_id);
495 break;
496
497 case 'u': /* union */
498 case 'f': /* function */
499 case 'v': /* variable */
500 case 't': /* typedef */
501 case 'e': /* enumerator */
502 default:
503 {
504 gpointer node;
505 /* Vars/Other may not be displayed already. Check it. */
506 node = g_tree_lookup (priv->nodes_displayed, (gpointer)-ROOT_GLOBAL);
507
508 if (node != NULL)
509 {
510 /* hey we found it */
511 /* note the negative: we'll store these under the vars/Other node */
512 curr_tree_row_ref = do_add_child_symbol_to_view (dbv,
513 -ROOT_GLOBAL, pixbuf, symbol_name,
514 symbol_id);
515 }
516 else
517 {
518 /* add it to the waiting_for trigger list */
519 add_new_waiting_for (dbv, parent_symbol_id, symbol_name, symbol_id,
520 pixbuf);
521 }
522 break;
523 }
524 }
525
526 if (curr_tree_row_ref == NULL)
527 {
528 return;
529 }
530
531 /* we'll fake the gpointer to store an int */
532 g_tree_insert (priv->nodes_displayed, (gpointer)symbol_id,
533 curr_tree_row_ref);
534
535 /* let's trigger the insertion of the symbol_id, there may be some children
536 * waiting for it.
537 */
538 trigger_on_symbol_inserted (dbv, symbol_id);
539 }
540 else
541 {
542 gpointer node;
543
544 switch (kind[0])
545 {
546 case 'u': /* union */
547 case 'f': /* function */
548 case 'v': /* variable */
549 case 't': /* typedef */
550 case 'e': /* enumerator */
551 /* switch to negative! i.e. schedule to put it under the
552 * Vars/Others node
553 */
554 parent_symbol_id = -parent_symbol_id;
555 break;
556 default: /* let it as it is */
557 break;
558 }
559
560
561 /* do we already have that parent_symbol displayed in gtktreeview?
562 * If that's the case add it as children.
563 */
564 node = g_tree_lookup (priv->nodes_displayed, (gpointer)parent_symbol_id);
565
566 if (node != NULL)
567 {
568 /* hey we found it */
569 GtkTreeRowReference *child_row_ref;
570 child_row_ref = do_add_child_symbol_to_view (dbv, parent_symbol_id,
571 pixbuf, symbol_name, symbol_id);
572
573 /* add the children_path to the GTree. */
574 g_tree_insert (priv->nodes_displayed, (gpointer)symbol_id,
575 child_row_ref);
576 trigger_on_symbol_inserted (dbv, symbol_id);
577 }
578 else
579 {
580 /* add it to the waiting_for trigger list */
581 add_new_waiting_for (dbv, parent_symbol_id, symbol_name, symbol_id,
582 pixbuf);
583 }
584 }
585 }
586
587 static void
588 on_symbol_inserted (SymbolDBEngine *dbe,
589 gint symbol_id, gpointer data)
590 {
591 SymbolDBEngineIterator *iterator;
592 GtkTreeStore *store;
593
594 /* it's not obligatory referred to a class inheritance */
595 gint parent_symbol_id;
596 SymbolDBView *dbv;
597 SymbolDBViewPriv *priv;
598
599 dbv = SYMBOL_DB_VIEW (data);
600
601 g_return_if_fail (dbv != NULL);
602
603 priv = dbv->priv;
604
605 /*DEBUG_PRINT ("on_symbol_inserted -global- %d", symbol_id);*/
606 store = GTK_TREE_STORE (gtk_tree_view_get_model (GTK_TREE_VIEW (dbv)));
607
608 parent_symbol_id = symbol_db_engine_get_parent_scope_id_by_symbol_id (dbe,
609 symbol_id,
610 NULL);
611
612 /*DEBUG_PRINT ("on_symbol_inserted parent_symbol_id detected %d", parent_symbol_id);*/
613
614 /* get the original symbol infos */
615 iterator = symbol_db_engine_get_symbol_info_by_id (dbe, symbol_id,
616 SYMINFO_SIMPLE |
617 SYMINFO_ACCESS |
618 SYMINFO_KIND);
619
620 if (iterator != NULL)
621 {
622 SymbolDBEngineIteratorNode *iter_node;
623 const GdkPixbuf *pixbuf;
624 const gchar* symbol_name;
625 const gchar* symbol_kind;
626 const gchar* symbol_access;
627 SymbolDBEngineIterator *iterator_for_children;
628
629 iter_node = SYMBOL_DB_ENGINE_ITERATOR_NODE (iterator);
630
631 /* check if what we want to add is on a global_scope and not only a local
632 * file scope e.g. static functions
633 */
634 if (symbol_db_engine_iterator_node_get_symbol_is_file_scope (iter_node) == TRUE)
635 {
636 /* DEBUG_PRINT ("on_symbol_inserted() -global- symbol %d is not global scope",
637 symbol_id);*/
638 g_object_unref (iterator);
639 return;
640 }
641
642 symbol_kind = symbol_db_engine_iterator_node_get_symbol_extra_string (
643 iter_node, SYMINFO_KIND);
644
645 symbol_access = symbol_db_engine_iterator_node_get_symbol_extra_string (
646 iter_node, SYMINFO_ACCESS);
647
648 pixbuf = symbol_db_view_get_pixbuf (symbol_kind, symbol_access);
649 symbol_name = symbol_db_engine_iterator_node_get_symbol_name (iter_node);
650
651 /* check if one of the children [if they exist] of symbol_id are already
652 * displayed. In that case we'll invalidate all of them.
653 * i.e. we're in an updating insertion.
654 */
655 iterator_for_children =
656 symbol_db_engine_get_scope_members_by_symbol_id (dbe, symbol_id, -1,
657 -1,
658 SYMINFO_SIMPLE);
659
660 if (iterator_for_children == NULL)
661 {
662 /* we don't have children */
663 }
664 else
665 {
666 /* hey there are some children here.. kill 'em all and put them on
667 * a waiting_for list
668 */
669 do
670 {
671 gint curr_child_id;
672 GtkTreeIter child_iter;
673 GtkTreeRowReference *row_ref;
674 SymbolDBEngineIteratorNode *iter_node;
675
676 iter_node = SYMBOL_DB_ENGINE_ITERATOR_NODE (iterator_for_children);
677
678 curr_child_id =
679 symbol_db_engine_iterator_node_get_symbol_id (iter_node);
680
681 row_ref = g_tree_lookup (priv->nodes_displayed,
682 (gpointer)curr_child_id);
683 if (row_ref == NULL)
684 continue;
685
686 if (sdb_view_get_iter_from_row_ref (dbv, row_ref, &child_iter) == FALSE)
687 {
688 /* no node displayed found */
689 g_warning ("on_symbol_inserted (): row_ref something went wrong ?!");
690 continue;
691 }
692
693 /* put on waiting_for the subtree */
694 do_recurse_subtree_and_invalidate (dbv, &child_iter, symbol_id);
695 } while (symbol_db_engine_iterator_move_next (iterator_for_children)
696 == TRUE);
697
698 g_object_unref (iterator_for_children);
699 }
700
701 prepare_for_adding (dbv, parent_symbol_id, symbol_name, symbol_id, pixbuf,
702 symbol_kind);
703 g_object_unref (iterator);
704 }
705 }
706
707 static void
708 do_recurse_subtree_and_remove (SymbolDBView *dbv,
709 GtkTreeIter *parent_subtree_iter)
710 {
711 gint curr_symbol_id;
712 const GdkPixbuf *curr_pixbuf;
713 GtkTreeStore *store;
714 gchar *curr_symbol_name;
715
716 SymbolDBViewPriv *priv;
717
718 g_return_if_fail (dbv != NULL);
719
720 priv = dbv->priv;
721 store = GTK_TREE_STORE (gtk_tree_view_get_model (GTK_TREE_VIEW (dbv)));
722
723 gtk_tree_model_get (GTK_TREE_MODEL (store), parent_subtree_iter,
724 COLUMN_SYMBOL_ID, &curr_symbol_id,
725 COLUMN_PIXBUF, &curr_pixbuf,
726 COLUMN_NAME, &curr_symbol_name, /* no strdup required */
727 -1);
728
729 while (gtk_tree_model_iter_has_child (GTK_TREE_MODEL (store), parent_subtree_iter))
730 {
731 GtkTreeIter child;
732 gtk_tree_model_iter_children (GTK_TREE_MODEL (store), &child, parent_subtree_iter);
733
734 /* recurse */
735 do_recurse_subtree_and_remove (dbv, &child);
736 }
737
738 gtk_tree_store_remove (store, parent_subtree_iter);
739 g_tree_remove (priv->nodes_displayed, (gpointer) curr_symbol_id);
740
741 /* don't forget to free this gchar */
742 g_free (curr_symbol_name);
743 }
744
745
746 static void
747 on_symbol_removed (SymbolDBEngine *dbe, gint symbol_id, gpointer data)
748 {
749 GtkTreeStore *store;
750 SymbolDBView *dbv;
751 SymbolDBViewPriv *priv;
752 GtkTreeIter iter;
753 GtkTreeRowReference *row_ref;
754
755 dbv = SYMBOL_DB_VIEW (data);
756
757 g_return_if_fail (dbv != NULL);
758 priv = dbv->priv;
759
760 store = GTK_TREE_STORE (gtk_tree_view_get_model (GTK_TREE_VIEW (dbv)));
761
762 DEBUG_PRINT ("on_symbol_removed (): -global- %d", symbol_id);
763
764 row_ref = g_tree_lookup (priv->nodes_displayed, (gpointer)symbol_id);
765 if (sdb_view_get_iter_from_row_ref (dbv, row_ref, &iter) == FALSE)
766 {
767 return;
768 }
769
770 do_recurse_subtree_and_remove (dbv, &iter);
771 }
772
773 /**
774 * Add at most ONE dummy child to the parent_iter. This is done to let the parent_iter
775 * node be expandable.
776 * @param force If true a dummy symbol will be added even if it has no children on db.
777 */
778 static void
779 sdb_view_do_add_hidden_dummy_child (SymbolDBView *dbv, SymbolDBEngine *dbe,
780 GtkTreeIter *parent_iter, gint parent_symbol_id,
781 gboolean force)
782 {
783 SymbolDBEngineIterator *child_iterator;
784 GtkTreeStore *store;
785 SymbolDBViewPriv *priv;
786
787 g_return_if_fail (dbv != NULL);
788 priv = dbv->priv;
789
790 store = GTK_TREE_STORE (gtk_tree_view_get_model (GTK_TREE_VIEW (dbv)));
791 child_iterator = symbol_db_engine_get_scope_members_by_symbol_id (dbe,
792 parent_symbol_id,
793 1,
794 -1,
795 SYMINFO_SIMPLE | SYMINFO_ACCESS | SYMINFO_KIND);
796
797 if (child_iterator != NULL || force == TRUE)
798 {
799 /* hey we have something here... */
800 GtkTreeIter child_iter;
801
802 gtk_tree_store_append (store, &child_iter, parent_iter);
803 gtk_tree_store_set (store, &child_iter,
804 COLUMN_PIXBUF, NULL,
805 COLUMN_NAME, _("Loading..."),
806 COLUMN_SYMBOL_ID, DUMMY_SYMBOL_ID,
807 -1);
808
809 if (child_iterator)
810 g_object_unref (child_iterator);
811 }
812 }
813
814 static void
815 sdb_view_row_expanded_idle_destroy (gpointer data)
816 {
817 NodeIdleExpand *node_expand;
818 SymbolDBView *dbv;
819 SymbolDBEngine *dbe;
820
821 g_return_if_fail (data != NULL);
822 node_expand = data;
823 DEBUG_PRINT ("sdb_view_global_row_expanded_idle_destroy ()");
824 dbv = node_expand->dbv;
825 dbe = node_expand->dbe;
826
827 /* remove from the GTree the ids of the func expanding */
828 g_tree_remove (dbv->priv->expanding_gfunc_ids,
829 (gpointer)node_expand->expanded_symbol_id);
830
831 if (node_expand->expanded_path != NULL) {
832 gtk_tree_path_free (node_expand->expanded_path);
833 node_expand->expanded_path = NULL;
834 }
835 g_object_unref (node_expand->iterator);
836 node_expand->iterator = NULL;
837 g_free (node_expand);
838 }
839
840 static gboolean
841 sdb_view_row_expanded_idle (gpointer data)
842 {
843 NodeIdleExpand *node_expand;
844 SymbolDBView *dbv;
845 SymbolDBEngine *dbe;
846 SymbolDBEngineIterator *iterator;
847 const GdkPixbuf *pixbuf;
848 const gchar* symbol_name;
849 const gchar* symbol_kind;
850 const gchar* symbol_access;
851 GtkTreeIter iter;
852 gint curr_symbol_id;
853 SymbolDBEngineIteratorNode *iter_node;
854 gpointer node;
855 GtkTreeRowReference *curr_tree_row_ref;
856 SymbolDBViewPriv *priv;
857
858 node_expand = data;
859
860 dbv = node_expand->dbv;
861 iterator = node_expand->iterator;
862 dbe = node_expand->dbe;
863 priv = dbv->priv;
864
865 if (iterator == NULL)
866 return FALSE;
867
868 iter_node = SYMBOL_DB_ENGINE_ITERATOR_NODE (iterator);
869 curr_symbol_id = symbol_db_engine_iterator_node_get_symbol_id (iter_node);
870 node = g_tree_lookup (priv->nodes_displayed, (gpointer)curr_symbol_id);
871
872 if (node != NULL)
873 {
874 /* already displayed */
875 return symbol_db_engine_iterator_move_next (iterator);
876 }
877
878 symbol_name = symbol_db_engine_iterator_node_get_symbol_name (iter_node);
879 symbol_kind = symbol_db_engine_iterator_node_get_symbol_extra_string (iter_node,
880 SYMINFO_KIND);
881 symbol_access = symbol_db_engine_iterator_node_get_symbol_extra_string (iter_node,
882 SYMINFO_ACCESS);
883 pixbuf = symbol_db_view_get_pixbuf (symbol_kind, symbol_access);
884
885 curr_tree_row_ref = do_add_child_symbol_to_view (dbv,
886 node_expand->expanded_symbol_id, pixbuf,
887 symbol_name, curr_symbol_id);
888 if (curr_tree_row_ref == NULL)
889 {
890 return symbol_db_engine_iterator_move_next (iterator);
891 }
892
893 /* we'll fake the gpointer to store an int */
894 g_tree_insert (priv->nodes_displayed, (gpointer)curr_symbol_id,
895 curr_tree_row_ref);
896
897 sdb_view_get_iter_from_row_ref (dbv, curr_tree_row_ref, &iter);
898
899 /* check for children about this node... */
900 sdb_view_do_add_hidden_dummy_child (dbv, dbe, &iter, curr_symbol_id,
901 FALSE);
902
903 if (node_expand->expanded_path != NULL)
904 {
905 gtk_tree_view_expand_row (GTK_TREE_VIEW (dbv),
906 node_expand->expanded_path,
907 FALSE);
908 gtk_tree_path_free (node_expand->expanded_path);
909 node_expand->expanded_path = NULL;
910 }
911
912 if (symbol_db_engine_iterator_move_next (iterator) == TRUE)
913 {
914 return TRUE;
915 }
916 else {
917 if (g_tree_lookup (priv->nodes_displayed,
918 (gpointer)-node_expand->expanded_symbol_id) == NULL)
919 {
920 GtkTreeRowReference *others_row_ref;
921 GtkTreeIter others_dummy_node;
922 others_row_ref = do_add_child_symbol_to_view (dbv,
923 node_expand->expanded_symbol_id,
924 symbol_db_view_get_pixbuf ("vars", "others"),
925 "Vars/Others",
926 -node_expand->expanded_symbol_id);
927
928 /* insert a negative node ... */
929 g_tree_insert (priv->nodes_displayed,
930 (gpointer)-node_expand->expanded_symbol_id,
931 others_row_ref);
932
933 /* ... and a dummy child */
934 sdb_view_get_iter_from_row_ref (dbv, others_row_ref, &others_dummy_node);
935
936 sdb_view_do_add_hidden_dummy_child (dbv, dbe, &others_dummy_node, 0,
937 TRUE);
938 }
939
940 return FALSE;
941 }
942 }
943
944 static void
945 sdb_view_namespace_row_expanded (SymbolDBView *dbv, SymbolDBEngine *dbe,
946 GtkTreeIter *expanded_iter, gint expanded_symbol_id)
947 {
948 SymbolDBViewPriv *priv;
949 SymbolDBEngineIterator *iterator;
950 GtkTreeStore *store;
951 GPtrArray *filter_array;
952 gpointer node;
953
954 g_return_if_fail (dbv != NULL);
955 priv = dbv->priv;
956
957 store = GTK_TREE_STORE (gtk_tree_view_get_model (GTK_TREE_VIEW (dbv)));
958
959 DEBUG_PRINT ("sdb_view_namespace_row_expanded ");
960
961 /* check if there's another expanding idle_func running */
962 node = g_tree_lookup (priv->expanding_gfunc_ids, (gpointer)expanded_symbol_id);
963 if (node != NULL)
964 {
965 return;
966 }
967
968 filter_array = g_ptr_array_new ();
969 g_ptr_array_add (filter_array, "class");
970 g_ptr_array_add (filter_array, "struct");
971
972 /* get results from database */
973 iterator = symbol_db_engine_get_scope_members_by_symbol_id_filtered (dbe,
974 expanded_symbol_id,
975 filter_array,
976 TRUE,
977 -1,
978 -1,
979 SYMINFO_SIMPLE| SYMINFO_KIND| SYMINFO_ACCESS
980 );
981
982 g_ptr_array_free (filter_array, TRUE);
983
984 if (iterator != NULL)
985 {
986 NodeIdleExpand *node_expand;
987 gint idle_id;
988
989 node_expand = g_new0 (NodeIdleExpand, 1);
990
991 node_expand->dbv = dbv;
992 node_expand->iterator = iterator;
993 node_expand->dbe = dbe;
994 node_expand->expanded_path =
995 gtk_tree_model_get_path (gtk_tree_view_get_model (GTK_TREE_VIEW (dbv)),
996 expanded_iter);
997 node_expand->expanded_symbol_id = expanded_symbol_id;
998
999 /* be sure that the expanding process doesn't freeze the gui */
1000 idle_id = g_idle_add_full (G_PRIORITY_LOW,
1001 (GSourceFunc) sdb_view_row_expanded_idle,
1002 (gpointer) node_expand,
1003 (GDestroyNotify) sdb_view_row_expanded_idle_destroy);
1004
1005 /* insert the idle_id into a g_tree */
1006 g_tree_insert (priv->expanding_gfunc_ids, (gpointer)expanded_symbol_id,
1007 (gpointer)idle_id);
1008 }
1009 }
1010
1011
1012 static void
1013 sdb_view_global_row_expanded (SymbolDBView *dbv, SymbolDBEngine *dbe,
1014 GtkTreeIter *expanded_iter, gint expanded_symbol_id)
1015 {
1016 GtkTreeStore *store;
1017 SymbolDBViewPriv *priv;
1018 SymbolDBEngineIterator *iterator;
1019 GPtrArray *filter_array;
1020 gpointer node;
1021 g_return_if_fail (dbv != NULL);
1022
1023 priv = dbv->priv;
1024
1025 store = GTK_TREE_STORE (gtk_tree_view_get_model (GTK_TREE_VIEW (dbv)));
1026
1027 filter_array = g_ptr_array_new ();
1028 g_ptr_array_add (filter_array, "class");
1029 g_ptr_array_add (filter_array, "struct");
1030
1031 DEBUG_PRINT ("sdb_view_global_row_expanded ()");
1032
1033 /* check if there's another expanding idle_func running */
1034 node = g_tree_lookup (priv->expanding_gfunc_ids, (gpointer)expanded_symbol_id);
1035 if (node != NULL)
1036 {
1037 return;
1038 }
1039
1040 /* check for the presence of namespaces.
1041 * If that's the case then populate the root with a 'Global' node.
1042 */
1043 iterator = symbol_db_engine_get_global_members_filtered (dbe, filter_array, TRUE,
1044 TRUE,
1045 -1,
1046 -1,
1047 SYMINFO_SIMPLE |
1048 SYMINFO_ACCESS |
1049 SYMINFO_KIND);
1050 g_ptr_array_free (filter_array, TRUE);
1051
1052 if (iterator != NULL)
1053 {
1054 NodeIdleExpand *node_expand;
1055 gint idle_id;
1056
1057 node_expand = g_new0 (NodeIdleExpand, 1);
1058
1059 node_expand->dbv = dbv;
1060 node_expand->iterator = iterator;
1061 node_expand->dbe = dbe;
1062 node_expand->expanded_path = gtk_tree_model_get_path (
1063 gtk_tree_view_get_model (GTK_TREE_VIEW (dbv)),
1064 expanded_iter);
1065 node_expand->expanded_symbol_id = expanded_symbol_id;
1066
1067 idle_id = g_idle_add_full (G_PRIORITY_LOW,
1068 (GSourceFunc) sdb_view_row_expanded_idle,
1069 (gpointer) node_expand,
1070 (GDestroyNotify) sdb_view_row_expanded_idle_destroy);
1071
1072 /* insert the idle_id into a g_tree for (eventually) a later retrieval */
1073 DEBUG_PRINT ("Inserting into g_tree expanded_symbol_id %d and idle_id %d",
1074 expanded_symbol_id, idle_id);
1075 g_tree_insert (priv->expanding_gfunc_ids, (gpointer)expanded_symbol_id,
1076 (gpointer)idle_id);
1077 }
1078 }
1079
1080 static void
1081 sdb_view_vars_row_expanded (SymbolDBView *dbv, SymbolDBEngine *dbe,
1082 GtkTreeIter *expanded_iter, gint expanded_symbol_id)
1083 {
1084 SymbolDBViewPriv *priv;
1085 SymbolDBEngineIterator *iterator;
1086 GtkTreeStore *store;
1087 GPtrArray *filter_array;
1088 gint positive_symbol_expanded;
1089 gpointer node;
1090
1091 g_return_if_fail (dbv != NULL);
1092 priv = dbv->priv;
1093
1094 positive_symbol_expanded = -expanded_symbol_id;
1095 store = GTK_TREE_STORE (gtk_tree_view_get_model (GTK_TREE_VIEW (dbv)));
1096
1097 DEBUG_PRINT ("sdb_view_vars_row_expanded ()");
1098
1099 /* check if there's another expanding idle_func running */
1100 node = g_tree_lookup (priv->expanding_gfunc_ids, (gpointer)expanded_symbol_id);
1101 if (node != NULL)
1102 {
1103 return;
1104 }
1105
1106 filter_array = g_ptr_array_new ();
1107 g_ptr_array_add (filter_array, "class");
1108 g_ptr_array_add (filter_array, "struct");
1109
1110 if (positive_symbol_expanded == ROOT_GLOBAL)
1111 {
1112 iterator = symbol_db_engine_get_global_members_filtered (dbe, filter_array,
1113 FALSE,
1114 TRUE,
1115 -1,
1116 -1,
1117 SYMINFO_SIMPLE |
1118 SYMINFO_ACCESS |
1119 SYMINFO_KIND);
1120 }
1121 else
1122 {
1123 iterator = symbol_db_engine_get_scope_members_by_symbol_id_filtered (dbe,
1124 positive_symbol_expanded,
1125 filter_array,
1126 FALSE,
1127 -1,
1128 -1,
1129 SYMINFO_SIMPLE|
1130 SYMINFO_KIND|
1131 SYMINFO_ACCESS
1132 );
1133 }
1134
1135 g_ptr_array_free (filter_array, TRUE);
1136
1137 if (iterator != NULL)
1138 {
1139 NodeIdleExpand *node_expand;
1140 gint idle_id;
1141
1142 node_expand = g_new0 (NodeIdleExpand, 1);
1143
1144 node_expand->dbv = dbv;
1145 node_expand->iterator = iterator;
1146 node_expand->dbe = dbe;
1147 node_expand->expanded_path = gtk_tree_model_get_path (
1148 gtk_tree_view_get_model (GTK_TREE_VIEW (dbv)),
1149 expanded_iter);
1150 node_expand->expanded_symbol_id = expanded_symbol_id;
1151
1152 idle_id = g_idle_add_full (G_PRIORITY_LOW,
1153 (GSourceFunc) sdb_view_row_expanded_idle,
1154 (gpointer) node_expand,
1155 (GDestroyNotify) sdb_view_row_expanded_idle_destroy);
1156
1157 /* insert the idle_id into a g_tree */
1158 g_tree_insert (priv->expanding_gfunc_ids, (gpointer)expanded_symbol_id,
1159 (gpointer)idle_id);
1160 }
1161 }
1162
1163 /**
1164 * Usually on a row expanded event we should perform the following steps:
1165 * 1. retrieve a list of scoped children.
1166 * 2. check if the nth children has already been displayed or not.
1167 * 3. if it isn't then append a child *and* check if that child has children itself.
1168 * using a dummy node we can achieve a performant population while setting an expand
1169 * mark on the child firstly appended.
1170 */
1171 void
1172 symbol_db_view_row_expanded (SymbolDBView *dbv, SymbolDBEngine *dbe,
1173 GtkTreeIter *expanded_iter)
1174 {
1175 GtkTreeStore *store;
1176 gint expanded_symbol_id;
1177 SymbolDBViewPriv *priv;
1178 SymbolDBEngineIterator *iterator;
1179 GtkTreePath *path;
1180
1181 g_return_if_fail (dbv != NULL);
1182 priv = dbv->priv;
1183
1184 store = GTK_TREE_STORE (gtk_tree_view_get_model (GTK_TREE_VIEW (dbv)));
1185
1186 gtk_tree_model_get (GTK_TREE_MODEL (store), expanded_iter,
1187 COLUMN_SYMBOL_ID, &expanded_symbol_id, -1);
1188
1189 /* remove the dummy item, if present */
1190 if (gtk_tree_model_iter_has_child (GTK_TREE_MODEL (store), expanded_iter))
1191 {
1192 GtkTreeIter child;
1193 gint dummy_symbol;
1194 gtk_tree_model_iter_children (GTK_TREE_MODEL (store), &child, expanded_iter);
1195
1196 gtk_tree_model_get (GTK_TREE_MODEL (store), &child,
1197 COLUMN_SYMBOL_ID, &dummy_symbol, -1);
1198
1199 if (dummy_symbol == DUMMY_SYMBOL_ID)
1200 gtk_tree_store_remove (store, &child);
1201 }
1202
1203 /* Ok. Is the expanded node a 'namespace' one? A 'global' one? Or a
1204 * 'vars/etc' one? parse here the cases and if we're not there
1205 * go on with a classic expanding node algo.
1206 */
1207
1208 /* Case Global */
1209 if (expanded_symbol_id == ROOT_GLOBAL)
1210 {
1211 sdb_view_global_row_expanded (dbv, dbe, expanded_iter, expanded_symbol_id);
1212 return;
1213 }
1214
1215 /* Case vars/etc */
1216 /* To identify a vars/etc node we'll check if the expanded_symbol_id is negative.
1217 * If yes, we can have the parent namespace by making the id positive.
1218 */
1219 if (expanded_symbol_id < 0)
1220 {
1221 sdb_view_vars_row_expanded (dbv, dbe, expanded_iter, expanded_symbol_id);
1222 return;
1223 }
1224
1225
1226 /* Case namespace */
1227 iterator = symbol_db_engine_get_symbol_info_by_id (dbe, expanded_symbol_id,
1228 SYMINFO_KIND);
1229 if (iterator != NULL)
1230 {
1231 SymbolDBEngineIteratorNode *iter_node;
1232 const gchar* symbol_kind;
1233
1234 iter_node = SYMBOL_DB_ENGINE_ITERATOR_NODE (iterator);
1235 symbol_kind = symbol_db_engine_iterator_node_get_symbol_extra_string (
1236 iter_node, SYMINFO_KIND);
1237 if (strcmp (symbol_kind, "namespace") == 0)
1238 {
1239 sdb_view_namespace_row_expanded (dbv, dbe, expanded_iter,
1240 expanded_symbol_id);
1241 g_object_unref (iterator);
1242 return;
1243 }
1244 g_object_unref (iterator);
1245 }
1246
1247 /* Case Normal: go on with usual expanding */
1248 DEBUG_PRINT ("symbol_db_view_row_expanded (): expanded %d", expanded_symbol_id);
1249
1250 /* Step 1 */
1251 iterator = symbol_db_engine_get_scope_members_by_symbol_id (dbe,
1252 expanded_symbol_id,
1253 -1,
1254 -1,
1255 SYMINFO_SIMPLE|
1256 SYMINFO_KIND|
1257 SYMINFO_ACCESS);
1258
1259 if (iterator != NULL)
1260 {
1261 do {
1262 gint curr_symbol_id;
1263 SymbolDBEngineIteratorNode *iter_node;
1264 const GdkPixbuf *pixbuf;
1265 const gchar* symbol_name;
1266 GtkTreeIter child_iter;
1267 GtkTreePath *path;
1268 GtkTreeRowReference *child_row_ref;
1269 gpointer node;
1270
1271 iter_node = SYMBOL_DB_ENGINE_ITERATOR_NODE (iterator);
1272
1273 curr_symbol_id = symbol_db_engine_iterator_node_get_symbol_id (iter_node);
1274
1275 /* Step 2:
1276 * check if the curr_symbol_id is already displayed. In that case
1277 * skip to the next symbol
1278 */
1279 node = g_tree_lookup (priv->nodes_displayed, (gpointer)curr_symbol_id);
1280
1281 if (node != NULL)
1282 {
1283 continue;
1284 }
1285
1286 /* Step 3 */
1287 /* ok we must display this symbol */
1288 pixbuf = symbol_db_view_get_pixbuf (
1289 symbol_db_engine_iterator_node_get_symbol_extra_string (
1290 iter_node, SYMINFO_KIND),
1291 symbol_db_engine_iterator_node_get_symbol_extra_string (
1292 iter_node, SYMINFO_ACCESS));
1293
1294 symbol_name = symbol_db_engine_iterator_node_get_symbol_name (iter_node);
1295
1296 gtk_tree_store_append (store, &child_iter, expanded_iter);
1297
1298 gtk_tree_store_set (store, &child_iter,
1299 COLUMN_PIXBUF, pixbuf,
1300 COLUMN_NAME, symbol_name,
1301 COLUMN_SYMBOL_ID, curr_symbol_id,
1302 -1);
1303
1304 path = gtk_tree_model_get_path (gtk_tree_view_get_model (GTK_TREE_VIEW (dbv)),
1305 &child_iter);
1306 child_row_ref = gtk_tree_row_reference_new (
1307 gtk_tree_view_get_model (GTK_TREE_VIEW (dbv)), path);
1308 gtk_tree_path_free (path);
1309
1310 /* insert the just append row_ref into the GTree for a quick retrieval
1311 * later
1312 */
1313 g_tree_insert (priv->nodes_displayed, (gpointer)curr_symbol_id,
1314 child_row_ref);
1315
1316 /* good. Let's check now for a child (B) of the just appended child (A).
1317 * Adding B (a dummy one for now) to A will make A expandable
1318 */
1319 sdb_view_do_add_hidden_dummy_child (dbv, dbe, &child_iter, curr_symbol_id,
1320 FALSE);
1321
1322 } while (symbol_db_engine_iterator_move_next (iterator) == TRUE);
1323
1324 g_object_unref (iterator);
1325 }
1326
1327 /* force expand it */
1328 path = gtk_tree_model_get_path (gtk_tree_view_get_model (GTK_TREE_VIEW (dbv)),
1329 expanded_iter);
1330 gtk_tree_view_expand_row (GTK_TREE_VIEW (dbv), path, FALSE);
1331 gtk_tree_path_free (path);
1332 }
1333
1334 void
1335 symbol_db_view_row_collapsed (SymbolDBView *dbv, SymbolDBEngine *dbe,
1336 GtkTreeIter *collapsed_iter)
1337 {
1338 GtkTreeStore *store;
1339 gint collapsed_symbol_id;
1340 SymbolDBViewPriv *priv;
1341 gpointer node;
1342
1343 g_return_if_fail (dbv != NULL);
1344 priv = dbv->priv;
1345
1346 store = GTK_TREE_STORE (gtk_tree_view_get_model (GTK_TREE_VIEW (dbv)));
1347
1348 gtk_tree_model_get (GTK_TREE_MODEL (store), collapsed_iter,
1349 COLUMN_SYMBOL_ID, &collapsed_symbol_id, -1);
1350
1351 /* do a quick check to see if the collapsed_symbol_id is listed into the
1352 * currently expanding symbols. If that's the case remove the gsource func.
1353 */
1354 node = g_tree_lookup (priv->expanding_gfunc_ids, (gpointer)collapsed_symbol_id);
1355
1356 if (node == NULL)
1357 {
1358 /* no expanding gfunc found. */
1359 return;
1360 }
1361 else {
1362 g_source_remove ((gint)node);
1363 g_tree_remove (priv->expanding_gfunc_ids, (gpointer)collapsed_symbol_id);
1364 }
1365 }
1366
1367 static GtkTreeStore *
1368 sdb_view_create_new_store ()
1369 {
1370 GtkTreeStore *store;
1371 store = gtk_tree_store_new (COLUMN_MAX, GDK_TYPE_PIXBUF,
1372 G_TYPE_STRING, G_TYPE_INT);
1373 gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (store),
1374 COLUMN_NAME,
1375 GTK_SORT_ASCENDING);
1376 return store;
1377 }
1378
1379 static void
1380 sdb_view_init (SymbolDBView *object)
1381 {
1382 SymbolDBView *dbv;
1383 GtkTreeStore *store;
1384 GtkTreeViewColumn *column;
1385 GtkCellRenderer *renderer;
1386 GtkTreeSelection *selection;
1387 SymbolDBViewPriv *priv;
1388
1389 dbv = SYMBOL_DB_VIEW (object);
1390 dbv->priv = g_new0 (SymbolDBViewPriv, 1);
1391
1392 priv = dbv->priv;
1393
1394 /* initialize some priv data */
1395 priv->insert_handler = 0;
1396 priv->remove_handler = 0;
1397 priv->nodes_displayed = NULL;
1398 priv->waiting_for = NULL;
1399
1400 priv->row_ref_global = NULL;
1401 priv->scan_end_handler = 0;
1402 priv->remove_handler = 0;
1403 priv->scan_end_handler = 0;
1404
1405 /* create a GTree where to store the row_expanding ids of the gfuncs.
1406 * we would be able then to g_source_remove them on row_collapsed
1407 */
1408 priv->expanding_gfunc_ids = g_tree_new_full ((GCompareDataFunc)&gtree_compare_func,
1409 NULL, NULL, NULL);
1410
1411 /* Tree and his model */
1412 store = NULL;
1413
1414 gtk_tree_view_set_model (GTK_TREE_VIEW (dbv), GTK_TREE_MODEL (store));
1415 gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (dbv), FALSE);
1416
1417 selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (dbv));
1418 gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE);
1419
1420 /* search through the tree interactively */
1421 gtk_tree_view_set_search_column (GTK_TREE_VIEW (dbv), COLUMN_NAME);
1422 gtk_tree_view_set_enable_search (GTK_TREE_VIEW (dbv), TRUE);
1423
1424 /* Columns */
1425 column = gtk_tree_view_column_new ();
1426 gtk_tree_view_column_set_sizing (column,
1427 GTK_TREE_VIEW_COLUMN_AUTOSIZE);
1428 gtk_tree_view_column_set_title (column, _("Symbol"));
1429
1430 renderer = gtk_cell_renderer_pixbuf_new ();
1431 gtk_tree_view_column_pack_start (column, renderer, FALSE);
1432 gtk_tree_view_column_add_attribute (column, renderer, "pixbuf",
1433 COLUMN_PIXBUF);
1434
1435 renderer = gtk_cell_renderer_text_new ();
1436 gtk_tree_view_column_pack_start (column, renderer, TRUE);
1437 gtk_tree_view_column_add_attribute (column, renderer, "text",
1438 COLUMN_NAME);
1439
1440 gtk_tree_view_append_column (GTK_TREE_VIEW (dbv), column);
1441 gtk_tree_view_set_expander_column (GTK_TREE_VIEW (dbv), column);
1442 }
1443
1444
1445 static void
1446 sdb_view_finalize (GObject *object)
1447 {
1448 SymbolDBView *view = SYMBOL_DB_VIEW (object);
1449 SymbolDBViewPriv *priv = view->priv;
1450
1451 DEBUG_PRINT ("finalizing symbol_db_view ()");
1452
1453 symbol_db_view_clear_cache (view);
1454
1455 if (priv->expanding_gfunc_ids)
1456 g_tree_destroy (priv->expanding_gfunc_ids);
1457
1458 g_free (priv);
1459
1460 /* dbe must be freed outside. */
1461 G_OBJECT_CLASS (parent_class)->finalize (object);
1462 }
1463
1464 static void
1465 sdb_view_class_init (SymbolDBViewClass *klass)
1466 {
1467 SymbolDBViewClass *sdbc;
1468 GObjectClass* object_class = G_OBJECT_CLASS (klass);
1469 parent_class = g_type_class_peek_parent (klass);
1470
1471 sdbc = SYMBOL_DB_VIEW_CLASS (klass);
1472 object_class->finalize = sdb_view_finalize;
1473 }
1474
1475 GType
1476 symbol_db_view_get_type (void)
1477 {
1478 static GType obj_type = 0;
1479
1480 if (!obj_type)
1481 {
1482 static const GTypeInfo obj_info = {
1483 sizeof (SymbolDBViewClass),
1484 (GBaseInitFunc) NULL,
1485 (GBaseFinalizeFunc) NULL,
1486 (GClassInitFunc) sdb_view_class_init,
1487 (GClassFinalizeFunc) NULL,
1488 NULL, /* class_data */
1489 sizeof (SymbolDBViewClass),
1490 0, /* n_preallocs */
1491 (GInstanceInitFunc) sdb_view_init,
1492 NULL /* value_table */
1493 };
1494 obj_type = g_type_register_static (GTK_TYPE_TREE_VIEW,
1495 "SymbolDBView",
1496 &obj_info, 0);
1497 }
1498 return obj_type;
1499 }
1500
1501
1502 #define CREATE_SYM_ICON(N, F) \
1503 pix_file = anjuta_res_get_pixmap_file (F); \
1504 g_hash_table_insert (pixbufs_hash, \
1505 N, \
1506 gdk_pixbuf_new_from_file (pix_file, NULL)); \
1507 g_free (pix_file);
1508
1509 static void
1510 sdb_view_load_symbol_pixbufs ()
1511 {
1512 gchar *pix_file;
1513
1514 if (pixbufs_hash != NULL)
1515 {
1516 /* we already have loaded it */
1517 return;
1518 }
1519
1520 pixbufs_hash = g_hash_table_new (g_str_hash, g_str_equal);
1521
1522 CREATE_SYM_ICON ("class", "Icons.16x16.Class");
1523 CREATE_SYM_ICON ("enum", "Icons.16x16.Enum");
1524 CREATE_SYM_ICON ("enumerator", "Icons.16x16.Enum");
1525 CREATE_SYM_ICON ("function", "Icons.16x16.Method");
1526 CREATE_SYM_ICON ("interface", "Icons.16x16.Interface");
1527 CREATE_SYM_ICON ("macro", "Icons.16x16.Field");
1528 CREATE_SYM_ICON ("namespace", "Icons.16x16.NameSpace");
1529 CREATE_SYM_ICON ("none", "Icons.16x16.Literal");
1530 CREATE_SYM_ICON ("struct", "Icons.16x16.ProtectedStruct");
1531 CREATE_SYM_ICON ("typedef", "Icons.16x16.Reference");
1532 CREATE_SYM_ICON ("union", "Icons.16x16.PrivateStruct");
1533 CREATE_SYM_ICON ("variable", "Icons.16x16.Literal");
1534 CREATE_SYM_ICON ("prototype", "Icons.16x16.Interface");
1535
1536 CREATE_SYM_ICON ("privateclass", "Icons.16x16.PrivateClass");
1537 CREATE_SYM_ICON ("privateenum", "Icons.16x16.PrivateEnum");
1538 CREATE_SYM_ICON ("privatefield", "Icons.16x16.PrivateField");
1539 CREATE_SYM_ICON ("privatefunction", "Icons.16x16.PrivateMethod");
1540 CREATE_SYM_ICON ("privateinterface", "Icons.16x16.PrivateInterface");
1541 CREATE_SYM_ICON ("privatemember", "Icons.16x16.PrivateProperty");
1542 CREATE_SYM_ICON ("privatemethod", "Icons.16x16.PrivateMethod");
1543 CREATE_SYM_ICON ("privateproperty", "Icons.16x16.PrivateProperty");
1544 CREATE_SYM_ICON ("privatestruct", "Icons.16x16.PrivateStruct");
1545 CREATE_SYM_ICON ("privateprototype", "Icons.16x16.PrivateInterface");
1546
1547 CREATE_SYM_ICON ("protectedclass", "Icons.16x16.ProtectedClass");
1548 CREATE_SYM_ICON ("protectedenum", "Icons.16x16.ProtectedEnum");
1549 CREATE_SYM_ICON ("protectedfield", "Icons.16x16.ProtectedField");
1550 CREATE_SYM_ICON ("protectedmember", "Icons.16x16.ProtectedProperty");
1551 CREATE_SYM_ICON ("protectedmethod", "Icons.16x16.ProtectedMethod");
1552 CREATE_SYM_ICON ("protectedproperty", "Icons.16x16.ProtectedProperty");
1553 CREATE_SYM_ICON ("publicprototype", "Icons.16x16.ProtectedInterface");
1554
1555 CREATE_SYM_ICON ("publicclass", "Icons.16x16.Class");
1556 CREATE_SYM_ICON ("publicenum", "Icons.16x16.Enum");
1557 CREATE_SYM_ICON ("publicfunction", "Icons.16x16.Method");
1558 CREATE_SYM_ICON ("publicmember", "Icons.16x16.Method");
1559 CREATE_SYM_ICON ("publicproperty", "Icons.16x16.Property");
1560 CREATE_SYM_ICON ("publicstruct", "Icons.16x16.Struct");
1561 CREATE_SYM_ICON ("publicprototype", "Icons.16x16.Interface");
1562
1563 /* special icon */
1564 CREATE_SYM_ICON ("othersvars", "Icons.16x16.Event");
1565 CREATE_SYM_ICON ("globalglobal", "Icons.16x16.Event");
1566 }
1567
1568 /**
1569 * @return The pixbufs. It will initialize pixbufs first if they weren't before
1570 * @param node_access can be NULL.
1571 */
1572 const GdkPixbuf*
1573 symbol_db_view_get_pixbuf (const gchar *node_type, const gchar *node_access)
1574 {
1575 gchar *search_node;
1576 GdkPixbuf *pix;
1577 if (!pixbufs_hash)
1578 {
1579 sdb_view_load_symbol_pixbufs ();
1580 }
1581
1582 g_return_val_if_fail (node_type != NULL, NULL);
1583
1584 /* is there a better/quicker method to retrieve pixbufs? */
1585 if (node_access != NULL)
1586 {
1587 search_node = g_strdup_printf ("%s%s", node_access, node_type);
1588 }
1589 else
1590 {
1591 /* we will not free search_node gchar, so casting here is ok. */
1592 search_node = (gchar*)node_type;
1593 }
1594 pix = GDK_PIXBUF (g_hash_table_lookup (pixbufs_hash, search_node));
1595
1596 if (node_access)
1597 {
1598 g_free (search_node);
1599 }
1600
1601 if (pix == NULL)
1602 {
1603 DEBUG_PRINT ("symbol_db_view_get_pixbuf (): no pixbuf for %s %s",
1604 node_type, node_access);
1605 }
1606
1607 return pix;
1608 }
1609
1610
1611 GtkWidget*
1612 symbol_db_view_new (void)
1613 {
1614 return GTK_WIDGET (g_object_new (SYMBOL_TYPE_DB_VIEW, NULL));
1615 }
1616
1617 gboolean
1618 symbol_db_view_get_file_and_line (SymbolDBView *dbv, SymbolDBEngine *dbe,
1619 GtkTreeIter * iter, gint *OUT_line, gchar **OUT_file)
1620 {
1621 GtkTreeStore *store;
1622
1623 g_return_val_if_fail (dbv != NULL, FALSE);
1624 g_return_val_if_fail (dbe != NULL, FALSE);
1625 g_return_val_if_fail (iter != NULL, FALSE);
1626
1627 store = GTK_TREE_STORE (gtk_tree_view_get_model (GTK_TREE_VIEW (dbv)));
1628
1629 if (store)
1630 {
1631 gint symbol_id;
1632 const gchar* relative_file;
1633 SymbolDBEngineIteratorNode *node;
1634
1635 gtk_tree_model_get (GTK_TREE_MODEL
1636 (store), iter,
1637 COLUMN_SYMBOL_ID, &symbol_id, -1);
1638
1639 /* getting line at click time with a query is faster than updating every
1640 * entry in the gtktreeview. We can be sure that the db is in a consistent
1641 * state and has all the last infos
1642 */
1643 node = SYMBOL_DB_ENGINE_ITERATOR_NODE (
1644 symbol_db_engine_get_symbol_info_by_id (dbe, symbol_id,
1645 SYMINFO_SIMPLE |
1646 SYMINFO_FILE_PATH));
1647 if (node != NULL)
1648 {
1649 *OUT_line = symbol_db_engine_iterator_node_get_symbol_file_pos (node);
1650 relative_file =
1651 symbol_db_engine_iterator_node_get_symbol_extra_string (node,
1652 SYMINFO_FILE_PATH);
1653 *OUT_file = symbol_db_engine_get_full_local_path (dbe, relative_file);
1654 return TRUE;
1655 }
1656 }
1657
1658 return FALSE;
1659 }
1660
1661 static void
1662 sdb_view_build_and_display_base_tree (SymbolDBView *dbv, SymbolDBEngine *dbe)
1663 {
1664 GtkTreeStore *store;
1665 SymbolDBViewPriv *priv;
1666 SymbolDBEngineIterator *iterator;
1667 gboolean we_have_namespaces;
1668 GPtrArray *filter_array;
1669 GtkTreeRowReference *global_tree_row_ref;
1670 GtkTreeIter global_child_iter;
1671 const GdkPixbuf *global_pixbuf;
1672
1673 g_return_if_fail (dbv != NULL);
1674
1675 priv = dbv->priv;
1676
1677 store = GTK_TREE_STORE (gtk_tree_view_get_model (GTK_TREE_VIEW (dbv)));
1678
1679 we_have_namespaces = FALSE;
1680
1681 filter_array = g_ptr_array_new ();
1682 g_ptr_array_add (filter_array, "namespace");
1683
1684 /* check for the presence of namespaces.
1685 * If that's the case then populate the root with a 'Global' node.
1686 */
1687 iterator = symbol_db_engine_get_global_members_filtered (dbe, filter_array, TRUE,
1688 TRUE,
1689 -1,
1690 -1,
1691 SYMINFO_SIMPLE |
1692 SYMINFO_ACCESS |
1693 SYMINFO_KIND);
1694 g_ptr_array_free (filter_array, TRUE);
1695
1696 if (iterator != NULL)
1697 {
1698 we_have_namespaces = TRUE;
1699
1700 do {
1701 gint curr_symbol_id;
1702 SymbolDBEngineIteratorNode *iter_node;
1703 const GdkPixbuf *pixbuf;
1704 const gchar* symbol_name;
1705 GtkTreeRowReference *curr_tree_row_ref;
1706 GtkTreeIter child_iter;
1707
1708 iter_node = SYMBOL_DB_ENGINE_ITERATOR_NODE (iterator);
1709
1710 curr_symbol_id = symbol_db_engine_iterator_node_get_symbol_id (iter_node);
1711
1712 pixbuf = symbol_db_view_get_pixbuf (
1713 symbol_db_engine_iterator_node_get_symbol_extra_string (
1714 iter_node, SYMINFO_KIND),
1715 symbol_db_engine_iterator_node_get_symbol_extra_string (
1716 iter_node, SYMINFO_ACCESS));
1717
1718 symbol_name = symbol_db_engine_iterator_node_get_symbol_name (iter_node);
1719
1720 curr_tree_row_ref = do_add_root_symbol_to_view (dbv, pixbuf,
1721 symbol_name, curr_symbol_id);
1722 if (curr_tree_row_ref == NULL)
1723 {
1724 continue;
1725 }
1726
1727 /* we'll fake the gpointer to store an int */
1728 g_tree_insert (priv->nodes_displayed, (gpointer)curr_symbol_id,
1729 curr_tree_row_ref);
1730
1731 if (sdb_view_get_iter_from_row_ref (dbv, curr_tree_row_ref,
1732 &child_iter) == FALSE)
1733 {
1734 g_warning ("sdb_view_build_and_display_base_tree (): something "
1735 "went wrong");
1736 continue;
1737 }
1738 /* add a dummy child */
1739 sdb_view_do_add_hidden_dummy_child (dbv, dbe,
1740 &child_iter, curr_symbol_id, FALSE);
1741
1742 } while (symbol_db_engine_iterator_move_next (iterator) == TRUE);
1743
1744 g_object_unref (iterator);
1745 }
1746
1747 /*
1748 * Good. Add a 'Global' node to the store.
1749 */
1750 global_pixbuf = symbol_db_view_get_pixbuf ("global", "global");
1751
1752 global_tree_row_ref = do_add_root_symbol_to_view (dbv, global_pixbuf,
1753 "Global", ROOT_GLOBAL);
1754
1755 if (global_tree_row_ref == NULL)
1756 {
1757 return;
1758 }
1759 g_tree_insert (priv->nodes_displayed, (gpointer)ROOT_GLOBAL,
1760 global_tree_row_ref);
1761
1762 if (sdb_view_get_iter_from_row_ref (dbv, global_tree_row_ref,
1763 &global_child_iter) == FALSE)
1764 {
1765 g_warning ("sdb_view_build_and_display_base_tree (): cannot retrieve iter for "
1766 "row_ref");
1767 return;
1768 }
1769
1770 /* add a dummy child */
1771 sdb_view_do_add_hidden_dummy_child (dbv, dbe,
1772 &global_child_iter, ROOT_GLOBAL, TRUE);
1773 }
1774
1775 void
1776 symbol_db_view_recv_signals_from_engine (SymbolDBView *dbv, SymbolDBEngine *dbe,
1777 gboolean enable_status)
1778 {
1779 SymbolDBViewPriv *priv;
1780
1781 g_return_if_fail (dbv != NULL);
1782 priv = dbv->priv;
1783
1784 if (enable_status == TRUE)
1785 {
1786 gtk_widget_set_sensitive (GTK_WIDGET (dbv), TRUE);
1787 /* connect some signals */
1788 if (priv->insert_handler <= 0)
1789 {
1790 priv->insert_handler = g_signal_connect (G_OBJECT (dbe), "symbol-inserted",
1791 G_CALLBACK (on_symbol_inserted), dbv);
1792 }
1793
1794 if (priv->remove_handler <= 0)
1795 {
1796 priv->remove_handler = g_signal_connect (G_OBJECT (dbe), "symbol-removed",
1797 G_CALLBACK (on_symbol_removed), dbv);
1798 }
1799
1800 if (priv->scan_end_handler <= 0)
1801 {
1802 priv->scan_end_handler = g_signal_connect (G_OBJECT (dbe), "scan-end",
1803 G_CALLBACK (on_scan_end), dbv);
1804 }
1805 }
1806 else /* disconnect them, if they were ever connected before */
1807 {
1808 gtk_widget_set_sensitive (GTK_WIDGET (dbv), FALSE);
1809
1810 if (priv->insert_handler >= 0)
1811 {
1812 g_signal_handler_disconnect (G_OBJECT (dbe), priv->insert_handler);
1813 priv->insert_handler = 0;
1814 }
1815
1816 if (priv->remove_handler >= 0)
1817 {
1818 g_signal_handler_disconnect (G_OBJECT (dbe), priv->remove_handler);
1819 priv->remove_handler = 0;
1820 }
1821
1822 if (priv->scan_end_handler >= 0)
1823 {
1824 g_signal_handler_disconnect (G_OBJECT (dbe), priv->scan_end_handler);
1825 priv->scan_end_handler = 0;
1826 }
1827 }
1828 }
1829
1830 void
1831 symbol_db_view_open (SymbolDBView *dbv, SymbolDBEngine *dbe)
1832 {
1833 SymbolDBViewPriv *priv;
1834 GtkTreeStore *store;
1835
1836 g_return_if_fail (dbv != NULL);
1837
1838 priv = dbv->priv;
1839
1840 DEBUG_PRINT ("symbol_db_view_open ()");
1841 symbol_db_view_clear_cache (dbv);
1842
1843 store = sdb_view_create_new_store ();
1844 gtk_tree_view_set_model (GTK_TREE_VIEW (dbv), GTK_TREE_MODEL (store));
1845
1846 priv->nodes_displayed = g_tree_new_full ((GCompareDataFunc)&gtree_compare_func,
1847 NULL,
1848 NULL,
1849 (GDestroyNotify)&gtk_tree_row_reference_free);
1850
1851 priv->waiting_for = g_tree_new_full ((GCompareDataFunc)&gtree_compare_func,
1852 NULL,
1853 NULL,
1854 NULL);
1855
1856 sdb_view_build_and_display_base_tree (dbv, dbe);
1857 }
Anjuta IDE Git Plugin Development Tree