1 /* GTK - The GIMP Toolkit
2 * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Library General Public
6 * License as published by the Free Software Foundation; either
7 * version 2 of the License, or (at your option) any later version.
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Library General Public License for more details.
14 * You should have received a copy of the GNU Library General Public
15 * License along with this library; if not, write to the
16 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
17 * Boston, MA 02111-1307, USA.
27 #include "../gdk/gdk.h"
28 #include "../gdk/gdkx.h"
29 #include "../gdk/gdkkeysyms.h"
31 #include "circles.xbm"
33 typedef struct _OptionMenuItem
40 shape_create_icon (char *xpm_file,
48 build_option_menu (OptionMenuItem items[],
53 /* macro, structure and variables used by tree window demos */
54 #define DEFAULT_NUMBER_OF_ITEM 3
55 #define DEFAULT_RECURSION_LEVEL 3
58 GSList* selection_mode_group;
59 GtkWidget* single_button;
60 GtkWidget* browse_button;
61 GtkWidget* multiple_button;
62 GtkWidget* draw_line_button;
63 GtkWidget* view_line_button;
64 GtkWidget* no_root_item_button;
65 GtkWidget* nb_item_spinner;
66 GtkWidget* recursion_spinner;
67 } sTreeSampleSelection;
69 typedef struct sTreeButtons {
71 GtkWidget* add_button;
72 GtkWidget* remove_button;
73 GtkWidget* subtree_button;
75 /* end of tree section */
78 build_option_menu (OptionMenuItem items[],
89 omenu = gtk_option_menu_new ();
91 menu = gtk_menu_new ();
94 for (i = 0; i < num_items; i++)
96 menu_item = gtk_radio_menu_item_new_with_label (group, items[i].name);
97 gtk_signal_connect (GTK_OBJECT (menu_item), "activate",
98 (GtkSignalFunc) items[i].func, data);
99 group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menu_item));
100 gtk_menu_append (GTK_MENU (menu), menu_item);
102 gtk_check_menu_item_set_state (GTK_CHECK_MENU_ITEM (menu_item), TRUE);
103 gtk_widget_show (menu_item);
106 gtk_option_menu_set_menu (GTK_OPTION_MENU (omenu), menu);
107 gtk_option_menu_set_history (GTK_OPTION_MENU (omenu), history);
113 destroy_tooltips (GtkWidget *widget, GtkWindow **window)
115 GtkTooltips *tt = gtk_object_get_data (GTK_OBJECT (*window), "tooltips");
116 gtk_object_unref (GTK_OBJECT (tt));
125 button_window (GtkWidget *widget,
128 if (!GTK_WIDGET_VISIBLE (button))
129 gtk_widget_show (button);
131 gtk_widget_hide (button);
135 create_buttons (void)
137 static GtkWidget *window = NULL;
141 GtkWidget *button[10];
142 GtkWidget *separator;
146 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
148 gtk_signal_connect (GTK_OBJECT (window), "destroy",
149 GTK_SIGNAL_FUNC (gtk_widget_destroyed),
152 gtk_window_set_title (GTK_WINDOW (window), "GtkButton");
153 gtk_container_border_width (GTK_CONTAINER (window), 0);
155 box1 = gtk_vbox_new (FALSE, 0);
156 gtk_container_add (GTK_CONTAINER (window), box1);
158 table = gtk_table_new (3, 3, FALSE);
159 gtk_table_set_row_spacings (GTK_TABLE (table), 5);
160 gtk_table_set_col_spacings (GTK_TABLE (table), 5);
161 gtk_container_border_width (GTK_CONTAINER (table), 10);
162 gtk_box_pack_start (GTK_BOX (box1), table, TRUE, TRUE, 0);
164 button[0] = gtk_button_new_with_label ("button1");
165 button[1] = gtk_button_new_with_label ("button2");
166 button[2] = gtk_button_new_with_label ("button3");
167 button[3] = gtk_button_new_with_label ("button4");
168 button[4] = gtk_button_new_with_label ("button5");
169 button[5] = gtk_button_new_with_label ("button6");
170 button[6] = gtk_button_new_with_label ("button7");
171 button[7] = gtk_button_new_with_label ("button8");
172 button[8] = gtk_button_new_with_label ("button9");
174 gtk_signal_connect (GTK_OBJECT (button[0]), "clicked",
175 GTK_SIGNAL_FUNC(button_window),
178 gtk_table_attach (GTK_TABLE (table), button[0], 0, 1, 0, 1,
179 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
181 gtk_signal_connect (GTK_OBJECT (button[1]), "clicked",
182 GTK_SIGNAL_FUNC(button_window),
185 gtk_table_attach (GTK_TABLE (table), button[1], 1, 2, 1, 2,
186 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
188 gtk_signal_connect (GTK_OBJECT (button[2]), "clicked",
189 GTK_SIGNAL_FUNC(button_window),
191 gtk_table_attach (GTK_TABLE (table), button[2], 2, 3, 2, 3,
192 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
194 gtk_signal_connect (GTK_OBJECT (button[3]), "clicked",
195 GTK_SIGNAL_FUNC(button_window),
197 gtk_table_attach (GTK_TABLE (table), button[3], 0, 1, 2, 3,
198 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
200 gtk_signal_connect (GTK_OBJECT (button[4]), "clicked",
201 GTK_SIGNAL_FUNC(button_window),
203 gtk_table_attach (GTK_TABLE (table), button[4], 2, 3, 0, 1,
204 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
206 gtk_signal_connect (GTK_OBJECT (button[5]), "clicked",
207 GTK_SIGNAL_FUNC(button_window),
209 gtk_table_attach (GTK_TABLE (table), button[5], 1, 2, 2, 3,
210 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
212 gtk_signal_connect (GTK_OBJECT (button[6]), "clicked",
213 GTK_SIGNAL_FUNC(button_window),
215 gtk_table_attach (GTK_TABLE (table), button[6], 1, 2, 0, 1,
216 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
218 gtk_signal_connect (GTK_OBJECT (button[7]), "clicked",
219 GTK_SIGNAL_FUNC(button_window),
221 gtk_table_attach (GTK_TABLE (table), button[7], 2, 3, 1, 2,
222 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
224 gtk_signal_connect (GTK_OBJECT (button[8]), "clicked",
225 GTK_SIGNAL_FUNC(button_window),
227 gtk_table_attach (GTK_TABLE (table), button[8], 0, 1, 1, 2,
228 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
230 separator = gtk_hseparator_new ();
231 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
233 box2 = gtk_vbox_new (FALSE, 10);
234 gtk_container_border_width (GTK_CONTAINER (box2), 10);
235 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
237 button[9] = gtk_button_new_with_label ("close");
238 gtk_signal_connect_object (GTK_OBJECT (button[9]), "clicked",
239 GTK_SIGNAL_FUNC(gtk_widget_destroy),
240 GTK_OBJECT (window));
241 gtk_box_pack_start (GTK_BOX (box2), button[9], TRUE, TRUE, 0);
242 GTK_WIDGET_SET_FLAGS (button[9], GTK_CAN_DEFAULT);
243 gtk_widget_grab_default (button[9]);
246 if (!GTK_WIDGET_VISIBLE (window))
247 gtk_widget_show_all (window);
249 gtk_widget_destroy (window);
257 create_toggle_buttons (void)
259 static GtkWidget *window = NULL;
263 GtkWidget *separator;
267 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
269 gtk_signal_connect (GTK_OBJECT (window), "destroy",
270 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
273 gtk_window_set_title (GTK_WINDOW (window), "GtkToggleButton");
274 gtk_container_border_width (GTK_CONTAINER (window), 0);
276 box1 = gtk_vbox_new (FALSE, 0);
277 gtk_container_add (GTK_CONTAINER (window), box1);
279 box2 = gtk_vbox_new (FALSE, 10);
280 gtk_container_border_width (GTK_CONTAINER (box2), 10);
281 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
283 button = gtk_toggle_button_new_with_label ("button1");
284 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
286 button = gtk_toggle_button_new_with_label ("button2");
287 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
289 button = gtk_toggle_button_new_with_label ("button3");
290 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
292 separator = gtk_hseparator_new ();
293 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
295 box2 = gtk_vbox_new (FALSE, 10);
296 gtk_container_border_width (GTK_CONTAINER (box2), 10);
297 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
299 button = gtk_button_new_with_label ("close");
300 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
301 GTK_SIGNAL_FUNC(gtk_widget_destroy),
302 GTK_OBJECT (window));
303 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
304 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
305 gtk_widget_grab_default (button);
308 if (!GTK_WIDGET_VISIBLE (window))
309 gtk_widget_show_all (window);
311 gtk_widget_destroy (window);
319 create_check_buttons (void)
321 static GtkWidget *window = NULL;
325 GtkWidget *separator;
329 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
331 gtk_signal_connect (GTK_OBJECT (window), "destroy",
332 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
335 gtk_window_set_title (GTK_WINDOW (window), "GtkCheckButton");
336 gtk_container_border_width (GTK_CONTAINER (window), 0);
338 box1 = gtk_vbox_new (FALSE, 0);
339 gtk_container_add (GTK_CONTAINER (window), box1);
341 box2 = gtk_vbox_new (FALSE, 10);
342 gtk_container_border_width (GTK_CONTAINER (box2), 10);
343 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
345 button = gtk_check_button_new_with_label ("button1");
346 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
348 button = gtk_check_button_new_with_label ("button2");
349 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
351 button = gtk_check_button_new_with_label ("button3");
352 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
354 separator = gtk_hseparator_new ();
355 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
357 box2 = gtk_vbox_new (FALSE, 10);
358 gtk_container_border_width (GTK_CONTAINER (box2), 10);
359 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
361 button = gtk_button_new_with_label ("close");
362 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
363 GTK_SIGNAL_FUNC(gtk_widget_destroy),
364 GTK_OBJECT (window));
365 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
366 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
367 gtk_widget_grab_default (button);
370 if (!GTK_WIDGET_VISIBLE (window))
371 gtk_widget_show_all (window);
373 gtk_widget_destroy (window);
381 create_radio_buttons (void)
383 static GtkWidget *window = NULL;
387 GtkWidget *separator;
391 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
393 gtk_signal_connect (GTK_OBJECT (window), "destroy",
394 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
397 gtk_window_set_title (GTK_WINDOW (window), "radio buttons");
398 gtk_container_border_width (GTK_CONTAINER (window), 0);
400 box1 = gtk_vbox_new (FALSE, 0);
401 gtk_container_add (GTK_CONTAINER (window), box1);
403 box2 = gtk_vbox_new (FALSE, 10);
404 gtk_container_border_width (GTK_CONTAINER (box2), 10);
405 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
407 button = gtk_radio_button_new_with_label (NULL, "button1");
408 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
410 button = gtk_radio_button_new_with_label (
411 gtk_radio_button_group (GTK_RADIO_BUTTON (button)),
413 gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON (button), TRUE);
414 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
416 button = gtk_radio_button_new_with_label (
417 gtk_radio_button_group (GTK_RADIO_BUTTON (button)),
419 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
421 separator = gtk_hseparator_new ();
422 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
424 box2 = gtk_vbox_new (FALSE, 10);
425 gtk_container_border_width (GTK_CONTAINER (box2), 10);
426 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
428 button = gtk_button_new_with_label ("close");
429 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
430 GTK_SIGNAL_FUNC(gtk_widget_destroy),
431 GTK_OBJECT (window));
432 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
433 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
434 gtk_widget_grab_default (button);
437 if (!GTK_WIDGET_VISIBLE (window))
438 gtk_widget_show_all (window);
440 gtk_widget_destroy (window);
448 create_bbox (gint horizontal,
459 frame = gtk_frame_new (title);
462 bbox = gtk_hbutton_box_new ();
464 bbox = gtk_vbutton_box_new ();
466 gtk_container_border_width (GTK_CONTAINER (bbox), 5);
467 gtk_container_add (GTK_CONTAINER (frame), bbox);
469 gtk_button_box_set_layout (GTK_BUTTON_BOX (bbox), layout);
470 gtk_button_box_set_spacing (GTK_BUTTON_BOX (bbox), spacing);
471 gtk_button_box_set_child_size (GTK_BUTTON_BOX (bbox), child_w, child_h);
473 button = gtk_button_new_with_label ("OK");
474 gtk_container_add (GTK_CONTAINER (bbox), button);
476 button = gtk_button_new_with_label ("Cancel");
477 gtk_container_add (GTK_CONTAINER (bbox), button);
479 button = gtk_button_new_with_label ("Help");
480 gtk_container_add (GTK_CONTAINER (bbox), button);
486 create_button_box (void)
488 static GtkWidget* window = NULL;
489 GtkWidget *main_vbox;
492 GtkWidget *frame_horz;
493 GtkWidget *frame_vert;
497 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
498 gtk_window_set_title (GTK_WINDOW (window), "Button Boxes");
500 gtk_signal_connect (GTK_OBJECT (window), "destroy",
501 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
504 gtk_container_border_width (GTK_CONTAINER (window), 10);
506 main_vbox = gtk_vbox_new (FALSE, 0);
507 gtk_container_add (GTK_CONTAINER (window), main_vbox);
509 frame_horz = gtk_frame_new ("Horizontal Button Boxes");
510 gtk_box_pack_start (GTK_BOX (main_vbox), frame_horz, TRUE, TRUE, 10);
512 vbox = gtk_vbox_new (FALSE, 0);
513 gtk_container_border_width (GTK_CONTAINER (vbox), 10);
514 gtk_container_add (GTK_CONTAINER (frame_horz), vbox);
516 gtk_box_pack_start (GTK_BOX (vbox),
517 create_bbox (TRUE, "Spread", 40, 85, 20, GTK_BUTTONBOX_SPREAD),
520 gtk_box_pack_start (GTK_BOX (vbox),
521 create_bbox (TRUE, "Edge", 40, 85, 20, GTK_BUTTONBOX_EDGE),
524 gtk_box_pack_start (GTK_BOX (vbox),
525 create_bbox (TRUE, "Start", 40, 85, 20, GTK_BUTTONBOX_START),
528 gtk_box_pack_start (GTK_BOX (vbox),
529 create_bbox (TRUE, "End", 40, 85, 20, GTK_BUTTONBOX_END),
532 frame_vert = gtk_frame_new ("Vertical Button Boxes");
533 gtk_box_pack_start (GTK_BOX (main_vbox), frame_vert, TRUE, TRUE, 10);
535 hbox = gtk_hbox_new (FALSE, 0);
536 gtk_container_border_width (GTK_CONTAINER (hbox), 10);
537 gtk_container_add (GTK_CONTAINER (frame_vert), hbox);
539 gtk_box_pack_start (GTK_BOX (hbox),
540 create_bbox (FALSE, "Spread", 30, 85, 20, GTK_BUTTONBOX_SPREAD),
543 gtk_box_pack_start (GTK_BOX (hbox),
544 create_bbox (FALSE, "Edge", 30, 85, 20, GTK_BUTTONBOX_EDGE),
547 gtk_box_pack_start (GTK_BOX (hbox),
548 create_bbox (FALSE, "Start", 30, 85, 20, GTK_BUTTONBOX_START),
551 gtk_box_pack_start (GTK_BOX (hbox),
552 create_bbox (FALSE, "End", 30, 85, 20, GTK_BUTTONBOX_END),
556 if (!GTK_WIDGET_VISIBLE (window))
557 gtk_widget_show_all (window);
559 gtk_widget_destroy (window);
567 new_pixmap (char *filename,
569 GdkColor *background)
575 pixmap = gdk_pixmap_create_from_xpm (window, &mask,
578 wpixmap = gtk_pixmap_new (pixmap, mask);
584 set_toolbar_horizontal (GtkWidget *widget,
587 gtk_toolbar_set_orientation (GTK_TOOLBAR (data), GTK_ORIENTATION_HORIZONTAL);
591 set_toolbar_vertical (GtkWidget *widget,
594 gtk_toolbar_set_orientation (GTK_TOOLBAR (data), GTK_ORIENTATION_VERTICAL);
598 set_toolbar_icons (GtkWidget *widget,
601 gtk_toolbar_set_style (GTK_TOOLBAR (data), GTK_TOOLBAR_ICONS);
605 set_toolbar_text (GtkWidget *widget,
608 gtk_toolbar_set_style (GTK_TOOLBAR (data), GTK_TOOLBAR_TEXT);
612 set_toolbar_both (GtkWidget *widget,
615 gtk_toolbar_set_style (GTK_TOOLBAR (data), GTK_TOOLBAR_BOTH);
619 set_toolbar_small_space (GtkWidget *widget,
622 gtk_toolbar_set_space_size (GTK_TOOLBAR (data), 5);
626 set_toolbar_big_space (GtkWidget *widget,
629 gtk_toolbar_set_space_size (GTK_TOOLBAR (data), 10);
633 set_toolbar_enable (GtkWidget *widget,
636 gtk_toolbar_set_tooltips (GTK_TOOLBAR (data), TRUE);
640 set_toolbar_disable (GtkWidget *widget,
643 gtk_toolbar_set_tooltips (GTK_TOOLBAR (data), FALSE);
647 set_toolbar_borders (GtkWidget *widget,
650 gtk_toolbar_set_button_relief (GTK_TOOLBAR (data), GTK_RELIEF_NORMAL);
654 set_toolbar_borderless (GtkWidget *widget,
657 gtk_toolbar_set_button_relief (GTK_TOOLBAR (data), GTK_RELIEF_NONE);
661 create_toolbar (void)
663 static GtkWidget *window = NULL;
669 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
670 gtk_window_set_title (GTK_WINDOW (window), "Toolbar test");
671 gtk_window_set_policy (GTK_WINDOW (window), FALSE, TRUE, TRUE);
673 gtk_signal_connect (GTK_OBJECT (window), "destroy",
674 GTK_SIGNAL_FUNC (gtk_widget_destroyed),
677 gtk_container_border_width (GTK_CONTAINER (window), 0);
678 gtk_widget_realize (window);
680 toolbar = gtk_toolbar_new (GTK_ORIENTATION_HORIZONTAL, GTK_TOOLBAR_BOTH);
681 gtk_toolbar_set_button_relief (GTK_TOOLBAR (toolbar), GTK_RELIEF_NONE);
683 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
684 "Horizontal", "Horizontal toolbar layout", "Toolbar/Horizontal",
685 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
686 (GtkSignalFunc) set_toolbar_horizontal, toolbar);
687 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
688 "Vertical", "Vertical toolbar layout", "Toolbar/Vertical",
689 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
690 (GtkSignalFunc) set_toolbar_vertical, toolbar);
692 gtk_toolbar_append_space (GTK_TOOLBAR(toolbar));
694 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
695 "Icons", "Only show toolbar icons", "Toolbar/IconsOnly",
696 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
697 (GtkSignalFunc) set_toolbar_icons, toolbar);
698 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
699 "Text", "Only show toolbar text", "Toolbar/TextOnly",
700 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
701 (GtkSignalFunc) set_toolbar_text, toolbar);
702 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
703 "Both", "Show toolbar icons and text", "Toolbar/Both",
704 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
705 (GtkSignalFunc) set_toolbar_both, toolbar);
707 gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
709 entry = gtk_entry_new ();
711 gtk_toolbar_append_widget (GTK_TOOLBAR (toolbar), entry, "This is an unusable GtkEntry ;)", "Hey don't click me!!!");
713 gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
715 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
716 "Small", "Use small spaces", "Toolbar/Small",
717 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
718 (GtkSignalFunc) set_toolbar_small_space, toolbar);
719 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
720 "Big", "Use big spaces", "Toolbar/Big",
721 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
722 (GtkSignalFunc) set_toolbar_big_space, toolbar);
724 gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
726 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
727 "Enable", "Enable tooltips", NULL,
728 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
729 (GtkSignalFunc) set_toolbar_enable, toolbar);
730 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
731 "Disable", "Disable tooltips", NULL,
732 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
733 (GtkSignalFunc) set_toolbar_disable, toolbar);
735 gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
737 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
738 "Borders", "Show Borders", NULL,
739 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
740 (GtkSignalFunc) set_toolbar_borders, toolbar);
741 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
742 "Borderless", "Hide Borders", NULL,
743 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
744 (GtkSignalFunc) set_toolbar_borderless, toolbar);
746 gtk_container_add (GTK_CONTAINER (window), toolbar);
749 if (!GTK_WIDGET_VISIBLE (window))
750 gtk_widget_show_all (window);
752 gtk_widget_destroy (window);
756 make_toolbar (GtkWidget *window)
760 if (!GTK_WIDGET_REALIZED (window))
761 gtk_widget_realize (window);
763 toolbar = gtk_toolbar_new (GTK_ORIENTATION_HORIZONTAL, GTK_TOOLBAR_BOTH);
764 gtk_toolbar_set_button_relief (GTK_TOOLBAR (toolbar), GTK_RELIEF_NONE);
766 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
767 "Horizontal", "Horizontal toolbar layout", NULL,
768 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
769 (GtkSignalFunc) set_toolbar_horizontal, toolbar);
770 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
771 "Vertical", "Vertical toolbar layout", NULL,
772 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
773 (GtkSignalFunc) set_toolbar_vertical, toolbar);
775 gtk_toolbar_append_space (GTK_TOOLBAR(toolbar));
777 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
778 "Icons", "Only show toolbar icons", NULL,
779 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
780 (GtkSignalFunc) set_toolbar_icons, toolbar);
781 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
782 "Text", "Only show toolbar text", NULL,
783 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
784 (GtkSignalFunc) set_toolbar_text, toolbar);
785 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
786 "Both", "Show toolbar icons and text", NULL,
787 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
788 (GtkSignalFunc) set_toolbar_both, toolbar);
790 gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
792 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
793 "Small", "Use small spaces", NULL,
794 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
795 (GtkSignalFunc) set_toolbar_small_space, toolbar);
796 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
797 "Big", "Use big spaces", "Toolbar/Big",
798 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
799 (GtkSignalFunc) set_toolbar_big_space, toolbar);
801 gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
803 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
804 "Enable", "Enable tooltips", NULL,
805 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
806 (GtkSignalFunc) set_toolbar_enable, toolbar);
807 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
808 "Disable", "Disable tooltips", NULL,
809 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
810 (GtkSignalFunc) set_toolbar_disable, toolbar);
812 gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
814 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
815 "Borders", "Show Borders", NULL,
816 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
817 (GtkSignalFunc) set_toolbar_borders, toolbar);
818 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
819 "Borderless", "Hide Borders", NULL,
820 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
821 (GtkSignalFunc) set_toolbar_borderless, toolbar);
830 static guint statusbar_counter = 1;
833 statusbar_push (GtkWidget *button,
834 GtkStatusbar *statusbar)
838 sprintf (text, "something %d", statusbar_counter++);
840 gtk_statusbar_push (statusbar, 1, text);
844 statusbar_pop (GtkWidget *button,
845 GtkStatusbar *statusbar)
847 gtk_statusbar_pop (statusbar, 1);
851 statusbar_steal (GtkWidget *button,
852 GtkStatusbar *statusbar)
854 gtk_statusbar_remove (statusbar, 1, 4);
858 statusbar_popped (GtkStatusbar *statusbar,
862 if (!statusbar->messages)
863 statusbar_counter = 1;
867 statusbar_contexts (GtkStatusbar *statusbar)
871 string = "any context";
872 g_print ("GtkStatusBar: context=\"%s\", context_id=%d\n",
874 gtk_statusbar_get_context_id (statusbar, string));
876 string = "idle messages";
877 g_print ("GtkStatusBar: context=\"%s\", context_id=%d\n",
879 gtk_statusbar_get_context_id (statusbar, string));
881 string = "some text";
882 g_print ("GtkStatusBar: context=\"%s\", context_id=%d\n",
884 gtk_statusbar_get_context_id (statusbar, string));
886 string = "hit the mouse";
887 g_print ("GtkStatusBar: context=\"%s\", context_id=%d\n",
889 gtk_statusbar_get_context_id (statusbar, string));
891 string = "hit the mouse2";
892 g_print ("GtkStatusBar: context=\"%s\", context_id=%d\n",
894 gtk_statusbar_get_context_id (statusbar, string));
898 statusbar_dump_stack (GtkStatusbar *statusbar)
902 for (list = statusbar->messages; list; list = list->next)
904 GtkStatusbarMsg *msg;
907 g_print ("context_id: %d, message_id: %d, status_text: \"%s\"\n",
915 create_statusbar (void)
917 static GtkWidget *window = NULL;
921 GtkWidget *separator;
922 GtkWidget *statusbar;
926 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
928 gtk_signal_connect (GTK_OBJECT (window), "destroy",
929 GTK_SIGNAL_FUNC (gtk_widget_destroyed),
932 gtk_window_set_title (GTK_WINDOW (window), "statusbar");
933 gtk_container_border_width (GTK_CONTAINER (window), 0);
935 box1 = gtk_vbox_new (FALSE, 0);
936 gtk_container_add (GTK_CONTAINER (window), box1);
938 box2 = gtk_vbox_new (FALSE, 10);
939 gtk_container_border_width (GTK_CONTAINER (box2), 10);
940 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
942 statusbar = gtk_statusbar_new ();
943 gtk_box_pack_end (GTK_BOX (box1), statusbar, TRUE, TRUE, 0);
944 gtk_signal_connect (GTK_OBJECT (statusbar),
946 GTK_SIGNAL_FUNC (statusbar_popped),
949 button = gtk_widget_new (gtk_button_get_type (),
950 "label", "push something",
953 "signal::clicked", statusbar_push, statusbar,
956 button = gtk_widget_new (gtk_button_get_type (),
960 "signal_after::clicked", statusbar_pop, statusbar,
963 button = gtk_widget_new (gtk_button_get_type (),
967 "signal_after::clicked", statusbar_steal, statusbar,
970 button = gtk_widget_new (gtk_button_get_type (),
971 "label", "dump stack",
974 "object_signal::clicked", statusbar_dump_stack, statusbar,
977 button = gtk_widget_new (gtk_button_get_type (),
978 "label", "test contexts",
981 "object_signal_after::clicked", statusbar_contexts, statusbar,
984 separator = gtk_hseparator_new ();
985 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
987 box2 = gtk_vbox_new (FALSE, 10);
988 gtk_container_border_width (GTK_CONTAINER (box2), 10);
989 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
991 button = gtk_button_new_with_label ("close");
992 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
993 GTK_SIGNAL_FUNC(gtk_widget_destroy),
994 GTK_OBJECT (window));
995 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
996 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
997 gtk_widget_grab_default (button);
1000 if (!GTK_WIDGET_VISIBLE (window))
1001 gtk_widget_show_all (window);
1003 gtk_widget_destroy (window);
1011 cb_tree_destroy_event(GtkWidget* w)
1013 sTreeButtons* tree_buttons;
1015 /* free buttons structure associate at this tree */
1016 tree_buttons = gtk_object_get_user_data(GTK_OBJECT(w));
1021 cb_add_new_item(GtkWidget* w, GtkTree* tree)
1023 sTreeButtons* tree_buttons;
1024 GList* selected_list;
1025 GtkWidget* selected_item;
1027 GtkWidget* item_new;
1030 tree_buttons = gtk_object_get_user_data(GTK_OBJECT(tree));
1032 selected_list = GTK_TREE_SELECTION(tree);
1034 if(selected_list == NULL)
1036 /* there is no item in tree */
1037 subtree = GTK_WIDGET(tree);
1041 /* list can have only one element */
1042 selected_item = GTK_WIDGET(selected_list->data);
1044 subtree = GTK_TREE_ITEM_SUBTREE(selected_item);
1048 /* current selected item have not subtree ... create it */
1049 subtree = gtk_tree_new();
1050 gtk_tree_item_set_subtree(GTK_TREE_ITEM(selected_item),
1055 /* at this point, we know which subtree will be used to add new item */
1056 /* create a new item */
1057 sprintf(buffer, "item add %d", tree_buttons->nb_item_add);
1058 item_new = gtk_tree_item_new_with_label(buffer);
1059 gtk_tree_append(GTK_TREE(subtree), item_new);
1060 gtk_widget_show(item_new);
1062 tree_buttons->nb_item_add++;
1066 cb_remove_item(GtkWidget*w, GtkTree* tree)
1068 GList* selected_list;
1071 selected_list = GTK_TREE_SELECTION(tree);
1075 while (selected_list)
1077 clear_list = g_list_prepend (clear_list, selected_list->data);
1078 selected_list = selected_list->next;
1081 clear_list = g_list_reverse (clear_list);
1082 gtk_tree_remove_items(tree, clear_list);
1084 g_list_free (clear_list);
1088 cb_remove_subtree(GtkWidget*w, GtkTree* tree)
1090 GList* selected_list;
1093 selected_list = GTK_TREE_SELECTION(tree);
1097 item = GTK_TREE_ITEM (selected_list->data);
1099 gtk_tree_item_remove_subtree (item);
1104 cb_tree_changed(GtkTree* tree)
1106 sTreeButtons* tree_buttons;
1107 GList* selected_list;
1110 tree_buttons = gtk_object_get_user_data(GTK_OBJECT(tree));
1112 selected_list = GTK_TREE_SELECTION(tree);
1113 nb_selected = g_list_length(selected_list);
1115 if(nb_selected == 0)
1117 if(tree->children == NULL)
1118 gtk_widget_set_sensitive(tree_buttons->add_button, TRUE);
1120 gtk_widget_set_sensitive(tree_buttons->add_button, FALSE);
1121 gtk_widget_set_sensitive(tree_buttons->remove_button, FALSE);
1122 gtk_widget_set_sensitive(tree_buttons->subtree_button, FALSE);
1126 gtk_widget_set_sensitive(tree_buttons->remove_button, TRUE);
1127 gtk_widget_set_sensitive(tree_buttons->add_button, (nb_selected == 1));
1128 gtk_widget_set_sensitive(tree_buttons->subtree_button, (nb_selected == 1));
1133 create_subtree(GtkWidget* item, guint level, guint nb_item_max, guint recursion_level_max)
1135 GtkWidget* item_subtree;
1136 GtkWidget* item_new;
1141 if(level == recursion_level_max) return;
1145 /* query with no root item */
1147 item_subtree = item;
1152 /* query with no root item */
1153 /* create subtree and associate it with current item */
1154 item_subtree = gtk_tree_new();
1158 for(nb_item = 0; nb_item < nb_item_max; nb_item++)
1160 sprintf(buffer, "item %d-%d", level, nb_item);
1161 item_new = gtk_tree_item_new_with_label(buffer);
1162 gtk_tree_append(GTK_TREE(item_subtree), item_new);
1163 create_subtree(item_new, level+1, nb_item_max, recursion_level_max);
1164 gtk_widget_show(item_new);
1168 gtk_tree_item_set_subtree(GTK_TREE_ITEM(item), item_subtree);
1172 create_tree_sample(guint selection_mode,
1173 guint draw_line, guint view_line, guint no_root_item,
1174 guint nb_item_max, guint recursion_level_max)
1179 GtkWidget* separator;
1181 GtkWidget* scrolled_win;
1182 GtkWidget* root_tree;
1183 GtkWidget* root_item;
1184 sTreeButtons* tree_buttons;
1186 /* create tree buttons struct */
1187 if((tree_buttons = g_malloc(sizeof(sTreeButtons))) == NULL)
1189 g_error("can't allocate memory for tree structure !\n");
1192 tree_buttons->nb_item_add = 0;
1194 /* create top level window */
1195 window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
1196 gtk_window_set_title(GTK_WINDOW(window), "Tree Sample");
1197 gtk_signal_connect(GTK_OBJECT(window), "destroy",
1198 (GtkSignalFunc) cb_tree_destroy_event, NULL);
1199 gtk_object_set_user_data(GTK_OBJECT(window), tree_buttons);
1201 box1 = gtk_vbox_new(FALSE, 0);
1202 gtk_container_add(GTK_CONTAINER(window), box1);
1203 gtk_widget_show(box1);
1205 /* create tree box */
1206 box2 = gtk_vbox_new(FALSE, 0);
1207 gtk_box_pack_start(GTK_BOX(box1), box2, TRUE, TRUE, 0);
1208 gtk_container_border_width(GTK_CONTAINER(box2), 5);
1209 gtk_widget_show(box2);
1211 /* create scrolled window */
1212 scrolled_win = gtk_scrolled_window_new (NULL, NULL);
1213 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
1214 GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
1215 gtk_box_pack_start (GTK_BOX (box2), scrolled_win, TRUE, TRUE, 0);
1216 gtk_widget_set_usize (scrolled_win, 200, 200);
1217 gtk_widget_show (scrolled_win);
1219 /* create root tree widget */
1220 root_tree = gtk_tree_new();
1221 gtk_signal_connect(GTK_OBJECT(root_tree), "selection_changed",
1222 (GtkSignalFunc)cb_tree_changed,
1224 gtk_object_set_user_data(GTK_OBJECT(root_tree), tree_buttons);
1225 gtk_container_add(GTK_CONTAINER(scrolled_win), root_tree);
1226 gtk_tree_set_selection_mode(GTK_TREE(root_tree), selection_mode);
1227 gtk_tree_set_view_lines(GTK_TREE(root_tree), draw_line);
1228 gtk_tree_set_view_mode(GTK_TREE(root_tree), !view_line);
1229 gtk_widget_show(root_tree);
1233 /* set root tree to subtree function with root item variable */
1234 root_item = GTK_WIDGET(root_tree);
1238 /* create root tree item widget */
1239 root_item = gtk_tree_item_new_with_label("root item");
1240 gtk_tree_append(GTK_TREE(root_tree), root_item);
1241 gtk_widget_show(root_item);
1243 create_subtree(root_item, -no_root_item, nb_item_max, recursion_level_max);
1245 box2 = gtk_vbox_new(FALSE, 0);
1246 gtk_box_pack_start(GTK_BOX(box1), box2, FALSE, FALSE, 0);
1247 gtk_container_border_width(GTK_CONTAINER(box2), 5);
1248 gtk_widget_show(box2);
1250 button = gtk_button_new_with_label("Add Item");
1251 gtk_widget_set_sensitive(button, FALSE);
1252 gtk_signal_connect(GTK_OBJECT (button), "clicked",
1253 (GtkSignalFunc) cb_add_new_item,
1254 (gpointer)root_tree);
1255 gtk_box_pack_start(GTK_BOX(box2), button, TRUE, TRUE, 0);
1256 gtk_widget_show(button);
1257 tree_buttons->add_button = button;
1259 button = gtk_button_new_with_label("Remove Item(s)");
1260 gtk_widget_set_sensitive(button, FALSE);
1261 gtk_signal_connect(GTK_OBJECT (button), "clicked",
1262 (GtkSignalFunc) cb_remove_item,
1263 (gpointer)root_tree);
1264 gtk_box_pack_start(GTK_BOX(box2), button, TRUE, TRUE, 0);
1265 gtk_widget_show(button);
1266 tree_buttons->remove_button = button;
1268 button = gtk_button_new_with_label("Remove Subtree");
1269 gtk_widget_set_sensitive(button, FALSE);
1270 gtk_signal_connect(GTK_OBJECT (button), "clicked",
1271 (GtkSignalFunc) cb_remove_subtree,
1272 (gpointer)root_tree);
1273 gtk_box_pack_start(GTK_BOX(box2), button, TRUE, TRUE, 0);
1274 gtk_widget_show(button);
1275 tree_buttons->subtree_button = button;
1277 /* create separator */
1278 separator = gtk_hseparator_new();
1279 gtk_box_pack_start(GTK_BOX(box1), separator, FALSE, FALSE, 0);
1280 gtk_widget_show(separator);
1282 /* create button box */
1283 box2 = gtk_vbox_new(FALSE, 0);
1284 gtk_box_pack_start(GTK_BOX(box1), box2, FALSE, FALSE, 0);
1285 gtk_container_border_width(GTK_CONTAINER(box2), 5);
1286 gtk_widget_show(box2);
1288 button = gtk_button_new_with_label("Close");
1289 gtk_box_pack_start(GTK_BOX(box2), button, TRUE, TRUE, 0);
1290 gtk_signal_connect_object(GTK_OBJECT (button), "clicked",
1291 (GtkSignalFunc) gtk_widget_destroy,
1292 GTK_OBJECT(window));
1293 gtk_widget_show(button);
1295 gtk_widget_show(window);
1299 cb_create_tree(GtkWidget* w)
1301 guint selection_mode = GTK_SELECTION_SINGLE;
1306 guint recursion_level;
1308 /* get selection mode choice */
1309 if(GTK_TOGGLE_BUTTON(sTreeSampleSelection.single_button)->active)
1310 selection_mode = GTK_SELECTION_SINGLE;
1312 if(GTK_TOGGLE_BUTTON(sTreeSampleSelection.browse_button)->active)
1313 selection_mode = GTK_SELECTION_BROWSE;
1315 selection_mode = GTK_SELECTION_MULTIPLE;
1317 /* get options choice */
1318 draw_line = GTK_TOGGLE_BUTTON(sTreeSampleSelection.draw_line_button)->active;
1319 view_line = GTK_TOGGLE_BUTTON(sTreeSampleSelection.view_line_button)->active;
1320 no_root_item = GTK_TOGGLE_BUTTON(sTreeSampleSelection.no_root_item_button)->active;
1323 nb_item = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(sTreeSampleSelection.nb_item_spinner));
1324 recursion_level = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(sTreeSampleSelection.recursion_spinner));
1326 if (pow (nb_item, recursion_level) > 10000)
1328 g_print ("%g total items? That will take a very long time. Try less\n",
1329 pow (nb_item, recursion_level));
1333 create_tree_sample(selection_mode, draw_line, view_line, no_root_item, nb_item, recursion_level);
1337 create_tree_mode_window(void)
1339 static GtkWidget* window;
1347 GtkWidget* separator;
1354 /* create toplevel window */
1355 window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
1356 gtk_window_set_title(GTK_WINDOW(window), "Set Tree Parameters");
1357 gtk_signal_connect (GTK_OBJECT (window), "destroy",
1358 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
1360 box1 = gtk_vbox_new(FALSE, 0);
1361 gtk_container_add(GTK_CONTAINER(window), box1);
1363 /* create upper box - selection box */
1364 box2 = gtk_vbox_new(FALSE, 5);
1365 gtk_box_pack_start(GTK_BOX(box1), box2, TRUE, TRUE, 0);
1366 gtk_container_border_width(GTK_CONTAINER(box2), 5);
1368 box3 = gtk_hbox_new(FALSE, 5);
1369 gtk_box_pack_start(GTK_BOX(box2), box3, TRUE, TRUE, 0);
1371 /* create selection mode frame */
1372 frame = gtk_frame_new("Selection Mode");
1373 gtk_box_pack_start(GTK_BOX(box3), frame, TRUE, TRUE, 0);
1375 box4 = gtk_vbox_new(FALSE, 0);
1376 gtk_container_add(GTK_CONTAINER(frame), box4);
1377 gtk_container_border_width(GTK_CONTAINER(box4), 5);
1379 /* create radio button */
1380 button = gtk_radio_button_new_with_label(NULL, "SINGLE");
1381 gtk_box_pack_start(GTK_BOX(box4), button, TRUE, TRUE, 0);
1382 sTreeSampleSelection.single_button = button;
1384 button = gtk_radio_button_new_with_label(gtk_radio_button_group (GTK_RADIO_BUTTON (button)),
1386 gtk_box_pack_start(GTK_BOX(box4), button, TRUE, TRUE, 0);
1387 sTreeSampleSelection.browse_button = button;
1389 button = gtk_radio_button_new_with_label(gtk_radio_button_group (GTK_RADIO_BUTTON (button)),
1391 gtk_box_pack_start(GTK_BOX(box4), button, TRUE, TRUE, 0);
1392 sTreeSampleSelection.multiple_button = button;
1394 sTreeSampleSelection.selection_mode_group = gtk_radio_button_group (GTK_RADIO_BUTTON (button));
1396 /* create option mode frame */
1397 frame = gtk_frame_new("Options");
1398 gtk_box_pack_start(GTK_BOX(box3), frame, TRUE, TRUE, 0);
1400 box4 = gtk_vbox_new(FALSE, 0);
1401 gtk_container_add(GTK_CONTAINER(frame), box4);
1402 gtk_container_border_width(GTK_CONTAINER(box4), 5);
1404 /* create check button */
1405 button = gtk_check_button_new_with_label("Draw line");
1406 gtk_box_pack_start(GTK_BOX(box4), button, TRUE, TRUE, 0);
1407 gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(button), TRUE);
1408 sTreeSampleSelection.draw_line_button = button;
1410 button = gtk_check_button_new_with_label("View Line mode");
1411 gtk_box_pack_start(GTK_BOX(box4), button, TRUE, TRUE, 0);
1412 gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(button), TRUE);
1413 sTreeSampleSelection.view_line_button = button;
1415 button = gtk_check_button_new_with_label("Without Root item");
1416 gtk_box_pack_start(GTK_BOX(box4), button, TRUE, TRUE, 0);
1417 sTreeSampleSelection.no_root_item_button = button;
1419 /* create recursion parameter */
1420 frame = gtk_frame_new("Size Parameters");
1421 gtk_box_pack_start(GTK_BOX(box2), frame, TRUE, TRUE, 0);
1423 box4 = gtk_hbox_new(FALSE, 5);
1424 gtk_container_add(GTK_CONTAINER(frame), box4);
1425 gtk_container_border_width(GTK_CONTAINER(box4), 5);
1427 /* create number of item spin button */
1428 box5 = gtk_hbox_new(FALSE, 5);
1429 gtk_box_pack_start(GTK_BOX(box4), box5, FALSE, FALSE, 0);
1431 label = gtk_label_new("Number of items : ");
1432 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
1433 gtk_box_pack_start (GTK_BOX (box5), label, FALSE, TRUE, 0);
1435 adj = (GtkAdjustment *) gtk_adjustment_new ((gfloat)DEFAULT_NUMBER_OF_ITEM, 1.0, 255.0, 1.0,
1437 spinner = gtk_spin_button_new (adj, 0, 0);
1438 gtk_box_pack_start (GTK_BOX (box5), spinner, FALSE, TRUE, 0);
1439 sTreeSampleSelection.nb_item_spinner = spinner;
1441 /* create recursion level spin button */
1442 box5 = gtk_hbox_new(FALSE, 5);
1443 gtk_box_pack_start(GTK_BOX(box4), box5, FALSE, FALSE, 0);
1445 label = gtk_label_new("Depth : ");
1446 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
1447 gtk_box_pack_start (GTK_BOX (box5), label, FALSE, TRUE, 0);
1449 adj = (GtkAdjustment *) gtk_adjustment_new ((gfloat)DEFAULT_RECURSION_LEVEL, 0.0, 255.0, 1.0,
1451 spinner = gtk_spin_button_new (adj, 0, 0);
1452 gtk_box_pack_start (GTK_BOX (box5), spinner, FALSE, TRUE, 0);
1453 sTreeSampleSelection.recursion_spinner = spinner;
1455 /* create horizontal separator */
1456 separator = gtk_hseparator_new();
1457 gtk_box_pack_start(GTK_BOX(box1), separator, FALSE, FALSE, 0);
1459 /* create bottom button box */
1460 box2 = gtk_hbox_new(TRUE, 10);
1461 gtk_box_pack_start(GTK_BOX(box1), box2, FALSE, FALSE, 0);
1462 gtk_container_border_width(GTK_CONTAINER(box2), 5);
1464 button = gtk_button_new_with_label("Create Tree");
1465 gtk_box_pack_start(GTK_BOX(box2), button, TRUE, TRUE, 0);
1466 gtk_signal_connect(GTK_OBJECT (button), "clicked",
1467 (GtkSignalFunc) cb_create_tree, NULL);
1469 button = gtk_button_new_with_label("Close");
1470 gtk_box_pack_start(GTK_BOX(box2), button, TRUE, TRUE, 0);
1471 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
1472 GTK_SIGNAL_FUNC(gtk_widget_destroy),
1473 GTK_OBJECT (window));
1475 if (!GTK_WIDGET_VISIBLE (window))
1476 gtk_widget_show_all (window);
1478 gtk_widget_destroy (window);
1486 handle_box_child_signal (GtkHandleBox *hb,
1488 const gchar *action)
1490 printf ("%s: child <%s> %sed\n",
1491 gtk_type_name (GTK_OBJECT_TYPE (hb)),
1492 gtk_type_name (GTK_OBJECT_TYPE (child)),
1497 create_handle_box (void)
1499 static GtkWidget* window = NULL;
1500 GtkWidget *handle_box;
1501 GtkWidget *handle_box2;
1506 GtkWidget *separator;
1510 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
1511 gtk_window_set_title (GTK_WINDOW (window),
1513 gtk_window_set_policy (GTK_WINDOW (window),
1518 gtk_signal_connect (GTK_OBJECT (window), "destroy",
1519 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
1522 gtk_container_border_width (GTK_CONTAINER (window), 20);
1524 vbox = gtk_vbox_new (FALSE, 0);
1525 gtk_container_add (GTK_CONTAINER (window), vbox);
1526 gtk_widget_show (vbox);
1528 label = gtk_label_new ("Above");
1529 gtk_container_add (GTK_CONTAINER (vbox), label);
1530 gtk_widget_show (label);
1532 separator = gtk_hseparator_new ();
1533 gtk_container_add (GTK_CONTAINER (vbox), separator);
1534 gtk_widget_show (separator);
1536 hbox = gtk_hbox_new (FALSE, 10);
1537 gtk_container_add (GTK_CONTAINER (vbox), hbox);
1538 gtk_widget_show (hbox);
1540 separator = gtk_hseparator_new ();
1541 gtk_container_add (GTK_CONTAINER (vbox), separator);
1542 gtk_widget_show (separator);
1544 label = gtk_label_new ("Below");
1545 gtk_container_add (GTK_CONTAINER (vbox), label);
1546 gtk_widget_show (label);
1548 handle_box = gtk_handle_box_new ();
1549 gtk_container_add (GTK_CONTAINER (hbox), handle_box);
1550 gtk_signal_connect (GTK_OBJECT (handle_box),
1552 GTK_SIGNAL_FUNC (handle_box_child_signal),
1554 gtk_signal_connect (GTK_OBJECT (handle_box),
1556 GTK_SIGNAL_FUNC (handle_box_child_signal),
1558 gtk_widget_show (handle_box);
1560 toolbar = make_toolbar (window);
1561 gtk_toolbar_set_button_relief (GTK_TOOLBAR (toolbar), GTK_RELIEF_NORMAL);
1562 gtk_container_add (GTK_CONTAINER (handle_box), toolbar);
1563 gtk_widget_show (toolbar);
1565 handle_box = gtk_handle_box_new ();
1566 gtk_container_add (GTK_CONTAINER (hbox), handle_box);
1567 gtk_signal_connect (GTK_OBJECT (handle_box),
1569 GTK_SIGNAL_FUNC (handle_box_child_signal),
1571 gtk_signal_connect (GTK_OBJECT (handle_box),
1573 GTK_SIGNAL_FUNC (handle_box_child_signal),
1575 gtk_widget_show (handle_box);
1577 handle_box2 = gtk_handle_box_new ();
1578 gtk_container_add (GTK_CONTAINER (handle_box), handle_box2);
1579 gtk_signal_connect (GTK_OBJECT (handle_box2),
1581 GTK_SIGNAL_FUNC (handle_box_child_signal),
1583 gtk_signal_connect (GTK_OBJECT (handle_box2),
1585 GTK_SIGNAL_FUNC (handle_box_child_signal),
1587 gtk_widget_show (handle_box2);
1589 label = gtk_label_new ("Fooo!");
1590 gtk_container_add (GTK_CONTAINER (handle_box2), label);
1591 gtk_widget_show (label);
1594 if (!GTK_WIDGET_VISIBLE (window))
1595 gtk_widget_show (window);
1597 gtk_widget_destroy (window);
1605 reparent_label (GtkWidget *widget,
1606 GtkWidget *new_parent)
1610 label = gtk_object_get_user_data (GTK_OBJECT (widget));
1612 gtk_widget_reparent (label, new_parent);
1616 set_parent_signal (GtkWidget *child,
1617 GtkWidget *old_parent,
1620 g_print ("set_parent for \"%s\": new parent: \"%s\", old parent: \"%s\", data: %d\n",
1621 gtk_type_name (GTK_OBJECT_TYPE (child)),
1622 child->parent ? gtk_type_name (GTK_OBJECT_TYPE (child->parent)) : "NULL",
1623 old_parent ? gtk_type_name (GTK_OBJECT_TYPE (old_parent)) : "NULL",
1624 GPOINTER_TO_INT (func_data));
1628 create_reparent (void)
1630 static GtkWidget *window = NULL;
1637 GtkWidget *separator;
1641 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
1643 gtk_signal_connect (GTK_OBJECT (window), "destroy",
1644 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
1647 gtk_window_set_title (GTK_WINDOW (window), "reparent");
1648 gtk_container_border_width (GTK_CONTAINER (window), 0);
1650 box1 = gtk_vbox_new (FALSE, 0);
1651 gtk_container_add (GTK_CONTAINER (window), box1);
1653 box2 = gtk_hbox_new (FALSE, 5);
1654 gtk_container_border_width (GTK_CONTAINER (box2), 10);
1655 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
1657 label = gtk_label_new ("Hello World");
1659 frame = gtk_frame_new ("Frame 1");
1660 gtk_box_pack_start (GTK_BOX (box2), frame, TRUE, TRUE, 0);
1662 box3 = gtk_vbox_new (FALSE, 5);
1663 gtk_container_border_width (GTK_CONTAINER (box3), 5);
1664 gtk_container_add (GTK_CONTAINER (frame), box3);
1666 button = gtk_button_new_with_label ("switch");
1667 gtk_signal_connect (GTK_OBJECT (button), "clicked",
1668 GTK_SIGNAL_FUNC(reparent_label),
1670 gtk_object_set_user_data (GTK_OBJECT (button), label);
1671 gtk_box_pack_start (GTK_BOX (box3), button, FALSE, TRUE, 0);
1673 gtk_box_pack_start (GTK_BOX (box3), label, FALSE, TRUE, 0);
1674 gtk_signal_connect (GTK_OBJECT (label),
1676 GTK_SIGNAL_FUNC (set_parent_signal),
1677 GINT_TO_POINTER (42));
1679 frame = gtk_frame_new ("Frame 2");
1680 gtk_box_pack_start (GTK_BOX (box2), frame, TRUE, TRUE, 0);
1682 box3 = gtk_vbox_new (FALSE, 5);
1683 gtk_container_border_width (GTK_CONTAINER (box3), 5);
1684 gtk_container_add (GTK_CONTAINER (frame), box3);
1686 button = gtk_button_new_with_label ("switch");
1687 gtk_signal_connect (GTK_OBJECT (button), "clicked",
1688 GTK_SIGNAL_FUNC(reparent_label),
1690 gtk_object_set_user_data (GTK_OBJECT (button), label);
1691 gtk_box_pack_start (GTK_BOX (box3), button, FALSE, TRUE, 0);
1693 separator = gtk_hseparator_new ();
1694 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
1696 box2 = gtk_vbox_new (FALSE, 10);
1697 gtk_container_border_width (GTK_CONTAINER (box2), 10);
1698 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
1700 button = gtk_button_new_with_label ("close");
1701 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
1702 GTK_SIGNAL_FUNC(gtk_widget_destroy),
1703 GTK_OBJECT (window));
1704 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
1705 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
1706 gtk_widget_grab_default (button);
1709 if (!GTK_WIDGET_VISIBLE (window))
1710 gtk_widget_show_all (window);
1712 gtk_widget_destroy (window);
1720 create_pixmap (void)
1722 static GtkWidget *window = NULL;
1728 GtkWidget *separator;
1729 GtkWidget *pixmapwid;
1736 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
1738 gtk_signal_connect (GTK_OBJECT (window), "destroy",
1739 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
1742 gtk_window_set_title (GTK_WINDOW (window), "GtkPixmap");
1743 gtk_container_border_width (GTK_CONTAINER (window), 0);
1744 gtk_widget_realize(window);
1746 box1 = gtk_vbox_new (FALSE, 0);
1747 gtk_container_add (GTK_CONTAINER (window), box1);
1749 box2 = gtk_vbox_new (FALSE, 10);
1750 gtk_container_border_width (GTK_CONTAINER (box2), 10);
1751 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
1753 button = gtk_button_new ();
1754 gtk_box_pack_start (GTK_BOX (box2), button, FALSE, FALSE, 0);
1756 style = gtk_widget_get_style(button);
1758 pixmap = gdk_pixmap_create_from_xpm (window->window, &mask,
1759 &style->bg[GTK_STATE_NORMAL],
1761 pixmapwid = gtk_pixmap_new (pixmap, mask);
1763 label = gtk_label_new ("Pixmap\ntest");
1764 box3 = gtk_hbox_new (FALSE, 0);
1765 gtk_container_border_width (GTK_CONTAINER (box3), 2);
1766 gtk_container_add (GTK_CONTAINER (box3), pixmapwid);
1767 gtk_container_add (GTK_CONTAINER (box3), label);
1768 gtk_container_add (GTK_CONTAINER (button), box3);
1770 separator = gtk_hseparator_new ();
1771 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
1773 box2 = gtk_vbox_new (FALSE, 10);
1774 gtk_container_border_width (GTK_CONTAINER (box2), 10);
1775 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
1777 button = gtk_button_new_with_label ("close");
1778 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
1779 GTK_SIGNAL_FUNC(gtk_widget_destroy),
1780 GTK_OBJECT (window));
1781 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
1782 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
1783 gtk_widget_grab_default (button);
1786 if (!GTK_WIDGET_VISIBLE (window))
1787 gtk_widget_show_all (window);
1789 gtk_widget_destroy (window);
1793 tips_query_widget_entered (GtkTipsQuery *tips_query,
1795 const gchar *tip_text,
1796 const gchar *tip_private,
1799 if (GTK_TOGGLE_BUTTON (toggle)->active)
1801 gtk_label_set (GTK_LABEL (tips_query), tip_text ? "There is a Tip!" : "There is no Tip!");
1802 /* don't let GtkTipsQuery reset it's label */
1803 gtk_signal_emit_stop_by_name (GTK_OBJECT (tips_query), "widget_entered");
1808 tips_query_widget_selected (GtkWidget *tips_query,
1810 const gchar *tip_text,
1811 const gchar *tip_private,
1812 GdkEventButton *event,
1816 g_print ("Help \"%s\" requested for <%s>\n",
1817 tip_private ? tip_private : "None",
1818 gtk_type_name (GTK_OBJECT_TYPE (widget)));
1823 create_tooltips (void)
1825 static GtkWidget *window = NULL;
1832 GtkWidget *tips_query;
1833 GtkWidget *separator;
1834 GtkTooltips *tooltips;
1839 gtk_widget_new (gtk_window_get_type (),
1840 "GtkWindow::type", GTK_WINDOW_TOPLEVEL,
1841 "GtkContainer::border_width", 0,
1842 "GtkWindow::title", "Tooltips",
1843 "GtkWindow::allow_shrink", TRUE,
1844 "GtkWindow::allow_grow", FALSE,
1845 "GtkWindow::auto_shrink", TRUE,
1846 "GtkWidget::width", 200,
1849 gtk_signal_connect (GTK_OBJECT (window), "destroy",
1850 GTK_SIGNAL_FUNC (destroy_tooltips),
1853 tooltips=gtk_tooltips_new();
1854 gtk_object_set_data (GTK_OBJECT (window), "tooltips", tooltips);
1856 box1 = gtk_vbox_new (FALSE, 0);
1857 gtk_container_add (GTK_CONTAINER (window), box1);
1859 box2 = gtk_vbox_new (FALSE, 10);
1860 gtk_container_border_width (GTK_CONTAINER (box2), 10);
1861 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
1863 button = gtk_toggle_button_new_with_label ("button1");
1864 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
1866 gtk_tooltips_set_tip (tooltips,button,"This is button 1", "ContextHelp/buttons/1");
1868 button = gtk_toggle_button_new_with_label ("button2");
1869 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
1871 gtk_tooltips_set_tip (tooltips,
1873 "This is button 2. This is also a really long tooltip which probably won't fit on a single line and will therefore need to be wrapped. Hopefully the wrapping will work correctly.",
1874 "ContextHelp/buttons/2_long");
1876 toggle = gtk_toggle_button_new_with_label ("Override TipsQuery Label");
1877 gtk_box_pack_start (GTK_BOX (box2), toggle, TRUE, TRUE, 0);
1879 gtk_tooltips_set_tip (tooltips, toggle, "Toggle TipsQuery view.", "Hi msw! ;)");
1882 gtk_widget_new (gtk_vbox_get_type (),
1883 "GtkBox::homogeneous", FALSE,
1884 "GtkBox::spacing", 5,
1885 "GtkContainer::border_width", 5,
1886 "GtkWidget::visible", TRUE,
1889 tips_query = gtk_tips_query_new ();
1892 gtk_widget_new (gtk_button_get_type (),
1893 "GtkButton::label", "[?]",
1894 "GtkWidget::visible", TRUE,
1895 "GtkWidget::parent", box3,
1896 "GtkObject::object_signal::clicked", gtk_tips_query_start_query, tips_query,
1898 gtk_box_set_child_packing (GTK_BOX (box3), button, FALSE, FALSE, 0, GTK_PACK_START);
1899 gtk_tooltips_set_tip (tooltips,
1901 "Start the Tooltips Inspector",
1902 "ContextHelp/buttons/?");
1905 gtk_widget_set (tips_query,
1906 "GtkWidget::visible", TRUE,
1907 "GtkWidget::parent", box3,
1908 "GtkTipsQuery::caller", button,
1909 "GtkObject::signal::widget_entered", tips_query_widget_entered, toggle,
1910 "GtkObject::signal::widget_selected", tips_query_widget_selected, NULL,
1914 gtk_widget_new (gtk_frame_get_type (),
1915 "GtkFrame::label", "ToolTips Inspector",
1916 "GtkFrame::label_xalign", (double) 0.5,
1917 "GtkContainer::border_width", 0,
1918 "GtkWidget::visible", TRUE,
1919 "GtkWidget::parent", box2,
1920 "GtkContainer::child", box3,
1922 gtk_box_set_child_packing (GTK_BOX (box2), frame, TRUE, TRUE, 10, GTK_PACK_START);
1924 separator = gtk_hseparator_new ();
1925 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
1927 box2 = gtk_vbox_new (FALSE, 10);
1928 gtk_container_border_width (GTK_CONTAINER (box2), 10);
1929 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
1931 button = gtk_button_new_with_label ("close");
1932 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
1933 GTK_SIGNAL_FUNC(gtk_widget_destroy),
1934 GTK_OBJECT (window));
1935 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
1936 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
1937 gtk_widget_grab_default (button);
1939 gtk_tooltips_set_tip (tooltips, button, "Push this button to close window", "ContextHelp/buttons/Close");
1942 if (!GTK_WIDGET_VISIBLE (window))
1943 gtk_widget_show_all (window);
1945 gtk_widget_destroy (window);
1953 create_menu (gint depth, gboolean tearoff)
1956 GtkWidget *menuitem;
1964 menu = gtk_menu_new ();
1969 menuitem = gtk_tearoff_menu_item_new ();
1970 gtk_menu_append (GTK_MENU (menu), menuitem);
1971 gtk_widget_show (menuitem);
1974 for (i = 0, j = 1; i < 5; i++, j++)
1976 sprintf (buf, "item %2d - %d", depth, j);
1977 menuitem = gtk_radio_menu_item_new_with_label (group, buf);
1978 group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menuitem));
1980 gtk_check_menu_item_set_show_toggle (GTK_CHECK_MENU_ITEM (menuitem), TRUE);
1981 gtk_menu_append (GTK_MENU (menu), menuitem);
1982 gtk_widget_show (menuitem);
1984 gtk_widget_set_sensitive (menuitem, FALSE);
1986 gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), create_menu (depth - 1, TRUE));
1995 static GtkWidget *window = NULL;
1999 GtkWidget *optionmenu;
2000 GtkWidget *separator;
2006 GtkWidget *menuitem;
2007 GtkAccelGroup *accel_group;
2009 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
2011 gtk_signal_connect (GTK_OBJECT (window), "destroy",
2012 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
2014 gtk_signal_connect (GTK_OBJECT (window), "delete-event",
2015 GTK_SIGNAL_FUNC (gtk_true),
2018 accel_group = gtk_accel_group_new ();
2019 gtk_accel_group_attach (accel_group, GTK_OBJECT (window));
2021 gtk_window_set_title (GTK_WINDOW (window), "menus");
2022 gtk_container_border_width (GTK_CONTAINER (window), 0);
2025 box1 = gtk_vbox_new (FALSE, 0);
2026 gtk_container_add (GTK_CONTAINER (window), box1);
2027 gtk_widget_show (box1);
2029 menubar = gtk_menu_bar_new ();
2030 gtk_box_pack_start (GTK_BOX (box1), menubar, FALSE, TRUE, 0);
2031 gtk_widget_show (menubar);
2033 menu = create_menu (2, TRUE);
2035 menuitem = gtk_menu_item_new_with_label ("test\nline2");
2036 gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), menu);
2037 gtk_menu_bar_append (GTK_MENU_BAR (menubar), menuitem);
2038 gtk_widget_show (menuitem);
2040 menuitem = gtk_menu_item_new_with_label ("foo");
2041 gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), create_menu (3, TRUE));
2042 gtk_menu_bar_append (GTK_MENU_BAR (menubar), menuitem);
2043 gtk_widget_show (menuitem);
2045 menuitem = gtk_menu_item_new_with_label ("bar");
2046 gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), create_menu (4, TRUE));
2047 gtk_menu_item_right_justify (GTK_MENU_ITEM (menuitem));
2048 gtk_menu_bar_append (GTK_MENU_BAR (menubar), menuitem);
2049 gtk_widget_show (menuitem);
2051 box2 = gtk_vbox_new (FALSE, 10);
2052 gtk_container_border_width (GTK_CONTAINER (box2), 10);
2053 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
2054 gtk_widget_show (box2);
2056 menu = create_menu (1, FALSE);
2057 gtk_menu_set_accel_group (GTK_MENU (menu), accel_group);
2059 menuitem = gtk_check_menu_item_new_with_label ("Accelerate Me");
2060 gtk_menu_append (GTK_MENU (menu), menuitem);
2061 gtk_widget_show (menuitem);
2062 gtk_widget_add_accelerator (menuitem,
2067 GTK_ACCEL_VISIBLE | GTK_ACCEL_SIGNAL_VISIBLE);
2068 menuitem = gtk_check_menu_item_new_with_label ("Accelerator Locked");
2069 gtk_menu_append (GTK_MENU (menu), menuitem);
2070 gtk_widget_show (menuitem);
2071 gtk_widget_add_accelerator (menuitem,
2076 GTK_ACCEL_VISIBLE | GTK_ACCEL_LOCKED);
2077 menuitem = gtk_check_menu_item_new_with_label ("Accelerators Frozen");
2078 gtk_menu_append (GTK_MENU (menu), menuitem);
2079 gtk_widget_show (menuitem);
2080 gtk_widget_add_accelerator (menuitem,
2086 gtk_widget_add_accelerator (menuitem,
2092 gtk_widget_freeze_accelerators (menuitem);
2094 optionmenu = gtk_option_menu_new ();
2095 gtk_option_menu_set_menu (GTK_OPTION_MENU (optionmenu), menu);
2096 gtk_option_menu_set_history (GTK_OPTION_MENU (optionmenu), 3);
2097 gtk_box_pack_start (GTK_BOX (box2), optionmenu, TRUE, TRUE, 0);
2098 gtk_widget_show (optionmenu);
2100 separator = gtk_hseparator_new ();
2101 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
2102 gtk_widget_show (separator);
2104 box2 = gtk_vbox_new (FALSE, 10);
2105 gtk_container_border_width (GTK_CONTAINER (box2), 10);
2106 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
2107 gtk_widget_show (box2);
2109 button = gtk_button_new_with_label ("close");
2110 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
2111 GTK_SIGNAL_FUNC(gtk_widget_destroy),
2112 GTK_OBJECT (window));
2113 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
2114 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
2115 gtk_widget_grab_default (button);
2116 gtk_widget_show (button);
2119 if (!GTK_WIDGET_VISIBLE (window))
2120 gtk_widget_show (window);
2122 gtk_widget_destroy (window);
2126 gtk_ifactory_cb (gpointer callback_data,
2127 guint callback_action,
2130 g_message ("ItemFactory: activated \"%s\"", gtk_item_factory_path_from_widget (widget));
2133 static GtkItemFactoryEntry menu_items[] =
2135 { "/_File", NULL, gtk_ifactory_cb, 0, "<Branch>" },
2136 { "/File/tearoff1", NULL, gtk_ifactory_cb, 0, "<Tearoff>" },
2137 { "/File/_New", "<control>N", gtk_ifactory_cb, 0 },
2138 { "/File/_Open", "<control>O", gtk_ifactory_cb, 0 },
2139 { "/File/_Save", "<control>S", gtk_ifactory_cb, 0 },
2140 { "/File/Save _As...", NULL, gtk_ifactory_cb, 0 },
2141 { "/File/sep1", NULL, gtk_ifactory_cb, 0, "<Separator>" },
2142 { "/File/_Quit", "<control>Q", gtk_ifactory_cb, 0 },
2144 { "/_Preferences", NULL, gtk_ifactory_cb, 0, "<Branch>" },
2145 { "/_Preferences/_Color", NULL, gtk_ifactory_cb, 0, "<Branch>" },
2146 { "/_Preferences/Color/_Red", NULL, gtk_ifactory_cb, 0, "<RadioItem>" },
2147 { "/_Preferences/Color/_Green", NULL, gtk_ifactory_cb, 0, "<RadioItem>" },
2148 { "/_Preferences/Color/_Blue", NULL, gtk_ifactory_cb, 0, "<RadioItem>" },
2149 { "/_Preferences/_Shape", NULL, gtk_ifactory_cb, 0, "<Branch>" },
2150 { "/_Preferences/Shape/_Square", NULL, gtk_ifactory_cb, 0, "<RadioItem>" },
2151 { "/_Preferences/Shape/_Rectangle", NULL, gtk_ifactory_cb, 0, "<RadioItem>" },
2152 { "/_Preferences/Shape/_Oval", NULL, gtk_ifactory_cb, 0, "<RadioItem>" },
2154 { "/_Help", NULL, gtk_ifactory_cb, 0, "<LastBranch>" },
2155 { "/Help/_About", NULL, gtk_ifactory_cb, 0 },
2158 static int nmenu_items = sizeof (menu_items) / sizeof (menu_items[0]);
2161 create_item_factory (void)
2163 static GtkWidget *window = NULL;
2169 GtkWidget *separator;
2172 GtkAccelGroup *accel_group;
2173 GtkItemFactory *item_factory;
2175 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
2177 gtk_signal_connect (GTK_OBJECT (window), "destroy",
2178 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
2180 gtk_signal_connect (GTK_OBJECT (window), "delete-event",
2181 GTK_SIGNAL_FUNC (gtk_true),
2184 accel_group = gtk_accel_group_new ();
2185 item_factory = gtk_item_factory_new (GTK_TYPE_MENU_BAR, "<main>", accel_group);
2186 gtk_item_factory_create_items (item_factory, nmenu_items, menu_items, NULL);
2187 gtk_accel_group_attach (accel_group, GTK_OBJECT (window));
2188 gtk_window_set_title (GTK_WINDOW (window), "Item Factory");
2189 gtk_container_border_width (GTK_CONTAINER (window), 0);
2191 box1 = gtk_vbox_new (FALSE, 0);
2192 gtk_container_add (GTK_CONTAINER (window), box1);
2194 gtk_box_pack_start (GTK_BOX (box1),
2195 gtk_item_factory_get_widget (item_factory, "<main>"),
2198 label = gtk_label_new ("Type\n<alt>\nto start");
2199 gtk_widget_set_usize (label, 200, 200);
2200 gtk_misc_set_alignment (GTK_MISC (label), 0.5, 0.5);
2201 gtk_box_pack_start (GTK_BOX (box1), label, TRUE, TRUE, 0);
2204 separator = gtk_hseparator_new ();
2205 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
2208 box2 = gtk_vbox_new (FALSE, 10);
2209 gtk_container_border_width (GTK_CONTAINER (box2), 10);
2210 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
2212 button = gtk_button_new_with_label ("close");
2213 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
2214 GTK_SIGNAL_FUNC(gtk_widget_destroy),
2215 GTK_OBJECT (window));
2216 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
2217 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
2218 gtk_widget_grab_default (button);
2220 gtk_widget_show_all (window);
2223 gtk_widget_destroy (window);
2231 scrolled_windows_remove (GtkWidget *widget, GtkWidget *scrollwin)
2233 static GtkWidget *parent = NULL;
2234 static GtkWidget *float_parent;
2238 gtk_widget_reparent (scrollwin, parent);
2239 gtk_widget_destroy (float_parent);
2240 float_parent = NULL;
2245 parent = widget->parent;
2246 float_parent = gtk_window_new (GTK_WINDOW_TOPLEVEL);
2247 gtk_widget_reparent (scrollwin, float_parent);
2248 gtk_widget_show (float_parent);
2257 cmw_destroy_cb(GtkWidget *widget)
2259 /* This is needed to get out of gtk_main */
2266 cmw_color (GtkWidget *widget)
2270 csd=gtk_color_selection_dialog_new ("This is a modal color selection dialog");
2273 gtk_window_set_modal (GTK_WINDOW(csd),TRUE);
2275 gtk_signal_connect (GTK_OBJECT(csd), "destroy",
2276 GTK_SIGNAL_FUNC(cmw_destroy_cb),NULL);
2278 gtk_signal_connect_object (GTK_OBJECT(GTK_COLOR_SELECTION_DIALOG(csd)->ok_button),
2279 "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy),
2281 gtk_signal_connect_object (GTK_OBJECT(GTK_COLOR_SELECTION_DIALOG(csd)->cancel_button),
2282 "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy),
2285 /* wait until destroy calls gtk_main_quit */
2286 gtk_widget_show (csd);
2291 cmw_file (GtkWidget *widget)
2295 fs = gtk_file_selection_new("This is a modal file selection dialog");
2298 gtk_window_set_modal (GTK_WINDOW(fs),TRUE);
2300 gtk_signal_connect (GTK_OBJECT(fs), "destroy",
2301 GTK_SIGNAL_FUNC(cmw_destroy_cb),NULL);
2303 gtk_signal_connect_object (GTK_OBJECT(GTK_FILE_SELECTION(fs)->ok_button),
2304 "clicked",GTK_SIGNAL_FUNC(gtk_widget_destroy),
2306 gtk_signal_connect_object (GTK_OBJECT(GTK_FILE_SELECTION(fs)->cancel_button),
2307 "clicked",GTK_SIGNAL_FUNC(gtk_widget_destroy),
2310 /* wait until destroy calls gtk_main_quit */
2311 gtk_widget_show (fs);
2318 create_modal_window (void)
2320 GtkWidget *window = NULL;
2321 GtkWidget *box1,*box2;
2323 GtkWidget *btnColor,*btnFile,*btnClose;
2325 /* Create modal window (Here you can use any window descendent )*/
2326 window=gtk_window_new (GTK_WINDOW_TOPLEVEL);
2327 gtk_window_set_title (GTK_WINDOW(window),"This window is modal");
2329 /* Set window as modal */
2330 gtk_window_set_modal (GTK_WINDOW(window),TRUE);
2332 /* Create widgets */
2333 box1 = gtk_vbox_new (FALSE,5);
2334 frame1 = gtk_frame_new ("Standard dialogs in modal form");
2335 box2 = gtk_vbox_new (TRUE,5);
2336 btnColor = gtk_button_new_with_label ("Color");
2337 btnFile = gtk_button_new_with_label ("File Selection");
2338 btnClose = gtk_button_new_with_label ("Close");
2341 gtk_container_border_width (GTK_CONTAINER(box1),3);
2342 gtk_container_border_width (GTK_CONTAINER(box2),3);
2345 gtk_container_add (GTK_CONTAINER (window), box1);
2346 gtk_box_pack_start (GTK_BOX (box1), frame1, TRUE, TRUE, 4);
2347 gtk_container_add (GTK_CONTAINER (frame1), box2);
2348 gtk_box_pack_start (GTK_BOX (box2), btnColor, FALSE, FALSE, 4);
2349 gtk_box_pack_start (GTK_BOX (box2), btnFile, FALSE, FALSE, 4);
2350 gtk_box_pack_start (GTK_BOX (box1), gtk_hseparator_new (), FALSE, FALSE, 4);
2351 gtk_box_pack_start (GTK_BOX (box1), btnClose, FALSE, FALSE, 4);
2353 /* connect signals */
2354 gtk_signal_connect_object (GTK_OBJECT (btnClose), "clicked",
2355 GTK_SIGNAL_FUNC (gtk_widget_destroy),
2356 GTK_OBJECT (window));
2358 gtk_signal_connect (GTK_OBJECT (window), "destroy",
2359 GTK_SIGNAL_FUNC (cmw_destroy_cb),NULL);
2361 gtk_signal_connect (GTK_OBJECT (btnColor), "clicked",
2362 GTK_SIGNAL_FUNC (cmw_color),NULL);
2363 gtk_signal_connect (GTK_OBJECT (btnFile), "clicked",
2364 GTK_SIGNAL_FUNC (cmw_file),NULL);
2367 gtk_widget_show_all (window);
2369 /* wait until dialog get destroyed */
2378 create_scrolled_windows (void)
2380 static GtkWidget *window;
2381 GtkWidget *scrolled_window;
2389 window = gtk_dialog_new ();
2391 gtk_signal_connect (GTK_OBJECT (window), "destroy",
2392 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
2395 gtk_window_set_title (GTK_WINDOW (window), "dialog");
2396 gtk_container_border_width (GTK_CONTAINER (window), 0);
2399 scrolled_window = gtk_scrolled_window_new (NULL, NULL);
2400 gtk_container_border_width (GTK_CONTAINER (scrolled_window), 10);
2401 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
2402 GTK_POLICY_AUTOMATIC,
2403 GTK_POLICY_AUTOMATIC);
2404 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox),
2405 scrolled_window, TRUE, TRUE, 0);
2406 gtk_widget_show (scrolled_window);
2408 table = gtk_table_new (20, 20, FALSE);
2409 gtk_table_set_row_spacings (GTK_TABLE (table), 10);
2410 gtk_table_set_col_spacings (GTK_TABLE (table), 10);
2411 gtk_container_add (GTK_CONTAINER (scrolled_window), table);
2412 gtk_container_set_focus_hadjustment (GTK_CONTAINER (table),
2413 gtk_scrolled_window_get_hadjustment (GTK_SCROLLED_WINDOW (scrolled_window)));
2414 gtk_container_set_focus_vadjustment (GTK_CONTAINER (table),
2415 gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (scrolled_window)));
2416 gtk_widget_show (table);
2418 for (i = 0; i < 20; i++)
2419 for (j = 0; j < 20; j++)
2421 sprintf (buffer, "button (%d,%d)\n", i, j);
2422 button = gtk_toggle_button_new_with_label (buffer);
2423 gtk_table_attach_defaults (GTK_TABLE (table), button,
2425 gtk_widget_show (button);
2429 button = gtk_button_new_with_label ("close");
2430 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
2431 GTK_SIGNAL_FUNC(gtk_widget_destroy),
2432 GTK_OBJECT (window));
2433 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
2434 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
2435 button, TRUE, TRUE, 0);
2436 gtk_widget_grab_default (button);
2437 gtk_widget_show (button);
2439 button = gtk_button_new_with_label ("remove");
2440 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
2441 GTK_SIGNAL_FUNC(scrolled_windows_remove),
2442 GTK_OBJECT (scrolled_window));
2443 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
2444 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
2445 button, TRUE, TRUE, 0);
2446 gtk_widget_grab_default (button);
2447 gtk_widget_show (button);
2451 if (!GTK_WIDGET_VISIBLE (window))
2452 gtk_widget_show (window);
2454 gtk_widget_destroy (window);
2462 entry_toggle_editable (GtkWidget *checkbutton,
2465 gtk_entry_set_editable(GTK_ENTRY(entry),
2466 GTK_TOGGLE_BUTTON(checkbutton)->active);
2470 entry_toggle_sensitive (GtkWidget *checkbutton,
2473 gtk_widget_set_sensitive (entry, GTK_TOGGLE_BUTTON(checkbutton)->active);
2477 entry_toggle_visibility (GtkWidget *checkbutton,
2480 gtk_entry_set_visibility(GTK_ENTRY(entry),
2481 GTK_TOGGLE_BUTTON(checkbutton)->active);
2487 static GtkWidget *window = NULL;
2490 GtkWidget *editable_check;
2491 GtkWidget *sensitive_check;
2492 GtkWidget *entry, *cb;
2494 GtkWidget *separator;
2495 GList *cbitems = NULL;
2499 cbitems = g_list_append(cbitems, "item0");
2500 cbitems = g_list_append(cbitems, "item1 item1");
2501 cbitems = g_list_append(cbitems, "item2 item2 item2");
2502 cbitems = g_list_append(cbitems, "item3 item3 item3 item3");
2503 cbitems = g_list_append(cbitems, "item4 item4 item4 item4 item4");
2504 cbitems = g_list_append(cbitems, "item5 item5 item5 item5 item5 item5");
2505 cbitems = g_list_append(cbitems, "item6 item6 item6 item6 item6");
2506 cbitems = g_list_append(cbitems, "item7 item7 item7 item7");
2507 cbitems = g_list_append(cbitems, "item8 item8 item8");
2508 cbitems = g_list_append(cbitems, "item9 item9");
2510 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
2512 gtk_signal_connect (GTK_OBJECT (window), "destroy",
2513 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
2516 gtk_window_set_title (GTK_WINDOW (window), "entry");
2517 gtk_container_border_width (GTK_CONTAINER (window), 0);
2520 box1 = gtk_vbox_new (FALSE, 0);
2521 gtk_container_add (GTK_CONTAINER (window), box1);
2522 gtk_widget_show (box1);
2525 box2 = gtk_vbox_new (FALSE, 10);
2526 gtk_container_border_width (GTK_CONTAINER (box2), 10);
2527 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
2528 gtk_widget_show (box2);
2530 entry = gtk_entry_new ();
2531 gtk_entry_set_text (GTK_ENTRY (entry), "hello world");
2532 gtk_editable_select_region (GTK_EDITABLE (entry), 0, 5);
2533 gtk_box_pack_start (GTK_BOX (box2), entry, TRUE, TRUE, 0);
2534 gtk_widget_show (entry);
2536 cb = gtk_combo_new ();
2537 gtk_combo_set_popdown_strings (GTK_COMBO (cb), cbitems);
2538 gtk_entry_set_text (GTK_ENTRY (GTK_COMBO(cb)->entry), "hello world");
2539 gtk_editable_select_region (GTK_EDITABLE (GTK_COMBO(cb)->entry),
2541 gtk_box_pack_start (GTK_BOX (box2), cb, TRUE, TRUE, 0);
2542 gtk_widget_show (cb);
2544 editable_check = gtk_check_button_new_with_label("Editable");
2545 gtk_box_pack_start (GTK_BOX (box2), editable_check, FALSE, TRUE, 0);
2546 gtk_signal_connect (GTK_OBJECT(editable_check), "toggled",
2547 GTK_SIGNAL_FUNC(entry_toggle_editable), entry);
2548 gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(editable_check), TRUE);
2549 gtk_widget_show (editable_check);
2551 editable_check = gtk_check_button_new_with_label("Visible");
2552 gtk_box_pack_start (GTK_BOX (box2), editable_check, FALSE, TRUE, 0);
2553 gtk_signal_connect (GTK_OBJECT(editable_check), "toggled",
2554 GTK_SIGNAL_FUNC(entry_toggle_visibility), entry);
2555 gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(editable_check), TRUE);
2556 gtk_widget_show (editable_check);
2558 sensitive_check = gtk_check_button_new_with_label("Sensitive");
2559 gtk_box_pack_start (GTK_BOX (box2), sensitive_check, FALSE, TRUE, 0);
2560 gtk_signal_connect (GTK_OBJECT(sensitive_check), "toggled",
2561 GTK_SIGNAL_FUNC(entry_toggle_sensitive), entry);
2562 gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(sensitive_check), TRUE);
2563 gtk_widget_show (sensitive_check);
2565 separator = gtk_hseparator_new ();
2566 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
2567 gtk_widget_show (separator);
2570 box2 = gtk_vbox_new (FALSE, 10);
2571 gtk_container_border_width (GTK_CONTAINER (box2), 10);
2572 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
2573 gtk_widget_show (box2);
2576 button = gtk_button_new_with_label ("close");
2577 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
2578 GTK_SIGNAL_FUNC(gtk_widget_destroy),
2579 GTK_OBJECT (window));
2580 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
2581 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
2582 gtk_widget_grab_default (button);
2583 gtk_widget_show (button);
2586 if (!GTK_WIDGET_VISIBLE (window))
2587 gtk_widget_show (window);
2589 gtk_widget_destroy (window);
2596 static GtkWidget *spinner1;
2599 toggle_snap (GtkWidget *widget, GtkSpinButton *spin)
2601 gtk_spin_button_set_snap_to_ticks (spin, GTK_TOGGLE_BUTTON (widget)->active);
2605 toggle_numeric (GtkWidget *widget, GtkSpinButton *spin)
2607 gtk_spin_button_set_numeric (spin, GTK_TOGGLE_BUTTON (widget)->active);
2611 change_digits (GtkWidget *widget, GtkSpinButton *spin)
2613 gtk_spin_button_set_digits (GTK_SPIN_BUTTON (spinner1),
2614 gtk_spin_button_get_value_as_int (spin));
2618 get_value (GtkWidget *widget, gpointer data)
2622 GtkSpinButton *spin;
2624 spin = GTK_SPIN_BUTTON (spinner1);
2625 label = GTK_LABEL (gtk_object_get_user_data (GTK_OBJECT (widget)));
2626 if (GPOINTER_TO_INT (data) == 1)
2627 sprintf (buf, "%d", gtk_spin_button_get_value_as_int (spin));
2629 sprintf (buf, "%0.*f", spin->digits,
2630 gtk_spin_button_get_value_as_float (spin));
2631 gtk_label_set (label, buf);
2637 static GtkWidget *window = NULL;
2640 GtkWidget *main_vbox;
2643 GtkWidget *spinner2;
2647 GtkWidget *val_label;
2652 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
2654 gtk_signal_connect (GTK_OBJECT (window), "destroy",
2655 GTK_SIGNAL_FUNC (gtk_widget_destroyed),
2658 gtk_window_set_title (GTK_WINDOW (window), "GtkSpinButton");
2660 main_vbox = gtk_vbox_new (FALSE, 5);
2661 gtk_container_border_width (GTK_CONTAINER (main_vbox), 10);
2662 gtk_container_add (GTK_CONTAINER (window), main_vbox);
2664 frame = gtk_frame_new ("Not accelerated");
2665 gtk_box_pack_start (GTK_BOX (main_vbox), frame, TRUE, TRUE, 0);
2667 vbox = gtk_vbox_new (FALSE, 0);
2668 gtk_container_border_width (GTK_CONTAINER (vbox), 5);
2669 gtk_container_add (GTK_CONTAINER (frame), vbox);
2671 /* Day, month, year spinners */
2673 hbox = gtk_hbox_new (FALSE, 0);
2674 gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 5);
2676 vbox2 = gtk_vbox_new (FALSE, 0);
2677 gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 5);
2679 label = gtk_label_new ("Day :");
2680 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
2681 gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, TRUE, 0);
2683 adj = (GtkAdjustment *) gtk_adjustment_new (1.0, 1.0, 31.0, 1.0,
2685 spinner = gtk_spin_button_new (adj, 0, 0);
2686 gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spinner), TRUE);
2687 gtk_spin_button_set_shadow_type (GTK_SPIN_BUTTON (spinner),
2689 gtk_box_pack_start (GTK_BOX (vbox2), spinner, FALSE, TRUE, 0);
2691 vbox2 = gtk_vbox_new (FALSE, 0);
2692 gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 5);
2694 label = gtk_label_new ("Month :");
2695 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
2696 gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, TRUE, 0);
2698 adj = (GtkAdjustment *) gtk_adjustment_new (1.0, 1.0, 12.0, 1.0,
2700 spinner = gtk_spin_button_new (adj, 0, 0);
2701 gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spinner), TRUE);
2702 gtk_spin_button_set_shadow_type (GTK_SPIN_BUTTON (spinner),
2703 GTK_SHADOW_ETCHED_IN);
2704 gtk_box_pack_start (GTK_BOX (vbox2), spinner, FALSE, TRUE, 0);
2706 vbox2 = gtk_vbox_new (FALSE, 0);
2707 gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 5);
2709 label = gtk_label_new ("Year :");
2710 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
2711 gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, TRUE, 0);
2713 adj = (GtkAdjustment *) gtk_adjustment_new (1998.0, 0.0, 2100.0,
2715 spinner = gtk_spin_button_new (adj, 0, 0);
2716 gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spinner), TRUE);
2717 gtk_spin_button_set_shadow_type (GTK_SPIN_BUTTON (spinner),
2719 gtk_widget_set_usize (spinner, 55, 0);
2720 gtk_box_pack_start (GTK_BOX (vbox2), spinner, FALSE, TRUE, 0);
2722 frame = gtk_frame_new ("Accelerated");
2723 gtk_box_pack_start (GTK_BOX (main_vbox), frame, TRUE, TRUE, 0);
2725 vbox = gtk_vbox_new (FALSE, 0);
2726 gtk_container_border_width (GTK_CONTAINER (vbox), 5);
2727 gtk_container_add (GTK_CONTAINER (frame), vbox);
2729 hbox = gtk_hbox_new (FALSE, 0);
2730 gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 5);
2732 vbox2 = gtk_vbox_new (FALSE, 0);
2733 gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 5);
2735 label = gtk_label_new ("Value :");
2736 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
2737 gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, TRUE, 0);
2739 adj = (GtkAdjustment *) gtk_adjustment_new (0.0, -10000.0, 10000.0,
2741 spinner1 = gtk_spin_button_new (adj, 1.0, 2);
2742 gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spinner1), TRUE);
2743 gtk_widget_set_usize (spinner1, 100, 0);
2744 gtk_box_pack_start (GTK_BOX (vbox2), spinner1, FALSE, TRUE, 0);
2746 vbox2 = gtk_vbox_new (FALSE, 0);
2747 gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 5);
2749 label = gtk_label_new ("Digits :");
2750 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
2751 gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, TRUE, 0);
2753 adj = (GtkAdjustment *) gtk_adjustment_new (2, 1, 5, 1, 1, 0);
2754 spinner2 = gtk_spin_button_new (adj, 0.0, 0);
2755 gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spinner2), TRUE);
2756 gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
2757 GTK_SIGNAL_FUNC (change_digits),
2758 (gpointer) spinner2);
2759 gtk_box_pack_start (GTK_BOX (vbox2), spinner2, FALSE, TRUE, 0);
2761 hbox = gtk_hbox_new (FALSE, 0);
2762 gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 5);
2764 button = gtk_check_button_new_with_label ("Snap to 0.5-ticks");
2765 gtk_signal_connect (GTK_OBJECT (button), "clicked",
2766 GTK_SIGNAL_FUNC (toggle_snap),
2768 gtk_box_pack_start (GTK_BOX (vbox), button, TRUE, TRUE, 0);
2769 gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON (button), TRUE);
2771 button = gtk_check_button_new_with_label ("Numeric only input mode");
2772 gtk_signal_connect (GTK_OBJECT (button), "clicked",
2773 GTK_SIGNAL_FUNC (toggle_numeric),
2775 gtk_box_pack_start (GTK_BOX (vbox), button, TRUE, TRUE, 0);
2776 gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON (button), TRUE);
2778 val_label = gtk_label_new ("");
2780 hbox = gtk_hbox_new (FALSE, 0);
2781 gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 5);
2783 button = gtk_button_new_with_label ("Value as Int");
2784 gtk_object_set_user_data (GTK_OBJECT (button), val_label);
2785 gtk_signal_connect (GTK_OBJECT (button), "clicked",
2786 GTK_SIGNAL_FUNC (get_value),
2787 GINT_TO_POINTER (1));
2788 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
2790 button = gtk_button_new_with_label ("Value as Float");
2791 gtk_object_set_user_data (GTK_OBJECT (button), val_label);
2792 gtk_signal_connect (GTK_OBJECT (button), "clicked",
2793 GTK_SIGNAL_FUNC (get_value),
2794 GINT_TO_POINTER (2));
2795 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
2797 gtk_box_pack_start (GTK_BOX (vbox), val_label, TRUE, TRUE, 0);
2798 gtk_label_set (GTK_LABEL (val_label), "0");
2800 hbox = gtk_hbox_new (FALSE, 0);
2801 gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, TRUE, 0);
2803 button = gtk_button_new_with_label ("Close");
2804 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
2805 GTK_SIGNAL_FUNC (gtk_widget_destroy),
2806 GTK_OBJECT (window));
2807 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
2810 if (!GTK_WIDGET_VISIBLE (window))
2811 gtk_widget_show_all (window);
2813 gtk_widget_destroy (window);
2821 cursor_expose_event (GtkWidget *widget,
2825 GtkDrawingArea *darea;
2826 GdkDrawable *drawable;
2833 g_return_val_if_fail (widget != NULL, TRUE);
2834 g_return_val_if_fail (GTK_IS_DRAWING_AREA (widget), TRUE);
2836 darea = GTK_DRAWING_AREA (widget);
2837 drawable = widget->window;
2838 white_gc = widget->style->white_gc;
2839 gray_gc = widget->style->bg_gc[GTK_STATE_NORMAL];
2840 black_gc = widget->style->black_gc;
2841 max_width = widget->allocation.width;
2842 max_height = widget->allocation.height;
2844 gdk_draw_rectangle (drawable, white_gc,
2851 gdk_draw_rectangle (drawable, black_gc,
2858 gdk_draw_rectangle (drawable, gray_gc,
2869 set_cursor (GtkWidget *spinner,
2877 c = CLAMP (gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (spinner)), 0, 152);
2880 label = gtk_object_get_user_data (GTK_OBJECT (spinner));
2881 vals = gtk_type_enum_get_values (GTK_TYPE_GDK_CURSOR_TYPE);
2882 while (vals && vals->value != c)
2885 gtk_label_set (GTK_LABEL (label), vals->value_nick);
2887 gtk_label_set (GTK_LABEL (label), "<unknown>");
2889 cursor = gdk_cursor_new (c);
2890 gdk_window_set_cursor (widget->window, cursor);
2891 gdk_cursor_destroy (cursor);
2895 cursor_event (GtkWidget *widget,
2897 GtkSpinButton *spinner)
2899 if ((event->type == GDK_BUTTON_PRESS) &&
2900 ((event->button.button == 1) ||
2901 (event->button.button == 3)))
2903 gtk_spin_button_spin (spinner, event->button.button == 1 ?
2904 GTK_SPIN_STEP_FORWARD : GTK_SPIN_STEP_BACKWARD, 0);
2912 create_cursors (void)
2914 static GtkWidget *window = NULL;
2917 GtkWidget *main_vbox;
2928 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
2930 gtk_signal_connect (GTK_OBJECT (window), "destroy",
2931 GTK_SIGNAL_FUNC (gtk_widget_destroyed),
2934 gtk_window_set_title (GTK_WINDOW (window), "Cursors");
2936 main_vbox = gtk_vbox_new (FALSE, 5);
2937 gtk_container_border_width (GTK_CONTAINER (main_vbox), 0);
2938 gtk_container_add (GTK_CONTAINER (window), main_vbox);
2941 gtk_widget_new (gtk_vbox_get_type (),
2942 "GtkBox::homogeneous", FALSE,
2943 "GtkBox::spacing", 5,
2944 "GtkContainer::border_width", 10,
2945 "GtkWidget::parent", main_vbox,
2946 "GtkWidget::visible", TRUE,
2949 hbox = gtk_hbox_new (FALSE, 0);
2950 gtk_container_border_width (GTK_CONTAINER (hbox), 5);
2951 gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0);
2953 label = gtk_label_new ("Cursor Value : ");
2954 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
2955 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
2957 adj = (GtkAdjustment *) gtk_adjustment_new (0,
2961 spinner = gtk_spin_button_new (adj, 0, 0);
2962 gtk_box_pack_start (GTK_BOX (hbox), spinner, TRUE, TRUE, 0);
2965 gtk_widget_new (gtk_frame_get_type (),
2966 "GtkFrame::shadow", GTK_SHADOW_ETCHED_IN,
2967 "GtkFrame::label_xalign", 0.5,
2968 "GtkFrame::label", "Cursor Area",
2969 "GtkContainer::border_width", 10,
2970 "GtkWidget::parent", vbox,
2971 "GtkWidget::visible", TRUE,
2974 darea = gtk_drawing_area_new ();
2975 gtk_widget_set_usize (darea, 80, 80);
2976 gtk_container_add (GTK_CONTAINER (frame), darea);
2977 gtk_signal_connect (GTK_OBJECT (darea),
2979 GTK_SIGNAL_FUNC (cursor_expose_event),
2981 gtk_widget_set_events (darea, GDK_EXPOSURE_MASK | GDK_BUTTON_PRESS_MASK);
2982 gtk_signal_connect (GTK_OBJECT (darea),
2983 "button_press_event",
2984 GTK_SIGNAL_FUNC (cursor_event),
2986 gtk_widget_show (darea);
2988 gtk_signal_connect (GTK_OBJECT (spinner), "changed",
2989 GTK_SIGNAL_FUNC (set_cursor),
2992 label = gtk_widget_new (GTK_TYPE_LABEL,
2997 gtk_container_child_set (GTK_CONTAINER (vbox), label,
3000 gtk_object_set_user_data (GTK_OBJECT (spinner), label);
3003 gtk_widget_new (gtk_hseparator_get_type (),
3004 "GtkWidget::visible", TRUE,
3006 gtk_box_pack_start (GTK_BOX (main_vbox), any, FALSE, TRUE, 0);
3008 hbox = gtk_hbox_new (FALSE, 0);
3009 gtk_container_border_width (GTK_CONTAINER (hbox), 10);
3010 gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, TRUE, 0);
3012 button = gtk_button_new_with_label ("Close");
3013 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
3014 GTK_SIGNAL_FUNC (gtk_widget_destroy),
3015 GTK_OBJECT (window));
3016 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
3018 gtk_widget_show_all (window);
3020 set_cursor (spinner, darea);
3023 gtk_widget_destroy (window);
3031 list_add (GtkWidget *widget,
3036 GtkWidget *list_item;
3037 GtkContainer *container;
3039 container = GTK_CONTAINER (list);
3041 sprintf (buffer, "added item %d", i++);
3042 list_item = gtk_list_item_new_with_label (buffer);
3043 gtk_widget_show (list_item);
3045 gtk_container_add (container, list_item);
3049 list_remove (GtkWidget *widget,
3055 tmp_list = GTK_LIST (list)->selection;
3060 clear_list = g_list_prepend (clear_list, tmp_list->data);
3061 tmp_list = tmp_list->next;
3064 clear_list = g_list_reverse (clear_list);
3066 gtk_list_remove_items (GTK_LIST (list), clear_list);
3068 g_list_free (clear_list);
3072 list_clear (GtkWidget *widget,
3075 gtk_list_clear_items (GTK_LIST (list), 0, -1);
3079 list_undo_selection (GtkWidget *widget,
3082 gtk_list_undo_selection (GTK_LIST (list));
3085 #define RADIOMENUTOGGLED(_rmi_, __i) { \
3088 __g = gtk_radio_menu_item_group(_rmi_); \
3089 while( __g && !((GtkCheckMenuItem *)(__g->data))->active) { \
3095 static GtkWidget *list_omenu;
3098 list_toggle_sel_mode (GtkWidget *widget, GtkList *list)
3102 if (!GTK_WIDGET_MAPPED (widget))
3105 RADIOMENUTOGGLED ((GtkRadioMenuItem *)
3106 (((GtkOptionMenu *)list_omenu)->menu_item), i);
3108 gtk_list_set_selection_mode (list, (GtkSelectionMode) (3-i));
3114 static GtkWidget *window = NULL;
3119 GtkWidget *scrolled_win;
3122 GtkWidget *separator;
3124 GtkWidget *menu_item;
3130 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
3132 gtk_signal_connect (GTK_OBJECT (window), "destroy",
3133 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
3136 gtk_window_set_title (GTK_WINDOW (window), "list");
3137 gtk_container_border_width (GTK_CONTAINER (window), 0);
3139 box1 = gtk_vbox_new (FALSE, 0);
3140 gtk_container_add (GTK_CONTAINER (window), box1);
3142 box2 = gtk_vbox_new (FALSE, 10);
3143 gtk_container_border_width (GTK_CONTAINER (box2), 10);
3144 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
3146 scrolled_win = gtk_scrolled_window_new (NULL, NULL);
3147 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
3148 GTK_POLICY_AUTOMATIC,
3149 GTK_POLICY_AUTOMATIC);
3150 gtk_box_pack_start (GTK_BOX (box2), scrolled_win, TRUE, TRUE, 0);
3151 gtk_widget_set_usize (scrolled_win, -1, 300);
3153 list = gtk_list_new ();
3154 gtk_list_set_selection_mode (GTK_LIST (list), GTK_SELECTION_EXTENDED);
3155 gtk_container_add (GTK_CONTAINER (scrolled_win), list);
3156 gtk_container_set_focus_vadjustment
3157 (GTK_CONTAINER (list),
3158 gtk_scrolled_window_get_vadjustment
3159 (GTK_SCROLLED_WINDOW (scrolled_win)));
3160 gtk_container_set_focus_hadjustment
3161 (GTK_CONTAINER (list),
3162 gtk_scrolled_window_get_hadjustment
3163 (GTK_SCROLLED_WINDOW (scrolled_win)));
3165 if ((infile = fopen("gtkenums.h", "r")))
3171 while (fgets (buffer, 256, infile))
3173 if ((pos = strchr (buffer, '\n')))
3175 item = gtk_list_item_new_with_label (buffer);
3176 gtk_container_add (GTK_CONTAINER (list), item);
3182 hbox = gtk_hbox_new (TRUE, 10);
3183 gtk_box_pack_start (GTK_BOX (box2), hbox, FALSE, TRUE, 0);
3185 button = gtk_button_new_with_label ("Undo Selection");
3186 gtk_signal_connect (GTK_OBJECT (button), "clicked",
3187 GTK_SIGNAL_FUNC(list_undo_selection),
3189 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
3191 button = gtk_button_new_with_label ("Remove Selection");
3192 gtk_signal_connect (GTK_OBJECT (button), "clicked",
3193 GTK_SIGNAL_FUNC (list_remove),
3195 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
3197 button = gtk_button_new_with_label ("Clear List");
3198 gtk_signal_connect (GTK_OBJECT (button), "clicked",
3199 GTK_SIGNAL_FUNC (list_clear),
3201 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
3203 hbox = gtk_hbox_new (FALSE, 10);
3204 gtk_box_pack_start (GTK_BOX (box2), hbox, FALSE, TRUE, 0);
3206 button = gtk_button_new_with_label ("Insert Row");
3207 gtk_signal_connect (GTK_OBJECT (button), "clicked",
3208 GTK_SIGNAL_FUNC (list_add),
3210 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
3212 label = gtk_label_new ("Selection Mode :");
3213 gtk_signal_connect (GTK_OBJECT (button), "clicked",
3214 GTK_SIGNAL_FUNC(list_remove),
3216 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
3218 list_omenu = gtk_option_menu_new ();
3219 menu = gtk_menu_new ();
3222 menu_item = gtk_radio_menu_item_new_with_label (group, "Single");
3223 gtk_signal_connect (GTK_OBJECT (menu_item), "activate",
3224 GTK_SIGNAL_FUNC (list_toggle_sel_mode), list);
3225 group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menu_item));
3226 gtk_menu_append (GTK_MENU (menu), menu_item);
3227 gtk_widget_show (menu_item);
3229 menu_item = gtk_radio_menu_item_new_with_label (group, "Browse");
3230 gtk_signal_connect (GTK_OBJECT (menu_item), "activate",
3231 GTK_SIGNAL_FUNC (list_toggle_sel_mode), list);
3232 group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menu_item));
3233 gtk_menu_append (GTK_MENU (menu), menu_item);
3234 gtk_widget_show (menu_item);
3236 menu_item = gtk_radio_menu_item_new_with_label (group, "Multiple");
3237 gtk_signal_connect (GTK_OBJECT (menu_item), "activate",
3238 GTK_SIGNAL_FUNC (list_toggle_sel_mode), list);
3239 group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menu_item));
3240 gtk_menu_append (GTK_MENU (menu), menu_item);
3241 gtk_widget_show (menu_item);
3243 menu_item = gtk_radio_menu_item_new_with_label (group, "Extended");
3244 gtk_signal_connect (GTK_OBJECT (menu_item), "activate",
3245 GTK_SIGNAL_FUNC (list_toggle_sel_mode), list);
3246 group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menu_item));
3247 gtk_menu_append (GTK_MENU (menu), menu_item);
3248 gtk_check_menu_item_set_state (GTK_CHECK_MENU_ITEM (menu_item), TRUE);
3249 gtk_widget_show (menu_item);
3251 gtk_option_menu_set_menu (GTK_OPTION_MENU (list_omenu), menu);
3252 gtk_box_pack_start (GTK_BOX (hbox), list_omenu, FALSE, TRUE, 0);
3254 gtk_option_menu_set_history (GTK_OPTION_MENU (list_omenu), 3);
3256 separator = gtk_hseparator_new ();
3257 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
3260 box2 = gtk_vbox_new (FALSE, 10);
3261 gtk_container_border_width (GTK_CONTAINER (box2), 10);
3262 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
3264 button = gtk_button_new_with_label ("close");
3265 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
3266 GTK_SIGNAL_FUNC(gtk_widget_destroy),
3267 GTK_OBJECT (window));
3268 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
3270 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
3271 gtk_widget_grab_default (button);
3274 if (!GTK_WIDGET_VISIBLE (window))
3275 gtk_widget_show_all (window);
3277 gtk_widget_destroy (window);
3284 static char * book_open_xpm[] = {
3307 static char * book_closed_xpm[] = {
3332 static char * mini_page_xpm[] = {
3355 #define TESTGTK_CLIST_COLUMNS 20
3356 static gint clist_rows = 0;
3357 static GtkWidget *clist_omenu;
3360 add1000_clist (GtkWidget *widget, gpointer data)
3363 char text[TESTGTK_CLIST_COLUMNS][50];
3364 char *texts[TESTGTK_CLIST_COLUMNS];
3368 pixmap = gdk_pixmap_create_from_xpm_d (GTK_CLIST (data)->clist_window,
3370 >K_WIDGET (data)->style->white,
3373 for (i = 0; i < TESTGTK_CLIST_COLUMNS; i++)
3376 sprintf (text[i], "Column %d", i);
3380 sprintf (text[1], "Right");
3381 sprintf (text[2], "Center");
3383 gtk_clist_freeze (GTK_CLIST (data));
3384 for (i = 0; i < 1000; i++)
3386 sprintf (text[0], "Row %d", rand() % 10000 /*clist_rows++*/);
3387 row = gtk_clist_append (GTK_CLIST (data), texts);
3388 gtk_clist_set_pixtext (GTK_CLIST (data), row, 3, "Hello World", 5, pixmap, mask);
3391 gtk_clist_thaw (GTK_CLIST (data));
3393 gdk_pixmap_unref (pixmap);
3394 gdk_bitmap_unref (mask);
3398 add10000_clist (GtkWidget *widget, gpointer data)
3401 char text[TESTGTK_CLIST_COLUMNS][50];
3402 char *texts[TESTGTK_CLIST_COLUMNS];
3404 for (i = 0; i < TESTGTK_CLIST_COLUMNS; i++)
3407 sprintf (text[i], "Column %d", i);
3410 sprintf (text[1], "Right");
3411 sprintf (text[2], "Center");
3413 gtk_clist_freeze (GTK_CLIST (data));
3414 for (i = 0; i < 10000; i++)
3416 sprintf (text[0], "Row %d", rand() % 10000 /*clist_rows++*/);
3417 gtk_clist_append (GTK_CLIST (data), texts);
3419 gtk_clist_thaw (GTK_CLIST (data));
3423 clear_clist (GtkWidget *widget, gpointer data)
3425 gtk_clist_clear (GTK_CLIST (data));
3430 remove_row_clist (GtkWidget *widget, gpointer data)
3432 gtk_clist_remove (GTK_CLIST (data), GTK_CLIST (data)->focus_row);
3437 show_titles_clist (GtkWidget *widget, gpointer data)
3439 gtk_clist_column_titles_show (GTK_CLIST (data));
3443 hide_titles_clist (GtkWidget *widget, gpointer data)
3445 gtk_clist_column_titles_hide (GTK_CLIST (data));
3449 select_clist (GtkWidget *widget,
3452 GdkEventButton * bevent,
3462 g_print ("GtkCList Selection: row %d column %d button %d\n",
3463 row, column, bevent ? bevent->button : 0);
3465 for (i = 0; i < TESTGTK_CLIST_COLUMNS; i++)
3467 switch (gtk_clist_get_cell_type (GTK_CLIST (widget), row, i))
3470 g_print ("CELL %d GTK_CELL_TEXT\n", i);
3471 gtk_clist_get_text (GTK_CLIST (widget), row, i, &text);
3472 g_print ("TEXT: %s\n", text);
3475 case GTK_CELL_PIXMAP:
3476 g_print ("CELL %d GTK_CELL_PIXMAP\n", i);
3477 gtk_clist_get_pixmap (GTK_CLIST (widget), row, i, &pixmap, &mask);
3478 g_print ("PIXMAP: %p\n", pixmap);
3479 g_print ("MASK: %p\n", mask);
3482 case GTK_CELL_PIXTEXT:
3483 g_print ("CELL %d GTK_CELL_PIXTEXT\n", i);
3484 gtk_clist_get_pixtext (GTK_CLIST (widget), row, i, &text, &spacing, &pixmap, &mask);
3485 g_print ("TEXT: %s\n", text);
3486 g_print ("SPACING: %d\n", spacing);
3487 g_print ("PIXMAP: %p\n", pixmap);
3488 g_print ("MASK: %p\n", mask);
3496 /* print selections list */
3497 g_print ("\nSelected Rows:");
3498 list = GTK_CLIST (widget)->selection;
3501 g_print (" %d ", GPOINTER_TO_INT (list->data));
3509 unselect_clist (GtkWidget *widget,
3512 GdkEventButton * bevent,
3522 g_print ("GtkCList Unselection: row %d column %d button %d\n",
3523 row, column, bevent ? bevent->button : 0);
3525 for (i = 0; i < TESTGTK_CLIST_COLUMNS; i++)
3527 switch (gtk_clist_get_cell_type (GTK_CLIST (widget), row, i))
3530 g_print ("CELL %d GTK_CELL_TEXT\n", i);
3531 gtk_clist_get_text (GTK_CLIST (widget), row, i, &text);
3532 g_print ("TEXT: %s\n", text);
3535 case GTK_CELL_PIXMAP:
3536 g_print ("CELL %d GTK_CELL_PIXMAP\n", i);
3537 gtk_clist_get_pixmap (GTK_CLIST (widget), row, i, &pixmap, &mask);
3538 g_print ("PIXMAP: %p\n", pixmap);
3539 g_print ("MASK: %p\n", mask);
3542 case GTK_CELL_PIXTEXT:
3543 g_print ("CELL %d GTK_CELL_PIXTEXT\n", i);
3544 gtk_clist_get_pixtext (GTK_CLIST (widget), row, i, &text, &spacing, &pixmap, &mask);
3545 g_print ("TEXT: %s\n", text);
3546 g_print ("SPACING: %d\n", spacing);
3547 g_print ("PIXMAP: %p\n", pixmap);
3548 g_print ("MASK: %p\n", mask);
3556 /* print selections list */
3557 g_print ("\nSelected Rows:");
3558 list = GTK_CLIST (widget)->selection;
3561 g_print (" %d ", GPOINTER_TO_INT (list->data));
3569 insert_row_clist (GtkWidget *widget, gpointer data)
3571 static char *text[] =
3573 "This", "is", "a", "inserted", "row.",
3574 "This", "is", "a", "inserted", "row.",
3575 "This", "is", "a", "inserted", "row.",
3576 "This", "is", "a", "inserted", "row."
3579 if (GTK_CLIST (data)->focus_row >= 0)
3580 gtk_clist_insert (GTK_CLIST (data), GTK_CLIST (data)->focus_row, text);
3582 gtk_clist_insert (GTK_CLIST (data), 0, text);
3588 clist_warning_test (GtkWidget *button,
3592 static gboolean add_remove = FALSE;
3594 add_remove = !add_remove;
3596 child = gtk_label_new ("Test");
3597 gtk_widget_ref (child);
3598 gtk_object_sink (GTK_OBJECT (child));
3601 gtk_container_add (GTK_CONTAINER (clist), child);
3604 child->parent = clist;
3605 gtk_container_remove (GTK_CONTAINER (clist), child);
3606 child->parent = NULL;
3609 gtk_widget_destroy (child);
3610 gtk_widget_unref (child);
3614 undo_selection (GtkWidget *button, GtkCList *clist)
3616 gtk_clist_undo_selection (clist);
3620 clist_toggle_sel_mode (GtkWidget *widget, GtkCList *clist)
3624 if (!GTK_WIDGET_MAPPED (widget))
3627 RADIOMENUTOGGLED ((GtkRadioMenuItem *)
3628 (((GtkOptionMenu *)clist_omenu)->menu_item), i);
3630 gtk_clist_set_selection_mode (clist, (GtkSelectionMode) (3-i));
3634 clist_click_column (GtkCList *clist, gint column, gpointer data)
3636 if (column == clist->sort_column)
3638 if (clist->sort_type == GTK_SORT_ASCENDING)
3639 clist->sort_type = GTK_SORT_DESCENDING;
3641 clist->sort_type = GTK_SORT_ASCENDING;
3644 gtk_clist_set_sort_column (clist, column);
3646 gtk_clist_sort (clist);
3653 static GtkWidget *window = NULL;
3655 static char *titles[] =
3657 "Title 0", "Title 1", "Title 2", "Title 3", "Title 4",
3658 "Title 5", "Title 6", "Title 7", "Title 8", "Title 9",
3659 "Title 10", "Title 11", "Title 12", "Title 13", "Title 14",
3660 "Title 15", "Title 16", "Title 17", "Title 18", "Title 19"
3663 static OptionMenuItem items[] =
3665 { "Single", clist_toggle_sel_mode },
3666 { "Browse", clist_toggle_sel_mode },
3667 { "Multiple", clist_toggle_sel_mode },
3668 { "Extended", clist_toggle_sel_mode }
3671 char text[TESTGTK_CLIST_COLUMNS][50];
3672 char *texts[TESTGTK_CLIST_COLUMNS];
3678 GtkWidget *separator;
3680 GtkWidget *undo_button;
3686 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
3688 gtk_signal_connect (GTK_OBJECT (window), "destroy",
3689 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
3692 gtk_window_set_title (GTK_WINDOW (window), "clist");
3693 gtk_container_border_width (GTK_CONTAINER (window), 0);
3695 box1 = gtk_vbox_new (FALSE, 0);
3696 gtk_container_add (GTK_CONTAINER (window), box1);
3698 box2 = gtk_hbox_new (FALSE, 10);
3699 gtk_container_border_width (GTK_CONTAINER (box2), 10);
3700 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0);
3702 /* create GtkCList here so we have a pointer to throw at the
3703 * button callbacks -- more is done with it later */
3704 clist = gtk_clist_new_with_titles (TESTGTK_CLIST_COLUMNS, titles);
3705 /*clist = gtk_clist_new (TESTGTK_CLIST_COLUMNS);*/
3707 gtk_signal_connect (GTK_OBJECT (clist), "click_column",
3708 (GtkSignalFunc) clist_click_column,
3711 /* control buttons */
3712 button = gtk_button_new_with_label ("Add 1,000 Rows With Pixmaps");
3713 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
3715 gtk_signal_connect (GTK_OBJECT (button),
3717 (GtkSignalFunc) add1000_clist,
3720 button = gtk_button_new_with_label ("Add 10,000 Rows");
3721 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
3723 gtk_signal_connect (GTK_OBJECT (button),
3725 (GtkSignalFunc) add10000_clist,
3728 button = gtk_button_new_with_label ("Clear List");
3729 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
3731 gtk_signal_connect (GTK_OBJECT (button),
3733 (GtkSignalFunc) clear_clist,
3736 button = gtk_button_new_with_label ("Remove Row");
3737 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
3739 gtk_signal_connect (GTK_OBJECT (button),
3741 (GtkSignalFunc) remove_row_clist,
3744 /* second layer of buttons */
3745 box2 = gtk_hbox_new (FALSE, 10);
3746 gtk_container_border_width (GTK_CONTAINER (box2), 10);
3747 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0);
3749 button = gtk_button_new_with_label ("Insert Row");
3750 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
3752 gtk_signal_connect (GTK_OBJECT (button),
3754 (GtkSignalFunc) insert_row_clist,
3757 button = gtk_button_new_with_label ("Show Title Buttons");
3758 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
3760 gtk_signal_connect (GTK_OBJECT (button),
3762 (GtkSignalFunc) show_titles_clist,
3765 button = gtk_button_new_with_label ("Hide Title Buttons");
3766 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
3768 gtk_signal_connect (GTK_OBJECT (button),
3770 (GtkSignalFunc) hide_titles_clist,
3773 button = gtk_button_new_with_label ("Warning Test");
3774 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
3776 gtk_signal_connect (GTK_OBJECT (button),
3778 (GtkSignalFunc) clist_warning_test,
3781 box2 = gtk_hbox_new (FALSE, 10);
3782 gtk_container_border_width (GTK_CONTAINER (box2), 10);
3783 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0);
3785 undo_button = gtk_button_new_with_label ("Undo last selection");
3786 gtk_box_pack_start (GTK_BOX (box2), undo_button, TRUE, TRUE, 0);
3787 gtk_signal_connect (GTK_OBJECT (undo_button),
3789 (GtkSignalFunc) undo_selection,
3792 label = gtk_label_new ("Selection Mode :");
3793 gtk_box_pack_start (GTK_BOX (box2), label, FALSE, TRUE, 0);
3795 clist_omenu = build_option_menu (items, 4, 3, clist);
3796 gtk_box_pack_start (GTK_BOX (box2), clist_omenu, FALSE, TRUE, 0);
3798 /* vbox for the list itself */
3799 box2 = gtk_vbox_new (FALSE, 10);
3800 gtk_container_border_width (GTK_CONTAINER (box2), 10);
3801 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
3804 * the rest of the clist configuration
3808 gtk_signal_connect (GTK_OBJECT (clist),
3810 (GtkSignalFunc) select_clist,
3813 gtk_signal_connect (GTK_OBJECT (clist),
3815 (GtkSignalFunc) unselect_clist,
3819 gtk_clist_set_row_height (GTK_CLIST (clist), 18);
3820 gtk_widget_set_usize (clist, -1, 300);
3822 gtk_clist_set_column_width (GTK_CLIST (clist), 0, 100);
3824 for (i = 1; i < TESTGTK_CLIST_COLUMNS; i++)
3825 gtk_clist_set_column_width (GTK_CLIST (clist), i, 80);
3827 gtk_clist_set_selection_mode (GTK_CLIST (clist), GTK_SELECTION_EXTENDED);
3828 gtk_clist_set_policy (GTK_CLIST (clist), GTK_POLICY_AUTOMATIC,
3829 GTK_POLICY_AUTOMATIC);
3831 gtk_clist_set_column_justification (GTK_CLIST (clist), 1,
3833 gtk_clist_set_column_justification (GTK_CLIST (clist), 2,
3834 GTK_JUSTIFY_CENTER);
3836 for (i = 0; i < TESTGTK_CLIST_COLUMNS; i++)
3839 sprintf (text[i], "Column %d", i);
3842 sprintf (text[1], "Right");
3843 sprintf (text[2], "Center");
3845 for (i = 0; i < 10; i++)
3847 sprintf (text[0], "Row %d", clist_rows++);
3848 gtk_clist_append (GTK_CLIST (clist), texts);
3851 gtk_container_border_width (GTK_CONTAINER (clist), 5);
3852 gtk_box_pack_start (GTK_BOX (box2), clist, TRUE, TRUE, 0);
3854 separator = gtk_hseparator_new ();
3855 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
3857 box2 = gtk_vbox_new (FALSE, 10);
3858 gtk_container_border_width (GTK_CONTAINER (box2), 10);
3859 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
3861 button = gtk_button_new_with_label ("close");
3862 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
3863 GTK_SIGNAL_FUNC(gtk_widget_destroy),
3864 GTK_OBJECT (window));
3866 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
3867 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
3868 gtk_widget_grab_default (button);
3871 if (!GTK_WIDGET_VISIBLE (window))
3872 gtk_widget_show_all (window);
3876 gtk_widget_destroy (window);
3891 static gint books = 0;
3892 static gint pages = 0;
3894 static GtkWidget *book_label;
3895 static GtkWidget *page_label;
3896 static GtkWidget *sel_label;
3897 static GtkWidget *vis_label;
3898 static GtkWidget *omenu1;
3899 static GtkWidget *omenu2;
3900 static GtkWidget *omenu3;
3901 static GtkWidget *spin1;
3902 static GtkWidget *spin2;
3903 static GtkWidget *spin3;
3904 static GdkColor *col_bg;
3906 void after_press (GtkCTree *ctree, gpointer data)
3910 sprintf (buf, "%d", g_list_length (GTK_CLIST (ctree)->selection));
3911 gtk_label_set (GTK_LABEL (sel_label), buf);
3913 sprintf (buf, "%d", g_list_length (GTK_CLIST (ctree)->row_list));
3914 gtk_label_set (GTK_LABEL (vis_label), buf);
3916 sprintf (buf, "%d", books);
3917 gtk_label_set (GTK_LABEL (book_label), buf);
3919 sprintf (buf, "%d", pages);
3920 gtk_label_set (GTK_LABEL (page_label), buf);
3923 void after_move (GtkCTree *ctree, GtkCTreeNode *child, GtkCTreeNode *parent,
3924 GtkCTreeNode *sibling, gpointer data)
3930 gtk_ctree_get_node_info (ctree, child, &source,
3931 NULL, NULL, NULL, NULL, NULL, NULL, NULL);
3933 gtk_ctree_get_node_info (ctree, parent, &target1,
3934 NULL, NULL, NULL, NULL, NULL, NULL, NULL);
3936 gtk_ctree_get_node_info (ctree, sibling, &target2,
3937 NULL, NULL, NULL, NULL, NULL, NULL, NULL);
3939 g_print ("Moving \"%s\" to \"%s\" with sibling \"%s\".\n", source,
3940 (parent) ? target1 : "nil", (sibling) ? target2 : "nil");
3943 gint button_press (GtkCTree *ctree, GdkEventButton *event, gpointer data)
3950 res = gtk_clist_get_selection_info (GTK_CLIST (ctree), event->x, event->y,
3952 if (!res && event->button != 3)
3955 work = GTK_CTREE_NODE (g_list_nth (GTK_CLIST (ctree)->row_list, row));
3957 switch (event->button)
3960 if (GTK_CLIST (ctree)->selection_mode == GTK_SELECTION_MULTIPLE &&
3961 event->state & GDK_SHIFT_MASK)
3962 gtk_signal_emit_stop_by_name (GTK_OBJECT (ctree),"button_press_event");
3965 if (GTK_CTREE_ROW (work)->children &&
3966 gtk_ctree_is_hot_spot (ctree, event->x, event->y))
3968 if (GTK_CTREE_ROW (work)->expanded)
3969 gtk_ctree_collapse_recursive (ctree, work);
3971 gtk_ctree_expand_recursive (ctree, work);
3972 after_press (ctree, NULL);
3973 gtk_signal_emit_stop_by_name (GTK_OBJECT (ctree),
3974 "button_press_event");
3983 gint button_release (GtkCTree *ctree, GdkEventButton *event, gpointer data)
3990 res = gtk_clist_get_selection_info (GTK_CLIST (ctree), event->x, event->y,
3992 if (!res || event->button != 1)
3995 work = GTK_CTREE_NODE (g_list_nth (GTK_CLIST (ctree)->row_list, row));
3997 if (GTK_CLIST (ctree)->selection_mode == GTK_SELECTION_MULTIPLE &&
3998 event->state & GDK_SHIFT_MASK)
4000 if (GTK_CTREE_ROW (work)->row.state == GTK_STATE_SELECTED)
4001 gtk_ctree_unselect_recursive (ctree, work);
4003 gtk_ctree_select_recursive (ctree, work);
4004 after_press (ctree, NULL);
4005 gtk_signal_emit_stop_by_name (GTK_OBJECT (ctree),
4006 "button_release_event");
4011 void count_items (GtkCTree *ctree, GtkCTreeNode *list)
4013 if (GTK_CTREE_ROW (list)->is_leaf)
4019 void expand_all (GtkWidget *widget, GtkCTree *ctree)
4021 gtk_ctree_expand_recursive (ctree, NULL);
4022 after_press (ctree, NULL);
4025 void collapse_all (GtkWidget *widget, GtkCTree *ctree)
4027 gtk_ctree_collapse_recursive (ctree, NULL);
4028 after_press (ctree, NULL);
4031 void select_all (GtkWidget *widget, GtkCTree *ctree)
4033 gtk_ctree_select_recursive (ctree, NULL);
4034 after_press (ctree, NULL);
4037 void unselect_all (GtkWidget *widget, GtkCTree *ctree)
4039 gtk_ctree_unselect_recursive (ctree, NULL);
4040 after_press (ctree, NULL);
4043 void remove_selection (GtkWidget *widget, GtkCTree *ctree)
4046 GtkCTreeNode *new_sel;
4049 selection = GTK_CLIST (ctree)->selection;
4052 gtk_clist_freeze (GTK_CLIST (ctree));
4056 work = selection->data;
4057 if (GTK_CTREE_ROW (work)->is_leaf)
4060 gtk_ctree_post_recursive (ctree, work,
4061 (GtkCTreeFunc) count_items, NULL);
4063 if (GTK_CLIST (ctree)->selection_mode == GTK_SELECTION_BROWSE)
4065 if (GTK_CTREE_ROW (work)->children)
4067 new_sel = GTK_CTREE_ROW (work)->sibling;
4069 new_sel = GTK_CTREE_NODE_NEXT (work);
4073 if (GTK_CTREE_NODE_NEXT (work))
4074 new_sel = GTK_CTREE_NODE_NEXT (work);
4076 new_sel = GTK_CTREE_NODE_PREV (work);
4080 gtk_ctree_remove_node (ctree, work);
4081 selection = GTK_CLIST (ctree)->selection;
4085 gtk_ctree_select (ctree, new_sel);
4087 gtk_clist_thaw (GTK_CLIST (ctree));
4088 after_press (ctree, NULL);
4091 void sort_all (GtkWidget *widget, GtkCTree *ctree)
4093 gtk_ctree_sort_recursive (ctree, NULL);
4096 struct _ExportStruct {
4102 typedef struct _ExportStruct ExportStruct;
4105 gnode2ctree (GtkCTree *ctree,
4108 GtkCTreeNode *cnode,
4112 GdkPixmap *pixmap_closed;
4113 GdkBitmap *mask_closed;
4114 GdkPixmap *pixmap_opened;
4115 GdkBitmap *mask_opened;
4117 if (!cnode || !gnode || (!(es = gnode->data)))
4122 pixmap_closed = pixmap3;
4123 mask_closed = mask3;
4124 pixmap_opened = NULL;
4129 pixmap_closed = pixmap1;
4130 mask_closed = mask1;
4131 pixmap_opened = pixmap2;
4132 mask_opened = mask2;
4135 gtk_ctree_set_node_info (ctree, cnode, es->tree, 2, pixmap_closed,
4136 mask_closed, pixmap_opened, mask_opened,
4137 es->is_leaf, (depth < 3));
4138 gtk_ctree_node_set_text (ctree, cnode, 1, es->info);
4146 ctree2gnode (GtkCTree *ctree,
4149 GtkCTreeNode *cnode,
4154 if (!cnode || !gnode)
4157 es = g_new (ExportStruct, 1);
4159 es->is_leaf = GTK_CTREE_ROW (cnode)->is_leaf;
4160 es->tree = GTK_CELL_PIXTEXT (GTK_CTREE_ROW (cnode)->row.cell[0])->text;
4161 es->info = GTK_CELL_PIXTEXT (GTK_CTREE_ROW (cnode)->row.cell[1])->text;
4165 void export_ctree (GtkWidget *widget, GtkCTree *ctree)
4167 char *title[] = { "Tree" , "Info" };
4168 static GtkWidget *export_window = NULL;
4169 static GtkCTree *export_ctree;
4178 export_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
4180 gtk_signal_connect (GTK_OBJECT (export_window), "destroy",
4181 GTK_SIGNAL_FUNC (gtk_widget_destroyed),
4184 gtk_window_set_title (GTK_WINDOW (export_window), "exported ctree");
4185 gtk_container_border_width (GTK_CONTAINER (export_window), 5);
4187 vbox = gtk_vbox_new (FALSE, 0);
4188 gtk_container_add (GTK_CONTAINER (export_window), vbox);
4190 button = gtk_button_new_with_label ("Close");
4191 gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, TRUE, 0);
4193 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
4194 (GtkSignalFunc) gtk_widget_destroy,
4195 GTK_OBJECT(export_window));
4197 sep = gtk_hseparator_new ();
4198 gtk_box_pack_end (GTK_BOX (vbox), sep, FALSE, TRUE, 10);
4200 export_ctree = GTK_CTREE (gtk_ctree_new_with_titles (2, 0, title));
4201 gtk_ctree_set_line_style (export_ctree, GTK_CTREE_LINES_DOTTED);
4203 gtk_box_pack_start (GTK_BOX (vbox), GTK_WIDGET (export_ctree),
4205 gtk_clist_set_selection_mode (GTK_CLIST (export_ctree),
4206 GTK_SELECTION_EXTENDED);
4207 gtk_clist_set_policy (GTK_CLIST (export_ctree), GTK_POLICY_ALWAYS,
4208 GTK_POLICY_AUTOMATIC);
4209 gtk_clist_set_column_width (GTK_CLIST (export_ctree), 0, 200);
4210 gtk_clist_set_column_width (GTK_CLIST (export_ctree), 1, 200);
4211 gtk_widget_set_usize (GTK_WIDGET (export_ctree), 300, 200);
4214 if (!GTK_WIDGET_VISIBLE (export_window))
4215 gtk_widget_show_all (export_window);
4217 gtk_clist_clear (GTK_CLIST (export_ctree));
4219 node = GTK_CTREE_NODE (g_list_nth (GTK_CLIST (ctree)->row_list,
4220 GTK_CLIST (ctree)->focus_row));
4224 gnode = gtk_ctree_export_to_gnode (ctree, NULL, NULL, node,
4228 gtk_ctree_insert_gnode (export_ctree, NULL, NULL, gnode,
4230 g_node_destroy (gnode);
4234 void change_indent (GtkWidget *widget, GtkCTree *ctree)
4236 gtk_ctree_set_indent (ctree, GTK_ADJUSTMENT (widget)->value);
4239 void change_row_height (GtkWidget *widget, GtkCList *clist)
4241 gtk_clist_set_row_height (clist, GTK_ADJUSTMENT (widget)->value);
4244 void toggle_reorderable (GtkWidget *widget, GtkCTree *ctree)
4246 gtk_ctree_set_reorderable (ctree, GTK_TOGGLE_BUTTON (widget)->active);
4249 void set_background (GtkCTree *ctree, GtkCTreeNode *node, gpointer data)
4254 if (ctree->line_style != GTK_CTREE_LINES_TABBED)
4256 if (GTK_CTREE_ROW (node)->is_leaf)
4258 if (GTK_CTREE_ROW (node)->parent)
4259 gtk_ctree_node_set_background
4261 GTK_CTREE_ROW (GTK_CTREE_ROW (node)->parent)->row.data);
4264 gtk_ctree_node_set_background (ctree, node,
4265 GTK_CTREE_ROW (node)->row.data);
4268 gtk_ctree_node_set_background (ctree, node, NULL);
4271 void ctree_toggle_line_style (GtkWidget *widget, GtkCTree *ctree)
4275 if (!GTK_WIDGET_MAPPED (widget))
4278 RADIOMENUTOGGLED ((GtkRadioMenuItem *)
4279 (((GtkOptionMenu *)omenu1)->menu_item),i);
4281 if ((ctree->line_style == GTK_CTREE_LINES_TABBED &&
4282 ((GtkCTreeLineStyle) (3-i)) != GTK_CTREE_LINES_TABBED) ||
4283 (ctree->line_style != GTK_CTREE_LINES_TABBED &&
4284 ((GtkCTreeLineStyle) (3-i)) == GTK_CTREE_LINES_TABBED))
4285 gtk_ctree_pre_recursive (ctree, NULL, set_background, NULL);
4286 gtk_ctree_set_line_style (ctree, (GtkCTreeLineStyle) (3-i));
4289 void ctree_toggle_justify (GtkWidget *widget, GtkCTree *ctree)
4293 if (!GTK_WIDGET_MAPPED (widget))
4296 RADIOMENUTOGGLED ((GtkRadioMenuItem *)
4297 (((GtkOptionMenu *)omenu2)->menu_item),i);
4299 gtk_clist_set_column_justification (GTK_CLIST (ctree), ctree->tree_column,
4300 (GtkJustification) (1-i));
4303 void ctree_toggle_sel_mode (GtkWidget *widget, GtkCTree *ctree)
4307 if (!GTK_WIDGET_MAPPED (widget))
4310 RADIOMENUTOGGLED ((GtkRadioMenuItem *)
4311 (((GtkOptionMenu *)omenu3)->menu_item), i);
4313 gtk_clist_set_selection_mode (GTK_CLIST (ctree), (GtkSelectionMode) (3-i));
4314 after_press (ctree, NULL);
4317 void build_recursive (GtkCTree *ctree, gint cur_depth, gint depth,
4318 gint num_books, gint num_pages, GtkCTreeNode *parent)
4323 GtkCTreeNode *sibling;
4330 for (i = num_pages + num_books; i > num_books; i--)
4333 sprintf (buf1, "Page %02d", (gint) rand() % 100);
4334 sprintf (buf2, "Item %d-%d", cur_depth, i);
4335 sibling = gtk_ctree_insert_node (ctree, parent, sibling, text, 5,
4336 pixmap3, mask3, NULL, NULL,
4339 if (ctree->line_style == GTK_CTREE_LINES_TABBED)
4340 gtk_ctree_node_set_background (ctree, sibling, col_bg);
4343 if (cur_depth == depth)
4346 for (i = num_books; i > 0; i--)
4349 sprintf (buf1, "Book %02d", (gint) rand() % 100);
4350 sprintf (buf2, "Item %d-%d", cur_depth, i);
4351 sibling = gtk_ctree_insert_node (ctree, parent, sibling, text, 5,
4352 pixmap1, mask1, pixmap2, mask2,
4355 col_bg = g_new (GdkColor, 1);
4357 if (cur_depth % 3 == 0)
4359 col_bg->red = 10000 * (cur_depth % 6);
4361 col_bg->blue = 65535 - ((i * 10000) % 65535);
4363 else if (cur_depth % 3 == 1)
4365 col_bg->red = 10000 * (cur_depth % 6);
4366 col_bg->green = 65535 - ((i * 10000) % 65535);
4371 col_bg->red = 65535 - ((i * 10000) % 65535);
4373 col_bg->blue = 10000 * (cur_depth % 6);
4376 gdk_color_alloc (gtk_widget_get_colormap (GTK_WIDGET (ctree)), col_bg);
4377 gtk_ctree_node_set_row_data_full (ctree, sibling, col_bg, g_free);
4379 if (ctree->line_style == GTK_CTREE_LINES_TABBED)
4380 gtk_ctree_node_set_background (ctree, sibling, col_bg);
4382 build_recursive (ctree, cur_depth + 1, depth, num_books, num_pages,
4387 void rebuild_tree (GtkWidget *widget, GtkCTree *ctree)
4390 gchar label1[] = "Root";
4391 gchar label2[] = "";
4392 GtkCTreeNode *parent;
4398 d = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (spin1));
4399 b = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (spin2));
4400 p = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (spin3));
4402 n = ((pow (b, d) - 1) / (b - 1)) * (p + 1);
4406 g_print ("%d total items? Try less\n",n);
4410 gtk_clist_freeze (GTK_CLIST (ctree));
4411 gtk_clist_clear (GTK_CLIST (ctree));
4416 parent = gtk_ctree_insert_node (ctree, NULL, NULL, text, 5, pixmap1,
4417 mask1, pixmap2, mask2, FALSE, TRUE);
4419 col_bg = g_new (GdkColor, 1);
4421 col_bg->green = 45000;
4422 col_bg->blue = 55000;
4423 gdk_color_alloc (gtk_widget_get_colormap (GTK_WIDGET (ctree)), col_bg);
4424 gtk_ctree_node_set_row_data_full (ctree, parent, col_bg, g_free);
4425 if (ctree->line_style == GTK_CTREE_LINES_TABBED)
4426 gtk_ctree_node_set_background (ctree, parent, col_bg);
4428 build_recursive (ctree, 1, d, b, p, parent);
4429 gtk_clist_thaw (GTK_CLIST (ctree));
4430 after_press (ctree, NULL);
4434 ctree_click_column (GtkCTree *ctree, gint column, gpointer data)
4438 clist = GTK_CLIST (ctree);
4440 if (column == clist->sort_column)
4442 if (clist->sort_type == GTK_SORT_ASCENDING)
4443 clist->sort_type = GTK_SORT_DESCENDING;
4445 clist->sort_type = GTK_SORT_ASCENDING;
4448 gtk_clist_set_sort_column (clist, column);
4450 gtk_ctree_sort_recursive (ctree, NULL);
4453 void create_ctree (void)
4455 static GtkWidget *window = NULL;
4456 GtkTooltips *tooltips;
4467 GdkColor transparent;
4469 char *title[] = { "Tree" , "Info" };
4472 static OptionMenuItem items1[] =
4474 { "Solid", ctree_toggle_line_style },
4475 { "Dotted", ctree_toggle_line_style },
4476 { "Tabbed", ctree_toggle_line_style },
4477 { "No lines", ctree_toggle_line_style }
4480 static OptionMenuItem items2[] =
4482 { "Left", ctree_toggle_justify },
4483 { "Right", ctree_toggle_justify }
4486 static OptionMenuItem items3[] =
4488 { "Single", ctree_toggle_sel_mode },
4489 { "Browse", ctree_toggle_sel_mode },
4490 { "Multiple", ctree_toggle_sel_mode },
4491 { "Extended", ctree_toggle_sel_mode }
4496 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
4498 gtk_signal_connect (GTK_OBJECT (window), "destroy",
4499 GTK_SIGNAL_FUNC (gtk_widget_destroyed),
4502 gtk_window_set_title (GTK_WINDOW (window), "GtkCTree");
4503 gtk_container_border_width (GTK_CONTAINER (window), 0);
4505 tooltips = gtk_tooltips_new ();
4506 gtk_object_ref (GTK_OBJECT (tooltips));
4507 gtk_object_sink (GTK_OBJECT (tooltips));
4509 gtk_object_set_data_full (GTK_OBJECT (window), "tooltips", tooltips,
4510 (GtkDestroyNotify) gtk_object_unref);
4512 vbox = gtk_vbox_new (FALSE, 0);
4513 gtk_container_add (GTK_CONTAINER (window), vbox);
4515 hbox = gtk_hbox_new (FALSE, 5);
4516 gtk_container_border_width (GTK_CONTAINER (hbox), 5);
4517 gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0);
4519 label = gtk_label_new ("Depth :");
4520 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
4522 adj = (GtkAdjustment *) gtk_adjustment_new (4, 1, 10, 1, 5, 0);
4523 spin1 = gtk_spin_button_new (adj, 0, 0);
4524 gtk_box_pack_start (GTK_BOX (hbox), spin1, FALSE, TRUE, 5);
4526 label = gtk_label_new ("Books :");
4527 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
4529 adj = (GtkAdjustment *) gtk_adjustment_new (3, 1, 20, 1, 5, 0);
4530 spin2 = gtk_spin_button_new (adj, 0, 0);
4531 gtk_box_pack_start (GTK_BOX (hbox), spin2, FALSE, TRUE, 5);
4533 label = gtk_label_new ("Pages :");
4534 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
4536 adj = (GtkAdjustment *) gtk_adjustment_new (5, 1, 20, 1, 5, 0);
4537 spin3 = gtk_spin_button_new (adj, 0, 0);
4538 gtk_box_pack_start (GTK_BOX (hbox), spin3, FALSE, TRUE, 5);
4540 button = gtk_button_new_with_label ("Close");
4541 gtk_box_pack_end (GTK_BOX (hbox), button, TRUE, TRUE, 0);
4543 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
4544 (GtkSignalFunc) gtk_widget_destroy,
4545 GTK_OBJECT(window));
4547 button = gtk_button_new_with_label ("Rebuild tree");
4548 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
4550 ctree = GTK_CTREE (gtk_ctree_new_with_titles (2, 0, title));
4551 gtk_ctree_set_line_style (ctree, GTK_CTREE_LINES_DOTTED);
4552 gtk_ctree_set_reorderable (ctree, TRUE);
4553 gtk_signal_connect (GTK_OBJECT (ctree), "click_column",
4554 (GtkSignalFunc) ctree_click_column,
4556 gtk_signal_connect (GTK_OBJECT (ctree), "button_press_event",
4557 GTK_SIGNAL_FUNC (button_press), NULL);
4558 gtk_signal_connect_after (GTK_OBJECT (ctree), "button_press_event",
4559 GTK_SIGNAL_FUNC (after_press), NULL);
4560 gtk_signal_connect (GTK_OBJECT (ctree), "button_release_event",
4561 GTK_SIGNAL_FUNC (button_release), NULL);
4562 gtk_signal_connect_after (GTK_OBJECT (ctree), "button_release_event",
4563 GTK_SIGNAL_FUNC (after_press), NULL);
4564 gtk_signal_connect_after (GTK_OBJECT (ctree), "tree_move",
4565 GTK_SIGNAL_FUNC (after_move), NULL);
4566 gtk_signal_connect_after (GTK_OBJECT (ctree), "end_selection",
4567 GTK_SIGNAL_FUNC (after_press), NULL);
4568 gtk_signal_connect_after (GTK_OBJECT (ctree), "toggle_focus_row",
4569 GTK_SIGNAL_FUNC (after_press), NULL);
4570 gtk_signal_connect_after (GTK_OBJECT (ctree), "select_all",
4571 GTK_SIGNAL_FUNC (after_press), NULL);
4572 gtk_signal_connect_after (GTK_OBJECT (ctree), "unselect_all",
4573 GTK_SIGNAL_FUNC (after_press), NULL);
4574 gtk_signal_connect_after (GTK_OBJECT (ctree), "scroll_vertical",
4575 GTK_SIGNAL_FUNC (after_press), NULL);
4577 gtk_box_pack_start (GTK_BOX (vbox), GTK_WIDGET (ctree), TRUE, TRUE, 0);
4578 gtk_clist_set_selection_mode (GTK_CLIST (ctree), GTK_SELECTION_EXTENDED);
4579 gtk_clist_set_policy (GTK_CLIST (ctree), GTK_POLICY_ALWAYS,
4580 GTK_POLICY_AUTOMATIC);
4581 gtk_clist_set_column_width (GTK_CLIST (ctree), 0, 200);
4582 gtk_clist_set_column_width (GTK_CLIST (ctree), 1, 200);
4584 gtk_signal_connect (GTK_OBJECT (button), "clicked",
4585 GTK_SIGNAL_FUNC (rebuild_tree), ctree);
4587 hbox = gtk_hbox_new (FALSE, 5);
4588 gtk_container_border_width (GTK_CONTAINER (hbox), 5);
4589 gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0);
4591 button = gtk_button_new_with_label ("Expand all");
4592 gtk_signal_connect (GTK_OBJECT (button), "clicked",
4593 GTK_SIGNAL_FUNC (expand_all), ctree);
4594 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
4596 button = gtk_button_new_with_label ("Collapse all");
4597 gtk_signal_connect (GTK_OBJECT (button), "clicked",
4598 GTK_SIGNAL_FUNC (collapse_all), ctree);
4599 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
4601 button = gtk_button_new_with_label ("Sort tree");
4602 gtk_signal_connect (GTK_OBJECT (button), "clicked",
4603 GTK_SIGNAL_FUNC (sort_all), ctree);
4604 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
4606 button = gtk_button_new_with_label ("Export tree");
4607 gtk_signal_connect (GTK_OBJECT (button), "clicked",
4608 GTK_SIGNAL_FUNC (export_ctree), ctree);
4609 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
4611 hbox = gtk_hbox_new (FALSE, 5);
4612 gtk_container_border_width (GTK_CONTAINER (hbox), 5);
4613 gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0);
4615 label = gtk_label_new ("Row height :");
4616 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
4618 adj = (GtkAdjustment *) gtk_adjustment_new (20, 12, 100, 1, 10, 0);
4619 spinner = gtk_spin_button_new (adj, 0, 0);
4620 gtk_tooltips_set_tip (tooltips, spinner,
4621 "Row height of list items", NULL);
4622 gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
4623 GTK_SIGNAL_FUNC (change_row_height), ctree);
4624 gtk_box_pack_start (GTK_BOX (hbox), spinner, FALSE, TRUE, 5);
4625 gtk_clist_set_row_height ( GTK_CLIST (ctree), adj->value);
4627 button = gtk_button_new_with_label ("Select all");
4628 gtk_signal_connect (GTK_OBJECT (button), "clicked",
4629 GTK_SIGNAL_FUNC (select_all), ctree);
4630 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
4632 button = gtk_button_new_with_label ("Unselect all");
4633 gtk_signal_connect (GTK_OBJECT (button), "clicked",
4634 GTK_SIGNAL_FUNC (unselect_all), ctree);
4635 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
4637 button = gtk_button_new_with_label ("Remove selection");
4638 gtk_signal_connect (GTK_OBJECT (button), "clicked",
4639 GTK_SIGNAL_FUNC (remove_selection), ctree);
4640 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
4642 hbox = gtk_hbox_new (TRUE, 5);
4643 gtk_container_border_width (GTK_CONTAINER (hbox), 5);
4644 gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0);
4646 hbox2 = gtk_hbox_new (FALSE, 0);
4647 gtk_box_pack_start (GTK_BOX (hbox), hbox2, FALSE, TRUE, 0);
4649 label = gtk_label_new ("Indent :");
4650 gtk_box_pack_start (GTK_BOX (hbox2), label, FALSE, TRUE, 0);
4652 adj = (GtkAdjustment *) gtk_adjustment_new (20, 0, 60, 1, 10, 0);
4653 spinner = gtk_spin_button_new (adj, 0, 0);
4654 gtk_tooltips_set_tip (tooltips, spinner, "Tree indentation.", NULL);
4655 gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
4656 GTK_SIGNAL_FUNC (change_indent), ctree);
4657 gtk_box_pack_start (GTK_BOX (hbox2), spinner, FALSE, TRUE, 5);
4659 check = gtk_check_button_new_with_label ("Reorderable");
4660 gtk_tooltips_set_tip (tooltips, check,
4661 "Tree items can be reordered by dragging.", NULL);
4662 gtk_signal_connect (GTK_OBJECT (check), "clicked",
4663 GTK_SIGNAL_FUNC (toggle_reorderable), ctree);
4664 gtk_box_pack_start (GTK_BOX (hbox), check, FALSE, TRUE, 0);
4665 gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON (check), TRUE);
4667 omenu1 = build_option_menu (items1, 4, 1, ctree);
4668 gtk_tooltips_set_tip (tooltips, omenu1, "The tree's line style.", NULL);
4669 gtk_box_pack_start (GTK_BOX (hbox), omenu1, FALSE, TRUE, 0);
4671 omenu2 = build_option_menu (items2, 2, 0, ctree);
4672 gtk_tooltips_set_tip (tooltips, omenu2, "The tree's justification.",
4674 gtk_box_pack_start (GTK_BOX (hbox), omenu2, FALSE, TRUE, 0);
4676 omenu3 = build_option_menu (items3, 4, 3, ctree);
4677 gtk_tooltips_set_tip (tooltips, omenu3, "The list's selection mode.",
4679 gtk_box_pack_start (GTK_BOX (hbox), omenu3, FALSE, TRUE, 0);
4681 gtk_widget_realize (window);
4683 pixmap1 = gdk_pixmap_create_from_xpm_d (window->window, &mask1,
4684 &transparent, book_closed_xpm);
4685 pixmap2 = gdk_pixmap_create_from_xpm_d (window->window, &mask2,
4686 &transparent, book_open_xpm);
4687 pixmap3 = gdk_pixmap_create_from_xpm_d (window->window, &mask3,
4688 &transparent, mini_page_xpm);
4690 gtk_widget_set_usize (GTK_WIDGET (ctree), 0, 300);
4692 frame = gtk_frame_new (NULL);
4693 gtk_container_border_width (GTK_CONTAINER (frame), 0);
4694 gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_OUT);
4695 gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, TRUE, 0);
4697 hbox = gtk_hbox_new (TRUE, 2);
4698 gtk_container_border_width (GTK_CONTAINER (hbox), 2);
4699 gtk_container_add (GTK_CONTAINER (frame), hbox);
4701 frame = gtk_frame_new (NULL);
4702 gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
4703 gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, TRUE, 0);
4705 hbox2 = gtk_hbox_new (FALSE, 0);
4706 gtk_container_border_width (GTK_CONTAINER (hbox2), 2);
4707 gtk_container_add (GTK_CONTAINER (frame), hbox2);
4709 label = gtk_label_new ("Books :");
4710 gtk_box_pack_start (GTK_BOX (hbox2), label, FALSE, TRUE, 0);
4712 sprintf (buf, "%d", books);
4713 book_label = gtk_label_new (buf);
4714 gtk_box_pack_end (GTK_BOX (hbox2), book_label, FALSE, TRUE, 5);
4716 frame = gtk_frame_new (NULL);
4717 gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
4718 gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, TRUE, 0);
4720 hbox2 = gtk_hbox_new (FALSE, 0);
4721 gtk_container_border_width (GTK_CONTAINER (hbox2), 2);
4722 gtk_container_add (GTK_CONTAINER (frame), hbox2);
4724 label = gtk_label_new ("Pages :");
4725 gtk_box_pack_start (GTK_BOX (hbox2), label, FALSE, TRUE, 0);
4727 sprintf (buf, "%d", pages);
4728 page_label = gtk_label_new (buf);
4729 gtk_box_pack_end (GTK_BOX (hbox2), page_label, FALSE, TRUE, 5);
4731 frame = gtk_frame_new (NULL);
4732 gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
4733 gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, TRUE, 0);
4735 hbox2 = gtk_hbox_new (FALSE, 0);
4736 gtk_container_border_width (GTK_CONTAINER (hbox2), 2);
4737 gtk_container_add (GTK_CONTAINER (frame), hbox2);
4739 label = gtk_label_new ("Selected :");
4740 gtk_box_pack_start (GTK_BOX (hbox2), label, FALSE, TRUE, 0);
4742 sprintf (buf, "%d", g_list_length (GTK_CLIST (ctree)->selection));
4743 sel_label = gtk_label_new (buf);
4744 gtk_box_pack_end (GTK_BOX (hbox2), sel_label, FALSE, TRUE, 5);
4746 frame = gtk_frame_new (NULL);
4747 gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
4748 gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, TRUE, 0);
4750 hbox2 = gtk_hbox_new (FALSE, 0);
4751 gtk_container_border_width (GTK_CONTAINER (hbox2), 2);
4752 gtk_container_add (GTK_CONTAINER (frame), hbox2);
4754 label = gtk_label_new ("Visible :");
4755 gtk_box_pack_start (GTK_BOX (hbox2), label, FALSE, TRUE, 0);
4757 sprintf (buf, "%d", g_list_length (GTK_CLIST (ctree)->row_list));
4758 vis_label = gtk_label_new (buf);
4759 gtk_box_pack_end (GTK_BOX (hbox2), vis_label, FALSE, TRUE, 5);
4761 rebuild_tree (NULL, ctree);
4764 if (!GTK_WIDGET_VISIBLE (window))
4765 gtk_widget_show_all (window);
4767 gtk_widget_destroy (window);
4775 color_selection_ok (GtkWidget *w,
4776 GtkColorSelectionDialog *cs)
4778 GtkColorSelection *colorsel;
4781 colorsel=GTK_COLOR_SELECTION(cs->colorsel);
4783 gtk_color_selection_get_color(colorsel,color);
4784 gtk_color_selection_set_color(colorsel,color);
4788 color_selection_changed (GtkWidget *w,
4789 GtkColorSelectionDialog *cs)
4791 GtkColorSelection *colorsel;
4794 colorsel=GTK_COLOR_SELECTION(cs->colorsel);
4795 gtk_color_selection_get_color(colorsel,color);
4799 create_color_selection (void)
4801 static GtkWidget *window = NULL;
4805 window = gtk_color_selection_dialog_new ("color selection dialog");
4807 gtk_color_selection_set_opacity (
4808 GTK_COLOR_SELECTION (GTK_COLOR_SELECTION_DIALOG (window)->colorsel),
4811 gtk_color_selection_set_update_policy(
4812 GTK_COLOR_SELECTION (GTK_COLOR_SELECTION_DIALOG (window)->colorsel),
4813 GTK_UPDATE_CONTINUOUS);
4815 gtk_window_position (GTK_WINDOW (window), GTK_WIN_POS_MOUSE);
4817 gtk_signal_connect (GTK_OBJECT (window), "destroy",
4818 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
4821 gtk_signal_connect (
4822 GTK_OBJECT (GTK_COLOR_SELECTION_DIALOG (window)->colorsel),
4824 GTK_SIGNAL_FUNC(color_selection_changed),
4827 gtk_signal_connect (
4828 GTK_OBJECT (GTK_COLOR_SELECTION_DIALOG (window)->ok_button),
4830 GTK_SIGNAL_FUNC(color_selection_ok),
4833 gtk_signal_connect_object (
4834 GTK_OBJECT (GTK_COLOR_SELECTION_DIALOG (window)->cancel_button),
4836 GTK_SIGNAL_FUNC(gtk_widget_destroy),
4837 GTK_OBJECT (window));
4840 if (!GTK_WIDGET_VISIBLE (window))
4841 gtk_widget_show (window);
4843 gtk_widget_destroy (window);
4851 file_selection_hide_fileops (GtkWidget *widget,
4852 GtkFileSelection *fs)
4854 gtk_file_selection_hide_fileop_buttons (fs);
4858 file_selection_ok (GtkWidget *w,
4859 GtkFileSelection *fs)
4861 g_print ("%s\n", gtk_file_selection_get_filename (fs));
4862 gtk_widget_destroy (GTK_WIDGET (fs));
4866 create_file_selection (void)
4868 static GtkWidget *window = NULL;
4873 window = gtk_file_selection_new ("file selection dialog");
4875 gtk_file_selection_hide_fileop_buttons (GTK_FILE_SELECTION (window));
4877 gtk_window_position (GTK_WINDOW (window), GTK_WIN_POS_MOUSE);
4879 gtk_signal_connect (GTK_OBJECT (window), "destroy",
4880 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
4883 gtk_signal_connect (GTK_OBJECT (GTK_FILE_SELECTION (window)->ok_button),
4884 "clicked", GTK_SIGNAL_FUNC(file_selection_ok),
4886 gtk_signal_connect_object (GTK_OBJECT (GTK_FILE_SELECTION (window)->cancel_button),
4887 "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy),
4888 GTK_OBJECT (window));
4890 button = gtk_button_new_with_label ("Hide Fileops");
4891 gtk_signal_connect (GTK_OBJECT (button), "clicked",
4892 (GtkSignalFunc) file_selection_hide_fileops,
4894 gtk_box_pack_start (GTK_BOX (GTK_FILE_SELECTION (window)->action_area),
4895 button, FALSE, FALSE, 0);
4896 gtk_widget_show (button);
4898 button = gtk_button_new_with_label ("Show Fileops");
4899 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
4900 (GtkSignalFunc) gtk_file_selection_show_fileop_buttons,
4902 gtk_box_pack_start (GTK_BOX (GTK_FILE_SELECTION (window)->action_area),
4903 button, FALSE, FALSE, 0);
4904 gtk_widget_show (button);
4907 if (!GTK_WIDGET_VISIBLE (window))
4908 gtk_widget_show (window);
4910 gtk_widget_destroy (window);
4918 font_selection_ok (GtkWidget *w,
4919 GtkFontSelectionDialog *fs)
4921 g_print ("%s\n", gtk_font_selection_dialog_get_font_name (fs));
4922 gtk_widget_destroy (GTK_WIDGET (fs));
4926 create_font_selection (void)
4928 static GtkWidget *window = NULL;
4932 window = gtk_font_selection_dialog_new ("Font Selection Dialog");
4934 gtk_window_position (GTK_WINDOW (window), GTK_WIN_POS_MOUSE);
4936 gtk_signal_connect (GTK_OBJECT (window), "destroy",
4937 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
4940 gtk_signal_connect (GTK_OBJECT (GTK_FONT_SELECTION_DIALOG (window)->ok_button),
4941 "clicked", GTK_SIGNAL_FUNC(font_selection_ok),
4942 GTK_FONT_SELECTION_DIALOG (window));
4943 gtk_signal_connect_object (GTK_OBJECT (GTK_FONT_SELECTION_DIALOG (window)->cancel_button),
4944 "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy),
4945 GTK_OBJECT (window));
4948 if (!GTK_WIDGET_VISIBLE (window))
4949 gtk_widget_show (window);
4951 gtk_widget_destroy (window);
4958 static GtkWidget *dialog_window = NULL;
4961 label_toggle (GtkWidget *widget,
4966 *label = gtk_label_new ("Dialog Test");
4967 gtk_signal_connect (GTK_OBJECT (*label),
4969 GTK_SIGNAL_FUNC (gtk_widget_destroyed),
4971 gtk_misc_set_padding (GTK_MISC (*label), 10, 10);
4972 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog_window)->vbox),
4973 *label, TRUE, TRUE, 0);
4974 gtk_widget_show (*label);
4977 gtk_widget_destroy (*label);
4981 create_dialog (void)
4983 static GtkWidget *label;
4988 dialog_window = gtk_dialog_new ();
4990 gtk_signal_connect (GTK_OBJECT (dialog_window), "destroy",
4991 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
4994 gtk_window_set_title (GTK_WINDOW (dialog_window), "GtkDialog");
4995 gtk_container_border_width (GTK_CONTAINER (dialog_window), 0);
4996 gtk_widget_set_usize (dialog_window, 200, 110);
4998 button = gtk_button_new_with_label ("OK");
4999 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
5000 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog_window)->action_area),
5001 button, TRUE, TRUE, 0);
5002 gtk_widget_grab_default (button);
5003 gtk_widget_show (button);
5005 button = gtk_button_new_with_label ("Toggle");
5006 gtk_signal_connect (GTK_OBJECT (button), "clicked",
5007 GTK_SIGNAL_FUNC (label_toggle),
5009 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
5010 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog_window)->action_area),
5011 button, TRUE, TRUE, 0);
5012 gtk_widget_show (button);
5017 if (!GTK_WIDGET_VISIBLE (dialog_window))
5018 gtk_widget_show (dialog_window);
5020 gtk_widget_destroy (dialog_window);
5028 create_range_controls (void)
5030 static GtkWidget *window = NULL;
5034 GtkWidget *scrollbar;
5036 GtkWidget *separator;
5037 GtkObject *adjustment;
5041 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
5043 gtk_signal_connect (GTK_OBJECT (window), "destroy",
5044 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
5047 gtk_window_set_title (GTK_WINDOW (window), "range controls");
5048 gtk_container_border_width (GTK_CONTAINER (window), 0);
5051 box1 = gtk_vbox_new (FALSE, 0);
5052 gtk_container_add (GTK_CONTAINER (window), box1);
5053 gtk_widget_show (box1);
5056 box2 = gtk_vbox_new (FALSE, 10);
5057 gtk_container_border_width (GTK_CONTAINER (box2), 10);
5058 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
5059 gtk_widget_show (box2);
5062 adjustment = gtk_adjustment_new (0.0, 0.0, 101.0, 0.1, 1.0, 1.0);
5064 scale = gtk_hscale_new (GTK_ADJUSTMENT (adjustment));
5065 gtk_widget_set_usize (GTK_WIDGET (scale), 150, 30);
5066 gtk_range_set_update_policy (GTK_RANGE (scale), GTK_UPDATE_DELAYED);
5067 gtk_scale_set_digits (GTK_SCALE (scale), 1);
5068 gtk_scale_set_draw_value (GTK_SCALE (scale), TRUE);
5069 gtk_box_pack_start (GTK_BOX (box2), scale, TRUE, TRUE, 0);
5070 gtk_widget_show (scale);
5072 scrollbar = gtk_hscrollbar_new (GTK_ADJUSTMENT (adjustment));
5073 gtk_range_set_update_policy (GTK_RANGE (scrollbar),
5074 GTK_UPDATE_CONTINUOUS);
5075 gtk_box_pack_start (GTK_BOX (box2), scrollbar, TRUE, TRUE, 0);
5076 gtk_widget_show (scrollbar);
5079 separator = gtk_hseparator_new ();
5080 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
5081 gtk_widget_show (separator);
5084 box2 = gtk_vbox_new (FALSE, 10);
5085 gtk_container_border_width (GTK_CONTAINER (box2), 10);
5086 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
5087 gtk_widget_show (box2);
5090 button = gtk_button_new_with_label ("close");
5091 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
5092 GTK_SIGNAL_FUNC(gtk_widget_destroy),
5093 GTK_OBJECT (window));
5094 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
5095 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
5096 gtk_widget_grab_default (button);
5097 gtk_widget_show (button);
5100 if (!GTK_WIDGET_VISIBLE (window))
5101 gtk_widget_show (window);
5103 gtk_widget_destroy (window);
5111 create_rulers (void)
5113 static GtkWidget *window = NULL;
5119 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
5120 gtk_window_set_policy (GTK_WINDOW (window), TRUE, TRUE, FALSE);
5122 gtk_signal_connect (GTK_OBJECT (window), "destroy",
5123 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
5126 gtk_window_set_title (GTK_WINDOW (window), "rulers");
5127 gtk_widget_set_usize (window, 300, 300);
5128 gtk_widget_set_events (window,
5129 GDK_POINTER_MOTION_MASK
5130 | GDK_POINTER_MOTION_HINT_MASK);
5131 gtk_container_border_width (GTK_CONTAINER (window), 0);
5133 table = gtk_table_new (2, 2, FALSE);
5134 gtk_container_add (GTK_CONTAINER (window), table);
5135 gtk_widget_show (table);
5137 ruler = gtk_hruler_new ();
5138 gtk_ruler_set_metric (GTK_RULER (ruler), GTK_CENTIMETERS);
5139 gtk_ruler_set_range (GTK_RULER (ruler), 100, 0, 0, 20);
5141 gtk_signal_connect_object (
5142 GTK_OBJECT (window),
5143 "motion_notify_event",
5145 GTK_WIDGET_CLASS (GTK_OBJECT (ruler)->klass)->motion_notify_event),
5146 GTK_OBJECT (ruler));
5148 gtk_table_attach (GTK_TABLE (table), ruler, 1, 2, 0, 1,
5149 GTK_EXPAND | GTK_FILL, GTK_FILL, 0, 0);
5150 gtk_widget_show (ruler);
5153 ruler = gtk_vruler_new ();
5154 gtk_ruler_set_range (GTK_RULER (ruler), 5, 15, 0, 20);
5156 gtk_signal_connect_object (
5157 GTK_OBJECT (window),
5158 "motion_notify_event",
5159 GTK_SIGNAL_FUNC (GTK_WIDGET_CLASS (GTK_OBJECT (ruler)->klass)->motion_notify_event),
5160 GTK_OBJECT (ruler));
5162 gtk_table_attach (GTK_TABLE (table), ruler, 0, 1, 1, 2,
5163 GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
5164 gtk_widget_show (ruler);
5167 if (!GTK_WIDGET_VISIBLE (window))
5168 gtk_widget_show (window);
5170 gtk_widget_destroy (window);
5174 text_toggle_editable (GtkWidget *checkbutton,
5177 gtk_text_set_editable(GTK_TEXT(text),
5178 GTK_TOGGLE_BUTTON(checkbutton)->active);
5182 text_toggle_word_wrap (GtkWidget *checkbutton,
5185 gtk_text_set_word_wrap(GTK_TEXT(text),
5186 GTK_TOGGLE_BUTTON(checkbutton)->active);
5196 static GtkWidget *window = NULL;
5202 GtkWidget *separator;
5204 GtkWidget *hscrollbar;
5205 GtkWidget *vscrollbar;
5212 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
5213 gtk_widget_set_name (window, "text window");
5214 gtk_widget_set_usize (window, 500, 500);
5215 gtk_window_set_policy (GTK_WINDOW(window), TRUE, TRUE, FALSE);
5217 gtk_signal_connect (GTK_OBJECT (window), "destroy",
5218 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
5221 gtk_window_set_title (GTK_WINDOW (window), "test");
5222 gtk_container_border_width (GTK_CONTAINER (window), 0);
5225 box1 = gtk_vbox_new (FALSE, 0);
5226 gtk_container_add (GTK_CONTAINER (window), box1);
5227 gtk_widget_show (box1);
5230 box2 = gtk_vbox_new (FALSE, 10);
5231 gtk_container_border_width (GTK_CONTAINER (box2), 10);
5232 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
5233 gtk_widget_show (box2);
5236 table = gtk_table_new (2, 2, FALSE);
5237 gtk_table_set_row_spacing (GTK_TABLE (table), 0, 2);
5238 gtk_table_set_col_spacing (GTK_TABLE (table), 0, 2);
5239 gtk_box_pack_start (GTK_BOX (box2), table, TRUE, TRUE, 0);
5240 gtk_widget_show (table);
5242 text = gtk_text_new (NULL, NULL);
5243 gtk_text_set_editable (GTK_TEXT (text), TRUE);
5244 gtk_table_attach (GTK_TABLE (table), text, 0, 1, 0, 1,
5245 GTK_EXPAND | GTK_SHRINK | GTK_FILL,
5246 GTK_EXPAND | GTK_SHRINK | GTK_FILL, 0, 0);
5247 gtk_widget_grab_focus (text);
5248 gtk_widget_show (text);
5250 hscrollbar = gtk_hscrollbar_new (GTK_TEXT (text)->hadj);
5251 gtk_table_attach (GTK_TABLE (table), hscrollbar, 0, 1, 1, 2,
5252 GTK_EXPAND | GTK_FILL | GTK_SHRINK, GTK_FILL, 0, 0);
5253 gtk_widget_show (hscrollbar);
5255 vscrollbar = gtk_vscrollbar_new (GTK_TEXT (text)->vadj);
5256 gtk_table_attach (GTK_TABLE (table), vscrollbar, 1, 2, 0, 1,
5257 GTK_FILL, GTK_EXPAND | GTK_SHRINK | GTK_FILL, 0, 0);
5258 gtk_widget_show (vscrollbar);
5260 gtk_text_freeze (GTK_TEXT (text));
5262 gtk_widget_realize (text);
5264 infile = fopen("testgtk.c", "r");
5273 nchars = fread(buffer, 1, 1024, infile);
5274 gtk_text_insert (GTK_TEXT (text), NULL, NULL,
5275 NULL, buffer, nchars);
5284 gtk_text_insert (GTK_TEXT (text), NULL, &text->style->black, NULL,
5286 gtk_text_insert (GTK_TEXT (text), NULL, &text->style->bg[GTK_STATE_NORMAL], NULL,
5288 gtk_text_insert (GTK_TEXT (text), NULL, &text->style->black, NULL,
5291 gtk_text_thaw (GTK_TEXT (text));
5293 hbox = gtk_hbutton_box_new ();
5294 gtk_box_pack_start (GTK_BOX (box2), hbox, FALSE, FALSE, 0);
5295 gtk_widget_show (hbox);
5297 check = gtk_check_button_new_with_label("Editable");
5298 gtk_box_pack_start (GTK_BOX (hbox), check, FALSE, FALSE, 0);
5299 gtk_signal_connect (GTK_OBJECT(check), "toggled",
5300 GTK_SIGNAL_FUNC(text_toggle_editable), text);
5301 gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(check), TRUE);
5302 gtk_widget_show (check);
5304 check = gtk_check_button_new_with_label("Wrap Words");
5305 gtk_box_pack_start (GTK_BOX (hbox), check, FALSE, TRUE, 0);
5306 gtk_signal_connect (GTK_OBJECT(check), "toggled",
5307 GTK_SIGNAL_FUNC(text_toggle_word_wrap), text);
5308 gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(check), FALSE);
5309 gtk_widget_show (check);
5311 separator = gtk_hseparator_new ();
5312 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
5313 gtk_widget_show (separator);
5316 box2 = gtk_vbox_new (FALSE, 10);
5317 gtk_container_border_width (GTK_CONTAINER (box2), 10);
5318 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
5319 gtk_widget_show (box2);
5322 button = gtk_button_new_with_label ("close");
5323 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
5324 GTK_SIGNAL_FUNC(gtk_widget_destroy),
5325 GTK_OBJECT (window));
5326 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
5327 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
5328 gtk_widget_grab_default (button);
5329 gtk_widget_show (button);
5332 if (!GTK_WIDGET_VISIBLE (window))
5333 gtk_widget_show (window);
5335 gtk_widget_destroy (window);
5342 GdkPixmap *book_open;
5343 GdkPixmap *book_closed;
5344 GdkBitmap *book_open_mask;
5345 GdkBitmap *book_closed_mask;
5348 page_switch (GtkWidget *widget, GtkNotebookPage *page, gint page_num)
5350 GtkNotebookPage *oldpage;
5353 oldpage = GTK_NOTEBOOK (widget)->cur_page;
5355 if (page == oldpage)
5358 pixwid = ((GtkBoxChild*)(GTK_BOX (page->tab_label)->children->data))->widget;
5359 gtk_pixmap_set (GTK_PIXMAP (pixwid), book_open, book_open_mask);
5360 pixwid = ((GtkBoxChild*) (GTK_BOX (page->menu_label)->children->data))->widget;
5361 gtk_pixmap_set (GTK_PIXMAP (pixwid), book_open, book_open_mask);
5365 pixwid = ((GtkBoxChild*) (GTK_BOX
5366 (oldpage->tab_label)->children->data))->widget;
5367 gtk_pixmap_set (GTK_PIXMAP (pixwid), book_closed, book_closed_mask);
5368 pixwid = ((GtkBoxChild*) (GTK_BOX (oldpage->menu_label)->children->data))->widget;
5369 gtk_pixmap_set (GTK_PIXMAP (pixwid), book_closed, book_closed_mask);
5374 create_pages (GtkNotebook *notebook, gint start, gint end)
5376 GtkWidget *child = NULL;
5381 GtkWidget *label_box;
5382 GtkWidget *menu_box;
5388 for (i = start; i <= end; i++)
5390 sprintf (buffer, "Page %d", i);
5395 child = gtk_button_new_with_label (buffer);
5396 gtk_container_border_width (GTK_CONTAINER(child), 10);
5399 child = gtk_label_new (buffer);
5402 child = gtk_frame_new (buffer);
5403 gtk_container_border_width (GTK_CONTAINER (child), 10);
5405 box = gtk_vbox_new (TRUE,0);
5406 gtk_container_border_width (GTK_CONTAINER (box), 10);
5407 gtk_container_add (GTK_CONTAINER (child), box);
5409 label = gtk_label_new (buffer);
5410 gtk_box_pack_start (GTK_BOX(box), label, TRUE, TRUE, 5);
5412 entry = gtk_entry_new ();
5413 gtk_box_pack_start (GTK_BOX(box), entry, TRUE, TRUE, 5);
5415 hbox = gtk_hbox_new (TRUE,0);
5416 gtk_box_pack_start (GTK_BOX(box), hbox, TRUE, TRUE, 5);
5418 button = gtk_button_new_with_label ("Ok");
5419 gtk_box_pack_start (GTK_BOX(hbox), button, TRUE, TRUE, 5);
5421 button = gtk_button_new_with_label ("Cancel");
5422 gtk_box_pack_start (GTK_BOX(hbox), button, TRUE, TRUE, 5);
5425 child = gtk_frame_new (buffer);
5426 gtk_container_border_width (GTK_CONTAINER (child), 10);
5428 label = gtk_label_new (buffer);
5429 gtk_container_add (GTK_CONTAINER (child), label);
5433 gtk_widget_show_all (child);
5435 label_box = gtk_hbox_new (FALSE, 0);
5436 pixwid = gtk_pixmap_new (book_closed, book_closed_mask);
5437 gtk_box_pack_start (GTK_BOX (label_box), pixwid, FALSE, TRUE, 0);
5438 gtk_misc_set_padding (GTK_MISC (pixwid), 3, 1);
5439 label = gtk_label_new (buffer);
5440 gtk_box_pack_start (GTK_BOX (label_box), label, FALSE, TRUE, 0);
5441 gtk_widget_show_all (label_box);
5443 menu_box = gtk_hbox_new (FALSE, 0);
5444 pixwid = gtk_pixmap_new (book_closed, book_closed_mask);
5445 gtk_box_pack_start (GTK_BOX (menu_box), pixwid, FALSE, TRUE, 0);
5446 gtk_misc_set_padding (GTK_MISC (pixwid), 3, 1);
5447 label = gtk_label_new (buffer);
5448 gtk_box_pack_start (GTK_BOX (menu_box), label, FALSE, TRUE, 0);
5449 gtk_widget_show_all (menu_box);
5451 gtk_notebook_append_page_menu (notebook, child, label_box, menu_box);
5456 rotate_notebook (GtkButton *button,
5457 GtkNotebook *notebook)
5459 gtk_notebook_set_tab_pos (notebook, (notebook->tab_pos + 1) % 4);
5463 standard_notebook (GtkButton *button,
5464 GtkNotebook *notebook)
5468 gtk_notebook_set_show_tabs (notebook, TRUE);
5469 gtk_notebook_set_scrollable (notebook, FALSE);
5470 if (g_list_length (notebook->children) == 15)
5471 for (i = 0; i < 10; i++)
5472 gtk_notebook_remove_page (notebook, 5);
5476 notabs_notebook (GtkButton *button,
5477 GtkNotebook *notebook)
5481 gtk_notebook_set_show_tabs (notebook, FALSE);
5482 if (g_list_length (notebook->children) == 15)
5483 for (i = 0; i < 10; i++)
5484 gtk_notebook_remove_page (notebook, 5);
5488 scrollable_notebook (GtkButton *button,
5489 GtkNotebook *notebook)
5491 gtk_notebook_set_show_tabs (notebook, TRUE);
5492 gtk_notebook_set_scrollable (notebook, TRUE);
5493 if (g_list_length (notebook->children) == 5)
5494 create_pages (notebook, 6, 15);
5498 notebook_popup (GtkToggleButton *button,
5499 GtkNotebook *notebook)
5502 gtk_notebook_popup_enable (notebook);
5504 gtk_notebook_popup_disable (notebook);
5508 create_notebook (void)
5510 static GtkWidget *window = NULL;
5514 GtkWidget *separator;
5515 GtkWidget *notebook;
5517 GdkColor *transparent = NULL;
5519 static OptionMenuItem items[] =
5521 { "Standard", standard_notebook },
5522 { "No tabs", notabs_notebook },
5523 { "Scrollable", scrollable_notebook }
5528 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
5530 gtk_signal_connect (GTK_OBJECT (window), "destroy",
5531 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
5534 gtk_window_set_title (GTK_WINDOW (window), "notebook");
5535 gtk_container_border_width (GTK_CONTAINER (window), 0);
5537 box1 = gtk_vbox_new (FALSE, 0);
5538 gtk_container_add (GTK_CONTAINER (window), box1);
5540 notebook = gtk_notebook_new ();
5541 gtk_signal_connect (GTK_OBJECT (notebook), "switch_page",
5542 GTK_SIGNAL_FUNC (page_switch), NULL);
5543 gtk_notebook_set_tab_pos (GTK_NOTEBOOK (notebook), GTK_POS_TOP);
5544 gtk_box_pack_start (GTK_BOX (box1), notebook, TRUE, TRUE, 0);
5545 gtk_container_border_width (GTK_CONTAINER (notebook), 10);
5547 gtk_widget_realize (notebook);
5548 book_open = gdk_pixmap_create_from_xpm_d (notebook->window,
5552 book_closed = gdk_pixmap_create_from_xpm_d (notebook->window,
5557 create_pages (GTK_NOTEBOOK (notebook), 1, 5);
5559 separator = gtk_hseparator_new ();
5560 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 10);
5562 box2 = gtk_hbox_new (TRUE, 5);
5563 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
5565 omenu = build_option_menu (items, 3, 0, notebook);
5566 gtk_box_pack_start (GTK_BOX (box2), omenu, FALSE, FALSE, 0);
5568 button = gtk_check_button_new_with_label ("enable popup menu");
5569 gtk_box_pack_start (GTK_BOX (box2), button, FALSE, FALSE, 0);
5570 gtk_signal_connect (GTK_OBJECT(button), "clicked",
5571 GTK_SIGNAL_FUNC (notebook_popup),
5572 GTK_OBJECT (notebook));
5574 box2 = gtk_hbox_new (TRUE, 10);
5575 gtk_container_border_width (GTK_CONTAINER (box2), 10);
5576 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
5578 button = gtk_button_new_with_label ("close");
5579 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
5580 GTK_SIGNAL_FUNC (gtk_widget_destroy),
5581 GTK_OBJECT (window));
5582 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
5583 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
5584 gtk_widget_grab_default (button);
5586 button = gtk_button_new_with_label ("next");
5587 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
5588 GTK_SIGNAL_FUNC (gtk_notebook_next_page),
5589 GTK_OBJECT (notebook));
5590 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
5591 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
5593 button = gtk_button_new_with_label ("prev");
5594 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
5595 GTK_SIGNAL_FUNC (gtk_notebook_prev_page),
5596 GTK_OBJECT (notebook));
5597 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
5598 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
5600 button = gtk_button_new_with_label ("rotate");
5601 gtk_signal_connect (GTK_OBJECT (button), "clicked",
5602 GTK_SIGNAL_FUNC (rotate_notebook),
5604 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
5605 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
5608 if (!GTK_WIDGET_VISIBLE (window))
5609 gtk_widget_show_all (window);
5611 gtk_widget_destroy (window);
5621 static GtkWidget *window = NULL;
5629 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
5631 gtk_signal_connect (GTK_OBJECT (window), "destroy",
5632 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
5635 gtk_window_set_title (GTK_WINDOW (window), "Panes");
5636 gtk_container_border_width (GTK_CONTAINER (window), 0);
5638 vpaned = gtk_vpaned_new ();
5639 gtk_container_add (GTK_CONTAINER (window), vpaned);
5640 gtk_container_border_width (GTK_CONTAINER(vpaned), 5);
5641 gtk_widget_show (vpaned);
5643 hpaned = gtk_hpaned_new ();
5644 gtk_paned_add1 (GTK_PANED (vpaned), hpaned);
5646 frame = gtk_frame_new (NULL);
5647 gtk_frame_set_shadow_type (GTK_FRAME(frame), GTK_SHADOW_IN);
5648 gtk_widget_set_usize (frame, 60, 60);
5649 gtk_paned_add1 (GTK_PANED (hpaned), frame);
5650 gtk_widget_show (frame);
5652 button = gtk_button_new_with_label ("Hi there");
5653 gtk_container_add (GTK_CONTAINER(frame), button);
5654 gtk_widget_show (button);
5656 frame = gtk_frame_new (NULL);
5657 gtk_frame_set_shadow_type (GTK_FRAME(frame), GTK_SHADOW_IN);
5658 gtk_widget_set_usize (frame, 80, 60);
5659 gtk_paned_add2 (GTK_PANED (hpaned), frame);
5660 gtk_widget_show (frame);
5662 gtk_widget_show (hpaned);
5664 frame = gtk_frame_new (NULL);
5665 gtk_frame_set_shadow_type (GTK_FRAME(frame), GTK_SHADOW_IN);
5666 gtk_widget_set_usize (frame, 60, 80);
5667 gtk_paned_add2 (GTK_PANED (vpaned), frame);
5668 gtk_widget_show (frame);
5671 if (!GTK_WIDGET_VISIBLE (window))
5672 gtk_widget_show (window);
5674 gtk_widget_destroy (window);
5682 dnd_drop_destroy_popup (GtkWidget *widget, GtkWindow **window)
5684 if(GTK_IS_BUTTON(widget)) /* I.e. they clicked the close button */
5685 gtk_widget_destroy(GTK_WIDGET(*window));
5687 gtk_grab_remove(GTK_WIDGET(*window));
5695 dnd_drop (GtkWidget *button, GdkEvent *event)
5697 static GtkWidget *window = NULL;
5698 GtkWidget *vbox, *lbl, *btn;
5701 /* DND doesn't obey gtk_grab's, so check if we're already displaying
5702 * drop modal dialog first
5707 window = gtk_window_new(GTK_WINDOW_DIALOG);
5708 gtk_container_border_width (GTK_CONTAINER(window), 10);
5710 gtk_signal_connect (GTK_OBJECT (window), "destroy",
5711 GTK_SIGNAL_FUNC(dnd_drop_destroy_popup),
5713 gtk_signal_connect (GTK_OBJECT (window), "delete-event",
5714 GTK_SIGNAL_FUNC(gtk_false),
5717 vbox = gtk_vbox_new(FALSE, 5);
5719 /* Display message that we got from drop source */
5720 msg = g_malloc(strlen(event->dropdataavailable.data)
5721 + strlen(event->dropdataavailable.data_type) + 100);
5722 sprintf(msg, "Drop data of type %s was:\n\n%s",
5723 event->dropdataavailable.data_type,
5724 (char *)event->dropdataavailable.data);
5725 lbl = gtk_label_new(msg);
5726 gtk_label_set_justify(GTK_LABEL(lbl), GTK_JUSTIFY_FILL);
5728 gtk_widget_show(lbl);
5729 gtk_box_pack_start_defaults(GTK_BOX(vbox), lbl);
5731 /* Provide an obvious way out of this heinousness */
5732 btn = gtk_button_new_with_label("Continue with life in\nspite of this oppression");
5733 gtk_signal_connect_object (GTK_OBJECT (btn), "clicked",
5734 GTK_SIGNAL_FUNC(gtk_widget_destroy),
5735 GTK_OBJECT (window));
5736 gtk_widget_show(btn);
5737 gtk_box_pack_start_defaults(GTK_BOX(vbox), btn);
5739 gtk_container_add(GTK_CONTAINER(window), vbox);
5741 gtk_widget_show(vbox);
5742 gtk_grab_add(window);
5743 gtk_widget_show(window);
5747 dnd_drag_request (GtkWidget *button, GdkEvent *event)
5749 #define DND_STRING "Bill Gates demands royalties for\nyour use of his innovation."
5750 gtk_widget_dnd_data_set (button, event, DND_STRING, strlen(DND_STRING) + 1);
5756 static GtkWidget *window = NULL;
5762 GtkWidget *separator;
5764 /* For clarity... */
5765 char *possible_drag_types[] = {"text/plain"};
5766 char *accepted_drop_types[] = {"text/plain"};
5768 static GtkWidget *drag_icon = NULL;
5769 static GtkWidget *drop_icon = NULL;
5773 GdkPoint hotspot = {5,5};
5777 drag_icon = shape_create_icon ("Modeller.xpm",
5778 440, 140, 0,0, GTK_WINDOW_POPUP);
5780 gtk_signal_connect (GTK_OBJECT (drag_icon), "destroy",
5781 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
5784 gtk_widget_hide (drag_icon);
5789 drop_icon = shape_create_icon ("3DRings.xpm",
5790 440, 140, 0,0, GTK_WINDOW_POPUP);
5792 gtk_signal_connect (GTK_OBJECT (drop_icon), "destroy",
5793 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
5796 gtk_widget_hide (drop_icon);
5799 gdk_dnd_set_drag_shape(drag_icon->window,
5804 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
5806 gtk_signal_connect (GTK_OBJECT (window), "destroy",
5807 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
5810 gtk_window_set_title (GTK_WINDOW (window), "Drag -N- Drop");
5811 gtk_container_border_width (GTK_CONTAINER (window), 0);
5813 box1 = gtk_vbox_new (FALSE, 0);
5814 gtk_container_add (GTK_CONTAINER (window), box1);
5815 gtk_widget_show (box1);
5817 box2 = gtk_hbox_new (FALSE, 5);
5818 gtk_container_border_width (GTK_CONTAINER (box2), 10);
5819 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
5820 gtk_widget_show (box2);
5822 frame = gtk_frame_new ("Drag");
5823 gtk_box_pack_start (GTK_BOX (box2), frame, TRUE, TRUE, 0);
5824 gtk_widget_show (frame);
5826 box3 = gtk_vbox_new (FALSE, 5);
5827 gtk_container_border_width (GTK_CONTAINER (box3), 5);
5828 gtk_container_add (GTK_CONTAINER (frame), box3);
5829 gtk_widget_show (box3);
5834 button = gtk_button_new_with_label ("Drag me!");
5835 gtk_box_pack_start (GTK_BOX (box3), button, FALSE, TRUE, 0);
5836 gtk_widget_show (button);
5839 * currently, the widget has to be realized to
5840 * set dnd on it, this needs to change
5842 gtk_widget_realize (button);
5843 gtk_signal_connect (GTK_OBJECT (button),
5844 "drag_request_event",
5845 GTK_SIGNAL_FUNC(dnd_drag_request),
5848 gtk_widget_dnd_drag_set (button, TRUE, possible_drag_types, 1);
5851 frame = gtk_frame_new ("Drop");
5852 gtk_box_pack_start (GTK_BOX (box2), frame, TRUE, TRUE, 0);
5853 gtk_widget_show (frame);
5855 box3 = gtk_vbox_new (FALSE, 5);
5856 gtk_container_border_width (GTK_CONTAINER (box3), 5);
5857 gtk_container_add (GTK_CONTAINER (frame), box3);
5858 gtk_widget_show (box3);
5864 button = gtk_button_new_with_label ("To");
5865 gtk_box_pack_start (GTK_BOX (box3), button, FALSE, TRUE, 0);
5866 gtk_widget_show (button);
5868 gtk_widget_realize (button);
5869 gtk_signal_connect (GTK_OBJECT (button),
5870 "drop_data_available_event",
5871 GTK_SIGNAL_FUNC(dnd_drop),
5874 gtk_widget_dnd_drop_set (button, TRUE, accepted_drop_types, 1, FALSE);
5877 separator = gtk_hseparator_new ();
5878 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
5879 gtk_widget_show (separator);
5882 box2 = gtk_vbox_new (FALSE, 10);
5883 gtk_container_border_width (GTK_CONTAINER (box2), 10);
5884 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
5885 gtk_widget_show (box2);
5888 button = gtk_button_new_with_label ("close");
5890 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
5891 GTK_SIGNAL_FUNC(gtk_widget_destroy),
5892 GTK_OBJECT (window));
5894 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
5895 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
5896 gtk_widget_grab_default (button);
5897 gtk_widget_show (button);
5900 if (!GTK_WIDGET_VISIBLE (window))
5901 gtk_widget_show (window);
5903 gtk_widget_destroy (window);
5910 static GdkWindow *root_win = NULL;
5912 typedef struct _cursoroffset {gint x,y;} CursorOffset;
5915 shape_pressed (GtkWidget *widget, GdkEventButton *event)
5919 /* ignore double and triple click */
5920 if (event->type != GDK_BUTTON_PRESS)
5923 p = gtk_object_get_user_data (GTK_OBJECT(widget));
5924 p->x = (int) event->x;
5925 p->y = (int) event->y;
5927 gtk_grab_add (widget);
5928 gdk_pointer_grab (widget->window, TRUE,
5929 GDK_BUTTON_RELEASE_MASK |
5930 GDK_BUTTON_MOTION_MASK |
5931 GDK_POINTER_MOTION_HINT_MASK,
5936 shape_released (GtkWidget *widget)
5938 gtk_grab_remove (widget);
5939 gdk_pointer_ungrab (0);
5943 shape_motion (GtkWidget *widget,
5944 GdkEventMotion *event)
5948 GdkModifierType mask;
5950 p = gtk_object_get_user_data (GTK_OBJECT (widget));
5953 * Can't use event->x / event->y here
5954 * because I need absolute coordinates.
5956 gdk_window_get_pointer (root_win, &xp, &yp, &mask);
5957 gtk_widget_set_uposition (widget, xp - p->x, yp - p->y);
5961 shape_create_icon (char *xpm_file,
5971 CursorOffset* icon_pos;
5973 GdkBitmap *gdk_pixmap_mask;
5974 GdkPixmap *gdk_pixmap;
5977 style = gtk_widget_get_default_style ();
5978 gc = style->black_gc;
5981 * GDK_WINDOW_TOPLEVEL works also, giving you a title border
5983 window = gtk_window_new (window_type);
5985 fixed = gtk_fixed_new ();
5986 gtk_widget_set_usize (fixed, 100,100);
5987 gtk_container_add (GTK_CONTAINER (window), fixed);
5988 gtk_widget_show (fixed);
5990 gtk_widget_set_events (window,
5991 gtk_widget_get_events (window) |
5992 GDK_BUTTON_MOTION_MASK |
5993 GDK_POINTER_MOTION_HINT_MASK |
5994 GDK_BUTTON_PRESS_MASK);
5996 gtk_widget_realize (window);
5997 gdk_pixmap = gdk_pixmap_create_from_xpm (window->window, &gdk_pixmap_mask,
5998 &style->bg[GTK_STATE_NORMAL],
6001 pixmap = gtk_pixmap_new (gdk_pixmap, gdk_pixmap_mask);
6002 gtk_fixed_put (GTK_FIXED (fixed), pixmap, px,py);
6003 gtk_widget_show (pixmap);
6005 gtk_widget_shape_combine_mask (window, gdk_pixmap_mask, px,py);
6008 gtk_signal_connect (GTK_OBJECT (window), "button_press_event",
6009 GTK_SIGNAL_FUNC (shape_pressed),NULL);
6010 gtk_signal_connect (GTK_OBJECT (window), "button_release_event",
6011 GTK_SIGNAL_FUNC (shape_released),NULL);
6012 gtk_signal_connect (GTK_OBJECT (window), "motion_notify_event",
6013 GTK_SIGNAL_FUNC (shape_motion),NULL);
6015 icon_pos = g_new (CursorOffset, 1);
6016 gtk_object_set_user_data(GTK_OBJECT(window), icon_pos);
6018 gtk_widget_set_uposition (window, x, y);
6019 gtk_widget_show (window);
6025 create_shapes (void)
6027 /* Variables used by the Drag/Drop and Shape Window demos */
6028 static GtkWidget *modeller = NULL;
6029 static GtkWidget *sheets = NULL;
6030 static GtkWidget *rings = NULL;
6032 root_win = gdk_window_foreign_new (GDK_ROOT_WINDOW ());
6036 modeller = shape_create_icon ("Modeller.xpm",
6037 440, 140, 0,0, GTK_WINDOW_POPUP);
6039 gtk_signal_connect (GTK_OBJECT (modeller), "destroy",
6040 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
6044 gtk_widget_destroy (modeller);
6048 sheets = shape_create_icon ("FilesQueue.xpm",
6049 580, 170, 0,0, GTK_WINDOW_POPUP);
6051 gtk_signal_connect (GTK_OBJECT (sheets), "destroy",
6052 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
6057 gtk_widget_destroy (sheets);
6061 rings = shape_create_icon ("3DRings.xpm",
6062 460, 270, 25,25, GTK_WINDOW_TOPLEVEL);
6064 gtk_signal_connect (GTK_OBJECT (rings), "destroy",
6065 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
6069 gtk_widget_destroy (rings);
6077 create_wmhints (void)
6079 static GtkWidget *window = NULL;
6081 GtkWidget *separator;
6090 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
6092 gtk_signal_connect (GTK_OBJECT (window), "destroy",
6093 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
6096 gtk_window_set_title (GTK_WINDOW (window), "WM Hints");
6097 gtk_container_border_width (GTK_CONTAINER (window), 0);
6099 gtk_widget_realize (window);
6101 circles = gdk_bitmap_create_from_data (window->window,
6105 gdk_window_set_icon (window->window, NULL,
6108 gdk_window_set_icon_name (window->window, "WMHints Test Icon");
6110 gdk_window_set_decorations (window->window, GDK_DECOR_ALL | GDK_DECOR_MENU);
6111 gdk_window_set_functions (window->window, GDK_FUNC_ALL | GDK_FUNC_RESIZE);
6113 box1 = gtk_vbox_new (FALSE, 0);
6114 gtk_container_add (GTK_CONTAINER (window), box1);
6115 gtk_widget_show (box1);
6117 label = gtk_label_new ("Try iconizing me!");
6118 gtk_widget_set_usize (label, 150, 50);
6119 gtk_box_pack_start (GTK_BOX (box1), label, TRUE, TRUE, 0);
6120 gtk_widget_show (label);
6123 separator = gtk_hseparator_new ();
6124 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
6125 gtk_widget_show (separator);
6128 box2 = gtk_vbox_new (FALSE, 10);
6129 gtk_container_border_width (GTK_CONTAINER (box2), 10);
6130 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
6131 gtk_widget_show (box2);
6134 button = gtk_button_new_with_label ("close");
6136 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
6137 GTK_SIGNAL_FUNC(gtk_widget_destroy),
6138 GTK_OBJECT (window));
6140 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
6141 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
6142 gtk_widget_grab_default (button);
6143 gtk_widget_show (button);
6146 if (!GTK_WIDGET_VISIBLE (window))
6147 gtk_widget_show (window);
6149 gtk_widget_destroy (window);
6156 typedef struct _ProgressData {
6159 GtkWidget *block_spin;
6160 GtkWidget *x_align_spin;
6161 GtkWidget *y_align_spin;
6162 GtkWidget *step_spin;
6163 GtkWidget *act_blocks_spin;
6172 progress_timeout (gpointer data)
6177 adj = GTK_PROGRESS (data)->adjustment;
6179 new_val = adj->value + 1;
6180 if (new_val > adj->upper)
6181 new_val = adj->lower;
6183 gtk_progress_set_value (GTK_PROGRESS (data), new_val);
6189 destroy_progress (GtkWidget *widget,
6190 ProgressData **pdata)
6192 gtk_timeout_remove ((*pdata)->timer);
6193 (*pdata)->timer = 0;
6194 (*pdata)->window = NULL;
6200 progressbar_toggle_orientation (GtkWidget *widget, ProgressData *pdata)
6204 if (!GTK_WIDGET_MAPPED (widget))
6207 RADIOMENUTOGGLED ((GtkRadioMenuItem *)
6208 (((GtkOptionMenu *)(pdata->omenu1))->menu_item), i);
6210 gtk_progress_bar_set_orientation (GTK_PROGRESS_BAR (pdata->pbar),
6211 (GtkProgressBarOrientation) (3-i));
6215 toggle_show_text (GtkWidget *widget, ProgressData *pdata)
6217 gtk_progress_set_show_text (GTK_PROGRESS (pdata->pbar),
6218 GTK_TOGGLE_BUTTON (widget)->active);
6219 gtk_widget_set_sensitive (pdata->entry, GTK_TOGGLE_BUTTON (widget)->active);
6220 gtk_widget_set_sensitive (pdata->x_align_spin,
6221 GTK_TOGGLE_BUTTON (widget)->active);
6222 gtk_widget_set_sensitive (pdata->y_align_spin,
6223 GTK_TOGGLE_BUTTON (widget)->active);
6227 progressbar_toggle_bar_style (GtkWidget *widget, ProgressData *pdata)
6231 if (!GTK_WIDGET_MAPPED (widget))
6234 RADIOMENUTOGGLED ((GtkRadioMenuItem *)
6235 (((GtkOptionMenu *)(pdata->omenu2))->menu_item), i);
6240 gtk_widget_set_sensitive (pdata->block_spin, TRUE);
6242 gtk_widget_set_sensitive (pdata->block_spin, FALSE);
6244 gtk_progress_bar_set_bar_style (GTK_PROGRESS_BAR (pdata->pbar),
6245 (GtkProgressBarStyle) i);
6249 progress_value_changed (GtkAdjustment *adj, ProgressData *pdata)
6253 if (GTK_PROGRESS (pdata->pbar)->activity_mode)
6254 sprintf (buf, "???");
6256 sprintf (buf, "%.0f%%", 100 *
6257 gtk_progress_get_current_percentage (GTK_PROGRESS (pdata->pbar)));
6258 gtk_label_set (GTK_LABEL (pdata->label), buf);
6262 adjust_blocks (GtkAdjustment *adj, ProgressData *pdata)
6264 gtk_progress_set_percentage (GTK_PROGRESS (pdata->pbar), 0);
6265 gtk_progress_bar_set_discrete_blocks (GTK_PROGRESS_BAR (pdata->pbar),
6266 gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (pdata->block_spin)));
6270 adjust_step (GtkAdjustment *adj, ProgressData *pdata)
6272 gtk_progress_bar_set_activity_step (GTK_PROGRESS_BAR (pdata->pbar),
6273 gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (pdata->step_spin)));
6277 adjust_act_blocks (GtkAdjustment *adj, ProgressData *pdata)
6279 gtk_progress_bar_set_activity_blocks (GTK_PROGRESS_BAR (pdata->pbar),
6280 gtk_spin_button_get_value_as_int
6281 (GTK_SPIN_BUTTON (pdata->act_blocks_spin)));
6285 adjust_align (GtkAdjustment *adj, ProgressData *pdata)
6287 gtk_progress_set_text_alignment (GTK_PROGRESS (pdata->pbar),
6288 gtk_spin_button_get_value_as_float
6289 (GTK_SPIN_BUTTON (pdata->x_align_spin)),
6290 gtk_spin_button_get_value_as_float
6291 (GTK_SPIN_BUTTON (pdata->y_align_spin)));
6295 toggle_activity_mode (GtkWidget *widget, ProgressData *pdata)
6297 gtk_progress_set_activity_mode (GTK_PROGRESS (pdata->pbar),
6298 GTK_TOGGLE_BUTTON (widget)->active);
6299 gtk_widget_set_sensitive (pdata->step_spin,
6300 GTK_TOGGLE_BUTTON (widget)->active);
6301 gtk_widget_set_sensitive (pdata->act_blocks_spin,
6302 GTK_TOGGLE_BUTTON (widget)->active);
6306 entry_changed (GtkWidget *widget, ProgressData *pdata)
6308 gtk_progress_set_format_string (GTK_PROGRESS (pdata->pbar),
6309 gtk_entry_get_text (GTK_ENTRY (pdata->entry)));
6313 create_progress_bar (void)
6325 static ProgressData *pdata = NULL;
6327 static OptionMenuItem items1[] =
6329 { "Left-Right", progressbar_toggle_orientation },
6330 { "Right-Left", progressbar_toggle_orientation },
6331 { "Bottom-Top", progressbar_toggle_orientation },
6332 { "Top-Bottom", progressbar_toggle_orientation }
6335 static OptionMenuItem items2[] =
6337 { "Continuous", progressbar_toggle_bar_style },
6338 { "Discrete", progressbar_toggle_bar_style }
6342 pdata = g_new0 (ProgressData, 1);
6346 pdata->window = gtk_dialog_new ();
6348 gtk_window_set_policy (GTK_WINDOW (pdata->window), FALSE, FALSE, TRUE);
6350 gtk_signal_connect (GTK_OBJECT (pdata->window), "destroy",
6351 GTK_SIGNAL_FUNC (destroy_progress),
6356 gtk_window_set_title (GTK_WINDOW (pdata->window), "GtkProgressBar");
6357 gtk_container_border_width (GTK_CONTAINER (pdata->window), 0);
6359 vbox = gtk_vbox_new (FALSE, 5);
6360 gtk_container_border_width (GTK_CONTAINER (vbox), 10);
6361 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (pdata->window)->vbox),
6362 vbox, FALSE, TRUE, 0);
6364 frame = gtk_frame_new ("Progress");
6365 gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, TRUE, 0);
6367 vbox2 = gtk_vbox_new (FALSE, 5);
6368 gtk_container_add (GTK_CONTAINER (frame), vbox2);
6370 align = gtk_alignment_new (0.5, 0.5, 0, 0);
6371 gtk_box_pack_start (GTK_BOX (vbox2), align, FALSE, FALSE, 5);
6373 adj = (GtkAdjustment *) gtk_adjustment_new (0, 1, 300, 0, 0, 0);
6374 gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
6375 GTK_SIGNAL_FUNC (progress_value_changed), pdata);
6377 pdata->pbar = gtk_progress_bar_new_with_adjustment (adj);
6378 gtk_progress_set_format_string (GTK_PROGRESS (pdata->pbar),
6379 "%v from [%l,%u] (=%p%%)");
6380 gtk_container_add (GTK_CONTAINER (align), pdata->pbar);
6381 pdata->timer = gtk_timeout_add (100, progress_timeout, pdata->pbar);
6383 align = gtk_alignment_new (0.5, 0.5, 0, 0);
6384 gtk_box_pack_start (GTK_BOX (vbox2), align, FALSE, FALSE, 5);
6386 hbox = gtk_hbox_new (FALSE, 5);
6387 gtk_container_add (GTK_CONTAINER (align), hbox);
6388 label = gtk_label_new ("Label updated by user :");
6389 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
6390 pdata->label = gtk_label_new ("");
6391 gtk_box_pack_start (GTK_BOX (hbox), pdata->label, FALSE, TRUE, 0);
6393 frame = gtk_frame_new ("Options");
6394 gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, TRUE, 0);
6396 vbox2 = gtk_vbox_new (FALSE, 5);
6397 gtk_container_add (GTK_CONTAINER (frame), vbox2);
6399 tab = gtk_table_new (7, 2, FALSE);
6400 gtk_box_pack_start (GTK_BOX (vbox2), tab, FALSE, TRUE, 0);
6402 label = gtk_label_new ("Orientation :");
6403 gtk_table_attach (GTK_TABLE (tab), label, 0, 1, 0, 1,
6404 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
6406 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
6408 pdata->omenu1 = build_option_menu (items1, 4, 0, pdata);
6409 hbox = gtk_hbox_new (FALSE, 0);
6410 gtk_table_attach (GTK_TABLE (tab), hbox, 1, 2, 0, 1,
6411 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
6413 gtk_box_pack_start (GTK_BOX (hbox), pdata->omenu1, TRUE, TRUE, 0);
6415 check = gtk_check_button_new_with_label ("Show text");
6416 gtk_signal_connect (GTK_OBJECT (check), "clicked",
6417 GTK_SIGNAL_FUNC (toggle_show_text),
6419 gtk_table_attach (GTK_TABLE (tab), check, 0, 1, 1, 2,
6420 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
6423 hbox = gtk_hbox_new (FALSE, 0);
6424 gtk_table_attach (GTK_TABLE (tab), hbox, 1, 2, 1, 2,
6425 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
6428 label = gtk_label_new ("Format : ");
6429 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
6431 pdata->entry = gtk_entry_new ();
6432 gtk_signal_connect (GTK_OBJECT (pdata->entry), "changed",
6433 GTK_SIGNAL_FUNC (entry_changed),
6435 gtk_box_pack_start (GTK_BOX (hbox), pdata->entry, TRUE, TRUE, 0);
6436 gtk_entry_set_text (GTK_ENTRY (pdata->entry), "%v from [%l,%u] (=%p%%)");
6437 gtk_widget_set_usize (pdata->entry, 100, -1);
6438 gtk_widget_set_sensitive (pdata->entry, FALSE);
6440 label = gtk_label_new ("Text align :");
6441 gtk_table_attach (GTK_TABLE (tab), label, 0, 1, 2, 3,
6442 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
6444 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
6446 hbox = gtk_hbox_new (FALSE, 0);
6447 gtk_table_attach (GTK_TABLE (tab), hbox, 1, 2, 2, 3,
6448 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
6451 label = gtk_label_new ("x :");
6452 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 5);
6454 adj = (GtkAdjustment *) gtk_adjustment_new (0.5, 0, 1, 0.1, 0.1, 0);
6455 pdata->x_align_spin = gtk_spin_button_new (adj, 0, 1);
6456 gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
6457 GTK_SIGNAL_FUNC (adjust_align), pdata);
6458 gtk_box_pack_start (GTK_BOX (hbox), pdata->x_align_spin, FALSE, TRUE, 0);
6459 gtk_widget_set_sensitive (pdata->x_align_spin, FALSE);
6461 label = gtk_label_new ("y :");
6462 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 5);
6464 adj = (GtkAdjustment *) gtk_adjustment_new (0.5, 0, 1, 0.1, 0.1, 0);
6465 pdata->y_align_spin = gtk_spin_button_new (adj, 0, 1);
6466 gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
6467 GTK_SIGNAL_FUNC (adjust_align), pdata);
6468 gtk_box_pack_start (GTK_BOX (hbox), pdata->y_align_spin, FALSE, TRUE, 0);
6469 gtk_widget_set_sensitive (pdata->y_align_spin, FALSE);
6471 label = gtk_label_new ("Bar Style :");
6472 gtk_table_attach (GTK_TABLE (tab), label, 0, 1, 3, 4,
6473 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
6475 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
6477 pdata->omenu2 = build_option_menu (items2, 2, 0, pdata);
6478 hbox = gtk_hbox_new (FALSE, 0);
6479 gtk_table_attach (GTK_TABLE (tab), hbox, 1, 2, 3, 4,
6480 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
6482 gtk_box_pack_start (GTK_BOX (hbox), pdata->omenu2, TRUE, TRUE, 0);
6484 label = gtk_label_new ("Block count :");
6485 gtk_table_attach (GTK_TABLE (tab), label, 0, 1, 4, 5,
6486 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
6488 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
6490 hbox = gtk_hbox_new (FALSE, 0);
6491 gtk_table_attach (GTK_TABLE (tab), hbox, 1, 2, 4, 5,
6492 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
6494 adj = (GtkAdjustment *) gtk_adjustment_new (10, 2, 20, 1, 5, 0);
6495 pdata->block_spin = gtk_spin_button_new (adj, 0, 0);
6496 gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
6497 GTK_SIGNAL_FUNC (adjust_blocks), pdata);
6498 gtk_box_pack_start (GTK_BOX (hbox), pdata->block_spin, FALSE, TRUE, 0);
6499 gtk_widget_set_sensitive (pdata->block_spin, FALSE);
6501 check = gtk_check_button_new_with_label ("Activity mode");
6502 gtk_signal_connect (GTK_OBJECT (check), "clicked",
6503 GTK_SIGNAL_FUNC (toggle_activity_mode),
6505 gtk_table_attach (GTK_TABLE (tab), check, 0, 1, 5, 6,
6506 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
6509 hbox = gtk_hbox_new (FALSE, 0);
6510 gtk_table_attach (GTK_TABLE (tab), hbox, 1, 2, 5, 6,
6511 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
6513 label = gtk_label_new ("Step size : ");
6514 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
6515 adj = (GtkAdjustment *) gtk_adjustment_new (3, 1, 20, 1, 5, 0);
6516 pdata->step_spin = gtk_spin_button_new (adj, 0, 0);
6517 gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
6518 GTK_SIGNAL_FUNC (adjust_step), pdata);
6519 gtk_box_pack_start (GTK_BOX (hbox), pdata->step_spin, FALSE, TRUE, 0);
6520 gtk_widget_set_sensitive (pdata->step_spin, FALSE);
6522 hbox = gtk_hbox_new (FALSE, 0);
6523 gtk_table_attach (GTK_TABLE (tab), hbox, 1, 2, 6, 7,
6524 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
6526 label = gtk_label_new ("Blocks : ");
6527 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
6528 adj = (GtkAdjustment *) gtk_adjustment_new (5, 2, 10, 1, 5, 0);
6529 pdata->act_blocks_spin = gtk_spin_button_new (adj, 0, 0);
6530 gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
6531 GTK_SIGNAL_FUNC (adjust_act_blocks), pdata);
6532 gtk_box_pack_start (GTK_BOX (hbox), pdata->act_blocks_spin, FALSE, TRUE,
6534 gtk_widget_set_sensitive (pdata->act_blocks_spin, FALSE);
6536 button = gtk_button_new_with_label ("close");
6537 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
6538 GTK_SIGNAL_FUNC (gtk_widget_destroy),
6539 GTK_OBJECT (pdata->window));
6540 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
6541 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (pdata->window)->action_area),
6542 button, TRUE, TRUE, 0);
6543 gtk_widget_grab_default (button);
6546 if (!GTK_WIDGET_VISIBLE (pdata->window))
6547 gtk_widget_show_all (pdata->window);
6549 gtk_widget_destroy (pdata->window);
6556 static int color_idle = 0;
6559 color_idle_func (GtkWidget *preview)
6561 static int count = 1;
6565 for (i = 0; i < 256; i++)
6567 for (j = 0, k = 0; j < 256; j++)
6569 buf[k+0] = i + count;
6571 buf[k+2] = j + count;
6575 gtk_preview_draw_row (GTK_PREVIEW (preview), buf, 0, i, 256);
6580 gtk_widget_draw (preview, NULL);
6586 color_preview_destroy (GtkWidget *widget,
6589 gtk_idle_remove (color_idle);
6596 create_color_preview (void)
6598 static GtkWidget *window = NULL;
6605 gtk_widget_push_visual (gdk_rgb_get_visual ());
6606 gtk_widget_push_colormap (gdk_rgb_get_cmap ());
6607 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
6608 gtk_widget_pop_colormap ();
6609 gtk_widget_pop_visual ();
6611 gtk_signal_connect (GTK_OBJECT (window), "destroy",
6612 GTK_SIGNAL_FUNC(color_preview_destroy),
6615 gtk_window_set_title (GTK_WINDOW (window), "test");
6616 gtk_container_border_width (GTK_CONTAINER (window), 10);
6618 preview = gtk_preview_new (GTK_PREVIEW_COLOR);
6619 gtk_preview_size (GTK_PREVIEW (preview), 256, 256);
6620 gtk_container_add (GTK_CONTAINER (window), preview);
6622 for (i = 0; i < 256; i++)
6624 for (j = 0, k = 0; j < 256; j++)
6632 gtk_preview_draw_row (GTK_PREVIEW (preview), buf, 0, i, 256);
6635 color_idle = gtk_idle_add ((GtkFunction) color_idle_func, preview);
6638 if (!GTK_WIDGET_VISIBLE (window))
6639 gtk_widget_show_all (window);
6641 gtk_widget_destroy (window);
6648 static int gray_idle = 0;
6651 gray_idle_func (GtkWidget *preview)
6653 static int count = 1;
6657 for (i = 0; i < 256; i++)
6659 for (j = 0; j < 256; j++)
6660 buf[j] = i + j + count;
6662 gtk_preview_draw_row (GTK_PREVIEW (preview), buf, 0, i, 256);
6667 gtk_widget_draw (preview, NULL);
6673 gray_preview_destroy (GtkWidget *widget,
6676 gtk_idle_remove (gray_idle);
6683 create_gray_preview (void)
6685 static GtkWidget *window = NULL;
6692 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
6694 gtk_signal_connect (GTK_OBJECT (window), "destroy",
6695 GTK_SIGNAL_FUNC(gray_preview_destroy),
6698 gtk_window_set_title (GTK_WINDOW (window), "test");
6699 gtk_container_border_width (GTK_CONTAINER (window), 10);
6701 preview = gtk_preview_new (GTK_PREVIEW_GRAYSCALE);
6702 gtk_preview_size (GTK_PREVIEW (preview), 256, 256);
6703 gtk_container_add (GTK_CONTAINER (window), preview);
6705 for (i = 0; i < 256; i++)
6707 for (j = 0; j < 256; j++)
6710 gtk_preview_draw_row (GTK_PREVIEW (preview), buf, 0, i, 256);
6713 gray_idle = gtk_idle_add ((GtkFunction) gray_idle_func, preview);
6716 if (!GTK_WIDGET_VISIBLE (window))
6717 gtk_widget_show_all (window);
6719 gtk_widget_destroy (window);
6728 selection_test_received (GtkWidget *list, GtkSelectionData *data)
6731 GtkWidget *list_item;
6735 if (data->length < 0)
6737 g_print ("Selection retrieval failed\n");
6740 if (data->type != GDK_SELECTION_TYPE_ATOM)
6742 g_print ("Selection \"TARGETS\" was not returned as atoms!\n");
6746 /* Clear out any current list items */
6748 gtk_list_clear_items (GTK_LIST(list), 0, -1);
6750 /* Add new items to list */
6752 atoms = (GdkAtom *)data->data;
6755 l = data->length / sizeof (GdkAtom);
6756 for (i = 0; i < l; i++)
6759 name = gdk_atom_name (atoms[i]);
6762 list_item = gtk_list_item_new_with_label (name);
6766 list_item = gtk_list_item_new_with_label ("(bad atom)");
6768 gtk_widget_show (list_item);
6769 item_list = g_list_append (item_list, list_item);
6772 gtk_list_append_items (GTK_LIST (list), item_list);
6778 selection_test_get_targets (GtkWidget *widget, GtkWidget *list)
6780 static GdkAtom targets_atom = GDK_NONE;
6782 if (targets_atom == GDK_NONE)
6783 targets_atom = gdk_atom_intern ("TARGETS", FALSE);
6785 gtk_selection_convert (list, GDK_SELECTION_PRIMARY, targets_atom,
6790 create_selection_test (void)
6792 static GtkWidget *window = NULL;
6795 GtkWidget *scrolled_win;
6801 window = gtk_dialog_new ();
6803 gtk_signal_connect (GTK_OBJECT (window), "destroy",
6804 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
6807 gtk_window_set_title (GTK_WINDOW (window), "Selection Test");
6808 gtk_container_border_width (GTK_CONTAINER (window), 0);
6810 /* Create the list */
6812 vbox = gtk_vbox_new (FALSE, 5);
6813 gtk_container_border_width (GTK_CONTAINER (vbox), 10);
6814 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), vbox,
6817 label = gtk_label_new ("Gets available targets for current selection");
6818 gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
6820 scrolled_win = gtk_scrolled_window_new (NULL, NULL);
6821 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
6822 GTK_POLICY_AUTOMATIC,
6823 GTK_POLICY_AUTOMATIC);
6824 gtk_box_pack_start (GTK_BOX (vbox), scrolled_win, TRUE, TRUE, 0);
6825 gtk_widget_set_usize (scrolled_win, 100, 200);
6827 list = gtk_list_new ();
6828 gtk_container_add (GTK_CONTAINER (scrolled_win), list);
6830 gtk_signal_connect (GTK_OBJECT(list), "selection_received",
6831 GTK_SIGNAL_FUNC (selection_test_received), NULL);
6833 /* .. And create some buttons */
6834 button = gtk_button_new_with_label ("Get Targets");
6835 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
6836 button, TRUE, TRUE, 0);
6838 gtk_signal_connect (GTK_OBJECT (button), "clicked",
6839 GTK_SIGNAL_FUNC (selection_test_get_targets), list);
6841 button = gtk_button_new_with_label ("Quit");
6842 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
6843 button, TRUE, TRUE, 0);
6845 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
6846 GTK_SIGNAL_FUNC (gtk_widget_destroy),
6847 GTK_OBJECT (window));
6850 if (!GTK_WIDGET_VISIBLE (window))
6851 gtk_widget_show_all (window);
6853 gtk_widget_destroy (window);
6861 create_gamma_curve (void)
6863 static GtkWidget *window = NULL, *curve;
6864 static int count = 0;
6871 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
6872 gtk_window_set_title (GTK_WINDOW (window), "test");
6873 gtk_container_border_width (GTK_CONTAINER (window), 10);
6875 gtk_signal_connect (GTK_OBJECT (window), "destroy",
6876 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
6879 curve = gtk_gamma_curve_new ();
6880 gtk_container_add (GTK_CONTAINER (window), curve);
6881 gtk_widget_show (curve);
6884 max = 127 + (count % 2)*128;
6885 gtk_curve_set_range (GTK_CURVE (GTK_GAMMA_CURVE (curve)->curve),
6887 for (i = 0; i < max; ++i)
6888 vec[i] = (127 / sqrt (max)) * sqrt (i);
6889 gtk_curve_set_vector (GTK_CURVE (GTK_GAMMA_CURVE (curve)->curve),
6892 if (!GTK_WIDGET_VISIBLE (window))
6893 gtk_widget_show (window);
6894 else if (count % 4 == 3)
6896 gtk_widget_destroy (window);
6907 static int scroll_test_pos = 0.0;
6908 static GdkGC *scroll_test_gc = NULL;
6911 scroll_test_expose (GtkWidget *widget, GdkEventExpose *event,
6915 gint imin, imax, jmin, jmax;
6917 imin = (event->area.x) / 10;
6918 imax = (event->area.x + event->area.width + 9) / 10;
6920 jmin = ((int)adj->value + event->area.y) / 10;
6921 jmax = ((int)adj->value + event->area.y + event->area.height + 9) / 10;
6923 gdk_window_clear_area (widget->window,
6924 event->area.x, event->area.y,
6925 event->area.width, event->area.height);
6927 for (i=imin; i<imax; i++)
6928 for (j=jmin; j<jmax; j++)
6930 gdk_draw_rectangle (widget->window,
6931 widget->style->black_gc,
6933 10*i, 10*j - (int)adj->value, 1+i%10, 1+j%10);
6939 scroll_test_configure (GtkWidget *widget, GdkEventConfigure *event,
6942 adj->page_increment = 0.9 * widget->allocation.height;
6943 adj->page_size = widget->allocation.height;
6945 gtk_signal_emit_by_name (GTK_OBJECT (adj), "changed");
6949 scroll_test_adjustment_changed (GtkAdjustment *adj, GtkWidget *widget)
6951 gint source_min = (int)adj->value - scroll_test_pos;
6952 gint source_max = source_min + widget->allocation.height;
6954 gint dest_max = widget->allocation.height;
6958 scroll_test_pos = adj->value;
6960 if (!GTK_WIDGET_DRAWABLE (widget))
6967 rect.width = widget->allocation.width;
6968 rect.height = -source_min;
6969 if (rect.height > widget->allocation.height)
6970 rect.height = widget->allocation.height;
6973 dest_min = rect.height;
6978 rect.y = 2*widget->allocation.height - source_max;
6981 rect.width = widget->allocation.width;
6982 rect.height = widget->allocation.height - rect.y;
6984 source_max = widget->allocation.height;
6988 if (source_min != source_max)
6990 if (scroll_test_gc == NULL)
6992 scroll_test_gc = gdk_gc_new (widget->window);
6993 gdk_gc_set_exposures (scroll_test_gc, TRUE);
6996 gdk_draw_pixmap (widget->window,
7001 widget->allocation.width,
7002 source_max - source_min);
7004 /* Make sure graphics expose events are processed before scrolling
7007 while ((event = gdk_event_get_graphics_expose (widget->window)) != NULL)
7009 gtk_widget_event (widget, event);
7010 if (event->expose.count == 0)
7012 gdk_event_free (event);
7015 gdk_event_free (event);
7019 if (rect.height != 0)
7020 gtk_widget_draw (widget, &rect);
7025 create_scroll_test (void)
7027 static GtkWidget *window = NULL;
7029 GtkWidget *drawing_area;
7030 GtkWidget *scrollbar;
7036 window = gtk_dialog_new ();
7038 gtk_signal_connect (GTK_OBJECT (window), "destroy",
7039 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
7042 gtk_window_set_title (GTK_WINDOW (window), "Scroll Test");
7043 gtk_container_border_width (GTK_CONTAINER (window), 0);
7045 hbox = gtk_hbox_new (FALSE, 0);
7046 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), hbox,
7048 gtk_widget_show (hbox);
7050 drawing_area = gtk_drawing_area_new ();
7051 gtk_drawing_area_size (GTK_DRAWING_AREA (drawing_area), 200, 200);
7052 gtk_box_pack_start (GTK_BOX (hbox), drawing_area, TRUE, TRUE, 0);
7053 gtk_widget_show (drawing_area);
7055 gtk_widget_set_events (drawing_area, GDK_EXPOSURE_MASK);
7057 adj = GTK_ADJUSTMENT (gtk_adjustment_new (0.0, 0.0, 1000.0, 1.0, 180.0, 200.0));
7058 scroll_test_pos = 0.0;
7060 scrollbar = gtk_vscrollbar_new (adj);
7061 gtk_box_pack_start (GTK_BOX (hbox), scrollbar, FALSE, FALSE, 0);
7062 gtk_widget_show (scrollbar);
7064 gtk_signal_connect (GTK_OBJECT (drawing_area), "expose_event",
7065 GTK_SIGNAL_FUNC (scroll_test_expose), adj);
7066 gtk_signal_connect (GTK_OBJECT (drawing_area), "configure_event",
7067 GTK_SIGNAL_FUNC (scroll_test_configure), adj);
7070 gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
7071 GTK_SIGNAL_FUNC (scroll_test_adjustment_changed),
7074 /* .. And create some buttons */
7076 button = gtk_button_new_with_label ("Quit");
7077 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
7078 button, TRUE, TRUE, 0);
7080 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
7081 GTK_SIGNAL_FUNC (gtk_widget_destroy),
7082 GTK_OBJECT (window));
7083 gtk_widget_show (button);
7086 if (!GTK_WIDGET_VISIBLE (window))
7087 gtk_widget_show (window);
7089 gtk_widget_destroy (window);
7096 static int timer = 0;
7099 timeout_test (GtkWidget *label)
7101 static int count = 0;
7102 static char buffer[32];
7104 sprintf (buffer, "count: %d", ++count);
7105 gtk_label_set (GTK_LABEL (label), buffer);
7111 start_timeout_test (GtkWidget *widget,
7116 timer = gtk_timeout_add (100, (GtkFunction) timeout_test, label);
7121 stop_timeout_test (GtkWidget *widget,
7126 gtk_timeout_remove (timer);
7132 destroy_timeout_test (GtkWidget *widget,
7135 stop_timeout_test (NULL, NULL);
7141 create_timeout_test (void)
7143 static GtkWidget *window = NULL;
7149 window = gtk_dialog_new ();
7151 gtk_signal_connect (GTK_OBJECT (window), "destroy",
7152 GTK_SIGNAL_FUNC(destroy_timeout_test),
7155 gtk_window_set_title (GTK_WINDOW (window), "Timeout Test");
7156 gtk_container_border_width (GTK_CONTAINER (window), 0);
7158 label = gtk_label_new ("count: 0");
7159 gtk_misc_set_padding (GTK_MISC (label), 10, 10);
7160 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox),
7161 label, TRUE, TRUE, 0);
7162 gtk_widget_show (label);
7164 button = gtk_button_new_with_label ("close");
7165 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
7166 GTK_SIGNAL_FUNC(gtk_widget_destroy),
7167 GTK_OBJECT (window));
7168 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
7169 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
7170 button, TRUE, TRUE, 0);
7171 gtk_widget_grab_default (button);
7172 gtk_widget_show (button);
7174 button = gtk_button_new_with_label ("start");
7175 gtk_signal_connect (GTK_OBJECT (button), "clicked",
7176 GTK_SIGNAL_FUNC(start_timeout_test),
7178 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
7179 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
7180 button, TRUE, TRUE, 0);
7181 gtk_widget_show (button);
7183 button = gtk_button_new_with_label ("stop");
7184 gtk_signal_connect (GTK_OBJECT (button), "clicked",
7185 GTK_SIGNAL_FUNC(stop_timeout_test),
7187 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
7188 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
7189 button, TRUE, TRUE, 0);
7190 gtk_widget_show (button);
7193 if (!GTK_WIDGET_VISIBLE (window))
7194 gtk_widget_show (window);
7196 gtk_widget_destroy (window);
7203 static int idle = 0;
7206 idle_test (GtkWidget *label)
7208 static int count = 0;
7209 static char buffer[32];
7211 sprintf (buffer, "count: %d", ++count);
7212 gtk_label_set (GTK_LABEL (label), buffer);
7218 start_idle_test (GtkWidget *widget,
7223 idle = gtk_idle_add ((GtkFunction) idle_test, label);
7228 stop_idle_test (GtkWidget *widget,
7233 gtk_idle_remove (idle);
7239 destroy_idle_test (GtkWidget *widget,
7242 stop_idle_test (NULL, NULL);
7248 toggle_idle_container (GtkObject *button,
7249 GtkContainer *container)
7251 gtk_container_set_resize_mode (container, (guint) gtk_object_get_user_data (button));
7255 create_idle_test (void)
7257 static GtkWidget *window = NULL;
7260 GtkWidget *container;
7267 window = gtk_dialog_new ();
7269 gtk_signal_connect (GTK_OBJECT (window), "destroy",
7270 GTK_SIGNAL_FUNC(destroy_idle_test),
7273 gtk_window_set_title (GTK_WINDOW (window), "Idle Test");
7274 gtk_container_border_width (GTK_CONTAINER (window), 0);
7276 label = gtk_label_new ("count: 0");
7277 gtk_misc_set_padding (GTK_MISC (label), 10, 10);
7278 gtk_widget_show (label);
7281 gtk_widget_new (GTK_TYPE_HBOX,
7282 "GtkWidget::visible", TRUE,
7283 /* "GtkContainer::child", gtk_widget_new (GTK_TYPE_HBOX,
7284 * "GtkWidget::visible", TRUE,
7286 "GtkContainer::child", label,
7289 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox),
7290 container, TRUE, TRUE, 0);
7293 gtk_widget_new (GTK_TYPE_FRAME,
7294 "GtkContainer::border_width", 5,
7295 "GtkFrame::label", "Label Container",
7296 "GtkWidget::visible", TRUE,
7297 "GtkWidget::parent", GTK_DIALOG (window)->vbox,
7300 gtk_widget_new (GTK_TYPE_VBOX,
7301 "GtkWidget::visible", TRUE,
7302 "GtkWidget::parent", frame,
7305 gtk_widget_new (GTK_TYPE_RADIO_BUTTON,
7306 "GtkButton::label", "Resize-Parent",
7307 "GtkObject::user_data", (void*)GTK_RESIZE_PARENT,
7308 "GtkObject::signal::clicked", toggle_idle_container, container,
7309 "GtkWidget::visible", TRUE,
7310 "GtkWidget::parent", box,
7313 gtk_widget_new (GTK_TYPE_RADIO_BUTTON,
7314 "GtkButton::label", "Resize-Queue",
7315 "GtkObject::user_data", (void*)GTK_RESIZE_QUEUE,
7316 "GtkObject::signal::clicked", toggle_idle_container, container,
7317 "GtkRadioButton::group", button,
7318 "GtkWidget::visible", TRUE,
7319 "GtkWidget::parent", box,
7322 gtk_widget_new (GTK_TYPE_RADIO_BUTTON,
7323 "GtkButton::label", "Resize-Immediate",
7324 "GtkObject::user_data", (void*)GTK_RESIZE_IMMEDIATE,
7325 "GtkObject::signal::clicked", toggle_idle_container, container,
7326 "GtkRadioButton::group", button,
7327 "GtkWidget::visible", TRUE,
7328 "GtkWidget::parent", box,
7332 button = gtk_button_new_with_label ("close");
7333 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
7334 GTK_SIGNAL_FUNC(gtk_widget_destroy),
7335 GTK_OBJECT (window));
7336 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
7337 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
7338 button, TRUE, TRUE, 0);
7339 gtk_widget_grab_default (button);
7340 gtk_widget_show (button);
7342 button = gtk_button_new_with_label ("start");
7343 gtk_signal_connect (GTK_OBJECT (button), "clicked",
7344 GTK_SIGNAL_FUNC(start_idle_test),
7346 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
7347 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
7348 button, TRUE, TRUE, 0);
7349 gtk_widget_show (button);
7351 button = gtk_button_new_with_label ("stop");
7352 gtk_signal_connect (GTK_OBJECT (button), "clicked",
7353 GTK_SIGNAL_FUNC(stop_idle_test),
7355 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
7356 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
7357 button, TRUE, TRUE, 0);
7358 gtk_widget_show (button);
7361 if (!GTK_WIDGET_VISIBLE (window))
7362 gtk_widget_show (window);
7364 gtk_widget_destroy (window);
7372 reload_rc_file (void)
7376 if (gtk_rc_reparse_all ())
7378 toplevels = gdk_window_get_toplevels();
7382 gdk_window_get_user_data (toplevels->data, (gpointer *)&widget);
7385 gtk_widget_reset_rc_styles (widget);
7387 toplevels = toplevels->next;
7389 g_list_free (toplevels);
7394 reload_all_rc_files (void)
7396 static GdkAtom atom_rcfiles = GDK_NONE;
7402 atom_rcfiles = gdk_atom_intern("_GTK_READ_RCFILES", FALSE);
7404 for(i = 0; i < 5; i++)
7406 sev.data_format = 32;
7407 sev.message_type = atom_rcfiles;
7408 gdk_event_send_clientmessage_toall ((GdkEvent *) &sev);
7412 create_rc_file (void)
7414 static GtkWidget *window = NULL;
7419 window = gtk_dialog_new ();
7421 gtk_signal_connect (GTK_OBJECT (window), "destroy",
7422 GTK_SIGNAL_FUNC(destroy_idle_test),
7425 gtk_window_set_title (GTK_WINDOW (window), "Reload Rc file");
7426 gtk_container_border_width (GTK_CONTAINER (window), 0);
7428 button = gtk_button_new_with_label ("Reload");
7429 gtk_signal_connect (GTK_OBJECT (button), "clicked",
7430 GTK_SIGNAL_FUNC(reload_rc_file), NULL);
7431 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
7432 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
7433 button, TRUE, TRUE, 0);
7434 gtk_widget_grab_default (button);
7435 gtk_widget_show (button);
7437 button = gtk_button_new_with_label ("Reload All");
7438 gtk_signal_connect (GTK_OBJECT (button), "clicked",
7439 GTK_SIGNAL_FUNC(reload_all_rc_files), NULL);
7440 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
7441 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
7442 button, TRUE, TRUE, 0);
7443 gtk_widget_show (button);
7445 button = gtk_button_new_with_label ("Close");
7446 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
7447 GTK_SIGNAL_FUNC(gtk_widget_destroy),
7448 GTK_OBJECT (window));
7449 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
7450 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
7451 button, TRUE, TRUE, 0);
7452 gtk_widget_show (button);
7456 if (!GTK_WIDGET_VISIBLE (window))
7457 gtk_widget_show (window);
7459 gtk_widget_destroy (window);
7463 * Test of recursive mainloop
7467 mainloop_destroyed (GtkWidget *w, GtkWidget **window)
7474 create_mainloop (void)
7476 static GtkWidget *window = NULL;
7482 window = gtk_dialog_new ();
7484 gtk_window_set_title (GTK_WINDOW (window), "Test Main Loop");
7486 gtk_signal_connect (GTK_OBJECT (window), "destroy",
7487 GTK_SIGNAL_FUNC(mainloop_destroyed),
7490 label = gtk_label_new ("In recursive main loop...");
7491 gtk_misc_set_padding (GTK_MISC(label), 20, 20);
7493 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), label,
7495 gtk_widget_show (label);
7497 button = gtk_button_new_with_label ("Leave");
7498 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area), button,
7501 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
7502 GTK_SIGNAL_FUNC (gtk_widget_destroy),
7503 GTK_OBJECT (window));
7505 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
7506 gtk_widget_grab_default (button);
7508 gtk_widget_show (button);
7511 if (!GTK_WIDGET_VISIBLE (window))
7513 gtk_widget_show (window);
7515 g_print ("create_mainloop: start\n");
7517 g_print ("create_mainloop: done\n");
7520 gtk_widget_destroy (window);
7524 * Main Window and Exit
7528 do_exit (GtkWidget *widget, GtkWidget *window)
7530 gtk_widget_destroy (window);
7535 create_main_window (void)
7542 { "button box", create_button_box },
7543 { "buttons", create_buttons },
7544 { "check buttons", create_check_buttons },
7545 { "clist", create_clist},
7546 { "color selection", create_color_selection },
7547 { "ctree", create_ctree },
7548 { "cursors", create_cursors },
7549 { "dialog", create_dialog },
7550 { "dnd", create_dnd },
7551 { "entry", create_entry },
7552 { "file selection", create_file_selection },
7553 { "font selection", create_font_selection },
7554 { "gamma curve", create_gamma_curve },
7555 { "handle box", create_handle_box },
7556 { "item factory", create_item_factory },
7557 { "list", create_list },
7558 { "menus", create_menus },
7559 { "modal window", create_modal_window },
7560 { "notebook", create_notebook },
7561 { "panes", create_panes },
7562 { "pixmap", create_pixmap },
7563 { "preview color", create_color_preview },
7564 { "preview gray", create_gray_preview },
7565 { "progress bar", create_progress_bar },
7566 { "radio buttons", create_radio_buttons },
7567 { "range controls", create_range_controls },
7568 { "rc file", create_rc_file },
7569 { "reparent", create_reparent },
7570 { "rulers", create_rulers },
7571 { "scrolled windows", create_scrolled_windows },
7572 { "shapes", create_shapes },
7573 { "spinbutton", create_spins },
7574 { "statusbar", create_statusbar },
7575 { "test idle", create_idle_test },
7576 { "test mainloop", create_mainloop },
7577 { "test scrolling", create_scroll_test },
7578 { "test selection", create_selection_test },
7579 { "test timeout", create_timeout_test },
7580 { "text", create_text },
7581 { "toggle buttons", create_toggle_buttons },
7582 { "toolbar", create_toolbar },
7583 { "tooltips", create_tooltips },
7584 { "tree", create_tree_mode_window},
7585 { "WM hints", create_wmhints },
7587 int nbuttons = sizeof (buttons) / sizeof (buttons[0]);
7591 GtkWidget *scrolled_window;
7595 GtkWidget *separator;
7598 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
7599 gtk_window_set_policy (GTK_WINDOW (window), FALSE, FALSE, FALSE);
7600 gtk_widget_set_name (window, "main window");
7601 gtk_widget_set_usize (window, 200, 400);
7602 gtk_widget_set_uposition (window, 20, 20);
7604 gtk_signal_connect (GTK_OBJECT (window), "destroy",
7605 GTK_SIGNAL_FUNC(gtk_main_quit),
7607 gtk_signal_connect (GTK_OBJECT (window), "delete-event",
7608 GTK_SIGNAL_FUNC (gtk_false),
7611 box1 = gtk_vbox_new (FALSE, 0);
7612 gtk_container_add (GTK_CONTAINER (window), box1);
7614 if (gtk_micro_version > 0)
7626 label = gtk_label_new (buffer);
7627 gtk_box_pack_start (GTK_BOX (box1), label, FALSE, FALSE, 0);
7629 scrolled_window = gtk_scrolled_window_new (NULL, NULL);
7630 gtk_container_border_width (GTK_CONTAINER (scrolled_window), 10);
7631 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
7632 GTK_POLICY_AUTOMATIC,
7633 GTK_POLICY_AUTOMATIC);
7634 GTK_WIDGET_UNSET_FLAGS (GTK_SCROLLED_WINDOW (scrolled_window)->vscrollbar, GTK_CAN_FOCUS);
7635 gtk_box_pack_start (GTK_BOX (box1), scrolled_window, TRUE, TRUE, 0);
7637 box2 = gtk_vbox_new (FALSE, 0);
7638 gtk_container_border_width (GTK_CONTAINER (box2), 10);
7639 gtk_container_add (GTK_CONTAINER (scrolled_window), box2);
7640 gtk_container_set_focus_vadjustment (GTK_CONTAINER (box2),
7641 gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (scrolled_window)));
7642 gtk_widget_show (box2);
7644 for (i = 0; i < nbuttons; i++)
7646 button = gtk_button_new_with_label (buttons[i].label);
7647 if (buttons[i].func)
7648 gtk_signal_connect (GTK_OBJECT (button),
7650 GTK_SIGNAL_FUNC(buttons[i].func),
7653 gtk_widget_set_sensitive (button, FALSE);
7654 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
7657 separator = gtk_hseparator_new ();
7658 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
7660 box2 = gtk_vbox_new (FALSE, 10);
7661 gtk_container_border_width (GTK_CONTAINER (box2), 10);
7662 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
7664 button = gtk_button_new_with_label ("close");
7665 gtk_signal_connect (GTK_OBJECT (button), "clicked",
7666 GTK_SIGNAL_FUNC (do_exit),
7668 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
7669 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
7670 gtk_widget_grab_default (button);
7672 gtk_widget_show_all (window);
7676 main (int argc, char *argv[])
7678 GtkBindingSet *binding_set;
7680 srand (time (NULL));
7684 gtk_init (&argc, &argv);
7688 binding_set = gtk_binding_set_by_class (gtk_type_class (GTK_TYPE_WIDGET));
7689 gtk_binding_entry_add_signal (binding_set,
7690 '9', GDK_CONTROL_MASK | GDK_RELEASE_MASK,
7693 GTK_TYPE_STRING, "GtkWidgetClass <ctrl><release>9 test");
7695 gtk_rc_parse ("testgtkrc");
7697 create_main_window ();