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