Pileus Git - ~andy/gtk/blob - tests/testtreecolumns.c

   1 /* testtreecolumns.c
   2  * Copyright (C) 2001 Red Hat, Inc
   3  * Author: Jonathan Blandford
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Library General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Library General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Library General Public
  16  * License along with this library; if not, write to the
  17  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  18  * Boston, MA 02111-1307, USA.
  19  */
  20
  21 #include "config.h"
  22 #include <gtk/gtk.h>
  23
  24 /*
  25  * README README README README README README README README README README
  26  * README README README README README README README README README README
  27  * README README README README README README README README README README
  28  * README README README README README README README README README README
  29  * README README README README README README README README README README
  30  * README README README README README README README README README README
  31  * README README README README README README README README README README
  32  * README README README README README README README README README README
  33  * README README README README README README README README README README
  34  * README README README README README README README README README README
  35  * README README README README README README README README README README
  36  * README README README README README README README README README README
  37  * README README README README README README README README README README
  38  *
  39  * DO NOT!!! I REPEAT DO NOT!  EVER LOOK AT THIS CODE AS AN EXAMPLE OF WHAT YOUR
  40  * CODE SHOULD LOOK LIKE.
  41  *
  42  * IT IS VERY CONFUSING, AND IS MEANT TO TEST A LOT OF CODE IN THE TREE.  WHILE
  43  * IT IS ACTUALLY CORRECT CODE, IT IS NOT USEFUL.
  44  */
  45
  46 GtkWidget *left_tree_view;
  47 GtkWidget *top_right_tree_view;
  48 GtkWidget *bottom_right_tree_view;
  49 GtkTreeModel *left_tree_model;
  50 GtkTreeModel *top_right_tree_model;
  51 GtkTreeModel *bottom_right_tree_model;
  52 GtkWidget *sample_tree_view_top;
  53 GtkWidget *sample_tree_view_bottom;
  54
  55 #define column_data "my_column_data"
  56
  57 static void move_row  (GtkTreeModel *src,
  58                        GtkTreeIter  *src_iter,
  59                        GtkTreeModel *dest,
  60                        GtkTreeIter  *dest_iter);
  61
  62 /* Kids, don't try this at home.  */
  63
  64 /* Small GtkTreeModel to model columns */
  65 typedef struct _ViewColumnModel ViewColumnModel;
  66 typedef struct _ViewColumnModelClass ViewColumnModelClass;
  67
  68 struct _ViewColumnModel
  69 {
  70   GObject parent;
  71   GtkTreeView *view;
  72   GList *columns;
  73   gint stamp;
  74 };
  75
  76 struct _ViewColumnModelClass
  77 {
  78   GObjectClass parent_class;
  79 };
  80
  81 static void view_column_model_init (ViewColumnModel *model)
  82 {
  83   model->stamp = g_random_int ();
  84 }
  85
  86 static gint
  87 view_column_model_get_n_columns (GtkTreeModel *tree_model)
  88 {
  89   return 2;
  90 }
  91
  92 static GType
  93 view_column_model_get_column_type (GtkTreeModel *tree_model,
  94                                    gint          index)
  95 {
  96   switch (index)
  97     {
  98     case 0:
  99       return G_TYPE_STRING;
 100     case 1:
 101       return GTK_TYPE_TREE_VIEW_COLUMN;
 102     default:
 103       return G_TYPE_INVALID;
 104     }
 105 }
 106
 107 static gboolean
 108 view_column_model_get_iter (GtkTreeModel *tree_model,
 109                             GtkTreeIter  *iter,
 110                             GtkTreePath  *path)
 111
 112 {
 113   ViewColumnModel *view_model = (ViewColumnModel *)tree_model;
 114   GList *list;
 115   gint i;
 116
 117   g_return_val_if_fail (gtk_tree_path_get_depth (path) > 0, FALSE);
 118
 119   i = gtk_tree_path_get_indices (path)[0];
 120   list = g_list_nth (view_model->columns, i);
 121
 122   if (list == NULL)
 123     return FALSE;
 124
 125   iter->stamp = view_model->stamp;
 126   iter->user_data = list;
 127
 128   return TRUE;
 129 }
 130
 131 static GtkTreePath *
 132 view_column_model_get_path (GtkTreeModel *tree_model,
 133                             GtkTreeIter  *iter)
 134 {
 135   ViewColumnModel *view_model = (ViewColumnModel *)tree_model;
 136   GtkTreePath *retval;
 137   GList *list;
 138   gint i = 0;
 139
 140   g_return_val_if_fail (iter->stamp == view_model->stamp, NULL);
 141
 142   for (list = view_model->columns; list; list = list->next)
 143     {
 144       if (list == (GList *)iter->user_data)
 145         break;
 146       i++;
 147     }
 148   if (list == NULL)
 149     return NULL;
 150
 151   retval = gtk_tree_path_new ();
 152   gtk_tree_path_append_index (retval, i);
 153   return retval;
 154 }
 155
 156 static void
 157 view_column_model_get_value (GtkTreeModel *tree_model,
 158                              GtkTreeIter  *iter,
 159                              gint          column,
 160                              GValue       *value)
 161 {
 162   ViewColumnModel *view_model = (ViewColumnModel *)tree_model;
 163
 164   g_return_if_fail (column < 2);
 165   g_return_if_fail (view_model->stamp == iter->stamp);
 166   g_return_if_fail (iter->user_data != NULL);
 167
 168   if (column == 0)
 169     {
 170       g_value_init (value, G_TYPE_STRING);
 171       g_value_set_string (value, gtk_tree_view_column_get_title (GTK_TREE_VIEW_COLUMN (((GList *)iter->user_data)->data)));
 172     }
 173   else
 174     {
 175       g_value_init (value, GTK_TYPE_TREE_VIEW_COLUMN);
 176       g_value_set_object (value, ((GList *)iter->user_data)->data);
 177     }
 178 }
 179
 180 static gboolean
 181 view_column_model_iter_next (GtkTreeModel  *tree_model,
 182                              GtkTreeIter   *iter)
 183 {
 184   ViewColumnModel *view_model = (ViewColumnModel *)tree_model;
 185
 186   g_return_val_if_fail (view_model->stamp == iter->stamp, FALSE);
 187   g_return_val_if_fail (iter->user_data != NULL, FALSE);
 188
 189   iter->user_data = ((GList *)iter->user_data)->next;
 190   return iter->user_data != NULL;
 191 }
 192
 193 static gboolean
 194 view_column_model_iter_children (GtkTreeModel *tree_model,
 195                                  GtkTreeIter  *iter,
 196                                  GtkTreeIter  *parent)
 197 {
 198   ViewColumnModel *view_model = (ViewColumnModel *)tree_model;
 199
 200   /* this is a list, nodes have no children */
 201   if (parent)
 202     return FALSE;
 203
 204   /* but if parent == NULL we return the list itself as children of the
 205    * "root"
 206    */
 207
 208   if (view_model->columns)
 209     {
 210       iter->stamp = view_model->stamp;
 211       iter->user_data = view_model->columns;
 212       return TRUE;
 213     }
 214   else
 215     return FALSE;
 216 }
 217
 218 static gboolean
 219 view_column_model_iter_has_child (GtkTreeModel *tree_model,
 220                                   GtkTreeIter  *iter)
 221 {
 222   return FALSE;
 223 }
 224
 225 static gint
 226 view_column_model_iter_n_children (GtkTreeModel *tree_model,
 227                                    GtkTreeIter  *iter)
 228 {
 229   return g_list_length (((ViewColumnModel *)tree_model)->columns);
 230 }
 231
 232 static gint
 233 view_column_model_iter_nth_child (GtkTreeModel *tree_model,
 234                                   GtkTreeIter  *iter,
 235                                   GtkTreeIter  *parent,
 236                                   gint          n)
 237 {
 238   ViewColumnModel *view_model = (ViewColumnModel *)tree_model;
 239
 240   if (parent)
 241     return FALSE;
 242
 243   iter->stamp = view_model->stamp;
 244   iter->user_data = g_list_nth ((GList *)view_model->columns, n);
 245
 246   return (iter->user_data != NULL);
 247 }
 248
 249 static gboolean
 250 view_column_model_iter_parent (GtkTreeModel *tree_model,
 251                                GtkTreeIter  *iter,
 252                                GtkTreeIter  *child)
 253 {
 254   return FALSE;
 255 }
 256
 257 static void
 258 view_column_model_tree_model_init (GtkTreeModelIface *iface)
 259 {
 260   iface->get_n_columns = view_column_model_get_n_columns;
 261   iface->get_column_type = view_column_model_get_column_type;
 262   iface->get_iter = view_column_model_get_iter;
 263   iface->get_path = view_column_model_get_path;
 264   iface->get_value = view_column_model_get_value;
 265   iface->iter_next = view_column_model_iter_next;
 266   iface->iter_children = view_column_model_iter_children;
 267   iface->iter_has_child = view_column_model_iter_has_child;
 268   iface->iter_n_children = view_column_model_iter_n_children;
 269   iface->iter_nth_child = view_column_model_iter_nth_child;
 270   iface->iter_parent = view_column_model_iter_parent;
 271 }
 272
 273 static gboolean
 274 view_column_model_drag_data_get (GtkTreeDragSource   *drag_source,
 275                                  GtkTreePath         *path,
 276                                  GtkSelectionData    *selection_data)
 277 {
 278   if (gtk_tree_set_row_drag_data (selection_data,
 279                                   GTK_TREE_MODEL (drag_source),
 280                                   path))
 281     return TRUE;
 282   else
 283     return FALSE;
 284 }
 285
 286 static gboolean
 287 view_column_model_drag_data_delete (GtkTreeDragSource *drag_source,
 288                                     GtkTreePath       *path)
 289 {
 290   /* Nothing -- we handle moves on the dest side */
 291
 292   return TRUE;
 293 }
 294
 295 static gboolean
 296 view_column_model_row_drop_possible (GtkTreeDragDest   *drag_dest,
 297                                      GtkTreePath       *dest_path,
 298                                      GtkSelectionData  *selection_data)
 299 {
 300   GtkTreeModel *src_model;
 301
 302   if (gtk_tree_get_row_drag_data (selection_data,
 303                                   &src_model,
 304                                   NULL))
 305     {
 306       if (src_model == left_tree_model ||
 307           src_model == top_right_tree_model ||
 308           src_model == bottom_right_tree_model)
 309         return TRUE;
 310     }
 311
 312   return FALSE;
 313 }
 314
 315 static gboolean
 316 view_column_model_drag_data_received (GtkTreeDragDest   *drag_dest,
 317                                       GtkTreePath       *dest,
 318                                       GtkSelectionData  *selection_data)
 319 {
 320   GtkTreeModel *src_model;
 321   GtkTreePath *src_path = NULL;
 322   gboolean retval = FALSE;
 323
 324   if (gtk_tree_get_row_drag_data (selection_data,
 325                                   &src_model,
 326                                   &src_path))
 327     {
 328       GtkTreeIter src_iter;
 329       GtkTreeIter dest_iter;
 330       gboolean have_dest;
 331
 332       /* We are a little lazy here, and assume if we can't convert dest
 333        * to an iter, we need to append. See gtkliststore.c for a more
 334        * careful handling of this.
 335        */
 336       have_dest = gtk_tree_model_get_iter (GTK_TREE_MODEL (drag_dest), &dest_iter, dest);
 337
 338       if (gtk_tree_model_get_iter (src_model, &src_iter, src_path))
 339         {
 340           if (src_model == left_tree_model ||
 341               src_model == top_right_tree_model ||
 342               src_model == bottom_right_tree_model)
 343             {
 344               move_row (src_model, &src_iter, GTK_TREE_MODEL (drag_dest),
 345                         have_dest ? &dest_iter : NULL);
 346               retval = TRUE;
 347             }
 348         }
 349
 350       gtk_tree_path_free (src_path);
 351     }
 352
 353   return retval;
 354 }
 355
 356 static void
 357 view_column_model_drag_source_init (GtkTreeDragSourceIface *iface)
 358 {
 359   iface->drag_data_get = view_column_model_drag_data_get;
 360   iface->drag_data_delete = view_column_model_drag_data_delete;
 361 }
 362
 363 static void
 364 view_column_model_drag_dest_init (GtkTreeDragDestIface *iface)
 365 {
 366   iface->drag_data_received = view_column_model_drag_data_received;
 367   iface->row_drop_possible = view_column_model_row_drop_possible;
 368 }
 369
 370 GType
 371 view_column_model_get_type (void)
 372 {
 373   static GType view_column_model_type = 0;
 374
 375   if (!view_column_model_type)
 376     {
 377       const GTypeInfo view_column_model_info =
 378       {
 379         sizeof (GtkListStoreClass),
 380         NULL,           /* base_init */
 381         NULL,           /* base_finalize */
 382         NULL,           /* class_init */
 383         NULL,           /* class_finalize */
 384         NULL,           /* class_data */
 385         sizeof (GtkListStore),
 386         0,
 387         (GInstanceInitFunc) view_column_model_init,
 388       };
 389
 390       const GInterfaceInfo tree_model_info =
 391       {
 392         (GInterfaceInitFunc) view_column_model_tree_model_init,
 393         NULL,
 394         NULL
 395       };
 396
 397       const GInterfaceInfo drag_source_info =
 398       {
 399         (GInterfaceInitFunc) view_column_model_drag_source_init,
 400         NULL,
 401         NULL
 402       };
 403
 404       const GInterfaceInfo drag_dest_info =
 405       {
 406         (GInterfaceInitFunc) view_column_model_drag_dest_init,
 407         NULL,
 408         NULL
 409       };
 410
 411       view_column_model_type = g_type_register_static (G_TYPE_OBJECT, "ViewModelColumn", &view_column_model_info, 0);
 412       g_type_add_interface_static (view_column_model_type,
 413                                    GTK_TYPE_TREE_MODEL,
 414                                    &tree_model_info);
 415       g_type_add_interface_static (view_column_model_type,
 416                                    GTK_TYPE_TREE_DRAG_SOURCE,
 417                                    &drag_source_info);
 418       g_type_add_interface_static (view_column_model_type,
 419                                    GTK_TYPE_TREE_DRAG_DEST,
 420                                    &drag_dest_info);
 421     }
 422
 423   return view_column_model_type;
 424 }
 425
 426 static void
 427 update_columns (GtkTreeView *view, ViewColumnModel *view_model)
 428 {
 429   GList *old_columns = view_model->columns;
 430   gint old_length, length;
 431   GList *a, *b;
 432
 433   view_model->columns = gtk_tree_view_get_columns (view_model->view);
 434
 435   /* As the view tells us one change at a time, we can do this hack. */
 436   length = g_list_length (view_model->columns);
 437   old_length = g_list_length (old_columns);
 438   if (length != old_length)
 439     {
 440       GtkTreePath *path;
 441       gint i = 0;
 442
 443       /* where are they different */
 444       for (a = old_columns, b = view_model->columns; a && b; a = a->next, b = b->next)
 445         {
 446           if (a->data != b->data)
 447             break;
 448           i++;
 449         }
 450       path = gtk_tree_path_new ();
 451       gtk_tree_path_append_index (path, i);
 452       if (length < old_length)
 453         {
 454           view_model->stamp++;
 455           gtk_tree_model_row_deleted (GTK_TREE_MODEL (view_model), path);
 456         }
 457       else
 458         {
 459           GtkTreeIter iter;
 460           iter.stamp = view_model->stamp;
 461           iter.user_data = b;
 462           gtk_tree_model_row_inserted (GTK_TREE_MODEL (view_model), path, &iter);
 463         }
 464       gtk_tree_path_free (path);
 465     }
 466   else
 467     {
 468       gint i;
 469       gint m = 0, n = 1;
 470       gint *new_order;
 471       GtkTreePath *path;
 472
 473       new_order = g_new (int, length);
 474       a = old_columns; b = view_model->columns;
 475
 476       while (a->data == b->data)
 477         {
 478           a = a->next;
 479           b = b->next;
 480           if (a == NULL)
 481             return;
 482           m++;
 483         }
 484
 485       if (a->next->data == b->data)
 486         {
 487           b = b->next;
 488           while (b->data != a->data)
 489             {
 490               b = b->next;
 491               n++;
 492             }
 493           for (i = 0; i < m; i++)
 494             new_order[i] = i;
 495           for (i = m; i < m+n; i++)
 496             new_order[i] = i+1;
 497           new_order[i] = m;
 498           for (i = m + n +1; i < length; i++)
 499             new_order[i] = i;
 500         }
 501       else
 502         {
 503           a = a->next;
 504           while (a->data != b->data)
 505             {
 506               a = a->next;
 507               n++;
 508             }
 509           for (i = 0; i < m; i++)
 510             new_order[i] = i;
 511           new_order[m] = m+n;
 512           for (i = m+1; i < m + n+ 1; i++)
 513             new_order[i] = i - 1;
 514           for (i = m + n + 1; i < length; i++)
 515             new_order[i] = i;
 516         }
 517
 518       path = gtk_tree_path_new ();
 519       gtk_tree_model_rows_reordered (GTK_TREE_MODEL (view_model),
 520                                      path,
 521                                      NULL,
 522                                      new_order);
 523       gtk_tree_path_free (path);
 524       g_free (new_order);
 525     }
 526   if (old_columns)
 527     g_list_free (old_columns);
 528 }
 529
 530 static GtkTreeModel *
 531 view_column_model_new (GtkTreeView *view)
 532 {
 533   GtkTreeModel *retval;
 534
 535   retval = g_object_new (view_column_model_get_type (), NULL);
 536   ((ViewColumnModel *)retval)->view = view;
 537   ((ViewColumnModel *)retval)->columns = gtk_tree_view_get_columns (view);
 538
 539   g_signal_connect (view, "columns_changed", G_CALLBACK (update_columns), retval);
 540
 541   return retval;
 542 }
 543
 544 /* Back to sanity.
 545  */
 546
 547 static void
 548 add_clicked (GtkWidget *button, gpointer data)
 549 {
 550   static gint i = 0;
 551
 552   GtkTreeIter iter;
 553   GtkTreeViewColumn *column;
 554   GtkTreeSelection *selection;
 555   GtkCellRenderer *cell;
 556   gchar *label = g_strdup_printf ("Column %d", i);
 557
 558   cell = gtk_cell_renderer_text_new ();
 559   column = gtk_tree_view_column_new_with_attributes (label, cell, "text", 0, NULL);
 560   g_object_set_data_full (G_OBJECT (column), column_data, label, g_free);
 561   gtk_tree_view_column_set_reorderable (column, TRUE);
 562   gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_GROW_ONLY);
 563   gtk_tree_view_column_set_resizable (column, TRUE);
 564   gtk_list_store_append (GTK_LIST_STORE (left_tree_model), &iter);
 565   gtk_list_store_set (GTK_LIST_STORE (left_tree_model), &iter, 0, label, 1, column, -1);
 566   i++;
 567
 568   selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (left_tree_view));
 569   gtk_tree_selection_select_iter (selection, &iter);
 570 }
 571
 572 static void
 573 get_visible (GtkTreeViewColumn *tree_column,
 574              GtkCellRenderer   *cell,
 575              GtkTreeModel      *tree_model,
 576              GtkTreeIter       *iter,
 577              gpointer           data)
 578 {
 579   GtkTreeViewColumn *column;
 580
 581   gtk_tree_model_get (tree_model, iter, 1, &column, -1);
 582   if (column)
 583     {
 584       gtk_cell_renderer_toggle_set_active (GTK_CELL_RENDERER_TOGGLE (cell),
 585                                            gtk_tree_view_column_get_visible (column));
 586     }
 587 }
 588
 589 static void
 590 set_visible (GtkCellRendererToggle *cell,
 591              gchar                 *path_str,
 592              gpointer               data)
 593 {
 594   GtkTreeView *tree_view = (GtkTreeView *) data;
 595   GtkTreeViewColumn *column;
 596   GtkTreeModel *model;
 597   GtkTreeIter iter;
 598   GtkTreePath *path = gtk_tree_path_new_from_string (path_str);
 599
 600   model = gtk_tree_view_get_model (tree_view);
 601
 602   gtk_tree_model_get_iter (model, &iter, path);
 603   gtk_tree_model_get (model, &iter, 1, &column, -1);
 604
 605   if (column)
 606     {
 607       gtk_tree_view_column_set_visible (column, ! gtk_tree_view_column_get_visible (column));
 608       gtk_tree_model_row_changed (model, path, &iter);
 609     }
 610   gtk_tree_path_free (path);
 611 }
 612
 613 static void
 614 move_to_left (GtkTreeModel *src,
 615               GtkTreeIter  *src_iter,
 616               GtkTreeIter  *dest_iter)
 617 {
 618   GtkTreeIter iter;
 619   GtkTreeViewColumn *column;
 620   GtkTreeSelection *selection;
 621   gchar *label;
 622
 623   gtk_tree_model_get (src, src_iter, 0, &label, 1, &column, -1);
 624
 625   if (src == top_right_tree_model)
 626     gtk_tree_view_remove_column (GTK_TREE_VIEW (sample_tree_view_top), column);
 627   else
 628     gtk_tree_view_remove_column (GTK_TREE_VIEW (sample_tree_view_bottom), column);
 629
 630   /*  gtk_list_store_remove (GTK_LIST_STORE (gtk_tree_view_get_model (GTK_TREE_VIEW (data))), &iter);*/
 631
 632   /* Put it back on the left */
 633   if (dest_iter)
 634     gtk_list_store_insert_before (GTK_LIST_STORE (left_tree_model),
 635                                   &iter, dest_iter);
 636   else
 637     gtk_list_store_append (GTK_LIST_STORE (left_tree_model), &iter);
 638
 639   gtk_list_store_set (GTK_LIST_STORE (left_tree_model), &iter, 0, label, 1, column, -1);
 640   selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (left_tree_view));
 641   gtk_tree_selection_select_iter (selection, &iter);
 642
 643   g_free (label);
 644 }
 645
 646 static void
 647 move_to_right (GtkTreeIter  *src_iter,
 648                GtkTreeModel *dest,
 649                GtkTreeIter  *dest_iter)
 650 {
 651   gchar *label;
 652   GtkTreeViewColumn *column;
 653   gint before = -1;
 654
 655   gtk_tree_model_get (GTK_TREE_MODEL (left_tree_model),
 656                       src_iter, 0, &label, 1, &column, -1);
 657   gtk_list_store_remove (GTK_LIST_STORE (left_tree_model), src_iter);
 658
 659   if (dest_iter)
 660     {
 661       GtkTreePath *path = gtk_tree_model_get_path (dest, dest_iter);
 662       before = (gtk_tree_path_get_indices (path))[0];
 663       gtk_tree_path_free (path);
 664     }
 665
 666   if (dest == top_right_tree_model)
 667     gtk_tree_view_insert_column (GTK_TREE_VIEW (sample_tree_view_top), column, before);
 668   else
 669     gtk_tree_view_insert_column (GTK_TREE_VIEW (sample_tree_view_bottom), column, before);
 670
 671   g_free (label);
 672 }
 673
 674 static void
 675 move_up_or_down (GtkTreeModel *src,
 676                  GtkTreeIter  *src_iter,
 677                  GtkTreeModel *dest,
 678                  GtkTreeIter  *dest_iter)
 679 {
 680   GtkTreeViewColumn *column;
 681   gchar *label;
 682   gint before = -1;
 683
 684   gtk_tree_model_get (src, src_iter, 0, &label, 1, &column, -1);
 685
 686   if (dest_iter)
 687     {
 688       GtkTreePath *path = gtk_tree_model_get_path (dest, dest_iter);
 689       before = (gtk_tree_path_get_indices (path))[0];
 690       gtk_tree_path_free (path);
 691     }
 692
 693   if (src == top_right_tree_model)
 694     gtk_tree_view_remove_column (GTK_TREE_VIEW (sample_tree_view_top), column);
 695   else
 696     gtk_tree_view_remove_column (GTK_TREE_VIEW (sample_tree_view_bottom), column);
 697
 698   if (dest == top_right_tree_model)
 699     gtk_tree_view_insert_column (GTK_TREE_VIEW (sample_tree_view_top), column, before);
 700   else
 701     gtk_tree_view_insert_column (GTK_TREE_VIEW (sample_tree_view_bottom), column, before);
 702
 703   g_free (label);
 704 }
 705
 706 static void
 707 move_row  (GtkTreeModel *src,
 708            GtkTreeIter  *src_iter,
 709            GtkTreeModel *dest,
 710            GtkTreeIter  *dest_iter)
 711 {
 712   if (src == left_tree_model)
 713     move_to_right (src_iter, dest, dest_iter);
 714   else if (dest == left_tree_model)
 715     move_to_left (src, src_iter, dest_iter);
 716   else
 717     move_up_or_down (src, src_iter, dest, dest_iter);
 718 }
 719
 720 static void
 721 add_left_clicked (GtkWidget *button,
 722                   gpointer data)
 723 {
 724   GtkTreeIter iter;
 725
 726   GtkTreeSelection *selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (data));
 727
 728   gtk_tree_selection_get_selected (selection, NULL, &iter);
 729
 730   move_to_left (gtk_tree_view_get_model (GTK_TREE_VIEW (data)), &iter, NULL);
 731 }
 732
 733 static void
 734 add_right_clicked (GtkWidget *button, gpointer data)
 735 {
 736   GtkTreeIter iter;
 737
 738   GtkTreeSelection *selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (left_tree_view));
 739
 740   gtk_tree_selection_get_selected (selection, NULL, &iter);
 741
 742   move_to_right (&iter, gtk_tree_view_get_model (GTK_TREE_VIEW (data)), NULL);
 743 }
 744
 745 static void
 746 selection_changed (GtkTreeSelection *selection, GtkWidget *button)
 747 {
 748   if (gtk_tree_selection_get_selected (selection, NULL, NULL))
 749     gtk_widget_set_sensitive (button, TRUE);
 750   else
 751     gtk_widget_set_sensitive (button, FALSE);
 752 }
 753
 754 static GtkTargetEntry row_targets[] = {
 755   { "GTK_TREE_MODEL_ROW", GTK_TARGET_SAME_APP, 0}
 756 };
 757
 758 int
 759 main (int argc, char *argv[])
 760 {
 761   GtkWidget *window;
 762   GtkWidget *hbox, *vbox;
 763   GtkWidget *vbox2, *bbox;
 764   GtkWidget *button;
 765   GtkTreeViewColumn *column;
 766   GtkCellRenderer *cell;
 767   GtkWidget *swindow;
 768   GtkTreeModel *sample_model;
 769   gint i;
 770
 771   gtk_init (&argc, &argv);
 772
 773   /* First initialize all the models for signal purposes */
 774   left_tree_model = (GtkTreeModel *) gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_POINTER);
 775   sample_model = (GtkTreeModel *) gtk_list_store_new (1, G_TYPE_STRING);
 776   sample_tree_view_top = gtk_tree_view_new_with_model (sample_model);
 777   sample_tree_view_bottom = gtk_tree_view_new_with_model (sample_model);
 778   top_right_tree_model = (GtkTreeModel *) view_column_model_new (GTK_TREE_VIEW (sample_tree_view_top));
 779   bottom_right_tree_model = (GtkTreeModel *) view_column_model_new (GTK_TREE_VIEW (sample_tree_view_bottom));
 780   top_right_tree_view = gtk_tree_view_new_with_model (top_right_tree_model);
 781   bottom_right_tree_view = gtk_tree_view_new_with_model (bottom_right_tree_model);
 782
 783   for (i = 0; i < 10; i++)
 784     {
 785       GtkTreeIter iter;
 786       gchar *string = g_strdup_printf ("%d", i);
 787       gtk_list_store_append (GTK_LIST_STORE (sample_model), &iter);
 788       gtk_list_store_set (GTK_LIST_STORE (sample_model), &iter, 0, string, -1);
 789       g_free (string);
 790     }
 791
 792   /* Set up the test windows. */
 793   window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 794   g_signal_connect (window, "destroy", G_CALLBACK (gtk_main_quit), NULL);
 795   gtk_window_set_default_size (GTK_WINDOW (window), 300, 300);
 796   gtk_window_set_title (GTK_WINDOW (window), "Top Window");
 797   swindow = gtk_scrolled_window_new (NULL, NULL);
 798   gtk_container_add (GTK_CONTAINER (window), swindow);
 799   gtk_container_add (GTK_CONTAINER (swindow), sample_tree_view_top);
 800   gtk_widget_show_all (window);
 801
 802   window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 803   g_signal_connect (window, "destroy", G_CALLBACK (gtk_main_quit), NULL);
 804   gtk_window_set_default_size (GTK_WINDOW (window), 300, 300);
 805   gtk_window_set_title (GTK_WINDOW (window), "Bottom Window");
 806   swindow = gtk_scrolled_window_new (NULL, NULL);
 807   gtk_container_add (GTK_CONTAINER (window), swindow);
 808   gtk_container_add (GTK_CONTAINER (swindow), sample_tree_view_bottom);
 809   gtk_widget_show_all (window);
 810
 811   /* Set up the main window */
 812   window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 813   g_signal_connect (window, "destroy", G_CALLBACK (gtk_main_quit), NULL);
 814   gtk_window_set_default_size (GTK_WINDOW (window), 500, 300);
 815   vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, FALSE, 8);
 816   gtk_container_set_border_width (GTK_CONTAINER (vbox), 8);
 817   gtk_container_add (GTK_CONTAINER (window), vbox);
 818
 819   hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, FALSE, 8);
 820   gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 0);
 821
 822   /* Left Pane */
 823   cell = gtk_cell_renderer_text_new ();
 824
 825   swindow = gtk_scrolled_window_new (NULL, NULL);
 826   gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (swindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
 827   left_tree_view = gtk_tree_view_new_with_model (left_tree_model);
 828   gtk_container_add (GTK_CONTAINER (swindow), left_tree_view);
 829   gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (left_tree_view), -1,
 830                                                "Unattached Columns", cell, "text", 0, NULL);
 831   cell = gtk_cell_renderer_toggle_new ();
 832   g_signal_connect (cell, "toggled", G_CALLBACK (set_visible), left_tree_view);
 833   column = gtk_tree_view_column_new_with_attributes ("Visible", cell, NULL);
 834   gtk_tree_view_append_column (GTK_TREE_VIEW (left_tree_view), column);
 835
 836   gtk_tree_view_column_set_cell_data_func (column, cell, get_visible, NULL, NULL);
 837   gtk_box_pack_start (GTK_BOX (hbox), swindow, TRUE, TRUE, 0);
 838
 839   /* Middle Pane */
 840   vbox2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, FALSE, 8);
 841   gtk_box_pack_start (GTK_BOX (hbox), vbox2, FALSE, FALSE, 0);
 842
 843   bbox = gtk_button_box_new (GTK_ORIENTATION_VERTICAL);
 844   gtk_button_box_set_layout (GTK_BUTTON_BOX (bbox), GTK_BUTTONBOX_SPREAD);
 845   gtk_box_pack_start (GTK_BOX (vbox2), bbox, TRUE, TRUE, 0);
 846
 847   button = gtk_button_new_with_mnemonic ("<< (_Q)");
 848   gtk_widget_set_sensitive (button, FALSE);
 849   g_signal_connect (button, "clicked", G_CALLBACK (add_left_clicked), top_right_tree_view);
 850   g_signal_connect (gtk_tree_view_get_selection (GTK_TREE_VIEW (top_right_tree_view)),
 851                     "changed", G_CALLBACK (selection_changed), button);
 852   gtk_box_pack_start (GTK_BOX (bbox), button, FALSE, FALSE, 0);
 853
 854   button = gtk_button_new_with_mnemonic (">> (_W)");
 855   gtk_widget_set_sensitive (button, FALSE);
 856   g_signal_connect (button, "clicked", G_CALLBACK (add_right_clicked), top_right_tree_view);
 857   g_signal_connect (gtk_tree_view_get_selection (GTK_TREE_VIEW (left_tree_view)),
 858                     "changed", G_CALLBACK (selection_changed), button);
 859   gtk_box_pack_start (GTK_BOX (bbox), button, FALSE, FALSE, 0);
 860
 861   bbox = gtk_button_box_new (GTK_ORIENTATION_VERTICAL);
 862   gtk_button_box_set_layout (GTK_BUTTON_BOX (bbox), GTK_BUTTONBOX_SPREAD);
 863   gtk_box_pack_start (GTK_BOX (vbox2), bbox, TRUE, TRUE, 0);
 864
 865   button = gtk_button_new_with_mnemonic ("<< (_E)");
 866   gtk_widget_set_sensitive (button, FALSE);
 867   g_signal_connect (button, "clicked", G_CALLBACK (add_left_clicked), bottom_right_tree_view);
 868   g_signal_connect (gtk_tree_view_get_selection (GTK_TREE_VIEW (bottom_right_tree_view)),
 869                     "changed", G_CALLBACK (selection_changed), button);
 870   gtk_box_pack_start (GTK_BOX (bbox), button, FALSE, FALSE, 0);
 871
 872   button = gtk_button_new_with_mnemonic (">> (_R)");
 873   gtk_widget_set_sensitive (button, FALSE);
 874   g_signal_connect (button, "clicked", G_CALLBACK (add_right_clicked), bottom_right_tree_view);
 875   g_signal_connect (gtk_tree_view_get_selection (GTK_TREE_VIEW (left_tree_view)),
 876                     "changed", G_CALLBACK (selection_changed), button);
 877   gtk_box_pack_start (GTK_BOX (bbox), button, FALSE, FALSE, 0);
 878
 879
 880   /* Right Pane */
 881   vbox2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, FALSE, 8);
 882   gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 0);
 883
 884   swindow = gtk_scrolled_window_new (NULL, NULL);
 885   gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (swindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
 886   gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (top_right_tree_view), FALSE);
 887   cell = gtk_cell_renderer_text_new ();
 888   gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (top_right_tree_view), -1,
 889                                                NULL, cell, "text", 0, NULL);
 890   cell = gtk_cell_renderer_toggle_new ();
 891   g_signal_connect (cell, "toggled", G_CALLBACK (set_visible), top_right_tree_view);
 892   column = gtk_tree_view_column_new_with_attributes (NULL, cell, NULL);
 893   gtk_tree_view_column_set_cell_data_func (column, cell, get_visible, NULL, NULL);
 894   gtk_tree_view_append_column (GTK_TREE_VIEW (top_right_tree_view), column);
 895
 896   gtk_container_add (GTK_CONTAINER (swindow), top_right_tree_view);
 897   gtk_box_pack_start (GTK_BOX (vbox2), swindow, TRUE, TRUE, 0);
 898
 899   swindow = gtk_scrolled_window_new (NULL, NULL);
 900   gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (swindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
 901   gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (bottom_right_tree_view), FALSE);
 902   cell = gtk_cell_renderer_text_new ();
 903   gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (bottom_right_tree_view), -1,
 904                                                NULL, cell, "text", 0, NULL);
 905   cell = gtk_cell_renderer_toggle_new ();
 906   g_signal_connect (cell, "toggled", G_CALLBACK (set_visible), bottom_right_tree_view);
 907   column = gtk_tree_view_column_new_with_attributes (NULL, cell, NULL);
 908   gtk_tree_view_column_set_cell_data_func (column, cell, get_visible, NULL, NULL);
 909   gtk_tree_view_append_column (GTK_TREE_VIEW (bottom_right_tree_view), column);
 910   gtk_container_add (GTK_CONTAINER (swindow), bottom_right_tree_view);
 911   gtk_box_pack_start (GTK_BOX (vbox2), swindow, TRUE, TRUE, 0);
 912
 913
 914   /* Drag and Drop */
 915   gtk_tree_view_enable_model_drag_source (GTK_TREE_VIEW (left_tree_view),
 916                                           GDK_BUTTON1_MASK,
 917                                           row_targets,
 918                                           G_N_ELEMENTS (row_targets),
 919                                           GDK_ACTION_MOVE);
 920   gtk_tree_view_enable_model_drag_dest (GTK_TREE_VIEW (left_tree_view),
 921                                         row_targets,
 922                                         G_N_ELEMENTS (row_targets),
 923                                         GDK_ACTION_MOVE);
 924
 925   gtk_tree_view_enable_model_drag_source (GTK_TREE_VIEW (top_right_tree_view),
 926                                           GDK_BUTTON1_MASK,
 927                                           row_targets,
 928                                           G_N_ELEMENTS (row_targets),
 929                                           GDK_ACTION_MOVE);
 930   gtk_tree_view_enable_model_drag_dest (GTK_TREE_VIEW (top_right_tree_view),
 931                                         row_targets,
 932                                         G_N_ELEMENTS (row_targets),
 933                                         GDK_ACTION_MOVE);
 934
 935   gtk_tree_view_enable_model_drag_source (GTK_TREE_VIEW (bottom_right_tree_view),
 936                                           GDK_BUTTON1_MASK,
 937                                           row_targets,
 938                                           G_N_ELEMENTS (row_targets),
 939                                           GDK_ACTION_MOVE);
 940   gtk_tree_view_enable_model_drag_dest (GTK_TREE_VIEW (bottom_right_tree_view),
 941                                         row_targets,
 942                                         G_N_ELEMENTS (row_targets),
 943                                         GDK_ACTION_MOVE);
 944
 945
 946   gtk_box_pack_start (GTK_BOX (vbox), gtk_separator_new (GTK_ORIENTATION_HORIZONTAL),
 947                       FALSE, FALSE, 0);
 948
 949   hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, FALSE, 8);
 950   gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
 951   button = gtk_button_new_with_mnemonic ("_Add new Column");
 952   g_signal_connect (button, "clicked", G_CALLBACK (add_clicked), left_tree_model);
 953   gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0);
 954
 955   gtk_widget_show_all (window);
 956   gtk_main ();
 957
 958   return 0;
 959 }