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 "gtksignal.h"
  25 #include <string.h>
  26 #include <gobject/gvaluecollector.h>
  27
  28 #define G_NODE(node) ((GNode *)node)
  29
  30 enum {
  31   CHANGED,
  32   INSERTED,
  33   CHILD_TOGGLED,
  34   DELETED,
  35   LAST_SIGNAL
  36 };
  37
  38 static guint tree_store_signals[LAST_SIGNAL] = { 0 };
  39
  40
  41 static void         gtk_tree_store_init            (GtkTreeStore      *tree_store);
  42 static void         gtk_tree_store_class_init      (GtkTreeStoreClass *tree_store_class);
  43 static void         gtk_tree_store_tree_model_init (GtkTreeModelIface *iface);
  44 static void         gtk_tree_store_drag_source_init(GtkTreeDragSourceIface *iface);
  45 static void         gtk_tree_store_drag_dest_init  (GtkTreeDragDestIface   *iface);
  46 static guint        gtk_tree_store_get_flags       (GtkTreeModel      *tree_model);
  47 static gint         gtk_tree_store_get_n_columns   (GtkTreeModel      *tree_model);
  48 static GType        gtk_tree_store_get_column_type (GtkTreeModel      *tree_model,
  49                                                     gint               index);
  50 static GtkTreePath *gtk_tree_store_get_path        (GtkTreeModel      *tree_model,
  51                                                     GtkTreeIter       *iter);
  52 static void         gtk_tree_store_get_value       (GtkTreeModel      *tree_model,
  53                                                     GtkTreeIter       *iter,
  54                                                     gint               column,
  55                                                     GValue            *value);
  56 static gboolean     gtk_tree_store_iter_next       (GtkTreeModel      *tree_model,
  57                                                     GtkTreeIter       *iter);
  58 static gboolean     gtk_tree_store_iter_children   (GtkTreeModel      *tree_model,
  59                                                     GtkTreeIter       *iter,
  60                                                     GtkTreeIter       *parent);
  61 static gboolean     gtk_tree_store_iter_has_child  (GtkTreeModel      *tree_model,
  62                                                     GtkTreeIter       *iter);
  63 static gint         gtk_tree_store_iter_n_children (GtkTreeModel      *tree_model,
  64                                                     GtkTreeIter       *iter);
  65 static gboolean     gtk_tree_store_iter_nth_child  (GtkTreeModel      *tree_model,
  66                                                     GtkTreeIter       *iter,
  67                                                     GtkTreeIter       *parent,
  68                                                     gint               n);
  69 static gboolean     gtk_tree_store_iter_parent     (GtkTreeModel      *tree_model,
  70                                                     GtkTreeIter       *iter,
  71                                                     GtkTreeIter       *child);
  72
  73
  74 static gboolean gtk_tree_store_drag_data_delete   (GtkTreeDragSource *drag_source,
  75                                                    GtkTreePath       *path);
  76 static gboolean gtk_tree_store_drag_data_get      (GtkTreeDragSource *drag_source,
  77                                                    GtkTreePath       *path,
  78                                                    GtkSelectionData  *selection_data);
  79 static gboolean gtk_tree_store_drag_data_received (GtkTreeDragDest   *drag_dest,
  80                                                    GtkTreePath       *dest,
  81                                                    GtkSelectionData  *selection_data);
  82 static gboolean gtk_tree_store_row_drop_possible  (GtkTreeDragDest   *drag_dest,
  83                                                    GtkTreeModel      *src_model,
  84                                                    GtkTreePath       *src_path,
  85                                                    GtkTreePath       *dest_path);
  86
  87 static void     validate_gnode                    (GNode *node);
  88
  89 static inline void
  90 validate_tree (GtkTreeStore *tree_store)
  91 {
  92   if (gtk_debug_flags & GTK_DEBUG_TREE)
  93     {
  94       g_assert (G_NODE (tree_store->root)->parent == NULL);
  95
  96       validate_gnode (G_NODE (tree_store->root));
  97     }
  98 }
  99
 100 GtkType
 101 gtk_tree_store_get_type (void)
 102 {
 103   static GtkType tree_store_type = 0;
 104
 105   if (!tree_store_type)
 106     {
 107       static const GTypeInfo tree_store_info =
 108       {
 109         sizeof (GtkTreeStoreClass),
 110         NULL,           /* base_init */
 111         NULL,           /* base_finalize */
 112         (GClassInitFunc) gtk_tree_store_class_init,
 113         NULL,           /* class_finalize */
 114         NULL,           /* class_data */
 115         sizeof (GtkTreeStore),
 116         0,              /* n_preallocs */
 117         (GInstanceInitFunc) gtk_tree_store_init
 118       };
 119
 120       static const GInterfaceInfo tree_model_info =
 121       {
 122         (GInterfaceInitFunc) gtk_tree_store_tree_model_init,
 123         NULL,
 124         NULL
 125       };
 126
 127       static const GInterfaceInfo drag_source_info =
 128       {
 129         (GInterfaceInitFunc) gtk_tree_store_drag_source_init,
 130         NULL,
 131         NULL
 132       };
 133
 134       static const GInterfaceInfo drag_dest_info =
 135       {
 136         (GInterfaceInitFunc) gtk_tree_store_drag_dest_init,
 137         NULL,
 138         NULL
 139       };
 140
 141       tree_store_type = g_type_register_static (GTK_TYPE_OBJECT, "GtkTreeStore", &tree_store_info, 0);
 142
 143       g_type_add_interface_static (tree_store_type,
 144                                    GTK_TYPE_TREE_MODEL,
 145                                    &tree_model_info);
 146
 147       g_type_add_interface_static (tree_store_type,
 148                                    GTK_TYPE_TREE_DRAG_SOURCE,
 149                                    &drag_source_info);
 150       g_type_add_interface_static (tree_store_type,
 151                                    GTK_TYPE_TREE_DRAG_DEST,
 152                                    &drag_dest_info);
 153
 154
 155     }
 156
 157   return tree_store_type;
 158 }
 159
 160 static void
 161 gtk_tree_store_class_init (GtkTreeStoreClass *tree_store_class)
 162 {
 163   GtkObjectClass *object_class;
 164
 165   object_class = (GtkObjectClass *) tree_store_class;
 166
 167   tree_store_signals[CHANGED] =
 168     gtk_signal_new ("changed",
 169                     GTK_RUN_FIRST,
 170                     GTK_CLASS_TYPE (object_class),
 171                     GTK_SIGNAL_OFFSET (GtkTreeStoreClass, changed),
 172                     gtk_marshal_VOID__BOXED_BOXED,
 173                     G_TYPE_NONE, 2,
 174                     GTK_TYPE_TREE_PATH,
 175                     GTK_TYPE_TREE_ITER);
 176   tree_store_signals[INSERTED] =
 177     gtk_signal_new ("inserted",
 178                     GTK_RUN_FIRST,
 179                     GTK_CLASS_TYPE (object_class),
 180                     GTK_SIGNAL_OFFSET (GtkTreeStoreClass, inserted),
 181                     gtk_marshal_VOID__BOXED_BOXED,
 182                     G_TYPE_NONE, 2,
 183                     GTK_TYPE_TREE_PATH,
 184                     GTK_TYPE_TREE_ITER);
 185   tree_store_signals[CHILD_TOGGLED] =
 186     gtk_signal_new ("child_toggled",
 187                     GTK_RUN_FIRST,
 188                     GTK_CLASS_TYPE (object_class),
 189                     GTK_SIGNAL_OFFSET (GtkTreeStoreClass, child_toggled),
 190                     gtk_marshal_VOID__BOXED_BOXED,
 191                     G_TYPE_NONE, 2,
 192                     GTK_TYPE_TREE_PATH,
 193                     GTK_TYPE_TREE_ITER);
 194   tree_store_signals[DELETED] =
 195     gtk_signal_new ("deleted",
 196                     GTK_RUN_FIRST,
 197                     GTK_CLASS_TYPE (object_class),
 198                     GTK_SIGNAL_OFFSET (GtkTreeStoreClass, deleted),
 199                     gtk_marshal_VOID__BOXED,
 200                     G_TYPE_NONE, 1,
 201                     GTK_TYPE_TREE_PATH);
 202 }
 203
 204 static void
 205 gtk_tree_store_tree_model_init (GtkTreeModelIface *iface)
 206 {
 207   iface->get_flags = gtk_tree_store_get_flags;
 208   iface->get_n_columns = gtk_tree_store_get_n_columns;
 209   iface->get_column_type = gtk_tree_store_get_column_type;
 210   iface->get_path = gtk_tree_store_get_path;
 211   iface->get_value = gtk_tree_store_get_value;
 212   iface->iter_next = gtk_tree_store_iter_next;
 213   iface->iter_children = gtk_tree_store_iter_children;
 214   iface->iter_has_child = gtk_tree_store_iter_has_child;
 215   iface->iter_n_children = gtk_tree_store_iter_n_children;
 216   iface->iter_nth_child = gtk_tree_store_iter_nth_child;
 217   iface->iter_parent = gtk_tree_store_iter_parent;
 218 }
 219
 220 static void
 221 gtk_tree_store_drag_source_init (GtkTreeDragSourceIface *iface)
 222 {
 223   iface->drag_data_delete = gtk_tree_store_drag_data_delete;
 224   iface->drag_data_get = gtk_tree_store_drag_data_get;
 225 }
 226
 227 static void
 228 gtk_tree_store_drag_dest_init   (GtkTreeDragDestIface   *iface)
 229 {
 230   iface->drag_data_received = gtk_tree_store_drag_data_received;
 231   iface->row_drop_possible = gtk_tree_store_row_drop_possible;
 232 }
 233
 234 static void
 235 gtk_tree_store_init (GtkTreeStore *tree_store)
 236 {
 237   tree_store->root = g_node_new (NULL);
 238   tree_store->stamp = g_random_int ();
 239 }
 240
 241 GtkTreeStore *
 242 gtk_tree_store_new (void)
 243 {
 244   return GTK_TREE_STORE (gtk_type_new (gtk_tree_store_get_type ()));
 245 }
 246
 247 GtkTreeStore *
 248 gtk_tree_store_new_with_types (gint n_columns,
 249                                ...)
 250 {
 251   GtkTreeStore *retval;
 252   va_list args;
 253   gint i;
 254
 255   g_return_val_if_fail (n_columns > 0, NULL);
 256
 257   retval = gtk_tree_store_new ();
 258   gtk_tree_store_set_n_columns (retval, n_columns);
 259
 260   va_start (args, n_columns);
 261
 262   for (i = 0; i < n_columns; i++)
 263     gtk_tree_store_set_column_type (retval, i, va_arg (args, GType));
 264
 265   va_end (args);
 266
 267   return retval;
 268 }
 269
 270 void
 271 gtk_tree_store_set_n_columns (GtkTreeStore *tree_store,
 272                               gint          n_columns)
 273 {
 274   GType *new_columns;
 275
 276   g_return_if_fail (tree_store != NULL);
 277   g_return_if_fail (GTK_IS_TREE_STORE (tree_store));
 278
 279   if (tree_store->n_columns == n_columns)
 280     return;
 281
 282   new_columns = g_new0 (GType, n_columns);
 283   if (tree_store->column_headers)
 284     {
 285       /* copy the old header orders over */
 286       if (n_columns >= tree_store->n_columns)
 287         memcpy (new_columns, tree_store->column_headers, tree_store->n_columns * sizeof (gchar *));
 288       else
 289         memcpy (new_columns, tree_store->column_headers, n_columns * sizeof (GType));
 290
 291       g_free (tree_store->column_headers);
 292     }
 293
 294   tree_store->column_headers = new_columns;
 295   tree_store->n_columns = n_columns;
 296 }
 297
 298 void
 299 gtk_tree_store_set_column_type (GtkTreeStore *tree_store,
 300                                 gint          column,
 301                                 GType         type)
 302 {
 303   g_return_if_fail (tree_store != NULL);
 304   g_return_if_fail (GTK_IS_TREE_STORE (tree_store));
 305   g_return_if_fail (column >=0 && column < tree_store->n_columns);
 306
 307   tree_store->column_headers[column] = type;
 308 }
 309
 310 /* fulfill the GtkTreeModel requirements */
 311 /* NOTE: GtkTreeStore::root is a GNode, that acts as the parent node.  However,
 312  * it is not visible to the tree or to the user., and the path "0" refers to the
 313  * first child of GtkTreeStore::root.
 314  */
 315
 316
 317 static guint
 318 gtk_tree_store_get_flags (GtkTreeModel *tree_model)
 319 {
 320   g_return_val_if_fail (GTK_IS_TREE_STORE (tree_model), 0);
 321
 322   return GTK_TREE_MODEL_ITERS_PERSIST;
 323 }
 324
 325 static gint
 326 gtk_tree_store_get_n_columns (GtkTreeModel *tree_model)
 327 {
 328   g_return_val_if_fail (GTK_IS_TREE_STORE (tree_model), 0);
 329
 330   return GTK_TREE_STORE (tree_model)->n_columns;
 331 }
 332
 333 static GType
 334 gtk_tree_store_get_column_type (GtkTreeModel *tree_model,
 335                                 gint          index)
 336 {
 337   g_return_val_if_fail (GTK_IS_TREE_STORE (tree_model), G_TYPE_INVALID);
 338   g_return_val_if_fail (index < GTK_TREE_STORE (tree_model)->n_columns &&
 339                         index >= 0, G_TYPE_INVALID);
 340
 341   return GTK_TREE_STORE (tree_model)->column_headers[index];
 342 }
 343
 344 static GtkTreePath *
 345 gtk_tree_store_get_path (GtkTreeModel *tree_model,
 346                          GtkTreeIter  *iter)
 347 {
 348   GtkTreePath *retval;
 349   GNode *tmp_node;
 350   gint i = 0;
 351
 352   g_return_val_if_fail (tree_model != NULL, NULL);
 353   g_return_val_if_fail (GTK_IS_TREE_STORE (tree_model), NULL);
 354   g_return_val_if_fail (iter != NULL, NULL);
 355   g_return_val_if_fail (iter->user_data != NULL, NULL);
 356
 357   validate_tree ((GtkTreeStore*)tree_model);
 358
 359   g_assert (G_NODE (iter->user_data)->parent != NULL);
 360
 361   if (G_NODE (iter->user_data)->parent == G_NODE (GTK_TREE_STORE (tree_model)->root))
 362     {
 363       retval = gtk_tree_path_new ();
 364       tmp_node = G_NODE (GTK_TREE_STORE (tree_model)->root)->children;
 365     }
 366   else
 367     {
 368       GtkTreeIter tmp_iter = *iter;
 369
 370       tmp_iter.user_data = G_NODE (iter->user_data)->parent;
 371
 372       retval = gtk_tree_store_get_path (tree_model,
 373                                         &tmp_iter);
 374       tmp_node = G_NODE (iter->user_data)->parent->children;
 375     }
 376
 377   if (retval == NULL)
 378     return NULL;
 379
 380   if (tmp_node == NULL)
 381     {
 382       gtk_tree_path_free (retval);
 383       return NULL;
 384     }
 385
 386   for (; tmp_node; tmp_node = tmp_node->next)
 387     {
 388       if (tmp_node == G_NODE (iter->user_data))
 389         break;
 390       i++;
 391     }
 392
 393   if (tmp_node == NULL)
 394     {
 395       /* We couldn't find node, meaning it's prolly not ours */
 396       /* Perhaps I should do a g_return_if_fail here. */
 397       gtk_tree_path_free (retval);
 398       return NULL;
 399     }
 400
 401   gtk_tree_path_append_index (retval, i);
 402
 403   return retval;
 404 }
 405
 406
 407 static void
 408 gtk_tree_store_get_value (GtkTreeModel *tree_model,
 409                           GtkTreeIter  *iter,
 410                           gint          column,
 411                           GValue       *value)
 412 {
 413   GtkTreeDataList *list;
 414   gint tmp_column = column;
 415
 416   g_return_if_fail (tree_model != NULL);
 417   g_return_if_fail (GTK_IS_TREE_STORE (tree_model));
 418   g_return_if_fail (iter != NULL);
 419   g_return_if_fail (column < GTK_TREE_STORE (tree_model)->n_columns);
 420
 421   list = G_NODE (iter->user_data)->data;
 422
 423   while (tmp_column-- > 0 && list)
 424     list = list->next;
 425
 426   if (list)
 427     {
 428       _gtk_tree_data_list_node_to_value (list,
 429                                          GTK_TREE_STORE (tree_model)->column_headers[column],
 430                                          value);
 431     }
 432   else
 433     {
 434       /* We want to return an initialized but empty (default) value */
 435       g_value_init (value, GTK_TREE_STORE (tree_model)->column_headers[column]);
 436     }
 437 }
 438
 439 static gboolean
 440 gtk_tree_store_iter_next (GtkTreeModel  *tree_model,
 441                           GtkTreeIter   *iter)
 442 {
 443   g_return_val_if_fail (iter->user_data != NULL, FALSE);
 444
 445   if (G_NODE (iter->user_data)->next)
 446     {
 447       iter->user_data = G_NODE (iter->user_data)->next;
 448       return TRUE;
 449     }
 450   else
 451     return FALSE;
 452 }
 453
 454 static gboolean
 455 gtk_tree_store_iter_children (GtkTreeModel *tree_model,
 456                               GtkTreeIter  *iter,
 457                               GtkTreeIter  *parent)
 458 {
 459   GNode *children;
 460
 461   g_return_val_if_fail (parent == NULL || parent->user_data != NULL, FALSE);
 462
 463   if (parent)
 464     children = G_NODE (parent->user_data)->children;
 465   else
 466     children = G_NODE (GTK_TREE_STORE (tree_model)->root)->children;
 467
 468   if (children)
 469     {
 470       iter->stamp = GTK_TREE_STORE (tree_model)->stamp;
 471       iter->user_data = children;
 472       return TRUE;
 473     }
 474   else
 475     return FALSE;
 476 }
 477
 478 static gboolean
 479 gtk_tree_store_iter_has_child (GtkTreeModel *tree_model,
 480                                GtkTreeIter  *iter)
 481 {
 482   g_return_val_if_fail (tree_model != NULL, FALSE);
 483   g_return_val_if_fail (GTK_IS_TREE_STORE (tree_model), FALSE);
 484   g_return_val_if_fail (iter != NULL, FALSE);
 485   g_return_val_if_fail (iter->user_data != NULL, FALSE);
 486
 487   return G_NODE (iter->user_data)->children != NULL;
 488 }
 489
 490 static gint
 491 gtk_tree_store_iter_n_children (GtkTreeModel *tree_model,
 492                                 GtkTreeIter  *iter)
 493 {
 494   GNode *node;
 495   gint i = 0;
 496
 497   g_return_val_if_fail (tree_model != NULL, 0);
 498   g_return_val_if_fail (GTK_IS_TREE_STORE (tree_model), 0);
 499   g_return_val_if_fail (iter != NULL, FALSE);
 500   g_return_val_if_fail (iter->user_data != NULL, FALSE);
 501
 502   if (iter == NULL)
 503     node = G_NODE (GTK_TREE_STORE (tree_model)->root)->children;
 504   else
 505     node = G_NODE (iter->user_data)->children;
 506
 507   while (node)
 508     {
 509       i++;
 510       node = node->next;
 511     }
 512
 513   return i;
 514 }
 515
 516 static gboolean
 517 gtk_tree_store_iter_nth_child (GtkTreeModel *tree_model,
 518                                GtkTreeIter  *iter,
 519                                GtkTreeIter  *parent,
 520                                gint          n)
 521 {
 522   GNode *parent_node;
 523   GNode *child;
 524
 525   g_return_val_if_fail (tree_model != NULL, FALSE);
 526   g_return_val_if_fail (GTK_IS_TREE_STORE (tree_model), FALSE);
 527   g_return_val_if_fail (parent == NULL || parent->user_data != NULL, FALSE);
 528
 529   if (parent == NULL)
 530     parent_node = GTK_TREE_STORE (tree_model)->root;
 531   else
 532     parent_node = parent->user_data;
 533
 534   child = g_node_nth_child (parent_node, n);
 535
 536   if (child)
 537     {
 538       iter->user_data = child;
 539       iter->stamp = GTK_TREE_STORE (tree_model)->stamp;
 540       return TRUE;
 541     }
 542   else
 543     return FALSE;
 544 }
 545
 546 static gboolean
 547 gtk_tree_store_iter_parent (GtkTreeModel *tree_model,
 548                             GtkTreeIter  *iter,
 549                             GtkTreeIter  *child)
 550 {
 551   GNode *parent;
 552
 553   g_return_val_if_fail (iter != NULL, FALSE);
 554   g_return_val_if_fail (iter->user_data != NULL, FALSE);
 555
 556   parent = G_NODE (child->user_data)->parent;
 557
 558   g_assert (parent != NULL);
 559
 560   if (parent != GTK_TREE_STORE (tree_model)->root)
 561     {
 562       iter->user_data = parent;
 563       iter->stamp = GTK_TREE_STORE (tree_model)->stamp;
 564       return TRUE;
 565     }
 566   else
 567     return FALSE;
 568 }
 569
 570 /*
 571  * This is a somewhat inelegant function that does a lot of list
 572  * manipulations on it's own.
 573  */
 574 void
 575 gtk_tree_store_set_cell (GtkTreeStore *tree_store,
 576                          GtkTreeIter  *iter,
 577                          gint          column,
 578                          GValue       *value)
 579 {
 580   GtkTreeDataList *list;
 581   GtkTreeDataList *prev;
 582
 583   g_return_if_fail (tree_store != NULL);
 584   g_return_if_fail (GTK_IS_TREE_STORE (tree_store));
 585   g_return_if_fail (column >= 0 && column < tree_store->n_columns);
 586
 587   prev = list = G_NODE (iter->user_data)->data;
 588
 589   while (list != NULL)
 590     {
 591       if (column == 0)
 592         {
 593           _gtk_tree_data_list_value_to_node (list, value);
 594           gtk_signal_emit_by_name (GTK_OBJECT (tree_store),
 595                                    "changed",
 596                                    NULL, iter);
 597           return;
 598         }
 599
 600       column--;
 601       prev = list;
 602       list = list->next;
 603     }
 604
 605   if (G_NODE (iter->user_data)->data == NULL)
 606     {
 607       G_NODE (iter->user_data)->data = list = _gtk_tree_data_list_alloc ();
 608       list->next = NULL;
 609     }
 610   else
 611     {
 612       list = prev->next = _gtk_tree_data_list_alloc ();
 613       list->next = NULL;
 614     }
 615
 616   while (column != 0)
 617     {
 618       list->next = _gtk_tree_data_list_alloc ();
 619       list = list->next;
 620       list->next = NULL;
 621       column --;
 622     }
 623   _gtk_tree_data_list_value_to_node (list, value);
 624   gtk_signal_emit_by_name (GTK_OBJECT (tree_store),
 625                            "changed",
 626                            NULL, iter);
 627 }
 628
 629 void
 630 gtk_tree_store_set_valist (GtkTreeStore *tree_store,
 631                            GtkTreeIter  *iter,
 632                            va_list      var_args)
 633 {
 634   gint column;
 635
 636   g_return_if_fail (GTK_IS_TREE_STORE (tree_store));
 637
 638   column = va_arg (var_args, gint);
 639
 640   while (column != -1)
 641     {
 642       GValue value = { 0, };
 643       gchar *error = NULL;
 644
 645       if (column >= tree_store->n_columns)
 646         {
 647           g_warning ("%s: Invalid column number %d added to iter (remember to end your list of columns with a -1)", G_STRLOC, column);
 648           break;
 649         }
 650       g_value_init (&value, tree_store->column_headers[column]);
 651
 652       G_VALUE_COLLECT (&value, var_args, &error);
 653       if (error)
 654         {
 655           g_warning ("%s: %s", G_STRLOC, error);
 656           g_free (error);
 657
 658           /* we purposely leak the value here, it might not be
 659            * in a sane state if an error condition occoured
 660            */
 661           break;
 662         }
 663
 664       gtk_tree_store_set_cell (tree_store,
 665                                iter,
 666                                column,
 667                                &value);
 668
 669       g_value_unset (&value);
 670
 671       column = va_arg (var_args, gint);
 672     }
 673 }
 674
 675 /**
 676  * gtk_tree_store_set:
 677  * @tree_store: a #GtkTreeStore
 678  * @iter: row iterator
 679  * @Varargs: pairs of column number and value, terminated with -1
 680  *
 681  * Sets the value of one or more cells in the row referenced by @iter.
 682  * The variable argument list should contain integer column numbers,
 683  * each column number followed by the value to be set. For example,
 684  * The list is terminated by a -1. For example, to set column 0 with type
 685  * %G_TYPE_STRING to "Foo", you would write gtk_tree_store_set (store, iter,
 686  * 0, "Foo", -1).
 687  **/
 688 void
 689 gtk_tree_store_set (GtkTreeStore *tree_store,
 690                     GtkTreeIter  *iter,
 691                     ...)
 692 {
 693   va_list var_args;
 694
 695   g_return_if_fail (GTK_IS_TREE_STORE (tree_store));
 696
 697   va_start (var_args, iter);
 698   gtk_tree_store_set_valist (tree_store, iter, var_args);
 699   va_end (var_args);
 700 }
 701
 702 void
 703 gtk_tree_store_get_valist (GtkTreeStore *tree_store,
 704                            GtkTreeIter  *iter,
 705                            va_list      var_args)
 706 {
 707   gint column;
 708
 709   g_return_if_fail (GTK_IS_TREE_STORE (tree_store));
 710
 711   column = va_arg (var_args, gint);
 712
 713   while (column != -1)
 714     {
 715       GValue value = { 0, };
 716       gchar *error = NULL;
 717
 718       if (column >= tree_store->n_columns)
 719         {
 720           g_warning ("%s: Invalid column number %d accessed (remember to end your list of columns with a -1)", G_STRLOC, column);
 721           break;
 722         }
 723
 724       gtk_tree_store_get_value (GTK_TREE_MODEL (tree_store), iter, column, &value);
 725
 726       G_VALUE_LCOPY (&value, var_args, &error);
 727       if (error)
 728         {
 729           g_warning ("%s: %s", G_STRLOC, error);
 730           g_free (error);
 731
 732           /* we purposely leak the value here, it might not be
 733            * in a sane state if an error condition occoured
 734            */
 735           break;
 736         }
 737
 738       g_value_unset (&value);
 739
 740       column = va_arg (var_args, gint);
 741     }
 742 }
 743
 744 void
 745 gtk_tree_store_get (GtkTreeStore *tree_store,
 746                     GtkTreeIter  *iter,
 747                     ...)
 748 {
 749   va_list var_args;
 750
 751   g_return_if_fail (GTK_IS_TREE_STORE (tree_store));
 752
 753   va_start (var_args, iter);
 754   gtk_tree_store_get_valist (tree_store, iter, var_args);
 755   va_end (var_args);
 756 }
 757
 758 void
 759 gtk_tree_store_remove (GtkTreeStore *model,
 760                        GtkTreeIter  *iter)
 761 {
 762   GtkTreePath *path;
 763
 764   GNode *parent;
 765
 766   g_return_if_fail (model != NULL);
 767   g_return_if_fail (GTK_IS_TREE_STORE (model));
 768
 769   parent = G_NODE (iter->user_data)->parent;
 770
 771   g_assert (parent != NULL);
 772
 773   if (G_NODE (iter->user_data)->data)
 774     _gtk_tree_data_list_free ((GtkTreeDataList *) G_NODE (iter->user_data)->data,
 775                               model->column_headers);
 776
 777   path = gtk_tree_store_get_path (GTK_TREE_MODEL (model), iter);
 778   g_node_destroy (G_NODE (iter->user_data));
 779
 780   model->stamp++;
 781   gtk_signal_emit_by_name (GTK_OBJECT (model),
 782                            "deleted",
 783                            path);
 784   if (parent != G_NODE (model->root) && parent->children == NULL)
 785     {
 786       gtk_tree_path_up (path);
 787
 788       gtk_signal_emit_by_name (GTK_OBJECT (model),
 789                                "child_toggled",
 790                                path,
 791                                parent);
 792     }
 793   gtk_tree_path_free (path);
 794 }
 795
 796 void
 797 gtk_tree_store_insert (GtkTreeStore *model,
 798                        GtkTreeIter  *iter,
 799                        GtkTreeIter  *parent,
 800                        gint          position)
 801 {
 802   GtkTreePath *path;
 803   GNode *parent_node;
 804
 805   g_return_if_fail (model != NULL);
 806   g_return_if_fail (GTK_IS_TREE_STORE (model));
 807
 808   if (parent)
 809     parent_node = parent->user_data;
 810   else
 811     parent_node = model->root;
 812
 813   iter->stamp = model->stamp;
 814   iter->user_data = g_node_new (NULL);
 815   g_node_insert (parent_node, position, G_NODE (iter->user_data));
 816
 817   path = gtk_tree_store_get_path (GTK_TREE_MODEL (model), iter);
 818   gtk_signal_emit_by_name (GTK_OBJECT (model),
 819                            "inserted",
 820                            path, iter);
 821   gtk_tree_path_free (path);
 822
 823   validate_tree ((GtkTreeStore*)model);
 824 }
 825
 826 void
 827 gtk_tree_store_insert_before (GtkTreeStore *model,
 828                               GtkTreeIter  *iter,
 829                               GtkTreeIter  *parent,
 830                               GtkTreeIter  *sibling)
 831 {
 832   GtkTreePath *path;
 833   GNode *parent_node = NULL;
 834   GNode *new_node;
 835
 836   g_return_if_fail (model != NULL);
 837   g_return_if_fail (GTK_IS_TREE_STORE (model));
 838   g_return_if_fail (iter != NULL);
 839
 840   new_node = g_node_new (NULL);
 841
 842   if (parent == NULL && sibling == NULL)
 843     parent_node = model->root;
 844   else if (parent == NULL)
 845     parent_node = G_NODE (sibling->user_data)->parent;
 846   else if (sibling == NULL)
 847     parent_node = G_NODE (parent->user_data);
 848   else
 849     {
 850       g_return_if_fail (G_NODE (sibling->user_data)->parent ==
 851                         G_NODE (parent->user_data));
 852       parent_node = G_NODE (parent->user_data);
 853     }
 854
 855   g_node_insert_before (parent_node,
 856                         sibling ? G_NODE (sibling->user_data) : NULL,
 857                         new_node);
 858
 859   iter->stamp = model->stamp;
 860   iter->user_data = new_node;
 861
 862   path = gtk_tree_store_get_path (GTK_TREE_MODEL (model), iter);
 863   gtk_signal_emit_by_name (GTK_OBJECT (model),
 864                            "inserted",
 865                            path, iter);
 866   gtk_tree_path_free (path);
 867
 868   validate_tree ((GtkTreeStore*)model);
 869 }
 870
 871 void
 872 gtk_tree_store_insert_after (GtkTreeStore *model,
 873                              GtkTreeIter  *iter,
 874                              GtkTreeIter  *parent,
 875                              GtkTreeIter  *sibling)
 876 {
 877   GtkTreePath *path;
 878   GNode *parent_node;
 879   GNode *new_node;
 880
 881   g_return_if_fail (model != NULL);
 882   g_return_if_fail (GTK_IS_TREE_STORE (model));
 883   g_return_if_fail (iter != NULL);
 884
 885   new_node = g_node_new (NULL);
 886
 887   if (parent == NULL && sibling == NULL)
 888     parent_node = model->root;
 889   else if (parent == NULL)
 890     parent_node = G_NODE (sibling->user_data)->parent;
 891   else if (sibling == NULL)
 892     parent_node = G_NODE (parent->user_data);
 893   else
 894     {
 895       g_return_if_fail (G_NODE (sibling->user_data)->parent ==
 896                         G_NODE (parent->user_data));
 897       parent_node = G_NODE (parent->user_data);
 898     }
 899
 900
 901   g_node_insert_after (parent_node,
 902                        sibling ? G_NODE (sibling->user_data) : NULL,
 903                        new_node);
 904
 905   iter->stamp = model->stamp;
 906   iter->user_data = new_node;
 907
 908   path = gtk_tree_store_get_path (GTK_TREE_MODEL (model), iter);
 909   gtk_signal_emit_by_name (GTK_OBJECT (model),
 910                            "inserted",
 911                            path, iter);
 912   gtk_tree_path_free (path);
 913
 914   validate_tree ((GtkTreeStore*)model);
 915 }
 916
 917 void
 918 gtk_tree_store_prepend (GtkTreeStore *model,
 919                         GtkTreeIter  *iter,
 920                         GtkTreeIter  *parent)
 921 {
 922   GNode *parent_node;
 923
 924   g_return_if_fail (model != NULL);
 925   g_return_if_fail (GTK_IS_TREE_STORE (model));
 926   g_return_if_fail (iter != NULL);
 927
 928   if (parent == NULL)
 929     parent_node = model->root;
 930   else
 931     parent_node = parent->user_data;
 932
 933   if (parent_node->children == NULL)
 934     {
 935       GtkTreePath *path;
 936
 937       iter->stamp = model->stamp;
 938       iter->user_data = g_node_new (NULL);
 939
 940       g_node_prepend (parent_node, iter->user_data);
 941
 942       if (parent_node != model->root)
 943         {
 944           path = gtk_tree_store_get_path (GTK_TREE_MODEL (model), parent);
 945           gtk_signal_emit_by_name (GTK_OBJECT (model),
 946                                    "child_toggled",
 947                                    path,
 948                                    parent);
 949           gtk_tree_path_append_index (path, 0);
 950         }
 951       else
 952         {
 953           path = gtk_tree_store_get_path (GTK_TREE_MODEL (model), iter);
 954         }
 955       gtk_signal_emit_by_name (GTK_OBJECT (model),
 956                                "inserted",
 957                                path,
 958                                iter);
 959       gtk_tree_path_free (path);
 960     }
 961   else
 962     {
 963       gtk_tree_store_insert_after (model, iter, parent, NULL);
 964     }
 965
 966   validate_tree ((GtkTreeStore*)model);
 967 }
 968
 969 void
 970 gtk_tree_store_append (GtkTreeStore *model,
 971                        GtkTreeIter  *iter,
 972                        GtkTreeIter  *parent)
 973 {
 974   GNode *parent_node;
 975
 976   g_return_if_fail (model != NULL);
 977   g_return_if_fail (GTK_IS_TREE_STORE (model));
 978   g_return_if_fail (iter != NULL);
 979
 980   if (parent == NULL)
 981     parent_node = model->root;
 982   else
 983     parent_node = parent->user_data;
 984
 985   if (parent_node->children == NULL)
 986     {
 987       GtkTreePath *path;
 988
 989       iter->stamp = model->stamp;
 990       iter->user_data = g_node_new (NULL);
 991
 992       g_node_append (parent_node, G_NODE (iter->user_data));
 993
 994       if (parent_node != model->root)
 995         {
 996           path = gtk_tree_store_get_path (GTK_TREE_MODEL (model), parent);
 997           gtk_signal_emit_by_name (GTK_OBJECT (model),
 998                                    "child_toggled",
 999                                    path,
1000                                    parent);
1001           gtk_tree_path_append_index (path, 0);
1002         }
1003       else
1004         {
1005           path = gtk_tree_store_get_path (GTK_TREE_MODEL (model), iter);
1006         }
1007
1008       gtk_signal_emit_by_name (GTK_OBJECT (model),
1009                                "inserted",
1010                                path,
1011                                iter);
1012       gtk_tree_path_free (path);
1013     }
1014   else
1015     {
1016       gtk_tree_store_insert_before (model, iter, parent, NULL);
1017     }
1018
1019   validate_tree ((GtkTreeStore*)model);
1020 }
1021
1022 gboolean
1023 gtk_tree_store_is_ancestor (GtkTreeStore *model,
1024                             GtkTreeIter  *iter,
1025                             GtkTreeIter  *descendant)
1026 {
1027   g_return_val_if_fail (model != NULL, FALSE);
1028   g_return_val_if_fail (GTK_IS_TREE_STORE (model), FALSE);
1029   g_return_val_if_fail (iter != NULL, FALSE);
1030   g_return_val_if_fail (descendant != NULL, FALSE);
1031
1032   return g_node_is_ancestor (G_NODE (iter->user_data),
1033                              G_NODE (descendant->user_data));
1034 }
1035
1036
1037 gint
1038 gtk_tree_store_iter_depth (GtkTreeStore *model,
1039                            GtkTreeIter  *iter)
1040 {
1041   g_return_val_if_fail (model != NULL, 0);
1042   g_return_val_if_fail (GTK_IS_TREE_STORE (model), 0);
1043   g_return_val_if_fail (iter != NULL, 0);
1044
1045   return g_node_depth (G_NODE (iter->user_data)) - 1;
1046 }
1047
1048 /* DND */
1049
1050
1051
1052 static gboolean
1053 gtk_tree_store_drag_data_delete (GtkTreeDragSource *drag_source,
1054                                  GtkTreePath       *path)
1055 {
1056   GtkTreeIter iter;
1057
1058   g_return_val_if_fail (GTK_IS_TREE_STORE (drag_source), FALSE);
1059
1060   if (gtk_tree_model_get_iter (GTK_TREE_MODEL (drag_source),
1061                                &iter,
1062                                path))
1063     {
1064       gtk_tree_store_remove (GTK_TREE_STORE (drag_source),
1065                              &iter);
1066       return TRUE;
1067     }
1068   else
1069     {
1070       return FALSE;
1071     }
1072 }
1073
1074 static gboolean
1075 gtk_tree_store_drag_data_get (GtkTreeDragSource *drag_source,
1076                               GtkTreePath       *path,
1077                               GtkSelectionData  *selection_data)
1078 {
1079   g_return_val_if_fail (GTK_IS_TREE_STORE (drag_source), FALSE);
1080
1081   /* Note that we don't need to handle the GTK_TREE_MODEL_ROW
1082    * target, because the default handler does it for us, but
1083    * we do anyway for the convenience of someone maybe overriding the
1084    * default handler.
1085    */
1086
1087   if (gtk_selection_data_set_tree_row (selection_data,
1088                                        GTK_TREE_MODEL (drag_source),
1089                                        path))
1090     {
1091       return TRUE;
1092     }
1093   else
1094     {
1095       /* FIXME handle text targets at least. */
1096     }
1097
1098   return FALSE;
1099 }
1100
1101 static void
1102 copy_node_data (GtkTreeStore *tree_store,
1103                 GtkTreeIter  *src_iter,
1104                 GtkTreeIter  *dest_iter)
1105 {
1106   GtkTreeDataList *dl = G_NODE (src_iter->user_data)->data;
1107   GtkTreeDataList *copy_head = NULL;
1108   GtkTreeDataList *copy_prev = NULL;
1109   GtkTreeDataList *copy_iter = NULL;
1110   gint col;
1111
1112   col = 0;
1113   while (dl)
1114     {
1115       copy_iter = _gtk_tree_data_list_node_copy (dl,
1116                                                  tree_store->column_headers[col]);
1117
1118       if (copy_head == NULL)
1119         copy_head = copy_iter;
1120
1121       if (copy_prev)
1122         copy_prev->next = copy_iter;
1123
1124       copy_prev = copy_iter;
1125
1126       dl = dl->next;
1127       ++col;
1128     }
1129
1130   G_NODE (dest_iter->user_data)->data = copy_head;
1131
1132   gtk_signal_emit_by_name (GTK_OBJECT (tree_store),
1133                            "changed",
1134                            NULL, dest_iter);
1135 }
1136
1137 static void
1138 recursive_node_copy (GtkTreeStore *tree_store,
1139                      GtkTreeIter  *src_iter,
1140                      GtkTreeIter  *dest_iter)
1141 {
1142   GtkTreeIter child;
1143   GtkTreeModel *model;
1144
1145   model = GTK_TREE_MODEL (tree_store);
1146
1147   copy_node_data (tree_store, src_iter, dest_iter);
1148
1149   if (gtk_tree_model_iter_children (model,
1150                                     &child,
1151                                     src_iter))
1152     {
1153       /* Need to create children and recurse. Note our
1154        * dependence on persistent iterators here.
1155        */
1156       do
1157         {
1158           GtkTreeIter copy;
1159
1160           /* Gee, a really slow algorithm... ;-) FIXME */
1161           gtk_tree_store_append (tree_store,
1162                                  &copy,
1163                                  dest_iter);
1164
1165           recursive_node_copy (tree_store, &child, &copy);
1166         }
1167       while (gtk_tree_model_iter_next (model, &child));
1168     }
1169 }
1170
1171 static gboolean
1172 gtk_tree_store_drag_data_received (GtkTreeDragDest   *drag_dest,
1173                                    GtkTreePath       *dest,
1174                                    GtkSelectionData  *selection_data)
1175 {
1176   GtkTreeModel *tree_model;
1177   GtkTreeStore *tree_store;
1178   GtkTreeModel *src_model = NULL;
1179   GtkTreePath *src_path = NULL;
1180   gboolean retval = FALSE;
1181
1182   g_return_val_if_fail (GTK_IS_TREE_STORE (drag_dest), FALSE);
1183
1184   tree_model = GTK_TREE_MODEL (drag_dest);
1185   tree_store = GTK_TREE_STORE (drag_dest);
1186
1187   validate_tree (tree_store);
1188
1189   if (gtk_selection_data_get_tree_row (selection_data,
1190                                        &src_model,
1191                                        &src_path) &&
1192       src_model == tree_model)
1193     {
1194       /* Copy the given row to a new position */
1195       GtkTreeIter src_iter;
1196       GtkTreeIter dest_iter;
1197       GtkTreePath *prev;
1198
1199       if (!gtk_tree_model_get_iter (src_model,
1200                                     &src_iter,
1201                                     src_path))
1202         {
1203           goto out;
1204         }
1205
1206       /* Get the path to insert _after_ (dest is the path to insert _before_) */
1207       prev = gtk_tree_path_copy (dest);
1208
1209       if (!gtk_tree_path_prev (prev))
1210         {
1211           GtkTreeIter dest_parent;
1212           GtkTreePath *parent;
1213           GtkTreeIter *dest_parent_p;
1214
1215           /* dest was the first spot at the current depth; which means
1216            * we are supposed to prepend.
1217            */
1218
1219           /* Get the parent, NULL if parent is the root */
1220           dest_parent_p = NULL;
1221           parent = gtk_tree_path_copy (dest);
1222           if (gtk_tree_path_up (parent))
1223             {
1224               gtk_tree_model_get_iter (tree_model,
1225                                        &dest_parent,
1226                                        parent);
1227               dest_parent_p = &dest_parent;
1228             }
1229           gtk_tree_path_free (parent);
1230           parent = NULL;
1231
1232           gtk_tree_store_prepend (GTK_TREE_STORE (tree_model),
1233                                   &dest_iter,
1234                                   dest_parent_p);
1235
1236           retval = TRUE;
1237         }
1238       else
1239         {
1240           if (gtk_tree_model_get_iter (GTK_TREE_MODEL (tree_model),
1241                                        &dest_iter,
1242                                        prev))
1243             {
1244               GtkTreeIter tmp_iter = dest_iter;
1245               gtk_tree_store_insert_after (GTK_TREE_STORE (tree_model),
1246                                            &dest_iter,
1247                                            NULL,
1248                                            &tmp_iter);
1249               retval = TRUE;
1250
1251             }
1252         }
1253
1254       gtk_tree_path_free (prev);
1255
1256       /* If we succeeded in creating dest_iter, walk src_iter tree branch,
1257        * duplicating it below dest_iter.
1258        */
1259
1260       if (retval)
1261         {
1262           recursive_node_copy (tree_store,
1263                                &src_iter,
1264                                &dest_iter);
1265         }
1266     }
1267   else
1268     {
1269       /* FIXME maybe add some data targets eventually, or handle text
1270        * targets in the simple case.
1271        */
1272
1273     }
1274
1275  out:
1276
1277   if (src_path)
1278     gtk_tree_path_free (src_path);
1279
1280   return retval;
1281 }
1282
1283 static gboolean
1284 gtk_tree_store_row_drop_possible (GtkTreeDragDest *drag_dest,
1285                                   GtkTreeModel    *src_model,
1286                                   GtkTreePath     *src_path,
1287                                   GtkTreePath     *dest_path)
1288 {
1289   /* can only drag to ourselves */
1290   if (src_model != GTK_TREE_MODEL (drag_dest))
1291     return FALSE;
1292
1293   /* Can't drop into ourself. */
1294   if (gtk_tree_path_is_ancestor (src_path,
1295                                  dest_path))
1296     return FALSE;
1297
1298   /* Can't drop if dest_path's parent doesn't exist */
1299   {
1300     GtkTreeIter iter;
1301     GtkTreePath *tmp = gtk_tree_path_copy (dest_path);
1302
1303     /* if we can't go up, we know the parent exists, the root
1304      * always exists.
1305      */
1306     if (gtk_tree_path_up (tmp))
1307       {
1308         if (!gtk_tree_model_get_iter (GTK_TREE_MODEL (drag_dest),
1309                                       &iter, tmp))
1310           {
1311             if (tmp)
1312               gtk_tree_path_free (tmp);
1313             return FALSE;
1314           }
1315       }
1316
1317     if (tmp)
1318       gtk_tree_path_free (tmp);
1319   }
1320
1321   /* Can otherwise drop anywhere. */
1322   return TRUE;
1323 }
1324
1325 static void
1326 validate_gnode (GNode* node)
1327 {
1328   GNode *iter;
1329
1330   iter = node->children;
1331   while (iter != NULL)
1332     {
1333       g_assert (iter->parent == node);
1334       if (iter->prev)
1335         g_assert (iter->prev->next == iter);
1336       validate_gnode (iter);
1337       iter = iter->next;
1338     }
1339 }
1340
1341