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 /**
 630  * gtk_tree_store_set_valist:
 631  * @tree_store: a #GtkTreeStore
 632  * @iter: row to set data for
 633  * @var_args: va_list of column/value pairs
 634  *
 635  * See gtk_tree_store_set(); this version takes a va_list for
 636  * use by language bindings.
 637  *
 638  **/
 639 void
 640 gtk_tree_store_set_valist (GtkTreeStore *tree_store,
 641                            GtkTreeIter  *iter,
 642                            va_list      var_args)
 643 {
 644   gint column;
 645
 646   g_return_if_fail (GTK_IS_TREE_STORE (tree_store));
 647
 648   column = va_arg (var_args, gint);
 649
 650   while (column != -1)
 651     {
 652       GValue value = { 0, };
 653       gchar *error = NULL;
 654
 655       if (column >= tree_store->n_columns)
 656         {
 657           g_warning ("%s: Invalid column number %d added to iter (remember to end your list of columns with a -1)", G_STRLOC, column);
 658           break;
 659         }
 660       g_value_init (&value, tree_store->column_headers[column]);
 661
 662       G_VALUE_COLLECT (&value, var_args, 0, &error);
 663       if (error)
 664         {
 665           g_warning ("%s: %s", G_STRLOC, error);
 666           g_free (error);
 667
 668           /* we purposely leak the value here, it might not be
 669            * in a sane state if an error condition occoured
 670            */
 671           break;
 672         }
 673
 674       gtk_tree_store_set_cell (tree_store,
 675                                iter,
 676                                column,
 677                                &value);
 678
 679       g_value_unset (&value);
 680
 681       column = va_arg (var_args, gint);
 682     }
 683 }
 684
 685 /**
 686  * gtk_tree_store_set:
 687  * @tree_store: a #GtkTreeStore
 688  * @iter: row iterator
 689  * @Varargs: pairs of column number and value, terminated with -1
 690  *
 691  * Sets the value of one or more cells in the row referenced by @iter.
 692  * The variable argument list should contain integer column numbers,
 693  * each column number followed by the value to be set. For example,
 694  * The list is terminated by a -1. For example, to set column 0 with type
 695  * %G_TYPE_STRING to "Foo", you would write gtk_tree_store_set (store, iter,
 696  * 0, "Foo", -1).
 697  **/
 698 void
 699 gtk_tree_store_set (GtkTreeStore *tree_store,
 700                     GtkTreeIter  *iter,
 701                     ...)
 702 {
 703   va_list var_args;
 704
 705   g_return_if_fail (GTK_IS_TREE_STORE (tree_store));
 706
 707   va_start (var_args, iter);
 708   gtk_tree_store_set_valist (tree_store, iter, var_args);
 709   va_end (var_args);
 710 }
 711
 712 void
 713 gtk_tree_store_remove (GtkTreeStore *model,
 714                        GtkTreeIter  *iter)
 715 {
 716   GtkTreePath *path;
 717
 718   GNode *parent;
 719
 720   g_return_if_fail (model != NULL);
 721   g_return_if_fail (GTK_IS_TREE_STORE (model));
 722
 723   parent = G_NODE (iter->user_data)->parent;
 724
 725   g_assert (parent != NULL);
 726
 727   if (G_NODE (iter->user_data)->data)
 728     _gtk_tree_data_list_free ((GtkTreeDataList *) G_NODE (iter->user_data)->data,
 729                               model->column_headers);
 730
 731   path = gtk_tree_store_get_path (GTK_TREE_MODEL (model), iter);
 732   g_node_destroy (G_NODE (iter->user_data));
 733
 734   model->stamp++;
 735   gtk_signal_emit_by_name (GTK_OBJECT (model),
 736                            "deleted",
 737                            path);
 738   if (parent != G_NODE (model->root) && parent->children == NULL)
 739     {
 740       gtk_tree_path_up (path);
 741
 742       gtk_signal_emit_by_name (GTK_OBJECT (model),
 743                                "child_toggled",
 744                                path,
 745                                parent);
 746     }
 747   gtk_tree_path_free (path);
 748 }
 749
 750 void
 751 gtk_tree_store_insert (GtkTreeStore *model,
 752                        GtkTreeIter  *iter,
 753                        GtkTreeIter  *parent,
 754                        gint          position)
 755 {
 756   GtkTreePath *path;
 757   GNode *parent_node;
 758
 759   g_return_if_fail (model != NULL);
 760   g_return_if_fail (GTK_IS_TREE_STORE (model));
 761
 762   if (parent)
 763     parent_node = parent->user_data;
 764   else
 765     parent_node = model->root;
 766
 767   iter->stamp = model->stamp;
 768   iter->user_data = g_node_new (NULL);
 769   g_node_insert (parent_node, position, G_NODE (iter->user_data));
 770
 771   path = gtk_tree_store_get_path (GTK_TREE_MODEL (model), iter);
 772   gtk_signal_emit_by_name (GTK_OBJECT (model),
 773                            "inserted",
 774                            path, iter);
 775   gtk_tree_path_free (path);
 776
 777   validate_tree ((GtkTreeStore*)model);
 778 }
 779
 780 void
 781 gtk_tree_store_insert_before (GtkTreeStore *model,
 782                               GtkTreeIter  *iter,
 783                               GtkTreeIter  *parent,
 784                               GtkTreeIter  *sibling)
 785 {
 786   GtkTreePath *path;
 787   GNode *parent_node = NULL;
 788   GNode *new_node;
 789
 790   g_return_if_fail (model != NULL);
 791   g_return_if_fail (GTK_IS_TREE_STORE (model));
 792   g_return_if_fail (iter != NULL);
 793
 794   new_node = g_node_new (NULL);
 795
 796   if (parent == NULL && sibling == NULL)
 797     parent_node = model->root;
 798   else if (parent == NULL)
 799     parent_node = G_NODE (sibling->user_data)->parent;
 800   else if (sibling == NULL)
 801     parent_node = G_NODE (parent->user_data);
 802   else
 803     {
 804       g_return_if_fail (G_NODE (sibling->user_data)->parent ==
 805                         G_NODE (parent->user_data));
 806       parent_node = G_NODE (parent->user_data);
 807     }
 808
 809   g_node_insert_before (parent_node,
 810                         sibling ? G_NODE (sibling->user_data) : NULL,
 811                         new_node);
 812
 813   iter->stamp = model->stamp;
 814   iter->user_data = new_node;
 815
 816   path = gtk_tree_store_get_path (GTK_TREE_MODEL (model), iter);
 817   gtk_signal_emit_by_name (GTK_OBJECT (model),
 818                            "inserted",
 819                            path, iter);
 820   gtk_tree_path_free (path);
 821
 822   validate_tree ((GtkTreeStore*)model);
 823 }
 824
 825 void
 826 gtk_tree_store_insert_after (GtkTreeStore *model,
 827                              GtkTreeIter  *iter,
 828                              GtkTreeIter  *parent,
 829                              GtkTreeIter  *sibling)
 830 {
 831   GtkTreePath *path;
 832   GNode *parent_node;
 833   GNode *new_node;
 834
 835   g_return_if_fail (model != NULL);
 836   g_return_if_fail (GTK_IS_TREE_STORE (model));
 837   g_return_if_fail (iter != NULL);
 838
 839   new_node = g_node_new (NULL);
 840
 841   if (parent == NULL && sibling == NULL)
 842     parent_node = model->root;
 843   else if (parent == NULL)
 844     parent_node = G_NODE (sibling->user_data)->parent;
 845   else if (sibling == NULL)
 846     parent_node = G_NODE (parent->user_data);
 847   else
 848     {
 849       g_return_if_fail (G_NODE (sibling->user_data)->parent ==
 850                         G_NODE (parent->user_data));
 851       parent_node = G_NODE (parent->user_data);
 852     }
 853
 854
 855   g_node_insert_after (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_prepend (GtkTreeStore *model,
 873                         GtkTreeIter  *iter,
 874                         GtkTreeIter  *parent)
 875 {
 876   GNode *parent_node;
 877
 878   g_return_if_fail (model != NULL);
 879   g_return_if_fail (GTK_IS_TREE_STORE (model));
 880   g_return_if_fail (iter != NULL);
 881
 882   if (parent == NULL)
 883     parent_node = model->root;
 884   else
 885     parent_node = parent->user_data;
 886
 887   if (parent_node->children == NULL)
 888     {
 889       GtkTreePath *path;
 890
 891       iter->stamp = model->stamp;
 892       iter->user_data = g_node_new (NULL);
 893
 894       g_node_prepend (parent_node, iter->user_data);
 895
 896       if (parent_node != model->root)
 897         {
 898           path = gtk_tree_store_get_path (GTK_TREE_MODEL (model), parent);
 899           gtk_signal_emit_by_name (GTK_OBJECT (model),
 900                                    "child_toggled",
 901                                    path,
 902                                    parent);
 903           gtk_tree_path_append_index (path, 0);
 904         }
 905       else
 906         {
 907           path = gtk_tree_store_get_path (GTK_TREE_MODEL (model), iter);
 908         }
 909       gtk_signal_emit_by_name (GTK_OBJECT (model),
 910                                "inserted",
 911                                path,
 912                                iter);
 913       gtk_tree_path_free (path);
 914     }
 915   else
 916     {
 917       gtk_tree_store_insert_after (model, iter, parent, NULL);
 918     }
 919
 920   validate_tree ((GtkTreeStore*)model);
 921 }
 922
 923 void
 924 gtk_tree_store_append (GtkTreeStore *model,
 925                        GtkTreeIter  *iter,
 926                        GtkTreeIter  *parent)
 927 {
 928   GNode *parent_node;
 929
 930   g_return_if_fail (model != NULL);
 931   g_return_if_fail (GTK_IS_TREE_STORE (model));
 932   g_return_if_fail (iter != NULL);
 933
 934   if (parent == NULL)
 935     parent_node = model->root;
 936   else
 937     parent_node = parent->user_data;
 938
 939   if (parent_node->children == NULL)
 940     {
 941       GtkTreePath *path;
 942
 943       iter->stamp = model->stamp;
 944       iter->user_data = g_node_new (NULL);
 945
 946       g_node_append (parent_node, G_NODE (iter->user_data));
 947
 948       if (parent_node != model->root)
 949         {
 950           path = gtk_tree_store_get_path (GTK_TREE_MODEL (model), parent);
 951           gtk_signal_emit_by_name (GTK_OBJECT (model),
 952                                    "child_toggled",
 953                                    path,
 954                                    parent);
 955           gtk_tree_path_append_index (path, 0);
 956         }
 957       else
 958         {
 959           path = gtk_tree_store_get_path (GTK_TREE_MODEL (model), iter);
 960         }
 961
 962       gtk_signal_emit_by_name (GTK_OBJECT (model),
 963                                "inserted",
 964                                path,
 965                                iter);
 966       gtk_tree_path_free (path);
 967     }
 968   else
 969     {
 970       gtk_tree_store_insert_before (model, iter, parent, NULL);
 971     }
 972
 973   validate_tree ((GtkTreeStore*)model);
 974 }
 975
 976 gboolean
 977 gtk_tree_store_is_ancestor (GtkTreeStore *model,
 978                             GtkTreeIter  *iter,
 979                             GtkTreeIter  *descendant)
 980 {
 981   g_return_val_if_fail (model != NULL, FALSE);
 982   g_return_val_if_fail (GTK_IS_TREE_STORE (model), FALSE);
 983   g_return_val_if_fail (iter != NULL, FALSE);
 984   g_return_val_if_fail (descendant != NULL, FALSE);
 985
 986   return g_node_is_ancestor (G_NODE (iter->user_data),
 987                              G_NODE (descendant->user_data));
 988 }
 989
 990
 991 gint
 992 gtk_tree_store_iter_depth (GtkTreeStore *model,
 993                            GtkTreeIter  *iter)
 994 {
 995   g_return_val_if_fail (model != NULL, 0);
 996   g_return_val_if_fail (GTK_IS_TREE_STORE (model), 0);
 997   g_return_val_if_fail (iter != NULL, 0);
 998
 999   return g_node_depth (G_NODE (iter->user_data)) - 1;
1000 }
1001
1002 /* DND */
1003
1004
1005
1006 static gboolean
1007 gtk_tree_store_drag_data_delete (GtkTreeDragSource *drag_source,
1008                                  GtkTreePath       *path)
1009 {
1010   GtkTreeIter iter;
1011
1012   g_return_val_if_fail (GTK_IS_TREE_STORE (drag_source), FALSE);
1013
1014   if (gtk_tree_model_get_iter (GTK_TREE_MODEL (drag_source),
1015                                &iter,
1016                                path))
1017     {
1018       gtk_tree_store_remove (GTK_TREE_STORE (drag_source),
1019                              &iter);
1020       return TRUE;
1021     }
1022   else
1023     {
1024       return FALSE;
1025     }
1026 }
1027
1028 static gboolean
1029 gtk_tree_store_drag_data_get (GtkTreeDragSource *drag_source,
1030                               GtkTreePath       *path,
1031                               GtkSelectionData  *selection_data)
1032 {
1033   g_return_val_if_fail (GTK_IS_TREE_STORE (drag_source), FALSE);
1034
1035   /* Note that we don't need to handle the GTK_TREE_MODEL_ROW
1036    * target, because the default handler does it for us, but
1037    * we do anyway for the convenience of someone maybe overriding the
1038    * default handler.
1039    */
1040
1041   if (gtk_selection_data_set_tree_row (selection_data,
1042                                        GTK_TREE_MODEL (drag_source),
1043                                        path))
1044     {
1045       return TRUE;
1046     }
1047   else
1048     {
1049       /* FIXME handle text targets at least. */
1050     }
1051
1052   return FALSE;
1053 }
1054
1055 static void
1056 copy_node_data (GtkTreeStore *tree_store,
1057                 GtkTreeIter  *src_iter,
1058                 GtkTreeIter  *dest_iter)
1059 {
1060   GtkTreeDataList *dl = G_NODE (src_iter->user_data)->data;
1061   GtkTreeDataList *copy_head = NULL;
1062   GtkTreeDataList *copy_prev = NULL;
1063   GtkTreeDataList *copy_iter = NULL;
1064   gint col;
1065
1066   col = 0;
1067   while (dl)
1068     {
1069       copy_iter = _gtk_tree_data_list_node_copy (dl,
1070                                                  tree_store->column_headers[col]);
1071
1072       if (copy_head == NULL)
1073         copy_head = copy_iter;
1074
1075       if (copy_prev)
1076         copy_prev->next = copy_iter;
1077
1078       copy_prev = copy_iter;
1079
1080       dl = dl->next;
1081       ++col;
1082     }
1083
1084   G_NODE (dest_iter->user_data)->data = copy_head;
1085
1086   gtk_signal_emit_by_name (GTK_OBJECT (tree_store),
1087                            "changed",
1088                            NULL, dest_iter);
1089 }
1090
1091 static void
1092 recursive_node_copy (GtkTreeStore *tree_store,
1093                      GtkTreeIter  *src_iter,
1094                      GtkTreeIter  *dest_iter)
1095 {
1096   GtkTreeIter child;
1097   GtkTreeModel *model;
1098
1099   model = GTK_TREE_MODEL (tree_store);
1100
1101   copy_node_data (tree_store, src_iter, dest_iter);
1102
1103   if (gtk_tree_model_iter_children (model,
1104                                     &child,
1105                                     src_iter))
1106     {
1107       /* Need to create children and recurse. Note our
1108        * dependence on persistent iterators here.
1109        */
1110       do
1111         {
1112           GtkTreeIter copy;
1113
1114           /* Gee, a really slow algorithm... ;-) FIXME */
1115           gtk_tree_store_append (tree_store,
1116                                  &copy,
1117                                  dest_iter);
1118
1119           recursive_node_copy (tree_store, &child, &copy);
1120         }
1121       while (gtk_tree_model_iter_next (model, &child));
1122     }
1123 }
1124
1125 static gboolean
1126 gtk_tree_store_drag_data_received (GtkTreeDragDest   *drag_dest,
1127                                    GtkTreePath       *dest,
1128                                    GtkSelectionData  *selection_data)
1129 {
1130   GtkTreeModel *tree_model;
1131   GtkTreeStore *tree_store;
1132   GtkTreeModel *src_model = NULL;
1133   GtkTreePath *src_path = NULL;
1134   gboolean retval = FALSE;
1135
1136   g_return_val_if_fail (GTK_IS_TREE_STORE (drag_dest), FALSE);
1137
1138   tree_model = GTK_TREE_MODEL (drag_dest);
1139   tree_store = GTK_TREE_STORE (drag_dest);
1140
1141   validate_tree (tree_store);
1142
1143   if (gtk_selection_data_get_tree_row (selection_data,
1144                                        &src_model,
1145                                        &src_path) &&
1146       src_model == tree_model)
1147     {
1148       /* Copy the given row to a new position */
1149       GtkTreeIter src_iter;
1150       GtkTreeIter dest_iter;
1151       GtkTreePath *prev;
1152
1153       if (!gtk_tree_model_get_iter (src_model,
1154                                     &src_iter,
1155                                     src_path))
1156         {
1157           goto out;
1158         }
1159
1160       /* Get the path to insert _after_ (dest is the path to insert _before_) */
1161       prev = gtk_tree_path_copy (dest);
1162
1163       if (!gtk_tree_path_prev (prev))
1164         {
1165           GtkTreeIter dest_parent;
1166           GtkTreePath *parent;
1167           GtkTreeIter *dest_parent_p;
1168
1169           /* dest was the first spot at the current depth; which means
1170            * we are supposed to prepend.
1171            */
1172
1173           /* Get the parent, NULL if parent is the root */
1174           dest_parent_p = NULL;
1175           parent = gtk_tree_path_copy (dest);
1176           if (gtk_tree_path_up (parent))
1177             {
1178               gtk_tree_model_get_iter (tree_model,
1179                                        &dest_parent,
1180                                        parent);
1181               dest_parent_p = &dest_parent;
1182             }
1183           gtk_tree_path_free (parent);
1184           parent = NULL;
1185
1186           gtk_tree_store_prepend (GTK_TREE_STORE (tree_model),
1187                                   &dest_iter,
1188                                   dest_parent_p);
1189
1190           retval = TRUE;
1191         }
1192       else
1193         {
1194           if (gtk_tree_model_get_iter (GTK_TREE_MODEL (tree_model),
1195                                        &dest_iter,
1196                                        prev))
1197             {
1198               GtkTreeIter tmp_iter = dest_iter;
1199               gtk_tree_store_insert_after (GTK_TREE_STORE (tree_model),
1200                                            &dest_iter,
1201                                            NULL,
1202                                            &tmp_iter);
1203               retval = TRUE;
1204
1205             }
1206         }
1207
1208       gtk_tree_path_free (prev);
1209
1210       /* If we succeeded in creating dest_iter, walk src_iter tree branch,
1211        * duplicating it below dest_iter.
1212        */
1213
1214       if (retval)
1215         {
1216           recursive_node_copy (tree_store,
1217                                &src_iter,
1218                                &dest_iter);
1219         }
1220     }
1221   else
1222     {
1223       /* FIXME maybe add some data targets eventually, or handle text
1224        * targets in the simple case.
1225        */
1226
1227     }
1228
1229  out:
1230
1231   if (src_path)
1232     gtk_tree_path_free (src_path);
1233
1234   return retval;
1235 }
1236
1237 static gboolean
1238 gtk_tree_store_row_drop_possible (GtkTreeDragDest *drag_dest,
1239                                   GtkTreeModel    *src_model,
1240                                   GtkTreePath     *src_path,
1241                                   GtkTreePath     *dest_path)
1242 {
1243   /* can only drag to ourselves */
1244   if (src_model != GTK_TREE_MODEL (drag_dest))
1245     return FALSE;
1246
1247   /* Can't drop into ourself. */
1248   if (gtk_tree_path_is_ancestor (src_path,
1249                                  dest_path))
1250     return FALSE;
1251
1252   /* Can't drop if dest_path's parent doesn't exist */
1253   {
1254     GtkTreeIter iter;
1255     GtkTreePath *tmp = gtk_tree_path_copy (dest_path);
1256
1257     /* if we can't go up, we know the parent exists, the root
1258      * always exists.
1259      */
1260     if (gtk_tree_path_up (tmp))
1261       {
1262         if (!gtk_tree_model_get_iter (GTK_TREE_MODEL (drag_dest),
1263                                       &iter, tmp))
1264           {
1265             if (tmp)
1266               gtk_tree_path_free (tmp);
1267             return FALSE;
1268           }
1269       }
1270
1271     if (tmp)
1272       gtk_tree_path_free (tmp);
1273   }
1274
1275   /* Can otherwise drop anywhere. */
1276   return TRUE;
1277 }
1278
1279 static void
1280 validate_gnode (GNode* node)
1281 {
1282   GNode *iter;
1283
1284   iter = node->children;
1285   while (iter != NULL)
1286     {
1287       g_assert (iter->parent == node);
1288       if (iter->prev)
1289         g_assert (iter->prev->next == iter);
1290       validate_gnode (iter);
1291       iter = iter->next;
1292     }
1293 }
1294
1295