2 * Copyright (C) 2001 Red Hat, Inc
3 * Author: Jonathan Blandford
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.
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.
15 * You should have received a copy of the GNU Library General Public
16 * License along with this library. If not, see <http://www.gnu.org/licenses/>.
20 #include "prop-editor.h"
24 /* Don't copy this bad example; inline RGB data is always a better
25 * idea than inline XPMs.
27 static char *book_closed_xpm[] = {
53 static void run_automated_tests (void);
55 /* This custom model is to test custom model use. */
57 #define GTK_TYPE_MODEL_TYPES (gtk_tree_model_types_get_type ())
58 #define GTK_TREE_MODEL_TYPES(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_MODEL_TYPES, GtkTreeModelTypes))
59 #define GTK_TREE_MODEL_TYPES_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_MODEL_TYPES, GtkTreeModelTypesClass))
60 #define GTK_IS_TREE_MODEL_TYPES(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_MODEL_TYPES))
61 #define GTK_IS_TREE_MODEL_TYPES_GET_CLASS(klass) (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_MODEL_TYPES))
63 typedef struct _GtkTreeModelTypes GtkTreeModelTypes;
64 typedef struct _GtkTreeModelTypesClass GtkTreeModelTypesClass;
66 struct _GtkTreeModelTypes
73 struct _GtkTreeModelTypesClass
75 GObjectClass parent_class;
77 guint (* get_flags) (GtkTreeModel *tree_model);
78 gint (* get_n_columns) (GtkTreeModel *tree_model);
79 GType (* get_column_type) (GtkTreeModel *tree_model,
81 gboolean (* get_iter) (GtkTreeModel *tree_model,
84 GtkTreePath *(* get_path) (GtkTreeModel *tree_model,
86 void (* get_value) (GtkTreeModel *tree_model,
90 gboolean (* iter_next) (GtkTreeModel *tree_model,
92 gboolean (* iter_children) (GtkTreeModel *tree_model,
95 gboolean (* iter_has_child) (GtkTreeModel *tree_model,
97 gint (* iter_n_children) (GtkTreeModel *tree_model,
99 gboolean (* iter_nth_child) (GtkTreeModel *tree_model,
103 gboolean (* iter_parent) (GtkTreeModel *tree_model,
106 void (* ref_iter) (GtkTreeModel *tree_model,
108 void (* unref_iter) (GtkTreeModel *tree_model,
111 /* These will be moved into the GtkTreeModelIface eventually */
112 void (* changed) (GtkTreeModel *tree_model,
115 void (* inserted) (GtkTreeModel *tree_model,
118 void (* child_toggled) (GtkTreeModel *tree_model,
121 void (* deleted) (GtkTreeModel *tree_model,
125 GType gtk_tree_model_types_get_type (void) G_GNUC_CONST;
126 GtkTreeModelTypes *gtk_tree_model_types_new (void);
136 static gchar *column_type_names[] = {
145 get_model_types (void)
147 static GType column_types[N_COLUMNS] = { 0 };
149 if (column_types[0] == 0)
151 column_types[0] = G_TYPE_STRING;
152 column_types[1] = G_TYPE_STRING;
153 column_types[2] = GDK_TYPE_PIXBUF;
154 column_types[3] = G_TYPE_FLOAT;
155 column_types[4] = G_TYPE_UINT;
156 column_types[5] = G_TYPE_UCHAR;
157 column_types[6] = G_TYPE_CHAR;
158 #define BOOL_COLUMN 7
159 column_types[BOOL_COLUMN] = G_TYPE_BOOLEAN;
160 column_types[8] = G_TYPE_INT;
167 col_clicked_cb (GtkTreeViewColumn *col, gpointer data)
171 win = GTK_WINDOW (create_prop_editor (G_OBJECT (col), GTK_TYPE_TREE_VIEW_COLUMN));
173 gtk_window_set_title (win, gtk_tree_view_column_get_title (col));
177 setup_column (GtkTreeViewColumn *col)
179 gtk_tree_view_column_set_clickable (col, TRUE);
180 g_signal_connect (col,
182 G_CALLBACK (col_clicked_cb),
187 toggled_callback (GtkCellRendererToggle *celltoggle,
189 GtkTreeView *tree_view)
191 GtkTreeModel *model = NULL;
192 GtkTreeModelSort *sort_model = NULL;
195 gboolean active = FALSE;
197 g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
199 model = gtk_tree_view_get_model (tree_view);
201 if (GTK_IS_TREE_MODEL_SORT (model))
203 sort_model = GTK_TREE_MODEL_SORT (model);
204 model = gtk_tree_model_sort_get_model (sort_model);
212 g_warning ("FIXME implement conversion from TreeModelSort iter to child model iter");
216 path = gtk_tree_path_new_from_string (path_string);
217 if (!gtk_tree_model_get_iter (model,
220 g_warning ("%s: bad path?", G_STRLOC);
223 gtk_tree_path_free (path);
225 if (GTK_IS_LIST_STORE (model))
227 gtk_tree_model_get (GTK_TREE_MODEL (model),
233 gtk_list_store_set (GTK_LIST_STORE (model),
239 else if (GTK_IS_TREE_STORE (model))
241 gtk_tree_model_get (GTK_TREE_MODEL (model),
247 gtk_tree_store_set (GTK_TREE_STORE (model),
254 g_warning ("don't know how to actually toggle value for model type %s",
255 g_type_name (G_TYPE_FROM_INSTANCE (model)));
259 edited_callback (GtkCellRendererText *renderer,
260 const gchar *path_string,
261 const gchar *new_text,
262 GtkTreeView *tree_view)
264 GtkTreeModel *model = NULL;
265 GtkTreeModelSort *sort_model = NULL;
268 guint value = atoi (new_text);
270 g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
272 model = gtk_tree_view_get_model (tree_view);
274 if (GTK_IS_TREE_MODEL_SORT (model))
276 sort_model = GTK_TREE_MODEL_SORT (model);
277 model = gtk_tree_model_sort_get_model (sort_model);
285 g_warning ("FIXME implement conversion from TreeModelSort iter to child model iter");
289 path = gtk_tree_path_new_from_string (path_string);
290 if (!gtk_tree_model_get_iter (model,
293 g_warning ("%s: bad path?", G_STRLOC);
296 gtk_tree_path_free (path);
298 if (GTK_IS_LIST_STORE (model))
300 gtk_list_store_set (GTK_LIST_STORE (model),
306 else if (GTK_IS_TREE_STORE (model))
308 gtk_tree_store_set (GTK_TREE_STORE (model),
315 g_warning ("don't know how to actually toggle value for model type %s",
316 g_type_name (G_TYPE_FROM_INSTANCE (model)));
319 static ColumnsType current_column_type = COLUMNS_LOTS;
322 set_columns_type (GtkTreeView *tree_view, ColumnsType type)
324 GtkTreeViewColumn *col;
325 GtkCellRenderer *rend;
328 GtkAdjustment *adjustment;
330 current_column_type = type;
332 col = gtk_tree_view_get_column (tree_view, 0);
335 gtk_tree_view_remove_column (tree_view, col);
337 col = gtk_tree_view_get_column (tree_view, 0);
340 gtk_tree_view_set_rules_hint (tree_view, FALSE);
348 /* with lots of columns we need to turn on rules */
349 gtk_tree_view_set_rules_hint (tree_view, TRUE);
351 rend = gtk_cell_renderer_text_new ();
353 col = gtk_tree_view_column_new_with_attributes ("Column 1",
359 gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), col);
361 col = gtk_tree_view_column_new();
362 gtk_tree_view_column_set_title (col, "Column 2");
364 rend = gtk_cell_renderer_pixbuf_new ();
365 gtk_tree_view_column_pack_start (col, rend, FALSE);
366 gtk_tree_view_column_add_attribute (col, rend, "pixbuf", 2);
367 rend = gtk_cell_renderer_text_new ();
368 gtk_tree_view_column_pack_start (col, rend, TRUE);
369 gtk_tree_view_column_add_attribute (col, rend, "text", 0);
374 gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), col);
375 gtk_tree_view_set_expander_column (tree_view, col);
377 rend = gtk_cell_renderer_toggle_new ();
379 g_signal_connect (rend, "toggled",
380 G_CALLBACK (toggled_callback), tree_view);
382 col = gtk_tree_view_column_new_with_attributes ("Column 3",
384 "active", BOOL_COLUMN,
389 gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), col);
391 pixbuf = gdk_pixbuf_new_from_xpm_data ((const char **)book_closed_xpm);
393 image = gtk_image_new_from_pixbuf (pixbuf);
395 g_object_unref (pixbuf);
397 gtk_widget_show (image);
399 gtk_tree_view_column_set_widget (col, image);
401 rend = gtk_cell_renderer_toggle_new ();
403 /* you could also set this per-row by tying it to a column
404 * in the model of course.
406 g_object_set (rend, "radio", TRUE, NULL);
408 g_signal_connect (rend, "toggled",
409 G_CALLBACK (toggled_callback), tree_view);
411 col = gtk_tree_view_column_new_with_attributes ("Column 4",
413 "active", BOOL_COLUMN,
418 gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), col);
420 rend = gtk_cell_renderer_spin_new ();
422 adjustment = gtk_adjustment_new (0, 0, 10000, 100, 100, 100);
423 g_object_set (rend, "editable", TRUE, NULL);
424 g_object_set (rend, "adjustment", adjustment, NULL);
426 g_signal_connect (rend, "edited",
427 G_CALLBACK (edited_callback), tree_view);
429 col = gtk_tree_view_column_new_with_attributes ("Column 5",
436 gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), col);
439 rend = gtk_cell_renderer_text_new ();
441 col = gtk_tree_view_column_new_with_attributes ("Column 6",
448 gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), col);
450 rend = gtk_cell_renderer_text_new ();
452 col = gtk_tree_view_column_new_with_attributes ("Column 7",
459 gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), col);
461 rend = gtk_cell_renderer_text_new ();
463 col = gtk_tree_view_column_new_with_attributes ("Column 8",
470 gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), col);
472 rend = gtk_cell_renderer_text_new ();
474 col = gtk_tree_view_column_new_with_attributes ("Column 9",
481 gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), col);
483 rend = gtk_cell_renderer_text_new ();
485 col = gtk_tree_view_column_new_with_attributes ("Column 10",
492 gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), col);
499 rend = gtk_cell_renderer_text_new ();
501 col = gtk_tree_view_column_new_with_attributes ("Column 0",
508 gtk_tree_view_insert_column (GTK_TREE_VIEW (tree_view), col, 0);
515 get_columns_type (void)
517 return current_column_type;
520 static GdkPixbuf *our_pixbuf;
535 /* FIXME add a custom model to test */
536 static GtkTreeModel *models[MODEL_LAST];
537 static const char *model_names[MODEL_LAST] = {
540 "GtkTreeModelSort wrapping GtkTreeStore",
541 "GtkTreeModelSort wrapping GtkListStore",
542 "Empty GtkListStore",
543 "Empty GtkTreeStore",
548 create_list_model (void)
555 t = get_model_types ();
557 store = gtk_list_store_new (N_COLUMNS,
567 gtk_list_store_append (store, &iter);
569 msg = g_strdup_printf ("%d", i);
571 gtk_list_store_set (store, &iter, 0, msg, 1, "Foo! Foo! Foo!",
573 3, 7.0, 4, (guint) 9000,
575 7, TRUE, 8, 23245454,
583 return GTK_TREE_MODEL (store);
587 typesystem_recurse (GType type,
588 GtkTreeIter *parent_iter,
592 guint n_children = 0;
597 gtk_tree_store_append (store, &iter, parent_iter);
599 str = g_strdup_printf ("%ld", (glong)type);
600 gtk_tree_store_set (store, &iter, 0, str, 1, g_type_name (type),
602 3, 7.0, 4, (guint) 9000,
604 7, TRUE, 8, 23245454,
608 children = g_type_children (type, &n_children);
611 while (i < n_children)
613 typesystem_recurse (children[i], &iter, store);
622 create_tree_model (void)
628 /* Make the tree more interesting */
629 /* - we need this magic here so we are sure the type ends up being
630 * registered and gcc doesn't optimize away the code */
631 g_type_class_unref (g_type_class_ref (gtk_scrolled_window_get_type ()));
632 g_type_class_unref (g_type_class_ref (gtk_label_get_type ()));
633 g_type_class_unref (g_type_class_ref (gtk_scrollbar_get_type ()));
634 g_type_class_unref (g_type_class_ref (pango_layout_get_type ()));
636 t = get_model_types ();
638 store = gtk_tree_store_new (N_COLUMNS,
644 while (i < G_TYPE_FUNDAMENTAL_MAX)
646 typesystem_recurse (i, NULL, store);
651 return GTK_TREE_MODEL (store);
655 model_selected (GtkComboBox *combo_box, gpointer data)
657 GtkTreeView *tree_view = GTK_TREE_VIEW (data);
660 hist = gtk_combo_box_get_active (combo_box);
662 if (models[hist] != gtk_tree_view_get_model (tree_view))
664 gtk_tree_view_set_model (tree_view, models[hist]);
669 columns_selected (GtkComboBox *combo_box, gpointer data)
671 GtkTreeView *tree_view = GTK_TREE_VIEW (data);
674 hist = gtk_combo_box_get_active (combo_box);
676 if (hist != get_columns_type ())
678 set_columns_type (tree_view, hist);
683 on_row_activated (GtkTreeView *tree_view,
685 GtkTreeViewColumn *column,
688 g_print ("Row activated\n");
693 TARGET_GTK_TREE_MODEL_ROW
696 static GtkTargetEntry row_targets[] = {
697 { "GTK_TREE_MODEL_ROW", GTK_TARGET_SAME_APP,
698 TARGET_GTK_TREE_MODEL_ROW }
709 GtkWidget *combo_box;
713 gtk_init (&argc, &argv);
715 if (g_getenv ("RTL"))
716 gtk_widget_set_default_direction (GTK_TEXT_DIR_RTL);
718 our_pixbuf = gdk_pixbuf_new_from_xpm_data ((const char **) book_closed_xpm);
721 models[MODEL_TYPES] = GTK_TREE_MODEL (gtk_tree_model_types_new ());
723 models[MODEL_LIST] = create_list_model ();
724 models[MODEL_TREE] = create_tree_model ();
726 model = create_list_model ();
727 models[MODEL_SORTED_LIST] = gtk_tree_model_sort_new_with_model (model);
728 g_object_unref (model);
730 model = create_tree_model ();
731 models[MODEL_SORTED_TREE] = gtk_tree_model_sort_new_with_model (model);
732 g_object_unref (model);
734 models[MODEL_EMPTY_LIST] = GTK_TREE_MODEL (gtk_list_store_new (1, G_TYPE_INT));
735 models[MODEL_EMPTY_TREE] = GTK_TREE_MODEL (gtk_tree_store_new (1, G_TYPE_INT));
737 models[MODEL_NULL] = NULL;
739 run_automated_tests ();
741 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
742 g_signal_connect (window, "destroy", G_CALLBACK (gtk_main_quit), NULL);
743 gtk_window_set_default_size (GTK_WINDOW (window), 430, 400);
745 box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
747 gtk_container_add (GTK_CONTAINER (window), box);
749 tv = gtk_tree_view_new_with_model (models[0]);
750 g_signal_connect (tv, "row-activated", G_CALLBACK (on_row_activated), NULL);
752 gtk_tree_view_enable_model_drag_source (GTK_TREE_VIEW (tv),
755 G_N_ELEMENTS (row_targets),
756 GDK_ACTION_MOVE | GDK_ACTION_COPY);
758 gtk_tree_view_enable_model_drag_dest (GTK_TREE_VIEW (tv),
760 G_N_ELEMENTS (row_targets),
761 GDK_ACTION_MOVE | GDK_ACTION_COPY);
764 combo_box = gtk_combo_box_text_new ();
765 gtk_widget_set_halign (combo_box, GTK_ALIGN_CENTER);
766 for (i = 0; i < MODEL_LAST; i++)
767 gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo_box), model_names[i]);
769 gtk_container_add (GTK_CONTAINER (box), combo_box);
770 g_signal_connect (combo_box,
772 G_CALLBACK (model_selected),
776 combo_box = gtk_combo_box_text_new ();
777 gtk_widget_set_halign (combo_box, GTK_ALIGN_CENTER);
778 for (i = 0; i < COLUMNS_LAST; i++)
779 gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo_box), column_type_names[i]);
781 gtk_container_add (GTK_CONTAINER (box), combo_box);
783 set_columns_type (GTK_TREE_VIEW (tv), COLUMNS_LOTS);
784 gtk_combo_box_set_active (GTK_COMBO_BOX (combo_box), COLUMNS_LOTS);
786 g_signal_connect (combo_box,
788 G_CALLBACK (columns_selected),
791 sw = gtk_scrolled_window_new (NULL, NULL);
792 gtk_widget_set_hexpand (sw, TRUE);
793 gtk_widget_set_vexpand (sw, TRUE);
794 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
795 GTK_POLICY_AUTOMATIC,
796 GTK_POLICY_AUTOMATIC);
798 gtk_container_add (GTK_CONTAINER (box), sw);
800 gtk_container_add (GTK_CONTAINER (sw), tv);
802 create_prop_editor (G_OBJECT (tv), GTK_TYPE_TREE_VIEW);
803 create_prop_editor (G_OBJECT (gtk_tree_view_get_selection (GTK_TREE_VIEW (tv))), GTK_TYPE_TREE_SELECTION);
805 gtk_widget_show_all (window);
816 static void gtk_tree_model_types_init (GtkTreeModelTypes *model_types);
817 static void gtk_tree_model_types_tree_model_init (GtkTreeModelIface *iface);
818 static gint gtk_real_model_types_get_n_columns (GtkTreeModel *tree_model);
819 static GType gtk_real_model_types_get_column_type (GtkTreeModel *tree_model,
821 static GtkTreePath *gtk_real_model_types_get_path (GtkTreeModel *tree_model,
823 static void gtk_real_model_types_get_value (GtkTreeModel *tree_model,
827 static gboolean gtk_real_model_types_iter_next (GtkTreeModel *tree_model,
829 static gboolean gtk_real_model_types_iter_children (GtkTreeModel *tree_model,
831 GtkTreeIter *parent);
832 static gboolean gtk_real_model_types_iter_has_child (GtkTreeModel *tree_model,
834 static gint gtk_real_model_types_iter_n_children (GtkTreeModel *tree_model,
836 static gboolean gtk_real_model_types_iter_nth_child (GtkTreeModel *tree_model,
840 static gboolean gtk_real_model_types_iter_parent (GtkTreeModel *tree_model,
846 gtk_tree_model_types_get_type (void)
848 static GType model_types_type = 0;
850 if (!model_types_type)
852 const GTypeInfo model_types_info =
854 sizeof (GtkTreeModelTypesClass),
855 NULL, /* base_init */
856 NULL, /* base_finalize */
857 NULL, /* class_init */
858 NULL, /* class_finalize */
859 NULL, /* class_data */
860 sizeof (GtkTreeModelTypes),
862 (GInstanceInitFunc) gtk_tree_model_types_init
865 const GInterfaceInfo tree_model_info =
867 (GInterfaceInitFunc) gtk_tree_model_types_tree_model_init,
872 model_types_type = g_type_register_static (G_TYPE_OBJECT,
874 &model_types_info, 0);
875 g_type_add_interface_static (model_types_type,
880 return model_types_type;
884 gtk_tree_model_types_new (void)
886 GtkTreeModelTypes *retval;
888 retval = g_object_new (GTK_TYPE_MODEL_TYPES, NULL);
894 gtk_tree_model_types_tree_model_init (GtkTreeModelIface *iface)
896 iface->get_n_columns = gtk_real_model_types_get_n_columns;
897 iface->get_column_type = gtk_real_model_types_get_column_type;
898 iface->get_path = gtk_real_model_types_get_path;
899 iface->get_value = gtk_real_model_types_get_value;
900 iface->iter_next = gtk_real_model_types_iter_next;
901 iface->iter_children = gtk_real_model_types_iter_children;
902 iface->iter_has_child = gtk_real_model_types_iter_has_child;
903 iface->iter_n_children = gtk_real_model_types_iter_n_children;
904 iface->iter_nth_child = gtk_real_model_types_iter_nth_child;
905 iface->iter_parent = gtk_real_model_types_iter_parent;
909 gtk_tree_model_types_init (GtkTreeModelTypes *model_types)
911 model_types->stamp = g_random_int ();
914 static GType column_types[] = {
915 G_TYPE_STRING, /* GType */
916 G_TYPE_STRING /* type name */
920 gtk_real_model_types_get_n_columns (GtkTreeModel *tree_model)
922 return G_N_ELEMENTS (column_types);
926 gtk_real_model_types_get_column_type (GtkTreeModel *tree_model,
929 g_return_val_if_fail (index < G_N_ELEMENTS (column_types), G_TYPE_INVALID);
931 return column_types[index];
935 /* Use default implementation of this */
937 gtk_real_model_types_get_iter (GtkTreeModel *tree_model,
945 /* The toplevel nodes of the tree are the reserved types, G_TYPE_NONE through
946 * G_TYPE_RESERVED_FUNDAMENTAL.
950 gtk_real_model_types_get_path (GtkTreeModel *tree_model,
957 g_return_val_if_fail (GTK_IS_TREE_MODEL_TYPES (tree_model), NULL);
958 g_return_val_if_fail (iter != NULL, NULL);
960 type = GPOINTER_TO_INT (iter->user_data);
962 retval = gtk_tree_path_new ();
964 parent = g_type_parent (type);
965 while (parent != G_TYPE_INVALID)
967 GType* children = g_type_children (parent, NULL);
970 if (!children || children[0] == G_TYPE_INVALID)
972 g_warning ("bad iterator?");
976 while (children[i] != type)
979 gtk_tree_path_prepend_index (retval, i);
984 parent = g_type_parent (parent);
987 /* The fundamental type itself is the index on the toplevel */
988 gtk_tree_path_prepend_index (retval, type);
994 gtk_real_model_types_get_value (GtkTreeModel *tree_model,
1001 type = GPOINTER_TO_INT (iter->user_data);
1009 g_value_init (value, G_TYPE_STRING);
1011 str = g_strdup_printf ("%ld", (long int) type);
1012 g_value_set_string (value, str);
1018 g_value_init (value, G_TYPE_STRING);
1019 g_value_set_string (value, g_type_name (type));
1023 g_warning ("Bad column %d requested", column);
1028 gtk_real_model_types_iter_next (GtkTreeModel *tree_model,
1035 type = GPOINTER_TO_INT (iter->user_data);
1037 parent = g_type_parent (type);
1039 if (parent == G_TYPE_INVALID)
1041 /* find next _valid_ fundamental type */
1044 while (!g_type_name (type) && type <= G_TYPE_FUNDAMENTAL_MAX);
1045 if (type <= G_TYPE_FUNDAMENTAL_MAX)
1048 iter->user_data = GINT_TO_POINTER (type);
1056 GType* children = g_type_children (parent, NULL);
1059 g_assert (children != NULL);
1061 while (children[i] != type)
1066 if (children[i] != G_TYPE_INVALID)
1069 iter->user_data = GINT_TO_POINTER (children[i]);
1081 gtk_real_model_types_iter_children (GtkTreeModel *tree_model,
1083 GtkTreeIter *parent)
1088 type = GPOINTER_TO_INT (parent->user_data);
1090 children = g_type_children (type, NULL);
1092 if (!children || children[0] == G_TYPE_INVALID)
1099 iter->user_data = GINT_TO_POINTER (children[0]);
1106 gtk_real_model_types_iter_has_child (GtkTreeModel *tree_model,
1112 type = GPOINTER_TO_INT (iter->user_data);
1114 children = g_type_children (type, NULL);
1116 if (!children || children[0] == G_TYPE_INVALID)
1129 gtk_real_model_types_iter_n_children (GtkTreeModel *tree_model,
1134 return G_TYPE_FUNDAMENTAL_MAX;
1140 guint n_children = 0;
1142 type = GPOINTER_TO_INT (iter->user_data);
1144 children = g_type_children (type, &n_children);
1153 gtk_real_model_types_iter_nth_child (GtkTreeModel *tree_model,
1155 GtkTreeIter *parent,
1160 /* fundamental type */
1161 if (n < G_TYPE_FUNDAMENTAL_MAX)
1163 iter->user_data = GINT_TO_POINTER (n);
1171 GType type = GPOINTER_TO_INT (parent->user_data);
1172 guint n_children = 0;
1173 GType* children = g_type_children (type, &n_children);
1175 if (n_children == 0)
1180 else if (n >= n_children)
1187 iter->user_data = GINT_TO_POINTER (children[n]);
1196 gtk_real_model_types_iter_parent (GtkTreeModel *tree_model,
1203 type = GPOINTER_TO_INT (child->user_data);
1205 parent = g_type_parent (type);
1207 if (parent == G_TYPE_INVALID)
1209 if (type > G_TYPE_FUNDAMENTAL_MAX)
1210 g_warning ("no parent for %ld %s\n",
1212 g_type_name (type));
1217 iter->user_data = GINT_TO_POINTER (parent);
1230 treestore_torture_recurse (GtkTreeStore *store,
1234 GtkTreeModel *model;
1238 model = GTK_TREE_MODEL (store);
1245 gtk_tree_store_append (store, &iter, root);
1247 gtk_tree_model_iter_children (model, &iter, root);
1252 gtk_tree_store_append (store, &iter, root);
1256 while (gtk_tree_model_iter_children (model, &iter, root))
1257 gtk_tree_store_remove (store, &iter);
1259 gtk_tree_store_append (store, &iter, root);
1261 /* inserts before last node in tree */
1265 gtk_tree_store_insert_before (store, &iter, root, &iter);
1269 /* inserts after the node before the last node */
1273 gtk_tree_store_insert_after (store, &iter, root, &iter);
1277 /* inserts after the last node */
1278 gtk_tree_store_append (store, &iter, root);
1283 gtk_tree_store_insert_after (store, &iter, root, &iter);
1287 /* remove everything again */
1288 while (gtk_tree_model_iter_children (model, &iter, root))
1289 gtk_tree_store_remove (store, &iter);
1293 gtk_tree_store_prepend (store, &iter, root);
1298 gtk_tree_store_prepend (store, &iter, root);
1302 /* remove everything again */
1303 while (gtk_tree_model_iter_children (model, &iter, root))
1304 gtk_tree_store_remove (store, &iter);
1306 gtk_tree_store_append (store, &iter, root);
1307 gtk_tree_store_append (store, &iter, root);
1308 gtk_tree_store_append (store, &iter, root);
1309 gtk_tree_store_append (store, &iter, root);
1311 while (gtk_tree_model_iter_children (model, &iter, root))
1313 treestore_torture_recurse (store, &iter, depth);
1314 gtk_tree_store_remove (store, &iter);
1321 run_automated_tests (void)
1323 g_print ("Running automated tests...\n");
1325 /* FIXME TreePath basic verification */
1327 /* FIXME generic consistency checks on the models */
1330 /* Make sure list store mutations don't crash anything */
1331 GtkListStore *store;
1332 GtkTreeModel *model;
1336 store = gtk_list_store_new (1, G_TYPE_INT);
1338 model = GTK_TREE_MODEL (store);
1343 gtk_list_store_append (store, &iter);
1347 while (gtk_tree_model_get_iter_first (model, &iter))
1348 gtk_list_store_remove (store, &iter);
1350 gtk_list_store_append (store, &iter);
1352 /* inserts before last node in list */
1356 gtk_list_store_insert_before (store, &iter, &iter);
1360 /* inserts after the node before the last node */
1364 gtk_list_store_insert_after (store, &iter, &iter);
1368 /* inserts after the last node */
1369 gtk_list_store_append (store, &iter);
1374 gtk_list_store_insert_after (store, &iter, &iter);
1378 /* remove everything again */
1379 while (gtk_tree_model_get_iter_first (model, &iter))
1380 gtk_list_store_remove (store, &iter);
1384 gtk_list_store_prepend (store, &iter);
1389 gtk_list_store_prepend (store, &iter);
1393 /* remove everything again */
1394 while (gtk_tree_model_get_iter_first (model, &iter))
1395 gtk_list_store_remove (store, &iter);
1397 g_object_unref (store);
1401 /* Make sure tree store mutations don't crash anything */
1402 GtkTreeStore *store;
1405 store = gtk_tree_store_new (1, G_TYPE_INT);
1406 gtk_tree_store_append (GTK_TREE_STORE (store), &root, NULL);
1407 /* Remove test until it is rewritten to work */
1408 /* treestore_torture_recurse (store, &root, 0);*/
1410 g_object_unref (store);
1413 g_print ("Passed.\n");