?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Implement AnjutaSyncCommand class in libanjuta.
[anjuta-git-plugin.git] / libegg / eggtreemodelfilter.c
blob6afed96ca9fff7ebda97c2bdc92c49ffbe9a2dc2
1 /* eggtreemodelfilter.c
2 * Copyright (C) 2000,2001 Red Hat, Inc., Jonathan Blandford <jrb@redhat.com>
3 * Copyright (C) 2001,2002 Kristian Rietveld <kris@gtk.org>
4 *
5 * This program is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU General Public License as
7 * published by the Free Software Foundation; either version 2 of the
8 * License, or (at your option) any later version.
9 *
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public
16 * License along with this program; if not, write to the
17 * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
18 * Boston, MA 02110-1301, USA.
19 */
20
21 #include "eggtreemodelfilter.h"
22 #include <gtk/gtksignal.h>
23 #include <string.h>
24
25 /* FIXME: remove this when we move it to GTK+ */
26 #include "eggintl.h"
27
28 /* ITER FORMAT:
29 *
30 * iter->stamp = filter->stamp
31 * iter->user_data = FilterLevel
32 * iter->user_data2 = FilterElt
33 */
34
35 /* all paths, iters, etc prefixed with c_ are paths, iters, etc relative to the
36 * child model.
37 */
38
39 typedef struct _FilterElt FilterElt;
40 typedef struct _FilterLevel FilterLevel;
41
42 struct _FilterElt
43 {
44 GtkTreeIter iter;
45 FilterLevel *children;
46 gint offset;
47 gint ref_count;
48 gint zero_ref_count;
49 gboolean visible;
50 };
51
52 struct _FilterLevel
53 {
54 GArray *array;
55 gint ref_count;
56
57 FilterElt *parent_elt;
58 FilterLevel *parent_level;
59 };
60
61 /* properties */
62 enum
63 {
64 PROP_0,
65 PROP_CHILD_MODEL,
66 PROP_VIRTUAL_ROOT
67 };
68
69 #define EGG_TREE_MODEL_FILTER_CACHE_CHILD_ITERS(filter) \
70 (((EggTreeModelFilter *)filter)->child_flags & GTK_TREE_MODEL_ITERS_PERSIST)
71
72 #define FILTER_ELT(filter_elt) ((FilterElt *)filter_elt)
73 #define FILTER_LEVEL(filter_level) ((FilterLevel *)filter_level)
74
75 /* general code (object/interface init, properties, etc) */
76 static void egg_tree_model_filter_init (EggTreeModelFilter *filter);
77 static void egg_tree_model_filter_class_init (EggTreeModelFilterClass *filter_class);
78 static void egg_tree_model_filter_tree_model_init (GtkTreeModelIface *iface);
79 static void egg_tree_model_filter_finalize (GObject *object);
80 static void egg_tree_model_filter_set_property (GObject *object,
81 guint prop_id,
82 const GValue *value,
83 GParamSpec *pspec);
84 static void egg_tree_model_filter_get_property (GObject *object,
85 guint prop_id,
86 GValue *value,
87 GParamSpec *pspec);
88
89 /* signal handlers */
90 static void egg_tree_model_filter_row_changed (GtkTreeModel *c_model,
91 GtkTreePath *c_path,
92 GtkTreeIter *c_iter,
93 gpointer data);
94 static void egg_tree_model_filter_row_inserted (GtkTreeModel *c_model,
95 GtkTreePath *c_path,
96 GtkTreeIter *c_iter,
97 gpointer data);
98 static void egg_tree_model_filter_row_has_child_toggled (GtkTreeModel *c_model,
99 GtkTreePath *c_path,
100 GtkTreeIter *c_iter,
101 gpointer data);
102 static void egg_tree_model_filter_row_deleted (GtkTreeModel *c_model,
103 GtkTreePath *c_path,
104 gpointer data);
105 static void egg_tree_model_filter_rows_reordered (GtkTreeModel *c_model,
106 GtkTreePath *c_path,
107 GtkTreeIter *c_iter,
108 gint *new_order,
109 gpointer data);
110
111 /* GtkTreeModel interface */
112 static guint egg_tree_model_filter_get_flags (GtkTreeModel *model);
113 static gint egg_tree_model_filter_get_n_columns (GtkTreeModel *model);
114 static GType egg_tree_model_filter_get_column_type (GtkTreeModel *model,
115 gint index);
116 static gboolean egg_tree_model_filter_get_iter (GtkTreeModel *model,
117 GtkTreeIter *iter,
118 GtkTreePath *path);
119 static GtkTreePath *egg_tree_model_filter_get_path (GtkTreeModel *model,
120 GtkTreeIter *iter);
121 static void egg_tree_model_filter_get_value (GtkTreeModel *model,
122 GtkTreeIter *iter,
123 gint column,
124 GValue *value);
125 static gboolean egg_tree_model_filter_iter_next (GtkTreeModel *model,
126 GtkTreeIter *iter);
127 static gboolean egg_tree_model_filter_iter_children (GtkTreeModel *model,
128 GtkTreeIter *iter,
129 GtkTreeIter *parent);
130 static gboolean egg_tree_model_filter_iter_has_child (GtkTreeModel *model,
131 GtkTreeIter *iter);
132 static gint egg_tree_model_filter_iter_n_children (GtkTreeModel *model,
133 GtkTreeIter *iter);
134 static gboolean egg_tree_model_filter_iter_nth_child (GtkTreeModel *model,
135 GtkTreeIter *iter,
136 GtkTreeIter *parent,
137 gint n);
138 static gboolean egg_tree_model_filter_iter_parent (GtkTreeModel *model,
139 GtkTreeIter *iter,
140 GtkTreeIter *child);
141 static void egg_tree_model_filter_ref_node (GtkTreeModel *model,
142 GtkTreeIter *iter);
143 static void egg_tree_model_filter_unref_node (GtkTreeModel *model,
144 GtkTreeIter *iter);
145
146
147
148 /* private functions */
149 static void egg_tree_model_filter_build_level (EggTreeModelFilter *filter,
150 FilterLevel *parent_level,
151 FilterElt *parent_elt);
152 static void egg_tree_model_filter_free_level (EggTreeModelFilter *filter,
153 FilterLevel *filter_level);
154
155 static GtkTreePath *egg_tree_model_filter_elt_get_path (FilterLevel *level,
156 FilterElt *elt,
157 GtkTreePath *root);
158
159 static GtkTreePath *egg_tree_model_filter_add_root (GtkTreePath *src,
160 GtkTreePath *root);
161 static GtkTreePath *egg_tree_model_filter_remove_root (GtkTreePath *src,
162 GtkTreePath *root);
163
164 static void egg_tree_model_filter_increment_stamp (EggTreeModelFilter *filter);
165
166 static gboolean egg_tree_model_filter_visible (EggTreeModelFilter *filter,
167 GtkTreeIter *child_iter);
168 static void egg_tree_model_filter_clear_cache_helper (EggTreeModelFilter *filter,
169 FilterLevel *level);
170
171 static void egg_tree_model_filter_real_unref_node (GtkTreeModel *model,
172 GtkTreeIter *iter,
173 gboolean propagate_unref);
174
175 static void egg_tree_model_filter_set_model (EggTreeModelFilter *filter,
176 GtkTreeModel *child_model);
177 static void egg_tree_model_filter_set_root (EggTreeModelFilter *filter,
178 GtkTreePath *root);
179
180 static GtkTreePath *egg_real_tree_model_filter_convert_child_path_to_path (EggTreeModelFilter *filter,
181 GtkTreePath *child_path,
182 gboolean build_levels,
183 gboolean fetch_childs);
184
185 static FilterElt *egg_tree_model_filter_fetch_child (EggTreeModelFilter *filter,
186 FilterLevel *level,
187 gint offset,
188 gint *index);
189 static void egg_tree_model_filter_remove_node (EggTreeModelFilter *filter,
190 GtkTreeIter *iter,
191 gboolean emit_signal);
192 static void egg_tree_model_filter_update_childs (EggTreeModelFilter *filter,
193 FilterLevel *level,
194 FilterElt *elt);
195 static FilterElt *bsearch_elt_with_offset (GArray *array,
196 gint offset,
197 gint *index);
198
199
200 static GObjectClass *parent_class = NULL;
201
202 GType
203 egg_tree_model_filter_get_type (void)
204 {
205 static GType tree_model_filter_type = 0;
206
207 if (!tree_model_filter_type)
208 {
209 static const GTypeInfo tree_model_filter_info =
210 {
211 sizeof (EggTreeModelFilterClass),
212 NULL, /* base_init */
213 NULL, /* base_finalize */
214 (GClassInitFunc) egg_tree_model_filter_class_init,
215 NULL, /* class_finalize */
216 NULL, /* class_data */
217 sizeof (EggTreeModelFilter),
218 0, /* n_preallocs */
219 (GInstanceInitFunc) egg_tree_model_filter_init
220 };
221
222 static const GInterfaceInfo tree_model_info =
223 {
224 (GInterfaceInitFunc) egg_tree_model_filter_tree_model_init,
225 NULL,
226 NULL
227 };
228
229 tree_model_filter_type = g_type_register_static (G_TYPE_OBJECT,
230 "EggTreeModelFilter",
231 &tree_model_filter_info, 0);
232
233 g_type_add_interface_static (tree_model_filter_type,
234 GTK_TYPE_TREE_MODEL,
235 &tree_model_info);
236 }
237
238 return tree_model_filter_type;
239 }
240
241 static void
242 egg_tree_model_filter_init (EggTreeModelFilter *filter)
243 {
244 filter->visible_column = -1;
245 filter->zero_ref_count = 0;
246 filter->visible_method_set = FALSE;
247 filter->modify_func_set = FALSE;
248 }
249
250 static void
251 egg_tree_model_filter_class_init (EggTreeModelFilterClass *filter_class)
252 {
253 GObjectClass *object_class;
254
255 object_class = (GObjectClass *) filter_class;
256 parent_class = g_type_class_peek_parent (filter_class);
257
258 object_class->set_property = egg_tree_model_filter_set_property;
259 object_class->get_property = egg_tree_model_filter_get_property;
260
261 object_class->finalize = egg_tree_model_filter_finalize;
262
263 /* Properties -- FIXME: write a better description ... */
264 g_object_class_install_property (object_class,
265 PROP_CHILD_MODEL,
266 g_param_spec_object ("child_model",
267 _("The child model"),
268 _("The model for the filtermodel to filter"),
269 GTK_TYPE_TREE_MODEL,
270 G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
271
272 g_object_class_install_property (object_class,
273 PROP_VIRTUAL_ROOT,
274 g_param_spec_boxed ("virtual_root",
275 _("The virtual root"),
276 _("The virtual root (relative to the child model) for this filtermodel"),
277 GTK_TYPE_TREE_PATH,
278 G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
279 }
280
281 static void
282 egg_tree_model_filter_tree_model_init (GtkTreeModelIface *iface)
283 {
284 iface->get_flags = egg_tree_model_filter_get_flags;
285 iface->get_n_columns = egg_tree_model_filter_get_n_columns;
286 iface->get_column_type = egg_tree_model_filter_get_column_type;
287 iface->get_iter = egg_tree_model_filter_get_iter;
288 iface->get_path = egg_tree_model_filter_get_path;
289 iface->get_value = egg_tree_model_filter_get_value;
290 iface->iter_next = egg_tree_model_filter_iter_next;
291 iface->iter_children = egg_tree_model_filter_iter_children;
292 iface->iter_has_child = egg_tree_model_filter_iter_has_child;
293 iface->iter_n_children = egg_tree_model_filter_iter_n_children;
294 iface->iter_nth_child = egg_tree_model_filter_iter_nth_child;
295 iface->iter_parent = egg_tree_model_filter_iter_parent;
296 iface->ref_node = egg_tree_model_filter_ref_node;
297 iface->unref_node = egg_tree_model_filter_unref_node;
298 }
299
300
301 static void
302 egg_tree_model_filter_finalize (GObject *object)
303 {
304 EggTreeModelFilter *filter = (EggTreeModelFilter *) object;
305
306 egg_tree_model_filter_set_model (filter, NULL);
307
308 if (filter->virtual_root)
309 gtk_tree_path_free (filter->virtual_root);
310
311 if (filter->root)
312 egg_tree_model_filter_free_level (filter, filter->root);
313
314 if (filter->modify_types)
315 g_free (filter->modify_types);
316
317 /* must chain up */
318 parent_class->finalize (object);
319 }
320
321 static void
322 egg_tree_model_filter_set_property (GObject *object,
323 guint prop_id,
324 const GValue *value,
325 GParamSpec *pspec)
326 {
327 EggTreeModelFilter *filter = EGG_TREE_MODEL_FILTER (object);
328
329 switch (prop_id)
330 {
331 case PROP_CHILD_MODEL:
332 egg_tree_model_filter_set_model (filter, g_value_get_object (value));
333 break;
334 case PROP_VIRTUAL_ROOT:
335 egg_tree_model_filter_set_root (filter, g_value_get_boxed (value));
336 break;
337 default:
338 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
339 break;
340 }
341 }
342
343 static void
344 egg_tree_model_filter_get_property (GObject *object,
345 guint prop_id,
346 GValue *value,
347 GParamSpec *pspec)
348 {
349 EggTreeModelFilter *filter = EGG_TREE_MODEL_FILTER (object);
350
351 switch (prop_id)
352 {
353 case PROP_CHILD_MODEL:
354 g_value_set_object (value, filter->child_model);
355 break;
356 case PROP_VIRTUAL_ROOT:
357 g_value_set_boxed (value, filter->virtual_root);
358 break;
359 default:
360 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
361 break;
362 }
363 }
364
365 /* helpers */
366
367 static void
368 egg_tree_model_filter_build_level (EggTreeModelFilter *filter,
369 FilterLevel *parent_level,
370 FilterElt *parent_elt)
371 {
372 GtkTreeIter iter;
373 GtkTreeIter root;
374 FilterLevel *new_level;
375 gint length = 0;
376 gint i;
377
378 g_assert (filter->child_model != NULL);
379
380 if (!parent_level)
381 {
382 if (filter->virtual_root)
383 {
384 if (gtk_tree_model_get_iter (filter->child_model, &root, filter->virtual_root) == FALSE)
385 return;
386 length = gtk_tree_model_iter_n_children (filter->child_model, &root);
387
388 if (gtk_tree_model_iter_children (filter->child_model, &iter, &root) == FALSE)
389 return;
390 }
391 else
392 {
393 if (!gtk_tree_model_get_iter_first (filter->child_model, &iter))
394 return;
395 length = gtk_tree_model_iter_n_children (filter->child_model, NULL);
396 }
397 }
398 else
399 {
400 GtkTreeIter parent_iter;
401 GtkTreeIter child_parent_iter;
402
403 parent_iter.stamp = filter->stamp;
404 parent_iter.user_data = parent_level;
405 parent_iter.user_data2 = parent_elt;
406
407 egg_tree_model_filter_convert_iter_to_child_iter (filter,
408 &child_parent_iter,
409 &parent_iter);
410 if (gtk_tree_model_iter_children (filter->child_model, &iter, &child_parent_iter) == FALSE)
411 return;
412
413 /* stamp may have changed */
414 egg_tree_model_filter_convert_iter_to_child_iter (filter,
415 &child_parent_iter,
416 &parent_iter);
417 length = gtk_tree_model_iter_n_children (filter->child_model, &child_parent_iter);
418 }
419
420 g_return_if_fail (length > 0);
421
422 new_level = g_new (FilterLevel, 1);
423 new_level->array = g_array_sized_new (FALSE, FALSE,
424 sizeof (FilterElt),
425 length);
426 new_level->ref_count = 0;
427 new_level->parent_elt = parent_elt;
428 new_level->parent_level = parent_level;
429
430 if (parent_elt)
431 parent_elt->children = new_level;
432 else
433 filter->root = new_level;
434
435 /* increase the count of zero ref_counts */
436 while (parent_level)
437 {
438 parent_elt->zero_ref_count++;
439
440 parent_elt = parent_level->parent_elt;
441 parent_level = parent_level->parent_level;
442 }
443 filter->zero_ref_count++;
444
445 i = 0;
446
447 if (!new_level->parent_level)
448 filter->root_level_visible = 0;
449
450 do
451 {
452 if (egg_tree_model_filter_visible (filter, &iter))
453 {
454 FilterElt filter_elt;
455
456 filter_elt.offset = i;
457 filter_elt.zero_ref_count = 0;
458 filter_elt.ref_count = 0;
459 filter_elt.children = NULL;
460 filter_elt.visible = TRUE;
461
462 if (EGG_TREE_MODEL_FILTER_CACHE_CHILD_ITERS (filter))
463 filter_elt.iter = iter;
464
465 g_array_append_val (new_level->array, filter_elt);
466
467 if (!new_level->parent_level)
468 filter->root_level_visible++;
469 }
470 i++;
471 }
472 while (gtk_tree_model_iter_next (filter->child_model, &iter));
473 }
474
475 static void
476 egg_tree_model_filter_free_level (EggTreeModelFilter *filter,
477 FilterLevel *filter_level)
478 {
479 gint i;
480
481 g_assert (filter_level);
482
483 if (filter_level->ref_count == 0)
484 {
485 FilterLevel *parent_level = filter_level->parent_level;
486 FilterElt *parent_elt = filter_level->parent_elt;
487
488 do
489 {
490 if (parent_elt)
491 parent_elt->zero_ref_count--;
492
493 if (parent_level)
494 {
495 parent_elt = parent_level->parent_elt;
496 parent_level = parent_level->parent_level;
497 }
498 }
499 while (parent_level);
500 filter->zero_ref_count--;
501 }
502
503 for (i = 0; i < filter_level->array->len; i++)
504 {
505 if (g_array_index (filter_level->array, FilterElt, i).children)
506 egg_tree_model_filter_free_level (filter,
507 FILTER_LEVEL (g_array_index (filter_level->array, FilterElt, i).children));
508 }
509
510 if (!filter_level->parent_level)
511 filter->root_level_visible = 0;
512
513 if (filter_level->parent_elt)
514 filter_level->parent_elt->children = NULL;
515 else
516 filter->root = NULL;
517
518 g_array_free (filter_level->array, TRUE);
519 filter_level->array = NULL;
520
521 g_free (filter_level);
522 filter_level = NULL;
523 }
524
525 static GtkTreePath *
526 egg_tree_model_filter_elt_get_path (FilterLevel *level,
527 FilterElt *elt,
528 GtkTreePath *root)
529 {
530 FilterLevel *walker = level;
531 FilterElt *walker2 = elt;
532 GtkTreePath *path;
533 GtkTreePath *real_path;
534
535 g_return_val_if_fail (level != NULL, NULL);
536 g_return_val_if_fail (elt != NULL, NULL);
537
538 path = gtk_tree_path_new ();
539
540 while (walker)
541 {
542 gtk_tree_path_prepend_index (path, walker2->offset);
543
544 walker2 = walker->parent_elt;
545 walker = walker->parent_level;
546 }
547
548 if (root)
549 {
550 real_path = egg_tree_model_filter_add_root (path, root);
551 gtk_tree_path_free (path);
552 return real_path;
553 }
554
555 return path;
556 }
557
558 static GtkTreePath *
559 egg_tree_model_filter_add_root (GtkTreePath *src,
560 GtkTreePath *root)
561 {
562 GtkTreePath *retval;
563 gint i;
564
565 retval = gtk_tree_path_copy (root);
566
567 for (i = 0; i < gtk_tree_path_get_depth (src); i++)
568 gtk_tree_path_append_index (retval, gtk_tree_path_get_indices (src)[i]);
569
570 return retval;
571 }
572
573 static GtkTreePath *
574 egg_tree_model_filter_remove_root (GtkTreePath *src,
575 GtkTreePath *root)
576 {
577 GtkTreePath *retval;
578 gint i;
579 gint depth;
580 gint *indices;
581
582 if (gtk_tree_path_get_depth (src) <= gtk_tree_path_get_depth (root))
583 return NULL;
584
585 depth = gtk_tree_path_get_depth (src);
586 indices = gtk_tree_path_get_indices (src);
587
588 for (i = 0; i < gtk_tree_path_get_depth (root); i++)
589 if (indices[i] != gtk_tree_path_get_indices (root)[i])
590 return NULL;
591
592 retval = gtk_tree_path_new ();
593
594 for (; i < depth; i++)
595 gtk_tree_path_append_index (retval, indices[i]);
596
597 return retval;
598 }
599
600 static void
601 egg_tree_model_filter_increment_stamp (EggTreeModelFilter *filter)
602 {
603 do
604 {
605 filter->stamp++;
606 }
607 while (filter->stamp == 0);
608
609 egg_tree_model_filter_clear_cache (filter);
610 }
611
612 static gboolean
613 egg_tree_model_filter_visible (EggTreeModelFilter *filter,
614 GtkTreeIter *child_iter)
615 {
616 if (filter->visible_func)
617 {
618 return (filter->visible_func (filter->child_model,
619 child_iter,
620 filter->visible_data));
621 }
622 else if (filter->visible_column >= 0)
623 {
624 GValue val = {0, };
625
626 gtk_tree_model_get_value (filter->child_model, child_iter,
627 filter->visible_column, &val);
628
629 if (g_value_get_boolean (&val))
630 {
631 g_value_unset (&val);
632 return TRUE;
633 }
634
635 g_value_unset (&val);
636 return FALSE;
637 }
638
639 /* no filter thing set, so always visible */
640 return TRUE;
641 }
642
643 static void
644 egg_tree_model_filter_clear_cache_helper (EggTreeModelFilter *filter,
645 FilterLevel *level)
646 {
647 gint i;
648
649 g_assert (level);
650
651 for (i = 0; i < level->array->len; i++)
652 {
653 if (g_array_index (level->array, FilterElt, i).zero_ref_count > 0)
654 egg_tree_model_filter_clear_cache_helper (filter, g_array_index (level->array, FilterElt, i).children);
655 }
656
657 if (level->ref_count == 0 && level != filter->root)
658 {
659 egg_tree_model_filter_free_level (filter, level);
660 return;
661 }
662 }
663
664 static FilterElt *
665 egg_tree_model_filter_fetch_child (EggTreeModelFilter *filter,
666 FilterLevel *level,
667 gint offset,
668 gint *index)
669 {
670 gint i = 0;
671 gint i_t;
672 gint start, middle, end;
673 gint len;
674 GtkTreePath *c_path = NULL;
675 GtkTreeIter c_iter;
676 GtkTreePath *c_parent_path = NULL;
677 GtkTreeIter c_parent_iter;
678 FilterElt elt;
679
680 /* check if child exists and is visible */
681 if (level->parent_elt)
682 {
683 c_parent_path =
684 egg_tree_model_filter_elt_get_path (level->parent_level,
685 level->parent_elt,
686 filter->virtual_root);
687 if (!c_parent_path)
688 return NULL;
689 }
690 else
691 {
692 if (filter->virtual_root)
693 c_parent_path = gtk_tree_path_copy (filter->virtual_root);
694 else
695 c_parent_path = NULL;
696 }
697
698 if (c_parent_path)
699 {
700 gtk_tree_model_get_iter (filter->child_model,
701 &c_parent_iter,
702 c_parent_path);
703 len = gtk_tree_model_iter_n_children (filter->child_model,
704 &c_parent_iter);
705
706 c_path = gtk_tree_path_copy (c_parent_path);
707 gtk_tree_path_free (c_parent_path);
708 }
709 else
710 {
711 len = gtk_tree_model_iter_n_children (filter->child_model, NULL);
712 c_path = gtk_tree_path_new ();
713 }
714
715 gtk_tree_path_append_index (c_path, offset);
716 gtk_tree_model_get_iter (filter->child_model, &c_iter, c_path);
717 gtk_tree_path_free (c_path);
718
719 if (offset >= len || !egg_tree_model_filter_visible (filter, &c_iter))
720 return NULL;
721
722 /* add child */
723 elt.offset = offset;
724 elt.zero_ref_count = 0;
725 elt.ref_count = 0;
726 elt.children = NULL;
727 /* visibility should be FALSE as we don't emit row_inserted */
728 elt.visible = FALSE;
729
730 if (EGG_TREE_MODEL_FILTER_CACHE_CHILD_ITERS (filter))
731 elt.iter = c_iter;
732
733 /* find index (binary search on offset) */
734 start = 0;
735 end = level->array->len;
736
737 if (start != end)
738 {
739 while (start != end)
740 {
741 middle = (start + end) / 2;
742
743 if (g_array_index (level->array, FilterElt, middle).offset <= offset)
744 start = middle + 1;
745 else
746 end = middle;
747 }
748
749 if (g_array_index (level->array, FilterElt, middle).offset <= offset)
750 i = middle + 1;
751 else
752 i = middle;
753 }
754 else
755 i = 0;
756
757 g_array_insert_val (level->array, i, elt);
758 *index = i;
759
760 i_t = i - 1;
761 for (i = MAX (i_t, 0); i < level->array->len; i++)
762 {
763 FilterElt *e = &(g_array_index (level->array, FilterElt, i));
764 if (e->children)
765 e->children->parent_elt = e;
766 }
767
768 return &g_array_index (level->array, FilterElt, *index);
769 }
770
771 static void
772 egg_tree_model_filter_remove_node (EggTreeModelFilter *filter,
773 GtkTreeIter *iter,
774 gboolean emit_signal)
775 {
776 FilterElt *elt, *parent;
777 FilterLevel *level, *parent_level;
778 gint offset, i, length, level_refcount;
779
780 /* FIXME: this function is very ugly. I need to rethink and
781 * rewrite it someday.
782 */
783
784 level = FILTER_LEVEL (iter->user_data);
785 elt = FILTER_ELT (iter->user_data2);
786
787 parent = level->parent_elt;
788 parent_level = level->parent_level;
789 length = level->array->len;
790 offset = elt->offset;
791
792 /* ref counting */
793 while (elt->ref_count > 0)
794 egg_tree_model_filter_real_unref_node (GTK_TREE_MODEL (filter),
795 iter, FALSE);
796
797 level_refcount = level->ref_count;
798
799 /* do the ref counting first! this touches the stamp */
800 if (emit_signal)
801 {
802 GtkTreePath *path;
803
804 path = gtk_tree_model_get_path (GTK_TREE_MODEL (filter), iter);
805 egg_tree_model_filter_increment_stamp (filter);
806 gtk_tree_model_row_deleted (GTK_TREE_MODEL (filter), path);
807 gtk_tree_path_free (path);
808 }
809
810 if ((length == 1 || level_refcount == 0) &&
811 emit_signal && iter->user_data != filter->root)
812 {
813 /* above code destroyed the level */
814 goto emit_has_child_toggled;
815 }
816
817 if (length == 1)
818 {
819 /* kill the level */
820 egg_tree_model_filter_free_level (filter, level);
821
822 if (!filter->root)
823 /* we killed the root */
824 return;
825 }
826 else
827 {
828 FilterElt *tmp;
829
830 /* remove the node */
831 tmp = bsearch_elt_with_offset (level->array, elt->offset, &i);
832
833 if (tmp)
834 {
835 gint i_t;
836 g_array_remove_index (level->array, i);
837
838 i_t = i - 1;
839 for (i = MAX (i_t, 0); i < level->array->len; i++)
840 {
841 /* NOTE: here we do *not* decrease offsets, because the node was
842 * not removed from the child model
843 */
844 elt = &g_array_index (level->array, FilterElt, i);
845 if (elt->children)
846 elt->children->parent_elt = elt;
847 }
848 }
849 }
850
851 emit_has_child_toggled:
852 /* children are being handled first, so we can check it this way
853 *
854 * yes this if-statement is ugly
855 */
856 if ((parent && parent->children && parent->children->array->len <= 1) ||
857 (length == 1 && emit_signal && iter->user_data != filter->root))
858 {
859 /* latest child has been removed, level has been destroyed */
860 GtkTreeIter piter;
861 GtkTreePath *ppath;
862
863 piter.stamp = filter->stamp;
864 piter.user_data = parent_level;
865 piter.user_data2 = parent;
866
867 ppath = gtk_tree_model_get_path (GTK_TREE_MODEL (filter), &piter);
868
869 gtk_tree_model_row_has_child_toggled (GTK_TREE_MODEL (filter),
870 ppath, &piter);
871 gtk_tree_path_free (ppath);
872 }
873 }
874
875 static void
876 egg_tree_model_filter_update_childs (EggTreeModelFilter *filter,
877 FilterLevel *level,
878 FilterElt *elt)
879 {
880 GtkTreeIter c_iter;
881 GtkTreeIter iter;
882
883 if (!elt->visible)
884 return;
885
886 iter.stamp = filter->stamp;
887 iter.user_data = level;
888 iter.user_data2 = elt;
889
890 egg_tree_model_filter_convert_iter_to_child_iter (filter, &c_iter, &iter);
891
892 if (gtk_tree_model_iter_has_child (filter->child_model, &c_iter))
893 {
894 GtkTreePath *path = gtk_tree_model_get_path (GTK_TREE_MODEL (filter),
895 &iter);
896 gtk_tree_model_row_has_child_toggled (GTK_TREE_MODEL (filter),
897 path,
898 &iter);
899 if (path)
900 gtk_tree_path_free (path);
901 }
902 }
903
904 static FilterElt *
905 bsearch_elt_with_offset (GArray *array,
906 gint offset,
907 gint *index)
908 {
909 gint start, middle, end;
910 FilterElt *elt;
911
912 start = 0;
913 end = array->len;
914
915 if (array->len < 1)
916 return NULL;
917
918 if (start == end)
919 {
920 elt = &g_array_index (array, FilterElt, 0);
921
922 if (elt->offset == offset)
923 {
924 *index = 0;
925 return elt;
926 }
927 else
928 return NULL;
929 }
930
931 while (start != end)
932 {
933 middle = (start + end) / 2;
934
935 elt = &g_array_index (array, FilterElt, middle);
936
937 if (elt->offset < offset)
938 start = middle + 1;
939 else if (elt->offset > offset)
940 end = middle;
941 else
942 break;
943 }
944
945 if (elt->offset == offset)
946 {
947 *index = middle;
948 return elt;
949 }
950
951 return NULL;
952 }
953
954 /* TreeModel signals */
955 static void
956 egg_tree_model_filter_row_changed (GtkTreeModel *c_model,
957 GtkTreePath *c_path,
958 GtkTreeIter *c_iter,
959 gpointer data)
960 {
961 EggTreeModelFilter *filter = EGG_TREE_MODEL_FILTER (data);
962 GtkTreeIter iter;
963 GtkTreeIter childs;
964 GtkTreeIter real_c_iter;
965 GtkTreePath *path = NULL;
966
967 FilterElt *elt;
968 FilterLevel *level;
969
970 gboolean requested_state;
971 gboolean current_state;
972 gboolean free_c_path = FALSE;
973
974 g_return_if_fail (c_path != NULL || c_iter != NULL);
975
976 if (!c_path)
977 {
978 c_path = gtk_tree_model_get_path (c_model, c_iter);
979 free_c_path = TRUE;
980 }
981
982 if (c_iter)
983 real_c_iter = *c_iter;
984 else
985 gtk_tree_model_get_iter (c_model, &real_c_iter, c_path);
986
987 /* is this node above the virtual root? */
988 if (filter->virtual_root
989 && (gtk_tree_path_get_depth (filter->virtual_root)
990 >= gtk_tree_path_get_depth (c_path)))
991 goto done;
992
993 /* what's the requested state? */
994 requested_state = egg_tree_model_filter_visible (filter, &real_c_iter);
995
996 /* now, let's see whether the item is there */
997 path = egg_real_tree_model_filter_convert_child_path_to_path (filter,
998 c_path,
999 FALSE,
1000 FALSE);
1001
1002 if (path)
1003 {
1004 gtk_tree_model_get_iter (GTK_TREE_MODEL (filter), &iter, path);
1005 current_state = FILTER_ELT (iter.user_data2)->visible;
1006 }
1007 else
1008 current_state = FALSE;
1009
1010 if (current_state == FALSE && requested_state == FALSE)
1011 /* no changes required */
1012 goto done;
1013
1014 if (current_state == TRUE && requested_state == FALSE)
1015 {
1016 /* get rid of this node */
1017 gtk_tree_model_get_iter (GTK_TREE_MODEL (filter), &iter, path);
1018 egg_tree_model_filter_remove_node (filter, &iter, TRUE);
1019
1020 level = FILTER_LEVEL (iter.user_data);
1021
1022 if (!level->parent_level)
1023 filter->root_level_visible--;
1024
1025 goto done;
1026 }
1027
1028 if (current_state == TRUE && requested_state == TRUE)
1029 {
1030 /* progate the signal */
1031 gtk_tree_model_get_iter (GTK_TREE_MODEL (filter), &iter, path);
1032 gtk_tree_model_row_changed (GTK_TREE_MODEL (filter), path, &iter);
1033
1034 level = FILTER_LEVEL (iter.user_data);
1035 elt = FILTER_ELT (iter.user_data2);
1036
1037 /* and update the childs */
1038 if (gtk_tree_model_iter_children (c_model, &childs, &real_c_iter))
1039 egg_tree_model_filter_update_childs (filter, level, elt);
1040
1041 goto done;
1042 }
1043
1044 /* only current == FALSE and requested == TRUE is left,
1045 * pull in the child
1046 */
1047 g_return_if_fail (current_state == FALSE && requested_state == TRUE);
1048
1049 /* make sure the new item has been pulled in */
1050 if (!filter->root)
1051 {
1052 gint i;
1053 FilterLevel *root;
1054
1055 egg_tree_model_filter_build_level (filter, NULL, NULL);
1056
1057 root = FILTER_LEVEL (filter->root);
1058
1059 if (root)
1060 {
1061 for (i = 0; i < root->array->len; i++)
1062 g_array_index (root->array, FilterElt, i).visible = FALSE;
1063 filter->root_level_visible = 0;
1064 }
1065 }
1066
1067 if (!path)
1068 path = egg_real_tree_model_filter_convert_child_path_to_path (filter,
1069 c_path,
1070 TRUE,
1071 TRUE);
1072
1073 g_return_if_fail (path != NULL);
1074
1075 egg_tree_model_filter_increment_stamp (filter);
1076 gtk_tree_model_get_iter (GTK_TREE_MODEL (filter), &iter, path);
1077
1078 level = FILTER_LEVEL (iter.user_data);
1079 elt = FILTER_ELT (iter.user_data2);
1080
1081 elt->visible = TRUE;
1082
1083 if (!level->parent_level)
1084 filter->root_level_visible++;
1085
1086 /* update stamp */
1087 gtk_tree_model_row_inserted (GTK_TREE_MODEL (filter), path, &iter);
1088
1089 if (gtk_tree_model_iter_children (c_model, &childs, c_iter))
1090 egg_tree_model_filter_update_childs (filter, level, elt);
1091
1092 done:
1093 if (path)
1094 gtk_tree_path_free (path);
1095
1096 if (free_c_path)
1097 gtk_tree_path_free (c_path);
1098 }
1099
1100 static void
1101 egg_tree_model_filter_row_inserted (GtkTreeModel *c_model,
1102 GtkTreePath *c_path,
1103 GtkTreeIter *c_iter,
1104 gpointer data)
1105 {
1106 EggTreeModelFilter *filter = EGG_TREE_MODEL_FILTER (data);
1107 GtkTreePath *path = NULL;
1108 GtkTreePath *real_path = NULL;
1109 GtkTreeIter iter;
1110
1111 GtkTreeIter real_c_iter;
1112
1113 FilterElt *elt;
1114 FilterLevel *level;
1115 FilterLevel *parent_level;
1116
1117 gint i = 0, offset, index = -1;
1118
1119 gboolean free_c_path = FALSE;
1120
1121 g_return_if_fail (c_path != NULL || c_iter != NULL);
1122
1123 if (!c_path)
1124 {
1125 c_path = gtk_tree_model_get_path (c_model, c_iter);
1126 free_c_path = TRUE;
1127 }
1128
1129 if (c_iter)
1130 real_c_iter = *c_iter;
1131 else
1132 gtk_tree_model_get_iter (c_model, &real_c_iter, c_path);
1133
1134 /* the row has already been inserted. so we need to fixup the
1135 * virtual root here first
1136 */
1137 if (filter->virtual_root)
1138 {
1139 if (gtk_tree_path_get_depth (filter->virtual_root) >=
1140 gtk_tree_path_get_depth (c_path))
1141 {
1142 gint level;
1143 gint *v_indices, *c_indices;
1144
1145 level = gtk_tree_path_get_depth (c_path) - 1;
1146 v_indices = gtk_tree_path_get_indices (filter->virtual_root);
1147 c_indices = gtk_tree_path_get_indices (c_path);
1148
1149 if (v_indices[level] >= c_indices[level])
1150 (v_indices[level])++;
1151 }
1152 }
1153
1154 if (!filter->root)
1155 {
1156 egg_tree_model_filter_build_level (filter, NULL, NULL);
1157 /* that already put the inserted iter in the level */
1158
1159 goto done_and_emit;
1160 }
1161
1162 parent_level = level = FILTER_LEVEL (filter->root);
1163
1164 /* subtract virtual root if necessary */
1165 if (filter->virtual_root)
1166 {
1167 real_path = egg_tree_model_filter_remove_root (c_path,
1168 filter->virtual_root);
1169 /* not our kiddo */
1170 if (!real_path)
1171 goto done;
1172 }
1173 else
1174 real_path = gtk_tree_path_copy (c_path);
1175
1176 if (gtk_tree_path_get_depth (real_path) - 1 >= 1)
1177 {
1178 /* find the parent level */
1179 while (i < gtk_tree_path_get_depth (real_path) - 1)
1180 {
1181 gint j;
1182
1183 if (!level)
1184 /* we don't cover this signal */
1185 goto done;
1186
1187 elt = bsearch_elt_with_offset (level->array,
1188 gtk_tree_path_get_indices (real_path)[i],
1189 &j);
1190
1191 if (!elt)
1192 /* parent is probably being filtered out */
1193 goto done;
1194
1195 if (!elt->children)
1196 {
1197 GtkTreePath *tmppath;
1198 GtkTreeIter tmpiter;
1199
1200 tmpiter.stamp = filter->stamp;
1201 tmpiter.user_data = level;
1202 tmpiter.user_data2 = elt;
1203
1204 tmppath = gtk_tree_model_get_path (GTK_TREE_MODEL (data),
1205 &tmpiter);
1206
1207 if (tmppath)
1208 {
1209 gtk_tree_model_row_has_child_toggled (GTK_TREE_MODEL (data),
1210 tmppath, &tmpiter);
1211 gtk_tree_path_free (tmppath);
1212 }
1213
1214 /* not covering this signal */
1215 goto done;
1216 }
1217
1218 level = elt->children;
1219 parent_level = level;
1220 i++;
1221 }
1222 }
1223
1224 if (!parent_level)
1225 goto done;
1226
1227 /* let's try to insert the value */
1228 offset = gtk_tree_path_get_indices (real_path)[gtk_tree_path_get_depth (real_path) - 1];
1229
1230 /* update the offsets, yes if we didn't insert the node above, there will
1231 * be a gap here. This will be filled with the node (via fetch_child) when
1232 * it becomes visible
1233 */
1234 for (i = 0; i < level->array->len; i++)
1235 {
1236 FilterElt *e = &g_array_index (level->array, FilterElt, i);
1237 if ((e->offset >= offset))
1238 e->offset++;
1239 }
1240
1241 /* only insert when visible */
1242 if (egg_tree_model_filter_visible (filter, &real_c_iter))
1243 {
1244 FilterElt felt;
1245
1246 if (EGG_TREE_MODEL_FILTER_CACHE_CHILD_ITERS (filter))
1247 felt.iter = real_c_iter;
1248
1249 felt.offset = offset;
1250 felt.zero_ref_count = 0;
1251 felt.ref_count = 0;
1252 felt.visible = TRUE;
1253 felt.children = NULL;
1254
1255 for (i = 0; i < level->array->len; i++)
1256 if (g_array_index (level->array, FilterElt, i).offset > offset)
1257 break;
1258
1259 g_array_insert_val (level->array, i, felt);
1260 index = i;
1261
1262 if (!level->parent_level)
1263 filter->root_level_visible++;
1264 }
1265
1266 /* another iteration to update the references of childs to parents. */
1267 for (i = 0; i < level->array->len; i++)
1268 {
1269 FilterElt *e = &g_array_index (level->array, FilterElt, i);
1270 if (e->children)
1271 e->children->parent_elt = e;
1272 }
1273
1274 /* don't emit the signal if we aren't visible */
1275 if (!egg_tree_model_filter_visible (filter, &real_c_iter))
1276 goto done;
1277
1278 done_and_emit:
1279 /* NOTE: pass c_path here and NOT real_path. This function does
1280 * root subtraction itself
1281 */
1282 path = egg_real_tree_model_filter_convert_child_path_to_path (filter,
1283 c_path,
1284 FALSE, TRUE);
1285
1286 if (!path)
1287 goto done;
1288
1289 egg_tree_model_filter_increment_stamp (filter);
1290
1291 gtk_tree_model_get_iter (GTK_TREE_MODEL (data), &iter, path);
1292 gtk_tree_model_row_inserted (GTK_TREE_MODEL (data), path, &iter);
1293
1294 gtk_tree_path_free (path);
1295
1296 done:
1297 if (real_path)
1298 gtk_tree_path_free (real_path);
1299
1300 if (free_c_path)
1301 gtk_tree_path_free (c_path);
1302 }
1303
1304 static void
1305 egg_tree_model_filter_row_has_child_toggled (GtkTreeModel *c_model,
1306 GtkTreePath *c_path,
1307 GtkTreeIter *c_iter,
1308 gpointer data)
1309 {
1310 EggTreeModelFilter *filter = EGG_TREE_MODEL_FILTER (data);
1311 GtkTreePath *path;
1312 GtkTreeIter iter;
1313
1314 g_return_if_fail (c_path != NULL && c_iter != NULL);
1315
1316 /* FIXME: does this code work? */
1317
1318 if (!egg_tree_model_filter_visible (filter, c_iter))
1319 return;
1320
1321 path = egg_real_tree_model_filter_convert_child_path_to_path (filter,
1322 c_path,
1323 FALSE,
1324 TRUE);
1325 if (!path)
1326 return;
1327
1328 gtk_tree_model_get_iter (GTK_TREE_MODEL (data), &iter, path);
1329 gtk_tree_model_row_has_child_toggled (GTK_TREE_MODEL (data), path, &iter);
1330
1331 gtk_tree_path_free (path);
1332 }
1333
1334 static void
1335 egg_tree_model_filter_row_deleted (GtkTreeModel *c_model,
1336 GtkTreePath *c_path,
1337 gpointer data)
1338 {
1339 EggTreeModelFilter *filter = EGG_TREE_MODEL_FILTER (data);
1340 GtkTreePath *path;
1341 GtkTreeIter iter;
1342 FilterElt *elt;
1343 FilterLevel *level;
1344 gint offset;
1345 gboolean emit_signal = TRUE;
1346 gint i;
1347
1348 g_return_if_fail (c_path != NULL);
1349
1350 /* special case the deletion of an ancestor of the virtual root */
1351 if (filter->virtual_root &&
1352 (gtk_tree_path_is_ancestor (c_path, filter->virtual_root) ||
1353 !gtk_tree_path_compare (c_path, filter->virtual_root)))
1354 {
1355 gint i;
1356 GtkTreePath *path;
1357 FilterLevel *level = FILTER_LEVEL (filter->root);
1358
1359 if (!level)
1360 return;
1361
1362 /* remove everything in the filter model
1363 *
1364 * For now, we just iterate over the root level and emit a
1365 * row_deleted for each FilterElt. Not sure if this is correct.
1366 */
1367
1368 egg_tree_model_filter_increment_stamp (filter);
1369 path = gtk_tree_path_new ();
1370 gtk_tree_path_append_index (path, 0);
1371
1372 for (i = 0; i < level->array->len; i++)
1373 gtk_tree_model_row_deleted (GTK_TREE_MODEL (data), path);
1374
1375 gtk_tree_path_free (path);
1376 egg_tree_model_filter_free_level (filter, filter->root);
1377
1378 return;
1379 }
1380
1381 /* fixup virtual root */
1382 if (filter->virtual_root)
1383 {
1384 if (gtk_tree_path_get_depth (filter->virtual_root) >=
1385 gtk_tree_path_get_depth (c_path))
1386 {
1387 gint level;
1388 gint *v_indices, *c_indices;
1389
1390 level = gtk_tree_path_get_depth (c_path) - 1;
1391 v_indices = gtk_tree_path_get_indices (filter->virtual_root);
1392 c_indices = gtk_tree_path_get_indices (c_path);
1393
1394 if (v_indices[level] > c_indices[level])
1395 (v_indices[level])--;
1396 }
1397 }
1398
1399 path = egg_real_tree_model_filter_convert_child_path_to_path (filter,
1400 c_path,
1401 FALSE,
1402 FALSE);
1403
1404 if (!path)
1405 {
1406 /* fixup the offsets */
1407 GtkTreePath *real_path;
1408
1409 if (!filter->root)
1410 return;
1411
1412 level = FILTER_LEVEL (filter->root);
1413
1414 /* subtract vroot if necessary */
1415 if (filter->virtual_root)
1416 {
1417 real_path = egg_tree_model_filter_remove_root (c_path,
1418 filter->virtual_root);
1419 /* we don't handle this */
1420 if (!real_path)
1421 return;
1422 }
1423 else
1424 real_path = gtk_tree_path_copy (c_path);
1425
1426 i = 0;
1427 if (gtk_tree_path_get_depth (real_path) - 1 >= 1)
1428 {
1429 while (i < gtk_tree_path_get_depth (real_path) - 1)
1430 {
1431 gint j;
1432
1433 if (!level)
1434 {
1435 /* we don't cover this */
1436 gtk_tree_path_free (real_path);
1437 return;
1438 }
1439
1440 elt = bsearch_elt_with_offset (level->array,
1441 gtk_tree_path_get_indices (real_path)[i],
1442 &j);
1443
1444
1445 if (!elt || !elt->children)
1446 {
1447 /* parent is filtered out, so no level */
1448 gtk_tree_path_free (real_path);
1449 return;
1450 }
1451
1452 level = elt->children;
1453 i++;
1454 }
1455 }
1456
1457 offset = gtk_tree_path_get_indices (real_path)[gtk_tree_path_get_depth (real_path) - 1];
1458 gtk_tree_path_free (real_path);
1459
1460 if (!level)
1461 return;
1462
1463 /* we need:
1464 * - the offset of the removed item
1465 * - the level
1466 */
1467 for (i = 0; i < level->array->len; i++)
1468 {
1469 elt = &g_array_index (level->array, FilterElt, i);
1470 if (elt->offset > offset)
1471 elt->offset--;
1472 if (elt->children)
1473 elt->children->parent_elt = elt;
1474 }
1475
1476 return;
1477 }
1478
1479 gtk_tree_model_get_iter (GTK_TREE_MODEL (data), &iter, path);
1480
1481 level = FILTER_LEVEL (iter.user_data);
1482 elt = FILTER_ELT (iter.user_data2);
1483 offset = elt->offset;
1484
1485 if (!level->parent_level && elt->visible)
1486 filter->root_level_visible--;
1487
1488 if (emit_signal)
1489 {
1490 if (level->ref_count == 0 && level != filter->root)
1491 {
1492 egg_tree_model_filter_increment_stamp (filter);
1493 gtk_tree_model_row_deleted (GTK_TREE_MODEL (data), path);
1494
1495 gtk_tree_path_free (path);
1496 return;
1497 }
1498
1499 egg_tree_model_filter_increment_stamp (filter);
1500 gtk_tree_model_row_deleted (GTK_TREE_MODEL (data), path);
1501 iter.stamp = filter->stamp;
1502
1503 while (elt->ref_count > 0)
1504 egg_tree_model_filter_real_unref_node (GTK_TREE_MODEL (data), &iter,
1505 FALSE);
1506 }
1507
1508 if (level->array->len == 1)
1509 {
1510 /* kill level */
1511 egg_tree_model_filter_free_level (filter, level);
1512 }
1513 else
1514 {
1515 FilterElt *tmp;
1516 gint i_t;
1517
1518 /* remove the row */
1519 tmp = bsearch_elt_with_offset (level->array, elt->offset, &i);
1520
1521 offset = tmp->offset;
1522 g_array_remove_index (level->array, i);
1523
1524 i_t = i = 1;
1525 for (i = MAX (i_t, 0); i < level->array->len; i++)
1526 {
1527 elt = &g_array_index (level->array, FilterElt, i);
1528 if (elt->offset > offset)
1529 elt->offset--;
1530 if (elt->children)
1531 elt->children->parent_elt = elt;
1532 }
1533 }
1534
1535 gtk_tree_path_free (path);
1536 }
1537
1538 static void
1539 egg_tree_model_filter_rows_reordered (GtkTreeModel *c_model,
1540 GtkTreePath *c_path,
1541 GtkTreeIter *c_iter,
1542 gint *new_order,
1543 gpointer data)
1544 {
1545 FilterElt *elt;
1546 FilterLevel *level;
1547 EggTreeModelFilter *filter = EGG_TREE_MODEL_FILTER (data);
1548
1549 GtkTreePath *path;
1550 GtkTreeIter iter;
1551
1552 gint *tmp_array;
1553 gint i, j, elt_count;
1554 gint length;
1555
1556 GArray *new_array;
1557
1558 g_return_if_fail (new_order != NULL);
1559
1560 if (c_path == NULL || gtk_tree_path_get_indices (c_path) == NULL)
1561 {
1562 if (!filter->root)
1563 return;
1564
1565 length = gtk_tree_model_iter_n_children (c_model, NULL);
1566
1567 if (filter->virtual_root)
1568 {
1569 gint new_pos = -1;
1570
1571 /* reorder root level of path */
1572 for (i = 0; i < length; i++)
1573 if (new_order[i] == gtk_tree_path_get_indices (filter->virtual_root)[0])
1574 new_pos = i;
1575
1576 if (new_pos < 0)
1577 return;
1578
1579 gtk_tree_path_get_indices (filter->virtual_root)[0] = new_pos;
1580 return;
1581 }
1582
1583 path = gtk_tree_path_new ();
1584 level = FILTER_LEVEL (filter->root);
1585 }
1586 else
1587 {
1588 GtkTreeIter child_iter;
1589
1590 /* virtual root anchor reordering */
1591 if (filter->virtual_root &&
1592 gtk_tree_path_get_depth (c_path) <
1593 gtk_tree_path_get_depth (filter->virtual_root))
1594 {
1595 gint new_pos = -1;
1596 gint length;
1597 gint level;
1598 GtkTreeIter real_c_iter;
1599
1600 level = gtk_tree_path_get_depth (c_path);
1601
1602 if (c_iter)
1603 real_c_iter = *c_iter;
1604 else
1605 gtk_tree_model_get_iter (c_model, &real_c_iter, c_path);
1606
1607 length = gtk_tree_model_iter_n_children (c_model, &real_c_iter);
1608
1609 for (i = 0; i < length; i++)
1610 if (new_order[i] == gtk_tree_path_get_indices (filter->virtual_root)[level])
1611 new_pos = i;
1612
1613 if (new_pos < 0)
1614 return;
1615
1616 gtk_tree_path_get_indices (filter->virtual_root)[level] = new_pos;
1617 return;
1618 }
1619
1620 path = egg_real_tree_model_filter_convert_child_path_to_path (filter,
1621 c_path,
1622 FALSE,
1623 FALSE);
1624 if (!path && filter->virtual_root &&
1625 gtk_tree_path_compare (c_path, filter->virtual_root))
1626 return;
1627
1628 if (!path && !filter->virtual_root)
1629 return;
1630
1631 if (!path)
1632 {
1633 /* root level mode */
1634 if (!c_iter)
1635 gtk_tree_model_get_iter (c_model, c_iter, c_path);
1636 length = gtk_tree_model_iter_n_children (c_model, c_iter);
1637 path = gtk_tree_path_new ();
1638 level = FILTER_LEVEL (filter->root);
1639 }
1640 else
1641 {
1642 gtk_tree_model_get_iter (GTK_TREE_MODEL (data), &iter, path);
1643
1644 level = FILTER_LEVEL (iter.user_data);
1645 elt = FILTER_ELT (iter.user_data2);
1646
1647 if (!elt->children)
1648 {
1649 gtk_tree_path_free (path);
1650 return;
1651 }
1652
1653 level = elt->children;
1654
1655 egg_tree_model_filter_convert_iter_to_child_iter (EGG_TREE_MODEL_FILTER (filter), &child_iter, &iter);
1656 length = gtk_tree_model_iter_n_children (c_model, &child_iter);
1657 }
1658 }
1659
1660 if (level->array->len < 1)
1661 return;
1662
1663 /* NOTE: we do not bail out here if level->array->len < 2 like
1664 * GtkTreeModelSort does. This because we do some special tricky
1665 * reordering.
1666 */
1667
1668 /* construct a new array */
1669 new_array = g_array_sized_new (FALSE, FALSE, sizeof (FilterElt),
1670 level->array->len);
1671 tmp_array = g_new (gint, level->array->len);
1672
1673 for (i = 0, elt_count = 0; i < length; i++)
1674 {
1675 FilterElt *e = NULL;
1676 gint old_offset = -1;
1677
1678 for (j = 0; j < level->array->len; j++)
1679 if (g_array_index (level->array, FilterElt, j).offset == new_order[i])
1680 {
1681 e = &g_array_index (level->array, FilterElt, j);
1682 old_offset = j;
1683 break;
1684 }
1685
1686 if (!e)
1687 continue;
1688
1689 tmp_array[elt_count] = old_offset;
1690 g_array_append_val (new_array, *e);
1691 g_array_index (new_array, FilterElt, elt_count).offset = i;
1692 elt_count++;
1693 }
1694
1695 g_array_free (level->array, TRUE);
1696 level->array = new_array;
1697
1698 /* fix up stuff */
1699 for (i = 0; i < level->array->len; i++)
1700 {
1701 FilterElt *e = &g_array_index (level->array, FilterElt, i);
1702 if (e->children)
1703 e->children->parent_elt = e;
1704 }
1705
1706 /* emit rows_reordered */
1707 if (!gtk_tree_path_get_indices (path))
1708 gtk_tree_model_rows_reordered (GTK_TREE_MODEL (data), path, NULL,
1709 tmp_array);
1710 else
1711 gtk_tree_model_rows_reordered (GTK_TREE_MODEL (data), path, &iter,
1712 tmp_array);
1713
1714 /* done */
1715 g_free (tmp_array);
1716 gtk_tree_path_free (path);
1717 }
1718
1719 /* TreeModelIface implementation */
1720 static guint
1721 egg_tree_model_filter_get_flags (GtkTreeModel *model)
1722 {
1723 g_return_val_if_fail (EGG_IS_TREE_MODEL_FILTER (model), 0);
1724
1725 return 0;
1726 }
1727
1728 static gint
1729 egg_tree_model_filter_get_n_columns (GtkTreeModel *model)
1730 {
1731 EggTreeModelFilter *filter = (EggTreeModelFilter *)model;
1732
1733 g_return_val_if_fail (EGG_IS_TREE_MODEL_FILTER (model), 0);
1734 g_return_val_if_fail (filter->child_model != NULL, 0);
1735
1736 if (filter->child_model == NULL)
1737 return 0;
1738
1739 /* so we can't modify the modify func after this ... */
1740 filter->modify_func_set = TRUE;
1741
1742 if (filter->modify_n_columns > 0)
1743 return filter->modify_n_columns;
1744
1745 return gtk_tree_model_get_n_columns (filter->child_model);
1746 }
1747
1748 static GType
1749 egg_tree_model_filter_get_column_type (GtkTreeModel *model,
1750 gint index)
1751 {
1752 EggTreeModelFilter *filter = (EggTreeModelFilter *)model;
1753
1754 g_return_val_if_fail (EGG_IS_TREE_MODEL_FILTER (model), G_TYPE_INVALID);
1755 g_return_val_if_fail (filter->child_model != NULL, G_TYPE_INVALID);
1756
1757 /* so we can't modify the modify func after this ... */
1758 filter->modify_func_set = TRUE;
1759
1760 if (filter->modify_types)
1761 {
1762 g_return_val_if_fail (index < filter->modify_n_columns, G_TYPE_INVALID);
1763
1764 return filter->modify_types[index];
1765 }
1766
1767 return gtk_tree_model_get_column_type (filter->child_model, index);
1768 }
1769
1770 static gboolean
1771 egg_tree_model_filter_get_iter (GtkTreeModel *model,
1772 GtkTreeIter *iter,
1773 GtkTreePath *path)
1774 {
1775 EggTreeModelFilter *filter = (EggTreeModelFilter *)model;
1776 gint *indices;
1777 FilterLevel *level;
1778 gint depth, i;
1779
1780 g_return_val_if_fail (EGG_IS_TREE_MODEL_FILTER (model), FALSE);
1781 g_return_val_if_fail (filter->child_model != NULL, FALSE);
1782
1783 indices = gtk_tree_path_get_indices (path);
1784
1785 if (filter->root == NULL)
1786 egg_tree_model_filter_build_level (filter, NULL, NULL);
1787 level = FILTER_LEVEL (filter->root);
1788
1789 depth = gtk_tree_path_get_depth (path);
1790 if (!depth)
1791 {
1792 iter->stamp = 0;
1793 return FALSE;
1794 }
1795
1796 for (i = 0; i < depth - 1; i++)
1797 {
1798 if (!level || indices[i] >= level->array->len)
1799 {
1800 return FALSE;
1801 }
1802
1803 if (!g_array_index (level->array, FilterElt, indices[i]).children)
1804 egg_tree_model_filter_build_level (filter, level,
1805 &g_array_index (level->array,
1806 FilterElt,
1807 indices[i]));
1808 level = g_array_index (level->array, FilterElt, indices[i]).children;
1809 }
1810
1811 if (!level || indices[i] >= level->array->len)
1812 {
1813 iter->stamp = 0;
1814 return FALSE;
1815 }
1816
1817 iter->stamp = filter->stamp;
1818 iter->user_data = level;
1819 iter->user_data2 = &g_array_index (level->array, FilterElt,
1820 indices[depth - 1]);
1821
1822 return TRUE;
1823 }
1824
1825 static GtkTreePath *
1826 egg_tree_model_filter_get_path (GtkTreeModel *model,
1827 GtkTreeIter *iter)
1828 {
1829 GtkTreePath *retval;
1830 FilterLevel *level;
1831 FilterElt *elt;
1832
1833 g_return_val_if_fail (EGG_IS_TREE_MODEL_FILTER (model), NULL);
1834 g_return_val_if_fail (EGG_TREE_MODEL_FILTER (model)->child_model != NULL, NULL);
1835 g_return_val_if_fail (EGG_TREE_MODEL_FILTER (model)->stamp == iter->stamp, NULL);
1836
1837 retval = gtk_tree_path_new ();
1838 level = iter->user_data;
1839 elt = iter->user_data2;
1840
1841 while (level)
1842 {
1843 gtk_tree_path_prepend_index (retval,
1844 elt - FILTER_ELT (level->array->data));
1845 elt = level->parent_elt;
1846 level = level->parent_level;
1847 }
1848
1849 return retval;
1850 }
1851
1852 static void
1853 egg_tree_model_filter_get_value (GtkTreeModel *model,
1854 GtkTreeIter *iter,
1855 gint column,
1856 GValue *value)
1857 {
1858 GtkTreeIter child_iter;
1859 EggTreeModelFilter *filter = EGG_TREE_MODEL_FILTER (model);
1860
1861 g_return_if_fail (EGG_IS_TREE_MODEL_FILTER (model));
1862 g_return_if_fail (EGG_TREE_MODEL_FILTER (model)->child_model != NULL);
1863 g_return_if_fail (EGG_TREE_MODEL_FILTER (model)->stamp == iter->stamp);
1864
1865 if (filter->modify_func)
1866 {
1867 g_return_if_fail (column < filter->modify_n_columns);
1868
1869 g_value_init (value, filter->modify_types[column]);
1870 filter->modify_func (model,
1871 iter,
1872 value,
1873 column,
1874 filter->modify_data);
1875
1876 return;
1877 }
1878
1879 egg_tree_model_filter_convert_iter_to_child_iter (EGG_TREE_MODEL_FILTER (model), &child_iter, iter);
1880 gtk_tree_model_get_value (EGG_TREE_MODEL_FILTER (model)->child_model,
1881 &child_iter, column, value);
1882 }
1883
1884 static gboolean
1885 egg_tree_model_filter_iter_next (GtkTreeModel *model,
1886 GtkTreeIter *iter)
1887 {
1888 FilterLevel *level;
1889 FilterElt *elt;
1890
1891 g_return_val_if_fail (EGG_IS_TREE_MODEL_FILTER (model), FALSE);
1892 g_return_val_if_fail (EGG_TREE_MODEL_FILTER (model)->child_model != NULL, FALSE);
1893 g_return_val_if_fail (EGG_TREE_MODEL_FILTER (model)->stamp == iter->stamp, FALSE);
1894
1895 level = iter->user_data;
1896 elt = iter->user_data2;
1897
1898 if (elt - FILTER_ELT (level->array->data) >= level->array->len - 1)
1899 {
1900 iter->stamp = 0;
1901 return FALSE;
1902 }
1903
1904 iter->user_data2 = elt + 1;
1905
1906 return TRUE;
1907 }
1908
1909 static gboolean
1910 egg_tree_model_filter_iter_children (GtkTreeModel *model,
1911 GtkTreeIter *iter,
1912 GtkTreeIter *parent)
1913 {
1914 EggTreeModelFilter *filter = (EggTreeModelFilter *)model;
1915 FilterLevel *level;
1916
1917 iter->stamp = 0;
1918 g_return_val_if_fail (EGG_IS_TREE_MODEL_FILTER (model), FALSE);
1919 g_return_val_if_fail (filter->child_model != NULL, FALSE);
1920 if (parent)
1921 g_return_val_if_fail (filter->stamp == parent->stamp, FALSE);
1922
1923 if (!parent)
1924 {
1925 if (!filter->root)
1926 egg_tree_model_filter_build_level (filter, NULL, NULL);
1927 if (!filter->root)
1928 return FALSE;
1929
1930 level = filter->root;
1931 iter->stamp = filter->stamp;
1932 iter->user_data = level;
1933 iter->user_data2 = level->array->data;
1934 }
1935 else
1936 {
1937 if (FILTER_ELT (parent->user_data2)->children == NULL)
1938 egg_tree_model_filter_build_level (filter,
1939 FILTER_LEVEL (parent->user_data),
1940 FILTER_ELT (parent->user_data2));
1941 if (FILTER_ELT (parent->user_data2)->children == NULL)
1942 return FALSE;
1943
1944 /* empty array? */
1945 if (FILTER_ELT (parent->user_data2)->children->array->len <= 0)
1946 return FALSE;
1947
1948 iter->stamp = filter->stamp;
1949 iter->user_data = FILTER_ELT (parent->user_data2)->children;
1950 iter->user_data2 = FILTER_LEVEL (iter->user_data)->array->data;
1951 }
1952
1953 return TRUE;
1954 }
1955
1956 static gboolean
1957 egg_tree_model_filter_iter_has_child (GtkTreeModel *model,
1958 GtkTreeIter *iter)
1959 {
1960 GtkTreeIter child_iter;
1961 EggTreeModelFilter *filter = (EggTreeModelFilter *)model;
1962 FilterElt *elt;
1963
1964 g_return_val_if_fail (EGG_IS_TREE_MODEL_FILTER (model), FALSE);
1965 g_return_val_if_fail (filter->child_model != NULL, FALSE);
1966 g_return_val_if_fail (filter->stamp == iter->stamp, FALSE);
1967
1968 filter = EGG_TREE_MODEL_FILTER (model);
1969
1970 egg_tree_model_filter_convert_iter_to_child_iter (EGG_TREE_MODEL_FILTER (model), &child_iter, iter);
1971 elt = FILTER_ELT (iter->user_data2);
1972
1973 /* we need to build the level to check if not all children are filtered
1974 * out
1975 */
1976 if (!elt->children
1977 && gtk_tree_model_iter_has_child (filter->child_model, &child_iter))
1978 egg_tree_model_filter_build_level (filter, FILTER_LEVEL (iter->user_data),
1979 elt);
1980
1981 /* FIXME: we should prolly count the visible nodes here, just like in
1982 * _iter_n_children.
1983 */
1984 if (elt->children && elt->children->array->len > 0)
1985 return TRUE;
1986
1987 return FALSE;
1988 }
1989
1990 static gint
1991 egg_tree_model_filter_iter_n_children (GtkTreeModel *model,
1992 GtkTreeIter *iter)
1993 {
1994 GtkTreeIter child_iter;
1995 EggTreeModelFilter *filter = (EggTreeModelFilter *)model;
1996 FilterElt *elt;
1997
1998 g_return_val_if_fail (EGG_IS_TREE_MODEL_FILTER (model), 0);
1999 g_return_val_if_fail (filter->child_model != NULL, 0);
2000 if (iter)
2001 g_return_val_if_fail (filter->stamp == iter->stamp, 0);
2002
2003 if (!iter)
2004 {
2005 if (!filter->root)
2006 egg_tree_model_filter_build_level (filter, NULL, NULL);
2007
2008 /* count visible nodes */
2009 return filter->root_level_visible;
2010 }
2011
2012 elt = FILTER_ELT (iter->user_data2);
2013 egg_tree_model_filter_convert_iter_to_child_iter (EGG_TREE_MODEL_FILTER (model), &child_iter, iter);
2014
2015 if (!elt->children &&
2016 gtk_tree_model_iter_has_child (filter->child_model, &child_iter))
2017 egg_tree_model_filter_build_level (filter,
2018 FILTER_LEVEL (iter->user_data),
2019 elt);
2020
2021 if (elt->children && elt->children->array->len)
2022 {
2023 int i = 0;
2024 int count = 0;
2025 GArray *a = elt->children->array;
2026
2027 /* count visible nodes */
2028 for (i = 0; i < a->len; i++)
2029 if (g_array_index (a, FilterElt, i).visible)
2030 count++;
2031
2032 return count;
2033 }
2034
2035 return 0;
2036 }
2037
2038 static gboolean
2039 egg_tree_model_filter_iter_nth_child (GtkTreeModel *model,
2040 GtkTreeIter *iter,
2041 GtkTreeIter *parent,
2042 gint n)
2043 {
2044 FilterLevel *level;
2045 GtkTreeIter children;
2046
2047 g_return_val_if_fail (EGG_IS_TREE_MODEL_FILTER (model), FALSE);
2048 if (parent)
2049 g_return_val_if_fail (EGG_TREE_MODEL_FILTER (model)->stamp == parent->stamp, FALSE);
2050
2051 /* use this instead of has_Child to force us to build the level, if needed */
2052 if (egg_tree_model_filter_iter_children (model, &children, parent) == FALSE)
2053 {
2054 iter->stamp = 0;
2055 return FALSE;
2056 }
2057
2058 level = children.user_data;
2059 if (n >= level->array->len)
2060 {
2061 iter->stamp = 0;
2062 return FALSE;
2063 }
2064
2065 iter->stamp = EGG_TREE_MODEL_FILTER (model)->stamp;
2066 iter->user_data = level;
2067 iter->user_data2 = &g_array_index (level->array, FilterElt, n);
2068
2069 return TRUE;
2070 }
2071
2072 static gboolean
2073 egg_tree_model_filter_iter_parent (GtkTreeModel *model,
2074 GtkTreeIter *iter,
2075 GtkTreeIter *child)
2076 {
2077 FilterLevel *level;
2078
2079 iter->stamp = 0;
2080 g_return_val_if_fail (EGG_IS_TREE_MODEL_FILTER (model), FALSE);
2081 g_return_val_if_fail (EGG_TREE_MODEL_FILTER (model)->child_model != NULL, FALSE);
2082 g_return_val_if_fail (EGG_TREE_MODEL_FILTER (model)->stamp == child->stamp, FALSE);
2083
2084 level = child->user_data;
2085
2086 if (level->parent_level)
2087 {
2088 iter->stamp = EGG_TREE_MODEL_FILTER (model)->stamp;
2089 iter->user_data = level->parent_level;
2090 iter->user_data2 = level->parent_elt;
2091
2092 return TRUE;
2093 }
2094
2095 return FALSE;
2096 }
2097
2098 static void
2099 egg_tree_model_filter_ref_node (GtkTreeModel *model,
2100 GtkTreeIter *iter)
2101 {
2102 EggTreeModelFilter *filter = (EggTreeModelFilter *)model;
2103 GtkTreeIter child_iter;
2104 FilterLevel *level;
2105 FilterElt *elt;
2106
2107 g_return_if_fail (EGG_IS_TREE_MODEL_FILTER (model));
2108 g_return_if_fail (EGG_TREE_MODEL_FILTER (model)->child_model != NULL);
2109 g_return_if_fail (EGG_TREE_MODEL_FILTER (model)->stamp == iter->stamp);
2110
2111 egg_tree_model_filter_convert_iter_to_child_iter (EGG_TREE_MODEL_FILTER (model), &child_iter, iter);
2112
2113 gtk_tree_model_ref_node (filter->child_model, &child_iter);
2114
2115 level = iter->user_data;
2116 elt = iter->user_data2;
2117
2118 elt->ref_count++;
2119 level->ref_count++;
2120 if (level->ref_count == 1)
2121 {
2122 FilterLevel *parent_level = level->parent_level;
2123 FilterElt *parent_elt = level->parent_elt;
2124
2125 /* we were at zero -- time to decrease the zero_ref_count val */
2126 do
2127 {
2128 if (parent_elt)
2129 parent_elt->zero_ref_count--;
2130
2131 if (parent_level)
2132 {
2133 parent_elt = parent_level->parent_elt;
2134 parent_level = parent_level->parent_level;
2135 }
2136 }
2137 while (parent_level);
2138 filter->zero_ref_count--;
2139 }
2140 }
2141
2142 static void
2143 egg_tree_model_filter_unref_node (GtkTreeModel *model,
2144 GtkTreeIter *iter)
2145 {
2146 egg_tree_model_filter_real_unref_node (model, iter, TRUE);
2147 }
2148
2149 static void
2150 egg_tree_model_filter_real_unref_node (GtkTreeModel *model,
2151 GtkTreeIter *iter,
2152 gboolean propagate_unref)
2153 {
2154 EggTreeModelFilter *filter = (EggTreeModelFilter *)model;
2155 FilterLevel *level;
2156 FilterElt *elt;
2157
2158 g_return_if_fail (EGG_IS_TREE_MODEL_FILTER (model));
2159 g_return_if_fail (filter->child_model != NULL);
2160 g_return_if_fail (filter->stamp == iter->stamp);
2161
2162 if (propagate_unref)
2163 {
2164 GtkTreeIter child_iter;
2165 egg_tree_model_filter_convert_iter_to_child_iter (EGG_TREE_MODEL_FILTER (model), &child_iter, iter);
2166 gtk_tree_model_unref_node (filter->child_model, &child_iter);
2167 }
2168
2169 level = iter->user_data;
2170 elt = iter->user_data2;
2171
2172 g_return_if_fail (elt->ref_count > 0);
2173
2174 elt->ref_count--;
2175 level->ref_count--;
2176 if (level->ref_count == 0)
2177 {
2178 FilterLevel *parent_level = level->parent_level;
2179 FilterElt *parent_elt = level->parent_elt;
2180
2181 /* we are at zero -- time to increase the zero_ref_count val */
2182 while (parent_level)
2183 {
2184 parent_elt->zero_ref_count++;
2185
2186 parent_elt = parent_level->parent_elt;
2187 parent_level = parent_level->parent_level;
2188 }
2189 filter->zero_ref_count++;
2190 }
2191 }
2192
2193 /* bits and pieces */
2194 static void
2195 egg_tree_model_filter_set_model (EggTreeModelFilter *filter,
2196 GtkTreeModel *child_model)
2197 {
2198 g_return_if_fail (EGG_IS_TREE_MODEL_FILTER (filter));
2199
2200 if (filter->child_model)
2201 {
2202 g_signal_handler_disconnect (G_OBJECT (filter->child_model),
2203 filter->changed_id);
2204 g_signal_handler_disconnect (G_OBJECT (filter->child_model),
2205 filter->inserted_id);
2206 g_signal_handler_disconnect (G_OBJECT (filter->child_model),
2207 filter->has_child_toggled_id);
2208 g_signal_handler_disconnect (G_OBJECT (filter->child_model),
2209 filter->deleted_id);
2210 g_signal_handler_disconnect (G_OBJECT (filter->child_model),
2211 filter->reordered_id);
2212
2213 /* reset our state */
2214 if (filter->root)
2215 egg_tree_model_filter_free_level (filter, filter->root);
2216
2217 filter->root = NULL;
2218 g_object_unref (G_OBJECT (filter->child_model));
2219 filter->visible_column = -1;
2220 /* FIXME: destroy more crack here? the funcs? */
2221 }
2222
2223 filter->child_model = child_model;
2224
2225 if (child_model)
2226 {
2227 g_object_ref (G_OBJECT (filter->child_model));
2228 filter->changed_id =
2229 g_signal_connect (child_model, "row_changed",
2230 G_CALLBACK (egg_tree_model_filter_row_changed),
2231 filter);
2232 filter->inserted_id =
2233 g_signal_connect (child_model, "row_inserted",
2234 G_CALLBACK (egg_tree_model_filter_row_inserted),
2235 filter);
2236 filter->has_child_toggled_id =
2237 g_signal_connect (child_model, "row_has_child_toggled",
2238 G_CALLBACK (egg_tree_model_filter_row_has_child_toggled),
2239 filter);
2240 filter->deleted_id =
2241 g_signal_connect (child_model, "row_deleted",
2242 G_CALLBACK (egg_tree_model_filter_row_deleted),
2243 filter);
2244 filter->reordered_id =
2245 g_signal_connect (child_model, "rows_reordered",
2246 G_CALLBACK (egg_tree_model_filter_rows_reordered),
2247 filter);
2248
2249 filter->child_flags = gtk_tree_model_get_flags (child_model);
2250 filter->stamp = g_random_int ();
2251 }
2252 }
2253
2254 static void
2255 egg_tree_model_filter_set_root (EggTreeModelFilter *filter,
2256 GtkTreePath *root)
2257 {
2258 g_return_if_fail (EGG_IS_TREE_MODEL_FILTER (filter));
2259
2260 if (!root)
2261 filter->virtual_root = NULL;
2262 else
2263 filter->virtual_root = gtk_tree_path_copy (root);
2264 }
2265
2266 /* public API */
2267
2268 /**
2269 * egg_tree_model_filter_new:
2270 * @child_model: A #GtkTreeModel.
2271 * @root: A #GtkTreePath or %NULL.
2272 *
2273 * Creates a new #GtkTreeModel, with @child_model as the child_model
2274 * and @root as the virtual root.
2275 *
2276 * Return value: A new #GtkTreeModel.
2277 */
2278 GtkTreeModel *
2279 egg_tree_model_filter_new (GtkTreeModel *child_model,
2280 GtkTreePath *root)
2281 {
2282 GtkTreeModel *retval;
2283
2284 g_return_val_if_fail (GTK_IS_TREE_MODEL (child_model), NULL);
2285
2286 retval = GTK_TREE_MODEL (g_object_new (egg_tree_model_filter_get_type (), NULL));
2287
2288 egg_tree_model_filter_set_model (EGG_TREE_MODEL_FILTER (retval),
2289 child_model);
2290 egg_tree_model_filter_set_root (EGG_TREE_MODEL_FILTER (retval), root);
2291
2292 return retval;
2293 }
2294
2295 /**
2296 * egg_tree_model_filter_get_model:
2297 * @filter: A #EggTreeModelFilter.
2298 *
2299 * Returns a pointer to the child model of @filter.
2300 *
2301 * Return value: A pointer to a #GtkTreeModel.
2302 */
2303 GtkTreeModel *
2304 egg_tree_model_filter_get_model (EggTreeModelFilter *filter)
2305 {
2306 g_return_val_if_fail (EGG_IS_TREE_MODEL_FILTER (filter), NULL);
2307
2308 return filter->child_model;
2309 }
2310
2311 /**
2312 * egg_tree_model_filter_set_visible_func:
2313 * @filter: A #EggTreeModelFilter.
2314 * @func: A #EggTreeModelFilterVisibleFunc, the visible function.
2315 * @data: User data to pass to the visible function, or %NULL.
2316 * @destroy: Destroy notifier of @data, or %NULL.
2317 *
2318 * Sets the visible function used when filtering the @filter to be @func. The
2319 * function should return %TRUE if the given row should be visible and
2320 * %FALSE otherwise.
2321 */
2322 void
2323 egg_tree_model_filter_set_visible_func (EggTreeModelFilter *filter,
2324 EggTreeModelFilterVisibleFunc func,
2325 gpointer data,
2326 GtkDestroyNotify destroy)
2327 {
2328 g_return_if_fail (EGG_IS_TREE_MODEL_FILTER (filter));
2329 g_return_if_fail (func != NULL);
2330 g_return_if_fail (filter->visible_method_set == FALSE);
2331
2332 if (filter->visible_func)
2333 {
2334 GtkDestroyNotify d = filter->visible_destroy;
2335
2336 filter->visible_destroy = NULL;
2337 d (filter->visible_data);
2338 }
2339
2340 filter->visible_func = func;
2341 filter->visible_data = data;
2342 filter->visible_destroy = destroy;
2343
2344 filter->visible_method_set = TRUE;
2345 }
2346
2347 /**
2348 * egg_tree_model_filter_set_modify_func:
2349 * @filter: A #EggTreeModelFilter.
2350 * @n_columns: The number of columns in the filter model.
2351 * @types: The #GType<!-- -->s of the columns.
2352 * @func: A #EggTreeModelFilterModifyFunc, or %NULL.
2353 * @data: User data to pass to the modify function, or %NULL.
2354 * @destroy: Destroy notifier of @data, or %NULL.
2355 *
2356 * Sets the @filter to have @n_columns columns with @types. If @func
2357 * is not %NULL, it will set @func to be the modify function of @filter.
2358 */
2359 void
2360 egg_tree_model_filter_set_modify_func (EggTreeModelFilter *filter,
2361 gint n_columns,
2362 GType *types,
2363 EggTreeModelFilterModifyFunc func,
2364 gpointer data,
2365 GtkDestroyNotify destroy)
2366 {
2367 g_return_if_fail (EGG_IS_TREE_MODEL_FILTER (filter));
2368 g_return_if_fail (func != NULL);
2369 g_return_if_fail (filter->modify_func_set == FALSE);
2370
2371 if (filter->modify_destroy)
2372 {
2373 GtkDestroyNotify d = filter->modify_destroy;
2374
2375 filter->modify_destroy = NULL;
2376 d (filter->modify_data);
2377 }
2378
2379 filter->modify_n_columns = n_columns;
2380 filter->modify_types = g_new0 (GType, n_columns);
2381 memcpy (filter->modify_types, types, sizeof (GType) * n_columns);
2382 filter->modify_func = func;
2383 filter->modify_data = data;
2384 filter->modify_destroy = destroy;
2385
2386 filter->modify_func_set = TRUE;
2387 }
2388
2389 /**
2390 * egg_tree_model_filter_set_visible_column:
2391 * @filter: A #EggTreeModelFilter.
2392 * @column: A #gint which is the column containing the visible information.
2393 *
2394 * Sets @column of the child_model to be the column where @filter should
2395 * look for visibility information. @columns should be a column of type
2396 * %G_TYPE_BOOLEAN, where %TRUE means that a row is visible, and %FALSE
2397 * if not.
2398 */
2399 void
2400 egg_tree_model_filter_set_visible_column (EggTreeModelFilter *filter,
2401 gint column)
2402 {
2403 g_return_if_fail (EGG_IS_TREE_MODEL_FILTER (filter));
2404 g_return_if_fail (column >= 0);
2405 g_return_if_fail (filter->visible_method_set == FALSE);
2406
2407 filter->visible_column = column;
2408
2409 filter->visible_method_set = TRUE;
2410 }
2411
2412 /* conversion */
2413
2414 /**
2415 * egg_tree_model_filter_convert_child_iter_to_iter:
2416 * @filter: A #EggTreeModelFilter.
2417 * @filter_iter: An uninitialized #GtkTreeIter.
2418 * @child_iter: A valid #GtkTreeIter pointing to a row on the child model.
2419 *
2420 * Sets @filter_iter to point to the row in @filter that corresponds to the
2421 * row pointed at by @child_iter.
2422 */
2423 void
2424 egg_tree_model_filter_convert_child_iter_to_iter (EggTreeModelFilter *filter,
2425 GtkTreeIter *filter_iter,
2426 GtkTreeIter *child_iter)
2427 {
2428 GtkTreePath *child_path, *path;
2429
2430 g_return_if_fail (EGG_IS_TREE_MODEL_FILTER (filter));
2431 g_return_if_fail (filter->child_model != NULL);
2432 g_return_if_fail (filter_iter != NULL);
2433 g_return_if_fail (child_iter != NULL);
2434
2435 filter_iter->stamp = 0;
2436
2437 child_path = gtk_tree_model_get_path (filter->child_model, child_iter);
2438 g_return_if_fail (child_path != NULL);
2439
2440 path = egg_tree_model_filter_convert_child_path_to_path (filter,
2441 child_path);
2442 gtk_tree_path_free (child_path);
2443 g_return_if_fail (path != NULL);
2444
2445 gtk_tree_model_get_iter (GTK_TREE_MODEL (filter), filter_iter, path);
2446 gtk_tree_path_free (path);
2447 }
2448
2449 /**
2450 * egg_tree_model_filter_convert_iter_to_child_iter:
2451 * @filter: A #EggTreeModelFilter.
2452 * @child_iter: An uninitialized #GtkTreeIter.
2453 * @filter_iter: A valid #GtkTreeIter pointing to a row on @filter.
2454 *
2455 * Sets @child_iter to point to the row pointed to by @filter_iter.
2456 */
2457 void
2458 egg_tree_model_filter_convert_iter_to_child_iter (EggTreeModelFilter *filter,
2459 GtkTreeIter *child_iter,
2460 GtkTreeIter *filter_iter)
2461 {
2462 g_return_if_fail (EGG_IS_TREE_MODEL_FILTER (filter));
2463 g_return_if_fail (filter->child_model != NULL);
2464 g_return_if_fail (child_iter != NULL);
2465 g_return_if_fail (filter_iter != NULL);
2466 g_return_if_fail (filter_iter->stamp == filter->stamp);
2467
2468 if (EGG_TREE_MODEL_FILTER_CACHE_CHILD_ITERS (filter))
2469 {
2470 *child_iter = FILTER_ELT (filter_iter->user_data2)->iter;
2471 }
2472 else
2473 {
2474 GtkTreePath *path;
2475
2476 path = egg_tree_model_filter_elt_get_path (filter_iter->user_data,
2477 filter_iter->user_data2,
2478 filter->virtual_root);
2479 gtk_tree_model_get_iter (filter->child_model, child_iter, path);
2480 gtk_tree_path_free (path);
2481 }
2482 }
2483
2484 static GtkTreePath *
2485 egg_real_tree_model_filter_convert_child_path_to_path (EggTreeModelFilter *filter,
2486 GtkTreePath *child_path,
2487 gboolean build_levels,
2488 gboolean fetch_childs)
2489 {
2490 gint *child_indices;
2491 GtkTreePath *retval;
2492 GtkTreePath *real_path;
2493 FilterLevel *level;
2494 FilterElt *tmp;
2495 gint i;
2496
2497 g_return_val_if_fail (EGG_IS_TREE_MODEL_FILTER (filter), NULL);
2498 g_return_val_if_fail (filter->child_model != NULL, NULL);
2499 g_return_val_if_fail (child_path != NULL, NULL);
2500
2501 if (!filter->virtual_root)
2502 real_path = gtk_tree_path_copy (child_path);
2503 else
2504 real_path = egg_tree_model_filter_remove_root (child_path,
2505 filter->virtual_root);
2506
2507 if (!real_path)
2508 return NULL;
2509
2510 retval = gtk_tree_path_new ();
2511 child_indices = gtk_tree_path_get_indices (real_path);
2512
2513 if (filter->root == NULL && build_levels)
2514 egg_tree_model_filter_build_level (filter, NULL, NULL);
2515 level = FILTER_LEVEL (filter->root);
2516
2517 for (i = 0; i < gtk_tree_path_get_depth (real_path); i++)
2518 {
2519 gint j;
2520 gboolean found_child = FALSE;
2521
2522 if (!level)
2523 {
2524 gtk_tree_path_free (real_path);
2525 gtk_tree_path_free (retval);
2526 return NULL;
2527 }
2528
2529 tmp = bsearch_elt_with_offset (level->array, child_indices[i], &j);
2530 if (tmp)
2531 {
2532 gtk_tree_path_append_index (retval, j);
2533 if (!tmp->children && build_levels)
2534 egg_tree_model_filter_build_level (filter, level, tmp);
2535 level = tmp->children;
2536 found_child = TRUE;
2537 }
2538
2539 if (!found_child && fetch_childs)
2540 {
2541 tmp = egg_tree_model_filter_fetch_child (filter, level,
2542 child_indices[i],
2543 &j);
2544
2545 /* didn't find the child, let's try to bring it back */
2546 if (!tmp || tmp->offset != child_indices[i])
2547 {
2548 /* not there */
2549 gtk_tree_path_free (real_path);
2550 gtk_tree_path_free (retval);
2551 return NULL;
2552 }
2553
2554 gtk_tree_path_append_index (retval, j);
2555 if (!tmp->children && build_levels)
2556 egg_tree_model_filter_build_level (filter, level, tmp);
2557 level = tmp->children;
2558 found_child = TRUE;
2559 }
2560 else if (!found_child && !fetch_childs)
2561 {
2562 /* no path */
2563 gtk_tree_path_free (real_path);
2564 gtk_tree_path_free (retval);
2565 return NULL;
2566 }
2567 }
2568
2569 gtk_tree_path_free (real_path);
2570 return retval;
2571 }
2572
2573 /**
2574 * egg_tree_model_filter_convert_child_path_to_path:
2575 * @filter: A #EggTreeModelFilter.
2576 * @child_path: A #GtkTreePath to convert.
2577 *
2578 * Converts @child_path to a path relative to @filter. That is, @child_path
2579 * points to a path in the child model. The rerturned path will point to the
2580 * same row in the filtered model. If @child_path isn't a valid path on the
2581 * child model, then %NULL is returned.
2582 *
2583 * Return value: A newly allocated #GtkTreePath, or %NULL.
2584 */
2585 GtkTreePath *
2586 egg_tree_model_filter_convert_child_path_to_path (EggTreeModelFilter *filter,
2587 GtkTreePath *child_path)
2588 {
2589 /* this function does the sanity checks */
2590 return egg_real_tree_model_filter_convert_child_path_to_path (filter,
2591 child_path,
2592 TRUE,
2593 TRUE);
2594 }
2595
2596 /**
2597 * egg_tree_model_filter_convert_path_to_child_path:
2598 * @filter: A #EggTreeModelFilter.
2599 * @filter_path: A #GtkTreePath to convert.
2600 *
2601 * Converts @filter_path to a path on the child model of @filter. That is,
2602 * @filter_path points to a location in @filter. The returned path will
2603 * point to the same location in the model not being filtered. If @filter_path
2604 * does not point to a location in the child model, %NULL is returned.
2605 *
2606 * Return value: A newly allocated #GtkTreePath, or %NULL.
2607 */
2608 GtkTreePath *
2609 egg_tree_model_filter_convert_path_to_child_path (EggTreeModelFilter *filter,
2610 GtkTreePath *filter_path)
2611 {
2612 gint *filter_indices;
2613 GtkTreePath *retval;
2614 FilterLevel *level;
2615 gint i;
2616
2617 g_return_val_if_fail (EGG_IS_TREE_MODEL_FILTER (filter), NULL);
2618 g_return_val_if_fail (filter->child_model != NULL, NULL);
2619 g_return_val_if_fail (filter_path != NULL, NULL);
2620
2621 /* convert path */
2622 retval = gtk_tree_path_new ();
2623 filter_indices = gtk_tree_path_get_indices (filter_path);
2624 if (!filter->root)
2625 egg_tree_model_filter_build_level (filter, NULL, NULL);
2626 level = FILTER_LEVEL (filter->root);
2627
2628 for (i = 0; i < gtk_tree_path_get_depth (filter_path); i++)
2629 {
2630 gint count = filter_indices[i];
2631
2632 if (!level || level->array->len <= filter_indices[i])
2633 {
2634 gtk_tree_path_free (retval);
2635 return NULL;
2636 }
2637
2638 if (g_array_index (level->array, FilterElt, count).children == NULL)
2639 egg_tree_model_filter_build_level (filter, level, &g_array_index (level->array, FilterElt, count));
2640
2641 if (!level || level->array->len <= filter_indices[i])
2642 {
2643 gtk_tree_path_free (retval);
2644 return NULL;
2645 }
2646
2647 gtk_tree_path_append_index (retval, g_array_index (level->array, FilterElt, count).offset);
2648 level = g_array_index (level->array, FilterElt, count).children;
2649 }
2650
2651 /* apply vroot */
2652
2653 if (filter->virtual_root)
2654 {
2655 GtkTreePath *real_retval;
2656
2657 real_retval = egg_tree_model_filter_add_root (retval,
2658 filter->virtual_root);
2659 gtk_tree_path_free (retval);
2660
2661 return real_retval;
2662 }
2663
2664 return retval;
2665 }
2666
2667 static gboolean
2668 egg_tree_model_filter_refilter_helper (GtkTreeModel *model,
2669 GtkTreePath *path,
2670 GtkTreeIter *iter,
2671 gpointer data)
2672 {
2673 /* evil, don't try this at home, but certainly speeds things up */
2674 egg_tree_model_filter_row_changed (model, path, iter, data);
2675
2676 return FALSE;
2677 }
2678
2679 /**
2680 * egg_tree_model_filter_refilter:
2681 * @filter: A #EggTreeModelFilter.
2682 *
2683 * Emits ::row_changed for each row in the child model, which causes
2684 * the filter to re-evaluate whether a row is visible or not.
2685 */
2686 void
2687 egg_tree_model_filter_refilter (EggTreeModelFilter *filter)
2688 {
2689 g_return_if_fail (EGG_IS_TREE_MODEL_FILTER (filter));
2690
2691 /* S L O W */
2692 gtk_tree_model_foreach (filter->child_model,
2693 egg_tree_model_filter_refilter_helper,
2694 filter);
2695 }
2696
2697 /**
2698 * egg_tree_model_filter_clear_cache:
2699 * @filter: A #EggTreeModelFilter.
2700 *
2701 * This function should almost never be called. It clears the @filter
2702 * of any cached iterators that haven't been reffed with
2703 * gtk_tree_model_ref_node(). This might be useful if the child model
2704 * being filtered is static (and doesn't change often) and there has been
2705 * a lot of unreffed access to nodes. As a side effect of this function,
2706 * all unreffed itters will be invalid.
2707 */
2708 void
2709 egg_tree_model_filter_clear_cache (EggTreeModelFilter *filter)
2710 {
2711 g_return_if_fail (EGG_IS_TREE_MODEL_FILTER (filter));
2712
2713 if (filter->zero_ref_count)
2714 egg_tree_model_filter_clear_cache_helper (filter,
2715 FILTER_LEVEL (filter->root));
2716 }
Anjuta IDE Git Plugin Development Tree