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

   1 #include <string.h>
   2 #include "prop-editor.h"
   3 #include <gtk/gtk.h>
   4
   5
   6 /* Don't copy this bad example; inline RGB data is always a better
   7  * idea than inline XPMs.
   8  */
   9 static char  *book_closed_xpm[] = {
  10 "16 16 6 1",
  11 "       c None s None",
  12 ".      c black",
  13 "X      c red",
  14 "o      c yellow",
  15 "O      c #808080",
  16 "#      c white",
  17 "                ",
  18 "       ..       ",
  19 "     ..XX.      ",
  20 "   ..XXXXX.     ",
  21 " ..XXXXXXXX.    ",
  22 ".ooXXXXXXXXX.   ",
  23 "..ooXXXXXXXXX.  ",
  24 ".X.ooXXXXXXXXX. ",
  25 ".XX.ooXXXXXX..  ",
  26 " .XX.ooXXX..#O  ",
  27 "  .XX.oo..##OO. ",
  28 "   .XX..##OO..  ",
  29 "    .X.#OO..    ",
  30 "     ..O..      ",
  31 "      ..        ",
  32 "                "
  33 };
  34
  35 static void run_automated_tests (void);
  36
  37 /* This custom model is to test custom model use. */
  38
  39 #define GTK_TYPE_MODEL_TYPES                    (gtk_tree_model_types_get_type ())
  40 #define GTK_TREE_MODEL_TYPES(obj)               (GTK_CHECK_CAST ((obj), GTK_TYPE_MODEL_TYPES, GtkTreeModelTypes))
  41 #define GTK_TREE_MODEL_TYPES_CLASS(klass)       (GTK_CHECK_CLASS_CAST ((klass), GTK_TYPE_MODEL_TYPES, GtkTreeModelTypesClass))
  42 #define GTK_IS_TREE_MODEL_TYPES(obj)            (GTK_CHECK_TYPE ((obj), GTK_TYPE_MODEL_TYPES))
  43 #define GTK_IS_TREE_MODEL_TYPES_CLASS(klass)    (GTK_CHECK_CLASS_TYPE ((obj), GTK_TYPE_MODEL_TYPES))
  44
  45 typedef struct _GtkTreeModelTypes       GtkTreeModelTypes;
  46 typedef struct _GtkTreeModelTypesClass  GtkTreeModelTypesClass;
  47
  48 struct _GtkTreeModelTypes
  49 {
  50   GtkObject parent;
  51
  52   gint stamp;
  53 };
  54
  55 struct _GtkTreeModelTypesClass
  56 {
  57   GtkObjectClass parent_class;
  58
  59   guint        (* get_flags)       (GtkTreeModel *tree_model);
  60   gint         (* get_n_columns)   (GtkTreeModel *tree_model);
  61   GType        (* get_column_type) (GtkTreeModel *tree_model,
  62                                     gint          index);
  63   gboolean     (* get_iter)        (GtkTreeModel *tree_model,
  64                                     GtkTreeIter  *iter,
  65                                     GtkTreePath  *path);
  66   GtkTreePath *(* get_path)        (GtkTreeModel *tree_model,
  67                                     GtkTreeIter  *iter);
  68   void         (* get_value)       (GtkTreeModel *tree_model,
  69                                     GtkTreeIter  *iter,
  70                                     gint          column,
  71                                     GValue       *value);
  72   gboolean     (* iter_next)       (GtkTreeModel *tree_model,
  73                                     GtkTreeIter  *iter);
  74   gboolean     (* iter_children)   (GtkTreeModel *tree_model,
  75                                     GtkTreeIter  *iter,
  76                                     GtkTreeIter  *parent);
  77   gboolean     (* iter_has_child)  (GtkTreeModel *tree_model,
  78                                     GtkTreeIter  *iter);
  79   gint         (* iter_n_children) (GtkTreeModel *tree_model,
  80                                     GtkTreeIter  *iter);
  81   gboolean     (* iter_nth_child)  (GtkTreeModel *tree_model,
  82                                     GtkTreeIter  *iter,
  83                                     GtkTreeIter  *parent,
  84                                     gint          n);
  85   gboolean     (* iter_parent)     (GtkTreeModel *tree_model,
  86                                     GtkTreeIter  *iter,
  87                                     GtkTreeIter  *child);
  88   void         (* ref_iter)        (GtkTreeModel *tree_model,
  89                                     GtkTreeIter  *iter);
  90   void         (* unref_iter)      (GtkTreeModel *tree_model,
  91                                     GtkTreeIter  *iter);
  92
  93   /* These will be moved into the GtkTreeModelIface eventually */
  94   void         (* changed)         (GtkTreeModel *tree_model,
  95                                     GtkTreePath  *path,
  96                                     GtkTreeIter  *iter);
  97   void         (* inserted)        (GtkTreeModel *tree_model,
  98                                     GtkTreePath  *path,
  99                                     GtkTreeIter  *iter);
 100   void         (* child_toggled)   (GtkTreeModel *tree_model,
 101                                     GtkTreePath  *path,
 102                                     GtkTreeIter  *iter);
 103   void         (* deleted)         (GtkTreeModel *tree_model,
 104                                     GtkTreePath  *path);
 105 };
 106
 107 GtkType             gtk_tree_model_types_get_type      (void);
 108 GtkTreeModelTypes *gtk_tree_model_types_new           (void);
 109
 110 typedef enum
 111 {
 112   COLUMNS_NONE,
 113   COLUMNS_ONE,
 114   COLUMNS_LOTS,
 115   COLUMNS_LAST
 116 } ColumnsType;
 117
 118 static gchar *column_type_names[] = {
 119   "No columns",
 120   "One column",
 121   "Many columns"
 122 };
 123
 124 #define N_COLUMNS 9
 125
 126 static GType*
 127 get_model_types (void)
 128 {
 129   static GType column_types[N_COLUMNS] = { 0 };
 130
 131   if (column_types[0] == 0)
 132     {
 133       column_types[0] = G_TYPE_STRING;
 134       column_types[1] = G_TYPE_STRING;
 135       column_types[2] = GDK_TYPE_PIXBUF;
 136       column_types[3] = G_TYPE_FLOAT;
 137       column_types[4] = G_TYPE_UINT;
 138       column_types[5] = G_TYPE_UCHAR;
 139       column_types[6] = G_TYPE_CHAR;
 140 #define BOOL_COLUMN 7
 141       column_types[BOOL_COLUMN] = G_TYPE_BOOLEAN;
 142       column_types[8] = G_TYPE_INT;
 143     }
 144
 145   return column_types;
 146 }
 147
 148 static void
 149 col_clicked_cb (GtkTreeViewColumn *col, gpointer data)
 150 {
 151   GtkWindow *win;
 152
 153   win = GTK_WINDOW (create_prop_editor (G_OBJECT (col), GTK_TYPE_TREE_VIEW_COLUMN));
 154
 155   gtk_window_set_title (win, gtk_tree_view_column_get_title (col));
 156 }
 157
 158 static void
 159 setup_column (GtkTreeViewColumn *col)
 160 {
 161   gtk_tree_view_column_set_clickable (col, TRUE);
 162   g_signal_connect (G_OBJECT (col),
 163                     "clicked",
 164                     (GCallback) col_clicked_cb,
 165                     NULL);
 166 }
 167
 168 static void
 169 toggled_callback (GtkCellRendererToggle *celltoggle,
 170                   gchar                 *path_string,
 171                   GtkTreeView           *tree_view)
 172 {
 173   GtkTreeModel *model = NULL;
 174   GtkTreeModelSort *sort_model = NULL;
 175   GtkTreePath *path;
 176   GtkTreeIter iter;
 177   gboolean active = FALSE;
 178
 179   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
 180
 181   model = gtk_tree_view_get_model (tree_view);
 182
 183   if (GTK_IS_TREE_MODEL_SORT (model))
 184     {
 185       sort_model = GTK_TREE_MODEL_SORT (model);
 186       model = gtk_tree_model_sort_get_model (sort_model);
 187     }
 188
 189   if (model == NULL)
 190     return;
 191
 192   if (sort_model)
 193     {
 194       g_warning ("FIXME implement conversion from TreeModelSort iter to child model iter");
 195       return;
 196     }
 197
 198   path = gtk_tree_path_new_from_string (path_string);
 199   if (!gtk_tree_model_get_iter (model,
 200                                 &iter, path))
 201     {
 202       g_warning ("%s: bad path?", G_STRLOC);
 203       return;
 204     }
 205   gtk_tree_path_free (path);
 206
 207   if (GTK_IS_LIST_STORE (model))
 208     {
 209       gtk_tree_model_get (GTK_TREE_MODEL (model),
 210                           &iter,
 211                           BOOL_COLUMN,
 212                           &active,
 213                           -1);
 214
 215       gtk_list_store_set (GTK_LIST_STORE (model),
 216                           &iter,
 217                           BOOL_COLUMN,
 218                           !active,
 219                           -1);
 220     }
 221   else if (GTK_IS_TREE_STORE (model))
 222     {
 223       gtk_tree_model_get (GTK_TREE_MODEL (model),
 224                           &iter,
 225                           BOOL_COLUMN,
 226                           &active,
 227                           -1);
 228
 229       gtk_tree_store_set (GTK_TREE_STORE (model),
 230                           &iter,
 231                           BOOL_COLUMN,
 232                           !active,
 233                           -1);
 234     }
 235   else
 236     g_warning ("don't know how to actually toggle value for model type %s",
 237                g_type_name (G_TYPE_FROM_INSTANCE (model)));
 238 }
 239
 240
 241 static ColumnsType current_column_type = COLUMNS_LOTS;
 242
 243 static void
 244 set_columns_type (GtkTreeView *tree_view, ColumnsType type)
 245 {
 246   GtkTreeViewColumn *col;
 247   GtkCellRenderer *rend;
 248   GdkPixbuf *pixbuf;
 249   GtkWidget *image;
 250
 251   current_column_type = type;
 252
 253   col = gtk_tree_view_get_column (tree_view, 0);
 254   while (col)
 255     {
 256       gtk_tree_view_remove_column (tree_view, col);
 257
 258       col = gtk_tree_view_get_column (tree_view, 0);
 259     }
 260
 261   gtk_tree_view_set_rules_hint (tree_view, FALSE);
 262
 263   switch (type)
 264     {
 265     case COLUMNS_NONE:
 266       break;
 267
 268     case COLUMNS_LOTS:
 269       /* with lots of columns we need to turn on rules */
 270       gtk_tree_view_set_rules_hint (tree_view, TRUE);
 271
 272       rend = gtk_cell_renderer_text_new ();
 273
 274       col = gtk_tree_view_column_new_with_attributes ("Column 1",
 275                                                       rend,
 276                                                       "text", 1,
 277                                                       NULL);
 278       setup_column (col);
 279
 280       gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), col);
 281
 282       rend = gtk_cell_renderer_text_pixbuf_new ();
 283
 284       col = gtk_tree_view_column_new_with_attributes ("Column 2",
 285                                                       rend,
 286                                                       "text", 0,
 287                                                       "pixbuf", 2,
 288                                                       NULL);
 289
 290       setup_column (col);
 291
 292
 293       gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), col);
 294       gtk_tree_view_set_expander_column (tree_view, col);
 295
 296       rend = gtk_cell_renderer_toggle_new ();
 297
 298       g_signal_connect (G_OBJECT (rend), "toggled",
 299                         GTK_SIGNAL_FUNC (toggled_callback), tree_view);
 300
 301       col = gtk_tree_view_column_new_with_attributes ("Column 3",
 302                                                       rend,
 303                                                       "active", BOOL_COLUMN,
 304                                                       NULL);
 305
 306       setup_column (col);
 307
 308       gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), col);
 309
 310       pixbuf = gdk_pixbuf_new_from_xpm_data ((const char **)book_closed_xpm);
 311
 312       image = gtk_image_new_from_pixbuf (pixbuf);
 313
 314       g_object_unref (G_OBJECT (pixbuf));
 315
 316       gtk_widget_show (image);
 317
 318       gtk_tree_view_column_set_widget (col, image);
 319
 320       rend = gtk_cell_renderer_toggle_new ();
 321
 322       /* you could also set this per-row by tying it to a column
 323        * in the model of course.
 324        */
 325       g_object_set (G_OBJECT (rend), "radio", TRUE, NULL);
 326
 327       g_signal_connect (G_OBJECT (rend), "toggled",
 328                         G_CALLBACK (toggled_callback), tree_view);
 329
 330       col = gtk_tree_view_column_new_with_attributes ("Column 4",
 331                                                       rend,
 332                                                       "active", BOOL_COLUMN,
 333                                                       NULL);
 334
 335       setup_column (col);
 336
 337       gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), col);
 338
 339 #if 0
 340
 341       rend = gtk_cell_renderer_text_new ();
 342
 343       col = gtk_tree_view_column_new_with_attributes ("Column 5",
 344                                                       rend,
 345                                                       "text", 3,
 346                                                       NULL);
 347
 348       setup_column (col);
 349
 350       gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), col);
 351
 352       rend = gtk_cell_renderer_text_new ();
 353
 354       col = gtk_tree_view_column_new_with_attributes ("Column 6",
 355                                                       rend,
 356                                                       "text", 4,
 357                                                       NULL);
 358
 359       setup_column (col);
 360
 361       gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), col);
 362
 363       rend = gtk_cell_renderer_text_new ();
 364
 365       col = gtk_tree_view_column_new_with_attributes ("Column 7",
 366                                                       rend,
 367                                                       "text", 5,
 368                                                       NULL);
 369
 370       setup_column (col);
 371
 372       gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), col);
 373
 374       rend = gtk_cell_renderer_text_new ();
 375
 376       col = gtk_tree_view_column_new_with_attributes ("Column 8",
 377                                                       rend,
 378                                                       "text", 6,
 379                                                       NULL);
 380
 381       setup_column (col);
 382
 383       gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), col);
 384
 385       rend = gtk_cell_renderer_text_new ();
 386
 387       col = gtk_tree_view_column_new_with_attributes ("Column 9",
 388                                                       rend,
 389                                                       "text", 7,
 390                                                       NULL);
 391
 392       setup_column (col);
 393
 394       gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), col);
 395
 396       rend = gtk_cell_renderer_text_new ();
 397
 398       col = gtk_tree_view_column_new_with_attributes ("Column 10",
 399                                                       rend,
 400                                                       "text", 8,
 401                                                       NULL);
 402
 403       setup_column (col);
 404
 405       gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), col);
 406
 407 #endif
 408
 409       /* FALL THRU */
 410
 411     case COLUMNS_ONE:
 412       rend = gtk_cell_renderer_text_new ();
 413
 414       col = gtk_tree_view_column_new_with_attributes ("Column 0",
 415                                                       rend,
 416                                                       "text", 0,
 417                                                       NULL);
 418
 419       setup_column (col);
 420
 421       gtk_tree_view_insert_column (GTK_TREE_VIEW (tree_view), col, 0);
 422     default:
 423       break;
 424     }
 425 }
 426
 427 static ColumnsType
 428 get_columns_type (void)
 429 {
 430   return current_column_type;
 431 }
 432
 433 static GdkPixbuf *our_pixbuf;
 434
 435 typedef enum
 436 {
 437   /*   MODEL_TYPES, */
 438   MODEL_TREE,
 439   MODEL_LIST,
 440   MODEL_SORTED_TREE,
 441   MODEL_SORTED_LIST,
 442   MODEL_EMPTY_LIST,
 443   MODEL_EMPTY_TREE,
 444   MODEL_NULL,
 445   MODEL_LAST
 446 } ModelType;
 447
 448 /* FIXME add a custom model to test */
 449 static GtkTreeModel *models[MODEL_LAST];
 450 static const char *model_names[MODEL_LAST] = {
 451   "GtkTreeStore",
 452   "GtkListStore",
 453   "GtkTreeModelSort wrapping GtkTreeStore",
 454   "GtkTreeModelSort wrapping GtkListStore",
 455   "Empty GtkListStore",
 456   "Empty GtkTreeStore",
 457   "NULL (no model)"
 458 };
 459
 460 static GtkTreeModel*
 461 create_list_model (void)
 462 {
 463   GtkListStore *store;
 464   GtkTreeIter iter;
 465   gint i;
 466   GType *t;
 467
 468   t = get_model_types ();
 469
 470   store = gtk_list_store_new (N_COLUMNS,
 471                               t[0], t[1], t[2],
 472                               t[3], t[4], t[5],
 473                               t[6], t[7], t[8]);
 474
 475   i = 0;
 476   while (i < 200)
 477     {
 478       char *msg;
 479
 480       gtk_list_store_append (store, &iter);
 481
 482       msg = g_strdup_printf ("%d", i);
 483
 484       gtk_list_store_set (store, &iter, 0, msg, 1, "Foo! Foo! Foo!",
 485                           2, our_pixbuf,
 486                           3, 7.0, 4, (guint) 9000,
 487                           5, 'f', 6, 'g',
 488                           7, TRUE, 8, 23245454,
 489                           -1);
 490
 491       g_free (msg);
 492
 493       ++i;
 494     }
 495
 496   return GTK_TREE_MODEL (store);
 497 }
 498
 499 static void
 500 typesystem_recurse (GType        type,
 501                     GtkTreeIter *parent_iter,
 502                     GtkTreeStore *store)
 503 {
 504   GType* children;
 505   guint n_children = 0;
 506   gint i;
 507   GtkTreeIter iter;
 508   gchar *str;
 509
 510   gtk_tree_store_append (store, &iter, parent_iter);
 511
 512   str = g_strdup_printf ("%d", type);
 513   gtk_tree_store_set (store, &iter, 0, str, 1, g_type_name (type),
 514                       2, our_pixbuf,
 515                       3, 7.0, 4, (guint) 9000,
 516                       5, 'f', 6, 'g',
 517                       7, TRUE, 8, 23245454,
 518                       -1);
 519   g_free (str);
 520
 521   children = g_type_children (type, &n_children);
 522
 523   i = 0;
 524   while (i < n_children)
 525     {
 526       typesystem_recurse (children[i], &iter, store);
 527
 528       ++i;
 529     }
 530
 531   g_free (children);
 532 }
 533
 534 static GtkTreeModel*
 535 create_tree_model (void)
 536 {
 537   GtkTreeStore *store;
 538   gint i;
 539   GType *t;
 540   volatile GType dummy; /* G_GNUC_CONST makes the optimizer remove
 541                          * get_type calls if you don't do something
 542                          * like this
 543                          */
 544
 545   /* Make the tree more interesting */
 546   dummy = gtk_scrolled_window_get_type ();
 547   dummy = gtk_label_get_type ();
 548   dummy = gtk_hscrollbar_get_type ();
 549   dummy = gtk_vscrollbar_get_type ();
 550   dummy = pango_layout_get_type ();
 551
 552   t = get_model_types ();
 553
 554   store = gtk_tree_store_new (N_COLUMNS,
 555                               t[0], t[1], t[2],
 556                               t[3], t[4], t[5],
 557                               t[6], t[7], t[8]);
 558
 559   i = 0;
 560   while (i < G_TYPE_RESERVED_LAST_FUNDAMENTAL)
 561     {
 562       typesystem_recurse (i, NULL, store);
 563
 564       ++i;
 565     }
 566
 567   return GTK_TREE_MODEL (store);
 568 }
 569
 570 static void
 571 model_selected (GtkOptionMenu *om, gpointer data)
 572 {
 573   GtkTreeView *tree_view = GTK_TREE_VIEW (data);
 574   gint hist;
 575
 576   hist = gtk_option_menu_get_history (om);
 577
 578   if (models[hist] != gtk_tree_view_get_model (tree_view))
 579     {
 580       gtk_tree_view_set_model (tree_view, models[hist]);
 581     }
 582 }
 583
 584 static void
 585 columns_selected (GtkOptionMenu *om, gpointer data)
 586 {
 587   GtkTreeView *tree_view = GTK_TREE_VIEW (data);
 588   gint hist;
 589
 590   hist = gtk_option_menu_get_history (om);
 591
 592   if (hist != get_columns_type ())
 593     {
 594       set_columns_type (tree_view, hist);
 595     }
 596 }
 597
 598
 599 enum
 600 {
 601   TARGET_GTK_TREE_MODEL_ROW
 602 };
 603
 604 static GtkTargetEntry row_targets[] = {
 605   { "GTK_TREE_MODEL_ROW", GTK_TARGET_SAME_APP,
 606     TARGET_GTK_TREE_MODEL_ROW }
 607 };
 608
 609 int
 610 main (int    argc,
 611       char **argv)
 612 {
 613   GtkWidget *window;
 614   GtkWidget *sw;
 615   GtkWidget *tv;
 616   GtkWidget *table;
 617   GtkWidget *om;
 618   GtkWidget *menu;
 619   GtkTreeModel *model;
 620   gint i;
 621
 622   gtk_init (&argc, &argv);
 623
 624   our_pixbuf = gdk_pixbuf_new_from_xpm_data ((const char **) book_closed_xpm);
 625
 626 #if 0
 627   models[MODEL_TYPES] = GTK_TREE_MODEL (gtk_tree_model_types_new ());
 628 #endif
 629   models[MODEL_LIST] = create_list_model ();
 630   models[MODEL_TREE] = create_tree_model ();
 631
 632   model = create_list_model ();
 633   models[MODEL_SORTED_LIST] = gtk_tree_model_sort_new_with_model (model);
 634   g_object_unref (G_OBJECT (model));
 635
 636   model = create_tree_model ();
 637   models[MODEL_SORTED_TREE] = gtk_tree_model_sort_new_with_model (model);
 638   g_object_unref (G_OBJECT (model));
 639
 640   models[MODEL_EMPTY_LIST] = GTK_TREE_MODEL (gtk_list_store_new (1, G_TYPE_INT));
 641   models[MODEL_EMPTY_TREE] = GTK_TREE_MODEL (gtk_tree_store_new (1, G_TYPE_INT));
 642
 643   models[MODEL_NULL] = NULL;
 644
 645   run_automated_tests ();
 646
 647   window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 648
 649   gtk_window_set_default_size (GTK_WINDOW (window), 400, 400);
 650
 651   table = gtk_table_new (3, 1, FALSE);
 652
 653   gtk_container_add (GTK_CONTAINER (window), table);
 654
 655   tv = gtk_tree_view_new_with_model (models[0]);
 656
 657   gtk_tree_view_set_rows_drag_source (GTK_TREE_VIEW (tv),
 658                                       GDK_BUTTON1_MASK,
 659                                       row_targets,
 660                                       G_N_ELEMENTS (row_targets),
 661                                       GDK_ACTION_MOVE | GDK_ACTION_COPY,
 662                                       NULL, NULL);
 663
 664   gtk_tree_view_set_rows_drag_dest (GTK_TREE_VIEW (tv),
 665                                     row_targets,
 666                                     G_N_ELEMENTS (row_targets),
 667                                     GDK_ACTION_MOVE | GDK_ACTION_COPY,
 668                                     NULL, NULL);
 669
 670   /* Model menu */
 671
 672   menu = gtk_menu_new ();
 673
 674   i = 0;
 675   while (i < MODEL_LAST)
 676     {
 677       GtkWidget *mi;
 678       const char *name;
 679
 680       name = model_names[i];
 681
 682       mi = gtk_menu_item_new_with_label (name);
 683
 684       gtk_menu_shell_append (GTK_MENU_SHELL (menu), mi);
 685
 686 #if 0
 687       window = create_prop_editor (G_OBJECT (models[i]));
 688
 689       gtk_window_set_title (GTK_WINDOW (window),
 690                             name);
 691 #endif
 692
 693       ++i;
 694     }
 695   gtk_widget_show_all (menu);
 696
 697   om = gtk_option_menu_new ();
 698   gtk_option_menu_set_menu (GTK_OPTION_MENU (om), menu);
 699
 700   gtk_table_attach (GTK_TABLE (table), om,
 701                     0, 1, 0, 1,
 702                     0, 0,
 703                     0, 0);
 704
 705   gtk_signal_connect (GTK_OBJECT (om),
 706                       "changed",
 707                       GTK_SIGNAL_FUNC (model_selected),
 708                       tv);
 709
 710   /* Columns menu */
 711
 712   menu = gtk_menu_new ();
 713
 714   i = 0;
 715   while (i < COLUMNS_LAST)
 716     {
 717       GtkWidget *mi;
 718       const char *name;
 719
 720       name = column_type_names[i];
 721
 722       mi = gtk_menu_item_new_with_label (name);
 723
 724       gtk_menu_shell_append (GTK_MENU_SHELL (menu), mi);
 725
 726       ++i;
 727     }
 728   gtk_widget_show_all (menu);
 729
 730   om = gtk_option_menu_new ();
 731   gtk_option_menu_set_menu (GTK_OPTION_MENU (om), menu);
 732
 733   gtk_table_attach (GTK_TABLE (table), om,
 734                     0, 1, 1, 2,
 735                     0, 0,
 736                     0, 0);
 737
 738   set_columns_type (GTK_TREE_VIEW (tv), COLUMNS_LOTS);
 739   gtk_option_menu_set_history (GTK_OPTION_MENU (om), COLUMNS_LOTS);
 740
 741   gtk_signal_connect (GTK_OBJECT (om),
 742                       "changed",
 743                       GTK_SIGNAL_FUNC (columns_selected),
 744                       tv);
 745
 746   sw = gtk_scrolled_window_new (NULL, NULL);
 747   gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
 748                                   GTK_POLICY_AUTOMATIC,
 749                                   GTK_POLICY_AUTOMATIC);
 750
 751   gtk_table_attach (GTK_TABLE (table), sw,
 752                     0, 1, 2, 3,
 753                     GTK_EXPAND | GTK_FILL,
 754                     GTK_EXPAND | GTK_FILL,
 755                     0, 0);
 756
 757   gtk_container_add (GTK_CONTAINER (sw), tv);
 758
 759   gtk_widget_show_all (window);
 760
 761   gtk_main ();
 762
 763   return 0;
 764 }
 765
 766 /*
 767  * GtkTreeModelTypes
 768  */
 769
 770 enum {
 771   CHANGED,
 772   INSERTED,
 773   CHILD_TOGGLED,
 774   DELETED,
 775
 776   LAST_SIGNAL
 777 };
 778
 779 static void         gtk_tree_model_types_init                 (GtkTreeModelTypes      *model_types);
 780 static void         gtk_tree_model_types_class_init           (GtkTreeModelTypesClass *class);
 781 static void         gtk_tree_model_types_tree_model_init      (GtkTreeModelIface   *iface);
 782 static gint         gtk_real_model_types_get_n_columns   (GtkTreeModel        *tree_model);
 783 static GType        gtk_real_model_types_get_column_type (GtkTreeModel        *tree_model,
 784                                                            gint                 index);
 785 static GtkTreePath *gtk_real_model_types_get_path        (GtkTreeModel        *tree_model,
 786                                                            GtkTreeIter         *iter);
 787 static void         gtk_real_model_types_get_value       (GtkTreeModel        *tree_model,
 788                                                            GtkTreeIter         *iter,
 789                                                            gint                 column,
 790                                                            GValue              *value);
 791 static gboolean     gtk_real_model_types_iter_next       (GtkTreeModel        *tree_model,
 792                                                            GtkTreeIter         *iter);
 793 static gboolean     gtk_real_model_types_iter_children   (GtkTreeModel        *tree_model,
 794                                                            GtkTreeIter         *iter,
 795                                                            GtkTreeIter         *parent);
 796 static gboolean     gtk_real_model_types_iter_has_child  (GtkTreeModel        *tree_model,
 797                                                            GtkTreeIter         *iter);
 798 static gint         gtk_real_model_types_iter_n_children (GtkTreeModel        *tree_model,
 799                                                            GtkTreeIter         *iter);
 800 static gboolean     gtk_real_model_types_iter_nth_child  (GtkTreeModel        *tree_model,
 801                                                            GtkTreeIter         *iter,
 802                                                            GtkTreeIter         *parent,
 803                                                            gint                 n);
 804 static gboolean     gtk_real_model_types_iter_parent     (GtkTreeModel        *tree_model,
 805                                                            GtkTreeIter         *iter,
 806                                                            GtkTreeIter         *child);
 807
 808
 809 static guint model_types_signals[LAST_SIGNAL] = { 0 };
 810
 811
 812 GtkType
 813 gtk_tree_model_types_get_type (void)
 814 {
 815   static GtkType model_types_type = 0;
 816
 817   if (!model_types_type)
 818     {
 819       static const GTypeInfo model_types_info =
 820       {
 821         sizeof (GtkTreeModelTypesClass),
 822         NULL,           /* base_init */
 823         NULL,           /* base_finalize */
 824         (GClassInitFunc) gtk_tree_model_types_class_init,
 825         NULL,           /* class_finalize */
 826         NULL,           /* class_data */
 827         sizeof (GtkTreeModelTypes),
 828         0,
 829         (GInstanceInitFunc) gtk_tree_model_types_init
 830       };
 831
 832       static const GInterfaceInfo tree_model_info =
 833       {
 834         (GInterfaceInitFunc) gtk_tree_model_types_tree_model_init,
 835         NULL,
 836         NULL
 837       };
 838
 839       model_types_type = g_type_register_static (GTK_TYPE_OBJECT, "GtkTreeModelTypes", &model_types_info, 0);
 840       g_type_add_interface_static (model_types_type,
 841                                    GTK_TYPE_TREE_MODEL,
 842                                    &tree_model_info);
 843     }
 844
 845   return model_types_type;
 846 }
 847
 848 GtkTreeModelTypes *
 849 gtk_tree_model_types_new (void)
 850 {
 851   GtkTreeModelTypes *retval;
 852
 853   retval = GTK_TREE_MODEL_TYPES (g_object_new (GTK_TYPE_MODEL_TYPES, NULL));
 854
 855   return retval;
 856 }
 857
 858 static void
 859 gtk_tree_model_types_class_init (GtkTreeModelTypesClass *class)
 860 {
 861   GObjectClass *object_class;
 862
 863   object_class = (GObjectClass*) class;
 864
 865   model_types_signals[CHANGED] =
 866     g_signal_new ("changed",
 867                   GTK_CLASS_TYPE (object_class),
 868                   G_SIGNAL_RUN_FIRST,
 869                   GTK_SIGNAL_OFFSET (GtkTreeModelTypesClass, changed),
 870                   NULL, NULL,
 871                   gtk_marshal_VOID__BOXED_BOXED,
 872                   G_TYPE_NONE, 2,
 873                   G_TYPE_POINTER,
 874                   G_TYPE_POINTER);
 875   model_types_signals[INSERTED] =
 876     g_signal_new ("inserted",
 877                   GTK_CLASS_TYPE (object_class),
 878                   G_SIGNAL_RUN_FIRST,
 879                   GTK_SIGNAL_OFFSET (GtkTreeModelTypesClass, inserted),
 880                   NULL, NULL,
 881                   gtk_marshal_VOID__BOXED_BOXED,
 882                   G_TYPE_NONE, 2,
 883                   G_TYPE_POINTER,
 884                   G_TYPE_POINTER);
 885   model_types_signals[CHILD_TOGGLED] =
 886     g_signal_new ("child_toggled",
 887                   GTK_CLASS_TYPE (object_class),
 888                   G_SIGNAL_RUN_FIRST,
 889                   GTK_SIGNAL_OFFSET (GtkTreeModelTypesClass, child_toggled),
 890                   NULL, NULL,
 891                   gtk_marshal_VOID__BOXED_BOXED,
 892                   G_TYPE_NONE, 2,
 893                   G_TYPE_POINTER,
 894                   G_TYPE_POINTER);
 895   model_types_signals[DELETED] =
 896     g_signal_new ("deleted",
 897                   GTK_CLASS_TYPE (object_class),
 898                   G_SIGNAL_RUN_FIRST,
 899                   GTK_SIGNAL_OFFSET (GtkTreeModelTypesClass, deleted),
 900                   NULL, NULL,
 901                   gtk_marshal_VOID__BOXED,
 902                   G_TYPE_NONE, 1,
 903                   G_TYPE_POINTER);
 904 }
 905
 906 static void
 907 gtk_tree_model_types_tree_model_init (GtkTreeModelIface *iface)
 908 {
 909   iface->get_n_columns = gtk_real_model_types_get_n_columns;
 910   iface->get_column_type = gtk_real_model_types_get_column_type;
 911   iface->get_path = gtk_real_model_types_get_path;
 912   iface->get_value = gtk_real_model_types_get_value;
 913   iface->iter_next = gtk_real_model_types_iter_next;
 914   iface->iter_children = gtk_real_model_types_iter_children;
 915   iface->iter_has_child = gtk_real_model_types_iter_has_child;
 916   iface->iter_n_children = gtk_real_model_types_iter_n_children;
 917   iface->iter_nth_child = gtk_real_model_types_iter_nth_child;
 918   iface->iter_parent = gtk_real_model_types_iter_parent;
 919 }
 920
 921 static void
 922 gtk_tree_model_types_init (GtkTreeModelTypes *model_types)
 923 {
 924   model_types->stamp = g_random_int ();
 925 }
 926
 927 static GType column_types[] = {
 928   G_TYPE_STRING, /* GType */
 929   G_TYPE_STRING  /* type name */
 930 };
 931
 932 static gint
 933 gtk_real_model_types_get_n_columns (GtkTreeModel *tree_model)
 934 {
 935   return G_N_ELEMENTS (column_types);
 936 }
 937
 938 static GType
 939 gtk_real_model_types_get_column_type (GtkTreeModel *tree_model,
 940                                       gint          index)
 941 {
 942   g_return_val_if_fail (index < G_N_ELEMENTS (column_types), G_TYPE_INVALID);
 943
 944   return column_types[index];
 945 }
 946
 947 #if 0
 948 /* Use default implementation of this */
 949 static gboolean
 950 gtk_real_model_types_get_iter (GtkTreeModel *tree_model,
 951                                GtkTreeIter  *iter,
 952                                GtkTreePath  *path)
 953 {
 954
 955 }
 956 #endif
 957
 958 /* The toplevel nodes of the tree are the reserved types, G_TYPE_NONE through
 959  * G_TYPE_RESERVED_FUNDAMENTAL.
 960  */
 961
 962 static GtkTreePath *
 963 gtk_real_model_types_get_path (GtkTreeModel *tree_model,
 964                                GtkTreeIter  *iter)
 965 {
 966   GtkTreePath *retval;
 967   GType type;
 968   GType parent;
 969
 970   g_return_val_if_fail (GTK_IS_TREE_MODEL_TYPES (tree_model), NULL);
 971   g_return_val_if_fail (iter != NULL, NULL);
 972
 973   type = GPOINTER_TO_INT (iter->user_data);
 974
 975   retval = gtk_tree_path_new ();
 976
 977   parent = g_type_parent (type);
 978   while (parent != G_TYPE_INVALID)
 979     {
 980       GType* children = g_type_children (parent, NULL);
 981       gint i = 0;
 982
 983       if (!children || children[0] == G_TYPE_INVALID)
 984         {
 985           g_warning ("bad iterator?");
 986           return NULL;
 987         }
 988
 989       while (children[i] != type)
 990         ++i;
 991
 992       gtk_tree_path_prepend_index (retval, i);
 993
 994       g_free (children);
 995
 996       type = parent;
 997       parent = g_type_parent (parent);
 998     }
 999
1000   /* The fundamental type itself is the index on the toplevel */
1001   gtk_tree_path_prepend_index (retval, type);
1002
1003   return retval;
1004 }
1005
1006 static void
1007 gtk_real_model_types_get_value (GtkTreeModel *tree_model,
1008                                 GtkTreeIter  *iter,
1009                                 gint          column,
1010                                 GValue       *value)
1011 {
1012   GType type;
1013
1014   type = GPOINTER_TO_INT (iter->user_data);
1015
1016   switch (column)
1017     {
1018     case 0:
1019       {
1020         gchar *str;
1021
1022         g_value_init (value, G_TYPE_STRING);
1023
1024         str = g_strdup_printf ("%d", type);
1025         g_value_set_string (value, str);
1026         g_free (str);
1027       }
1028       break;
1029
1030     case 1:
1031       g_value_init (value, G_TYPE_STRING);
1032       g_value_set_string (value, g_type_name (type));
1033       break;
1034
1035     default:
1036       g_warning ("Bad column %d requested", column);
1037     }
1038 }
1039
1040 static gboolean
1041 gtk_real_model_types_iter_next (GtkTreeModel  *tree_model,
1042                                 GtkTreeIter   *iter)
1043 {
1044
1045   GType parent;
1046   GType type;
1047
1048   type = GPOINTER_TO_INT (iter->user_data);
1049
1050   parent = g_type_parent (type);
1051
1052   if (parent == G_TYPE_INVALID)
1053     {
1054       /* fundamental type, add 1 */
1055       if ((type + 1) < G_TYPE_RESERVED_LAST_FUNDAMENTAL)
1056         {
1057           iter->user_data = GINT_TO_POINTER (type + 1);
1058           return TRUE;
1059         }
1060       else
1061         return FALSE;
1062     }
1063   else
1064     {
1065       GType* children = g_type_children (parent, NULL);
1066       gint i = 0;
1067
1068       g_assert (children != NULL);
1069
1070       while (children[i] != type)
1071         ++i;
1072
1073       ++i;
1074
1075       if (children[i] != G_TYPE_INVALID)
1076         {
1077           g_free (children);
1078           iter->user_data = GINT_TO_POINTER (children[i]);
1079           return TRUE;
1080         }
1081       else
1082         {
1083           g_free (children);
1084           return FALSE;
1085         }
1086     }
1087 }
1088
1089 static gboolean
1090 gtk_real_model_types_iter_children (GtkTreeModel *tree_model,
1091                                     GtkTreeIter  *iter,
1092                                     GtkTreeIter  *parent)
1093 {
1094   GType type;
1095   GType* children;
1096
1097   type = GPOINTER_TO_INT (parent->user_data);
1098
1099   children = g_type_children (type, NULL);
1100
1101   if (!children || children[0] == G_TYPE_INVALID)
1102     {
1103       g_free (children);
1104       return FALSE;
1105     }
1106   else
1107     {
1108       iter->user_data = GINT_TO_POINTER (children[0]);
1109       g_free (children);
1110       return TRUE;
1111     }
1112 }
1113
1114 static gboolean
1115 gtk_real_model_types_iter_has_child (GtkTreeModel *tree_model,
1116                                      GtkTreeIter  *iter)
1117 {
1118   GType type;
1119   GType* children;
1120
1121   type = GPOINTER_TO_INT (iter->user_data);
1122
1123   children = g_type_children (type, NULL);
1124
1125   if (!children || children[0] == G_TYPE_INVALID)
1126     {
1127       g_free (children);
1128       return FALSE;
1129     }
1130   else
1131     {
1132       g_free (children);
1133       return TRUE;
1134     }
1135 }
1136
1137 static gint
1138 gtk_real_model_types_iter_n_children (GtkTreeModel *tree_model,
1139                                       GtkTreeIter  *iter)
1140 {
1141   if (iter == NULL)
1142     {
1143       return G_TYPE_RESERVED_LAST_FUNDAMENTAL - 1;
1144     }
1145   else
1146     {
1147       GType type;
1148       GType* children;
1149       guint n_children = 0;
1150
1151       type = GPOINTER_TO_INT (iter->user_data);
1152
1153       children = g_type_children (type, &n_children);
1154
1155       g_free (children);
1156
1157       return n_children;
1158     }
1159 }
1160
1161 static gboolean
1162 gtk_real_model_types_iter_nth_child (GtkTreeModel *tree_model,
1163                                      GtkTreeIter  *iter,
1164                                      GtkTreeIter  *parent,
1165                                      gint          n)
1166 {
1167   if (parent == NULL)
1168     {
1169       /* fundamental type */
1170       if (n < G_TYPE_RESERVED_LAST_FUNDAMENTAL)
1171         {
1172           iter->user_data = GINT_TO_POINTER (n);
1173           return TRUE;
1174         }
1175       else
1176         return FALSE;
1177     }
1178   else
1179     {
1180       GType type = GPOINTER_TO_INT (parent->user_data);
1181       guint n_children = 0;
1182       GType* children = g_type_children (type, &n_children);
1183
1184       if (n_children == 0)
1185         {
1186           g_free (children);
1187           return FALSE;
1188         }
1189       else if (n >= n_children)
1190         {
1191           g_free (children);
1192           return FALSE;
1193         }
1194       else
1195         {
1196           iter->user_data = GINT_TO_POINTER (children[n]);
1197           g_free (children);
1198
1199           return TRUE;
1200         }
1201     }
1202 }
1203
1204 static gboolean
1205 gtk_real_model_types_iter_parent (GtkTreeModel *tree_model,
1206                                   GtkTreeIter  *iter,
1207                                   GtkTreeIter  *child)
1208 {
1209   GType type;
1210   GType parent;
1211
1212   type = GPOINTER_TO_INT (child->user_data);
1213
1214   parent = g_type_parent (type);
1215
1216   if (parent == G_TYPE_INVALID)
1217     {
1218       if (type >= G_TYPE_RESERVED_LAST_FUNDAMENTAL)
1219         g_warning ("no parent for %d %s\n", type, g_type_name (type));
1220       return FALSE;
1221     }
1222   else
1223     {
1224       iter->user_data = GINT_TO_POINTER (parent);
1225
1226       return TRUE;
1227     }
1228 }
1229
1230 /*
1231  * Automated testing
1232  */
1233
1234 static void
1235 treestore_torture_recurse (GtkTreeStore *store,
1236                            GtkTreeIter  *root,
1237                            gint          depth)
1238 {
1239   GtkTreeModel *model;
1240   gint i;
1241   GtkTreeIter iter;
1242
1243   model = GTK_TREE_MODEL (store);
1244
1245   if (depth > 2)
1246     return;
1247
1248   ++depth;
1249
1250   gtk_tree_store_append (store, &iter, root);
1251
1252   gtk_tree_model_iter_children (model, &iter, root);
1253
1254   i = 0;
1255   while (i < 100)
1256     {
1257       gtk_tree_store_append (store, &iter, root);
1258       ++i;
1259     }
1260
1261   while (gtk_tree_model_iter_children (model, &iter, root))
1262     gtk_tree_store_remove (store, &iter);
1263
1264   gtk_tree_store_append (store, &iter, root);
1265
1266   /* inserts before last node in tree */
1267   i = 0;
1268   while (i < 100)
1269     {
1270       gtk_tree_store_insert_before (store, &iter, root, &iter);
1271       ++i;
1272     }
1273
1274   /* inserts after the node before the last node */
1275   i = 0;
1276   while (i < 100)
1277     {
1278       gtk_tree_store_insert_after (store, &iter, root, &iter);
1279       ++i;
1280     }
1281
1282   /* inserts after the last node */
1283   gtk_tree_store_append (store, &iter, root);
1284
1285   i = 0;
1286   while (i < 100)
1287     {
1288       gtk_tree_store_insert_after (store, &iter, root, &iter);
1289       ++i;
1290     }
1291
1292   /* remove everything again */
1293   while (gtk_tree_model_iter_children (model, &iter, root))
1294     gtk_tree_store_remove (store, &iter);
1295
1296
1297     /* Prepends */
1298   gtk_tree_store_prepend (store, &iter, root);
1299
1300   i = 0;
1301   while (i < 100)
1302     {
1303       gtk_tree_store_prepend (store, &iter, root);
1304       ++i;
1305     }
1306
1307   /* remove everything again */
1308   while (gtk_tree_model_iter_children (model, &iter, root))
1309     gtk_tree_store_remove (store, &iter);
1310
1311   gtk_tree_store_append (store, &iter, root);
1312   gtk_tree_store_append (store, &iter, root);
1313   gtk_tree_store_append (store, &iter, root);
1314   gtk_tree_store_append (store, &iter, root);
1315
1316   while (gtk_tree_model_iter_children (model, &iter, root))
1317     {
1318       treestore_torture_recurse (store, &iter, depth);
1319       gtk_tree_store_remove (store, &iter);
1320     }
1321 }
1322
1323 static void
1324 run_automated_tests (void)
1325 {
1326   g_print ("Running automated tests...\n");
1327
1328   /* FIXME TreePath basic verification */
1329
1330   /* FIXME generic consistency checks on the models */
1331
1332   {
1333     /* Make sure list store mutations don't crash anything */
1334     GtkListStore *store;
1335     GtkTreeModel *model;
1336     gint i;
1337     GtkTreeIter iter;
1338
1339     store = gtk_list_store_new (1, G_TYPE_INT);
1340
1341     model = GTK_TREE_MODEL (store);
1342
1343     i = 0;
1344     while (i < 100)
1345       {
1346         gtk_list_store_append (store, &iter);
1347         ++i;
1348       }
1349
1350     while (gtk_tree_model_get_iter_root (model, &iter))
1351       gtk_list_store_remove (store, &iter);
1352
1353     gtk_list_store_append (store, &iter);
1354
1355     /* inserts before last node in list */
1356     i = 0;
1357     while (i < 100)
1358       {
1359         gtk_list_store_insert_before (store, &iter, &iter);
1360         ++i;
1361       }
1362
1363     /* inserts after the node before the last node */
1364     i = 0;
1365     while (i < 100)
1366       {
1367         gtk_list_store_insert_after (store, &iter, &iter);
1368         ++i;
1369       }
1370
1371     /* inserts after the last node */
1372     gtk_list_store_append (store, &iter);
1373
1374     i = 0;
1375     while (i < 100)
1376       {
1377         gtk_list_store_insert_after (store, &iter, &iter);
1378         ++i;
1379       }
1380
1381     /* remove everything again */
1382     while (gtk_tree_model_get_iter_root (model, &iter))
1383       gtk_list_store_remove (store, &iter);
1384
1385
1386     /* Prepends */
1387     gtk_list_store_prepend (store, &iter);
1388
1389     i = 0;
1390     while (i < 100)
1391       {
1392         gtk_list_store_prepend (store, &iter);
1393         ++i;
1394       }
1395
1396     /* remove everything again */
1397     while (gtk_tree_model_get_iter_root (model, &iter))
1398       gtk_list_store_remove (store, &iter);
1399
1400     g_object_unref (G_OBJECT (store));
1401   }
1402
1403   {
1404     /* Make sure tree store mutations don't crash anything */
1405     GtkTreeStore *store;
1406     GtkTreeIter root;
1407
1408     store = gtk_tree_store_new (1, G_TYPE_INT);
1409     gtk_tree_store_append (GTK_TREE_STORE (store), &root, NULL);
1410     /* Remove test until it is rewritten to work */
1411     /*    treestore_torture_recurse (store, &root, 0);*/
1412
1413     g_object_unref (G_OBJECT (store));
1414   }
1415
1416   g_print ("Passed.\n");
1417 }