2 #include "prop-editor.h"
6 /* Don't copy this bad example; inline RGB data is always a better
7 * idea than inline XPMs.
9 static char *book_closed_xpm[] = {
35 static void run_automated_tests (void);
37 /* This custom model is to test custom model use. */
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))
45 typedef struct _GtkTreeModelTypes GtkTreeModelTypes;
46 typedef struct _GtkTreeModelTypesClass GtkTreeModelTypesClass;
48 struct _GtkTreeModelTypes
55 struct _GtkTreeModelTypesClass
57 GtkObjectClass parent_class;
59 guint (* get_flags) (GtkTreeModel *tree_model);
60 gint (* get_n_columns) (GtkTreeModel *tree_model);
61 GType (* get_column_type) (GtkTreeModel *tree_model,
63 gboolean (* get_iter) (GtkTreeModel *tree_model,
66 GtkTreePath *(* get_path) (GtkTreeModel *tree_model,
68 void (* get_value) (GtkTreeModel *tree_model,
72 gboolean (* iter_next) (GtkTreeModel *tree_model,
74 gboolean (* iter_children) (GtkTreeModel *tree_model,
77 gboolean (* iter_has_child) (GtkTreeModel *tree_model,
79 gint (* iter_n_children) (GtkTreeModel *tree_model,
81 gboolean (* iter_nth_child) (GtkTreeModel *tree_model,
85 gboolean (* iter_parent) (GtkTreeModel *tree_model,
88 void (* ref_iter) (GtkTreeModel *tree_model,
90 void (* unref_iter) (GtkTreeModel *tree_model,
93 /* These will be moved into the GtkTreeModelIface eventually */
94 void (* changed) (GtkTreeModel *tree_model,
97 void (* inserted) (GtkTreeModel *tree_model,
100 void (* child_toggled) (GtkTreeModel *tree_model,
103 void (* deleted) (GtkTreeModel *tree_model,
107 GtkType gtk_tree_model_types_get_type (void);
108 GtkTreeModelTypes *gtk_tree_model_types_new (void);
118 static gchar *column_type_names[] = {
127 get_model_types (void)
129 static GType column_types[N_COLUMNS] = { 0 };
131 if (column_types[0] == 0)
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;
149 col_clicked_cb (GtkTreeViewColumn *col, gpointer data)
153 win = GTK_WINDOW (create_prop_editor (G_OBJECT (col), GTK_TYPE_TREE_VIEW_COLUMN));
155 gtk_window_set_title (win, gtk_tree_view_column_get_title (col));
159 setup_column (GtkTreeViewColumn *col)
161 gtk_tree_view_column_set_clickable (col, TRUE);
162 g_signal_connect (G_OBJECT (col),
164 (GCallback) col_clicked_cb,
169 toggled_callback (GtkCellRendererToggle *celltoggle,
171 GtkTreeView *tree_view)
173 GtkTreeModel *model = NULL;
174 GtkTreeModelSort *sort_model = NULL;
177 gboolean active = FALSE;
179 g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
181 model = gtk_tree_view_get_model (tree_view);
183 if (GTK_IS_TREE_MODEL_SORT (model))
185 sort_model = GTK_TREE_MODEL_SORT (model);
186 model = gtk_tree_model_sort_get_model (sort_model);
194 g_warning ("FIXME implement conversion from TreeModelSort iter to child model iter");
198 path = gtk_tree_path_new_from_string (path_string);
199 if (!gtk_tree_model_get_iter (model,
202 g_warning ("%s: bad path?", G_STRLOC);
205 gtk_tree_path_free (path);
207 if (GTK_IS_LIST_STORE (model))
209 gtk_tree_model_get (GTK_TREE_MODEL (model),
215 gtk_list_store_set (GTK_LIST_STORE (model),
221 else if (GTK_IS_TREE_STORE (model))
223 gtk_tree_model_get (GTK_TREE_MODEL (model),
229 gtk_tree_store_set (GTK_TREE_STORE (model),
236 g_warning ("don't know how to actually toggle value for model type %s",
237 g_type_name (G_TYPE_FROM_INSTANCE (model)));
241 static ColumnsType current_column_type = COLUMNS_LOTS;
244 set_columns_type (GtkTreeView *tree_view, ColumnsType type)
246 GtkTreeViewColumn *col;
247 GtkCellRenderer *rend;
251 current_column_type = type;
253 col = gtk_tree_view_get_column (tree_view, 0);
256 gtk_tree_view_remove_column (tree_view, col);
258 col = gtk_tree_view_get_column (tree_view, 0);
261 gtk_tree_view_set_rules_hint (tree_view, FALSE);
269 /* with lots of columns we need to turn on rules */
270 gtk_tree_view_set_rules_hint (tree_view, TRUE);
272 rend = gtk_cell_renderer_text_new ();
274 col = gtk_tree_view_column_new_with_attributes ("Column 1",
280 gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), col);
282 col = gtk_tree_view_column_new();
283 gtk_tree_view_column_set_title (col, "Column 2");
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);
295 gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), col);
296 gtk_tree_view_set_expander_column (tree_view, col);
298 rend = gtk_cell_renderer_toggle_new ();
300 g_signal_connect (G_OBJECT (rend), "toggled",
301 GTK_SIGNAL_FUNC (toggled_callback), tree_view);
303 col = gtk_tree_view_column_new_with_attributes ("Column 3",
305 "active", BOOL_COLUMN,
310 gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), col);
312 pixbuf = gdk_pixbuf_new_from_xpm_data ((const char **)book_closed_xpm);
314 image = gtk_image_new_from_pixbuf (pixbuf);
316 g_object_unref (G_OBJECT (pixbuf));
318 gtk_widget_show (image);
320 gtk_tree_view_column_set_widget (col, image);
322 rend = gtk_cell_renderer_toggle_new ();
324 /* you could also set this per-row by tying it to a column
325 * in the model of course.
327 g_object_set (G_OBJECT (rend), "radio", TRUE, NULL);
329 g_signal_connect (G_OBJECT (rend), "toggled",
330 G_CALLBACK (toggled_callback), tree_view);
332 col = gtk_tree_view_column_new_with_attributes ("Column 4",
334 "active", BOOL_COLUMN,
339 gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), col);
343 rend = gtk_cell_renderer_text_new ();
345 col = gtk_tree_view_column_new_with_attributes ("Column 5",
352 gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), col);
354 rend = gtk_cell_renderer_text_new ();
356 col = gtk_tree_view_column_new_with_attributes ("Column 6",
363 gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), col);
365 rend = gtk_cell_renderer_text_new ();
367 col = gtk_tree_view_column_new_with_attributes ("Column 7",
374 gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), col);
376 rend = gtk_cell_renderer_text_new ();
378 col = gtk_tree_view_column_new_with_attributes ("Column 8",
385 gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), col);
387 rend = gtk_cell_renderer_text_new ();
389 col = gtk_tree_view_column_new_with_attributes ("Column 9",
396 gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), col);
398 rend = gtk_cell_renderer_text_new ();
400 col = gtk_tree_view_column_new_with_attributes ("Column 10",
407 gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), col);
414 rend = gtk_cell_renderer_text_new ();
416 col = gtk_tree_view_column_new_with_attributes ("Column 0",
423 gtk_tree_view_insert_column (GTK_TREE_VIEW (tree_view), col, 0);
430 get_columns_type (void)
432 return current_column_type;
435 static GdkPixbuf *our_pixbuf;
450 /* FIXME add a custom model to test */
451 static GtkTreeModel *models[MODEL_LAST];
452 static const char *model_names[MODEL_LAST] = {
455 "GtkTreeModelSort wrapping GtkTreeStore",
456 "GtkTreeModelSort wrapping GtkListStore",
457 "Empty GtkListStore",
458 "Empty GtkTreeStore",
463 create_list_model (void)
470 t = get_model_types ();
472 store = gtk_list_store_new (N_COLUMNS,
482 gtk_list_store_append (store, &iter);
484 msg = g_strdup_printf ("%d", i);
486 gtk_list_store_set (store, &iter, 0, msg, 1, "Foo! Foo! Foo!",
488 3, 7.0, 4, (guint) 9000,
490 7, TRUE, 8, 23245454,
498 return GTK_TREE_MODEL (store);
502 typesystem_recurse (GType type,
503 GtkTreeIter *parent_iter,
507 guint n_children = 0;
512 gtk_tree_store_append (store, &iter, parent_iter);
514 str = g_strdup_printf ("%d", type);
515 gtk_tree_store_set (store, &iter, 0, str, 1, g_type_name (type),
517 3, 7.0, 4, (guint) 9000,
519 7, TRUE, 8, 23245454,
523 children = g_type_children (type, &n_children);
526 while (i < n_children)
528 typesystem_recurse (children[i], &iter, store);
537 create_tree_model (void)
542 volatile GType dummy; /* G_GNUC_CONST makes the optimizer remove
543 * get_type calls if you don't do something
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 ();
554 t = get_model_types ();
556 store = gtk_tree_store_new (N_COLUMNS,
562 while (i < G_TYPE_RESERVED_LAST_FUNDAMENTAL)
564 typesystem_recurse (i, NULL, store);
569 return GTK_TREE_MODEL (store);
573 model_selected (GtkOptionMenu *om, gpointer data)
575 GtkTreeView *tree_view = GTK_TREE_VIEW (data);
578 hist = gtk_option_menu_get_history (om);
580 if (models[hist] != gtk_tree_view_get_model (tree_view))
582 gtk_tree_view_set_model (tree_view, models[hist]);
587 columns_selected (GtkOptionMenu *om, gpointer data)
589 GtkTreeView *tree_view = GTK_TREE_VIEW (data);
592 hist = gtk_option_menu_get_history (om);
594 if (hist != get_columns_type ())
596 set_columns_type (tree_view, hist);
603 TARGET_GTK_TREE_MODEL_ROW
606 static GtkTargetEntry row_targets[] = {
607 { "GTK_TREE_MODEL_ROW", GTK_TARGET_SAME_APP,
608 TARGET_GTK_TREE_MODEL_ROW }
624 gtk_init (&argc, &argv);
626 our_pixbuf = gdk_pixbuf_new_from_xpm_data ((const char **) book_closed_xpm);
629 models[MODEL_TYPES] = GTK_TREE_MODEL (gtk_tree_model_types_new ());
631 models[MODEL_LIST] = create_list_model ();
632 models[MODEL_TREE] = create_tree_model ();
634 model = create_list_model ();
635 models[MODEL_SORTED_LIST] = gtk_tree_model_sort_new_with_model (model);
636 g_object_unref (G_OBJECT (model));
638 model = create_tree_model ();
639 models[MODEL_SORTED_TREE] = gtk_tree_model_sort_new_with_model (model);
640 g_object_unref (G_OBJECT (model));
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));
645 models[MODEL_NULL] = NULL;
647 run_automated_tests ();
649 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
651 gtk_window_set_default_size (GTK_WINDOW (window), 400, 400);
653 table = gtk_table_new (3, 1, FALSE);
655 gtk_container_add (GTK_CONTAINER (window), table);
657 tv = gtk_tree_view_new_with_model (models[0]);
659 gtk_tree_view_enable_model_drag_source (GTK_TREE_VIEW (tv),
662 G_N_ELEMENTS (row_targets),
663 GDK_ACTION_MOVE | GDK_ACTION_COPY);
665 gtk_tree_view_enable_model_drag_dest (GTK_TREE_VIEW (tv),
667 G_N_ELEMENTS (row_targets),
668 GDK_ACTION_MOVE | GDK_ACTION_COPY);
672 menu = gtk_menu_new ();
675 while (i < MODEL_LAST)
680 name = model_names[i];
682 mi = gtk_menu_item_new_with_label (name);
684 gtk_menu_shell_append (GTK_MENU_SHELL (menu), mi);
687 window = create_prop_editor (G_OBJECT (models[i]));
689 gtk_window_set_title (GTK_WINDOW (window),
695 gtk_widget_show_all (menu);
697 om = gtk_option_menu_new ();
698 gtk_option_menu_set_menu (GTK_OPTION_MENU (om), menu);
700 gtk_table_attach (GTK_TABLE (table), om,
705 gtk_signal_connect (GTK_OBJECT (om),
707 GTK_SIGNAL_FUNC (model_selected),
712 menu = gtk_menu_new ();
715 while (i < COLUMNS_LAST)
720 name = column_type_names[i];
722 mi = gtk_menu_item_new_with_label (name);
724 gtk_menu_shell_append (GTK_MENU_SHELL (menu), mi);
728 gtk_widget_show_all (menu);
730 om = gtk_option_menu_new ();
731 gtk_option_menu_set_menu (GTK_OPTION_MENU (om), menu);
733 gtk_table_attach (GTK_TABLE (table), om,
738 set_columns_type (GTK_TREE_VIEW (tv), COLUMNS_LOTS);
739 gtk_option_menu_set_history (GTK_OPTION_MENU (om), COLUMNS_LOTS);
741 gtk_signal_connect (GTK_OBJECT (om),
743 GTK_SIGNAL_FUNC (columns_selected),
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);
751 gtk_table_attach (GTK_TABLE (table), sw,
753 GTK_EXPAND | GTK_FILL,
754 GTK_EXPAND | GTK_FILL,
757 gtk_container_add (GTK_CONTAINER (sw), tv);
759 gtk_widget_show_all (window);
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,
775 static GtkTreePath *gtk_real_model_types_get_path (GtkTreeModel *tree_model,
777 static void gtk_real_model_types_get_value (GtkTreeModel *tree_model,
781 static gboolean gtk_real_model_types_iter_next (GtkTreeModel *tree_model,
783 static gboolean gtk_real_model_types_iter_children (GtkTreeModel *tree_model,
785 GtkTreeIter *parent);
786 static gboolean gtk_real_model_types_iter_has_child (GtkTreeModel *tree_model,
788 static gint gtk_real_model_types_iter_n_children (GtkTreeModel *tree_model,
790 static gboolean gtk_real_model_types_iter_nth_child (GtkTreeModel *tree_model,
794 static gboolean gtk_real_model_types_iter_parent (GtkTreeModel *tree_model,
800 gtk_tree_model_types_get_type (void)
802 static GtkType model_types_type = 0;
804 if (!model_types_type)
806 static const GTypeInfo model_types_info =
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),
816 (GInstanceInitFunc) gtk_tree_model_types_init
819 static const GInterfaceInfo tree_model_info =
821 (GInterfaceInitFunc) gtk_tree_model_types_tree_model_init,
826 model_types_type = g_type_register_static (GTK_TYPE_OBJECT, "GtkTreeModelTypes", &model_types_info, 0);
827 g_type_add_interface_static (model_types_type,
832 return model_types_type;
836 gtk_tree_model_types_new (void)
838 GtkTreeModelTypes *retval;
840 retval = GTK_TREE_MODEL_TYPES (g_object_new (GTK_TYPE_MODEL_TYPES, NULL));
846 gtk_tree_model_types_tree_model_init (GtkTreeModelIface *iface)
848 iface->get_n_columns = gtk_real_model_types_get_n_columns;
849 iface->get_column_type = gtk_real_model_types_get_column_type;
850 iface->get_path = gtk_real_model_types_get_path;
851 iface->get_value = gtk_real_model_types_get_value;
852 iface->iter_next = gtk_real_model_types_iter_next;
853 iface->iter_children = gtk_real_model_types_iter_children;
854 iface->iter_has_child = gtk_real_model_types_iter_has_child;
855 iface->iter_n_children = gtk_real_model_types_iter_n_children;
856 iface->iter_nth_child = gtk_real_model_types_iter_nth_child;
857 iface->iter_parent = gtk_real_model_types_iter_parent;
861 gtk_tree_model_types_init (GtkTreeModelTypes *model_types)
863 model_types->stamp = g_random_int ();
866 static GType column_types[] = {
867 G_TYPE_STRING, /* GType */
868 G_TYPE_STRING /* type name */
872 gtk_real_model_types_get_n_columns (GtkTreeModel *tree_model)
874 return G_N_ELEMENTS (column_types);
878 gtk_real_model_types_get_column_type (GtkTreeModel *tree_model,
881 g_return_val_if_fail (index < G_N_ELEMENTS (column_types), G_TYPE_INVALID);
883 return column_types[index];
887 /* Use default implementation of this */
889 gtk_real_model_types_get_iter (GtkTreeModel *tree_model,
897 /* The toplevel nodes of the tree are the reserved types, G_TYPE_NONE through
898 * G_TYPE_RESERVED_FUNDAMENTAL.
902 gtk_real_model_types_get_path (GtkTreeModel *tree_model,
909 g_return_val_if_fail (GTK_IS_TREE_MODEL_TYPES (tree_model), NULL);
910 g_return_val_if_fail (iter != NULL, NULL);
912 type = GPOINTER_TO_INT (iter->user_data);
914 retval = gtk_tree_path_new ();
916 parent = g_type_parent (type);
917 while (parent != G_TYPE_INVALID)
919 GType* children = g_type_children (parent, NULL);
922 if (!children || children[0] == G_TYPE_INVALID)
924 g_warning ("bad iterator?");
928 while (children[i] != type)
931 gtk_tree_path_prepend_index (retval, i);
936 parent = g_type_parent (parent);
939 /* The fundamental type itself is the index on the toplevel */
940 gtk_tree_path_prepend_index (retval, type);
946 gtk_real_model_types_get_value (GtkTreeModel *tree_model,
953 type = GPOINTER_TO_INT (iter->user_data);
961 g_value_init (value, G_TYPE_STRING);
963 str = g_strdup_printf ("%d", type);
964 g_value_set_string (value, str);
970 g_value_init (value, G_TYPE_STRING);
971 g_value_set_string (value, g_type_name (type));
975 g_warning ("Bad column %d requested", column);
980 gtk_real_model_types_iter_next (GtkTreeModel *tree_model,
987 type = GPOINTER_TO_INT (iter->user_data);
989 parent = g_type_parent (type);
991 if (parent == G_TYPE_INVALID)
993 /* fundamental type, add 1 */
994 if ((type + 1) < G_TYPE_RESERVED_LAST_FUNDAMENTAL)
996 iter->user_data = GINT_TO_POINTER (type + 1);
1004 GType* children = g_type_children (parent, NULL);
1007 g_assert (children != NULL);
1009 while (children[i] != type)
1014 if (children[i] != G_TYPE_INVALID)
1017 iter->user_data = GINT_TO_POINTER (children[i]);
1029 gtk_real_model_types_iter_children (GtkTreeModel *tree_model,
1031 GtkTreeIter *parent)
1036 type = GPOINTER_TO_INT (parent->user_data);
1038 children = g_type_children (type, NULL);
1040 if (!children || children[0] == G_TYPE_INVALID)
1047 iter->user_data = GINT_TO_POINTER (children[0]);
1054 gtk_real_model_types_iter_has_child (GtkTreeModel *tree_model,
1060 type = GPOINTER_TO_INT (iter->user_data);
1062 children = g_type_children (type, NULL);
1064 if (!children || children[0] == G_TYPE_INVALID)
1077 gtk_real_model_types_iter_n_children (GtkTreeModel *tree_model,
1082 return G_TYPE_RESERVED_LAST_FUNDAMENTAL - 1;
1088 guint n_children = 0;
1090 type = GPOINTER_TO_INT (iter->user_data);
1092 children = g_type_children (type, &n_children);
1101 gtk_real_model_types_iter_nth_child (GtkTreeModel *tree_model,
1103 GtkTreeIter *parent,
1108 /* fundamental type */
1109 if (n < G_TYPE_RESERVED_LAST_FUNDAMENTAL)
1111 iter->user_data = GINT_TO_POINTER (n);
1119 GType type = GPOINTER_TO_INT (parent->user_data);
1120 guint n_children = 0;
1121 GType* children = g_type_children (type, &n_children);
1123 if (n_children == 0)
1128 else if (n >= n_children)
1135 iter->user_data = GINT_TO_POINTER (children[n]);
1144 gtk_real_model_types_iter_parent (GtkTreeModel *tree_model,
1151 type = GPOINTER_TO_INT (child->user_data);
1153 parent = g_type_parent (type);
1155 if (parent == G_TYPE_INVALID)
1157 if (type >= G_TYPE_RESERVED_LAST_FUNDAMENTAL)
1158 g_warning ("no parent for %d %s\n", type, g_type_name (type));
1163 iter->user_data = GINT_TO_POINTER (parent);
1174 treestore_torture_recurse (GtkTreeStore *store,
1178 GtkTreeModel *model;
1182 model = GTK_TREE_MODEL (store);
1189 gtk_tree_store_append (store, &iter, root);
1191 gtk_tree_model_iter_children (model, &iter, root);
1196 gtk_tree_store_append (store, &iter, root);
1200 while (gtk_tree_model_iter_children (model, &iter, root))
1201 gtk_tree_store_remove (store, &iter);
1203 gtk_tree_store_append (store, &iter, root);
1205 /* inserts before last node in tree */
1209 gtk_tree_store_insert_before (store, &iter, root, &iter);
1213 /* inserts after the node before the last node */
1217 gtk_tree_store_insert_after (store, &iter, root, &iter);
1221 /* inserts after the last node */
1222 gtk_tree_store_append (store, &iter, root);
1227 gtk_tree_store_insert_after (store, &iter, root, &iter);
1231 /* remove everything again */
1232 while (gtk_tree_model_iter_children (model, &iter, root))
1233 gtk_tree_store_remove (store, &iter);
1237 gtk_tree_store_prepend (store, &iter, root);
1242 gtk_tree_store_prepend (store, &iter, root);
1246 /* remove everything again */
1247 while (gtk_tree_model_iter_children (model, &iter, root))
1248 gtk_tree_store_remove (store, &iter);
1250 gtk_tree_store_append (store, &iter, root);
1251 gtk_tree_store_append (store, &iter, root);
1252 gtk_tree_store_append (store, &iter, root);
1253 gtk_tree_store_append (store, &iter, root);
1255 while (gtk_tree_model_iter_children (model, &iter, root))
1257 treestore_torture_recurse (store, &iter, depth);
1258 gtk_tree_store_remove (store, &iter);
1263 run_automated_tests (void)
1265 g_print ("Running automated tests...\n");
1267 /* FIXME TreePath basic verification */
1269 /* FIXME generic consistency checks on the models */
1272 /* Make sure list store mutations don't crash anything */
1273 GtkListStore *store;
1274 GtkTreeModel *model;
1278 store = gtk_list_store_new (1, G_TYPE_INT);
1280 model = GTK_TREE_MODEL (store);
1285 gtk_list_store_append (store, &iter);
1289 while (gtk_tree_model_get_iter_root (model, &iter))
1290 gtk_list_store_remove (store, &iter);
1292 gtk_list_store_append (store, &iter);
1294 /* inserts before last node in list */
1298 gtk_list_store_insert_before (store, &iter, &iter);
1302 /* inserts after the node before the last node */
1306 gtk_list_store_insert_after (store, &iter, &iter);
1310 /* inserts after the last node */
1311 gtk_list_store_append (store, &iter);
1316 gtk_list_store_insert_after (store, &iter, &iter);
1320 /* remove everything again */
1321 while (gtk_tree_model_get_iter_root (model, &iter))
1322 gtk_list_store_remove (store, &iter);
1326 gtk_list_store_prepend (store, &iter);
1331 gtk_list_store_prepend (store, &iter);
1335 /* remove everything again */
1336 while (gtk_tree_model_get_iter_root (model, &iter))
1337 gtk_list_store_remove (store, &iter);
1339 g_object_unref (G_OBJECT (store));
1343 /* Make sure tree store mutations don't crash anything */
1344 GtkTreeStore *store;
1347 store = gtk_tree_store_new (1, G_TYPE_INT);
1348 gtk_tree_store_append (GTK_TREE_STORE (store), &root, NULL);
1349 /* Remove test until it is rewritten to work */
1350 /* treestore_torture_recurse (store, &root, 0);*/
1352 g_object_unref (G_OBJECT (store));
1355 g_print ("Passed.\n");