Pileus Git - ~andy/gtk/blob - gtk/gtktreemodelfilter.c

   1 /* gtktreemodelfilter.c
   2  * Copyright (C) 2000,2001  Red Hat, Inc., Jonathan Blandford <jrb@redhat.com>
   3  * Copyright (C) 2001-2003  Kristian Rietveld <kris@gtk.org>
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Library General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2 of the License, or (at your option) any later version.
   9  *
  10  * This library 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  * Library General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Library General Public
  16  * License along with this library; if not, write to the
  17  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  18  * Boston, MA 02111-1307, USA.
  19  */
  20
  21 #include "config.h"
  22 #include "gtktreemodelfilter.h"
  23 #include "gtkintl.h"
  24 #include "gtktreednd.h"
  25 #include "gtkprivate.h"
  26 #include "gtkalias.h"
  27 #include <string.h>
  28
  29 /* ITER FORMAT:
  30  *
  31  * iter->stamp = filter->priv->stamp
  32  * iter->user_data = FilterLevel
  33  * iter->user_data2 = FilterElt
  34  */
  35
  36 /* all paths, iters, etc prefixed with c_ are paths, iters, etc relative to the
  37  * child model.
  38  */
  39
  40 /* A few notes:
  41  *  There are three model/views involved, so there are two mappings:
  42  *    * this model -> child model: mapped via offset in FilterElt.
  43  *    * this model -> parent model (or view): mapped via the array index
  44  *                                            of FilterElt.
  45  *
  46  *  Note that there are two kinds of paths relative to the filter model
  47  *  (those generated from the array indices): paths taking non-visible
  48  *  nodes into account, and paths which don't.  Paths which take
  49  *  non-visible nodes into account should only be used internally and
  50  *  NEVER be passed along with a signal emission.
  51  *
  52  *  The filter model has a reference on every node that is not in the root
  53  *  level and has a parent with ref_count > 1.  Exception is a virtual root
  54  *  level; all nodes in the virtual root level are referenced too.
  55  */
  56
  57 typedef struct _FilterElt FilterElt;
  58 typedef struct _FilterLevel FilterLevel;
  59
  60 struct _FilterElt
  61 {
  62   GtkTreeIter iter;
  63   FilterLevel *children;
  64   gint offset;
  65   gint ref_count;
  66   gint zero_ref_count;
  67   gboolean visible;
  68 };
  69
  70 struct _FilterLevel
  71 {
  72   GArray *array;
  73   gint ref_count;
  74   gint visible_nodes;
  75
  76   FilterElt *parent_elt;
  77   FilterLevel *parent_level;
  78 };
  79
  80 #define GTK_TREE_MODEL_FILTER_GET_PRIVATE(obj)  (G_TYPE_INSTANCE_GET_PRIVATE ((obj), GTK_TYPE_TREE_MODEL_FILTER, GtkTreeModelFilterPrivate))
  81
  82 struct _GtkTreeModelFilterPrivate
  83 {
  84   gpointer root;
  85   gint stamp;
  86   guint child_flags;
  87   GtkTreeModel *child_model;
  88   gint zero_ref_count;
  89
  90   GtkTreePath *virtual_root;
  91
  92   GtkTreeModelFilterVisibleFunc visible_func;
  93   gpointer visible_data;
  94   GDestroyNotify visible_destroy;
  95
  96   gint modify_n_columns;
  97   GType *modify_types;
  98   GtkTreeModelFilterModifyFunc modify_func;
  99   gpointer modify_data;
 100   GDestroyNotify modify_destroy;
 101
 102   gint visible_column;
 103
 104   gboolean visible_method_set;
 105   gboolean modify_func_set;
 106
 107   gboolean in_row_deleted;
 108   gboolean virtual_root_deleted;
 109
 110   /* signal ids */
 111   guint changed_id;
 112   guint inserted_id;
 113   guint has_child_toggled_id;
 114   guint deleted_id;
 115   guint reordered_id;
 116 };
 117
 118 /* properties */
 119 enum
 120 {
 121   PROP_0,
 122   PROP_CHILD_MODEL,
 123   PROP_VIRTUAL_ROOT
 124 };
 125
 126 #define GTK_TREE_MODEL_FILTER_CACHE_CHILD_ITERS(filter) \
 127         (((GtkTreeModelFilter *)filter)->priv->child_flags & GTK_TREE_MODEL_ITERS_PERSIST)
 128
 129 #define FILTER_ELT(filter_elt) ((FilterElt *)filter_elt)
 130 #define FILTER_LEVEL(filter_level) ((FilterLevel *)filter_level)
 131
 132 /* general code (object/interface init, properties, etc) */
 133 static void         gtk_tree_model_filter_tree_model_init                 (GtkTreeModelIface       *iface);
 134 static void         gtk_tree_model_filter_drag_source_init                (GtkTreeDragSourceIface  *iface);
 135 static void         gtk_tree_model_filter_finalize                        (GObject                 *object);
 136 static void         gtk_tree_model_filter_set_property                    (GObject                 *object,
 137                                                                            guint                    prop_id,
 138                                                                            const GValue            *value,
 139                                                                            GParamSpec              *pspec);
 140 static void         gtk_tree_model_filter_get_property                    (GObject                 *object,
 141                                                                            guint                    prop_id,
 142                                                                            GValue                 *value,
 143                                                                            GParamSpec             *pspec);
 144
 145 /* signal handlers */
 146 static void         gtk_tree_model_filter_row_changed                     (GtkTreeModel           *c_model,
 147                                                                            GtkTreePath            *c_path,
 148                                                                            GtkTreeIter            *c_iter,
 149                                                                            gpointer                data);
 150 static void         gtk_tree_model_filter_row_inserted                    (GtkTreeModel           *c_model,
 151                                                                            GtkTreePath            *c_path,
 152                                                                            GtkTreeIter            *c_iter,
 153                                                                            gpointer                data);
 154 static void         gtk_tree_model_filter_row_has_child_toggled           (GtkTreeModel           *c_model,
 155                                                                            GtkTreePath            *c_path,
 156                                                                            GtkTreeIter            *c_iter,
 157                                                                            gpointer                data);
 158 static void         gtk_tree_model_filter_row_deleted                     (GtkTreeModel           *c_model,
 159                                                                            GtkTreePath            *c_path,
 160                                                                            gpointer                data);
 161 static void         gtk_tree_model_filter_rows_reordered                  (GtkTreeModel           *c_model,
 162                                                                            GtkTreePath            *c_path,
 163                                                                            GtkTreeIter            *c_iter,
 164                                                                            gint                   *new_order,
 165                                                                            gpointer                data);
 166
 167 /* GtkTreeModel interface */
 168 static GtkTreeModelFlags gtk_tree_model_filter_get_flags                       (GtkTreeModel           *model);
 169 static gint         gtk_tree_model_filter_get_n_columns                   (GtkTreeModel           *model);
 170 static GType        gtk_tree_model_filter_get_column_type                 (GtkTreeModel           *model,
 171                                                                            gint                    index);
 172 static gboolean     gtk_tree_model_filter_get_iter_full                   (GtkTreeModel           *model,
 173                                                                            GtkTreeIter            *iter,
 174                                                                            GtkTreePath            *path);
 175 static gboolean     gtk_tree_model_filter_get_iter                        (GtkTreeModel           *model,
 176                                                                            GtkTreeIter            *iter,
 177                                                                            GtkTreePath            *path);
 178 static GtkTreePath *gtk_tree_model_filter_get_path                        (GtkTreeModel           *model,
 179                                                                            GtkTreeIter            *iter);
 180 static void         gtk_tree_model_filter_get_value                       (GtkTreeModel           *model,
 181                                                                            GtkTreeIter            *iter,
 182                                                                            gint                    column,
 183                                                                            GValue                 *value);
 184 static gboolean     gtk_tree_model_filter_iter_next                       (GtkTreeModel           *model,
 185                                                                            GtkTreeIter            *iter);
 186 static gboolean     gtk_tree_model_filter_iter_children                   (GtkTreeModel           *model,
 187                                                                            GtkTreeIter            *iter,
 188                                                                            GtkTreeIter            *parent);
 189 static gboolean     gtk_tree_model_filter_iter_has_child                  (GtkTreeModel           *model,
 190                                                                            GtkTreeIter            *iter);
 191 static gint         gtk_tree_model_filter_iter_n_children                 (GtkTreeModel           *model,
 192                                                                            GtkTreeIter            *iter);
 193 static gboolean     gtk_tree_model_filter_iter_nth_child                  (GtkTreeModel           *model,
 194                                                                            GtkTreeIter            *iter,
 195                                                                            GtkTreeIter            *parent,
 196                                                                            gint                    n);
 197 static gboolean     gtk_tree_model_filter_iter_parent                     (GtkTreeModel           *model,
 198                                                                            GtkTreeIter            *iter,
 199                                                                            GtkTreeIter            *child);
 200 static void         gtk_tree_model_filter_ref_node                        (GtkTreeModel           *model,
 201                                                                            GtkTreeIter            *iter);
 202 static void         gtk_tree_model_filter_unref_node                      (GtkTreeModel           *model,
 203                                                                            GtkTreeIter            *iter);
 204
 205 /* TreeDragSource interface */
 206 static gboolean    gtk_tree_model_filter_row_draggable                    (GtkTreeDragSource      *drag_source,
 207                                                                            GtkTreePath            *path);
 208 static gboolean    gtk_tree_model_filter_drag_data_get                    (GtkTreeDragSource      *drag_source,
 209                                                                            GtkTreePath            *path,
 210                                                                            GtkSelectionData       *selection_data);
 211 static gboolean    gtk_tree_model_filter_drag_data_delete                 (GtkTreeDragSource      *drag_source,
 212                                                                            GtkTreePath            *path);
 213
 214 /* private functions */
 215 static void        gtk_tree_model_filter_build_level                      (GtkTreeModelFilter     *filter,
 216                                                                            FilterLevel            *parent_level,
 217                                                                            FilterElt              *parent_elt,
 218                                                                            gboolean                emit_inserted);
 219
 220 static void        gtk_tree_model_filter_free_level                       (GtkTreeModelFilter     *filter,
 221                                                                            FilterLevel            *filter_level);
 222
 223 static GtkTreePath *gtk_tree_model_filter_elt_get_path                    (FilterLevel            *level,
 224                                                                            FilterElt              *elt,
 225                                                                            GtkTreePath            *root);
 226
 227 static GtkTreePath *gtk_tree_model_filter_add_root                        (GtkTreePath            *src,
 228                                                                            GtkTreePath            *root);
 229 static GtkTreePath *gtk_tree_model_filter_remove_root                     (GtkTreePath            *src,
 230                                                                            GtkTreePath            *root);
 231
 232 static void         gtk_tree_model_filter_increment_stamp                 (GtkTreeModelFilter     *filter);
 233
 234 static gboolean     gtk_tree_model_filter_visible                         (GtkTreeModelFilter     *filter,
 235                                                                            GtkTreeIter            *child_iter);
 236 static void         gtk_tree_model_filter_clear_cache_helper              (GtkTreeModelFilter     *filter,
 237                                                                            FilterLevel            *level);
 238
 239 static void         gtk_tree_model_filter_real_unref_node                 (GtkTreeModel           *model,
 240                                                                            GtkTreeIter            *iter,
 241                                                                            gboolean                propagate_unref);
 242
 243 static void         gtk_tree_model_filter_set_model                       (GtkTreeModelFilter     *filter,
 244                                                                            GtkTreeModel           *child_model);
 245 static void         gtk_tree_model_filter_ref_path                        (GtkTreeModelFilter     *filter,
 246                                                                            GtkTreePath            *path);
 247 static void         gtk_tree_model_filter_unref_path                      (GtkTreeModelFilter     *filter,
 248                                                                            GtkTreePath            *path);
 249 static void         gtk_tree_model_filter_set_root                        (GtkTreeModelFilter     *filter,
 250                                                                            GtkTreePath            *root);
 251
 252 static GtkTreePath *gtk_real_tree_model_filter_convert_child_path_to_path (GtkTreeModelFilter     *filter,
 253                                                                            GtkTreePath            *child_path,
 254                                                                            gboolean                build_levels,
 255                                                                            gboolean                fetch_children);
 256
 257 static FilterElt   *gtk_tree_model_filter_get_nth                         (GtkTreeModelFilter     *filter,
 258                                                                            FilterLevel            *level,
 259                                                                            int                     n);
 260 static gboolean    gtk_tree_model_filter_elt_is_visible_in_target         (FilterLevel            *level,
 261                                                                            FilterElt              *elt);
 262 static FilterElt   *gtk_tree_model_filter_get_nth_visible                 (GtkTreeModelFilter     *filter,
 263                                                                            FilterLevel            *level,
 264                                                                            int                     n);
 265
 266 static FilterElt   *gtk_tree_model_filter_fetch_child                     (GtkTreeModelFilter     *filter,
 267                                                                            FilterLevel            *level,
 268                                                                            gint                    offset,
 269                                                                            gint                   *index);
 270 static void         gtk_tree_model_filter_remove_node                     (GtkTreeModelFilter     *filter,
 271                                                                            GtkTreeIter            *iter);
 272 static void         gtk_tree_model_filter_update_children                 (GtkTreeModelFilter     *filter,
 273                                                                            FilterLevel            *level,
 274                                                                            FilterElt              *elt);
 275 static FilterElt   *bsearch_elt_with_offset                               (GArray                 *array,
 276                                                                            gint                   offset,
 277                                                                            gint                  *index);
 278
 279
 280 G_DEFINE_TYPE_WITH_CODE (GtkTreeModelFilter, gtk_tree_model_filter, G_TYPE_OBJECT,
 281                          G_IMPLEMENT_INTERFACE (GTK_TYPE_TREE_MODEL,
 282                                                 gtk_tree_model_filter_tree_model_init)
 283                          G_IMPLEMENT_INTERFACE (GTK_TYPE_TREE_DRAG_SOURCE,
 284                                                 gtk_tree_model_filter_drag_source_init))
 285
 286 static void
 287 gtk_tree_model_filter_init (GtkTreeModelFilter *filter)
 288 {
 289   filter->priv = GTK_TREE_MODEL_FILTER_GET_PRIVATE (filter);
 290
 291   filter->priv->visible_column = -1;
 292   filter->priv->zero_ref_count = 0;
 293   filter->priv->visible_method_set = FALSE;
 294   filter->priv->modify_func_set = FALSE;
 295   filter->priv->in_row_deleted = FALSE;
 296   filter->priv->virtual_root_deleted = FALSE;
 297 }
 298
 299 static void
 300 gtk_tree_model_filter_class_init (GtkTreeModelFilterClass *filter_class)
 301 {
 302   GObjectClass *object_class;
 303
 304   object_class = (GObjectClass *) filter_class;
 305
 306   object_class->set_property = gtk_tree_model_filter_set_property;
 307   object_class->get_property = gtk_tree_model_filter_get_property;
 308
 309   object_class->finalize = gtk_tree_model_filter_finalize;
 310
 311   /* Properties -- FIXME: disabled translations for now, until I can come up with a
 312    * better description
 313    */
 314   g_object_class_install_property (object_class,
 315                                    PROP_CHILD_MODEL,
 316                                    g_param_spec_object ("child-model",
 317                                                         ("The child model"),
 318                                                         ("The model for the filtermodel to filter"),
 319                                                         GTK_TYPE_TREE_MODEL,
 320                                                         GTK_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
 321
 322   g_object_class_install_property (object_class,
 323                                    PROP_VIRTUAL_ROOT,
 324                                    g_param_spec_boxed ("virtual-root",
 325                                                        ("The virtual root"),
 326                                                        ("The virtual root (relative to the child model) for this filtermodel"),
 327                                                        GTK_TYPE_TREE_PATH,
 328                                                        GTK_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
 329
 330   g_type_class_add_private (object_class, sizeof (GtkTreeModelFilterPrivate));
 331 }
 332
 333 static void
 334 gtk_tree_model_filter_tree_model_init (GtkTreeModelIface *iface)
 335 {
 336   iface->get_flags = gtk_tree_model_filter_get_flags;
 337   iface->get_n_columns = gtk_tree_model_filter_get_n_columns;
 338   iface->get_column_type = gtk_tree_model_filter_get_column_type;
 339   iface->get_iter = gtk_tree_model_filter_get_iter;
 340   iface->get_path = gtk_tree_model_filter_get_path;
 341   iface->get_value = gtk_tree_model_filter_get_value;
 342   iface->iter_next = gtk_tree_model_filter_iter_next;
 343   iface->iter_children = gtk_tree_model_filter_iter_children;
 344   iface->iter_has_child = gtk_tree_model_filter_iter_has_child;
 345   iface->iter_n_children = gtk_tree_model_filter_iter_n_children;
 346   iface->iter_nth_child = gtk_tree_model_filter_iter_nth_child;
 347   iface->iter_parent = gtk_tree_model_filter_iter_parent;
 348   iface->ref_node = gtk_tree_model_filter_ref_node;
 349   iface->unref_node = gtk_tree_model_filter_unref_node;
 350 }
 351
 352 static void
 353 gtk_tree_model_filter_drag_source_init (GtkTreeDragSourceIface *iface)
 354 {
 355   iface->row_draggable = gtk_tree_model_filter_row_draggable;
 356   iface->drag_data_delete = gtk_tree_model_filter_drag_data_delete;
 357   iface->drag_data_get = gtk_tree_model_filter_drag_data_get;
 358 }
 359
 360
 361 static void
 362 gtk_tree_model_filter_finalize (GObject *object)
 363 {
 364   GtkTreeModelFilter *filter = (GtkTreeModelFilter *) object;
 365
 366   if (filter->priv->virtual_root && !filter->priv->virtual_root_deleted)
 367     {
 368       gtk_tree_model_filter_unref_path (filter, filter->priv->virtual_root);
 369       filter->priv->virtual_root_deleted = TRUE;
 370     }
 371
 372   gtk_tree_model_filter_set_model (filter, NULL);
 373
 374   if (filter->priv->virtual_root)
 375     gtk_tree_path_free (filter->priv->virtual_root);
 376
 377   if (filter->priv->root)
 378     gtk_tree_model_filter_free_level (filter, filter->priv->root);
 379
 380   g_free (filter->priv->modify_types);
 381
 382   if (filter->priv->modify_destroy)
 383     filter->priv->modify_destroy (filter->priv->modify_data);
 384
 385   if (filter->priv->visible_destroy)
 386     filter->priv->visible_destroy (filter->priv->visible_data);
 387
 388   /* must chain up */
 389   G_OBJECT_CLASS (gtk_tree_model_filter_parent_class)->finalize (object);
 390 }
 391
 392 static void
 393 gtk_tree_model_filter_set_property (GObject      *object,
 394                                     guint         prop_id,
 395                                     const GValue *value,
 396                                     GParamSpec   *pspec)
 397 {
 398   GtkTreeModelFilter *filter = GTK_TREE_MODEL_FILTER (object);
 399
 400   switch (prop_id)
 401     {
 402       case PROP_CHILD_MODEL:
 403         gtk_tree_model_filter_set_model (filter, g_value_get_object (value));
 404         break;
 405       case PROP_VIRTUAL_ROOT:
 406         gtk_tree_model_filter_set_root (filter, g_value_get_boxed (value));
 407         break;
 408       default:
 409         G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 410         break;
 411     }
 412 }
 413
 414 static void
 415 gtk_tree_model_filter_get_property (GObject    *object,
 416                                     guint       prop_id,
 417                                     GValue     *value,
 418                                     GParamSpec *pspec)
 419 {
 420   GtkTreeModelFilter *filter = GTK_TREE_MODEL_FILTER (object);
 421
 422   switch (prop_id)
 423     {
 424       case PROP_CHILD_MODEL:
 425         g_value_set_object (value, filter->priv->child_model);
 426         break;
 427       case PROP_VIRTUAL_ROOT:
 428         g_value_set_boxed (value, filter->priv->virtual_root);
 429         break;
 430       default:
 431         G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 432         break;
 433     }
 434 }
 435
 436 /* helpers */
 437
 438 static void
 439 gtk_tree_model_filter_build_level (GtkTreeModelFilter *filter,
 440                                    FilterLevel        *parent_level,
 441                                    FilterElt          *parent_elt,
 442                                    gboolean            emit_inserted)
 443 {
 444   GtkTreeIter iter;
 445   GtkTreeIter first_node;
 446   GtkTreeIter root;
 447   FilterLevel *new_level;
 448   gint length = 0;
 449   gint i;
 450
 451   g_assert (filter->priv->child_model != NULL);
 452
 453   if (filter->priv->in_row_deleted)
 454     return;
 455
 456   if (!parent_level)
 457     {
 458       if (filter->priv->virtual_root)
 459         {
 460           if (gtk_tree_model_get_iter (filter->priv->child_model, &root, filter->priv->virtual_root) == FALSE)
 461             return;
 462           length = gtk_tree_model_iter_n_children (filter->priv->child_model, &root);
 463
 464           if (gtk_tree_model_iter_children (filter->priv->child_model, &iter, &root) == FALSE)
 465             return;
 466         }
 467       else
 468         {
 469           if (!gtk_tree_model_get_iter_first (filter->priv->child_model, &iter))
 470             return;
 471           length = gtk_tree_model_iter_n_children (filter->priv->child_model, NULL);
 472         }
 473     }
 474   else
 475     {
 476       GtkTreeIter parent_iter;
 477       GtkTreeIter child_parent_iter;
 478
 479       parent_iter.stamp = filter->priv->stamp;
 480       parent_iter.user_data = parent_level;
 481       parent_iter.user_data2 = parent_elt;
 482
 483       gtk_tree_model_filter_convert_iter_to_child_iter (filter,
 484                                                         &child_parent_iter,
 485                                                         &parent_iter);
 486       if (gtk_tree_model_iter_children (filter->priv->child_model, &iter, &child_parent_iter) == FALSE)
 487         return;
 488
 489       /* stamp may have changed */
 490       gtk_tree_model_filter_convert_iter_to_child_iter (filter,
 491                                                         &child_parent_iter,
 492                                                         &parent_iter);
 493       length = gtk_tree_model_iter_n_children (filter->priv->child_model, &child_parent_iter);
 494     }
 495
 496   g_return_if_fail (length > 0);
 497
 498   new_level = g_new (FilterLevel, 1);
 499   new_level->array = g_array_sized_new (FALSE, FALSE,
 500                                         sizeof (FilterElt),
 501                                         length);
 502   new_level->ref_count = 0;
 503   new_level->visible_nodes = 0;
 504   new_level->parent_elt = parent_elt;
 505   new_level->parent_level = parent_level;
 506
 507   if (parent_elt)
 508     parent_elt->children = new_level;
 509   else
 510     filter->priv->root = new_level;
 511
 512   /* increase the count of zero ref_counts */
 513   while (parent_level)
 514     {
 515       parent_elt->zero_ref_count++;
 516
 517       parent_elt = parent_level->parent_elt;
 518       parent_level = parent_level->parent_level;
 519     }
 520   if (new_level != filter->priv->root)
 521     filter->priv->zero_ref_count++;
 522
 523   i = 0;
 524
 525   first_node = iter;
 526
 527   do
 528     {
 529       if (gtk_tree_model_filter_visible (filter, &iter))
 530         {
 531           FilterElt filter_elt;
 532
 533           filter_elt.offset = i;
 534           filter_elt.zero_ref_count = 0;
 535           filter_elt.ref_count = 0;
 536           filter_elt.children = NULL;
 537           filter_elt.visible = TRUE;
 538
 539           if (GTK_TREE_MODEL_FILTER_CACHE_CHILD_ITERS (filter))
 540             filter_elt.iter = iter;
 541
 542           g_array_append_val (new_level->array, filter_elt);
 543           new_level->visible_nodes++;
 544
 545           if (new_level->parent_level || filter->priv->virtual_root)
 546             {
 547               GtkTreeIter f_iter;
 548
 549               f_iter.stamp = filter->priv->stamp;
 550               f_iter.user_data = new_level;
 551               f_iter.user_data2 = &(g_array_index (new_level->array, FilterElt, new_level->array->len - 1));
 552
 553               gtk_tree_model_filter_ref_node (GTK_TREE_MODEL (filter), &f_iter);
 554
 555               if (emit_inserted)
 556                 {
 557                   GtkTreePath *f_path;
 558
 559                   f_path = gtk_tree_model_get_path (GTK_TREE_MODEL (filter),
 560                                                     &f_iter);
 561                   gtk_tree_model_row_inserted (GTK_TREE_MODEL (filter),
 562                                                f_path, &f_iter);
 563                   gtk_tree_path_free (f_path);
 564                 }
 565             }
 566         }
 567       i++;
 568     }
 569   while (gtk_tree_model_iter_next (filter->priv->child_model, &iter));
 570
 571   if (new_level->array->len == 0
 572       && (new_level != filter->priv->root || filter->priv->virtual_root))
 573     {
 574       /* If none of the nodes are visible, we will just pull in the
 575        * first node of the level and keep a reference on it.  We need this
 576        * to make sure that we get all signals for this level.
 577        */
 578       FilterElt filter_elt;
 579       GtkTreeIter f_iter;
 580
 581       filter_elt.offset = 0;
 582       filter_elt.zero_ref_count = 0;
 583       filter_elt.ref_count = 0;
 584       filter_elt.children = NULL;
 585       filter_elt.visible = FALSE;
 586
 587       if (GTK_TREE_MODEL_FILTER_CACHE_CHILD_ITERS (filter))
 588         filter_elt.iter = first_node;
 589
 590       g_array_append_val (new_level->array, filter_elt);
 591
 592       f_iter.stamp = filter->priv->stamp;
 593       f_iter.user_data = new_level;
 594       f_iter.user_data2 = &(g_array_index (new_level->array, FilterElt, new_level->array->len - 1));
 595
 596       gtk_tree_model_filter_ref_node (GTK_TREE_MODEL (filter), &f_iter);
 597     }
 598   else if (new_level->array->len == 0)
 599     gtk_tree_model_filter_free_level (filter, new_level);
 600 }
 601
 602 static void
 603 gtk_tree_model_filter_free_level (GtkTreeModelFilter *filter,
 604                                   FilterLevel        *filter_level)
 605 {
 606   gint i;
 607
 608   g_assert (filter_level);
 609
 610   for (i = 0; i < filter_level->array->len; i++)
 611     {
 612       if (g_array_index (filter_level->array, FilterElt, i).children)
 613         gtk_tree_model_filter_free_level (filter,
 614                                           FILTER_LEVEL (g_array_index (filter_level->array, FilterElt, i).children));
 615
 616       if (filter_level->parent_level || filter->priv->virtual_root)
 617         {
 618           GtkTreeIter f_iter;
 619
 620           f_iter.stamp = filter->priv->stamp;
 621           f_iter.user_data = filter_level;
 622           f_iter.user_data2 = &(g_array_index (filter_level->array, FilterElt, i));
 623
 624           gtk_tree_model_filter_unref_node (GTK_TREE_MODEL (filter), &f_iter);
 625         }
 626     }
 627
 628   if (filter_level->ref_count == 0)
 629     {
 630       FilterLevel *parent_level = filter_level->parent_level;
 631       FilterElt *parent_elt = filter_level->parent_elt;
 632
 633       while (parent_level)
 634         {
 635           parent_elt->zero_ref_count--;
 636
 637           parent_elt = parent_level->parent_elt;
 638           parent_level = parent_level->parent_level;
 639         }
 640
 641       if (filter_level != filter->priv->root)
 642         filter->priv->zero_ref_count--;
 643     }
 644
 645   if (filter_level->parent_elt)
 646     filter_level->parent_elt->children = NULL;
 647   else
 648     filter->priv->root = NULL;
 649
 650   g_array_free (filter_level->array, TRUE);
 651   filter_level->array = NULL;
 652
 653   g_free (filter_level);
 654   filter_level = NULL;
 655 }
 656
 657 /* Creates paths suitable for accessing the child model. */
 658 static GtkTreePath *
 659 gtk_tree_model_filter_elt_get_path (FilterLevel *level,
 660                                     FilterElt   *elt,
 661                                     GtkTreePath *root)
 662 {
 663   FilterLevel *walker = level;
 664   FilterElt *walker2 = elt;
 665   GtkTreePath *path;
 666   GtkTreePath *real_path;
 667
 668   g_return_val_if_fail (level != NULL, NULL);
 669   g_return_val_if_fail (elt != NULL, NULL);
 670
 671   path = gtk_tree_path_new ();
 672
 673   while (walker)
 674     {
 675       gtk_tree_path_prepend_index (path, walker2->offset);
 676
 677       walker2 = walker->parent_elt;
 678       walker = walker->parent_level;
 679     }
 680
 681   if (root)
 682     {
 683       real_path = gtk_tree_model_filter_add_root (path, root);
 684       gtk_tree_path_free (path);
 685       return real_path;
 686     }
 687
 688   return path;
 689 }
 690
 691 static GtkTreePath *
 692 gtk_tree_model_filter_add_root (GtkTreePath *src,
 693                                 GtkTreePath *root)
 694 {
 695   GtkTreePath *retval;
 696   gint i;
 697
 698   retval = gtk_tree_path_copy (root);
 699
 700   for (i = 0; i < gtk_tree_path_get_depth (src); i++)
 701     gtk_tree_path_append_index (retval, gtk_tree_path_get_indices (src)[i]);
 702
 703   return retval;
 704 }
 705
 706 static GtkTreePath *
 707 gtk_tree_model_filter_remove_root (GtkTreePath *src,
 708                                    GtkTreePath *root)
 709 {
 710   GtkTreePath *retval;
 711   gint i;
 712   gint depth;
 713   gint *indices;
 714
 715   if (gtk_tree_path_get_depth (src) <= gtk_tree_path_get_depth (root))
 716     return NULL;
 717
 718   depth = gtk_tree_path_get_depth (src);
 719   indices = gtk_tree_path_get_indices (src);
 720
 721   for (i = 0; i < gtk_tree_path_get_depth (root); i++)
 722     if (indices[i] != gtk_tree_path_get_indices (root)[i])
 723       return NULL;
 724
 725   retval = gtk_tree_path_new ();
 726
 727   for (; i < depth; i++)
 728     gtk_tree_path_append_index (retval, indices[i]);
 729
 730   return retval;
 731 }
 732
 733 static void
 734 gtk_tree_model_filter_increment_stamp (GtkTreeModelFilter *filter)
 735 {
 736   do
 737     {
 738       filter->priv->stamp++;
 739     }
 740   while (filter->priv->stamp == 0);
 741
 742   gtk_tree_model_filter_clear_cache (filter);
 743 }
 744
 745 static gboolean
 746 gtk_tree_model_filter_visible (GtkTreeModelFilter *filter,
 747                                GtkTreeIter        *child_iter)
 748 {
 749   if (filter->priv->visible_func)
 750     {
 751       return filter->priv->visible_func (filter->priv->child_model,
 752                                          child_iter,
 753                                          filter->priv->visible_data)
 754         ? TRUE : FALSE;
 755     }
 756   else if (filter->priv->visible_column >= 0)
 757    {
 758      GValue val = {0, };
 759
 760      gtk_tree_model_get_value (filter->priv->child_model, child_iter,
 761                                filter->priv->visible_column, &val);
 762
 763      if (g_value_get_boolean (&val))
 764        {
 765          g_value_unset (&val);
 766          return TRUE;
 767        }
 768
 769      g_value_unset (&val);
 770      return FALSE;
 771    }
 772
 773   /* no visible function set, so always visible */
 774   return TRUE;
 775 }
 776
 777 static void
 778 gtk_tree_model_filter_clear_cache_helper (GtkTreeModelFilter *filter,
 779                                           FilterLevel        *level)
 780 {
 781   gint i;
 782
 783   g_assert (level);
 784
 785   for (i = 0; i < level->array->len; i++)
 786     {
 787       if (g_array_index (level->array, FilterElt, i).zero_ref_count > 0)
 788         gtk_tree_model_filter_clear_cache_helper (filter, g_array_index (level->array, FilterElt, i).children);
 789      }
 790
 791   if (level->ref_count == 0 && level != filter->priv->root)
 792     {
 793       gtk_tree_model_filter_free_level (filter, level);
 794       return;
 795     }
 796 }
 797
 798 static FilterElt *
 799 gtk_tree_model_filter_get_nth (GtkTreeModelFilter *filter,
 800                                FilterLevel        *level,
 801                                int                 n)
 802 {
 803   if (level->array->len <= n)
 804     return NULL;
 805
 806   return &g_array_index (level->array, FilterElt, n);
 807 }
 808
 809 static gboolean
 810 gtk_tree_model_filter_elt_is_visible_in_target (FilterLevel *level,
 811                                                 FilterElt   *elt)
 812 {
 813   if (!elt->visible)
 814     return FALSE;
 815
 816   if (!level->parent_elt)
 817     return TRUE;
 818
 819   do
 820     {
 821       elt = level->parent_elt;
 822       level = level->parent_level;
 823
 824       if (elt && !elt->visible)
 825         return FALSE;
 826     }
 827   while (level);
 828
 829   return TRUE;
 830 }
 831
 832 static FilterElt *
 833 gtk_tree_model_filter_get_nth_visible (GtkTreeModelFilter *filter,
 834                                        FilterLevel        *level,
 835                                        int                 n)
 836 {
 837   int i = 0;
 838   FilterElt *elt;
 839
 840   if (level->visible_nodes <= n)
 841     return NULL;
 842
 843   elt = FILTER_ELT (level->array->data);
 844   while (!elt->visible)
 845     elt++;
 846
 847   while (i < n)
 848     {
 849       if (elt->visible)
 850         i++;
 851       elt++;
 852     }
 853
 854   while (!elt->visible)
 855     elt++;
 856
 857   return elt;
 858 }
 859
 860 static FilterElt *
 861 gtk_tree_model_filter_fetch_child (GtkTreeModelFilter *filter,
 862                                    FilterLevel        *level,
 863                                    gint                offset,
 864                                    gint               *index)
 865 {
 866   gint i = 0;
 867   gint start, middle, end;
 868   gint len;
 869   GtkTreePath *c_path = NULL;
 870   GtkTreeIter c_iter;
 871   GtkTreePath *c_parent_path = NULL;
 872   GtkTreeIter c_parent_iter;
 873   FilterElt elt;
 874
 875   /* check if child exists and is visible */
 876   if (level->parent_elt)
 877     {
 878       c_parent_path =
 879         gtk_tree_model_filter_elt_get_path (level->parent_level,
 880                                             level->parent_elt,
 881                                             filter->priv->virtual_root);
 882       if (!c_parent_path)
 883         return NULL;
 884     }
 885   else
 886     {
 887       if (filter->priv->virtual_root)
 888         c_parent_path = gtk_tree_path_copy (filter->priv->virtual_root);
 889       else
 890         c_parent_path = NULL;
 891     }
 892
 893   if (c_parent_path)
 894     {
 895       gtk_tree_model_get_iter (filter->priv->child_model,
 896                                &c_parent_iter,
 897                                c_parent_path);
 898       len = gtk_tree_model_iter_n_children (filter->priv->child_model,
 899                                             &c_parent_iter);
 900
 901       c_path = gtk_tree_path_copy (c_parent_path);
 902       gtk_tree_path_free (c_parent_path);
 903     }
 904   else
 905     {
 906       len = gtk_tree_model_iter_n_children (filter->priv->child_model, NULL);
 907       c_path = gtk_tree_path_new ();
 908     }
 909
 910   gtk_tree_path_append_index (c_path, offset);
 911   gtk_tree_model_get_iter (filter->priv->child_model, &c_iter, c_path);
 912   gtk_tree_path_free (c_path);
 913
 914   if (offset >= len || !gtk_tree_model_filter_visible (filter, &c_iter))
 915     return NULL;
 916
 917   /* add child */
 918   elt.offset = offset;
 919   elt.zero_ref_count = 0;
 920   elt.ref_count = 0;
 921   elt.children = NULL;
 922   /* visibility should be FALSE as we don't emit row_inserted */
 923   elt.visible = FALSE;
 924
 925   if (GTK_TREE_MODEL_FILTER_CACHE_CHILD_ITERS (filter))
 926     elt.iter = c_iter;
 927
 928   /* find index (binary search on offset) */
 929   start = 0;
 930   end = level->array->len;
 931
 932   if (start != end)
 933     {
 934       while (start != end)
 935         {
 936           middle = (start + end) / 2;
 937
 938           if (g_array_index (level->array, FilterElt, middle).offset <= offset)
 939             start = middle + 1;
 940           else
 941             end = middle;
 942         }
 943
 944       if (g_array_index (level->array, FilterElt, middle).offset <= offset)
 945         i = middle + 1;
 946       else
 947         i = middle;
 948     }
 949   else
 950     i = 0;
 951
 952   g_array_insert_val (level->array, i, elt);
 953   *index = i;
 954
 955   for (i = 0; i < level->array->len; i++)
 956     {
 957       FilterElt *e = &(g_array_index (level->array, FilterElt, i));
 958       if (e->children)
 959         e->children->parent_elt = e;
 960     }
 961
 962   c_iter.stamp = filter->priv->stamp;
 963   c_iter.user_data = level;
 964   c_iter.user_data2 = &g_array_index (level->array, FilterElt, *index);
 965
 966   if (level->parent_level || filter->priv->virtual_root)
 967     gtk_tree_model_filter_ref_node (GTK_TREE_MODEL (filter), &c_iter);
 968
 969   return &g_array_index (level->array, FilterElt, *index);
 970 }
 971
 972 static void
 973 gtk_tree_model_filter_remove_node (GtkTreeModelFilter *filter,
 974                                    GtkTreeIter        *iter)
 975 {
 976   FilterElt *elt, *parent;
 977   FilterLevel *level, *parent_level;
 978   gint i, length;
 979
 980   gboolean emit_child_toggled = FALSE;
 981
 982   level = FILTER_LEVEL (iter->user_data);
 983   elt = FILTER_ELT (iter->user_data2);
 984
 985   parent = level->parent_elt;
 986   parent_level = level->parent_level;
 987
 988   length = level->array->len;
 989
 990   /* we distinguish a couple of cases:
 991    *  - root level, length > 1: emit row-deleted and remove.
 992    *  - root level, length == 1: emit row-deleted and keep in cache.
 993    *  - level, length == 1: parent->ref_count > 1: emit row-deleted and keep.
 994    *  - level, length > 1: emit row-deleted and remove.
 995    *  - else, remove level.
 996    *
 997    *  if level != root level and visible nodes == 0, emit row-has-child-toggled.
 998    */
 999
1000   if (level != filter->priv->root
1001       && level->visible_nodes == 0
1002       && level->parent_elt
1003       && level->parent_elt->visible)
1004     emit_child_toggled = TRUE;
1005
1006   if (length > 1)
1007     {
1008       GtkTreePath *path;
1009       FilterElt *tmp;
1010
1011       /* we emit row-deleted, and remove the node from the cache.
1012        */
1013
1014       path = gtk_tree_model_get_path (GTK_TREE_MODEL (filter), iter);
1015       elt->visible = FALSE;
1016       gtk_tree_model_filter_increment_stamp (filter);
1017       iter->stamp = filter->priv->stamp;
1018       gtk_tree_model_row_deleted (GTK_TREE_MODEL (filter), path);
1019       gtk_tree_path_free (path);
1020
1021       while (elt->ref_count > 1)
1022         gtk_tree_model_filter_real_unref_node (GTK_TREE_MODEL (filter),
1023                                                iter, FALSE);
1024
1025       if (parent_level || filter->priv->virtual_root)
1026         gtk_tree_model_filter_unref_node (GTK_TREE_MODEL (filter), iter);
1027       else if (elt->ref_count > 0)
1028         gtk_tree_model_filter_real_unref_node (GTK_TREE_MODEL (filter),
1029                                                iter, FALSE);
1030
1031       /* remove the node */
1032       tmp = bsearch_elt_with_offset (level->array, elt->offset, &i);
1033
1034       if (tmp)
1035         {
1036           g_array_remove_index (level->array, i);
1037
1038           i--;
1039           for (i = MAX (i, 0); i < level->array->len; i++)
1040             {
1041               /* NOTE: here we do *not* decrease offsets, because the node was
1042                * not removed from the child model
1043                */
1044               elt = &g_array_index (level->array, FilterElt, i);
1045               if (elt->children)
1046                 elt->children->parent_elt = elt;
1047             }
1048         }
1049     }
1050   else if ((length == 1 && parent && parent->ref_count > 1)
1051            || (length == 1 && level == filter->priv->root))
1052     {
1053       GtkTreePath *path;
1054
1055       /* we emit row-deleted, but keep the node in the cache and
1056        * referenced.
1057        */
1058
1059       path = gtk_tree_model_get_path (GTK_TREE_MODEL (filter), iter);
1060       elt->visible = FALSE;
1061       gtk_tree_model_filter_increment_stamp (filter);
1062       gtk_tree_model_row_deleted (GTK_TREE_MODEL (filter), path);
1063       gtk_tree_path_free (path);
1064     }
1065   else
1066     {
1067       GtkTreePath *path;
1068
1069       /* blow level away */
1070
1071       path = gtk_tree_model_get_path (GTK_TREE_MODEL (filter), iter);
1072       elt->visible = FALSE;
1073       gtk_tree_model_filter_increment_stamp (filter);
1074       iter->stamp = filter->priv->stamp;
1075       gtk_tree_model_row_deleted (GTK_TREE_MODEL (filter), path);
1076       gtk_tree_path_free (path);
1077
1078       while (elt->ref_count > 1)
1079         gtk_tree_model_filter_real_unref_node (GTK_TREE_MODEL (filter),
1080                                                iter, FALSE);
1081
1082       gtk_tree_model_filter_free_level (filter, level);
1083     }
1084
1085   if (emit_child_toggled)
1086     {
1087       GtkTreeIter piter;
1088       GtkTreePath *ppath;
1089
1090       piter.stamp = filter->priv->stamp;
1091       piter.user_data = parent_level;
1092       piter.user_data2 = parent;
1093
1094       ppath = gtk_tree_model_get_path (GTK_TREE_MODEL (filter), &piter);
1095
1096       gtk_tree_model_row_has_child_toggled (GTK_TREE_MODEL (filter),
1097                                             ppath, &piter);
1098       gtk_tree_path_free (ppath);
1099     }
1100 }
1101
1102 static void
1103 gtk_tree_model_filter_update_children (GtkTreeModelFilter *filter,
1104                                        FilterLevel        *level,
1105                                        FilterElt          *elt)
1106 {
1107   GtkTreeIter c_iter;
1108   GtkTreeIter iter;
1109
1110   if (!elt->visible)
1111     return;
1112
1113   iter.stamp = filter->priv->stamp;
1114   iter.user_data = level;
1115   iter.user_data2 = elt;
1116
1117   gtk_tree_model_filter_convert_iter_to_child_iter (filter, &c_iter, &iter);
1118
1119   if (gtk_tree_model_iter_has_child (filter->priv->child_model, &c_iter))
1120     {
1121       GtkTreePath *path = gtk_tree_model_get_path (GTK_TREE_MODEL (filter),
1122                                                    &iter);
1123       gtk_tree_model_row_has_child_toggled (GTK_TREE_MODEL (filter),
1124                                             path,
1125                                             &iter);
1126       if (path)
1127         gtk_tree_path_free (path);
1128     }
1129 }
1130
1131 static FilterElt *
1132 bsearch_elt_with_offset (GArray *array,
1133                          gint    offset,
1134                          gint   *index)
1135 {
1136   gint start, middle, end;
1137   FilterElt *elt;
1138
1139   start = 0;
1140   end = array->len;
1141
1142   if (array->len < 1)
1143     return NULL;
1144
1145   if (start == end)
1146     {
1147       elt = &g_array_index (array, FilterElt, 0);
1148
1149       if (elt->offset == offset)
1150         {
1151           *index = 0;
1152           return elt;
1153         }
1154       else
1155         return NULL;
1156     }
1157
1158   do
1159     {
1160       middle = (start + end) / 2;
1161
1162       elt = &g_array_index (array, FilterElt, middle);
1163
1164       if (elt->offset < offset)
1165         start = middle + 1;
1166       else if (elt->offset > offset)
1167         end = middle;
1168       else
1169         break;
1170     }
1171   while (start != end);
1172
1173   if (elt->offset == offset)
1174     {
1175       *index = middle;
1176       return elt;
1177     }
1178
1179   return NULL;
1180 }
1181
1182 /* TreeModel signals */
1183 static void
1184 gtk_tree_model_filter_row_changed (GtkTreeModel *c_model,
1185                                    GtkTreePath  *c_path,
1186                                    GtkTreeIter  *c_iter,
1187                                    gpointer      data)
1188 {
1189   GtkTreeModelFilter *filter = GTK_TREE_MODEL_FILTER (data);
1190   GtkTreeIter iter;
1191   GtkTreeIter children;
1192   GtkTreeIter real_c_iter;
1193   GtkTreePath *path = NULL;
1194
1195   FilterElt *elt;
1196   FilterLevel *level;
1197
1198   gboolean requested_state;
1199   gboolean current_state;
1200   gboolean free_c_path = FALSE;
1201
1202   g_return_if_fail (c_path != NULL || c_iter != NULL);
1203
1204   if (!c_path)
1205     {
1206       c_path = gtk_tree_model_get_path (c_model, c_iter);
1207       free_c_path = TRUE;
1208     }
1209
1210   if (c_iter)
1211     real_c_iter = *c_iter;
1212   else
1213     gtk_tree_model_get_iter (c_model, &real_c_iter, c_path);
1214
1215   /* is this node above the virtual root? */
1216   if (filter->priv->virtual_root
1217       && (gtk_tree_path_get_depth (filter->priv->virtual_root)
1218           >= gtk_tree_path_get_depth (c_path)))
1219     goto done;
1220
1221   /* what's the requested state? */
1222   requested_state = gtk_tree_model_filter_visible (filter, &real_c_iter);
1223
1224   /* now, let's see whether the item is there */
1225   path = gtk_real_tree_model_filter_convert_child_path_to_path (filter,
1226                                                                 c_path,
1227                                                                 FALSE,
1228                                                                 FALSE);
1229
1230   if (path)
1231     {
1232       gtk_tree_model_filter_get_iter_full (GTK_TREE_MODEL (filter),
1233                                            &iter, path);
1234       current_state = FILTER_ELT (iter.user_data2)->visible;
1235     }
1236   else
1237     current_state = FALSE;
1238
1239   if (current_state == FALSE && requested_state == FALSE)
1240     /* no changes required */
1241     goto done;
1242
1243   if (current_state == TRUE && requested_state == FALSE)
1244     {
1245       /* get rid of this node */
1246       level = FILTER_LEVEL (iter.user_data);
1247       level->visible_nodes--;
1248
1249       gtk_tree_model_filter_remove_node (filter, &iter);
1250
1251       goto done;
1252     }
1253
1254   if (current_state == TRUE && requested_state == TRUE)
1255     {
1256       /* propagate the signal; also get a path taking only visible
1257        * nodes into account.
1258        */
1259       gtk_tree_path_free (path);
1260       path = gtk_tree_model_get_path (GTK_TREE_MODEL (filter), &iter);
1261       gtk_tree_model_row_changed (GTK_TREE_MODEL (filter), path, &iter);
1262
1263       level = FILTER_LEVEL (iter.user_data);
1264       elt = FILTER_ELT (iter.user_data2);
1265
1266       /* and update the children */
1267       if (gtk_tree_model_iter_children (c_model, &children, &real_c_iter))
1268         gtk_tree_model_filter_update_children (filter, level, elt);
1269
1270       goto done;
1271     }
1272
1273   /* only current == FALSE and requested == TRUE is left,
1274    * pull in the child
1275    */
1276   g_return_if_fail (current_state == FALSE && requested_state == TRUE);
1277
1278   /* make sure the new item has been pulled in */
1279   if (!filter->priv->root)
1280     {
1281       gint i;
1282       FilterLevel *root;
1283
1284       gtk_tree_model_filter_build_level (filter, NULL, NULL, FALSE);
1285
1286       root = FILTER_LEVEL (filter->priv->root);
1287     }
1288
1289   gtk_tree_model_filter_increment_stamp (filter);
1290
1291   if (!path)
1292     path = gtk_real_tree_model_filter_convert_child_path_to_path (filter,
1293                                                                   c_path,
1294                                                                   TRUE,
1295                                                                   TRUE);
1296
1297   if (!path)
1298     /* parent is probably being filtered out */
1299     goto done;
1300
1301   gtk_tree_model_filter_get_iter_full (GTK_TREE_MODEL (filter), &iter, path);
1302
1303   level = FILTER_LEVEL (iter.user_data);
1304   elt = FILTER_ELT (iter.user_data2);
1305
1306   /* elt->visible can be TRUE at this point if it was pulled in above */
1307   if (!elt->visible)
1308     {
1309       elt->visible = TRUE;
1310       level->visible_nodes++;
1311     }
1312
1313   if (gtk_tree_model_filter_elt_is_visible_in_target (level, elt))
1314     {
1315       /* visibility changed -- reget path */
1316       gtk_tree_path_free (path);
1317       path = gtk_tree_model_get_path (GTK_TREE_MODEL (filter), &iter);
1318
1319       gtk_tree_model_row_inserted (GTK_TREE_MODEL (filter), path, &iter);
1320
1321       if (gtk_tree_model_iter_children (c_model, &children, c_iter))
1322         gtk_tree_model_filter_update_children (filter, level, elt);
1323     }
1324
1325 done:
1326   if (path)
1327     gtk_tree_path_free (path);
1328
1329   if (free_c_path)
1330     gtk_tree_path_free (c_path);
1331 }
1332
1333 static void
1334 gtk_tree_model_filter_row_inserted (GtkTreeModel *c_model,
1335                                     GtkTreePath  *c_path,
1336                                     GtkTreeIter  *c_iter,
1337                                     gpointer      data)
1338 {
1339   GtkTreeModelFilter *filter = GTK_TREE_MODEL_FILTER (data);
1340   GtkTreePath *path = NULL;
1341   GtkTreePath *real_path = NULL;
1342   GtkTreeIter iter;
1343
1344   GtkTreeIter real_c_iter;
1345
1346   FilterElt *elt;
1347   FilterLevel *level;
1348   FilterLevel *parent_level;
1349
1350   gint i = 0, offset;
1351
1352   gboolean free_c_path = FALSE;
1353
1354   g_return_if_fail (c_path != NULL || c_iter != NULL);
1355
1356   if (!c_path)
1357     {
1358       c_path = gtk_tree_model_get_path (c_model, c_iter);
1359       free_c_path = TRUE;
1360     }
1361
1362   if (c_iter)
1363     real_c_iter = *c_iter;
1364   else
1365     gtk_tree_model_get_iter (c_model, &real_c_iter, c_path);
1366
1367   /* the row has already been inserted. so we need to fixup the
1368    * virtual root here first
1369    */
1370   if (filter->priv->virtual_root)
1371     {
1372       if (gtk_tree_path_get_depth (filter->priv->virtual_root) >=
1373           gtk_tree_path_get_depth (c_path))
1374         {
1375           gint level;
1376           gint *v_indices, *c_indices;
1377           gboolean common_prefix = TRUE;
1378
1379           level = gtk_tree_path_get_depth (c_path) - 1;
1380           v_indices = gtk_tree_path_get_indices (filter->priv->virtual_root);
1381           c_indices = gtk_tree_path_get_indices (c_path);
1382
1383           for (i = 0; i < level; i++)
1384             if (v_indices[i] != c_indices[i])
1385               {
1386                 common_prefix = FALSE;
1387                 break;
1388               }
1389
1390           if (common_prefix && v_indices[level] >= c_indices[level])
1391             (v_indices[level])++;
1392         }
1393     }
1394
1395   if (!filter->priv->root)
1396     {
1397       /* No point in building the level if this node is not visible. */
1398       if (!filter->priv->virtual_root
1399           && !gtk_tree_model_filter_visible (filter, c_iter))
1400         goto done;
1401
1402       /* build level will pull in the new child */
1403       gtk_tree_model_filter_build_level (filter, NULL, NULL, FALSE);
1404
1405       if (filter->priv->root
1406           && FILTER_LEVEL (filter->priv->root)->visible_nodes)
1407         goto done_and_emit;
1408       else
1409         goto done;
1410     }
1411
1412   parent_level = level = FILTER_LEVEL (filter->priv->root);
1413
1414   /* subtract virtual root if necessary */
1415   if (filter->priv->virtual_root)
1416     {
1417       real_path = gtk_tree_model_filter_remove_root (c_path,
1418                                                      filter->priv->virtual_root);
1419       /* not our child */
1420       if (!real_path)
1421         goto done;
1422     }
1423   else
1424     real_path = gtk_tree_path_copy (c_path);
1425
1426   if (gtk_tree_path_get_depth (real_path) - 1 >= 1)
1427     {
1428       /* find the parent level */
1429       while (i < gtk_tree_path_get_depth (real_path) - 1)
1430         {
1431           gint j;
1432
1433           if (!level)
1434             /* we don't cover this signal */
1435             goto done;
1436
1437           elt = bsearch_elt_with_offset (level->array,
1438                                          gtk_tree_path_get_indices (real_path)[i],
1439                                          &j);
1440
1441           if (!elt)
1442             /* parent is probably being filtered out */
1443             goto done;
1444
1445           if (!elt->children)
1446             {
1447               GtkTreePath *tmppath;
1448               GtkTreeIter  tmpiter;
1449
1450               tmpiter.stamp = filter->priv->stamp;
1451               tmpiter.user_data = level;
1452               tmpiter.user_data2 = elt;
1453
1454               tmppath = gtk_tree_model_get_path (GTK_TREE_MODEL (data),
1455                                                  &tmpiter);
1456
1457               if (tmppath)
1458                 {
1459                   gtk_tree_model_row_has_child_toggled (GTK_TREE_MODEL (data),
1460                                                         tmppath, &tmpiter);
1461                   gtk_tree_path_free (tmppath);
1462                 }
1463
1464               /* not covering this signal */
1465               goto done;
1466             }
1467
1468           level = elt->children;
1469           parent_level = level;
1470           i++;
1471         }
1472     }
1473
1474   if (!parent_level)
1475     goto done;
1476
1477   /* let's try to insert the value */
1478   offset = gtk_tree_path_get_indices (real_path)[gtk_tree_path_get_depth (real_path) - 1];
1479
1480   /* update the offsets, yes if we didn't insert the node above, there will
1481    * be a gap here. This will be filled with the node (via fetch_child) when
1482    * it becomes visible
1483    */
1484   for (i = 0; i < level->array->len; i++)
1485     {
1486       FilterElt *e = &g_array_index (level->array, FilterElt, i);
1487       if ((e->offset >= offset))
1488         e->offset++;
1489     }
1490
1491   /* only insert when visible */
1492   if (gtk_tree_model_filter_visible (filter, &real_c_iter))
1493     {
1494       FilterElt felt;
1495
1496       if (GTK_TREE_MODEL_FILTER_CACHE_CHILD_ITERS (filter))
1497         felt.iter = real_c_iter;
1498
1499       felt.offset = offset;
1500       felt.zero_ref_count = 0;
1501       felt.ref_count = 0;
1502       felt.visible = TRUE;
1503       felt.children = NULL;
1504
1505       for (i = 0; i < level->array->len; i++)
1506         if (g_array_index (level->array, FilterElt, i).offset > offset)
1507           break;
1508
1509       level->visible_nodes++;
1510
1511       g_array_insert_val (level->array, i, felt);
1512
1513       if (level->parent_level || filter->priv->virtual_root)
1514         {
1515           GtkTreeIter f_iter;
1516
1517           f_iter.stamp = filter->priv->stamp;
1518           f_iter.user_data = level;
1519           f_iter.user_data2 = &g_array_index (level->array, FilterElt, i);
1520
1521           gtk_tree_model_filter_ref_node (GTK_TREE_MODEL (filter), &f_iter);
1522         }
1523     }
1524
1525   /* another iteration to update the references of children to parents. */
1526   for (i = 0; i < level->array->len; i++)
1527     {
1528       FilterElt *e = &g_array_index (level->array, FilterElt, i);
1529       if (e->children)
1530         e->children->parent_elt = e;
1531     }
1532
1533   /* don't emit the signal if we aren't visible */
1534   if (!gtk_tree_model_filter_visible (filter, &real_c_iter))
1535     goto done;
1536
1537 done_and_emit:
1538   /* NOTE: pass c_path here and NOT real_path. This function does
1539    * root subtraction itself
1540    */
1541   path = gtk_real_tree_model_filter_convert_child_path_to_path (filter,
1542                                                                 c_path,
1543                                                                 FALSE, TRUE);
1544
1545   if (!path)
1546     goto done;
1547
1548   gtk_tree_model_filter_increment_stamp (filter);
1549
1550   gtk_tree_model_filter_get_iter_full (GTK_TREE_MODEL (data), &iter, path);
1551
1552   /* get a path taking only visible nodes into account */
1553   gtk_tree_path_free (path);
1554   path = gtk_tree_model_get_path (GTK_TREE_MODEL (data), &iter);
1555
1556   gtk_tree_model_row_inserted (GTK_TREE_MODEL (data), path, &iter);
1557
1558   gtk_tree_path_free (path);
1559
1560 done:
1561   if (real_path)
1562     gtk_tree_path_free (real_path);
1563
1564   if (free_c_path)
1565     gtk_tree_path_free (c_path);
1566 }
1567
1568 static void
1569 gtk_tree_model_filter_row_has_child_toggled (GtkTreeModel *c_model,
1570                                              GtkTreePath  *c_path,
1571                                              GtkTreeIter  *c_iter,
1572                                              gpointer      data)
1573 {
1574   GtkTreeModelFilter *filter = GTK_TREE_MODEL_FILTER (data);
1575   GtkTreePath *path;
1576   GtkTreeIter iter;
1577   FilterLevel *level;
1578   FilterElt *elt;
1579
1580   g_return_if_fail (c_path != NULL && c_iter != NULL);
1581
1582   /* If we get row-has-child-toggled on the virtual root, and there is
1583    * no root level; try to build it now.
1584    */
1585   if (filter->priv->virtual_root && !filter->priv->root
1586       && !gtk_tree_path_compare (c_path, filter->priv->virtual_root))
1587     {
1588       gtk_tree_model_filter_build_level (filter, NULL, NULL, TRUE);
1589       return;
1590     }
1591
1592   if (!gtk_tree_model_filter_visible (filter, c_iter))
1593     return;
1594
1595   path = gtk_real_tree_model_filter_convert_child_path_to_path (filter,
1596                                                                 c_path,
1597                                                                 FALSE,
1598                                                                 TRUE);
1599   if (!path)
1600     return;
1601
1602   gtk_tree_model_filter_get_iter_full (GTK_TREE_MODEL (data), &iter, path);
1603
1604   gtk_tree_path_free (path);
1605
1606   level = FILTER_LEVEL (iter.user_data);
1607   elt = FILTER_ELT (iter.user_data2);
1608
1609   g_assert (elt->visible);
1610
1611   /* If this node is referenced and has children, build the level so we
1612    * can monitor it for changes.
1613    */
1614   if (elt->ref_count > 1 && gtk_tree_model_iter_has_child (c_model, c_iter))
1615     gtk_tree_model_filter_build_level (filter, level, elt, TRUE);
1616
1617   /* get a path taking only visible nodes into account */
1618   path = gtk_tree_model_get_path (GTK_TREE_MODEL (data), &iter);
1619   gtk_tree_model_row_has_child_toggled (GTK_TREE_MODEL (data), path, &iter);
1620   gtk_tree_path_free (path);
1621 }
1622
1623 static void
1624 gtk_tree_model_filter_row_deleted (GtkTreeModel *c_model,
1625                                    GtkTreePath  *c_path,
1626                                    gpointer      data)
1627 {
1628   GtkTreeModelFilter *filter = GTK_TREE_MODEL_FILTER (data);
1629   GtkTreePath *path;
1630   GtkTreeIter iter;
1631   FilterElt *elt, *parent = NULL;
1632   FilterLevel *level, *parent_level = NULL;
1633   gboolean emit_child_toggled = FALSE;
1634   gint offset;
1635   gint i;
1636
1637   g_return_if_fail (c_path != NULL);
1638
1639   /* special case the deletion of an ancestor of the virtual root */
1640   if (filter->priv->virtual_root &&
1641       (gtk_tree_path_is_ancestor (c_path, filter->priv->virtual_root) ||
1642        !gtk_tree_path_compare (c_path, filter->priv->virtual_root)))
1643     {
1644       gint i;
1645       GtkTreePath *path;
1646       FilterLevel *level = FILTER_LEVEL (filter->priv->root);
1647
1648       gtk_tree_model_filter_unref_path (filter, filter->priv->virtual_root);
1649       filter->priv->virtual_root_deleted = TRUE;
1650
1651       if (!level)
1652         return;
1653
1654       /* remove everything in the filter model
1655        *
1656        * For now, we just iterate over the root level and emit a
1657        * row_deleted for each FilterElt. Not sure if this is correct.
1658        */
1659
1660       gtk_tree_model_filter_increment_stamp (filter);
1661       path = gtk_tree_path_new ();
1662       gtk_tree_path_append_index (path, 0);
1663
1664       for (i = 0; i < level->visible_nodes; i++)
1665         gtk_tree_model_row_deleted (GTK_TREE_MODEL (data), path);
1666
1667       gtk_tree_path_free (path);
1668       gtk_tree_model_filter_free_level (filter, filter->priv->root);
1669
1670       return;
1671     }
1672
1673   /* fixup virtual root */
1674   if (filter->priv->virtual_root)
1675     {
1676       if (gtk_tree_path_get_depth (filter->priv->virtual_root) >=
1677           gtk_tree_path_get_depth (c_path))
1678         {
1679           gint level;
1680           gint *v_indices, *c_indices;
1681           gboolean common_prefix = TRUE;
1682
1683           level = gtk_tree_path_get_depth (c_path) - 1;
1684           v_indices = gtk_tree_path_get_indices (filter->priv->virtual_root);
1685           c_indices = gtk_tree_path_get_indices (c_path);
1686
1687           for (i = 0; i < level; i++)
1688             if (v_indices[i] != c_indices[i])
1689               {
1690                 common_prefix = FALSE;
1691                 break;
1692               }
1693
1694           if (common_prefix && v_indices[level] > c_indices[level])
1695             (v_indices[level])--;
1696         }
1697     }
1698
1699   path = gtk_real_tree_model_filter_convert_child_path_to_path (filter,
1700                                                                 c_path,
1701                                                                 FALSE,
1702                                                                 FALSE);
1703
1704   if (!path)
1705     {
1706       /* The node deleted in the child model is not visible in the
1707        * filter model.  We will not emit a signal, just fixup the offsets
1708        * of the other nodes.
1709        */
1710       GtkTreePath *real_path;
1711
1712       if (!filter->priv->root)
1713         return;
1714
1715       level = FILTER_LEVEL (filter->priv->root);
1716
1717       /* subtract vroot if necessary */
1718       if (filter->priv->virtual_root)
1719         {
1720           real_path = gtk_tree_model_filter_remove_root (c_path,
1721                                                          filter->priv->virtual_root);
1722           /* we don't handle this */
1723           if (!real_path)
1724             return;
1725         }
1726       else
1727         real_path = gtk_tree_path_copy (c_path);
1728
1729       i = 0;
1730       if (gtk_tree_path_get_depth (real_path) - 1 >= 1)
1731         {
1732           /* find the level where the deletion occurred */
1733           while (i < gtk_tree_path_get_depth (real_path) - 1)
1734             {
1735               gint j;
1736
1737               if (!level)
1738                 {
1739                   /* we don't cover this */
1740                   gtk_tree_path_free (real_path);
1741                   return;
1742                 }
1743
1744               elt = bsearch_elt_with_offset (level->array,
1745                                              gtk_tree_path_get_indices (real_path)[i],
1746                                              &j);
1747
1748               if (!elt || !elt->children)
1749                 {
1750                   /* parent is filtered out, so no level */
1751                   gtk_tree_path_free (real_path);
1752                   return;
1753                 }
1754
1755               level = elt->children;
1756               i++;
1757             }
1758         }
1759
1760       offset = gtk_tree_path_get_indices (real_path)[gtk_tree_path_get_depth (real_path) - 1];
1761       gtk_tree_path_free (real_path);
1762
1763       if (!level)
1764         return;
1765
1766       /* decrease offset of all nodes following the deleted node */
1767       for (i = 0; i < level->array->len; i++)
1768         {
1769           elt = &g_array_index (level->array, FilterElt, i);
1770           if (elt->offset > offset)
1771             elt->offset--;
1772           if (elt->children)
1773             elt->children->parent_elt = elt;
1774         }
1775
1776       return;
1777     }
1778
1779   /* a node was deleted, which was in our cache */
1780   gtk_tree_model_filter_get_iter_full (GTK_TREE_MODEL (data), &iter, path);
1781
1782   level = FILTER_LEVEL (iter.user_data);
1783   elt = FILTER_ELT (iter.user_data2);
1784   offset = elt->offset;
1785
1786   if (elt->visible)
1787     {
1788       /* get a path taking only visible nodes into account */
1789       gtk_tree_path_free (path);
1790       path = gtk_tree_model_get_path (GTK_TREE_MODEL (filter), &iter);
1791
1792       level->visible_nodes--;
1793
1794       if (level->visible_nodes == 0)
1795         {
1796           emit_child_toggled = TRUE;
1797           parent_level = level->parent_level;
1798           parent = level->parent_elt;
1799         }
1800
1801       /* emit row_deleted */
1802       gtk_tree_model_filter_increment_stamp (filter);
1803       gtk_tree_model_row_deleted (GTK_TREE_MODEL (data), path);
1804       iter.stamp = filter->priv->stamp;
1805     }
1806
1807   /* The filter model's reference on the child node is released
1808    * below.
1809    */
1810   while (elt->ref_count > 1)
1811     gtk_tree_model_filter_real_unref_node (GTK_TREE_MODEL (data), &iter,
1812                                            FALSE);
1813
1814   if (level->array->len == 1)
1815     {
1816       /* kill level */
1817       gtk_tree_model_filter_free_level (filter, level);
1818     }
1819   else
1820     {
1821       FilterElt *tmp;
1822
1823       /* release the filter model's reference on the node */
1824       if (level->parent_level || filter->priv->virtual_root)
1825         gtk_tree_model_filter_unref_node (GTK_TREE_MODEL (filter), &iter);
1826       else if (elt->ref_count > 0)
1827         gtk_tree_model_filter_real_unref_node (GTK_TREE_MODEL (data), &iter,
1828                                                FALSE);
1829
1830       /* remove the row */
1831       tmp = bsearch_elt_with_offset (level->array, elt->offset, &i);
1832
1833       offset = tmp->offset;
1834       g_array_remove_index (level->array, i);
1835
1836       i--;
1837       for (i = MAX (i, 0); i < level->array->len; i++)
1838         {
1839           elt = &g_array_index (level->array, FilterElt, i);
1840           if (elt->offset > offset)
1841             elt->offset--;
1842           if (elt->children)
1843             elt->children->parent_elt = elt;
1844         }
1845     }
1846
1847   if (emit_child_toggled && parent_level)
1848     {
1849       GtkTreeIter iter;
1850       GtkTreePath *path;
1851
1852       iter.stamp = filter->priv->stamp;
1853       iter.user_data = parent_level;
1854       iter.user_data2 = parent;
1855
1856       /* We set in_row_deleted to TRUE to avoid a level build triggered
1857        * by row-has-child-toggled (parent model could call iter_has_child
1858        * for example).
1859        */
1860       filter->priv->in_row_deleted = TRUE;
1861       path = gtk_tree_model_get_path (GTK_TREE_MODEL (filter), &iter);
1862       gtk_tree_model_row_has_child_toggled (GTK_TREE_MODEL (filter),
1863                                             path, &iter);
1864       gtk_tree_path_free (path);
1865       filter->priv->in_row_deleted = FALSE;
1866     }
1867
1868   gtk_tree_path_free (path);
1869 }
1870
1871 static void
1872 gtk_tree_model_filter_rows_reordered (GtkTreeModel *c_model,
1873                                       GtkTreePath  *c_path,
1874                                       GtkTreeIter  *c_iter,
1875                                       gint         *new_order,
1876                                       gpointer      data)
1877 {
1878   FilterElt *elt;
1879   FilterLevel *level;
1880   GtkTreeModelFilter *filter = GTK_TREE_MODEL_FILTER (data);
1881
1882   GtkTreePath *path;
1883   GtkTreeIter iter;
1884
1885   gint *tmp_array;
1886   gint i, j, elt_count;
1887   gint length;
1888
1889   GArray *new_array;
1890
1891   g_return_if_fail (new_order != NULL);
1892
1893   if (c_path == NULL || gtk_tree_path_get_depth (c_path) == 0)
1894     {
1895       length = gtk_tree_model_iter_n_children (c_model, NULL);
1896
1897       if (filter->priv->virtual_root)
1898         {
1899           gint new_pos = -1;
1900
1901           /* reorder root level of path */
1902           for (i = 0; i < length; i++)
1903             if (new_order[i] == gtk_tree_path_get_indices (filter->priv->virtual_root)[0])
1904               new_pos = i;
1905
1906           if (new_pos < 0)
1907             return;
1908
1909           gtk_tree_path_get_indices (filter->priv->virtual_root)[0] = new_pos;
1910           return;
1911         }
1912
1913       path = gtk_tree_path_new ();
1914       level = FILTER_LEVEL (filter->priv->root);
1915     }
1916   else
1917     {
1918       GtkTreeIter child_iter;
1919
1920       /* virtual root anchor reordering */
1921       if (filter->priv->virtual_root &&
1922           gtk_tree_path_is_ancestor (c_path, filter->priv->virtual_root))
1923         {
1924           gint new_pos = -1;
1925           gint length;
1926           gint level;
1927           GtkTreeIter real_c_iter;
1928
1929           level = gtk_tree_path_get_depth (c_path);
1930
1931           if (c_iter)
1932             real_c_iter = *c_iter;
1933           else
1934             gtk_tree_model_get_iter (c_model, &real_c_iter, c_path);
1935
1936           length = gtk_tree_model_iter_n_children (c_model, &real_c_iter);
1937
1938           for (i = 0; i < length; i++)
1939             if (new_order[i] == gtk_tree_path_get_indices (filter->priv->virtual_root)[level])
1940               new_pos = i;
1941
1942           if (new_pos < 0)
1943             return;
1944
1945           gtk_tree_path_get_indices (filter->priv->virtual_root)[level] = new_pos;
1946           return;
1947         }
1948
1949       path = gtk_real_tree_model_filter_convert_child_path_to_path (filter,
1950                                                                     c_path,
1951                                                                     FALSE,
1952                                                                     FALSE);
1953
1954       if (!path && filter->priv->virtual_root &&
1955           gtk_tree_path_compare (c_path, filter->priv->virtual_root))
1956         return;
1957
1958       if (!path && !filter->priv->virtual_root)
1959         return;
1960
1961       if (!path)
1962         {
1963           /* root level mode */
1964           if (!c_iter)
1965             gtk_tree_model_get_iter (c_model, c_iter, c_path);
1966           length = gtk_tree_model_iter_n_children (c_model, c_iter);
1967           path = gtk_tree_path_new ();
1968           level = FILTER_LEVEL (filter->priv->root);
1969         }
1970       else
1971         {
1972           gtk_tree_model_filter_get_iter_full (GTK_TREE_MODEL (data),
1973                                                &iter, path);
1974
1975           level = FILTER_LEVEL (iter.user_data);
1976           elt = FILTER_ELT (iter.user_data2);
1977
1978           if (!elt->children)
1979             {
1980               gtk_tree_path_free (path);
1981               return;
1982             }
1983
1984           level = elt->children;
1985
1986           gtk_tree_model_filter_convert_iter_to_child_iter (GTK_TREE_MODEL_FILTER (filter), &child_iter, &iter);
1987           length = gtk_tree_model_iter_n_children (c_model, &child_iter);
1988         }
1989     }
1990
1991   if (!level || level->array->len < 1)
1992     {
1993       gtk_tree_path_free (path);
1994       return;
1995     }
1996
1997   /* NOTE: we do not bail out here if level->array->len < 2 like
1998    * GtkTreeModelSort does. This because we do some special tricky
1999    * reordering.
2000    */
2001
2002   /* construct a new array */
2003   new_array = g_array_sized_new (FALSE, FALSE, sizeof (FilterElt),
2004                                  level->array->len);
2005   tmp_array = g_new (gint, level->array->len);
2006
2007   for (i = 0, elt_count = 0; i < length; i++)
2008     {
2009       FilterElt *e = NULL;
2010       gint old_offset = -1;
2011
2012       for (j = 0; j < level->array->len; j++)
2013         if (g_array_index (level->array, FilterElt, j).offset == new_order[i])
2014           {
2015             e = &g_array_index (level->array, FilterElt, j);
2016             old_offset = j;
2017             break;
2018           }
2019
2020       if (!e)
2021         continue;
2022
2023       tmp_array[elt_count] = old_offset;
2024       g_array_append_val (new_array, *e);
2025       g_array_index (new_array, FilterElt, elt_count).offset = i;
2026       elt_count++;
2027     }
2028
2029   g_array_free (level->array, TRUE);
2030   level->array = new_array;
2031
2032   /* fix up stuff */
2033   for (i = 0; i < level->array->len; i++)
2034     {
2035       FilterElt *e = &g_array_index (level->array, FilterElt, i);
2036       if (e->children)
2037         e->children->parent_elt = e;
2038     }
2039
2040   /* emit rows_reordered */
2041   if (!gtk_tree_path_get_indices (path))
2042     gtk_tree_model_rows_reordered (GTK_TREE_MODEL (data), path, NULL,
2043                                    tmp_array);
2044   else
2045     {
2046       /* get a path taking only visible nodes into account */
2047       gtk_tree_path_free (path);
2048       path = gtk_tree_model_get_path (GTK_TREE_MODEL (data), &iter);
2049
2050       gtk_tree_model_rows_reordered (GTK_TREE_MODEL (data), path, &iter,
2051                                      tmp_array);
2052     }
2053
2054   /* done */
2055   g_free (tmp_array);
2056   gtk_tree_path_free (path);
2057 }
2058
2059 /* TreeModelIface implementation */
2060 static GtkTreeModelFlags
2061 gtk_tree_model_filter_get_flags (GtkTreeModel *model)
2062 {
2063   GtkTreeModelFlags flags;
2064
2065   g_return_val_if_fail (GTK_IS_TREE_MODEL_FILTER (model), 0);
2066   g_return_val_if_fail (GTK_TREE_MODEL_FILTER (model)->priv->child_model != NULL, 0);
2067
2068   flags = gtk_tree_model_get_flags (GTK_TREE_MODEL_FILTER (model)->priv->child_model);
2069
2070   if ((flags & GTK_TREE_MODEL_LIST_ONLY) == GTK_TREE_MODEL_LIST_ONLY)
2071     return GTK_TREE_MODEL_LIST_ONLY;
2072
2073   return 0;
2074 }
2075
2076 static gint
2077 gtk_tree_model_filter_get_n_columns (GtkTreeModel *model)
2078 {
2079   GtkTreeModelFilter *filter = (GtkTreeModelFilter *)model;
2080
2081   g_return_val_if_fail (GTK_IS_TREE_MODEL_FILTER (model), 0);
2082   g_return_val_if_fail (filter->priv->child_model != NULL, 0);
2083
2084   if (filter->priv->child_model == NULL)
2085     return 0;
2086
2087   /* so we can't modify the modify func after this ... */
2088   filter->priv->modify_func_set = TRUE;
2089
2090   if (filter->priv->modify_n_columns > 0)
2091     return filter->priv->modify_n_columns;
2092
2093   return gtk_tree_model_get_n_columns (filter->priv->child_model);
2094 }
2095
2096 static GType
2097 gtk_tree_model_filter_get_column_type (GtkTreeModel *model,
2098                                        gint          index)
2099 {
2100   GtkTreeModelFilter *filter = (GtkTreeModelFilter *)model;
2101
2102   g_return_val_if_fail (GTK_IS_TREE_MODEL_FILTER (model), G_TYPE_INVALID);
2103   g_return_val_if_fail (filter->priv->child_model != NULL, G_TYPE_INVALID);
2104
2105   /* so we can't modify the modify func after this ... */
2106   filter->priv->modify_func_set = TRUE;
2107
2108   if (filter->priv->modify_types)
2109     {
2110       g_return_val_if_fail (index < filter->priv->modify_n_columns, G_TYPE_INVALID);
2111
2112       return filter->priv->modify_types[index];
2113     }
2114
2115   return gtk_tree_model_get_column_type (filter->priv->child_model, index);
2116 }
2117
2118 /* A special case of _get_iter; this function can also get iters which
2119  * are not visible.  These iters should ONLY be passed internally, never
2120  * pass those along with a signal emission.
2121  */
2122 static gboolean
2123 gtk_tree_model_filter_get_iter_full (GtkTreeModel *model,
2124                                      GtkTreeIter  *iter,
2125                                      GtkTreePath  *path)
2126 {
2127   GtkTreeModelFilter *filter = (GtkTreeModelFilter *)model;
2128   gint *indices;
2129   FilterLevel *level;
2130   FilterElt *elt;
2131   gint depth, i;
2132   g_return_val_if_fail (GTK_IS_TREE_MODEL_FILTER (model), FALSE);
2133   g_return_val_if_fail (filter->priv->child_model != NULL, FALSE);
2134
2135   indices = gtk_tree_path_get_indices (path);
2136
2137   if (filter->priv->root == NULL)
2138     gtk_tree_model_filter_build_level (filter, NULL, NULL, FALSE);
2139   level = FILTER_LEVEL (filter->priv->root);
2140
2141   depth = gtk_tree_path_get_depth (path);
2142   if (!depth)
2143     {
2144       iter->stamp = 0;
2145       return FALSE;
2146     }
2147
2148   for (i = 0; i < depth - 1; i++)
2149     {
2150       if (!level || indices[i] >= level->array->len)
2151         {
2152           return FALSE;
2153         }
2154
2155       elt = gtk_tree_model_filter_get_nth (filter, level, indices[i]);
2156
2157       if (!elt->children)
2158         gtk_tree_model_filter_build_level (filter, level, elt, FALSE);
2159       level = elt->children;
2160     }
2161
2162   if (!level || indices[i] >= level->array->len)
2163     {
2164       iter->stamp = 0;
2165       return FALSE;
2166     }
2167
2168   iter->stamp = filter->priv->stamp;
2169   iter->user_data = level;
2170
2171   elt = gtk_tree_model_filter_get_nth (filter, level, indices[depth - 1]);
2172   iter->user_data2 = elt;
2173
2174   return TRUE;
2175 }
2176
2177 static gboolean
2178 gtk_tree_model_filter_get_iter (GtkTreeModel *model,
2179                                 GtkTreeIter  *iter,
2180                                 GtkTreePath  *path)
2181 {
2182   GtkTreeModelFilter *filter = (GtkTreeModelFilter *)model;
2183   gint *indices;
2184   FilterLevel *level;
2185   FilterElt *elt;
2186   gint depth, i;
2187   g_return_val_if_fail (GTK_IS_TREE_MODEL_FILTER (model), FALSE);
2188   g_return_val_if_fail (filter->priv->child_model != NULL, FALSE);
2189
2190   indices = gtk_tree_path_get_indices (path);
2191
2192   if (filter->priv->root == NULL)
2193     gtk_tree_model_filter_build_level (filter, NULL, NULL, FALSE);
2194   level = FILTER_LEVEL (filter->priv->root);
2195
2196   depth = gtk_tree_path_get_depth (path);
2197   if (!depth)
2198     {
2199       iter->stamp = 0;
2200       return FALSE;
2201     }
2202
2203   for (i = 0; i < depth - 1; i++)
2204     {
2205       if (!level || indices[i] >= level->visible_nodes)
2206         {
2207           return FALSE;
2208         }
2209
2210       elt = gtk_tree_model_filter_get_nth_visible (filter, level, indices[i]);
2211
2212       if (!elt->children)
2213         gtk_tree_model_filter_build_level (filter, level, elt, FALSE);
2214       level = elt->children;
2215     }
2216
2217   if (!level || indices[i] >= level->visible_nodes)
2218     {
2219       iter->stamp = 0;
2220       return FALSE;
2221     }
2222
2223   iter->stamp = filter->priv->stamp;
2224   iter->user_data = level;
2225
2226   elt = gtk_tree_model_filter_get_nth_visible (filter, level,
2227                                                indices[depth - 1]);
2228   iter->user_data2 = elt;
2229
2230   return TRUE;
2231 }
2232
2233 static GtkTreePath *
2234 gtk_tree_model_filter_get_path (GtkTreeModel *model,
2235                                 GtkTreeIter  *iter)
2236 {
2237   GtkTreePath *retval;
2238   FilterLevel *level;
2239   FilterElt *elt;
2240
2241   g_return_val_if_fail (GTK_IS_TREE_MODEL_FILTER (model), NULL);
2242   g_return_val_if_fail (GTK_TREE_MODEL_FILTER (model)->priv->child_model != NULL, NULL);
2243   g_return_val_if_fail (GTK_TREE_MODEL_FILTER (model)->priv->stamp == iter->stamp, NULL);
2244
2245   level = iter->user_data;
2246   elt = iter->user_data2;
2247
2248   if (!elt->visible)
2249     return NULL;
2250
2251   retval = gtk_tree_path_new ();
2252
2253   while (level)
2254     {
2255       int i = 0, index = 0;
2256
2257       while (&g_array_index (level->array, FilterElt, i) != elt)
2258         {
2259           if (g_array_index (level->array, FilterElt, i).visible)
2260             index++;
2261           i++;
2262
2263           g_assert (i < level->array->len);
2264         }
2265
2266       gtk_tree_path_prepend_index (retval, index);
2267       elt = level->parent_elt;
2268       level = level->parent_level;
2269     }
2270
2271   return retval;
2272 }
2273
2274 static void
2275 gtk_tree_model_filter_get_value (GtkTreeModel *model,
2276                                  GtkTreeIter  *iter,
2277                                  gint          column,
2278                                  GValue       *value)
2279 {
2280   GtkTreeIter child_iter;
2281   GtkTreeModelFilter *filter = GTK_TREE_MODEL_FILTER (model);
2282
2283   g_return_if_fail (GTK_IS_TREE_MODEL_FILTER (model));
2284   g_return_if_fail (GTK_TREE_MODEL_FILTER (model)->priv->child_model != NULL);
2285   g_return_if_fail (GTK_TREE_MODEL_FILTER (model)->priv->stamp == iter->stamp);
2286
2287   if (filter->priv->modify_func)
2288     {
2289       g_return_if_fail (column < filter->priv->modify_n_columns);
2290
2291       g_value_init (value, filter->priv->modify_types[column]);
2292       filter->priv->modify_func (model,
2293                            iter,
2294                            value,
2295                            column,
2296                            filter->priv->modify_data);
2297
2298       return;
2299     }
2300
2301   gtk_tree_model_filter_convert_iter_to_child_iter (GTK_TREE_MODEL_FILTER (model), &child_iter, iter);
2302   gtk_tree_model_get_value (GTK_TREE_MODEL_FILTER (model)->priv->child_model,
2303                             &child_iter, column, value);
2304 }
2305
2306 static gboolean
2307 gtk_tree_model_filter_iter_next (GtkTreeModel *model,
2308                                  GtkTreeIter  *iter)
2309 {
2310   int i;
2311   FilterLevel *level;
2312   FilterElt *elt;
2313
2314   g_return_val_if_fail (GTK_IS_TREE_MODEL_FILTER (model), FALSE);
2315   g_return_val_if_fail (GTK_TREE_MODEL_FILTER (model)->priv->child_model != NULL, FALSE);
2316   g_return_val_if_fail (GTK_TREE_MODEL_FILTER (model)->priv->stamp == iter->stamp, FALSE);
2317
2318   level = iter->user_data;
2319   elt = iter->user_data2;
2320
2321   i = elt - FILTER_ELT (level->array->data);
2322
2323   while (i < level->array->len - 1)
2324     {
2325       i++;
2326       elt++;
2327
2328       if (elt->visible)
2329         {
2330           iter->user_data2 = elt;
2331           return TRUE;
2332         }
2333     }
2334
2335   /* no next visible iter */
2336   iter->stamp = 0;
2337
2338   return FALSE;
2339 }
2340
2341 static gboolean
2342 gtk_tree_model_filter_iter_children (GtkTreeModel *model,
2343                                      GtkTreeIter  *iter,
2344                                      GtkTreeIter  *parent)
2345 {
2346   GtkTreeModelFilter *filter = (GtkTreeModelFilter *)model;
2347   FilterLevel *level;
2348
2349   iter->stamp = 0;
2350   g_return_val_if_fail (GTK_IS_TREE_MODEL_FILTER (model), FALSE);
2351   g_return_val_if_fail (filter->priv->child_model != NULL, FALSE);
2352   if (parent)
2353     g_return_val_if_fail (filter->priv->stamp == parent->stamp, FALSE);
2354
2355   if (!parent)
2356     {
2357       int i = 0;
2358
2359       if (!filter->priv->root)
2360         gtk_tree_model_filter_build_level (filter, NULL, NULL, FALSE);
2361       if (!filter->priv->root)
2362         return FALSE;
2363
2364       level = filter->priv->root;
2365
2366       if (!level->visible_nodes)
2367         return FALSE;
2368
2369       iter->stamp = filter->priv->stamp;
2370       iter->user_data = level;
2371
2372       while (i < level->array->len)
2373         {
2374           if (!g_array_index (level->array, FilterElt, i).visible)
2375             {
2376               i++;
2377               continue;
2378             }
2379
2380           iter->user_data2 = &g_array_index (level->array, FilterElt, i);
2381           return TRUE;
2382         }
2383
2384       iter->stamp = 0;
2385       return FALSE;
2386     }
2387   else
2388     {
2389       int i = 0;
2390
2391       if (FILTER_ELT (parent->user_data2)->children == NULL)
2392         gtk_tree_model_filter_build_level (filter,
2393                                            FILTER_LEVEL (parent->user_data),
2394                                            FILTER_ELT (parent->user_data2),
2395                                            FALSE);
2396       if (FILTER_ELT (parent->user_data2)->children == NULL)
2397         return FALSE;
2398
2399       if (FILTER_ELT (parent->user_data2)->children->visible_nodes <= 0)
2400         return FALSE;
2401
2402       iter->stamp = filter->priv->stamp;
2403       iter->user_data = FILTER_ELT (parent->user_data2)->children;
2404
2405       level = FILTER_LEVEL (iter->user_data);
2406
2407       while (i < level->array->len)
2408         {
2409           if (!g_array_index (level->array, FilterElt, i).visible)
2410             {
2411               i++;
2412               continue;
2413             }
2414
2415           iter->user_data2 = &g_array_index (level->array, FilterElt, i);
2416           return TRUE;
2417         }
2418
2419       iter->stamp = 0;
2420       return FALSE;
2421     }
2422
2423   iter->stamp = 0;
2424   return FALSE;
2425 }
2426
2427 static gboolean
2428 gtk_tree_model_filter_iter_has_child (GtkTreeModel *model,
2429                                       GtkTreeIter  *iter)
2430 {
2431   GtkTreeIter child_iter;
2432   GtkTreeModelFilter *filter = (GtkTreeModelFilter *)model;
2433   FilterElt *elt;
2434
2435   g_return_val_if_fail (GTK_IS_TREE_MODEL_FILTER (model), FALSE);
2436   g_return_val_if_fail (filter->priv->child_model != NULL, FALSE);
2437   g_return_val_if_fail (filter->priv->stamp == iter->stamp, FALSE);
2438
2439   filter = GTK_TREE_MODEL_FILTER (model);
2440
2441   gtk_tree_model_filter_convert_iter_to_child_iter (GTK_TREE_MODEL_FILTER (model), &child_iter, iter);
2442   elt = FILTER_ELT (iter->user_data2);
2443
2444   if (!elt->visible)
2445     return FALSE;
2446
2447   /* we need to build the level to check if not all children are filtered
2448    * out
2449    */
2450   if (!elt->children
2451       && gtk_tree_model_iter_has_child (filter->priv->child_model, &child_iter))
2452     gtk_tree_model_filter_build_level (filter, FILTER_LEVEL (iter->user_data),
2453                                        elt, FALSE);
2454
2455   if (elt->children && elt->children->visible_nodes > 0)
2456     return TRUE;
2457
2458   return FALSE;
2459 }
2460
2461 static gint
2462 gtk_tree_model_filter_iter_n_children (GtkTreeModel *model,
2463                                        GtkTreeIter  *iter)
2464 {
2465   GtkTreeIter child_iter;
2466   GtkTreeModelFilter *filter = (GtkTreeModelFilter *)model;
2467   FilterElt *elt;
2468
2469   g_return_val_if_fail (GTK_IS_TREE_MODEL_FILTER (model), 0);
2470   g_return_val_if_fail (filter->priv->child_model != NULL, 0);
2471   if (iter)
2472     g_return_val_if_fail (filter->priv->stamp == iter->stamp, 0);
2473
2474   if (!iter)
2475     {
2476       if (!filter->priv->root)
2477         gtk_tree_model_filter_build_level (filter, NULL, NULL, FALSE);
2478
2479       if (filter->priv->root)
2480         return FILTER_LEVEL (filter->priv->root)->visible_nodes;
2481
2482       return 0;
2483     }
2484
2485   elt = FILTER_ELT (iter->user_data2);
2486
2487   if (!elt->visible)
2488     return 0;
2489
2490   gtk_tree_model_filter_convert_iter_to_child_iter (GTK_TREE_MODEL_FILTER (model), &child_iter, iter);
2491
2492   if (!elt->children &&
2493       gtk_tree_model_iter_has_child (filter->priv->child_model, &child_iter))
2494     gtk_tree_model_filter_build_level (filter,
2495                                        FILTER_LEVEL (iter->user_data),
2496                                        elt, FALSE);
2497
2498   if (elt->children)
2499     return elt->children->visible_nodes;
2500
2501   return 0;
2502 }
2503
2504 static gboolean
2505 gtk_tree_model_filter_iter_nth_child (GtkTreeModel *model,
2506                                       GtkTreeIter  *iter,
2507                                       GtkTreeIter  *parent,
2508                                       gint          n)
2509 {
2510   FilterElt *elt;
2511   FilterLevel *level;
2512   GtkTreeIter children;
2513
2514   g_return_val_if_fail (GTK_IS_TREE_MODEL_FILTER (model), FALSE);
2515   if (parent)
2516     g_return_val_if_fail (GTK_TREE_MODEL_FILTER (model)->priv->stamp == parent->stamp, FALSE);
2517
2518   /* use this instead of has_child to force us to build the level, if needed */
2519   if (gtk_tree_model_filter_iter_children (model, &children, parent) == FALSE)
2520     {
2521       iter->stamp = 0;
2522       return FALSE;
2523     }
2524
2525   level = children.user_data;
2526   elt = FILTER_ELT (level->array->data);
2527
2528   if (n >= level->visible_nodes)
2529     {
2530       iter->stamp = 0;
2531       return FALSE;
2532     }
2533
2534   elt = gtk_tree_model_filter_get_nth_visible (GTK_TREE_MODEL_FILTER (model),
2535                                                level, n);
2536
2537   iter->stamp = GTK_TREE_MODEL_FILTER (model)->priv->stamp;
2538   iter->user_data = level;
2539   iter->user_data2 = elt;
2540
2541   return TRUE;
2542 }
2543
2544 static gboolean
2545 gtk_tree_model_filter_iter_parent (GtkTreeModel *model,
2546                                    GtkTreeIter  *iter,
2547                                    GtkTreeIter  *child)
2548 {
2549   FilterLevel *level;
2550
2551   iter->stamp = 0;
2552   g_return_val_if_fail (GTK_IS_TREE_MODEL_FILTER (model), FALSE);
2553   g_return_val_if_fail (GTK_TREE_MODEL_FILTER (model)->priv->child_model != NULL, FALSE);
2554   g_return_val_if_fail (GTK_TREE_MODEL_FILTER (model)->priv->stamp == child->stamp, FALSE);
2555
2556   level = child->user_data;
2557
2558   if (level->parent_level)
2559     {
2560       iter->stamp = GTK_TREE_MODEL_FILTER (model)->priv->stamp;
2561       iter->user_data = level->parent_level;
2562       iter->user_data2 = level->parent_elt;
2563
2564       return TRUE;
2565     }
2566
2567   return FALSE;
2568 }
2569
2570 static void
2571 gtk_tree_model_filter_ref_node (GtkTreeModel *model,
2572                                 GtkTreeIter  *iter)
2573 {
2574   GtkTreeModelFilter *filter = (GtkTreeModelFilter *)model;
2575   GtkTreeIter child_iter;
2576   FilterLevel *level;
2577   FilterElt *elt;
2578
2579   g_return_if_fail (GTK_IS_TREE_MODEL_FILTER (model));
2580   g_return_if_fail (GTK_TREE_MODEL_FILTER (model)->priv->child_model != NULL);
2581   g_return_if_fail (GTK_TREE_MODEL_FILTER (model)->priv->stamp == iter->stamp);
2582
2583   gtk_tree_model_filter_convert_iter_to_child_iter (GTK_TREE_MODEL_FILTER (model), &child_iter, iter);
2584
2585   gtk_tree_model_ref_node (filter->priv->child_model, &child_iter);
2586
2587   level = iter->user_data;
2588   elt = iter->user_data2;
2589
2590   elt->ref_count++;
2591   level->ref_count++;
2592   if (level->ref_count == 1)
2593     {
2594       FilterLevel *parent_level = level->parent_level;
2595       FilterElt *parent_elt = level->parent_elt;
2596
2597       /* we were at zero -- time to decrease the zero_ref_count val */
2598       while (parent_level)
2599         {
2600           parent_elt->zero_ref_count--;
2601
2602           parent_elt = parent_level->parent_elt;
2603           parent_level = parent_level->parent_level;
2604         }
2605
2606       if (filter->priv->root != level)
2607         filter->priv->zero_ref_count--;
2608     }
2609 }
2610
2611 static void
2612 gtk_tree_model_filter_unref_node (GtkTreeModel *model,
2613                                   GtkTreeIter  *iter)
2614 {
2615   gtk_tree_model_filter_real_unref_node (model, iter, TRUE);
2616 }
2617
2618 static void
2619 gtk_tree_model_filter_real_unref_node (GtkTreeModel *model,
2620                                        GtkTreeIter  *iter,
2621                                        gboolean      propagate_unref)
2622 {
2623   GtkTreeModelFilter *filter = (GtkTreeModelFilter *)model;
2624   FilterLevel *level;
2625   FilterElt *elt;
2626
2627   g_return_if_fail (GTK_IS_TREE_MODEL_FILTER (model));
2628   g_return_if_fail (filter->priv->child_model != NULL);
2629   g_return_if_fail (filter->priv->stamp == iter->stamp);
2630
2631   if (propagate_unref)
2632     {
2633       GtkTreeIter child_iter;
2634       gtk_tree_model_filter_convert_iter_to_child_iter (GTK_TREE_MODEL_FILTER (model), &child_iter, iter);
2635       gtk_tree_model_unref_node (filter->priv->child_model, &child_iter);
2636     }
2637
2638   level = iter->user_data;
2639   elt = iter->user_data2;
2640
2641   g_return_if_fail (elt->ref_count > 0);
2642
2643   elt->ref_count--;
2644   level->ref_count--;
2645   if (level->ref_count == 0)
2646     {
2647       FilterLevel *parent_level = level->parent_level;
2648       FilterElt *parent_elt = level->parent_elt;
2649
2650       /* we are at zero -- time to increase the zero_ref_count val */
2651       while (parent_level)
2652         {
2653           parent_elt->zero_ref_count++;
2654
2655           parent_elt = parent_level->parent_elt;
2656           parent_level = parent_level->parent_level;
2657         }
2658
2659       if (filter->priv->root != level)
2660         filter->priv->zero_ref_count++;
2661     }
2662 }
2663
2664 /* TreeDragSource interface implementation */
2665 static gboolean
2666 gtk_tree_model_filter_row_draggable (GtkTreeDragSource *drag_source,
2667                                      GtkTreePath       *path)
2668 {
2669   GtkTreeModelFilter *tree_model_filter = (GtkTreeModelFilter *)drag_source;
2670   GtkTreePath *child_path;
2671   gboolean draggable;
2672
2673   g_return_val_if_fail (GTK_IS_TREE_MODEL_FILTER (drag_source), FALSE);
2674   g_return_val_if_fail (path != NULL, FALSE);
2675
2676   child_path = gtk_tree_model_filter_convert_path_to_child_path (tree_model_filter, path);
2677   draggable = gtk_tree_drag_source_row_draggable (GTK_TREE_DRAG_SOURCE (tree_model_filter->priv->child_model), child_path);
2678   gtk_tree_path_free (child_path);
2679
2680   return draggable;
2681 }
2682
2683 static gboolean
2684 gtk_tree_model_filter_drag_data_get (GtkTreeDragSource *drag_source,
2685                                      GtkTreePath       *path,
2686                                      GtkSelectionData  *selection_data)
2687 {
2688   GtkTreeModelFilter *tree_model_filter = (GtkTreeModelFilter *)drag_source;
2689   GtkTreePath *child_path;
2690   gboolean gotten;
2691
2692   g_return_val_if_fail (GTK_IS_TREE_MODEL_FILTER (drag_source), FALSE);
2693   g_return_val_if_fail (path != NULL, FALSE);
2694
2695   child_path = gtk_tree_model_filter_convert_path_to_child_path (tree_model_filter, path);
2696   gotten = gtk_tree_drag_source_drag_data_get (GTK_TREE_DRAG_SOURCE (tree_model_filter->priv->child_model), child_path, selection_data);
2697   gtk_tree_path_free (child_path);
2698
2699   return gotten;
2700 }
2701
2702 static gboolean
2703 gtk_tree_model_filter_drag_data_delete (GtkTreeDragSource *drag_source,
2704                                         GtkTreePath       *path)
2705 {
2706   GtkTreeModelFilter *tree_model_filter = (GtkTreeModelFilter *)drag_source;
2707   GtkTreePath *child_path;
2708   gboolean deleted;
2709
2710   g_return_val_if_fail (GTK_IS_TREE_MODEL_FILTER (drag_source), FALSE);
2711   g_return_val_if_fail (path != NULL, FALSE);
2712
2713   child_path = gtk_tree_model_filter_convert_path_to_child_path (tree_model_filter, path);
2714   deleted = gtk_tree_drag_source_drag_data_delete (GTK_TREE_DRAG_SOURCE (tree_model_filter->priv->child_model), child_path);
2715   gtk_tree_path_free (child_path);
2716
2717   return deleted;
2718 }
2719
2720 /* bits and pieces */
2721 static void
2722 gtk_tree_model_filter_set_model (GtkTreeModelFilter *filter,
2723                                  GtkTreeModel       *child_model)
2724 {
2725   g_return_if_fail (GTK_IS_TREE_MODEL_FILTER (filter));
2726
2727   if (filter->priv->child_model)
2728     {
2729       g_signal_handler_disconnect (filter->priv->child_model,
2730                                    filter->priv->changed_id);
2731       g_signal_handler_disconnect (filter->priv->child_model,
2732                                    filter->priv->inserted_id);
2733       g_signal_handler_disconnect (filter->priv->child_model,
2734                                    filter->priv->has_child_toggled_id);
2735       g_signal_handler_disconnect (filter->priv->child_model,
2736                                    filter->priv->deleted_id);
2737       g_signal_handler_disconnect (filter->priv->child_model,
2738                                    filter->priv->reordered_id);
2739
2740       /* reset our state */
2741       if (filter->priv->root)
2742         gtk_tree_model_filter_free_level (filter, filter->priv->root);
2743
2744       filter->priv->root = NULL;
2745       g_object_unref (filter->priv->child_model);
2746       filter->priv->visible_column = -1;
2747
2748       /* FIXME: do we need to destroy more here? */
2749     }
2750
2751   filter->priv->child_model = child_model;
2752
2753   if (child_model)
2754     {
2755       g_object_ref (filter->priv->child_model);
2756       filter->priv->changed_id =
2757         g_signal_connect (child_model, "row-changed",
2758                           G_CALLBACK (gtk_tree_model_filter_row_changed),
2759                           filter);
2760       filter->priv->inserted_id =
2761         g_signal_connect (child_model, "row-inserted",
2762                           G_CALLBACK (gtk_tree_model_filter_row_inserted),
2763                           filter);
2764       filter->priv->has_child_toggled_id =
2765         g_signal_connect (child_model, "row-has-child-toggled",
2766                           G_CALLBACK (gtk_tree_model_filter_row_has_child_toggled),
2767                           filter);
2768       filter->priv->deleted_id =
2769         g_signal_connect (child_model, "row-deleted",
2770                           G_CALLBACK (gtk_tree_model_filter_row_deleted),
2771                           filter);
2772       filter->priv->reordered_id =
2773         g_signal_connect (child_model, "rows-reordered",
2774                           G_CALLBACK (gtk_tree_model_filter_rows_reordered),
2775                           filter);
2776
2777       filter->priv->child_flags = gtk_tree_model_get_flags (child_model);
2778       filter->priv->stamp = g_random_int ();
2779     }
2780 }
2781
2782 static void
2783 gtk_tree_model_filter_ref_path (GtkTreeModelFilter *filter,
2784                                 GtkTreePath        *path)
2785 {
2786   int len;
2787   GtkTreePath *p;
2788
2789   len = gtk_tree_path_get_depth (path);
2790   p = gtk_tree_path_copy (path);
2791   while (len--)
2792     {
2793       GtkTreeIter iter;
2794
2795       gtk_tree_model_get_iter (GTK_TREE_MODEL (filter->priv->child_model), &iter, p);
2796       gtk_tree_model_ref_node (GTK_TREE_MODEL (filter->priv->child_model), &iter);
2797       gtk_tree_path_up (p);
2798     }
2799
2800   gtk_tree_path_free (p);
2801 }
2802
2803 static void
2804 gtk_tree_model_filter_unref_path (GtkTreeModelFilter *filter,
2805                                   GtkTreePath        *path)
2806 {
2807   int len;
2808   GtkTreePath *p;
2809
2810   len = gtk_tree_path_get_depth (path);
2811   p = gtk_tree_path_copy (path);
2812   while (len--)
2813     {
2814       GtkTreeIter iter;
2815
2816       gtk_tree_model_get_iter (GTK_TREE_MODEL (filter->priv->child_model), &iter, p);
2817       gtk_tree_model_unref_node (GTK_TREE_MODEL (filter->priv->child_model), &iter);
2818       gtk_tree_path_up (p);
2819     }
2820
2821   gtk_tree_path_free (p);
2822 }
2823
2824 static void
2825 gtk_tree_model_filter_set_root (GtkTreeModelFilter *filter,
2826                                 GtkTreePath        *root)
2827 {
2828   g_return_if_fail (GTK_IS_TREE_MODEL_FILTER (filter));
2829
2830   if (!root)
2831     filter->priv->virtual_root = NULL;
2832   else
2833     filter->priv->virtual_root = gtk_tree_path_copy (root);
2834 }
2835
2836 /* public API */
2837
2838 /**
2839  * gtk_tree_model_filter_new:
2840  * @child_model: A #GtkTreeModel.
2841  * @root: A #GtkTreePath or %NULL.
2842  *
2843  * Creates a new #GtkTreeModel, with @child_model as the child_model
2844  * and @root as the virtual root.
2845  *
2846  * Return value: A new #GtkTreeModel.
2847  *
2848  * Since: 2.4
2849  */
2850 GtkTreeModel *
2851 gtk_tree_model_filter_new (GtkTreeModel *child_model,
2852                            GtkTreePath  *root)
2853 {
2854   GtkTreeModel *retval;
2855   GtkTreeModelFilter *filter;
2856
2857   g_return_val_if_fail (GTK_IS_TREE_MODEL (child_model), NULL);
2858
2859   retval = g_object_new (GTK_TYPE_TREE_MODEL_FILTER,
2860                          "child-model", child_model,
2861                          "virtual-root", root,
2862                          NULL);
2863
2864   filter = GTK_TREE_MODEL_FILTER (retval);
2865   if (filter->priv->virtual_root)
2866     {
2867       gtk_tree_model_filter_ref_path (filter, filter->priv->virtual_root);
2868       filter->priv->virtual_root_deleted = FALSE;
2869     }
2870
2871   return retval;
2872 }
2873
2874 /**
2875  * gtk_tree_model_filter_get_model:
2876  * @filter: A #GtkTreeModelFilter.
2877  *
2878  * Returns a pointer to the child model of @filter.
2879  *
2880  * Return value: A pointer to a #GtkTreeModel.
2881  *
2882  * Since: 2.4
2883  */
2884 GtkTreeModel *
2885 gtk_tree_model_filter_get_model (GtkTreeModelFilter *filter)
2886 {
2887   g_return_val_if_fail (GTK_IS_TREE_MODEL_FILTER (filter), NULL);
2888
2889   return filter->priv->child_model;
2890 }
2891
2892 /**
2893  * gtk_tree_model_filter_set_visible_func:
2894  * @filter: A #GtkTreeModelFilter.
2895  * @func: A #GtkTreeModelFilterVisibleFunc, the visible function.
2896  * @data: User data to pass to the visible function, or %NULL.
2897  * @destroy: Destroy notifier of @data, or %NULL.
2898  *
2899  * Sets the visible function used when filtering the @filter to be @func. The
2900  * function should return %TRUE if the given row should be visible and
2901  * %FALSE otherwise.
2902  *
2903  * If the condition calculated by the function changes over time (e.g. because
2904  * it depends on some global parameters), you must call
2905  * gtk_tree_model_filter_refilter() to keep the visibility information of
2906  * the model uptodate.
2907  *
2908  * Note that @func is called whenever a row is inserted, when it may still be
2909  * empty. The visible function should therefore take special care of empty
2910  * rows, like in the example below.
2911  *
2912  * <informalexample><programlisting>
2913  * static gboolean
2914  * visible_func (GtkTreeModel *model,
2915  *               GtkTreeIter  *iter,
2916  *               gpointer      data)
2917  * {
2918  *   /&ast; Visible if row is non-empty and first column is "HI" &ast;/
2919  *   gchar *str;
2920  *   gboolean visible = FALSE;
2921  *
2922  *   gtk_tree_model_get (model, iter, 0, &str, -1);
2923  *   if (str && strcmp (str, "HI") == 0)
2924  *     visible = TRUE;
2925  *   g_free (str);
2926  *
2927  *   return visible;
2928  * }
2929  * </programlisting></informalexample>
2930  *
2931  * Since: 2.4
2932  */
2933 void
2934 gtk_tree_model_filter_set_visible_func (GtkTreeModelFilter            *filter,
2935                                         GtkTreeModelFilterVisibleFunc  func,
2936                                         gpointer                       data,
2937                                         GDestroyNotify                 destroy)
2938 {
2939   g_return_if_fail (GTK_IS_TREE_MODEL_FILTER (filter));
2940   g_return_if_fail (func != NULL);
2941   g_return_if_fail (filter->priv->visible_method_set == FALSE);
2942
2943   if (filter->priv->visible_func)
2944     {
2945       GDestroyNotify d = filter->priv->visible_destroy;
2946
2947       filter->priv->visible_destroy = NULL;
2948       d (filter->priv->visible_data);
2949     }
2950
2951   filter->priv->visible_func = func;
2952   filter->priv->visible_data = data;
2953   filter->priv->visible_destroy = destroy;
2954
2955   filter->priv->visible_method_set = TRUE;
2956 }
2957
2958 /**
2959  * gtk_tree_model_filter_set_modify_func:
2960  * @filter: A #GtkTreeModelFilter.
2961  * @n_columns: The number of columns in the filter model.
2962  * @types: The #GType<!-- -->s of the columns.
2963  * @func: A #GtkTreeModelFilterModifyFunc
2964  * @data: User data to pass to the modify function, or %NULL.
2965  * @destroy: Destroy notifier of @data, or %NULL.
2966  *
2967  * With the @n_columns and @types parameters, you give an array of column
2968  * types for this model (which will be exposed to the parent model/view).
2969  * The @func, @data and @destroy parameters are for specifying the modify
2970  * function. The modify function will get called for <emphasis>each</emphasis>
2971  * data access, the goal of the modify function is to return the data which
2972  * should be displayed at the location specified using the parameters of the
2973  * modify function.
2974  *
2975  * Since: 2.4
2976  */
2977 void
2978 gtk_tree_model_filter_set_modify_func (GtkTreeModelFilter           *filter,
2979                                        gint                          n_columns,
2980                                        GType                        *types,
2981                                        GtkTreeModelFilterModifyFunc  func,
2982                                        gpointer                      data,
2983                                        GDestroyNotify                destroy)
2984 {
2985   g_return_if_fail (GTK_IS_TREE_MODEL_FILTER (filter));
2986   g_return_if_fail (func != NULL);
2987   g_return_if_fail (filter->priv->modify_func_set == FALSE);
2988
2989   if (filter->priv->modify_destroy)
2990     {
2991       GDestroyNotify d = filter->priv->modify_destroy;
2992
2993       filter->priv->modify_destroy = NULL;
2994       d (filter->priv->modify_data);
2995     }
2996
2997   filter->priv->modify_n_columns = n_columns;
2998   filter->priv->modify_types = g_new0 (GType, n_columns);
2999   memcpy (filter->priv->modify_types, types, sizeof (GType) * n_columns);
3000   filter->priv->modify_func = func;
3001   filter->priv->modify_data = data;
3002   filter->priv->modify_destroy = destroy;
3003
3004   filter->priv->modify_func_set = TRUE;
3005 }
3006
3007 /**
3008  * gtk_tree_model_filter_set_visible_column:
3009  * @filter: A #GtkTreeModelFilter.
3010  * @column: A #gint which is the column containing the visible information.
3011  *
3012  * Sets @column of the child_model to be the column where @filter should
3013  * look for visibility information. @columns should be a column of type
3014  * %G_TYPE_BOOLEAN, where %TRUE means that a row is visible, and %FALSE
3015  * if not.
3016  *
3017  * Since: 2.4
3018  */
3019 void
3020 gtk_tree_model_filter_set_visible_column (GtkTreeModelFilter *filter,
3021                                           gint column)
3022 {
3023   g_return_if_fail (GTK_IS_TREE_MODEL_FILTER (filter));
3024   g_return_if_fail (column >= 0);
3025   g_return_if_fail (filter->priv->visible_method_set == FALSE);
3026
3027   filter->priv->visible_column = column;
3028
3029   filter->priv->visible_method_set = TRUE;
3030 }
3031
3032 /* conversion */
3033
3034 /**
3035  * gtk_tree_model_filter_convert_child_iter_to_iter:
3036  * @filter: A #GtkTreeModelFilter.
3037  * @filter_iter: An uninitialized #GtkTreeIter.
3038  * @child_iter: A valid #GtkTreeIter pointing to a row on the child model.
3039  *
3040  * Sets @filter_iter to point to the row in @filter that corresponds to the
3041  * row pointed at by @child_iter.  If @filter_iter was not set, %FALSE is
3042  * returned.
3043  *
3044  * Return value: %TRUE, if @filter_iter was set, i.e. if @child_iter is a
3045  * valid iterator pointing to a visible row in child model.
3046  *
3047  * Since: 2.4
3048  */
3049 gboolean
3050 gtk_tree_model_filter_convert_child_iter_to_iter (GtkTreeModelFilter *filter,
3051                                                   GtkTreeIter        *filter_iter,
3052                                                   GtkTreeIter        *child_iter)
3053 {
3054   gboolean ret;
3055   GtkTreePath *child_path, *path;
3056
3057   g_return_val_if_fail (GTK_IS_TREE_MODEL_FILTER (filter), FALSE);
3058   g_return_val_if_fail (filter->priv->child_model != NULL, FALSE);
3059   g_return_val_if_fail (filter_iter != NULL, FALSE);
3060   g_return_val_if_fail (child_iter != NULL, FALSE);
3061   g_return_val_if_fail (filter_iter != child_iter, FALSE);
3062
3063   filter_iter->stamp = 0;
3064
3065   child_path = gtk_tree_model_get_path (filter->priv->child_model, child_iter);
3066   g_return_val_if_fail (child_path != NULL, FALSE);
3067
3068   path = gtk_tree_model_filter_convert_child_path_to_path (filter,
3069                                                            child_path);
3070   gtk_tree_path_free (child_path);
3071
3072   if (!path)
3073     return FALSE;
3074
3075   ret = gtk_tree_model_get_iter (GTK_TREE_MODEL (filter), filter_iter, path);
3076   gtk_tree_path_free (path);
3077
3078   return ret;
3079 }
3080
3081 /**
3082  * gtk_tree_model_filter_convert_iter_to_child_iter:
3083  * @filter: A #GtkTreeModelFilter.
3084  * @child_iter: An uninitialized #GtkTreeIter.
3085  * @filter_iter: A valid #GtkTreeIter pointing to a row on @filter.
3086  *
3087  * Sets @child_iter to point to the row pointed to by @filter_iter.
3088  *
3089  * Since: 2.4
3090  */
3091 void
3092 gtk_tree_model_filter_convert_iter_to_child_iter (GtkTreeModelFilter *filter,
3093                                                   GtkTreeIter        *child_iter,
3094                                                   GtkTreeIter        *filter_iter)
3095 {
3096   g_return_if_fail (GTK_IS_TREE_MODEL_FILTER (filter));
3097   g_return_if_fail (filter->priv->child_model != NULL);
3098   g_return_if_fail (child_iter != NULL);
3099   g_return_if_fail (filter_iter != NULL);
3100   g_return_if_fail (filter_iter->stamp == filter->priv->stamp);
3101   g_return_if_fail (filter_iter != child_iter);
3102
3103   if (GTK_TREE_MODEL_FILTER_CACHE_CHILD_ITERS (filter))
3104     {
3105       *child_iter = FILTER_ELT (filter_iter->user_data2)->iter;
3106     }
3107   else
3108     {
3109       GtkTreePath *path;
3110
3111       path = gtk_tree_model_filter_elt_get_path (filter_iter->user_data,
3112                                                  filter_iter->user_data2,
3113                                                  filter->priv->virtual_root);
3114       gtk_tree_model_get_iter (filter->priv->child_model, child_iter, path);
3115       gtk_tree_path_free (path);
3116     }
3117 }
3118
3119 /* The path returned can only be used internally in the filter model. */
3120 static GtkTreePath *
3121 gtk_real_tree_model_filter_convert_child_path_to_path (GtkTreeModelFilter *filter,
3122                                                        GtkTreePath        *child_path,
3123                                                        gboolean            build_levels,
3124                                                        gboolean            fetch_children)
3125 {
3126   gint *child_indices;
3127   GtkTreePath *retval;
3128   GtkTreePath *real_path;
3129   FilterLevel *level;
3130   FilterElt *tmp;
3131   gint i;
3132
3133   g_return_val_if_fail (GTK_IS_TREE_MODEL_FILTER (filter), NULL);
3134   g_return_val_if_fail (filter->priv->child_model != NULL, NULL);
3135   g_return_val_if_fail (child_path != NULL, NULL);
3136
3137   if (!filter->priv->virtual_root)
3138     real_path = gtk_tree_path_copy (child_path);
3139   else
3140     real_path = gtk_tree_model_filter_remove_root (child_path,
3141                                                    filter->priv->virtual_root);
3142
3143   if (!real_path)
3144     return NULL;
3145
3146   retval = gtk_tree_path_new ();
3147   child_indices = gtk_tree_path_get_indices (real_path);
3148
3149   if (filter->priv->root == NULL && build_levels)
3150     gtk_tree_model_filter_build_level (filter, NULL, NULL, FALSE);
3151   level = FILTER_LEVEL (filter->priv->root);
3152
3153   for (i = 0; i < gtk_tree_path_get_depth (real_path); i++)
3154     {
3155       gint j;
3156       gboolean found_child = FALSE;
3157
3158       if (!level)
3159         {
3160           gtk_tree_path_free (real_path);
3161           gtk_tree_path_free (retval);
3162           return NULL;
3163         }
3164
3165       tmp = bsearch_elt_with_offset (level->array, child_indices[i], &j);
3166       if (tmp)
3167         {
3168           gtk_tree_path_append_index (retval, j);
3169           if (!tmp->children && build_levels)
3170             gtk_tree_model_filter_build_level (filter, level, tmp, FALSE);
3171           level = tmp->children;
3172           found_child = TRUE;
3173         }
3174
3175       if (!found_child && fetch_children)
3176         {
3177           tmp = gtk_tree_model_filter_fetch_child (filter, level,
3178                                                    child_indices[i],
3179                                                    &j);
3180
3181           /* didn't find the child, let's try to bring it back */
3182           if (!tmp || tmp->offset != child_indices[i])
3183             {
3184               /* not there */
3185               gtk_tree_path_free (real_path);
3186               gtk_tree_path_free (retval);
3187               return NULL;
3188             }
3189
3190           gtk_tree_path_append_index (retval, j);
3191           if (!tmp->children && build_levels)
3192             gtk_tree_model_filter_build_level (filter, level, tmp, FALSE);
3193           level = tmp->children;
3194           found_child = TRUE;
3195         }
3196       else if (!found_child && !fetch_children)
3197         {
3198           /* no path */
3199           gtk_tree_path_free (real_path);
3200           gtk_tree_path_free (retval);
3201           return NULL;
3202         }
3203     }
3204
3205   gtk_tree_path_free (real_path);
3206   return retval;
3207 }
3208
3209 /**
3210  * gtk_tree_model_filter_convert_child_path_to_path:
3211  * @filter: A #GtkTreeModelFilter.
3212  * @child_path: A #GtkTreePath to convert.
3213  *
3214  * Converts @child_path to a path relative to @filter. That is, @child_path
3215  * points to a path in the child model. The rerturned path will point to the
3216  * same row in the filtered model. If @child_path isn't a valid path on the
3217  * child model or points to a row which is not visible in @filter, then %NULL
3218  * is returned.
3219  *
3220  * Return value: A newly allocated #GtkTreePath, or %NULL.
3221  *
3222  * Since: 2.4
3223  */
3224 GtkTreePath *
3225 gtk_tree_model_filter_convert_child_path_to_path (GtkTreeModelFilter *filter,
3226                                                   GtkTreePath        *child_path)
3227 {
3228   GtkTreeIter iter;
3229   GtkTreePath *path;
3230
3231   /* this function does the sanity checks */
3232   path = gtk_real_tree_model_filter_convert_child_path_to_path (filter,
3233                                                                 child_path,
3234                                                                 TRUE,
3235                                                                 TRUE);
3236
3237   if (!path)
3238       return NULL;
3239
3240   /* get a new path which only takes visible nodes into account.
3241    * -- if this gives any performance issues, we can write a special
3242    *    version of convert_child_path_to_path immediately returning
3243    *    a visible-nodes-only path.
3244    */
3245   gtk_tree_model_filter_get_iter_full (GTK_TREE_MODEL (filter), &iter, path);
3246
3247   gtk_tree_path_free (path);
3248   path = gtk_tree_model_get_path (GTK_TREE_MODEL (filter), &iter);
3249
3250   return path;
3251 }
3252
3253 /**
3254  * gtk_tree_model_filter_convert_path_to_child_path:
3255  * @filter: A #GtkTreeModelFilter.
3256  * @filter_path: A #GtkTreePath to convert.
3257  *
3258  * Converts @filter_path to a path on the child model of @filter. That is,
3259  * @filter_path points to a location in @filter. The returned path will
3260  * point to the same location in the model not being filtered. If @filter_path
3261  * does not point to a location in the child model, %NULL is returned.
3262  *
3263  * Return value: A newly allocated #GtkTreePath, or %NULL.
3264  *
3265  * Since: 2.4
3266  */
3267 GtkTreePath *
3268 gtk_tree_model_filter_convert_path_to_child_path (GtkTreeModelFilter *filter,
3269                                                   GtkTreePath        *filter_path)
3270 {
3271   gint *filter_indices;
3272   GtkTreePath *retval;
3273   FilterLevel *level;
3274   gint i;
3275
3276   g_return_val_if_fail (GTK_IS_TREE_MODEL_FILTER (filter), NULL);
3277   g_return_val_if_fail (filter->priv->child_model != NULL, NULL);
3278   g_return_val_if_fail (filter_path != NULL, NULL);
3279
3280   /* convert path */
3281   retval = gtk_tree_path_new ();
3282   filter_indices = gtk_tree_path_get_indices (filter_path);
3283   if (!filter->priv->root)
3284     gtk_tree_model_filter_build_level (filter, NULL, NULL, FALSE);
3285   level = FILTER_LEVEL (filter->priv->root);
3286
3287   for (i = 0; i < gtk_tree_path_get_depth (filter_path); i++)
3288     {
3289       FilterElt *elt;
3290
3291       if (!level || level->visible_nodes <= filter_indices[i])
3292         {
3293           gtk_tree_path_free (retval);
3294           return NULL;
3295         }
3296
3297       elt = gtk_tree_model_filter_get_nth_visible (filter, level,
3298                                                    filter_indices[i]);
3299
3300       if (elt->children == NULL)
3301         gtk_tree_model_filter_build_level (filter, level, elt, FALSE);
3302
3303       if (!level || level->visible_nodes <= filter_indices[i])
3304         {
3305           gtk_tree_path_free (retval);
3306           return NULL;
3307         }
3308
3309       gtk_tree_path_append_index (retval, elt->offset);
3310       level = elt->children;
3311     }
3312
3313   /* apply vroot */
3314
3315   if (filter->priv->virtual_root)
3316     {
3317       GtkTreePath *real_retval;
3318
3319       real_retval = gtk_tree_model_filter_add_root (retval,
3320                                                     filter->priv->virtual_root);
3321       gtk_tree_path_free (retval);
3322
3323       return real_retval;
3324     }
3325
3326   return retval;
3327 }
3328
3329 static gboolean
3330 gtk_tree_model_filter_refilter_helper (GtkTreeModel *model,
3331                                        GtkTreePath  *path,
3332                                        GtkTreeIter  *iter,
3333                                        gpointer      data)
3334 {
3335   /* evil, don't try this at home, but certainly speeds things up */
3336   gtk_tree_model_filter_row_changed (model, path, iter, data);
3337
3338   return FALSE;
3339 }
3340
3341 /**
3342  * gtk_tree_model_filter_refilter:
3343  * @filter: A #GtkTreeModelFilter.
3344  *
3345  * Emits ::row_changed for each row in the child model, which causes
3346  * the filter to re-evaluate whether a row is visible or not.
3347  *
3348  * Since: 2.4
3349  */
3350 void
3351 gtk_tree_model_filter_refilter (GtkTreeModelFilter *filter)
3352 {
3353   g_return_if_fail (GTK_IS_TREE_MODEL_FILTER (filter));
3354
3355   /* S L O W */
3356   gtk_tree_model_foreach (filter->priv->child_model,
3357                           gtk_tree_model_filter_refilter_helper,
3358                           filter);
3359 }
3360
3361 /**
3362  * gtk_tree_model_filter_clear_cache:
3363  * @filter: A #GtkTreeModelFilter.
3364  *
3365  * This function should almost never be called. It clears the @filter
3366  * of any cached iterators that haven't been reffed with
3367  * gtk_tree_model_ref_node(). This might be useful if the child model
3368  * being filtered is static (and doesn't change often) and there has been
3369  * a lot of unreffed access to nodes. As a side effect of this function,
3370  * all unreffed iters will be invalid.
3371  *
3372  * Since: 2.4
3373  */
3374 void
3375 gtk_tree_model_filter_clear_cache (GtkTreeModelFilter *filter)
3376 {
3377   g_return_if_fail (GTK_IS_TREE_MODEL_FILTER (filter));
3378
3379   if (filter->priv->zero_ref_count > 0)
3380     gtk_tree_model_filter_clear_cache_helper (filter,
3381                                               FILTER_LEVEL (filter->priv->root));
3382 }
3383
3384 #define __GTK_TREE_MODEL_FILTER_C__
3385 #include "gtkaliasdef.c"