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)                       (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_MODEL_TYPES, GtkTreeModelTypes))
  41 #define GTK_TREE_MODEL_TYPES_CLASS(klass)               (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_MODEL_TYPES, GtkTreeModelTypesClass))
  42 #define GTK_IS_TREE_MODEL_TYPES(obj)                    (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_MODEL_TYPES))
  43 #define GTK_IS_TREE_MODEL_TYPES_GET_CLASS(klass)        (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_MODEL_TYPES))
  44
  45 typedef struct _GtkTreeModelTypes       GtkTreeModelTypes;
  46 typedef struct _GtkTreeModelTypesClass  GtkTreeModelTypesClass;
  47
  48 struct _GtkTreeModelTypes
  49 {
  50   GObject parent;
  51
  52   gint stamp;
  53 };
  54
  55 struct _GtkTreeModelTypesClass
  56 {
  57   GObjectClass 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 GType              gtk_tree_model_types_get_type      (void) G_GNUC_CONST;
 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 (col,
 163                     "clicked",
 164                     G_CALLBACK (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       col = gtk_tree_view_column_new();
 283       gtk_tree_view_column_set_title (col, "Column 2");
 284
 285       rend = gtk_cell_renderer_pixbuf_new ();
 286       gtk_tree_view_column_pack_start (col, rend, FALSE);
 287       gtk_tree_view_column_add_attribute (col, rend, "pixbuf", 2);
 288       rend = gtk_cell_renderer_text_new ();
 289       gtk_tree_view_column_pack_start (col, rend, TRUE);
 290       gtk_tree_view_column_add_attribute (col, rend, "text", 0);
 291
 292       setup_column (col);
 293
 294
 295       gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), col);
 296       gtk_tree_view_set_expander_column (tree_view, col);
 297
 298       rend = gtk_cell_renderer_toggle_new ();
 299
 300       g_signal_connect (rend, "toggled",
 301                         G_CALLBACK (toggled_callback), tree_view);
 302
 303       col = gtk_tree_view_column_new_with_attributes ("Column 3",
 304                                                       rend,
 305                                                       "active", BOOL_COLUMN,
 306                                                       NULL);
 307
 308       setup_column (col);
 309
 310       gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), col);
 311
 312       pixbuf = gdk_pixbuf_new_from_xpm_data ((const char **)book_closed_xpm);
 313
 314       image = gtk_image_new_from_pixbuf (pixbuf);
 315
 316       g_object_unref (pixbuf);
 317
 318       gtk_widget_show (image);
 319
 320       gtk_tree_view_column_set_widget (col, image);
 321
 322       rend = gtk_cell_renderer_toggle_new ();
 323
 324       /* you could also set this per-row by tying it to a column
 325        * in the model of course.
 326        */
 327       g_object_set (G_OBJECT (rend), "radio", TRUE, NULL);
 328
 329       g_signal_connect (rend, "toggled",
 330                         G_CALLBACK (toggled_callback), tree_view);
 331
 332       col = gtk_tree_view_column_new_with_attributes ("Column 4",
 333                                                       rend,
 334                                                       "active", BOOL_COLUMN,
 335                                                       NULL);
 336
 337       setup_column (col);
 338
 339       gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), col);
 340
 341 #if 0
 342
 343       rend = gtk_cell_renderer_text_new ();
 344
 345       col = gtk_tree_view_column_new_with_attributes ("Column 5",
 346                                                       rend,
 347                                                       "text", 3,
 348                                                       NULL);
 349
 350       setup_column (col);
 351
 352       gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), col);
 353
 354       rend = gtk_cell_renderer_text_new ();
 355
 356       col = gtk_tree_view_column_new_with_attributes ("Column 6",
 357                                                       rend,
 358                                                       "text", 4,
 359                                                       NULL);
 360
 361       setup_column (col);
 362
 363       gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), col);
 364
 365       rend = gtk_cell_renderer_text_new ();
 366
 367       col = gtk_tree_view_column_new_with_attributes ("Column 7",
 368                                                       rend,
 369                                                       "text", 5,
 370                                                       NULL);
 371
 372       setup_column (col);
 373
 374       gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), col);
 375
 376       rend = gtk_cell_renderer_text_new ();
 377
 378       col = gtk_tree_view_column_new_with_attributes ("Column 8",
 379                                                       rend,
 380                                                       "text", 6,
 381                                                       NULL);
 382
 383       setup_column (col);
 384
 385       gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), col);
 386
 387       rend = gtk_cell_renderer_text_new ();
 388
 389       col = gtk_tree_view_column_new_with_attributes ("Column 9",
 390                                                       rend,
 391                                                       "text", 7,
 392                                                       NULL);
 393
 394       setup_column (col);
 395
 396       gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), col);
 397
 398       rend = gtk_cell_renderer_text_new ();
 399
 400       col = gtk_tree_view_column_new_with_attributes ("Column 10",
 401                                                       rend,
 402                                                       "text", 8,
 403                                                       NULL);
 404
 405       setup_column (col);
 406
 407       gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), col);
 408
 409 #endif
 410
 411       /* FALL THRU */
 412
 413     case COLUMNS_ONE:
 414       rend = gtk_cell_renderer_text_new ();
 415
 416       col = gtk_tree_view_column_new_with_attributes ("Column 0",
 417                                                       rend,
 418                                                       "text", 0,
 419                                                       NULL);
 420
 421       setup_column (col);
 422
 423       gtk_tree_view_insert_column (GTK_TREE_VIEW (tree_view), col, 0);
 424     default:
 425       break;
 426     }
 427 }
 428
 429 static ColumnsType
 430 get_columns_type (void)
 431 {
 432   return current_column_type;
 433 }
 434
 435 static GdkPixbuf *our_pixbuf;
 436
 437 typedef enum
 438 {
 439   /*   MODEL_TYPES, */
 440   MODEL_TREE,
 441   MODEL_LIST,
 442   MODEL_SORTED_TREE,
 443   MODEL_SORTED_LIST,
 444   MODEL_EMPTY_LIST,
 445   MODEL_EMPTY_TREE,
 446   MODEL_NULL,
 447   MODEL_LAST
 448 } ModelType;
 449
 450 /* FIXME add a custom model to test */
 451 static GtkTreeModel *models[MODEL_LAST];
 452 static const char *model_names[MODEL_LAST] = {
 453   "GtkTreeStore",
 454   "GtkListStore",
 455   "GtkTreeModelSort wrapping GtkTreeStore",
 456   "GtkTreeModelSort wrapping GtkListStore",
 457   "Empty GtkListStore",
 458   "Empty GtkTreeStore",
 459   "NULL (no model)"
 460 };
 461
 462 static GtkTreeModel*
 463 create_list_model (void)
 464 {
 465   GtkListStore *store;
 466   GtkTreeIter iter;
 467   gint i;
 468   GType *t;
 469
 470   t = get_model_types ();
 471
 472   store = gtk_list_store_new (N_COLUMNS,
 473                               t[0], t[1], t[2],
 474                               t[3], t[4], t[5],
 475                               t[6], t[7], t[8]);
 476
 477   i = 0;
 478   while (i < 200)
 479     {
 480       char *msg;
 481
 482       gtk_list_store_append (store, &iter);
 483
 484       msg = g_strdup_printf ("%d", i);
 485
 486       gtk_list_store_set (store, &iter, 0, msg, 1, "Foo! Foo! Foo!",
 487                           2, our_pixbuf,
 488                           3, 7.0, 4, (guint) 9000,
 489                           5, 'f', 6, 'g',
 490                           7, TRUE, 8, 23245454,
 491                           -1);
 492
 493       g_free (msg);
 494
 495       ++i;
 496     }
 497
 498   return GTK_TREE_MODEL (store);
 499 }
 500
 501 static void
 502 typesystem_recurse (GType        type,
 503                     GtkTreeIter *parent_iter,
 504                     GtkTreeStore *store)
 505 {
 506   GType* children;
 507   guint n_children = 0;
 508   gint i;
 509   GtkTreeIter iter;
 510   gchar *str;
 511
 512   gtk_tree_store_append (store, &iter, parent_iter);
 513
 514   str = g_strdup_printf ("%ld", (glong)type);
 515   gtk_tree_store_set (store, &iter, 0, str, 1, g_type_name (type),
 516                       2, our_pixbuf,
 517                       3, 7.0, 4, (guint) 9000,
 518                       5, 'f', 6, 'g',
 519                       7, TRUE, 8, 23245454,
 520                       -1);
 521   g_free (str);
 522
 523   children = g_type_children (type, &n_children);
 524
 525   i = 0;
 526   while (i < n_children)
 527     {
 528       typesystem_recurse (children[i], &iter, store);
 529
 530       ++i;
 531     }
 532
 533   g_free (children);
 534 }
 535
 536 static GtkTreeModel*
 537 create_tree_model (void)
 538 {
 539   GtkTreeStore *store;
 540   gint i;
 541   GType *t;
 542   volatile GType dummy; /* G_GNUC_CONST makes the optimizer remove
 543                          * get_type calls if you don't do something
 544                          * like this
 545                          */
 546
 547   /* Make the tree more interesting */
 548   dummy = gtk_scrolled_window_get_type ();
 549   dummy = gtk_label_get_type ();
 550   dummy = gtk_hscrollbar_get_type ();
 551   dummy = gtk_vscrollbar_get_type ();
 552   dummy = pango_layout_get_type ();
 553
 554   t = get_model_types ();
 555
 556   store = gtk_tree_store_new (N_COLUMNS,
 557                               t[0], t[1], t[2],
 558                               t[3], t[4], t[5],
 559                               t[6], t[7], t[8]);
 560
 561   i = 0;
 562   while (i < G_TYPE_FUNDAMENTAL_MAX)
 563     {
 564       typesystem_recurse (i, NULL, store);
 565
 566       ++i;
 567     }
 568
 569   return GTK_TREE_MODEL (store);
 570 }
 571
 572 static void
 573 model_selected (GtkOptionMenu *om, gpointer data)
 574 {
 575   GtkTreeView *tree_view = GTK_TREE_VIEW (data);
 576   gint hist;
 577
 578   hist = gtk_option_menu_get_history (om);
 579
 580   if (models[hist] != gtk_tree_view_get_model (tree_view))
 581     {
 582       gtk_tree_view_set_model (tree_view, models[hist]);
 583     }
 584 }
 585
 586 static void
 587 columns_selected (GtkOptionMenu *om, gpointer data)
 588 {
 589   GtkTreeView *tree_view = GTK_TREE_VIEW (data);
 590   gint hist;
 591
 592   hist = gtk_option_menu_get_history (om);
 593
 594   if (hist != get_columns_type ())
 595     {
 596       set_columns_type (tree_view, hist);
 597     }
 598 }
 599
 600
 601 enum
 602 {
 603   TARGET_GTK_TREE_MODEL_ROW
 604 };
 605
 606 static GtkTargetEntry row_targets[] = {
 607   { "GTK_TREE_MODEL_ROW", GTK_TARGET_SAME_APP,
 608     TARGET_GTK_TREE_MODEL_ROW }
 609 };
 610
 611 int
 612 main (int    argc,
 613       char **argv)
 614 {
 615   GtkWidget *window;
 616   GtkWidget *sw;
 617   GtkWidget *tv;
 618   GtkWidget *table;
 619   GtkWidget *om;
 620   GtkWidget *menu;
 621   GtkTreeModel *model;
 622   gint i;
 623
 624   gtk_init (&argc, &argv);
 625
 626   our_pixbuf = gdk_pixbuf_new_from_xpm_data ((const char **) book_closed_xpm);
 627
 628 #if 0
 629   models[MODEL_TYPES] = GTK_TREE_MODEL (gtk_tree_model_types_new ());
 630 #endif
 631   models[MODEL_LIST] = create_list_model ();
 632   models[MODEL_TREE] = create_tree_model ();
 633
 634   model = create_list_model ();
 635   models[MODEL_SORTED_LIST] = gtk_tree_model_sort_new_with_model (model);
 636   g_object_unref (model);
 637
 638   model = create_tree_model ();
 639   models[MODEL_SORTED_TREE] = gtk_tree_model_sort_new_with_model (model);
 640   g_object_unref (model);
 641
 642   models[MODEL_EMPTY_LIST] = GTK_TREE_MODEL (gtk_list_store_new (1, G_TYPE_INT));
 643   models[MODEL_EMPTY_TREE] = GTK_TREE_MODEL (gtk_tree_store_new (1, G_TYPE_INT));
 644
 645   models[MODEL_NULL] = NULL;
 646
 647   run_automated_tests ();
 648
 649   window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 650   g_signal_connect (window, "destroy", G_CALLBACK (gtk_main_quit), NULL);
 651   gtk_window_set_default_size (GTK_WINDOW (window), 400, 400);
 652
 653   table = gtk_table_new (3, 1, FALSE);
 654
 655   gtk_container_add (GTK_CONTAINER (window), table);
 656
 657   tv = gtk_tree_view_new_with_model (models[0]);
 658
 659   gtk_tree_view_enable_model_drag_source (GTK_TREE_VIEW (tv),
 660                                           GDK_BUTTON1_MASK,
 661                                           row_targets,
 662                                           G_N_ELEMENTS (row_targets),
 663                                           GDK_ACTION_MOVE | GDK_ACTION_COPY);
 664
 665   gtk_tree_view_enable_model_drag_dest (GTK_TREE_VIEW (tv),
 666                                         row_targets,
 667                                         G_N_ELEMENTS (row_targets),
 668                                         GDK_ACTION_MOVE | GDK_ACTION_COPY);
 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   g_signal_connect (om,
 706                     "changed",
 707                     G_CALLBACK (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   g_signal_connect (om,
 742                     "changed",
 743                     G_CALLBACK (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 static void         gtk_tree_model_types_init                 (GtkTreeModelTypes      *model_types);
 771 static void         gtk_tree_model_types_tree_model_init      (GtkTreeModelIface   *iface);
 772 static gint         gtk_real_model_types_get_n_columns   (GtkTreeModel        *tree_model);
 773 static GType        gtk_real_model_types_get_column_type (GtkTreeModel        *tree_model,
 774                                                            gint                 index);
 775 static GtkTreePath *gtk_real_model_types_get_path        (GtkTreeModel        *tree_model,
 776                                                            GtkTreeIter         *iter);
 777 static void         gtk_real_model_types_get_value       (GtkTreeModel        *tree_model,
 778                                                            GtkTreeIter         *iter,
 779                                                            gint                 column,
 780                                                            GValue              *value);
 781 static gboolean     gtk_real_model_types_iter_next       (GtkTreeModel        *tree_model,
 782                                                            GtkTreeIter         *iter);
 783 static gboolean     gtk_real_model_types_iter_children   (GtkTreeModel        *tree_model,
 784                                                            GtkTreeIter         *iter,
 785                                                            GtkTreeIter         *parent);
 786 static gboolean     gtk_real_model_types_iter_has_child  (GtkTreeModel        *tree_model,
 787                                                            GtkTreeIter         *iter);
 788 static gint         gtk_real_model_types_iter_n_children (GtkTreeModel        *tree_model,
 789                                                            GtkTreeIter         *iter);
 790 static gboolean     gtk_real_model_types_iter_nth_child  (GtkTreeModel        *tree_model,
 791                                                            GtkTreeIter         *iter,
 792                                                            GtkTreeIter         *parent,
 793                                                            gint                 n);
 794 static gboolean     gtk_real_model_types_iter_parent     (GtkTreeModel        *tree_model,
 795                                                            GtkTreeIter         *iter,
 796                                                            GtkTreeIter         *child);
 797
 798
 799 GType
 800 gtk_tree_model_types_get_type (void)
 801 {
 802   static GType model_types_type = 0;
 803
 804   if (!model_types_type)
 805     {
 806       static const GTypeInfo model_types_info =
 807       {
 808         sizeof (GtkTreeModelTypesClass),
 809         NULL,           /* base_init */
 810         NULL,           /* base_finalize */
 811         NULL,           /* class_init */
 812         NULL,           /* class_finalize */
 813         NULL,           /* class_data */
 814         sizeof (GtkTreeModelTypes),
 815         0,
 816         (GInstanceInitFunc) gtk_tree_model_types_init
 817       };
 818
 819       static const GInterfaceInfo tree_model_info =
 820       {
 821         (GInterfaceInitFunc) gtk_tree_model_types_tree_model_init,
 822         NULL,
 823         NULL
 824       };
 825
 826       model_types_type = g_type_register_static (G_TYPE_OBJECT,
 827                                                  "GtkTreeModelTypes",
 828                                                  &model_types_info, 0);
 829       g_type_add_interface_static (model_types_type,
 830                                    GTK_TYPE_TREE_MODEL,
 831                                    &tree_model_info);
 832     }
 833
 834   return model_types_type;
 835 }
 836
 837 GtkTreeModelTypes *
 838 gtk_tree_model_types_new (void)
 839 {
 840   GtkTreeModelTypes *retval;
 841
 842   retval = GTK_TREE_MODEL_TYPES (g_object_new (GTK_TYPE_MODEL_TYPES, NULL));
 843
 844   return retval;
 845 }
 846
 847 static void
 848 gtk_tree_model_types_tree_model_init (GtkTreeModelIface *iface)
 849 {
 850   iface->get_n_columns = gtk_real_model_types_get_n_columns;
 851   iface->get_column_type = gtk_real_model_types_get_column_type;
 852   iface->get_path = gtk_real_model_types_get_path;
 853   iface->get_value = gtk_real_model_types_get_value;
 854   iface->iter_next = gtk_real_model_types_iter_next;
 855   iface->iter_children = gtk_real_model_types_iter_children;
 856   iface->iter_has_child = gtk_real_model_types_iter_has_child;
 857   iface->iter_n_children = gtk_real_model_types_iter_n_children;
 858   iface->iter_nth_child = gtk_real_model_types_iter_nth_child;
 859   iface->iter_parent = gtk_real_model_types_iter_parent;
 860 }
 861
 862 static void
 863 gtk_tree_model_types_init (GtkTreeModelTypes *model_types)
 864 {
 865   model_types->stamp = g_random_int ();
 866 }
 867
 868 static GType column_types[] = {
 869   G_TYPE_STRING, /* GType */
 870   G_TYPE_STRING  /* type name */
 871 };
 872
 873 static gint
 874 gtk_real_model_types_get_n_columns (GtkTreeModel *tree_model)
 875 {
 876   return G_N_ELEMENTS (column_types);
 877 }
 878
 879 static GType
 880 gtk_real_model_types_get_column_type (GtkTreeModel *tree_model,
 881                                       gint          index)
 882 {
 883   g_return_val_if_fail (index < G_N_ELEMENTS (column_types), G_TYPE_INVALID);
 884
 885   return column_types[index];
 886 }
 887
 888 #if 0
 889 /* Use default implementation of this */
 890 static gboolean
 891 gtk_real_model_types_get_iter (GtkTreeModel *tree_model,
 892                                GtkTreeIter  *iter,
 893                                GtkTreePath  *path)
 894 {
 895
 896 }
 897 #endif
 898
 899 /* The toplevel nodes of the tree are the reserved types, G_TYPE_NONE through
 900  * G_TYPE_RESERVED_FUNDAMENTAL.
 901  */
 902
 903 static GtkTreePath *
 904 gtk_real_model_types_get_path (GtkTreeModel *tree_model,
 905                                GtkTreeIter  *iter)
 906 {
 907   GtkTreePath *retval;
 908   GType type;
 909   GType parent;
 910
 911   g_return_val_if_fail (GTK_IS_TREE_MODEL_TYPES (tree_model), NULL);
 912   g_return_val_if_fail (iter != NULL, NULL);
 913
 914   type = GPOINTER_TO_INT (iter->user_data);
 915
 916   retval = gtk_tree_path_new ();
 917
 918   parent = g_type_parent (type);
 919   while (parent != G_TYPE_INVALID)
 920     {
 921       GType* children = g_type_children (parent, NULL);
 922       gint i = 0;
 923
 924       if (!children || children[0] == G_TYPE_INVALID)
 925         {
 926           g_warning ("bad iterator?");
 927           return NULL;
 928         }
 929
 930       while (children[i] != type)
 931         ++i;
 932
 933       gtk_tree_path_prepend_index (retval, i);
 934
 935       g_free (children);
 936
 937       type = parent;
 938       parent = g_type_parent (parent);
 939     }
 940
 941   /* The fundamental type itself is the index on the toplevel */
 942   gtk_tree_path_prepend_index (retval, type);
 943
 944   return retval;
 945 }
 946
 947 static void
 948 gtk_real_model_types_get_value (GtkTreeModel *tree_model,
 949                                 GtkTreeIter  *iter,
 950                                 gint          column,
 951                                 GValue       *value)
 952 {
 953   GType type;
 954
 955   type = GPOINTER_TO_INT (iter->user_data);
 956
 957   switch (column)
 958     {
 959     case 0:
 960       {
 961         gchar *str;
 962
 963         g_value_init (value, G_TYPE_STRING);
 964
 965         str = g_strdup_printf ("%ld", type);
 966         g_value_set_string (value, str);
 967         g_free (str);
 968       }
 969       break;
 970
 971     case 1:
 972       g_value_init (value, G_TYPE_STRING);
 973       g_value_set_string (value, g_type_name (type));
 974       break;
 975
 976     default:
 977       g_warning ("Bad column %d requested", column);
 978     }
 979 }
 980
 981 static gboolean
 982 gtk_real_model_types_iter_next (GtkTreeModel  *tree_model,
 983                                 GtkTreeIter   *iter)
 984 {
 985
 986   GType parent;
 987   GType type;
 988
 989   type = GPOINTER_TO_INT (iter->user_data);
 990
 991   parent = g_type_parent (type);
 992
 993   if (parent == G_TYPE_INVALID)
 994     {
 995       /* find next _valid_ fundamental type */
 996       do
 997         type++;
 998       while (!g_type_name (type) && type <= G_TYPE_FUNDAMENTAL_MAX);
 999       if (type <= G_TYPE_FUNDAMENTAL_MAX)
1000         {
1001           /* found one */
1002           iter->user_data = GINT_TO_POINTER (type);
1003           return TRUE;
1004         }
1005       else
1006         return FALSE;
1007     }
1008   else
1009     {
1010       GType* children = g_type_children (parent, NULL);
1011       gint i = 0;
1012
1013       g_assert (children != NULL);
1014
1015       while (children[i] != type)
1016         ++i;
1017
1018       ++i;
1019
1020       if (children[i] != G_TYPE_INVALID)
1021         {
1022           g_free (children);
1023           iter->user_data = GINT_TO_POINTER (children[i]);
1024           return TRUE;
1025         }
1026       else
1027         {
1028           g_free (children);
1029           return FALSE;
1030         }
1031     }
1032 }
1033
1034 static gboolean
1035 gtk_real_model_types_iter_children (GtkTreeModel *tree_model,
1036                                     GtkTreeIter  *iter,
1037                                     GtkTreeIter  *parent)
1038 {
1039   GType type;
1040   GType* children;
1041
1042   type = GPOINTER_TO_INT (parent->user_data);
1043
1044   children = g_type_children (type, NULL);
1045
1046   if (!children || children[0] == G_TYPE_INVALID)
1047     {
1048       g_free (children);
1049       return FALSE;
1050     }
1051   else
1052     {
1053       iter->user_data = GINT_TO_POINTER (children[0]);
1054       g_free (children);
1055       return TRUE;
1056     }
1057 }
1058
1059 static gboolean
1060 gtk_real_model_types_iter_has_child (GtkTreeModel *tree_model,
1061                                      GtkTreeIter  *iter)
1062 {
1063   GType type;
1064   GType* children;
1065
1066   type = GPOINTER_TO_INT (iter->user_data);
1067
1068   children = g_type_children (type, NULL);
1069
1070   if (!children || children[0] == G_TYPE_INVALID)
1071     {
1072       g_free (children);
1073       return FALSE;
1074     }
1075   else
1076     {
1077       g_free (children);
1078       return TRUE;
1079     }
1080 }
1081
1082 static gint
1083 gtk_real_model_types_iter_n_children (GtkTreeModel *tree_model,
1084                                       GtkTreeIter  *iter)
1085 {
1086   if (iter == NULL)
1087     {
1088       return G_TYPE_FUNDAMENTAL_MAX;
1089     }
1090   else
1091     {
1092       GType type;
1093       GType* children;
1094       guint n_children = 0;
1095
1096       type = GPOINTER_TO_INT (iter->user_data);
1097
1098       children = g_type_children (type, &n_children);
1099
1100       g_free (children);
1101
1102       return n_children;
1103     }
1104 }
1105
1106 static gboolean
1107 gtk_real_model_types_iter_nth_child (GtkTreeModel *tree_model,
1108                                      GtkTreeIter  *iter,
1109                                      GtkTreeIter  *parent,
1110                                      gint          n)
1111 {
1112   if (parent == NULL)
1113     {
1114       /* fundamental type */
1115       if (n < G_TYPE_FUNDAMENTAL_MAX)
1116         {
1117           iter->user_data = GINT_TO_POINTER (n);
1118           return TRUE;
1119         }
1120       else
1121         return FALSE;
1122     }
1123   else
1124     {
1125       GType type = GPOINTER_TO_INT (parent->user_data);
1126       guint n_children = 0;
1127       GType* children = g_type_children (type, &n_children);
1128
1129       if (n_children == 0)
1130         {
1131           g_free (children);
1132           return FALSE;
1133         }
1134       else if (n >= n_children)
1135         {
1136           g_free (children);
1137           return FALSE;
1138         }
1139       else
1140         {
1141           iter->user_data = GINT_TO_POINTER (children[n]);
1142           g_free (children);
1143
1144           return TRUE;
1145         }
1146     }
1147 }
1148
1149 static gboolean
1150 gtk_real_model_types_iter_parent (GtkTreeModel *tree_model,
1151                                   GtkTreeIter  *iter,
1152                                   GtkTreeIter  *child)
1153 {
1154   GType type;
1155   GType parent;
1156
1157   type = GPOINTER_TO_INT (child->user_data);
1158
1159   parent = g_type_parent (type);
1160
1161   if (parent == G_TYPE_INVALID)
1162     {
1163       if (type > G_TYPE_FUNDAMENTAL_MAX)
1164         g_warning ("no parent for %ld %s\n", type, g_type_name (type));
1165       return FALSE;
1166     }
1167   else
1168     {
1169       iter->user_data = GINT_TO_POINTER (parent);
1170
1171       return TRUE;
1172     }
1173 }
1174
1175 /*
1176  * Automated testing
1177  */
1178
1179 static void
1180 treestore_torture_recurse (GtkTreeStore *store,
1181                            GtkTreeIter  *root,
1182                            gint          depth)
1183 {
1184   GtkTreeModel *model;
1185   gint i;
1186   GtkTreeIter iter;
1187
1188   model = GTK_TREE_MODEL (store);
1189
1190   if (depth > 2)
1191     return;
1192
1193   ++depth;
1194
1195   gtk_tree_store_append (store, &iter, root);
1196
1197   gtk_tree_model_iter_children (model, &iter, root);
1198
1199   i = 0;
1200   while (i < 100)
1201     {
1202       gtk_tree_store_append (store, &iter, root);
1203       ++i;
1204     }
1205
1206   while (gtk_tree_model_iter_children (model, &iter, root))
1207     gtk_tree_store_remove (store, &iter);
1208
1209   gtk_tree_store_append (store, &iter, root);
1210
1211   /* inserts before last node in tree */
1212   i = 0;
1213   while (i < 100)
1214     {
1215       gtk_tree_store_insert_before (store, &iter, root, &iter);
1216       ++i;
1217     }
1218
1219   /* inserts after the node before the last node */
1220   i = 0;
1221   while (i < 100)
1222     {
1223       gtk_tree_store_insert_after (store, &iter, root, &iter);
1224       ++i;
1225     }
1226
1227   /* inserts after the last node */
1228   gtk_tree_store_append (store, &iter, root);
1229
1230   i = 0;
1231   while (i < 100)
1232     {
1233       gtk_tree_store_insert_after (store, &iter, root, &iter);
1234       ++i;
1235     }
1236
1237   /* remove everything again */
1238   while (gtk_tree_model_iter_children (model, &iter, root))
1239     gtk_tree_store_remove (store, &iter);
1240
1241
1242     /* Prepends */
1243   gtk_tree_store_prepend (store, &iter, root);
1244
1245   i = 0;
1246   while (i < 100)
1247     {
1248       gtk_tree_store_prepend (store, &iter, root);
1249       ++i;
1250     }
1251
1252   /* remove everything again */
1253   while (gtk_tree_model_iter_children (model, &iter, root))
1254     gtk_tree_store_remove (store, &iter);
1255
1256   gtk_tree_store_append (store, &iter, root);
1257   gtk_tree_store_append (store, &iter, root);
1258   gtk_tree_store_append (store, &iter, root);
1259   gtk_tree_store_append (store, &iter, root);
1260
1261   while (gtk_tree_model_iter_children (model, &iter, root))
1262     {
1263       treestore_torture_recurse (store, &iter, depth);
1264       gtk_tree_store_remove (store, &iter);
1265     }
1266 }
1267
1268 static void
1269 run_automated_tests (void)
1270 {
1271   g_print ("Running automated tests...\n");
1272
1273   /* FIXME TreePath basic verification */
1274
1275   /* FIXME generic consistency checks on the models */
1276
1277   {
1278     /* Make sure list store mutations don't crash anything */
1279     GtkListStore *store;
1280     GtkTreeModel *model;
1281     gint i;
1282     GtkTreeIter iter;
1283
1284     store = gtk_list_store_new (1, G_TYPE_INT);
1285
1286     model = GTK_TREE_MODEL (store);
1287
1288     i = 0;
1289     while (i < 100)
1290       {
1291         gtk_list_store_append (store, &iter);
1292         ++i;
1293       }
1294
1295     while (gtk_tree_model_get_iter_first (model, &iter))
1296       gtk_list_store_remove (store, &iter);
1297
1298     gtk_list_store_append (store, &iter);
1299
1300     /* inserts before last node in list */
1301     i = 0;
1302     while (i < 100)
1303       {
1304         gtk_list_store_insert_before (store, &iter, &iter);
1305         ++i;
1306       }
1307
1308     /* inserts after the node before the last node */
1309     i = 0;
1310     while (i < 100)
1311       {
1312         gtk_list_store_insert_after (store, &iter, &iter);
1313         ++i;
1314       }
1315
1316     /* inserts after the last node */
1317     gtk_list_store_append (store, &iter);
1318
1319     i = 0;
1320     while (i < 100)
1321       {
1322         gtk_list_store_insert_after (store, &iter, &iter);
1323         ++i;
1324       }
1325
1326     /* remove everything again */
1327     while (gtk_tree_model_get_iter_first (model, &iter))
1328       gtk_list_store_remove (store, &iter);
1329
1330
1331     /* Prepends */
1332     gtk_list_store_prepend (store, &iter);
1333
1334     i = 0;
1335     while (i < 100)
1336       {
1337         gtk_list_store_prepend (store, &iter);
1338         ++i;
1339       }
1340
1341     /* remove everything again */
1342     while (gtk_tree_model_get_iter_first (model, &iter))
1343       gtk_list_store_remove (store, &iter);
1344
1345     g_object_unref (store);
1346   }
1347
1348   {
1349     /* Make sure tree store mutations don't crash anything */
1350     GtkTreeStore *store;
1351     GtkTreeIter root;
1352
1353     store = gtk_tree_store_new (1, G_TYPE_INT);
1354     gtk_tree_store_append (GTK_TREE_STORE (store), &root, NULL);
1355     /* Remove test until it is rewritten to work */
1356     /*    treestore_torture_recurse (store, &root, 0);*/
1357
1358     g_object_unref (store);
1359   }
1360
1361   g_print ("Passed.\n");
1362 }