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

   1 /* gtktreestore.c
   2   * Copyright (C) 2000  Red Hat, Inc.,  Jonathan Blandford <jrb@redhat.com>
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Library General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Library General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Library General Public
  15  * License along with this library; if not, write to the
  16  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17  * Boston, MA 02111-1307, USA.
  18  */
  19
  20 #include "gtktreemodel.h"
  21 #include "gtktreestore.h"
  22 #include "gtktreedatalist.h"
  23 #include "gtktreednd.h"
  24 #include <string.h>
  25 #include <gobject/gvaluecollector.h>
  26
  27 #define G_NODE(node) ((GNode *)node)
  28 #define GTK_TREE_STORE_IS_SORTED(tree) (GTK_TREE_STORE (tree)->sort_column_id != -2)
  29 #define VALID_ITER(iter, tree_store) (iter!= NULL && iter->user_data != NULL && tree_store->stamp == iter->stamp)
  30
  31 static void         gtk_tree_store_init            (GtkTreeStore      *tree_store);
  32 static void         gtk_tree_store_class_init      (GtkTreeStoreClass *tree_store_class);
  33 static void         gtk_tree_store_tree_model_init (GtkTreeModelIface *iface);
  34 static void         gtk_tree_store_drag_source_init(GtkTreeDragSourceIface *iface);
  35 static void         gtk_tree_store_drag_dest_init  (GtkTreeDragDestIface   *iface);
  36 static void         gtk_tree_store_sortable_init   (GtkTreeSortableIface   *iface);
  37 static guint        gtk_tree_store_get_flags       (GtkTreeModel      *tree_model);
  38 static gint         gtk_tree_store_get_n_columns   (GtkTreeModel      *tree_model);
  39 static GType        gtk_tree_store_get_column_type (GtkTreeModel      *tree_model,
  40                                                     gint               index);
  41 static gboolean     gtk_tree_store_get_iter        (GtkTreeModel      *tree_model,
  42                                                     GtkTreeIter       *iter,
  43                                                     GtkTreePath       *path);
  44 static GtkTreePath *gtk_tree_store_get_path        (GtkTreeModel      *tree_model,
  45                                                     GtkTreeIter       *iter);
  46 static void         gtk_tree_store_get_value       (GtkTreeModel      *tree_model,
  47                                                     GtkTreeIter       *iter,
  48                                                     gint               column,
  49                                                     GValue            *value);
  50 static gboolean     gtk_tree_store_iter_next       (GtkTreeModel      *tree_model,
  51                                                     GtkTreeIter       *iter);
  52 static gboolean     gtk_tree_store_iter_children   (GtkTreeModel      *tree_model,
  53                                                     GtkTreeIter       *iter,
  54                                                     GtkTreeIter       *parent);
  55 static gboolean     gtk_tree_store_iter_has_child  (GtkTreeModel      *tree_model,
  56                                                     GtkTreeIter       *iter);
  57 static gint         gtk_tree_store_iter_n_children (GtkTreeModel      *tree_model,
  58                                                     GtkTreeIter       *iter);
  59 static gboolean     gtk_tree_store_iter_nth_child  (GtkTreeModel      *tree_model,
  60                                                     GtkTreeIter       *iter,
  61                                                     GtkTreeIter       *parent,
  62                                                     gint               n);
  63 static gboolean     gtk_tree_store_iter_parent     (GtkTreeModel      *tree_model,
  64                                                     GtkTreeIter       *iter,
  65                                                     GtkTreeIter       *child);
  66
  67
  68 static void gtk_tree_store_set_n_columns   (GtkTreeStore *tree_store,
  69                                             gint          n_columns);
  70 static void gtk_tree_store_set_column_type (GtkTreeStore *tree_store,
  71                                             gint          column,
  72                                             GType         type);
  73
  74
  75 /* DND interfaces */
  76 static gboolean gtk_tree_store_drag_data_delete   (GtkTreeDragSource *drag_source,
  77                                                    GtkTreePath       *path);
  78 static gboolean gtk_tree_store_drag_data_get      (GtkTreeDragSource *drag_source,
  79                                                    GtkTreePath       *path,
  80                                                    GtkSelectionData  *selection_data);
  81 static gboolean gtk_tree_store_drag_data_received (GtkTreeDragDest   *drag_dest,
  82                                                    GtkTreePath       *dest,
  83                                                    GtkSelectionData  *selection_data);
  84 static gboolean gtk_tree_store_row_drop_possible  (GtkTreeDragDest   *drag_dest,
  85                                                    GtkTreeModel      *src_model,
  86                                                    GtkTreePath       *src_path,
  87                                                    GtkTreePath       *dest_path);
  88
  89 /* Sortable Interfaces */
  90
  91 static void     gtk_tree_store_sort                    (GtkTreeStore           *tree_store);
  92 static void     gtk_tree_store_sort_iter_changed       (GtkTreeStore           *tree_store,
  93                                                         GtkTreeIter            *iter,
  94                                                         gint                    column);
  95 static gboolean gtk_tree_store_get_sort_column_id      (GtkTreeSortable        *sortable,
  96                                                         gint                   *sort_column_id,
  97                                                         GtkSortType            *order);
  98 static void     gtk_tree_store_set_sort_column_id      (GtkTreeSortable        *sortable,
  99                                                         gint                    sort_column_id,
 100                                                         GtkSortType             order);
 101 static void     gtk_tree_store_set_sort_func           (GtkTreeSortable        *sortable,
 102                                                         gint                    sort_column_id,
 103                                                         GtkTreeIterCompareFunc  func,
 104                                                         gpointer                data,
 105                                                         GtkDestroyNotify        destroy);
 106 static void     gtk_tree_store_set_default_sort_func   (GtkTreeSortable        *sortable,
 107                                                         GtkTreeIterCompareFunc  func,
 108                                                         gpointer                data,
 109                                                         GtkDestroyNotify        destroy);
 110 static gboolean gtk_tree_store_has_default_sort_func   (GtkTreeSortable        *sortable);
 111
 112 static void     validate_gnode                    (GNode *node);
 113
 114 static inline void
 115 validate_tree (GtkTreeStore *tree_store)
 116 {
 117   if (gtk_debug_flags & GTK_DEBUG_TREE)
 118     {
 119       g_assert (G_NODE (tree_store->root)->parent == NULL);
 120
 121       validate_gnode (G_NODE (tree_store->root));
 122     }
 123 }
 124
 125 GtkType
 126 gtk_tree_store_get_type (void)
 127 {
 128   static GType tree_store_type = 0;
 129
 130   if (!tree_store_type)
 131     {
 132       static const GTypeInfo tree_store_info =
 133       {
 134         sizeof (GtkTreeStoreClass),
 135         NULL,           /* base_init */
 136         NULL,           /* base_finalize */
 137         (GClassInitFunc) gtk_tree_store_class_init,
 138         NULL,           /* class_finalize */
 139         NULL,           /* class_data */
 140         sizeof (GtkTreeStore),
 141         0,              /* n_preallocs */
 142         (GInstanceInitFunc) gtk_tree_store_init
 143       };
 144
 145       static const GInterfaceInfo tree_model_info =
 146       {
 147         (GInterfaceInitFunc) gtk_tree_store_tree_model_init,
 148         NULL,
 149         NULL
 150       };
 151
 152       static const GInterfaceInfo drag_source_info =
 153       {
 154         (GInterfaceInitFunc) gtk_tree_store_drag_source_init,
 155         NULL,
 156         NULL
 157       };
 158
 159       static const GInterfaceInfo drag_dest_info =
 160       {
 161         (GInterfaceInitFunc) gtk_tree_store_drag_dest_init,
 162         NULL,
 163         NULL
 164       };
 165
 166       static const GInterfaceInfo sortable_info =
 167       {
 168         (GInterfaceInitFunc) gtk_tree_store_sortable_init,
 169         NULL,
 170         NULL
 171       };
 172
 173       tree_store_type = g_type_register_static (G_TYPE_OBJECT, "GtkTreeStore", &tree_store_info, 0);
 174
 175       g_type_add_interface_static (tree_store_type,
 176                                    GTK_TYPE_TREE_MODEL,
 177                                    &tree_model_info);
 178       g_type_add_interface_static (tree_store_type,
 179                                    GTK_TYPE_TREE_DRAG_SOURCE,
 180                                    &drag_source_info);
 181       g_type_add_interface_static (tree_store_type,
 182                                    GTK_TYPE_TREE_DRAG_DEST,
 183                                    &drag_dest_info);
 184       g_type_add_interface_static (tree_store_type,
 185                                    GTK_TYPE_TREE_SORTABLE,
 186                                    &sortable_info);
 187
 188     }
 189
 190   return tree_store_type;
 191 }
 192
 193 static void
 194 gtk_tree_store_class_init (GtkTreeStoreClass *tree_store_class)
 195 {
 196   GObjectClass *object_class;
 197
 198   object_class = (GObjectClass *) tree_store_class;
 199
 200 }
 201
 202 static void
 203 gtk_tree_store_tree_model_init (GtkTreeModelIface *iface)
 204 {
 205   iface->get_flags = gtk_tree_store_get_flags;
 206   iface->get_n_columns = gtk_tree_store_get_n_columns;
 207   iface->get_column_type = gtk_tree_store_get_column_type;
 208   iface->get_iter = gtk_tree_store_get_iter;
 209   iface->get_path = gtk_tree_store_get_path;
 210   iface->get_value = gtk_tree_store_get_value;
 211   iface->iter_next = gtk_tree_store_iter_next;
 212   iface->iter_children = gtk_tree_store_iter_children;
 213   iface->iter_has_child = gtk_tree_store_iter_has_child;
 214   iface->iter_n_children = gtk_tree_store_iter_n_children;
 215   iface->iter_nth_child = gtk_tree_store_iter_nth_child;
 216   iface->iter_parent = gtk_tree_store_iter_parent;
 217 }
 218
 219 static void
 220 gtk_tree_store_drag_source_init (GtkTreeDragSourceIface *iface)
 221 {
 222   iface->drag_data_delete = gtk_tree_store_drag_data_delete;
 223   iface->drag_data_get = gtk_tree_store_drag_data_get;
 224 }
 225
 226 static void
 227 gtk_tree_store_drag_dest_init (GtkTreeDragDestIface *iface)
 228 {
 229   iface->drag_data_received = gtk_tree_store_drag_data_received;
 230   iface->row_drop_possible = gtk_tree_store_row_drop_possible;
 231 }
 232
 233 static void
 234 gtk_tree_store_sortable_init (GtkTreeSortableIface *iface)
 235 {
 236   iface->get_sort_column_id = gtk_tree_store_get_sort_column_id;
 237   iface->set_sort_column_id = gtk_tree_store_set_sort_column_id;
 238   iface->set_sort_func = gtk_tree_store_set_sort_func;
 239   iface->set_default_sort_func = gtk_tree_store_set_default_sort_func;
 240   iface->has_default_sort_func = gtk_tree_store_has_default_sort_func;
 241 }
 242
 243 static void
 244 gtk_tree_store_init (GtkTreeStore *tree_store)
 245 {
 246   tree_store->root = g_node_new (NULL);
 247   do
 248     {
 249       tree_store->stamp = g_random_int ();
 250     }
 251   while (tree_store->stamp == 0);
 252   tree_store->sort_list = NULL;
 253   tree_store->sort_column_id = -2;
 254 }
 255
 256 /**
 257  * gtk_tree_store_new:
 258  * @n_columns: number of columns in the tree store
 259  * @Varargs: all #GType types for the columns, from first to last
 260  *
 261  * Creates a new tree store as with @n_columns columns each of the types passed
 262  * in.  As an example, gtk_tree_store_new (3, G_TYPE_INT, G_TYPE_STRING,
 263  * GDK_TYPE_PIXBUF); will create a new GtkTreeStore with three columns, of type
 264  * int, string and GDkPixbuf respectively.
 265  *
 266  * Return value: a new #GtkTreeStore
 267  **/
 268 GtkTreeStore *
 269 gtk_tree_store_new (gint n_columns,
 270                                ...)
 271 {
 272   GtkTreeStore *retval;
 273   va_list args;
 274   gint i;
 275
 276   g_return_val_if_fail (n_columns > 0, NULL);
 277
 278   retval = GTK_TREE_STORE (g_object_new (GTK_TYPE_TREE_STORE, NULL));
 279   gtk_tree_store_set_n_columns (retval, n_columns);
 280
 281   va_start (args, n_columns);
 282
 283   for (i = 0; i < n_columns; i++)
 284     {
 285       GType type = va_arg (args, GType);
 286       if (! _gtk_tree_data_list_check_type (type))
 287         {
 288           g_warning ("%s: Invalid type %s passed to gtk_tree_store_new_with_types\n", G_STRLOC, g_type_name (type));
 289           g_object_unref (G_OBJECT (retval));
 290           return NULL;
 291         }
 292       gtk_tree_store_set_column_type (retval, i, type);
 293     }
 294   va_end (args);
 295
 296   return retval;
 297 }
 298 /**
 299  * gtk_tree_store_newv:
 300  * @n_columns: number of columns in the tree store
 301  * @types: an array of #GType types for the columns, from first to last
 302  *
 303  * Non vararg creation function.  Used primarily by language bindings.
 304  *
 305  * Return value: a new #GtkTreeStore
 306  **/
 307 GtkTreeStore *
 308 gtk_tree_store_newv (gint   n_columns,
 309                      GType *types)
 310 {
 311   GtkTreeStore *retval;
 312   gint i;
 313
 314   g_return_val_if_fail (n_columns > 0, NULL);
 315
 316   retval = GTK_TREE_STORE (g_object_new (GTK_TYPE_TREE_STORE, NULL));
 317   gtk_tree_store_set_n_columns (retval, n_columns);
 318
 319    for (i = 0; i < n_columns; i++)
 320     {
 321       if (! _gtk_tree_data_list_check_type (types[i]))
 322         {
 323           g_warning ("%s: Invalid type %s passed to gtk_tree_store_new_with_types\n", G_STRLOC, g_type_name (types[i]));
 324           g_object_unref (G_OBJECT (retval));
 325           return NULL;
 326         }
 327       gtk_tree_store_set_column_type (retval, i, types[i]);
 328     }
 329
 330   return retval;
 331 }
 332
 333 /**
 334  * gtk_tree_store_set_n_columns:
 335  * @tree_store:
 336  * @n_columns:
 337  *
 338  * As a side effect of calling this function, all sort columns that overlap with
 339  * the current number of columns will be removed.
 340  **/
 341 static void
 342 gtk_tree_store_set_n_columns (GtkTreeStore *tree_store,
 343                               gint          n_columns)
 344 {
 345   GType *new_columns;
 346
 347   g_return_if_fail (GTK_IS_TREE_STORE (tree_store));
 348
 349   if (tree_store->n_columns == n_columns)
 350     return;
 351
 352   new_columns = g_new0 (GType, n_columns);
 353   if (tree_store->column_headers)
 354     {
 355       /* copy the old header orders over */
 356       if (n_columns >= tree_store->n_columns)
 357         memcpy (new_columns, tree_store->column_headers, tree_store->n_columns * sizeof (gchar *));
 358       else
 359         memcpy (new_columns, tree_store->column_headers, n_columns * sizeof (GType));
 360
 361       g_free (tree_store->column_headers);
 362     }
 363
 364   if (tree_store->sort_list)
 365     _gtk_tree_data_list_header_free (tree_store->sort_list);
 366
 367   tree_store->sort_list = _gtk_tree_data_list_header_new (n_columns, tree_store->column_headers);
 368
 369   tree_store->column_headers = new_columns;
 370   tree_store->n_columns = n_columns;
 371 }
 372
 373 /**
 374  * gtk_tree_store_set_column_type:
 375  * @tree_store: a #GtkTreeStore
 376  * @column: column number
 377  * @type: type of the data to be stored in @column
 378  *
 379  * Supported types include: %G_TYPE_UINT, %G_TYPE_INT, %G_TYPE_UCHAR,
 380  * %G_TYPE_CHAR, %G_TYPE_BOOLEAN, %G_TYPE_POINTER, %G_TYPE_FLOAT,
 381  * %G_TYPE_DOUBLE, %G_TYPE_STRING, %G_TYPE_OBJECT, and %G_TYPE_BOXED, along with
 382  * subclasses of those types such as %GDK_TYPE_PIXBUF.
 383  *
 384  **/
 385 static void
 386 gtk_tree_store_set_column_type (GtkTreeStore *tree_store,
 387                                 gint          column,
 388                                 GType         type)
 389 {
 390   g_return_if_fail (GTK_IS_TREE_STORE (tree_store));
 391   g_return_if_fail (column >=0 && column < tree_store->n_columns);
 392   if (!_gtk_tree_data_list_check_type (type))
 393     {
 394       g_warning ("%s: Invalid type %s passed to gtk_tree_store_new_with_types\n", G_STRLOC, g_type_name (type));
 395       return;
 396     }
 397   tree_store->column_headers[column] = type;
 398 }
 399
 400 /* fulfill the GtkTreeModel requirements */
 401 /* NOTE: GtkTreeStore::root is a GNode, that acts as the parent node.  However,
 402  * it is not visible to the tree or to the user., and the path "0" refers to the
 403  * first child of GtkTreeStore::root.
 404  */
 405
 406
 407 static guint
 408 gtk_tree_store_get_flags (GtkTreeModel *tree_model)
 409 {
 410   g_return_val_if_fail (GTK_IS_TREE_STORE (tree_model), 0);
 411
 412   return GTK_TREE_MODEL_ITERS_PERSIST;
 413 }
 414
 415 static gint
 416 gtk_tree_store_get_n_columns (GtkTreeModel *tree_model)
 417 {
 418   g_return_val_if_fail (GTK_IS_TREE_STORE (tree_model), 0);
 419
 420   return GTK_TREE_STORE (tree_model)->n_columns;
 421 }
 422
 423 static GType
 424 gtk_tree_store_get_column_type (GtkTreeModel *tree_model,
 425                                 gint          index)
 426 {
 427   g_return_val_if_fail (GTK_IS_TREE_STORE (tree_model), G_TYPE_INVALID);
 428   g_return_val_if_fail (index < GTK_TREE_STORE (tree_model)->n_columns &&
 429                         index >= 0, G_TYPE_INVALID);
 430
 431   return GTK_TREE_STORE (tree_model)->column_headers[index];
 432 }
 433
 434 static gboolean
 435 gtk_tree_store_get_iter (GtkTreeModel *tree_model,
 436                          GtkTreeIter  *iter,
 437                          GtkTreePath  *path)
 438 {
 439   GtkTreeStore *tree_store = (GtkTreeStore *) tree_model;
 440   GtkTreeIter parent;
 441   gint *indices;
 442   gint depth, i;
 443
 444   g_return_val_if_fail (GTK_IS_TREE_STORE (tree_store), FALSE);
 445
 446   indices = gtk_tree_path_get_indices (path);
 447   depth = gtk_tree_path_get_depth (path);
 448
 449   g_return_val_if_fail (depth > 0, FALSE);
 450
 451   parent.stamp = tree_store->stamp;
 452   parent.user_data = tree_store->root;
 453
 454   if (! gtk_tree_model_iter_nth_child (tree_model, iter, &parent, indices[0]))
 455     return FALSE;
 456
 457   for (i = 1; i < depth; i++)
 458     {
 459       parent = *iter;
 460       if (! gtk_tree_model_iter_nth_child (tree_model, iter, &parent, indices[i]))
 461         return FALSE;
 462     }
 463
 464   return TRUE;
 465 }
 466
 467 static GtkTreePath *
 468 gtk_tree_store_get_path (GtkTreeModel *tree_model,
 469                          GtkTreeIter  *iter)
 470 {
 471   GtkTreePath *retval;
 472   GNode *tmp_node;
 473   gint i = 0;
 474
 475   g_return_val_if_fail (GTK_IS_TREE_STORE (tree_model), NULL);
 476   g_return_val_if_fail (iter != NULL, NULL);
 477   g_return_val_if_fail (iter->user_data != NULL, NULL);
 478   g_return_val_if_fail (iter->stamp == GTK_TREE_STORE (tree_model)->stamp, NULL);
 479
 480   validate_tree ((GtkTreeStore*)tree_model);
 481
 482   if (G_NODE (iter->user_data)->parent == NULL &&
 483       G_NODE (iter->user_data) == GTK_TREE_STORE (tree_model)->root)
 484     return gtk_tree_path_new ();
 485   g_assert (G_NODE (iter->user_data)->parent != NULL);
 486
 487   if (G_NODE (iter->user_data)->parent == G_NODE (GTK_TREE_STORE (tree_model)->root))
 488     {
 489       retval = gtk_tree_path_new ();
 490       tmp_node = G_NODE (GTK_TREE_STORE (tree_model)->root)->children;
 491     }
 492   else
 493     {
 494       GtkTreeIter tmp_iter = *iter;
 495
 496       tmp_iter.user_data = G_NODE (iter->user_data)->parent;
 497
 498       retval = gtk_tree_store_get_path (tree_model,
 499                                         &tmp_iter);
 500       tmp_node = G_NODE (iter->user_data)->parent->children;
 501     }
 502
 503   if (retval == NULL)
 504     return NULL;
 505
 506   if (tmp_node == NULL)
 507     {
 508       gtk_tree_path_free (retval);
 509       return NULL;
 510     }
 511
 512   for (; tmp_node; tmp_node = tmp_node->next)
 513     {
 514       if (tmp_node == G_NODE (iter->user_data))
 515         break;
 516       i++;
 517     }
 518
 519   if (tmp_node == NULL)
 520     {
 521       /* We couldn't find node, meaning it's prolly not ours */
 522       /* Perhaps I should do a g_return_if_fail here. */
 523       gtk_tree_path_free (retval);
 524       return NULL;
 525     }
 526
 527   gtk_tree_path_append_index (retval, i);
 528
 529   return retval;
 530 }
 531
 532
 533 static void
 534 gtk_tree_store_get_value (GtkTreeModel *tree_model,
 535                           GtkTreeIter  *iter,
 536                           gint          column,
 537                           GValue       *value)
 538 {
 539   GtkTreeDataList *list;
 540   gint tmp_column = column;
 541
 542   g_return_if_fail (GTK_IS_TREE_STORE (tree_model));
 543   g_return_if_fail (iter != NULL);
 544   g_return_if_fail (column < GTK_TREE_STORE (tree_model)->n_columns);
 545
 546   list = G_NODE (iter->user_data)->data;
 547
 548   while (tmp_column-- > 0 && list)
 549     list = list->next;
 550
 551   if (list)
 552     {
 553       _gtk_tree_data_list_node_to_value (list,
 554                                          GTK_TREE_STORE (tree_model)->column_headers[column],
 555                                          value);
 556     }
 557   else
 558     {
 559       /* We want to return an initialized but empty (default) value */
 560       g_value_init (value, GTK_TREE_STORE (tree_model)->column_headers[column]);
 561     }
 562 }
 563
 564 static gboolean
 565 gtk_tree_store_iter_next (GtkTreeModel  *tree_model,
 566                           GtkTreeIter   *iter)
 567 {
 568   g_return_val_if_fail (iter->user_data != NULL, FALSE);
 569
 570   if (G_NODE (iter->user_data)->next)
 571     {
 572       iter->user_data = G_NODE (iter->user_data)->next;
 573       return TRUE;
 574     }
 575   else
 576     return FALSE;
 577 }
 578
 579 static gboolean
 580 gtk_tree_store_iter_children (GtkTreeModel *tree_model,
 581                               GtkTreeIter  *iter,
 582                               GtkTreeIter  *parent)
 583 {
 584   GNode *children;
 585
 586   g_return_val_if_fail (parent == NULL || parent->user_data != NULL, FALSE);
 587
 588   if (parent)
 589     children = G_NODE (parent->user_data)->children;
 590   else
 591     children = G_NODE (GTK_TREE_STORE (tree_model)->root)->children;
 592
 593   if (children)
 594     {
 595       iter->stamp = GTK_TREE_STORE (tree_model)->stamp;
 596       iter->user_data = children;
 597       return TRUE;
 598     }
 599   else
 600     return FALSE;
 601 }
 602
 603 static gboolean
 604 gtk_tree_store_iter_has_child (GtkTreeModel *tree_model,
 605                                GtkTreeIter  *iter)
 606 {
 607   g_return_val_if_fail (GTK_IS_TREE_STORE (tree_model), FALSE);
 608   g_return_val_if_fail (iter != NULL, FALSE);
 609   g_return_val_if_fail (iter->user_data != NULL, FALSE);
 610
 611   return G_NODE (iter->user_data)->children != NULL;
 612 }
 613
 614 static gint
 615 gtk_tree_store_iter_n_children (GtkTreeModel *tree_model,
 616                                 GtkTreeIter  *iter)
 617 {
 618   GNode *node;
 619   gint i = 0;
 620
 621   g_return_val_if_fail (GTK_IS_TREE_STORE (tree_model), 0);
 622   g_return_val_if_fail (iter == NULL || iter->user_data != NULL, FALSE);
 623
 624   if (iter == NULL)
 625     node = G_NODE (GTK_TREE_STORE (tree_model)->root)->children;
 626   else
 627     node = G_NODE (iter->user_data)->children;
 628
 629   while (node)
 630     {
 631       i++;
 632       node = node->next;
 633     }
 634
 635   return i;
 636 }
 637
 638 static gboolean
 639 gtk_tree_store_iter_nth_child (GtkTreeModel *tree_model,
 640                                GtkTreeIter  *iter,
 641                                GtkTreeIter  *parent,
 642                                gint          n)
 643 {
 644   GNode *parent_node;
 645   GNode *child;
 646
 647   g_return_val_if_fail (GTK_IS_TREE_STORE (tree_model), FALSE);
 648   g_return_val_if_fail (parent == NULL || parent->user_data != NULL, FALSE);
 649
 650   if (parent == NULL)
 651     parent_node = GTK_TREE_STORE (tree_model)->root;
 652   else
 653     parent_node = parent->user_data;
 654
 655   child = g_node_nth_child (parent_node, n);
 656
 657   if (child)
 658     {
 659       iter->user_data = child;
 660       iter->stamp = GTK_TREE_STORE (tree_model)->stamp;
 661       return TRUE;
 662     }
 663   else
 664     return FALSE;
 665 }
 666
 667 static gboolean
 668 gtk_tree_store_iter_parent (GtkTreeModel *tree_model,
 669                             GtkTreeIter  *iter,
 670                             GtkTreeIter  *child)
 671 {
 672   GNode *parent;
 673
 674   g_return_val_if_fail (iter != NULL, FALSE);
 675   g_return_val_if_fail (iter->user_data != NULL, FALSE);
 676
 677   parent = G_NODE (child->user_data)->parent;
 678
 679   g_assert (parent != NULL);
 680
 681   if (parent != GTK_TREE_STORE (tree_model)->root)
 682     {
 683       iter->user_data = parent;
 684       iter->stamp = GTK_TREE_STORE (tree_model)->stamp;
 685       return TRUE;
 686     }
 687   else
 688     return FALSE;
 689 }
 690
 691
 692 /* Does not emit a signal */
 693 gboolean
 694 gtk_tree_store_real_set_value (GtkTreeStore *tree_store,
 695                                GtkTreeIter  *iter,
 696                                gint          column,
 697                                GValue       *value)
 698 {
 699   GtkTreeDataList *list;
 700   GtkTreeDataList *prev;
 701   GtkTreePath *path = NULL;
 702   GValue real_value = {0, };
 703   gboolean converted = FALSE;
 704   gint orig_column = column;
 705   gboolean retval = FALSE;
 706
 707   if (! g_type_is_a (G_VALUE_TYPE (value), tree_store->column_headers[column]))
 708     {
 709       if (! (g_value_type_compatible (G_VALUE_TYPE (value), tree_store->column_headers[column]) &&
 710              g_value_type_compatible (tree_store->column_headers[column], G_VALUE_TYPE (value))))
 711         {
 712           g_warning ("%s: Unable to convert from %s to %s\n",
 713                      G_STRLOC,
 714                      g_type_name (G_VALUE_TYPE (value)),
 715                      g_type_name (tree_store->column_headers[column]));
 716           return retval;
 717         }
 718       if (!g_value_transform (value, &real_value))
 719         {
 720           g_warning ("%s: Unable to make conversion from %s to %s\n",
 721                      G_STRLOC,
 722                      g_type_name (G_VALUE_TYPE (value)),
 723                      g_type_name (tree_store->column_headers[column]));
 724           g_value_unset (&real_value);
 725           return retval;
 726         }
 727       converted = TRUE;
 728     }
 729
 730   prev = list = G_NODE (iter->user_data)->data;
 731
 732   path = gtk_tree_store_get_path (GTK_TREE_MODEL (tree_store), iter);
 733
 734   while (list != NULL)
 735     {
 736       if (column == 0)
 737         {
 738           if (converted)
 739             _gtk_tree_data_list_value_to_node (list, &real_value);
 740           else
 741             _gtk_tree_data_list_value_to_node (list, value);
 742           retval = TRUE;
 743           gtk_tree_path_free (path);
 744           if (converted)
 745             g_value_unset (&real_value);
 746           return retval;
 747         }
 748
 749       column--;
 750       prev = list;
 751       list = list->next;
 752     }
 753
 754   if (G_NODE (iter->user_data)->data == NULL)
 755     {
 756       G_NODE (iter->user_data)->data = list = _gtk_tree_data_list_alloc ();
 757       list->next = NULL;
 758     }
 759   else
 760     {
 761       list = prev->next = _gtk_tree_data_list_alloc ();
 762       list->next = NULL;
 763     }
 764
 765   while (column != 0)
 766     {
 767       list->next = _gtk_tree_data_list_alloc ();
 768       list = list->next;
 769       list->next = NULL;
 770       column --;
 771     }
 772   if (converted)
 773     _gtk_tree_data_list_value_to_node (list, &real_value);
 774   else
 775     _gtk_tree_data_list_value_to_node (list, value);
 776
 777   gtk_tree_path_free (path);
 778   if (converted)
 779     g_value_unset (&real_value);
 780
 781   if (GTK_TREE_STORE_IS_SORTED (tree_store))
 782     gtk_tree_store_sort_iter_changed (tree_store, iter, orig_column);
 783
 784   return retval;
 785 }
 786
 787 /**
 788  * gtk_tree_store_set_value:
 789  * @tree_store: a #GtkTreeStore
 790  * @iter: A valid #GtkTreeIter for the row being modified
 791  * @column: column number to modify
 792  * @value: new value for the cell
 793  *
 794  * Sets the data in the cell specified by @iter and @column.
 795  * The type of @value must be convertible to the type of the
 796  * column.
 797  *
 798  **/
 799 void
 800 gtk_tree_store_set_value (GtkTreeStore *tree_store,
 801                           GtkTreeIter  *iter,
 802                           gint          column,
 803                           GValue       *value)
 804 {
 805   g_return_if_fail (GTK_IS_TREE_STORE (tree_store));
 806   g_return_if_fail (VALID_ITER (iter, tree_store));
 807   g_return_if_fail (column >= 0 && column < tree_store->n_columns);
 808   g_return_if_fail (G_IS_VALUE (value));
 809
 810   if (gtk_tree_store_real_set_value (tree_store, iter, column, value))
 811     {
 812       GtkTreePath *path;
 813
 814       path = gtk_tree_model_get_path (GTK_TREE_MODEL (tree_store), iter);
 815       gtk_tree_model_row_changed (GTK_TREE_MODEL (tree_store), path, iter);
 816       gtk_tree_path_free (path);
 817     }
 818 }
 819
 820 /**
 821  * gtk_tree_store_set_valist:
 822  * @tree_store: A #GtkTreeStore
 823  * @iter: A valid #GtkTreeIter for the row being modified
 824  * @var_args: va_list of column/value pairs
 825  *
 826  * See @gtk_tree_store_set; this version takes a va_list for
 827  * use by language bindings.
 828  *
 829  **/
 830 void
 831 gtk_tree_store_set_valist (GtkTreeStore *tree_store,
 832                            GtkTreeIter  *iter,
 833                            va_list      var_args)
 834 {
 835   gint column;
 836   gboolean emit_signal = FALSE;
 837
 838   g_return_if_fail (GTK_IS_TREE_STORE (tree_store));
 839   g_return_if_fail (VALID_ITER (iter, tree_store));
 840
 841   column = va_arg (var_args, gint);
 842
 843   while (column != -1)
 844     {
 845       GValue value = { 0, };
 846       gchar *error = NULL;
 847
 848       if (column >= tree_store->n_columns)
 849         {
 850           g_warning ("%s: Invalid column number %d added to iter (remember to end your list of columns with a -1)", G_STRLOC, column);
 851           break;
 852         }
 853       g_value_init (&value, tree_store->column_headers[column]);
 854
 855       G_VALUE_COLLECT (&value, var_args, 0, &error);
 856       if (error)
 857         {
 858           g_warning ("%s: %s", G_STRLOC, error);
 859           g_free (error);
 860
 861           /* we purposely leak the value here, it might not be
 862            * in a sane state if an error condition occoured
 863            */
 864           break;
 865         }
 866
 867       emit_signal = gtk_tree_store_real_set_value (tree_store,
 868                                                    iter,
 869                                                    column,
 870                                                    &value) || emit_signal;
 871
 872       g_value_unset (&value);
 873
 874       column = va_arg (var_args, gint);
 875     }
 876   if (emit_signal)
 877     {
 878       GtkTreePath *path;
 879
 880       path = gtk_tree_model_get_path (GTK_TREE_MODEL (tree_store), iter);
 881       gtk_tree_model_row_changed (GTK_TREE_MODEL (tree_store), path, iter);
 882       gtk_tree_path_free (path);
 883     }
 884 }
 885
 886 /**
 887  * gtk_tree_store_set:
 888  * @tree_store: A #GtkTreeStore
 889  * @iter: A valid #GtkTreeIter for the row being modified
 890  * @Varargs: pairs of column number and value, terminated with -1
 891  *
 892  * Sets the value of one or more cells in the row referenced by @iter.
 893  * The variable argument list should contain integer column numbers,
 894  * each column number followed by the value to be set. For example,
 895  * The list is terminated by a -1. For example, to set column 0 with type
 896  * %G_TYPE_STRING to "Foo", you would write gtk_tree_store_set (store, iter,
 897  * 0, "Foo", -1).
 898  **/
 899 void
 900 gtk_tree_store_set (GtkTreeStore *tree_store,
 901                     GtkTreeIter  *iter,
 902                     ...)
 903 {
 904   va_list var_args;
 905
 906   g_return_if_fail (GTK_IS_TREE_STORE (tree_store));
 907   g_return_if_fail (VALID_ITER (iter, tree_store));
 908
 909   va_start (var_args, iter);
 910   gtk_tree_store_set_valist (tree_store, iter, var_args);
 911   va_end (var_args);
 912 }
 913
 914 /**
 915  * gtk_tree_store_remove:
 916  * @tree_store: A #GtkTreeStore
 917  * @iter: A valid #GtkTreeIter
 918  *
 919  * Removes @iter from @tree_store.  After being removed, @iter is set to the
 920  * next valid row at that level, or invalidated if it previeously pointed to the last one.
 921  **/
 922 void
 923 gtk_tree_store_remove (GtkTreeStore *tree_store,
 924                        GtkTreeIter  *iter)
 925 {
 926   GtkTreePath *path;
 927   GtkTreeIter new_iter = {0,};
 928   GNode *parent;
 929   GNode *next_node;
 930
 931   g_return_if_fail (GTK_IS_TREE_STORE (tree_store));
 932   g_return_if_fail (VALID_ITER (iter, tree_store));
 933
 934   parent = G_NODE (iter->user_data)->parent;
 935
 936   g_assert (parent != NULL);
 937   next_node = G_NODE (iter->user_data);
 938
 939   if (G_NODE (iter->user_data)->data)
 940     _gtk_tree_data_list_free ((GtkTreeDataList *) G_NODE (iter->user_data)->data,
 941                               tree_store->column_headers);
 942
 943   path = gtk_tree_store_get_path (GTK_TREE_MODEL (tree_store), iter);
 944   g_node_destroy (G_NODE (iter->user_data));
 945
 946   gtk_tree_model_row_deleted (GTK_TREE_MODEL (tree_store), path);
 947
 948   if (parent != G_NODE (tree_store->root))
 949     {
 950       /* child_toggled */
 951       if (parent->children == NULL)
 952         {
 953           gtk_tree_path_up (path);
 954
 955           new_iter.stamp = tree_store->stamp;
 956           new_iter.user_data = parent;
 957           gtk_tree_model_row_has_child_toggled (GTK_TREE_MODEL (tree_store), path, &new_iter);
 958         }
 959     }
 960   gtk_tree_path_free (path);
 961
 962   /* revalidate iter */
 963   if (next_node != NULL)
 964     {
 965       iter->stamp = tree_store->stamp;
 966       iter->user_data = next_node;
 967     }
 968   else
 969     {
 970       iter->stamp = 0;
 971     }
 972 }
 973
 974 /**
 975  * gtk_tree_store_insert:
 976  * @tree_store: A #GtkListStore
 977  * @iter: An unset #GtkTreeIter to set to the new row
 978  * @parent: A valid #GtkTreeIter, or %NULL
 979  * @position: position to insert the new row
 980  *
 981  * Creates a new row at @position.  If parent is non-NULL, then the row will be
 982  * made a child of @parent.  Otherwise, the row will be created at the toplevel.
 983  * If @position is larger than the number of rows at that level, then the new
 984  * row will be inserted to the end of the list.  @iter will be changed to point
 985  * to this new row.  The row will be empty before this function is called.  To
 986  * fill in values, you need to call @gtk_list_store_set or
 987  * @gtk_list_store_set_value.
 988  *
 989  **/
 990 void
 991 gtk_tree_store_insert (GtkTreeStore *tree_store,
 992                        GtkTreeIter  *iter,
 993                        GtkTreeIter  *parent,
 994                        gint          position)
 995 {
 996   GtkTreePath *path;
 997   GNode *parent_node;
 998
 999   g_return_if_fail (GTK_IS_TREE_STORE (tree_store));
1000   if (parent)
1001     g_return_if_fail (VALID_ITER (parent, tree_store));
1002
1003   if (parent)
1004     parent_node = parent->user_data;
1005   else
1006     parent_node = tree_store->root;
1007
1008   iter->stamp = tree_store->stamp;
1009   iter->user_data = g_node_new (NULL);
1010   g_node_insert (parent_node, position, G_NODE (iter->user_data));
1011
1012   path = gtk_tree_store_get_path (GTK_TREE_MODEL (tree_store), iter);
1013   gtk_tree_model_row_inserted (GTK_TREE_MODEL (tree_store), path, iter);
1014
1015   gtk_tree_path_free (path);
1016
1017   validate_tree ((GtkTreeStore*)tree_store);
1018 }
1019
1020 /**
1021  * gtk_tree_store_insert_before:
1022  * @tree_store: A #GtkTreeStore
1023  * @iter: An unset #GtkTreeIter to set to the new row
1024  * @parent: A valid #GtkTreeIter, or %NULL
1025  * @sibling: A valid #GtkTreeIter, or %NULL
1026  *
1027  * Inserts a new row before @sibling.  If @sibling is %NULL, then the row will
1028  * be appended to the beginning of the @parent 's children.  If @parent and
1029  * @sibling are %NULL, then the row will be appended to the toplevel.  If both
1030  * @sibling and @parent are set, then @parent must be the parent of @sibling.
1031  * When @sibling is set, @parent is optional.
1032  *
1033  * @iter will be changed to point to this new row.  The row will be empty after
1034  * this function is called.  To fill in values, you need to call
1035  * @gtk_tree_store_set or @gtk_tree_store_set_value.
1036  *
1037  **/
1038 void
1039 gtk_tree_store_insert_before (GtkTreeStore *tree_store,
1040                               GtkTreeIter  *iter,
1041                               GtkTreeIter  *parent,
1042                               GtkTreeIter  *sibling)
1043 {
1044   GtkTreePath *path;
1045   GNode *parent_node = NULL;
1046   GNode *new_node;
1047
1048   g_return_if_fail (GTK_IS_TREE_STORE (tree_store));
1049   g_return_if_fail (iter != NULL);
1050   if (parent != NULL)
1051     g_return_if_fail (VALID_ITER (parent, tree_store));
1052   if (sibling != NULL)
1053     g_return_if_fail (VALID_ITER (sibling, tree_store));
1054
1055   new_node = g_node_new (NULL);
1056
1057   if (parent == NULL && sibling == NULL)
1058     parent_node = tree_store->root;
1059   else if (parent == NULL)
1060     parent_node = G_NODE (sibling->user_data)->parent;
1061   else if (sibling == NULL)
1062     parent_node = G_NODE (parent->user_data);
1063   else
1064     {
1065       g_return_if_fail (G_NODE (sibling->user_data)->parent == G_NODE (parent->user_data));
1066       parent_node = G_NODE (parent->user_data);
1067     }
1068
1069   g_node_insert_before (parent_node,
1070                         sibling ? G_NODE (sibling->user_data) : NULL,
1071                         new_node);
1072
1073   iter->stamp = tree_store->stamp;
1074   iter->user_data = new_node;
1075
1076   path = gtk_tree_store_get_path (GTK_TREE_MODEL (tree_store), iter);
1077   gtk_tree_model_row_inserted (GTK_TREE_MODEL (tree_store), path, iter);
1078
1079   gtk_tree_path_free (path);
1080
1081   validate_tree ((GtkTreeStore*)tree_store);
1082 }
1083
1084 /**
1085  * gtk_tree_store_insert_after:
1086  * @tree_store: A #GtkTreeStore
1087  * @iter: An unset #GtkTreeIter to set to the new row
1088  * @parent: A valid #GtkTreeIter, or %NULL
1089  * @sibling: A valid #GtkTreeIter, or %NULL
1090  *
1091  * Inserts a new row after @sibling.  If @sibling is %NULL, then the row will be
1092  * prepended to the beginning of the @parent 's children.  If @parent and
1093  * @sibling are %NULL, then the row will be prepended to the toplevel.  If both
1094  * @sibling and @parent are set, then @parent must be the parent of @sibling.
1095  * When @sibling is set, @parent is optional.
1096  *
1097  * @iter will be changed to point to this new row.  The row will be empty after
1098  * this function is called.  To fill in values, you need to call
1099  * @gtk_tree_store_set or @gtk_tree_store_set_value.
1100  *
1101  **/
1102 void
1103 gtk_tree_store_insert_after (GtkTreeStore *tree_store,
1104                              GtkTreeIter  *iter,
1105                              GtkTreeIter  *parent,
1106                              GtkTreeIter  *sibling)
1107 {
1108   GtkTreePath *path;
1109   GNode *parent_node;
1110   GNode *new_node;
1111
1112   g_return_if_fail (GTK_IS_TREE_STORE (tree_store));
1113   g_return_if_fail (iter != NULL);
1114   if (parent != NULL)
1115     g_return_if_fail (VALID_ITER (parent, tree_store));
1116   if (sibling != NULL)
1117     g_return_if_fail (VALID_ITER (sibling, tree_store));
1118
1119   new_node = g_node_new (NULL);
1120
1121   if (parent == NULL && sibling == NULL)
1122     parent_node = tree_store->root;
1123   else if (parent == NULL)
1124     parent_node = G_NODE (sibling->user_data)->parent;
1125   else if (sibling == NULL)
1126     parent_node = G_NODE (parent->user_data);
1127   else
1128     {
1129       g_return_if_fail (G_NODE (sibling->user_data)->parent ==
1130                         G_NODE (parent->user_data));
1131       parent_node = G_NODE (parent->user_data);
1132     }
1133
1134
1135   g_node_insert_after (parent_node,
1136                        sibling ? G_NODE (sibling->user_data) : NULL,
1137                        new_node);
1138
1139   iter->stamp = tree_store->stamp;
1140   iter->user_data = new_node;
1141
1142   path = gtk_tree_store_get_path (GTK_TREE_MODEL (tree_store), iter);
1143   gtk_tree_model_row_inserted (GTK_TREE_MODEL (tree_store), path, iter);
1144
1145   gtk_tree_path_free (path);
1146
1147   validate_tree ((GtkTreeStore*)tree_store);
1148 }
1149
1150 /**
1151  * gtk_tree_store_prepend:
1152  * @tree_store: A #GtkTreeStore
1153  * @iter: An unset #GtkTreeIter to set to the prepended row
1154  * @parent: A valid #GtkTreeIter, or %NULL
1155  *
1156  * Prepends a new row to @tree_store.  If @parent is non-NULL, then it will prepend
1157  * the new row before the last child of @parent, otherwise it will prepend a row
1158  * to the top level.  @iter will be changed to point to this new row.  The row
1159  * will be empty after this function is called.  To fill in values, you need to
1160  * call @gtk_tree_store_set or @gtk_tree_store_set_value.
1161  **/
1162 void
1163 gtk_tree_store_prepend (GtkTreeStore *tree_store,
1164                         GtkTreeIter  *iter,
1165                         GtkTreeIter  *parent)
1166 {
1167   GNode *parent_node;
1168
1169   g_return_if_fail (GTK_IS_TREE_STORE (tree_store));
1170   g_return_if_fail (iter != NULL);
1171   if (parent != NULL)
1172     g_return_if_fail (VALID_ITER (parent, tree_store));
1173
1174   if (parent == NULL)
1175     parent_node = tree_store->root;
1176   else
1177     parent_node = parent->user_data;
1178
1179   if (parent_node->children == NULL)
1180     {
1181       GtkTreePath *path;
1182
1183       iter->stamp = tree_store->stamp;
1184       iter->user_data = g_node_new (NULL);
1185
1186       g_node_prepend (parent_node, iter->user_data);
1187
1188       path = gtk_tree_store_get_path (GTK_TREE_MODEL (tree_store), iter);
1189       gtk_tree_model_row_inserted (GTK_TREE_MODEL (tree_store), path, iter);
1190
1191       if (parent_node != tree_store->root)
1192         {
1193           gtk_tree_path_up (path);
1194           gtk_tree_model_row_has_child_toggled (GTK_TREE_MODEL (tree_store), path, parent);
1195         }
1196       gtk_tree_path_free (path);
1197     }
1198   else
1199     {
1200       gtk_tree_store_insert_after (tree_store, iter, parent, NULL);
1201     }
1202
1203   validate_tree ((GtkTreeStore*)tree_store);
1204 }
1205
1206 /**
1207  * gtk_tree_store_append:
1208  * @tree_store: A #GtkTreeStore
1209  * @iter: An unset #GtkTreeIter to set to the appended row
1210  * @parent: A valid #GtkTreeIter, or %NULL
1211  *
1212  * Appends a new row to @tree_store.  If @parent is non-NULL, then it will append the
1213  * new row after the last child of @parent, otherwise it will append a row to
1214  * the top level.  @iter will be changed to point to this new row.  The row will
1215  * be empty after this function is called.  To fill in values, you need to call
1216  * @gtk_tree_store_set or @gtk_tree_store_set_value.
1217  **/
1218 void
1219 gtk_tree_store_append (GtkTreeStore *tree_store,
1220                        GtkTreeIter  *iter,
1221                        GtkTreeIter  *parent)
1222 {
1223   GNode *parent_node;
1224
1225   g_return_if_fail (GTK_IS_TREE_STORE (tree_store));
1226   g_return_if_fail (iter != NULL);
1227
1228   if (parent != NULL)
1229     g_return_if_fail (VALID_ITER (parent, tree_store));
1230
1231   if (parent == NULL)
1232     parent_node = tree_store->root;
1233   else
1234     parent_node = parent->user_data;
1235
1236   if (parent_node->children == NULL)
1237     {
1238       GtkTreePath *path;
1239
1240       iter->stamp = tree_store->stamp;
1241       iter->user_data = g_node_new (NULL);
1242
1243       g_node_append (parent_node, G_NODE (iter->user_data));
1244
1245       path = gtk_tree_store_get_path (GTK_TREE_MODEL (tree_store), iter);
1246       gtk_tree_model_row_inserted (GTK_TREE_MODEL (tree_store), path, iter);
1247
1248       if (parent_node != tree_store->root)
1249         {
1250           gtk_tree_path_up (path);
1251           gtk_tree_model_row_has_child_toggled (GTK_TREE_MODEL (tree_store), path, parent);
1252         }
1253       gtk_tree_path_free (path);
1254     }
1255   else
1256     {
1257       gtk_tree_store_insert_before (tree_store, iter, parent, NULL);
1258     }
1259
1260   validate_tree ((GtkTreeStore*)tree_store);
1261 }
1262
1263 /**
1264  * gtk_tree_store_is_ancestor:
1265  * @tree_store: A #GtkTreeStore
1266  * @iter: A valid #GtkTreeIter
1267  * @descendant: A valid #GtkTreeIter
1268  *
1269  * Returns %TRUE if @iter is an ancestor of @descendant.  That is, @iter is the
1270  * parent (or grandparent or great-grandparent) of @descendant.
1271  *
1272  * Return value: %TRUE, if @iter is an ancestor of @descendant
1273  **/
1274 gboolean
1275 gtk_tree_store_is_ancestor (GtkTreeStore *tree_store,
1276                             GtkTreeIter  *iter,
1277                             GtkTreeIter  *descendant)
1278 {
1279   g_return_val_if_fail (GTK_IS_TREE_STORE (tree_store), FALSE);
1280   g_return_val_if_fail (VALID_ITER (iter, tree_store), FALSE);
1281   g_return_val_if_fail (VALID_ITER (descendant, tree_store), FALSE);
1282
1283   return g_node_is_ancestor (G_NODE (iter->user_data),
1284                              G_NODE (descendant->user_data));
1285 }
1286
1287
1288 /**
1289  * gtk_tree_store_iter_depth:
1290  * @tree_store: A #GtkTreeStore
1291  * @iter: A valid #GtkTreeIter
1292  *
1293  * Returns the depth of @iter.  This will be 0 for anything on the root level, 1
1294  * for anything down a level, etc.
1295  *
1296  * Return value: The depth of @iter
1297  **/
1298 gint
1299 gtk_tree_store_iter_depth (GtkTreeStore *tree_store,
1300                            GtkTreeIter  *iter)
1301 {
1302   g_return_val_if_fail (GTK_IS_TREE_STORE (tree_store), 0);
1303   g_return_val_if_fail (VALID_ITER (iter, tree_store), 0);
1304
1305   return g_node_depth (G_NODE (iter->user_data)) - 1;
1306 }
1307
1308
1309 /**
1310  * gtk_tree_store_clear:
1311  * @tree_store: @ #GtkTreeStore
1312  *
1313  * Removes all rows from @tree_store
1314  **/
1315 void
1316 gtk_tree_store_clear (GtkTreeStore *tree_store)
1317 {
1318   GtkTreeIter iter;
1319
1320   g_return_if_fail (GTK_IS_TREE_STORE (tree_store));
1321
1322   while (G_NODE (tree_store->root)->children)
1323     {
1324       iter.stamp = tree_store->stamp;
1325       iter.user_data = G_NODE (tree_store->root)->children;
1326       gtk_tree_store_remove (tree_store, &iter);
1327     }
1328 }
1329
1330 /* DND */
1331
1332
1333 static gboolean
1334 gtk_tree_store_drag_data_delete (GtkTreeDragSource *drag_source,
1335                                  GtkTreePath       *path)
1336 {
1337   GtkTreeIter iter;
1338
1339   g_return_val_if_fail (GTK_IS_TREE_STORE (drag_source), FALSE);
1340
1341   if (gtk_tree_model_get_iter (GTK_TREE_MODEL (drag_source),
1342                                &iter,
1343                                path))
1344     {
1345       gtk_tree_store_remove (GTK_TREE_STORE (drag_source),
1346                              &iter);
1347       return TRUE;
1348     }
1349   else
1350     {
1351       return FALSE;
1352     }
1353 }
1354
1355 static gboolean
1356 gtk_tree_store_drag_data_get (GtkTreeDragSource *drag_source,
1357                               GtkTreePath       *path,
1358                               GtkSelectionData  *selection_data)
1359 {
1360   g_return_val_if_fail (GTK_IS_TREE_STORE (drag_source), FALSE);
1361
1362   /* Note that we don't need to handle the GTK_TREE_MODEL_ROW
1363    * target, because the default handler does it for us, but
1364    * we do anyway for the convenience of someone maybe overriding the
1365    * default handler.
1366    */
1367
1368   if (gtk_selection_data_set_tree_row (selection_data,
1369                                        GTK_TREE_MODEL (drag_source),
1370                                        path))
1371     {
1372       return TRUE;
1373     }
1374   else
1375     {
1376       /* FIXME handle text targets at least. */
1377     }
1378
1379   return FALSE;
1380 }
1381
1382 static void
1383 copy_node_data (GtkTreeStore *tree_store,
1384                 GtkTreeIter  *src_iter,
1385                 GtkTreeIter  *dest_iter)
1386 {
1387   GtkTreeDataList *dl = G_NODE (src_iter->user_data)->data;
1388   GtkTreeDataList *copy_head = NULL;
1389   GtkTreeDataList *copy_prev = NULL;
1390   GtkTreeDataList *copy_iter = NULL;
1391   GtkTreePath *path;
1392   gint col;
1393
1394   col = 0;
1395   while (dl)
1396     {
1397       copy_iter = _gtk_tree_data_list_node_copy (dl, tree_store->column_headers[col]);
1398
1399       if (copy_head == NULL)
1400         copy_head = copy_iter;
1401
1402       if (copy_prev)
1403         copy_prev->next = copy_iter;
1404
1405       copy_prev = copy_iter;
1406
1407       dl = dl->next;
1408       ++col;
1409     }
1410
1411   G_NODE (dest_iter->user_data)->data = copy_head;
1412
1413   path = gtk_tree_store_get_path (GTK_TREE_MODEL (tree_store), dest_iter);
1414   gtk_tree_model_row_changed (GTK_TREE_MODEL (tree_store), path, dest_iter);
1415   gtk_tree_path_free (path);
1416 }
1417
1418 static void
1419 recursive_node_copy (GtkTreeStore *tree_store,
1420                      GtkTreeIter  *src_iter,
1421                      GtkTreeIter  *dest_iter)
1422 {
1423   GtkTreeIter child;
1424   GtkTreeModel *model;
1425
1426   model = GTK_TREE_MODEL (tree_store);
1427
1428   copy_node_data (tree_store, src_iter, dest_iter);
1429
1430   if (gtk_tree_model_iter_children (model,
1431                                     &child,
1432                                     src_iter))
1433     {
1434       /* Need to create children and recurse. Note our
1435        * dependence on persistent iterators here.
1436        */
1437       do
1438         {
1439           GtkTreeIter copy;
1440
1441           /* Gee, a really slow algorithm... ;-) FIXME */
1442           gtk_tree_store_append (tree_store,
1443                                  &copy,
1444                                  dest_iter);
1445
1446           recursive_node_copy (tree_store, &child, &copy);
1447         }
1448       while (gtk_tree_model_iter_next (model, &child));
1449     }
1450 }
1451
1452 static gboolean
1453 gtk_tree_store_drag_data_received (GtkTreeDragDest   *drag_dest,
1454                                    GtkTreePath       *dest,
1455                                    GtkSelectionData  *selection_data)
1456 {
1457   GtkTreeModel *tree_model;
1458   GtkTreeStore *tree_store;
1459   GtkTreeModel *src_model = NULL;
1460   GtkTreePath *src_path = NULL;
1461   gboolean retval = FALSE;
1462
1463   g_return_val_if_fail (GTK_IS_TREE_STORE (drag_dest), FALSE);
1464
1465   tree_model = GTK_TREE_MODEL (drag_dest);
1466   tree_store = GTK_TREE_STORE (drag_dest);
1467
1468   validate_tree (tree_store);
1469
1470   if (gtk_selection_data_get_tree_row (selection_data,
1471                                        &src_model,
1472                                        &src_path) &&
1473       src_model == tree_model)
1474     {
1475       /* Copy the given row to a new position */
1476       GtkTreeIter src_iter;
1477       GtkTreeIter dest_iter;
1478       GtkTreePath *prev;
1479
1480       if (!gtk_tree_model_get_iter (src_model,
1481                                     &src_iter,
1482                                     src_path))
1483         {
1484           goto out;
1485         }
1486
1487       /* Get the path to insert _after_ (dest is the path to insert _before_) */
1488       prev = gtk_tree_path_copy (dest);
1489
1490       if (!gtk_tree_path_prev (prev))
1491         {
1492           GtkTreeIter dest_parent;
1493           GtkTreePath *parent;
1494           GtkTreeIter *dest_parent_p;
1495
1496           /* dest was the first spot at the current depth; which means
1497            * we are supposed to prepend.
1498            */
1499
1500           /* Get the parent, NULL if parent is the root */
1501           dest_parent_p = NULL;
1502           parent = gtk_tree_path_copy (dest);
1503           if (gtk_tree_path_up (parent))
1504             {
1505               gtk_tree_model_get_iter (tree_model,
1506                                        &dest_parent,
1507                                        parent);
1508               dest_parent_p = &dest_parent;
1509             }
1510           gtk_tree_path_free (parent);
1511           parent = NULL;
1512
1513           gtk_tree_store_prepend (GTK_TREE_STORE (tree_model),
1514                                   &dest_iter,
1515                                   dest_parent_p);
1516
1517           retval = TRUE;
1518         }
1519       else
1520         {
1521           if (gtk_tree_model_get_iter (GTK_TREE_MODEL (tree_model),
1522                                        &dest_iter,
1523                                        prev))
1524             {
1525               GtkTreeIter tmp_iter = dest_iter;
1526               gtk_tree_store_insert_after (GTK_TREE_STORE (tree_model),
1527                                            &dest_iter,
1528                                            NULL,
1529                                            &tmp_iter);
1530               retval = TRUE;
1531
1532             }
1533         }
1534
1535       gtk_tree_path_free (prev);
1536
1537       /* If we succeeded in creating dest_iter, walk src_iter tree branch,
1538        * duplicating it below dest_iter.
1539        */
1540
1541       if (retval)
1542         {
1543           recursive_node_copy (tree_store,
1544                                &src_iter,
1545                                &dest_iter);
1546         }
1547     }
1548   else
1549     {
1550       /* FIXME maybe add some data targets eventually, or handle text
1551        * targets in the simple case.
1552        */
1553
1554     }
1555
1556  out:
1557
1558   if (src_path)
1559     gtk_tree_path_free (src_path);
1560
1561   return retval;
1562 }
1563
1564 static gboolean
1565 gtk_tree_store_row_drop_possible (GtkTreeDragDest *drag_dest,
1566                                   GtkTreeModel    *src_model,
1567                                   GtkTreePath     *src_path,
1568                                   GtkTreePath     *dest_path)
1569 {
1570   /* can only drag to ourselves */
1571   if (src_model != GTK_TREE_MODEL (drag_dest))
1572     return FALSE;
1573
1574   /* Can't drop into ourself. */
1575   if (gtk_tree_path_is_ancestor (src_path,
1576                                  dest_path))
1577     return FALSE;
1578
1579   /* Can't drop if dest_path's parent doesn't exist */
1580   {
1581     GtkTreeIter iter;
1582     GtkTreePath *tmp = gtk_tree_path_copy (dest_path);
1583
1584     /* if we can't go up, we know the parent exists, the root
1585      * always exists.
1586      */
1587     if (gtk_tree_path_up (tmp))
1588       {
1589         if (!gtk_tree_model_get_iter (GTK_TREE_MODEL (drag_dest),
1590                                       &iter, tmp))
1591           {
1592             if (tmp)
1593               gtk_tree_path_free (tmp);
1594             return FALSE;
1595           }
1596       }
1597
1598     if (tmp)
1599       gtk_tree_path_free (tmp);
1600   }
1601
1602   /* Can otherwise drop anywhere. */
1603   return TRUE;
1604 }
1605
1606 /* Sorting */
1607 typedef struct _SortTuple
1608 {
1609   gint offset;
1610   GNode *node;
1611 } SortTuple;
1612
1613 static gint
1614 gtk_tree_store_compare_func (gconstpointer a,
1615                              gconstpointer b,
1616                              gpointer      user_data)
1617 {
1618   GtkTreeStore *tree_store = user_data;
1619   GNode *node_a;
1620   GNode *node_b;
1621   GtkTreeIterCompareFunc func;
1622   gpointer data;
1623
1624   GtkTreeIter iter_a;
1625   GtkTreeIter iter_b;
1626   gint retval;
1627
1628   if (tree_store->sort_column_id != -1)
1629     {
1630       GtkTreeDataSortHeader *header;
1631
1632       header = _gtk_tree_data_list_get_header (tree_store->sort_list,
1633                                                tree_store->sort_column_id);
1634       g_return_val_if_fail (header != NULL, 0);
1635       g_return_val_if_fail (header->func != NULL, 0);
1636
1637       func = header->func;
1638       data = header->data;
1639     }
1640   else
1641     {
1642       g_return_val_if_fail (tree_store->default_sort_func != NULL, 0);
1643       func = tree_store->default_sort_func;
1644       data = tree_store->default_sort_data;
1645     }
1646
1647   node_a = ((SortTuple *) a)->node;
1648   node_b = ((SortTuple *) b)->node;
1649
1650   iter_a.stamp = tree_store->stamp;
1651   iter_a.user_data = node_a;
1652   iter_b.stamp = tree_store->stamp;
1653   iter_b.user_data = node_b;
1654
1655   retval = (* func) (GTK_TREE_MODEL (user_data), &iter_a, &iter_b, data);
1656
1657   if (tree_store->order == GTK_SORT_DESCENDING)
1658     {
1659       if (retval > 0)
1660         retval = -1;
1661       else if (retval < 0)
1662         retval = 1;
1663     }
1664   return retval;
1665 }
1666
1667 static void
1668 gtk_tree_store_sort_helper (GtkTreeStore *tree_store,
1669                             GNode        *parent,
1670                             gboolean      recurse)
1671 {
1672   GtkTreeIter iter;
1673   GArray *sort_array;
1674   GNode *node;
1675   GNode *tmp_node;
1676   gint list_length;
1677   gint i;
1678   gint *new_order;
1679   GtkTreePath *path;
1680
1681   node = parent->children;
1682   if (node == NULL || node->next == NULL)
1683     return;
1684
1685   g_assert (GTK_TREE_STORE_IS_SORTED (tree_store));
1686
1687   list_length = 0;
1688   for (tmp_node = node; tmp_node; tmp_node = tmp_node->next)
1689     list_length++;
1690
1691   sort_array = g_array_sized_new (FALSE, FALSE, sizeof (SortTuple), list_length);
1692
1693   i = 0;
1694   for (tmp_node = node; tmp_node; tmp_node = tmp_node->next)
1695     {
1696       SortTuple tuple;
1697
1698       tuple.offset = i;
1699       tuple.node = tmp_node;
1700       g_array_append_val (sort_array, tuple);
1701       i++;
1702     }
1703
1704   g_array_sort_with_data (sort_array, gtk_tree_store_compare_func, tree_store);
1705
1706   for (i = 0; i < list_length - 1; i++)
1707     {
1708       g_array_index (sort_array, SortTuple, i).node->next =
1709         g_array_index (sort_array, SortTuple, i + 1).node;
1710       g_array_index (sort_array, SortTuple, i + 1).node->prev =
1711         g_array_index (sort_array, SortTuple, i).node;
1712     }
1713   g_array_index (sort_array, SortTuple, list_length - 1).node->next = NULL;
1714   g_array_index (sort_array, SortTuple, 0).node->prev = NULL;
1715   parent->children = g_array_index (sort_array, SortTuple, 0).node;
1716
1717   /* Let the world know about our new order */
1718   new_order = g_new (gint, list_length);
1719   for (i = 0; i < list_length; i++)
1720     new_order[i] = g_array_index (sort_array, SortTuple, i).offset;
1721
1722   iter.stamp = tree_store->stamp;
1723   iter.user_data = parent;
1724   path = gtk_tree_store_get_path (GTK_TREE_MODEL (tree_store), &iter);
1725   gtk_tree_model_rows_reordered (GTK_TREE_MODEL (tree_store),
1726                                  path, &iter, new_order);
1727   gtk_tree_path_free (path);
1728   g_free (new_order);
1729   g_array_free (sort_array, TRUE);
1730
1731   if (recurse)
1732     {
1733       for (tmp_node = parent->children; tmp_node; tmp_node = tmp_node->next)
1734         {
1735           if (tmp_node->children)
1736             gtk_tree_store_sort_helper (tree_store, tmp_node, TRUE);
1737         }
1738     }
1739 }
1740
1741 static void
1742 gtk_tree_store_sort (GtkTreeStore *tree_store)
1743 {
1744   if (tree_store->sort_column_id != -1)
1745     {
1746       GtkTreeDataSortHeader *header = NULL;
1747
1748       header = _gtk_tree_data_list_get_header (tree_store->sort_list, tree_store->sort_column_id);
1749
1750       /* We want to make sure that we have a function */
1751       g_return_if_fail (header != NULL);
1752       g_return_if_fail (header->func != NULL);
1753     }
1754   else
1755     {
1756       g_return_if_fail (tree_store->default_sort_func != NULL);
1757     }
1758
1759   gtk_tree_store_sort_helper (tree_store, G_NODE (tree_store->root), TRUE);
1760 }
1761
1762 static void
1763 gtk_tree_store_sort_iter_changed (GtkTreeStore *tree_store,
1764                                   GtkTreeIter  *iter,
1765                                   gint          column)
1766 {
1767   GNode *prev = NULL;
1768   GNode *next = NULL;
1769   GNode *node;
1770   GtkTreePath *tmp_path;
1771   GtkTreeIter tmp_iter;
1772   gint cmp_a = 0;
1773   gint cmp_b = 0;
1774   gint i;
1775   gint old_location;
1776   gint new_location;
1777   gint *new_order;
1778   gint length;
1779   GtkTreeIterCompareFunc func;
1780   gpointer data;
1781
1782   g_return_if_fail (G_NODE (iter->user_data)->parent != NULL);
1783
1784   tmp_iter.stamp = tree_store->stamp;
1785   if (tree_store->sort_column_id != -1)
1786     {
1787       GtkTreeDataSortHeader *header;
1788       header = _gtk_tree_data_list_get_header (tree_store->sort_list,
1789                                                tree_store->sort_column_id);
1790       g_return_if_fail (header != NULL);
1791       g_return_if_fail (header->func != NULL);
1792       func = header->func;
1793       data = header->data;
1794     }
1795   else
1796     {
1797       g_return_if_fail (tree_store->default_sort_func != NULL);
1798       func = tree_store->default_sort_func;
1799       data = tree_store->default_sort_data;
1800     }
1801
1802   /* If it's the built in function, we don't sort. */
1803   if (func == gtk_tree_data_list_compare_func &&
1804       tree_store->sort_column_id != column)
1805     return;
1806
1807   old_location = 0;
1808   node = G_NODE (iter->user_data)->parent->children;
1809   /* First we find the iter, its prev, and its next */
1810   while (node)
1811     {
1812       if (node == G_NODE (iter->user_data))
1813         break;
1814       old_location++;
1815       node = node->next;
1816     }
1817   g_assert (node != NULL);
1818
1819   prev = node->prev;
1820   next = node->next;
1821
1822   /* Check the common case, where we don't need to sort it moved. */
1823   if (prev != NULL)
1824     {
1825       tmp_iter.user_data = prev;
1826       cmp_a = (* func) (GTK_TREE_MODEL (tree_store), &tmp_iter, iter, data);
1827     }
1828
1829   if (next != NULL)
1830     {
1831       tmp_iter.user_data = next;
1832       cmp_b = (* func) (GTK_TREE_MODEL (tree_store), iter, &tmp_iter, data);
1833     }
1834
1835
1836   if (tree_store->order == GTK_SORT_DESCENDING)
1837     {
1838       if (cmp_a < 0)
1839         cmp_a = 1;
1840       else if (cmp_a > 0)
1841         cmp_a = -1;
1842
1843       if (cmp_b < 0)
1844         cmp_b = 1;
1845       else if (cmp_b > 0)
1846         cmp_b = -1;
1847     }
1848
1849   if (prev == NULL && cmp_b <= 0)
1850     return;
1851   else if (next == NULL && cmp_a <= 0)
1852     return;
1853   else if (prev != NULL && next != NULL &&
1854            cmp_a <= 0 && cmp_b <= 0)
1855     return;
1856
1857   /* We actually need to sort it */
1858   /* First, remove the old link. */
1859
1860   if (prev)
1861     prev->next = next;
1862   else
1863     node->parent->children = next;
1864   if (next)
1865     next->prev = prev;
1866
1867   node->prev = NULL;
1868   node->next = NULL;
1869
1870   /* FIXME: as an optimization, we can potentially start at next */
1871   prev = NULL;
1872   node = node->parent->children;
1873   new_location = 0;
1874   tmp_iter.user_data = node;
1875   if (tree_store->order == GTK_SORT_DESCENDING)
1876     cmp_a = (* func) (GTK_TREE_MODEL (tree_store), &tmp_iter, iter, data);
1877   else
1878     cmp_a = (* func) (GTK_TREE_MODEL (tree_store), iter, &tmp_iter, data);
1879
1880   while ((node->next) && (cmp_a > 0))
1881     {
1882       prev = node;
1883       node = node->next;
1884       new_location++;
1885       tmp_iter.user_data = node;
1886       if (tree_store->order == GTK_SORT_DESCENDING)
1887         cmp_a = (* func) (GTK_TREE_MODEL (tree_store), &tmp_iter, iter, data);
1888       else
1889         cmp_a = (* func) (GTK_TREE_MODEL (tree_store), iter, &tmp_iter, data);
1890     }
1891
1892   if ((!node->next) && (cmp_a > 0))
1893     {
1894       node->next = G_NODE (iter->user_data);
1895       node->next->prev = node;
1896     }
1897   else if (prev)
1898     {
1899       prev->next = G_NODE (iter->user_data);
1900       prev->next->prev = prev;
1901       G_NODE (iter->user_data)->next = node;
1902       G_NODE (iter->user_data)->next->prev = G_NODE (iter->user_data);
1903     }
1904   else
1905     {
1906       G_NODE (iter->user_data)->next = G_NODE (iter->user_data)->parent->children;
1907       G_NODE (iter->user_data)->parent->children = G_NODE (iter->user_data);
1908     }
1909
1910   /* Emit the reordered signal. */
1911   length = g_node_n_children (node->parent);
1912   new_order = g_new (int, length);
1913   if (old_location < new_location)
1914     for (i = 0; i < length; i++)
1915       {
1916         if (i < old_location ||
1917             i > new_location)
1918           new_order[i] = i;
1919         else if (i >= old_location &&
1920                  i < new_location)
1921           new_order[i] = i + 1;
1922         else if (i == new_location)
1923           new_order[i] = old_location;
1924       }
1925   else
1926     for (i = 0; i < length; i++)
1927       {
1928         if (i < new_location ||
1929             i > old_location)
1930           new_order[i] = i;
1931         else if (i > new_location &&
1932                  i <= old_location)
1933           new_order[i] = i - 1;
1934         else if (i == new_location)
1935           new_order[i] = old_location;
1936       }
1937
1938   tmp_iter.user_data = node->parent;
1939   tmp_path = gtk_tree_store_get_path (GTK_TREE_MODEL (tree_store), &tmp_iter);
1940
1941   gtk_tree_model_rows_reordered (GTK_TREE_MODEL (tree_store),
1942                                  tmp_path, &tmp_iter,
1943                                  new_order);
1944
1945   gtk_tree_path_free (tmp_path);
1946   g_free (new_order);
1947 }
1948
1949
1950 static gboolean
1951 gtk_tree_store_get_sort_column_id (GtkTreeSortable  *sortable,
1952                                    gint             *sort_column_id,
1953                                    GtkSortType      *order)
1954 {
1955   GtkTreeStore *tree_store = (GtkTreeStore *) sortable;
1956
1957   g_return_val_if_fail (GTK_IS_TREE_STORE (sortable), FALSE);
1958
1959   if (tree_store->sort_column_id == -1)
1960     return FALSE;
1961
1962   if (sort_column_id)
1963     * sort_column_id = tree_store->sort_column_id;
1964   if (order)
1965     * order = tree_store->order;
1966   return TRUE;
1967
1968 }
1969
1970 static void
1971 gtk_tree_store_set_sort_column_id (GtkTreeSortable  *sortable,
1972                                    gint              sort_column_id,
1973                                    GtkSortType       order)
1974 {
1975   GtkTreeStore *tree_store = (GtkTreeStore *) sortable;
1976
1977   g_return_if_fail (GTK_IS_TREE_STORE (sortable));
1978
1979
1980   if ((tree_store->sort_column_id == sort_column_id) &&
1981       (tree_store->order == order))
1982     return;
1983
1984   if (sort_column_id != -1)
1985     {
1986       GtkTreeDataSortHeader *header = NULL;
1987
1988       header = _gtk_tree_data_list_get_header (tree_store->sort_list, sort_column_id);
1989
1990       /* We want to make sure that we have a function */
1991       g_return_if_fail (header != NULL);
1992       g_return_if_fail (header->func != NULL);
1993     }
1994   else
1995     {
1996       g_return_if_fail (tree_store->default_sort_func != NULL);
1997     }
1998
1999   tree_store->sort_column_id = sort_column_id;
2000   tree_store->order = order;
2001
2002   gtk_tree_store_sort (tree_store);
2003
2004   gtk_tree_sortable_sort_column_changed (sortable);
2005 }
2006
2007 static void
2008 gtk_tree_store_set_sort_func (GtkTreeSortable        *sortable,
2009                               gint                    sort_column_id,
2010                               GtkTreeIterCompareFunc  func,
2011                               gpointer                data,
2012                               GtkDestroyNotify        destroy)
2013 {
2014   GtkTreeStore *tree_store = (GtkTreeStore *) sortable;
2015   GtkTreeDataSortHeader *header = NULL;
2016   GList *list;
2017
2018   g_return_if_fail (GTK_IS_TREE_STORE (sortable));
2019   g_return_if_fail (func != NULL);
2020
2021   for (list = tree_store->sort_list; list; list = list->next)
2022     {
2023       header = (GtkTreeDataSortHeader*) list->data;
2024       if (header->sort_column_id == sort_column_id)
2025         break;
2026     }
2027
2028   if (header == NULL)
2029     {
2030       header = g_new0 (GtkTreeDataSortHeader, 1);
2031       header->sort_column_id = sort_column_id;
2032       tree_store->sort_list = g_list_append (tree_store->sort_list, header);
2033     }
2034
2035   if (header->destroy)
2036     (* header->destroy) (header->data);
2037
2038   header->func = func;
2039   header->data = data;
2040   header->destroy = destroy;
2041
2042 }
2043
2044 static void
2045 gtk_tree_store_set_default_sort_func (GtkTreeSortable        *sortable,
2046                                       GtkTreeIterCompareFunc  func,
2047                                       gpointer                data,
2048                                       GtkDestroyNotify        destroy)
2049 {
2050   GtkTreeStore *tree_store = (GtkTreeStore *) sortable;
2051
2052   g_return_if_fail (GTK_IS_TREE_STORE (sortable));
2053
2054   if (tree_store->default_sort_destroy)
2055     (* tree_store->default_sort_destroy) (tree_store->default_sort_data);
2056
2057   tree_store->default_sort_func = func;
2058   tree_store->default_sort_data = data;
2059   tree_store->default_sort_destroy = destroy;
2060 }
2061
2062 static gboolean
2063 gtk_tree_store_has_default_sort_func (GtkTreeSortable *sortable)
2064 {
2065   GtkTreeStore *tree_store = (GtkTreeStore *) sortable;
2066
2067   g_return_val_if_fail (GTK_IS_TREE_STORE (sortable), FALSE);
2068
2069   return (tree_store->default_sort_func != NULL);
2070 }
2071
2072 static void
2073 validate_gnode (GNode* node)
2074 {
2075   GNode *iter;
2076
2077   iter = node->children;
2078   while (iter != NULL)
2079     {
2080       g_assert (iter->parent == node);
2081       if (iter->prev)
2082         g_assert (iter->prev->next == iter);
2083       validate_gnode (iter);
2084       iter = iter->next;
2085     }
2086 }
2087
2088
2089