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));
1017 g_free (tree_buttons);
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);
1718 gint upositionx = 0;
1719 gint upositiony = 0;
1722 uposition_configure (GtkWidget *window)
1728 lx = gtk_object_get_data (GTK_OBJECT (window), "x");
1729 ly = gtk_object_get_data (GTK_OBJECT (window), "y");
1731 gdk_window_get_root_origin (window->window, &upositionx, &upositiony);
1732 sprintf (buffer, "%d", upositionx);
1733 gtk_label_set (lx, buffer);
1734 sprintf (buffer, "%d", upositiony);
1735 gtk_label_set (ly, buffer);
1741 create_saved_position (void)
1743 static GtkWidget *window = NULL;
1748 GtkWidget *main_vbox;
1756 window = gtk_widget_new (GTK_TYPE_WINDOW,
1757 "type", GTK_WINDOW_TOPLEVEL,
1758 "signal::configure_event", uposition_configure, NULL,
1761 "title", "Saved Position",
1764 gtk_signal_connect (GTK_OBJECT (window), "destroy",
1765 GTK_SIGNAL_FUNC (gtk_widget_destroyed),
1768 main_vbox = gtk_vbox_new (FALSE, 5);
1769 gtk_container_border_width (GTK_CONTAINER (main_vbox), 0);
1770 gtk_container_add (GTK_CONTAINER (window), main_vbox);
1773 gtk_widget_new (gtk_vbox_get_type (),
1774 "GtkBox::homogeneous", FALSE,
1775 "GtkBox::spacing", 5,
1776 "GtkContainer::border_width", 10,
1777 "GtkWidget::parent", main_vbox,
1778 "GtkWidget::visible", TRUE,
1781 hbox = gtk_hbox_new (FALSE, 0);
1782 gtk_container_border_width (GTK_CONTAINER (hbox), 5);
1783 gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0);
1785 label = gtk_label_new ("X Origin : ");
1786 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
1787 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
1789 x_label = gtk_label_new ("");
1790 gtk_box_pack_start (GTK_BOX (hbox), x_label, TRUE, TRUE, 0);
1791 gtk_object_set_data (GTK_OBJECT (window), "x", x_label);
1793 hbox = gtk_hbox_new (FALSE, 0);
1794 gtk_container_border_width (GTK_CONTAINER (hbox), 5);
1795 gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0);
1797 label = gtk_label_new ("Y Origin : ");
1798 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
1799 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
1801 y_label = gtk_label_new ("");
1802 gtk_box_pack_start (GTK_BOX (hbox), y_label, TRUE, TRUE, 0);
1803 gtk_object_set_data (GTK_OBJECT (window), "y", y_label);
1806 gtk_widget_new (gtk_hseparator_get_type (),
1807 "GtkWidget::visible", TRUE,
1809 gtk_box_pack_start (GTK_BOX (main_vbox), any, FALSE, TRUE, 0);
1811 hbox = gtk_hbox_new (FALSE, 0);
1812 gtk_container_border_width (GTK_CONTAINER (hbox), 10);
1813 gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, TRUE, 0);
1815 button = gtk_button_new_with_label ("Close");
1816 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
1817 GTK_SIGNAL_FUNC (gtk_widget_destroy),
1818 GTK_OBJECT (window));
1819 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
1820 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
1821 gtk_widget_grab_default (button);
1823 gtk_widget_show_all (window);
1826 gtk_widget_destroy (window);
1834 create_pixmap (void)
1836 static GtkWidget *window = NULL;
1842 GtkWidget *separator;
1843 GtkWidget *pixmapwid;
1850 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
1852 gtk_signal_connect (GTK_OBJECT (window), "destroy",
1853 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
1856 gtk_window_set_title (GTK_WINDOW (window), "GtkPixmap");
1857 gtk_container_border_width (GTK_CONTAINER (window), 0);
1858 gtk_widget_realize(window);
1860 box1 = gtk_vbox_new (FALSE, 0);
1861 gtk_container_add (GTK_CONTAINER (window), box1);
1863 box2 = gtk_vbox_new (FALSE, 10);
1864 gtk_container_border_width (GTK_CONTAINER (box2), 10);
1865 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
1867 button = gtk_button_new ();
1868 gtk_box_pack_start (GTK_BOX (box2), button, FALSE, FALSE, 0);
1870 style = gtk_widget_get_style(button);
1872 pixmap = gdk_pixmap_create_from_xpm (window->window, &mask,
1873 &style->bg[GTK_STATE_NORMAL],
1875 pixmapwid = gtk_pixmap_new (pixmap, mask);
1876 gdk_pixmap_unref (pixmap);
1877 gdk_pixmap_unref (mask);
1879 label = gtk_label_new ("Pixmap\ntest");
1880 box3 = gtk_hbox_new (FALSE, 0);
1881 gtk_container_border_width (GTK_CONTAINER (box3), 2);
1882 gtk_container_add (GTK_CONTAINER (box3), pixmapwid);
1883 gtk_container_add (GTK_CONTAINER (box3), label);
1884 gtk_container_add (GTK_CONTAINER (button), box3);
1886 separator = gtk_hseparator_new ();
1887 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
1889 box2 = gtk_vbox_new (FALSE, 10);
1890 gtk_container_border_width (GTK_CONTAINER (box2), 10);
1891 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
1893 button = gtk_button_new_with_label ("close");
1894 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
1895 GTK_SIGNAL_FUNC(gtk_widget_destroy),
1896 GTK_OBJECT (window));
1897 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
1898 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
1899 gtk_widget_grab_default (button);
1902 if (!GTK_WIDGET_VISIBLE (window))
1903 gtk_widget_show_all (window);
1905 gtk_widget_destroy (window);
1909 tips_query_widget_entered (GtkTipsQuery *tips_query,
1911 const gchar *tip_text,
1912 const gchar *tip_private,
1915 if (GTK_TOGGLE_BUTTON (toggle)->active)
1917 gtk_label_set (GTK_LABEL (tips_query), tip_text ? "There is a Tip!" : "There is no Tip!");
1918 /* don't let GtkTipsQuery reset it's label */
1919 gtk_signal_emit_stop_by_name (GTK_OBJECT (tips_query), "widget_entered");
1924 tips_query_widget_selected (GtkWidget *tips_query,
1926 const gchar *tip_text,
1927 const gchar *tip_private,
1928 GdkEventButton *event,
1932 g_print ("Help \"%s\" requested for <%s>\n",
1933 tip_private ? tip_private : "None",
1934 gtk_type_name (GTK_OBJECT_TYPE (widget)));
1939 create_tooltips (void)
1941 static GtkWidget *window = NULL;
1948 GtkWidget *tips_query;
1949 GtkWidget *separator;
1950 GtkTooltips *tooltips;
1955 gtk_widget_new (gtk_window_get_type (),
1956 "GtkWindow::type", GTK_WINDOW_TOPLEVEL,
1957 "GtkContainer::border_width", 0,
1958 "GtkWindow::title", "Tooltips",
1959 "GtkWindow::allow_shrink", TRUE,
1960 "GtkWindow::allow_grow", FALSE,
1961 "GtkWindow::auto_shrink", TRUE,
1962 "GtkWidget::width", 200,
1965 gtk_signal_connect (GTK_OBJECT (window), "destroy",
1966 GTK_SIGNAL_FUNC (destroy_tooltips),
1969 tooltips=gtk_tooltips_new();
1970 gtk_object_set_data (GTK_OBJECT (window), "tooltips", tooltips);
1972 box1 = gtk_vbox_new (FALSE, 0);
1973 gtk_container_add (GTK_CONTAINER (window), box1);
1975 box2 = gtk_vbox_new (FALSE, 10);
1976 gtk_container_border_width (GTK_CONTAINER (box2), 10);
1977 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
1979 button = gtk_toggle_button_new_with_label ("button1");
1980 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
1982 gtk_tooltips_set_tip (tooltips,button,"This is button 1", "ContextHelp/buttons/1");
1984 button = gtk_toggle_button_new_with_label ("button2");
1985 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
1987 gtk_tooltips_set_tip (tooltips,
1989 "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.",
1990 "ContextHelp/buttons/2_long");
1992 toggle = gtk_toggle_button_new_with_label ("Override TipsQuery Label");
1993 gtk_box_pack_start (GTK_BOX (box2), toggle, TRUE, TRUE, 0);
1995 gtk_tooltips_set_tip (tooltips, toggle, "Toggle TipsQuery view.", "Hi msw! ;)");
1998 gtk_widget_new (gtk_vbox_get_type (),
1999 "GtkBox::homogeneous", FALSE,
2000 "GtkBox::spacing", 5,
2001 "GtkContainer::border_width", 5,
2002 "GtkWidget::visible", TRUE,
2005 tips_query = gtk_tips_query_new ();
2008 gtk_widget_new (gtk_button_get_type (),
2009 "GtkButton::label", "[?]",
2010 "GtkWidget::visible", TRUE,
2011 "GtkWidget::parent", box3,
2012 "GtkObject::object_signal::clicked", gtk_tips_query_start_query, tips_query,
2014 gtk_box_set_child_packing (GTK_BOX (box3), button, FALSE, FALSE, 0, GTK_PACK_START);
2015 gtk_tooltips_set_tip (tooltips,
2017 "Start the Tooltips Inspector",
2018 "ContextHelp/buttons/?");
2021 gtk_widget_set (tips_query,
2022 "GtkWidget::visible", TRUE,
2023 "GtkWidget::parent", box3,
2024 "GtkTipsQuery::caller", button,
2025 "GtkObject::signal::widget_entered", tips_query_widget_entered, toggle,
2026 "GtkObject::signal::widget_selected", tips_query_widget_selected, NULL,
2030 gtk_widget_new (gtk_frame_get_type (),
2031 "GtkFrame::label", "ToolTips Inspector",
2032 "GtkFrame::label_xalign", (double) 0.5,
2033 "GtkContainer::border_width", 0,
2034 "GtkWidget::visible", TRUE,
2035 "GtkWidget::parent", box2,
2036 "GtkContainer::child", box3,
2038 gtk_box_set_child_packing (GTK_BOX (box2), frame, TRUE, TRUE, 10, GTK_PACK_START);
2040 separator = gtk_hseparator_new ();
2041 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
2043 box2 = gtk_vbox_new (FALSE, 10);
2044 gtk_container_border_width (GTK_CONTAINER (box2), 10);
2045 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
2047 button = gtk_button_new_with_label ("close");
2048 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
2049 GTK_SIGNAL_FUNC(gtk_widget_destroy),
2050 GTK_OBJECT (window));
2051 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
2052 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
2053 gtk_widget_grab_default (button);
2055 gtk_tooltips_set_tip (tooltips, button, "Push this button to close window", "ContextHelp/buttons/Close");
2058 if (!GTK_WIDGET_VISIBLE (window))
2059 gtk_widget_show_all (window);
2061 gtk_widget_destroy (window);
2069 create_menu (gint depth, gboolean tearoff)
2072 GtkWidget *menuitem;
2080 menu = gtk_menu_new ();
2085 menuitem = gtk_tearoff_menu_item_new ();
2086 gtk_menu_append (GTK_MENU (menu), menuitem);
2087 gtk_widget_show (menuitem);
2090 for (i = 0, j = 1; i < 5; i++, j++)
2092 sprintf (buf, "item %2d - %d", depth, j);
2093 menuitem = gtk_radio_menu_item_new_with_label (group, buf);
2094 group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menuitem));
2096 gtk_check_menu_item_set_show_toggle (GTK_CHECK_MENU_ITEM (menuitem), TRUE);
2097 gtk_menu_append (GTK_MENU (menu), menuitem);
2098 gtk_widget_show (menuitem);
2100 gtk_widget_set_sensitive (menuitem, FALSE);
2102 gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), create_menu (depth - 1, TRUE));
2111 static GtkWidget *window = NULL;
2115 GtkWidget *optionmenu;
2116 GtkWidget *separator;
2122 GtkWidget *menuitem;
2123 GtkAccelGroup *accel_group;
2125 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
2127 gtk_signal_connect (GTK_OBJECT (window), "destroy",
2128 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
2130 gtk_signal_connect (GTK_OBJECT (window), "delete-event",
2131 GTK_SIGNAL_FUNC (gtk_true),
2134 accel_group = gtk_accel_group_new ();
2135 gtk_accel_group_attach (accel_group, GTK_OBJECT (window));
2137 gtk_window_set_title (GTK_WINDOW (window), "menus");
2138 gtk_container_border_width (GTK_CONTAINER (window), 0);
2141 box1 = gtk_vbox_new (FALSE, 0);
2142 gtk_container_add (GTK_CONTAINER (window), box1);
2143 gtk_widget_show (box1);
2145 menubar = gtk_menu_bar_new ();
2146 gtk_box_pack_start (GTK_BOX (box1), menubar, FALSE, TRUE, 0);
2147 gtk_widget_show (menubar);
2149 menu = create_menu (2, TRUE);
2151 menuitem = gtk_menu_item_new_with_label ("test\nline2");
2152 gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), menu);
2153 gtk_menu_bar_append (GTK_MENU_BAR (menubar), menuitem);
2154 gtk_widget_show (menuitem);
2156 menuitem = gtk_menu_item_new_with_label ("foo");
2157 gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), create_menu (3, TRUE));
2158 gtk_menu_bar_append (GTK_MENU_BAR (menubar), menuitem);
2159 gtk_widget_show (menuitem);
2161 menuitem = gtk_menu_item_new_with_label ("bar");
2162 gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), create_menu (4, TRUE));
2163 gtk_menu_item_right_justify (GTK_MENU_ITEM (menuitem));
2164 gtk_menu_bar_append (GTK_MENU_BAR (menubar), menuitem);
2165 gtk_widget_show (menuitem);
2167 box2 = gtk_vbox_new (FALSE, 10);
2168 gtk_container_border_width (GTK_CONTAINER (box2), 10);
2169 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
2170 gtk_widget_show (box2);
2172 menu = create_menu (1, FALSE);
2173 gtk_menu_set_accel_group (GTK_MENU (menu), accel_group);
2175 menuitem = gtk_check_menu_item_new_with_label ("Accelerate Me");
2176 gtk_menu_append (GTK_MENU (menu), menuitem);
2177 gtk_widget_show (menuitem);
2178 gtk_widget_add_accelerator (menuitem,
2183 GTK_ACCEL_VISIBLE | GTK_ACCEL_SIGNAL_VISIBLE);
2184 menuitem = gtk_check_menu_item_new_with_label ("Accelerator Locked");
2185 gtk_menu_append (GTK_MENU (menu), menuitem);
2186 gtk_widget_show (menuitem);
2187 gtk_widget_add_accelerator (menuitem,
2192 GTK_ACCEL_VISIBLE | GTK_ACCEL_LOCKED);
2193 menuitem = gtk_check_menu_item_new_with_label ("Accelerators Frozen");
2194 gtk_menu_append (GTK_MENU (menu), menuitem);
2195 gtk_widget_show (menuitem);
2196 gtk_widget_add_accelerator (menuitem,
2202 gtk_widget_add_accelerator (menuitem,
2208 gtk_widget_freeze_accelerators (menuitem);
2210 optionmenu = gtk_option_menu_new ();
2211 gtk_option_menu_set_menu (GTK_OPTION_MENU (optionmenu), menu);
2212 gtk_option_menu_set_history (GTK_OPTION_MENU (optionmenu), 3);
2213 gtk_box_pack_start (GTK_BOX (box2), optionmenu, TRUE, TRUE, 0);
2214 gtk_widget_show (optionmenu);
2216 separator = gtk_hseparator_new ();
2217 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
2218 gtk_widget_show (separator);
2220 box2 = gtk_vbox_new (FALSE, 10);
2221 gtk_container_border_width (GTK_CONTAINER (box2), 10);
2222 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
2223 gtk_widget_show (box2);
2225 button = gtk_button_new_with_label ("close");
2226 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
2227 GTK_SIGNAL_FUNC(gtk_widget_destroy),
2228 GTK_OBJECT (window));
2229 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
2230 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
2231 gtk_widget_grab_default (button);
2232 gtk_widget_show (button);
2235 if (!GTK_WIDGET_VISIBLE (window))
2236 gtk_widget_show (window);
2238 gtk_widget_destroy (window);
2242 gtk_ifactory_cb (gpointer callback_data,
2243 guint callback_action,
2246 g_message ("ItemFactory: activated \"%s\"", gtk_item_factory_path_from_widget (widget));
2249 static GtkItemFactoryEntry menu_items[] =
2251 { "/_File", NULL, gtk_ifactory_cb, 0, "<Branch>" },
2252 { "/File/tearoff1", NULL, gtk_ifactory_cb, 0, "<Tearoff>" },
2253 { "/File/_New", "<control>N", gtk_ifactory_cb, 0 },
2254 { "/File/_Open", "<control>O", gtk_ifactory_cb, 0 },
2255 { "/File/_Save", "<control>S", gtk_ifactory_cb, 0 },
2256 { "/File/Save _As...", NULL, gtk_ifactory_cb, 0 },
2257 { "/File/sep1", NULL, gtk_ifactory_cb, 0, "<Separator>" },
2258 { "/File/_Quit", "<control>Q", gtk_ifactory_cb, 0 },
2260 { "/_Preferences", NULL, gtk_ifactory_cb, 0, "<Branch>" },
2261 { "/_Preferences/_Color", NULL, gtk_ifactory_cb, 0, "<Branch>" },
2262 { "/_Preferences/Color/_Red", NULL, gtk_ifactory_cb, 0, "<RadioItem>" },
2263 { "/_Preferences/Color/_Green", NULL, gtk_ifactory_cb, 0, "<RadioItem>" },
2264 { "/_Preferences/Color/_Blue", NULL, gtk_ifactory_cb, 0, "<RadioItem>" },
2265 { "/_Preferences/_Shape", NULL, gtk_ifactory_cb, 0, "<Branch>" },
2266 { "/_Preferences/Shape/_Square", NULL, gtk_ifactory_cb, 0, "<RadioItem>" },
2267 { "/_Preferences/Shape/_Rectangle", NULL, gtk_ifactory_cb, 0, "<RadioItem>" },
2268 { "/_Preferences/Shape/_Oval", NULL, gtk_ifactory_cb, 0, "<RadioItem>" },
2270 { "/_Help", NULL, gtk_ifactory_cb, 0, "<LastBranch>" },
2271 { "/Help/_About", NULL, gtk_ifactory_cb, 0 },
2274 static int nmenu_items = sizeof (menu_items) / sizeof (menu_items[0]);
2277 create_item_factory (void)
2279 static GtkWidget *window = NULL;
2285 GtkWidget *separator;
2288 GtkAccelGroup *accel_group;
2289 GtkItemFactory *item_factory;
2291 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
2293 gtk_signal_connect (GTK_OBJECT (window), "destroy",
2294 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
2296 gtk_signal_connect (GTK_OBJECT (window), "delete-event",
2297 GTK_SIGNAL_FUNC (gtk_true),
2300 accel_group = gtk_accel_group_new ();
2301 item_factory = gtk_item_factory_new (GTK_TYPE_MENU_BAR, "<main>", accel_group);
2302 gtk_item_factory_create_items (item_factory, nmenu_items, menu_items, NULL);
2303 gtk_accel_group_attach (accel_group, GTK_OBJECT (window));
2304 gtk_window_set_title (GTK_WINDOW (window), "Item Factory");
2305 gtk_container_border_width (GTK_CONTAINER (window), 0);
2307 box1 = gtk_vbox_new (FALSE, 0);
2308 gtk_container_add (GTK_CONTAINER (window), box1);
2310 gtk_box_pack_start (GTK_BOX (box1),
2311 gtk_item_factory_get_widget (item_factory, "<main>"),
2314 label = gtk_label_new ("Type\n<alt>\nto start");
2315 gtk_widget_set_usize (label, 200, 200);
2316 gtk_misc_set_alignment (GTK_MISC (label), 0.5, 0.5);
2317 gtk_box_pack_start (GTK_BOX (box1), label, TRUE, TRUE, 0);
2320 separator = gtk_hseparator_new ();
2321 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
2324 box2 = gtk_vbox_new (FALSE, 10);
2325 gtk_container_border_width (GTK_CONTAINER (box2), 10);
2326 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
2328 button = gtk_button_new_with_label ("close");
2329 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
2330 GTK_SIGNAL_FUNC(gtk_widget_destroy),
2331 GTK_OBJECT (window));
2332 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
2333 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
2334 gtk_widget_grab_default (button);
2336 gtk_widget_show_all (window);
2339 gtk_widget_destroy (window);
2347 scrolled_windows_remove (GtkWidget *widget, GtkWidget *scrollwin)
2349 static GtkWidget *parent = NULL;
2350 static GtkWidget *float_parent;
2354 gtk_widget_reparent (scrollwin, parent);
2355 gtk_widget_destroy (float_parent);
2356 float_parent = NULL;
2361 parent = widget->parent;
2362 float_parent = gtk_window_new (GTK_WINDOW_TOPLEVEL);
2363 gtk_widget_reparent (scrollwin, float_parent);
2364 gtk_widget_show (float_parent);
2373 cmw_destroy_cb(GtkWidget *widget)
2375 /* This is needed to get out of gtk_main */
2382 cmw_color (GtkWidget *widget)
2386 csd=gtk_color_selection_dialog_new ("This is a modal color selection dialog");
2389 gtk_window_set_modal (GTK_WINDOW(csd),TRUE);
2391 gtk_signal_connect (GTK_OBJECT(csd), "destroy",
2392 GTK_SIGNAL_FUNC(cmw_destroy_cb),NULL);
2394 gtk_signal_connect_object (GTK_OBJECT(GTK_COLOR_SELECTION_DIALOG(csd)->ok_button),
2395 "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy),
2397 gtk_signal_connect_object (GTK_OBJECT(GTK_COLOR_SELECTION_DIALOG(csd)->cancel_button),
2398 "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy),
2401 /* wait until destroy calls gtk_main_quit */
2402 gtk_widget_show (csd);
2407 cmw_file (GtkWidget *widget)
2411 fs = gtk_file_selection_new("This is a modal file selection dialog");
2414 gtk_window_set_modal (GTK_WINDOW(fs),TRUE);
2416 gtk_signal_connect (GTK_OBJECT(fs), "destroy",
2417 GTK_SIGNAL_FUNC(cmw_destroy_cb),NULL);
2419 gtk_signal_connect_object (GTK_OBJECT(GTK_FILE_SELECTION(fs)->ok_button),
2420 "clicked",GTK_SIGNAL_FUNC(gtk_widget_destroy),
2422 gtk_signal_connect_object (GTK_OBJECT(GTK_FILE_SELECTION(fs)->cancel_button),
2423 "clicked",GTK_SIGNAL_FUNC(gtk_widget_destroy),
2426 /* wait until destroy calls gtk_main_quit */
2427 gtk_widget_show (fs);
2434 create_modal_window (void)
2436 GtkWidget *window = NULL;
2437 GtkWidget *box1,*box2;
2439 GtkWidget *btnColor,*btnFile,*btnClose;
2441 /* Create modal window (Here you can use any window descendent )*/
2442 window=gtk_window_new (GTK_WINDOW_TOPLEVEL);
2443 gtk_window_set_title (GTK_WINDOW(window),"This window is modal");
2445 /* Set window as modal */
2446 gtk_window_set_modal (GTK_WINDOW(window),TRUE);
2448 /* Create widgets */
2449 box1 = gtk_vbox_new (FALSE,5);
2450 frame1 = gtk_frame_new ("Standard dialogs in modal form");
2451 box2 = gtk_vbox_new (TRUE,5);
2452 btnColor = gtk_button_new_with_label ("Color");
2453 btnFile = gtk_button_new_with_label ("File Selection");
2454 btnClose = gtk_button_new_with_label ("Close");
2457 gtk_container_border_width (GTK_CONTAINER(box1),3);
2458 gtk_container_border_width (GTK_CONTAINER(box2),3);
2461 gtk_container_add (GTK_CONTAINER (window), box1);
2462 gtk_box_pack_start (GTK_BOX (box1), frame1, TRUE, TRUE, 4);
2463 gtk_container_add (GTK_CONTAINER (frame1), box2);
2464 gtk_box_pack_start (GTK_BOX (box2), btnColor, FALSE, FALSE, 4);
2465 gtk_box_pack_start (GTK_BOX (box2), btnFile, FALSE, FALSE, 4);
2466 gtk_box_pack_start (GTK_BOX (box1), gtk_hseparator_new (), FALSE, FALSE, 4);
2467 gtk_box_pack_start (GTK_BOX (box1), btnClose, FALSE, FALSE, 4);
2469 /* connect signals */
2470 gtk_signal_connect_object (GTK_OBJECT (btnClose), "clicked",
2471 GTK_SIGNAL_FUNC (gtk_widget_destroy),
2472 GTK_OBJECT (window));
2474 gtk_signal_connect (GTK_OBJECT (window), "destroy",
2475 GTK_SIGNAL_FUNC (cmw_destroy_cb),NULL);
2477 gtk_signal_connect (GTK_OBJECT (btnColor), "clicked",
2478 GTK_SIGNAL_FUNC (cmw_color),NULL);
2479 gtk_signal_connect (GTK_OBJECT (btnFile), "clicked",
2480 GTK_SIGNAL_FUNC (cmw_file),NULL);
2483 gtk_widget_show_all (window);
2485 /* wait until dialog get destroyed */
2494 create_scrolled_windows (void)
2496 static GtkWidget *window;
2497 GtkWidget *scrolled_window;
2505 window = gtk_dialog_new ();
2507 gtk_signal_connect (GTK_OBJECT (window), "destroy",
2508 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
2511 gtk_window_set_title (GTK_WINDOW (window), "dialog");
2512 gtk_container_border_width (GTK_CONTAINER (window), 0);
2515 scrolled_window = gtk_scrolled_window_new (NULL, NULL);
2516 gtk_container_border_width (GTK_CONTAINER (scrolled_window), 10);
2517 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
2518 GTK_POLICY_AUTOMATIC,
2519 GTK_POLICY_AUTOMATIC);
2520 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox),
2521 scrolled_window, TRUE, TRUE, 0);
2522 gtk_widget_show (scrolled_window);
2524 table = gtk_table_new (20, 20, FALSE);
2525 gtk_table_set_row_spacings (GTK_TABLE (table), 10);
2526 gtk_table_set_col_spacings (GTK_TABLE (table), 10);
2527 gtk_container_add (GTK_CONTAINER (scrolled_window), table);
2528 gtk_container_set_focus_hadjustment (GTK_CONTAINER (table),
2529 gtk_scrolled_window_get_hadjustment (GTK_SCROLLED_WINDOW (scrolled_window)));
2530 gtk_container_set_focus_vadjustment (GTK_CONTAINER (table),
2531 gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (scrolled_window)));
2532 gtk_widget_show (table);
2534 for (i = 0; i < 20; i++)
2535 for (j = 0; j < 20; j++)
2537 sprintf (buffer, "button (%d,%d)\n", i, j);
2538 button = gtk_toggle_button_new_with_label (buffer);
2539 gtk_table_attach_defaults (GTK_TABLE (table), button,
2541 gtk_widget_show (button);
2545 button = gtk_button_new_with_label ("close");
2546 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
2547 GTK_SIGNAL_FUNC(gtk_widget_destroy),
2548 GTK_OBJECT (window));
2549 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
2550 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
2551 button, TRUE, TRUE, 0);
2552 gtk_widget_grab_default (button);
2553 gtk_widget_show (button);
2555 button = gtk_button_new_with_label ("remove");
2556 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
2557 GTK_SIGNAL_FUNC(scrolled_windows_remove),
2558 GTK_OBJECT (scrolled_window));
2559 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
2560 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
2561 button, TRUE, TRUE, 0);
2562 gtk_widget_grab_default (button);
2563 gtk_widget_show (button);
2567 if (!GTK_WIDGET_VISIBLE (window))
2568 gtk_widget_show (window);
2570 gtk_widget_destroy (window);
2578 entry_toggle_editable (GtkWidget *checkbutton,
2581 gtk_entry_set_editable(GTK_ENTRY(entry),
2582 GTK_TOGGLE_BUTTON(checkbutton)->active);
2586 entry_toggle_sensitive (GtkWidget *checkbutton,
2589 gtk_widget_set_sensitive (entry, GTK_TOGGLE_BUTTON(checkbutton)->active);
2593 entry_toggle_visibility (GtkWidget *checkbutton,
2596 gtk_entry_set_visibility(GTK_ENTRY(entry),
2597 GTK_TOGGLE_BUTTON(checkbutton)->active);
2603 static GtkWidget *window = NULL;
2606 GtkWidget *editable_check;
2607 GtkWidget *sensitive_check;
2608 GtkWidget *entry, *cb;
2610 GtkWidget *separator;
2611 GList *cbitems = NULL;
2615 cbitems = g_list_append(cbitems, "item0");
2616 cbitems = g_list_append(cbitems, "item1 item1");
2617 cbitems = g_list_append(cbitems, "item2 item2 item2");
2618 cbitems = g_list_append(cbitems, "item3 item3 item3 item3");
2619 cbitems = g_list_append(cbitems, "item4 item4 item4 item4 item4");
2620 cbitems = g_list_append(cbitems, "item5 item5 item5 item5 item5 item5");
2621 cbitems = g_list_append(cbitems, "item6 item6 item6 item6 item6");
2622 cbitems = g_list_append(cbitems, "item7 item7 item7 item7");
2623 cbitems = g_list_append(cbitems, "item8 item8 item8");
2624 cbitems = g_list_append(cbitems, "item9 item9");
2626 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
2628 gtk_signal_connect (GTK_OBJECT (window), "destroy",
2629 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
2632 gtk_window_set_title (GTK_WINDOW (window), "entry");
2633 gtk_container_border_width (GTK_CONTAINER (window), 0);
2636 box1 = gtk_vbox_new (FALSE, 0);
2637 gtk_container_add (GTK_CONTAINER (window), box1);
2638 gtk_widget_show (box1);
2641 box2 = gtk_vbox_new (FALSE, 10);
2642 gtk_container_border_width (GTK_CONTAINER (box2), 10);
2643 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
2644 gtk_widget_show (box2);
2646 entry = gtk_entry_new ();
2647 gtk_entry_set_text (GTK_ENTRY (entry), "hello world");
2648 gtk_editable_select_region (GTK_EDITABLE (entry), 0, 5);
2649 gtk_box_pack_start (GTK_BOX (box2), entry, TRUE, TRUE, 0);
2650 gtk_widget_show (entry);
2652 cb = gtk_combo_new ();
2653 gtk_combo_set_popdown_strings (GTK_COMBO (cb), cbitems);
2654 gtk_entry_set_text (GTK_ENTRY (GTK_COMBO(cb)->entry), "hello world");
2655 gtk_editable_select_region (GTK_EDITABLE (GTK_COMBO(cb)->entry),
2657 gtk_box_pack_start (GTK_BOX (box2), cb, TRUE, TRUE, 0);
2658 gtk_widget_show (cb);
2660 editable_check = gtk_check_button_new_with_label("Editable");
2661 gtk_box_pack_start (GTK_BOX (box2), editable_check, FALSE, TRUE, 0);
2662 gtk_signal_connect (GTK_OBJECT(editable_check), "toggled",
2663 GTK_SIGNAL_FUNC(entry_toggle_editable), entry);
2664 gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(editable_check), TRUE);
2665 gtk_widget_show (editable_check);
2667 editable_check = gtk_check_button_new_with_label("Visible");
2668 gtk_box_pack_start (GTK_BOX (box2), editable_check, FALSE, TRUE, 0);
2669 gtk_signal_connect (GTK_OBJECT(editable_check), "toggled",
2670 GTK_SIGNAL_FUNC(entry_toggle_visibility), entry);
2671 gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(editable_check), TRUE);
2672 gtk_widget_show (editable_check);
2674 sensitive_check = gtk_check_button_new_with_label("Sensitive");
2675 gtk_box_pack_start (GTK_BOX (box2), sensitive_check, FALSE, TRUE, 0);
2676 gtk_signal_connect (GTK_OBJECT(sensitive_check), "toggled",
2677 GTK_SIGNAL_FUNC(entry_toggle_sensitive), entry);
2678 gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(sensitive_check), TRUE);
2679 gtk_widget_show (sensitive_check);
2681 separator = gtk_hseparator_new ();
2682 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
2683 gtk_widget_show (separator);
2686 box2 = gtk_vbox_new (FALSE, 10);
2687 gtk_container_border_width (GTK_CONTAINER (box2), 10);
2688 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
2689 gtk_widget_show (box2);
2692 button = gtk_button_new_with_label ("close");
2693 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
2694 GTK_SIGNAL_FUNC(gtk_widget_destroy),
2695 GTK_OBJECT (window));
2696 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
2697 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
2698 gtk_widget_grab_default (button);
2699 gtk_widget_show (button);
2702 if (!GTK_WIDGET_VISIBLE (window))
2703 gtk_widget_show (window);
2705 gtk_widget_destroy (window);
2712 static GtkWidget *spinner1;
2715 toggle_snap (GtkWidget *widget, GtkSpinButton *spin)
2717 gtk_spin_button_set_snap_to_ticks (spin, GTK_TOGGLE_BUTTON (widget)->active);
2721 toggle_numeric (GtkWidget *widget, GtkSpinButton *spin)
2723 gtk_spin_button_set_numeric (spin, GTK_TOGGLE_BUTTON (widget)->active);
2727 change_digits (GtkWidget *widget, GtkSpinButton *spin)
2729 gtk_spin_button_set_digits (GTK_SPIN_BUTTON (spinner1),
2730 gtk_spin_button_get_value_as_int (spin));
2734 get_value (GtkWidget *widget, gpointer data)
2738 GtkSpinButton *spin;
2740 spin = GTK_SPIN_BUTTON (spinner1);
2741 label = GTK_LABEL (gtk_object_get_user_data (GTK_OBJECT (widget)));
2742 if (GPOINTER_TO_INT (data) == 1)
2743 sprintf (buf, "%d", gtk_spin_button_get_value_as_int (spin));
2745 sprintf (buf, "%0.*f", spin->digits,
2746 gtk_spin_button_get_value_as_float (spin));
2747 gtk_label_set (label, buf);
2753 static GtkWidget *window = NULL;
2756 GtkWidget *main_vbox;
2759 GtkWidget *spinner2;
2763 GtkWidget *val_label;
2768 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
2770 gtk_signal_connect (GTK_OBJECT (window), "destroy",
2771 GTK_SIGNAL_FUNC (gtk_widget_destroyed),
2774 gtk_window_set_title (GTK_WINDOW (window), "GtkSpinButton");
2776 main_vbox = gtk_vbox_new (FALSE, 5);
2777 gtk_container_border_width (GTK_CONTAINER (main_vbox), 10);
2778 gtk_container_add (GTK_CONTAINER (window), main_vbox);
2780 frame = gtk_frame_new ("Not accelerated");
2781 gtk_box_pack_start (GTK_BOX (main_vbox), frame, TRUE, TRUE, 0);
2783 vbox = gtk_vbox_new (FALSE, 0);
2784 gtk_container_border_width (GTK_CONTAINER (vbox), 5);
2785 gtk_container_add (GTK_CONTAINER (frame), vbox);
2787 /* Day, month, year spinners */
2789 hbox = gtk_hbox_new (FALSE, 0);
2790 gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 5);
2792 vbox2 = gtk_vbox_new (FALSE, 0);
2793 gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 5);
2795 label = gtk_label_new ("Day :");
2796 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
2797 gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, TRUE, 0);
2799 adj = (GtkAdjustment *) gtk_adjustment_new (1.0, 1.0, 31.0, 1.0,
2801 spinner = gtk_spin_button_new (adj, 0, 0);
2802 gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spinner), TRUE);
2803 gtk_spin_button_set_shadow_type (GTK_SPIN_BUTTON (spinner),
2805 gtk_box_pack_start (GTK_BOX (vbox2), spinner, FALSE, TRUE, 0);
2807 vbox2 = gtk_vbox_new (FALSE, 0);
2808 gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 5);
2810 label = gtk_label_new ("Month :");
2811 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
2812 gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, TRUE, 0);
2814 adj = (GtkAdjustment *) gtk_adjustment_new (1.0, 1.0, 12.0, 1.0,
2816 spinner = gtk_spin_button_new (adj, 0, 0);
2817 gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spinner), TRUE);
2818 gtk_spin_button_set_shadow_type (GTK_SPIN_BUTTON (spinner),
2819 GTK_SHADOW_ETCHED_IN);
2820 gtk_box_pack_start (GTK_BOX (vbox2), spinner, FALSE, TRUE, 0);
2822 vbox2 = gtk_vbox_new (FALSE, 0);
2823 gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 5);
2825 label = gtk_label_new ("Year :");
2826 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
2827 gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, TRUE, 0);
2829 adj = (GtkAdjustment *) gtk_adjustment_new (1998.0, 0.0, 2100.0,
2831 spinner = gtk_spin_button_new (adj, 0, 0);
2832 gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spinner), TRUE);
2833 gtk_spin_button_set_shadow_type (GTK_SPIN_BUTTON (spinner),
2835 gtk_widget_set_usize (spinner, 55, 0);
2836 gtk_box_pack_start (GTK_BOX (vbox2), spinner, FALSE, TRUE, 0);
2838 frame = gtk_frame_new ("Accelerated");
2839 gtk_box_pack_start (GTK_BOX (main_vbox), frame, TRUE, TRUE, 0);
2841 vbox = gtk_vbox_new (FALSE, 0);
2842 gtk_container_border_width (GTK_CONTAINER (vbox), 5);
2843 gtk_container_add (GTK_CONTAINER (frame), vbox);
2845 hbox = gtk_hbox_new (FALSE, 0);
2846 gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 5);
2848 vbox2 = gtk_vbox_new (FALSE, 0);
2849 gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 5);
2851 label = gtk_label_new ("Value :");
2852 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
2853 gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, TRUE, 0);
2855 adj = (GtkAdjustment *) gtk_adjustment_new (0.0, -10000.0, 10000.0,
2857 spinner1 = gtk_spin_button_new (adj, 1.0, 2);
2858 gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spinner1), TRUE);
2859 gtk_widget_set_usize (spinner1, 100, 0);
2860 gtk_box_pack_start (GTK_BOX (vbox2), spinner1, FALSE, TRUE, 0);
2862 vbox2 = gtk_vbox_new (FALSE, 0);
2863 gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 5);
2865 label = gtk_label_new ("Digits :");
2866 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
2867 gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, TRUE, 0);
2869 adj = (GtkAdjustment *) gtk_adjustment_new (2, 1, 5, 1, 1, 0);
2870 spinner2 = gtk_spin_button_new (adj, 0.0, 0);
2871 gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spinner2), TRUE);
2872 gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
2873 GTK_SIGNAL_FUNC (change_digits),
2874 (gpointer) spinner2);
2875 gtk_box_pack_start (GTK_BOX (vbox2), spinner2, FALSE, TRUE, 0);
2877 hbox = gtk_hbox_new (FALSE, 0);
2878 gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 5);
2880 button = gtk_check_button_new_with_label ("Snap to 0.5-ticks");
2881 gtk_signal_connect (GTK_OBJECT (button), "clicked",
2882 GTK_SIGNAL_FUNC (toggle_snap),
2884 gtk_box_pack_start (GTK_BOX (vbox), button, TRUE, TRUE, 0);
2885 gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON (button), TRUE);
2887 button = gtk_check_button_new_with_label ("Numeric only input mode");
2888 gtk_signal_connect (GTK_OBJECT (button), "clicked",
2889 GTK_SIGNAL_FUNC (toggle_numeric),
2891 gtk_box_pack_start (GTK_BOX (vbox), button, TRUE, TRUE, 0);
2892 gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON (button), TRUE);
2894 val_label = gtk_label_new ("");
2896 hbox = gtk_hbox_new (FALSE, 0);
2897 gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 5);
2899 button = gtk_button_new_with_label ("Value as Int");
2900 gtk_object_set_user_data (GTK_OBJECT (button), val_label);
2901 gtk_signal_connect (GTK_OBJECT (button), "clicked",
2902 GTK_SIGNAL_FUNC (get_value),
2903 GINT_TO_POINTER (1));
2904 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
2906 button = gtk_button_new_with_label ("Value as Float");
2907 gtk_object_set_user_data (GTK_OBJECT (button), val_label);
2908 gtk_signal_connect (GTK_OBJECT (button), "clicked",
2909 GTK_SIGNAL_FUNC (get_value),
2910 GINT_TO_POINTER (2));
2911 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
2913 gtk_box_pack_start (GTK_BOX (vbox), val_label, TRUE, TRUE, 0);
2914 gtk_label_set (GTK_LABEL (val_label), "0");
2916 hbox = gtk_hbox_new (FALSE, 0);
2917 gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, TRUE, 0);
2919 button = gtk_button_new_with_label ("Close");
2920 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
2921 GTK_SIGNAL_FUNC (gtk_widget_destroy),
2922 GTK_OBJECT (window));
2923 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
2926 if (!GTK_WIDGET_VISIBLE (window))
2927 gtk_widget_show_all (window);
2929 gtk_widget_destroy (window);
2937 cursor_expose_event (GtkWidget *widget,
2941 GtkDrawingArea *darea;
2942 GdkDrawable *drawable;
2949 g_return_val_if_fail (widget != NULL, TRUE);
2950 g_return_val_if_fail (GTK_IS_DRAWING_AREA (widget), TRUE);
2952 darea = GTK_DRAWING_AREA (widget);
2953 drawable = widget->window;
2954 white_gc = widget->style->white_gc;
2955 gray_gc = widget->style->bg_gc[GTK_STATE_NORMAL];
2956 black_gc = widget->style->black_gc;
2957 max_width = widget->allocation.width;
2958 max_height = widget->allocation.height;
2960 gdk_draw_rectangle (drawable, white_gc,
2967 gdk_draw_rectangle (drawable, black_gc,
2974 gdk_draw_rectangle (drawable, gray_gc,
2985 set_cursor (GtkWidget *spinner,
2993 c = CLAMP (gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (spinner)), 0, 152);
2996 label = gtk_object_get_user_data (GTK_OBJECT (spinner));
2997 vals = gtk_type_enum_get_values (GTK_TYPE_GDK_CURSOR_TYPE);
2998 while (vals && vals->value != c)
3001 gtk_label_set (GTK_LABEL (label), vals->value_nick);
3003 gtk_label_set (GTK_LABEL (label), "<unknown>");
3005 cursor = gdk_cursor_new (c);
3006 gdk_window_set_cursor (widget->window, cursor);
3007 gdk_cursor_destroy (cursor);
3011 cursor_event (GtkWidget *widget,
3013 GtkSpinButton *spinner)
3015 if ((event->type == GDK_BUTTON_PRESS) &&
3016 ((event->button.button == 1) ||
3017 (event->button.button == 3)))
3019 gtk_spin_button_spin (spinner, event->button.button == 1 ?
3020 GTK_SPIN_STEP_FORWARD : GTK_SPIN_STEP_BACKWARD, 0);
3028 create_cursors (void)
3030 static GtkWidget *window = NULL;
3033 GtkWidget *main_vbox;
3044 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
3046 gtk_signal_connect (GTK_OBJECT (window), "destroy",
3047 GTK_SIGNAL_FUNC (gtk_widget_destroyed),
3050 gtk_window_set_title (GTK_WINDOW (window), "Cursors");
3052 main_vbox = gtk_vbox_new (FALSE, 5);
3053 gtk_container_border_width (GTK_CONTAINER (main_vbox), 0);
3054 gtk_container_add (GTK_CONTAINER (window), main_vbox);
3057 gtk_widget_new (gtk_vbox_get_type (),
3058 "GtkBox::homogeneous", FALSE,
3059 "GtkBox::spacing", 5,
3060 "GtkContainer::border_width", 10,
3061 "GtkWidget::parent", main_vbox,
3062 "GtkWidget::visible", TRUE,
3065 hbox = gtk_hbox_new (FALSE, 0);
3066 gtk_container_border_width (GTK_CONTAINER (hbox), 5);
3067 gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0);
3069 label = gtk_label_new ("Cursor Value : ");
3070 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
3071 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
3073 adj = (GtkAdjustment *) gtk_adjustment_new (0,
3077 spinner = gtk_spin_button_new (adj, 0, 0);
3078 gtk_box_pack_start (GTK_BOX (hbox), spinner, TRUE, TRUE, 0);
3081 gtk_widget_new (gtk_frame_get_type (),
3082 "GtkFrame::shadow", GTK_SHADOW_ETCHED_IN,
3083 "GtkFrame::label_xalign", 0.5,
3084 "GtkFrame::label", "Cursor Area",
3085 "GtkContainer::border_width", 10,
3086 "GtkWidget::parent", vbox,
3087 "GtkWidget::visible", TRUE,
3090 darea = gtk_drawing_area_new ();
3091 gtk_widget_set_usize (darea, 80, 80);
3092 gtk_container_add (GTK_CONTAINER (frame), darea);
3093 gtk_signal_connect (GTK_OBJECT (darea),
3095 GTK_SIGNAL_FUNC (cursor_expose_event),
3097 gtk_widget_set_events (darea, GDK_EXPOSURE_MASK | GDK_BUTTON_PRESS_MASK);
3098 gtk_signal_connect (GTK_OBJECT (darea),
3099 "button_press_event",
3100 GTK_SIGNAL_FUNC (cursor_event),
3102 gtk_widget_show (darea);
3104 gtk_signal_connect (GTK_OBJECT (spinner), "changed",
3105 GTK_SIGNAL_FUNC (set_cursor),
3108 label = gtk_widget_new (GTK_TYPE_LABEL,
3113 gtk_container_child_set (GTK_CONTAINER (vbox), label,
3116 gtk_object_set_user_data (GTK_OBJECT (spinner), label);
3119 gtk_widget_new (gtk_hseparator_get_type (),
3120 "GtkWidget::visible", TRUE,
3122 gtk_box_pack_start (GTK_BOX (main_vbox), any, FALSE, TRUE, 0);
3124 hbox = gtk_hbox_new (FALSE, 0);
3125 gtk_container_border_width (GTK_CONTAINER (hbox), 10);
3126 gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, TRUE, 0);
3128 button = gtk_button_new_with_label ("Close");
3129 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
3130 GTK_SIGNAL_FUNC (gtk_widget_destroy),
3131 GTK_OBJECT (window));
3132 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
3134 gtk_widget_show_all (window);
3136 set_cursor (spinner, darea);
3139 gtk_widget_destroy (window);
3147 list_add (GtkWidget *widget,
3152 GtkWidget *list_item;
3153 GtkContainer *container;
3155 container = GTK_CONTAINER (list);
3157 sprintf (buffer, "added item %d", i++);
3158 list_item = gtk_list_item_new_with_label (buffer);
3159 gtk_widget_show (list_item);
3161 gtk_container_add (container, list_item);
3165 list_remove (GtkWidget *widget,
3171 tmp_list = GTK_LIST (list)->selection;
3176 clear_list = g_list_prepend (clear_list, tmp_list->data);
3177 tmp_list = tmp_list->next;
3180 clear_list = g_list_reverse (clear_list);
3182 gtk_list_remove_items (GTK_LIST (list), clear_list);
3184 g_list_free (clear_list);
3188 list_clear (GtkWidget *widget,
3191 gtk_list_clear_items (GTK_LIST (list), 0, -1);
3195 list_undo_selection (GtkWidget *widget,
3198 gtk_list_undo_selection (GTK_LIST (list));
3201 #define RADIOMENUTOGGLED(_rmi_, __i) { \
3204 __g = gtk_radio_menu_item_group(_rmi_); \
3205 while( __g && !((GtkCheckMenuItem *)(__g->data))->active) { \
3211 static GtkWidget *list_omenu;
3214 list_toggle_sel_mode (GtkWidget *widget, GtkList *list)
3218 if (!GTK_WIDGET_MAPPED (widget))
3221 RADIOMENUTOGGLED ((GtkRadioMenuItem *)
3222 (((GtkOptionMenu *)list_omenu)->menu_item), i);
3224 gtk_list_set_selection_mode (list, (GtkSelectionMode) (3-i));
3230 static GtkWidget *window = NULL;
3235 GtkWidget *scrolled_win;
3238 GtkWidget *separator;
3240 GtkWidget *menu_item;
3246 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
3248 gtk_signal_connect (GTK_OBJECT (window), "destroy",
3249 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
3252 gtk_window_set_title (GTK_WINDOW (window), "list");
3253 gtk_container_border_width (GTK_CONTAINER (window), 0);
3255 box1 = gtk_vbox_new (FALSE, 0);
3256 gtk_container_add (GTK_CONTAINER (window), box1);
3258 box2 = gtk_vbox_new (FALSE, 10);
3259 gtk_container_border_width (GTK_CONTAINER (box2), 10);
3260 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
3262 scrolled_win = gtk_scrolled_window_new (NULL, NULL);
3263 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
3264 GTK_POLICY_AUTOMATIC,
3265 GTK_POLICY_AUTOMATIC);
3266 gtk_box_pack_start (GTK_BOX (box2), scrolled_win, TRUE, TRUE, 0);
3267 gtk_widget_set_usize (scrolled_win, -1, 300);
3269 list = gtk_list_new ();
3270 gtk_list_set_selection_mode (GTK_LIST (list), GTK_SELECTION_EXTENDED);
3271 gtk_container_add (GTK_CONTAINER (scrolled_win), list);
3272 gtk_container_set_focus_vadjustment
3273 (GTK_CONTAINER (list),
3274 gtk_scrolled_window_get_vadjustment
3275 (GTK_SCROLLED_WINDOW (scrolled_win)));
3276 gtk_container_set_focus_hadjustment
3277 (GTK_CONTAINER (list),
3278 gtk_scrolled_window_get_hadjustment
3279 (GTK_SCROLLED_WINDOW (scrolled_win)));
3281 if ((infile = fopen("gtkenums.h", "r")))
3287 while (fgets (buffer, 256, infile))
3289 if ((pos = strchr (buffer, '\n')))
3291 item = gtk_list_item_new_with_label (buffer);
3292 gtk_container_add (GTK_CONTAINER (list), item);
3298 hbox = gtk_hbox_new (TRUE, 10);
3299 gtk_box_pack_start (GTK_BOX (box2), hbox, FALSE, TRUE, 0);
3301 button = gtk_button_new_with_label ("Undo Selection");
3302 gtk_signal_connect (GTK_OBJECT (button), "clicked",
3303 GTK_SIGNAL_FUNC(list_undo_selection),
3305 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
3307 button = gtk_button_new_with_label ("Remove Selection");
3308 gtk_signal_connect (GTK_OBJECT (button), "clicked",
3309 GTK_SIGNAL_FUNC (list_remove),
3311 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
3313 button = gtk_button_new_with_label ("Clear List");
3314 gtk_signal_connect (GTK_OBJECT (button), "clicked",
3315 GTK_SIGNAL_FUNC (list_clear),
3317 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
3319 hbox = gtk_hbox_new (FALSE, 10);
3320 gtk_box_pack_start (GTK_BOX (box2), hbox, FALSE, TRUE, 0);
3322 button = gtk_button_new_with_label ("Insert Row");
3323 gtk_signal_connect (GTK_OBJECT (button), "clicked",
3324 GTK_SIGNAL_FUNC (list_add),
3326 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
3328 label = gtk_label_new ("Selection Mode :");
3329 gtk_signal_connect (GTK_OBJECT (button), "clicked",
3330 GTK_SIGNAL_FUNC(list_remove),
3332 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
3334 list_omenu = gtk_option_menu_new ();
3335 menu = gtk_menu_new ();
3338 menu_item = gtk_radio_menu_item_new_with_label (group, "Single");
3339 gtk_signal_connect (GTK_OBJECT (menu_item), "activate",
3340 GTK_SIGNAL_FUNC (list_toggle_sel_mode), list);
3341 group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menu_item));
3342 gtk_menu_append (GTK_MENU (menu), menu_item);
3343 gtk_widget_show (menu_item);
3345 menu_item = gtk_radio_menu_item_new_with_label (group, "Browse");
3346 gtk_signal_connect (GTK_OBJECT (menu_item), "activate",
3347 GTK_SIGNAL_FUNC (list_toggle_sel_mode), list);
3348 group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menu_item));
3349 gtk_menu_append (GTK_MENU (menu), menu_item);
3350 gtk_widget_show (menu_item);
3352 menu_item = gtk_radio_menu_item_new_with_label (group, "Multiple");
3353 gtk_signal_connect (GTK_OBJECT (menu_item), "activate",
3354 GTK_SIGNAL_FUNC (list_toggle_sel_mode), list);
3355 group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menu_item));
3356 gtk_menu_append (GTK_MENU (menu), menu_item);
3357 gtk_widget_show (menu_item);
3359 menu_item = gtk_radio_menu_item_new_with_label (group, "Extended");
3360 gtk_signal_connect (GTK_OBJECT (menu_item), "activate",
3361 GTK_SIGNAL_FUNC (list_toggle_sel_mode), list);
3362 group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menu_item));
3363 gtk_menu_append (GTK_MENU (menu), menu_item);
3364 gtk_check_menu_item_set_state (GTK_CHECK_MENU_ITEM (menu_item), TRUE);
3365 gtk_widget_show (menu_item);
3367 gtk_option_menu_set_menu (GTK_OPTION_MENU (list_omenu), menu);
3368 gtk_box_pack_start (GTK_BOX (hbox), list_omenu, FALSE, TRUE, 0);
3370 gtk_option_menu_set_history (GTK_OPTION_MENU (list_omenu), 3);
3372 separator = gtk_hseparator_new ();
3373 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
3376 box2 = gtk_vbox_new (FALSE, 10);
3377 gtk_container_border_width (GTK_CONTAINER (box2), 10);
3378 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
3380 button = gtk_button_new_with_label ("close");
3381 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
3382 GTK_SIGNAL_FUNC(gtk_widget_destroy),
3383 GTK_OBJECT (window));
3384 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
3386 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
3387 gtk_widget_grab_default (button);
3390 if (!GTK_WIDGET_VISIBLE (window))
3391 gtk_widget_show_all (window);
3393 gtk_widget_destroy (window);
3400 static char * book_open_xpm[] = {
3423 static char * book_closed_xpm[] = {
3448 static char * mini_page_xpm[] = {
3471 static char * gtk_mini_xpm[] = {
3511 #define TESTGTK_CLIST_COLUMNS 20
3512 static gint clist_rows = 0;
3513 static GtkWidget *clist_omenu;
3516 add1000_clist (GtkWidget *widget, gpointer data)
3519 char text[TESTGTK_CLIST_COLUMNS][50];
3520 char *texts[TESTGTK_CLIST_COLUMNS];
3525 clist = GTK_CLIST (data);
3527 pixmap = gdk_pixmap_create_from_xpm_d (clist->clist_window,
3529 >K_WIDGET (data)->style->white,
3532 for (i = 0; i < TESTGTK_CLIST_COLUMNS; i++)
3535 sprintf (text[i], "Column %d", i);
3539 sprintf (text[1], "Right");
3540 sprintf (text[2], "Center");
3542 gtk_clist_freeze (GTK_CLIST (data));
3543 for (i = 0; i < 1000; i++)
3545 sprintf (text[0], "Row %d", rand() % 10000);
3546 row = gtk_clist_append (clist, texts);
3547 gtk_clist_set_pixtext (clist, row, 3, "gtk+", 5, pixmap, mask);
3550 gtk_clist_thaw (GTK_CLIST (data));
3552 gdk_pixmap_unref (pixmap);
3553 gdk_bitmap_unref (mask);
3557 add10000_clist (GtkWidget *widget, gpointer data)
3560 char text[TESTGTK_CLIST_COLUMNS][50];
3561 char *texts[TESTGTK_CLIST_COLUMNS];
3563 for (i = 0; i < TESTGTK_CLIST_COLUMNS; i++)
3566 sprintf (text[i], "Column %d", i);
3569 sprintf (text[1], "Right");
3570 sprintf (text[2], "Center");
3572 gtk_clist_freeze (GTK_CLIST (data));
3573 for (i = 0; i < 10000; i++)
3575 sprintf (text[0], "Row %d", rand() % 10000 /*clist_rows++*/);
3576 gtk_clist_append (GTK_CLIST (data), texts);
3578 gtk_clist_thaw (GTK_CLIST (data));
3582 clear_clist (GtkWidget *widget, gpointer data)
3584 gtk_clist_clear (GTK_CLIST (data));
3589 remove_row_clist (GtkWidget *widget, gpointer data)
3591 gtk_clist_remove (GTK_CLIST (data), GTK_CLIST (data)->focus_row);
3596 show_titles_clist (GtkWidget *widget, gpointer data)
3598 gtk_clist_column_titles_show (GTK_CLIST (data));
3602 hide_titles_clist (GtkWidget *widget, gpointer data)
3604 gtk_clist_column_titles_hide (GTK_CLIST (data));
3608 select_clist (GtkWidget *widget,
3611 GdkEventButton * bevent,
3621 g_print ("GtkCList Selection: row %d column %d button %d\n",
3622 row, column, bevent ? bevent->button : 0);
3624 for (i = 0; i < TESTGTK_CLIST_COLUMNS; i++)
3626 switch (gtk_clist_get_cell_type (GTK_CLIST (widget), row, i))
3629 g_print ("CELL %d GTK_CELL_TEXT\n", i);
3630 gtk_clist_get_text (GTK_CLIST (widget), row, i, &text);
3631 g_print ("TEXT: %s\n", text);
3634 case GTK_CELL_PIXMAP:
3635 g_print ("CELL %d GTK_CELL_PIXMAP\n", i);
3636 gtk_clist_get_pixmap (GTK_CLIST (widget), row, i, &pixmap, &mask);
3637 g_print ("PIXMAP: %p\n", pixmap);
3638 g_print ("MASK: %p\n", mask);
3641 case GTK_CELL_PIXTEXT:
3642 g_print ("CELL %d GTK_CELL_PIXTEXT\n", i);
3643 gtk_clist_get_pixtext (GTK_CLIST (widget), row, i, &text, &spacing, &pixmap, &mask);
3644 g_print ("TEXT: %s\n", text);
3645 g_print ("SPACING: %d\n", spacing);
3646 g_print ("PIXMAP: %p\n", pixmap);
3647 g_print ("MASK: %p\n", mask);
3655 /* print selections list */
3656 g_print ("\nSelected Rows:");
3657 list = GTK_CLIST (widget)->selection;
3660 g_print (" %d ", GPOINTER_TO_INT (list->data));
3668 unselect_clist (GtkWidget *widget,
3671 GdkEventButton * bevent,
3681 g_print ("GtkCList Unselection: row %d column %d button %d\n",
3682 row, column, bevent ? bevent->button : 0);
3684 for (i = 0; i < TESTGTK_CLIST_COLUMNS; i++)
3686 switch (gtk_clist_get_cell_type (GTK_CLIST (widget), row, i))
3689 g_print ("CELL %d GTK_CELL_TEXT\n", i);
3690 gtk_clist_get_text (GTK_CLIST (widget), row, i, &text);
3691 g_print ("TEXT: %s\n", text);
3694 case GTK_CELL_PIXMAP:
3695 g_print ("CELL %d GTK_CELL_PIXMAP\n", i);
3696 gtk_clist_get_pixmap (GTK_CLIST (widget), row, i, &pixmap, &mask);
3697 g_print ("PIXMAP: %p\n", pixmap);
3698 g_print ("MASK: %p\n", mask);
3701 case GTK_CELL_PIXTEXT:
3702 g_print ("CELL %d GTK_CELL_PIXTEXT\n", i);
3703 gtk_clist_get_pixtext (GTK_CLIST (widget), row, i, &text, &spacing, &pixmap, &mask);
3704 g_print ("TEXT: %s\n", text);
3705 g_print ("SPACING: %d\n", spacing);
3706 g_print ("PIXMAP: %p\n", pixmap);
3707 g_print ("MASK: %p\n", mask);
3715 /* print selections list */
3716 g_print ("\nSelected Rows:");
3717 list = GTK_CLIST (widget)->selection;
3720 g_print (" %d ", GPOINTER_TO_INT (list->data));
3728 insert_row_clist (GtkWidget *widget, gpointer data)
3730 static char *text[] =
3732 "This", "is", "a", "inserted", "row.",
3733 "This", "is", "a", "inserted", "row.",
3734 "This", "is", "a", "inserted", "row.",
3735 "This", "is", "a", "inserted", "row."
3738 static GtkStyle *style1 = NULL;
3739 static GtkStyle *style2 = NULL;
3740 static GtkStyle *style3 = NULL;
3743 if (GTK_CLIST (data)->focus_row >= 0)
3744 row = gtk_clist_insert (GTK_CLIST (data), GTK_CLIST (data)->focus_row,
3747 row = gtk_clist_prepend (GTK_CLIST (data), text);
3761 style1 = gtk_style_copy (GTK_WIDGET (data)->style);
3762 style1->bg[GTK_STATE_PRELIGHT] = col1;
3763 style1->bg[GTK_STATE_SELECTED] = col2;
3765 style2 = gtk_style_copy (GTK_WIDGET (data)->style);
3766 style2->fg[GTK_STATE_PRELIGHT] = col1;
3767 style2->fg[GTK_STATE_SELECTED] = col2;
3769 style3 = gtk_style_copy (GTK_WIDGET (data)->style);
3770 style3->fg[GTK_STATE_PRELIGHT] = col1;
3771 style3->bg[GTK_STATE_PRELIGHT] = col2;
3772 gdk_font_unref (style3->font);
3774 gdk_font_load ("-*-courier-medium-*-*-*-*-120-*-*-*-*-*-*");
3777 gtk_clist_set_cell_style (GTK_CLIST (data), row, 3, style1);
3778 gtk_clist_set_cell_style (GTK_CLIST (data), row, 4, style2);
3779 gtk_clist_set_cell_style (GTK_CLIST (data), row, 0, style3);
3785 clist_warning_test (GtkWidget *button,
3789 static gboolean add_remove = FALSE;
3791 add_remove = !add_remove;
3793 child = gtk_label_new ("Test");
3794 gtk_widget_ref (child);
3795 gtk_object_sink (GTK_OBJECT (child));
3798 gtk_container_add (GTK_CONTAINER (clist), child);
3801 child->parent = clist;
3802 gtk_container_remove (GTK_CONTAINER (clist), child);
3803 child->parent = NULL;
3806 gtk_widget_destroy (child);
3807 gtk_widget_unref (child);
3811 undo_selection (GtkWidget *button, GtkCList *clist)
3813 gtk_clist_undo_selection (clist);
3817 clist_toggle_sel_mode (GtkWidget *widget, GtkCList *clist)
3821 if (!GTK_WIDGET_MAPPED (widget))
3824 RADIOMENUTOGGLED ((GtkRadioMenuItem *)
3825 (((GtkOptionMenu *)clist_omenu)->menu_item), i);
3827 gtk_clist_set_selection_mode (clist, (GtkSelectionMode) (3-i));
3831 clist_click_column (GtkCList *clist, gint column, gpointer data)
3834 gtk_clist_set_column_visibility (clist, column, FALSE);
3835 else if (column == clist->sort_column)
3837 if (clist->sort_type == GTK_SORT_ASCENDING)
3838 clist->sort_type = GTK_SORT_DESCENDING;
3840 clist->sort_type = GTK_SORT_ASCENDING;
3843 gtk_clist_set_sort_column (clist, column);
3845 gtk_clist_sort (clist);
3852 static GtkWidget *window = NULL;
3854 static char *titles[] =
3856 "Title 0", "Title 1", "not resizeable", "max width 120",
3857 "min width 40", "hide column", "Title 6", "Title 7",
3858 "Title 8", "Title 9", "Title 10", "Title 11", "Title 12",
3859 "Title 13", "Title 14", "Title 15", "Title 16", "Title 17",
3860 "Title 18", "Title 19"
3863 static OptionMenuItem items[] =
3865 { "Single", clist_toggle_sel_mode },
3866 { "Browse", clist_toggle_sel_mode },
3867 { "Multiple", clist_toggle_sel_mode },
3868 { "Extended", clist_toggle_sel_mode }
3871 char text[TESTGTK_CLIST_COLUMNS][50];
3872 char *texts[TESTGTK_CLIST_COLUMNS];
3878 GtkWidget *separator;
3880 GtkWidget *undo_button;
3890 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
3892 gtk_signal_connect (GTK_OBJECT (window), "destroy",
3893 GTK_SIGNAL_FUNC (gtk_widget_destroyed), &window);
3895 gtk_window_set_title (GTK_WINDOW (window), "clist");
3896 gtk_container_border_width (GTK_CONTAINER (window), 0);
3898 box1 = gtk_vbox_new (FALSE, 0);
3899 gtk_container_add (GTK_CONTAINER (window), box1);
3901 box2 = gtk_hbox_new (FALSE, 10);
3902 gtk_container_border_width (GTK_CONTAINER (box2), 10);
3903 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0);
3905 /* create GtkCList here so we have a pointer to throw at the
3906 * button callbacks -- more is done with it later */
3907 clist = gtk_clist_new_with_titles (TESTGTK_CLIST_COLUMNS, titles);
3908 /*clist = gtk_clist_new (TESTGTK_CLIST_COLUMNS);*/
3910 gtk_signal_connect (GTK_OBJECT (clist), "click_column",
3911 (GtkSignalFunc) clist_click_column, NULL);
3913 /* control buttons */
3914 button = gtk_button_new_with_label ("Add 1,000 Rows With Pixmaps");
3915 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
3917 gtk_signal_connect (GTK_OBJECT (button), "clicked",
3918 (GtkSignalFunc) add1000_clist, (gpointer) clist);
3920 button = gtk_button_new_with_label ("Add 10,000 Rows");
3921 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
3923 gtk_signal_connect (GTK_OBJECT (button), "clicked",
3924 (GtkSignalFunc) add10000_clist, (gpointer) clist);
3926 button = gtk_button_new_with_label ("Clear List");
3927 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
3929 gtk_signal_connect (GTK_OBJECT (button), "clicked",
3930 (GtkSignalFunc) clear_clist, (gpointer) clist);
3932 button = gtk_button_new_with_label ("Remove Row");
3933 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
3935 gtk_signal_connect (GTK_OBJECT (button), "clicked",
3936 (GtkSignalFunc) remove_row_clist, (gpointer) clist);
3938 /* second layer of buttons */
3939 box2 = gtk_hbox_new (FALSE, 10);
3940 gtk_container_border_width (GTK_CONTAINER (box2), 10);
3941 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0);
3943 button = gtk_button_new_with_label ("Insert Row");
3944 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
3946 gtk_signal_connect (GTK_OBJECT (button), "clicked",
3947 (GtkSignalFunc) insert_row_clist, (gpointer) clist);
3949 button = gtk_button_new_with_label ("Show Title Buttons");
3950 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
3952 gtk_signal_connect (GTK_OBJECT (button), "clicked",
3953 (GtkSignalFunc) show_titles_clist, (gpointer) clist);
3955 button = gtk_button_new_with_label ("Hide Title Buttons");
3956 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
3958 gtk_signal_connect (GTK_OBJECT (button), "clicked",
3959 (GtkSignalFunc) hide_titles_clist, (gpointer) clist);
3961 button = gtk_button_new_with_label ("Warning Test");
3962 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
3964 gtk_signal_connect (GTK_OBJECT (button), "clicked",
3965 (GtkSignalFunc) clist_warning_test,(gpointer) clist);
3967 box2 = gtk_hbox_new (FALSE, 10);
3968 gtk_container_border_width (GTK_CONTAINER (box2), 10);
3969 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0);
3971 undo_button = gtk_button_new_with_label ("Undo last selection");
3972 gtk_box_pack_start (GTK_BOX (box2), undo_button, TRUE, TRUE, 0);
3973 gtk_signal_connect (GTK_OBJECT (undo_button), "clicked",
3974 (GtkSignalFunc) undo_selection, (gpointer) clist);
3976 label = gtk_label_new ("Selection Mode :");
3977 gtk_box_pack_start (GTK_BOX (box2), label, FALSE, TRUE, 0);
3979 clist_omenu = build_option_menu (items, 4, 3, clist);
3980 gtk_box_pack_start (GTK_BOX (box2), clist_omenu, FALSE, TRUE, 0);
3982 /* vbox for the list itself */
3983 box2 = gtk_vbox_new (FALSE, 10);
3984 gtk_container_border_width (GTK_CONTAINER (box2), 10);
3985 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
3988 * the rest of the clist configuration
3992 gtk_signal_connect (GTK_OBJECT (clist),
3994 (GtkSignalFunc) select_clist,
3997 gtk_signal_connect (GTK_OBJECT (clist),
3999 (GtkSignalFunc) unselect_clist,
4003 gtk_clist_set_row_height (GTK_CLIST (clist), 18);
4004 gtk_widget_set_usize (clist, -1, 300);
4006 gtk_clist_set_column_width (GTK_CLIST (clist), 0, 100);
4008 for (i = 1; i < TESTGTK_CLIST_COLUMNS; i++)
4009 gtk_clist_set_column_width (GTK_CLIST (clist), i, 80);
4011 gtk_clist_set_column_resizeable (GTK_CLIST (clist), 2, FALSE);
4012 gtk_clist_set_column_max_width (GTK_CLIST (clist), 3, 120);
4013 gtk_clist_set_column_min_width (GTK_CLIST (clist), 4, 40);
4015 gtk_clist_set_selection_mode (GTK_CLIST (clist), GTK_SELECTION_EXTENDED);
4016 gtk_clist_set_policy (GTK_CLIST (clist), GTK_POLICY_AUTOMATIC,
4017 GTK_POLICY_AUTOMATIC);
4019 gtk_clist_set_column_justification (GTK_CLIST (clist), 1,
4021 gtk_clist_set_column_justification (GTK_CLIST (clist), 2,
4022 GTK_JUSTIFY_CENTER);
4024 for (i = 0; i < TESTGTK_CLIST_COLUMNS; i++)
4027 sprintf (text[i], "Column %d", i);
4030 sprintf (text[1], "Right");
4031 sprintf (text[2], "Center");
4040 style = gtk_style_new ();
4041 style->fg[GTK_STATE_PRELIGHT] = col1;
4042 style->bg[GTK_STATE_PRELIGHT] = col2;
4044 gdk_font_unref (style->font);
4046 gdk_font_load ("-adobe-helvetica-bold-r-*-*-*-140-*-*-*-*-*-*");
4048 for (i = 0; i < 10; i++)
4050 sprintf (text[0], "Row %d", clist_rows++);
4051 gtk_clist_append (GTK_CLIST (clist), texts);
4056 gtk_clist_set_row_style (GTK_CLIST (clist), i, style);
4059 gtk_clist_set_cell_style (GTK_CLIST (clist), i, i % 4, style);
4064 gtk_container_border_width (GTK_CONTAINER (clist), 5);
4065 gtk_box_pack_start (GTK_BOX (box2), clist, TRUE, TRUE, 0);
4067 separator = gtk_hseparator_new ();
4068 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
4070 box2 = gtk_vbox_new (FALSE, 10);
4071 gtk_container_border_width (GTK_CONTAINER (box2), 10);
4072 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
4074 button = gtk_button_new_with_label ("close");
4075 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
4076 GTK_SIGNAL_FUNC(gtk_widget_destroy),
4077 GTK_OBJECT (window));
4079 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
4080 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
4081 gtk_widget_grab_default (button);
4084 if (!GTK_WIDGET_VISIBLE (window))
4085 gtk_widget_show_all (window);
4089 gtk_widget_destroy (window);
4104 static gint books = 0;
4105 static gint pages = 0;
4107 static GtkWidget *book_label;
4108 static GtkWidget *page_label;
4109 static GtkWidget *sel_label;
4110 static GtkWidget *vis_label;
4111 static GtkWidget *omenu1;
4112 static GtkWidget *omenu2;
4113 static GtkWidget *omenu3;
4114 static GtkWidget *omenu4;
4115 static GtkWidget *spin1;
4116 static GtkWidget *spin2;
4117 static GtkWidget *spin3;
4118 static gint line_style;
4120 void after_press (GtkCTree *ctree, gpointer data)
4124 sprintf (buf, "%d", g_list_length (GTK_CLIST (ctree)->selection));
4125 gtk_label_set (GTK_LABEL (sel_label), buf);
4127 sprintf (buf, "%d", g_list_length (GTK_CLIST (ctree)->row_list));
4128 gtk_label_set (GTK_LABEL (vis_label), buf);
4130 sprintf (buf, "%d", books);
4131 gtk_label_set (GTK_LABEL (book_label), buf);
4133 sprintf (buf, "%d", pages);
4134 gtk_label_set (GTK_LABEL (page_label), buf);
4137 void after_move (GtkCTree *ctree, GtkCTreeNode *child, GtkCTreeNode *parent,
4138 GtkCTreeNode *sibling, gpointer data)
4144 gtk_ctree_get_node_info (ctree, child, &source,
4145 NULL, NULL, NULL, NULL, NULL, NULL, NULL);
4147 gtk_ctree_get_node_info (ctree, parent, &target1,
4148 NULL, NULL, NULL, NULL, NULL, NULL, NULL);
4150 gtk_ctree_get_node_info (ctree, sibling, &target2,
4151 NULL, NULL, NULL, NULL, NULL, NULL, NULL);
4153 g_print ("Moving \"%s\" to \"%s\" with sibling \"%s\".\n", source,
4154 (parent) ? target1 : "nil", (sibling) ? target2 : "nil");
4157 gint button_press (GtkCTree *ctree, GdkEventButton *event, gpointer data)
4164 res = gtk_clist_get_selection_info (GTK_CLIST (ctree), event->x, event->y,
4166 if (!res && event->button != 3)
4169 work = GTK_CTREE_NODE (g_list_nth (GTK_CLIST (ctree)->row_list, row));
4171 switch (event->button)
4174 if (GTK_CLIST (ctree)->selection_mode == GTK_SELECTION_MULTIPLE &&
4175 event->state & GDK_SHIFT_MASK)
4176 gtk_signal_emit_stop_by_name (GTK_OBJECT (ctree),"button_press_event");
4179 if (GTK_CTREE_ROW (work)->children &&
4180 gtk_ctree_is_hot_spot (ctree, event->x, event->y))
4182 if (GTK_CTREE_ROW (work)->expanded)
4183 gtk_ctree_collapse_recursive (ctree, work);
4185 gtk_ctree_expand_recursive (ctree, work);
4186 after_press (ctree, NULL);
4187 gtk_signal_emit_stop_by_name (GTK_OBJECT (ctree),
4188 "button_press_event");
4197 gint button_release (GtkCTree *ctree, GdkEventButton *event, gpointer data)
4204 res = gtk_clist_get_selection_info (GTK_CLIST (ctree), event->x, event->y,
4206 if (!res || event->button != 1)
4209 work = GTK_CTREE_NODE (g_list_nth (GTK_CLIST (ctree)->row_list, row));
4211 if (GTK_CLIST (ctree)->selection_mode == GTK_SELECTION_MULTIPLE &&
4212 event->state & GDK_SHIFT_MASK)
4214 if (GTK_CTREE_ROW (work)->row.state == GTK_STATE_SELECTED)
4215 gtk_ctree_unselect_recursive (ctree, work);
4217 gtk_ctree_select_recursive (ctree, work);
4218 after_press (ctree, NULL);
4219 gtk_signal_emit_stop_by_name (GTK_OBJECT (ctree),
4220 "button_release_event");
4225 void count_items (GtkCTree *ctree, GtkCTreeNode *list)
4227 if (GTK_CTREE_ROW (list)->is_leaf)
4233 void expand_all (GtkWidget *widget, GtkCTree *ctree)
4235 gtk_ctree_expand_recursive (ctree, NULL);
4236 after_press (ctree, NULL);
4239 void collapse_all (GtkWidget *widget, GtkCTree *ctree)
4241 gtk_ctree_collapse_recursive (ctree, NULL);
4242 after_press (ctree, NULL);
4245 void select_all (GtkWidget *widget, GtkCTree *ctree)
4247 gtk_ctree_select_recursive (ctree, NULL);
4248 after_press (ctree, NULL);
4251 void change_style (GtkWidget *widget, GtkCTree *ctree)
4253 static GtkStyle *style1 = NULL;
4254 static GtkStyle *style2 = NULL;
4260 if (GTK_CLIST (ctree)->focus_row >= 0)
4261 node = GTK_CTREE_NODE
4262 (g_list_nth (GTK_CLIST (ctree)->row_list,GTK_CLIST (ctree)->focus_row));
4264 node = GTK_CTREE_NODE (GTK_CLIST (ctree)->row_list);
4278 style1 = gtk_style_new ();
4279 style1->bg[GTK_STATE_PRELIGHT] = col1;
4280 style1->fg[GTK_STATE_SELECTED] = col2;
4282 style2 = gtk_style_new ();
4283 style2->bg[GTK_STATE_SELECTED] = col2;
4284 style2->fg[GTK_STATE_PRELIGHT] = col1;
4285 style2->bg[GTK_STATE_PRELIGHT] = col2;
4286 gdk_font_unref (style2->font);
4288 gdk_font_load ("-*-courier-medium-*-*-*-*-300-*-*-*-*-*-*");
4291 gtk_ctree_node_set_cell_style (ctree, node, 1, style1);
4292 gtk_ctree_node_set_cell_style (ctree, node, 0, style2);
4294 if (GTK_CTREE_ROW (node)->children)
4295 gtk_ctree_node_set_row_style (ctree, GTK_CTREE_ROW (node)->children,
4300 void unselect_all (GtkWidget *widget, GtkCTree *ctree)
4302 gtk_ctree_unselect_recursive (ctree, NULL);
4303 after_press (ctree, NULL);
4306 void remove_selection (GtkWidget *widget, GtkCTree *ctree)
4309 GtkCTreeNode *new_sel;
4312 selection = GTK_CLIST (ctree)->selection;
4315 gtk_clist_freeze (GTK_CLIST (ctree));
4319 work = selection->data;
4320 if (GTK_CTREE_ROW (work)->is_leaf)
4323 gtk_ctree_post_recursive (ctree, work,
4324 (GtkCTreeFunc) count_items, NULL);
4326 if (GTK_CLIST (ctree)->selection_mode == GTK_SELECTION_BROWSE)
4328 if (GTK_CTREE_ROW (work)->children)
4330 new_sel = GTK_CTREE_ROW (work)->sibling;
4332 new_sel = GTK_CTREE_NODE_NEXT (work);
4336 if (GTK_CTREE_NODE_NEXT (work))
4337 new_sel = GTK_CTREE_NODE_NEXT (work);
4339 new_sel = GTK_CTREE_NODE_PREV (work);
4343 gtk_ctree_remove_node (ctree, work);
4344 selection = GTK_CLIST (ctree)->selection;
4348 gtk_ctree_select (ctree, new_sel);
4350 gtk_clist_thaw (GTK_CLIST (ctree));
4351 after_press (ctree, NULL);
4354 struct _ExportStruct {
4360 typedef struct _ExportStruct ExportStruct;
4363 gnode2ctree (GtkCTree *ctree,
4366 GtkCTreeNode *cnode,
4370 GdkPixmap *pixmap_closed;
4371 GdkBitmap *mask_closed;
4372 GdkPixmap *pixmap_opened;
4373 GdkBitmap *mask_opened;
4375 if (!cnode || !gnode || (!(es = gnode->data)))
4380 pixmap_closed = pixmap3;
4381 mask_closed = mask3;
4382 pixmap_opened = NULL;
4387 pixmap_closed = pixmap1;
4388 mask_closed = mask1;
4389 pixmap_opened = pixmap2;
4390 mask_opened = mask2;
4393 gtk_ctree_set_node_info (ctree, cnode, es->tree, 2, pixmap_closed,
4394 mask_closed, pixmap_opened, mask_opened,
4395 es->is_leaf, (depth < 3));
4396 gtk_ctree_node_set_text (ctree, cnode, 1, es->info);
4404 ctree2gnode (GtkCTree *ctree,
4407 GtkCTreeNode *cnode,
4412 if (!cnode || !gnode)
4415 es = g_new (ExportStruct, 1);
4417 es->is_leaf = GTK_CTREE_ROW (cnode)->is_leaf;
4418 es->tree = GTK_CELL_PIXTEXT (GTK_CTREE_ROW (cnode)->row.cell[0])->text;
4419 es->info = GTK_CELL_PIXTEXT (GTK_CTREE_ROW (cnode)->row.cell[1])->text;
4423 void export_ctree (GtkWidget *widget, GtkCTree *ctree)
4425 char *title[] = { "Tree" , "Info" };
4426 static GtkWidget *export_window = NULL;
4427 static GtkCTree *export_ctree;
4436 export_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
4438 gtk_signal_connect (GTK_OBJECT (export_window), "destroy",
4439 GTK_SIGNAL_FUNC (gtk_widget_destroyed),
4442 gtk_window_set_title (GTK_WINDOW (export_window), "exported ctree");
4443 gtk_container_border_width (GTK_CONTAINER (export_window), 5);
4445 vbox = gtk_vbox_new (FALSE, 0);
4446 gtk_container_add (GTK_CONTAINER (export_window), vbox);
4448 button = gtk_button_new_with_label ("Close");
4449 gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, TRUE, 0);
4451 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
4452 (GtkSignalFunc) gtk_widget_destroy,
4453 GTK_OBJECT(export_window));
4455 sep = gtk_hseparator_new ();
4456 gtk_box_pack_end (GTK_BOX (vbox), sep, FALSE, TRUE, 10);
4458 export_ctree = GTK_CTREE (gtk_ctree_new_with_titles (2, 0, title));
4459 gtk_ctree_set_line_style (export_ctree, GTK_CTREE_LINES_DOTTED);
4461 gtk_box_pack_start (GTK_BOX (vbox), GTK_WIDGET (export_ctree),
4463 gtk_clist_set_selection_mode (GTK_CLIST (export_ctree),
4464 GTK_SELECTION_EXTENDED);
4465 gtk_clist_set_policy (GTK_CLIST (export_ctree), GTK_POLICY_ALWAYS,
4466 GTK_POLICY_AUTOMATIC);
4467 gtk_clist_set_column_width (GTK_CLIST (export_ctree), 0, 200);
4468 gtk_clist_set_column_width (GTK_CLIST (export_ctree), 1, 200);
4469 gtk_widget_set_usize (GTK_WIDGET (export_ctree), 300, 200);
4472 if (!GTK_WIDGET_VISIBLE (export_window))
4473 gtk_widget_show_all (export_window);
4475 gtk_clist_clear (GTK_CLIST (export_ctree));
4477 node = GTK_CTREE_NODE (g_list_nth (GTK_CLIST (ctree)->row_list,
4478 GTK_CLIST (ctree)->focus_row));
4482 gnode = gtk_ctree_export_to_gnode (ctree, NULL, NULL, node,
4486 gtk_ctree_insert_gnode (export_ctree, NULL, NULL, gnode,
4488 g_node_destroy (gnode);
4492 void change_indent (GtkWidget *widget, GtkCTree *ctree)
4494 gtk_ctree_set_indent (ctree, GTK_ADJUSTMENT (widget)->value);
4497 void change_spacing (GtkWidget *widget, GtkCTree *ctree)
4499 gtk_ctree_set_spacing (ctree, GTK_ADJUSTMENT (widget)->value);
4502 void change_row_height (GtkWidget *widget, GtkCList *clist)
4504 gtk_clist_set_row_height (clist, GTK_ADJUSTMENT (widget)->value);
4507 void toggle_reorderable (GtkWidget *widget, GtkCTree *ctree)
4509 gtk_ctree_set_reorderable (ctree, GTK_TOGGLE_BUTTON (widget)->active);
4512 void set_background (GtkCTree *ctree, GtkCTreeNode *node, gpointer data)
4514 GtkStyle *style = NULL;
4519 if (ctree->line_style != GTK_CTREE_LINES_TABBED)
4521 if (!GTK_CTREE_ROW (node)->is_leaf)
4522 style = GTK_CTREE_ROW (node)->row.data;
4523 else if (GTK_CTREE_ROW (node)->parent)
4524 style = GTK_CTREE_ROW (GTK_CTREE_ROW (node)->parent)->row.data;
4527 gtk_ctree_node_set_row_style (ctree, node, style);
4530 void ctree_toggle_line_style (GtkWidget *widget, GtkCTree *ctree)
4534 if (!GTK_WIDGET_MAPPED (widget))
4537 RADIOMENUTOGGLED ((GtkRadioMenuItem *)
4538 (((GtkOptionMenu *)omenu1)->menu_item), i);
4540 if ((ctree->line_style == GTK_CTREE_LINES_TABBED &&
4541 ((GtkCTreeLineStyle) (3 - i)) != GTK_CTREE_LINES_TABBED) ||
4542 (ctree->line_style != GTK_CTREE_LINES_TABBED &&
4543 ((GtkCTreeLineStyle) (3 - i)) == GTK_CTREE_LINES_TABBED))
4544 gtk_ctree_pre_recursive (ctree, NULL, set_background, NULL);
4545 gtk_ctree_set_line_style (ctree, 3 - i);
4549 void ctree_toggle_expander_style (GtkWidget *widget, GtkCTree *ctree)
4553 if (!GTK_WIDGET_MAPPED (widget))
4556 RADIOMENUTOGGLED ((GtkRadioMenuItem *)
4557 (((GtkOptionMenu *)omenu2)->menu_item), i);
4559 gtk_ctree_set_expander_style (ctree, (GtkCTreeExpanderStyle) (3 - i));
4562 void ctree_toggle_justify (GtkWidget *widget, GtkCTree *ctree)
4566 if (!GTK_WIDGET_MAPPED (widget))
4569 RADIOMENUTOGGLED ((GtkRadioMenuItem *)
4570 (((GtkOptionMenu *)omenu3)->menu_item), i);
4572 gtk_clist_set_column_justification (GTK_CLIST (ctree), ctree->tree_column,
4573 (GtkJustification) (1 - i));
4576 void ctree_toggle_sel_mode (GtkWidget *widget, GtkCTree *ctree)
4580 if (!GTK_WIDGET_MAPPED (widget))
4583 RADIOMENUTOGGLED ((GtkRadioMenuItem *)
4584 (((GtkOptionMenu *)omenu4)->menu_item), i);
4586 gtk_clist_set_selection_mode (GTK_CLIST (ctree), (GtkSelectionMode) (3 - i));
4587 after_press (ctree, NULL);
4590 void build_recursive (GtkCTree *ctree, gint cur_depth, gint depth,
4591 gint num_books, gint num_pages, GtkCTreeNode *parent)
4596 GtkCTreeNode *sibling;
4603 for (i = num_pages + num_books; i > num_books; i--)
4606 sprintf (buf1, "Page %02d", (gint) rand() % 100);
4607 sprintf (buf2, "Item %d-%d", cur_depth, i);
4608 sibling = gtk_ctree_insert_node (ctree, parent, sibling, text, 5,
4609 pixmap3, mask3, NULL, NULL,
4612 if (parent && ctree->line_style == GTK_CTREE_LINES_TABBED)
4613 gtk_ctree_node_set_row_style (ctree, sibling,
4614 GTK_CTREE_ROW (parent)->row.style);
4617 if (cur_depth == depth)
4620 for (i = num_books; i > 0; i--)
4625 sprintf (buf1, "Book %02d", (gint) rand() % 100);
4626 sprintf (buf2, "Item %d-%d", cur_depth, i);
4627 sibling = gtk_ctree_insert_node (ctree, parent, sibling, text, 5,
4628 pixmap1, mask1, pixmap2, mask2,
4631 style = gtk_style_new();
4632 switch (cur_depth % 3)
4635 style->bg[GTK_STATE_PRELIGHT].red = 10000 * (cur_depth % 6);
4636 style->bg[GTK_STATE_PRELIGHT].green = 0;
4637 style->bg[GTK_STATE_PRELIGHT].blue = 65535 - ((i * 10000) % 65535);
4640 style->bg[GTK_STATE_PRELIGHT].red = 10000 * (cur_depth % 6);
4641 style->bg[GTK_STATE_PRELIGHT].green = 65535 - ((i * 10000) % 65535);
4642 style->bg[GTK_STATE_PRELIGHT].blue = 0;
4645 style->bg[GTK_STATE_PRELIGHT].red = 65535 - ((i * 10000) % 65535);
4646 style->bg[GTK_STATE_PRELIGHT].green = 0;
4647 style->bg[GTK_STATE_PRELIGHT].blue = 10000 * (cur_depth % 6);
4650 gtk_ctree_node_set_row_data_full (ctree, sibling, style,
4651 (GtkDestroyNotify) gtk_style_unref);
4653 if (ctree->line_style == GTK_CTREE_LINES_TABBED)
4654 gtk_ctree_node_set_row_style (ctree, sibling, style);
4656 build_recursive (ctree, cur_depth + 1, depth, num_books, num_pages,
4661 void rebuild_tree (GtkWidget *widget, GtkCTree *ctree)
4664 gchar label1[] = "Root";
4665 gchar label2[] = "";
4666 GtkCTreeNode *parent;
4673 d = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (spin1));
4674 b = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (spin2));
4675 p = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (spin3));
4677 n = ((pow (b, d) - 1) / (b - 1)) * (p + 1);
4681 g_print ("%d total items? Try less\n",n);
4685 gtk_clist_freeze (GTK_CLIST (ctree));
4686 gtk_clist_clear (GTK_CLIST (ctree));
4691 parent = gtk_ctree_insert_node (ctree, NULL, NULL, text, 5, pixmap1,
4692 mask1, pixmap2, mask2, FALSE, TRUE);
4694 style = gtk_style_new ();
4695 style->bg[GTK_STATE_PRELIGHT].red = 0;
4696 style->bg[GTK_STATE_PRELIGHT].green = 45000;
4697 style->bg[GTK_STATE_PRELIGHT].blue = 55000;
4698 gtk_ctree_node_set_row_data_full (ctree, parent, style,
4699 (GtkDestroyNotify) gtk_style_unref);
4701 if (ctree->line_style == GTK_CTREE_LINES_TABBED)
4702 gtk_ctree_node_set_row_style (ctree, parent, style);
4704 build_recursive (ctree, 1, d, b, p, parent);
4705 gtk_clist_thaw (GTK_CLIST (ctree));
4706 after_press (ctree, NULL);
4710 ctree_click_column (GtkCTree *ctree, gint column, gpointer data)
4714 clist = GTK_CLIST (ctree);
4716 if (column == clist->sort_column)
4718 if (clist->sort_type == GTK_SORT_ASCENDING)
4719 clist->sort_type = GTK_SORT_DESCENDING;
4721 clist->sort_type = GTK_SORT_ASCENDING;
4724 gtk_clist_set_sort_column (clist, column);
4726 gtk_ctree_sort_recursive (ctree, NULL);
4729 void create_ctree (void)
4731 static GtkWidget *window = NULL;
4732 GtkTooltips *tooltips;
4745 GdkColor transparent;
4747 char *title[] = { "Tree" , "Info" };
4750 static OptionMenuItem items1[] =
4752 { "No lines", ctree_toggle_line_style },
4753 { "Solid", ctree_toggle_line_style },
4754 { "Dotted", ctree_toggle_line_style },
4755 { "Tabbed", ctree_toggle_line_style }
4758 static OptionMenuItem items2[] =
4760 { "None", ctree_toggle_expander_style },
4761 { "Square", ctree_toggle_expander_style },
4762 { "Triangle", ctree_toggle_expander_style },
4763 { "Circular", ctree_toggle_expander_style }
4766 static OptionMenuItem items3[] =
4768 { "Left", ctree_toggle_justify },
4769 { "Right", ctree_toggle_justify }
4772 static OptionMenuItem items4[] =
4774 { "Single", ctree_toggle_sel_mode },
4775 { "Browse", ctree_toggle_sel_mode },
4776 { "Multiple", ctree_toggle_sel_mode },
4777 { "Extended", ctree_toggle_sel_mode }
4782 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
4784 gtk_signal_connect (GTK_OBJECT (window), "destroy",
4785 GTK_SIGNAL_FUNC (gtk_widget_destroyed),
4788 gtk_window_set_title (GTK_WINDOW (window), "GtkCTree");
4789 gtk_container_border_width (GTK_CONTAINER (window), 0);
4791 tooltips = gtk_tooltips_new ();
4792 gtk_object_ref (GTK_OBJECT (tooltips));
4793 gtk_object_sink (GTK_OBJECT (tooltips));
4795 gtk_object_set_data_full (GTK_OBJECT (window), "tooltips", tooltips,
4796 (GtkDestroyNotify) gtk_object_unref);
4798 vbox = gtk_vbox_new (FALSE, 0);
4799 gtk_container_add (GTK_CONTAINER (window), vbox);
4801 hbox = gtk_hbox_new (FALSE, 5);
4802 gtk_container_border_width (GTK_CONTAINER (hbox), 5);
4803 gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0);
4805 label = gtk_label_new ("Depth :");
4806 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
4808 adj = (GtkAdjustment *) gtk_adjustment_new (4, 1, 10, 1, 5, 0);
4809 spin1 = gtk_spin_button_new (adj, 0, 0);
4810 gtk_box_pack_start (GTK_BOX (hbox), spin1, FALSE, TRUE, 5);
4812 label = gtk_label_new ("Books :");
4813 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
4815 adj = (GtkAdjustment *) gtk_adjustment_new (3, 1, 20, 1, 5, 0);
4816 spin2 = gtk_spin_button_new (adj, 0, 0);
4817 gtk_box_pack_start (GTK_BOX (hbox), spin2, FALSE, TRUE, 5);
4819 label = gtk_label_new ("Pages :");
4820 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
4822 adj = (GtkAdjustment *) gtk_adjustment_new (5, 1, 20, 1, 5, 0);
4823 spin3 = gtk_spin_button_new (adj, 0, 0);
4824 gtk_box_pack_start (GTK_BOX (hbox), spin3, FALSE, TRUE, 5);
4826 button = gtk_button_new_with_label ("Close");
4827 gtk_box_pack_end (GTK_BOX (hbox), button, TRUE, TRUE, 0);
4829 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
4830 (GtkSignalFunc) gtk_widget_destroy,
4831 GTK_OBJECT(window));
4833 button = gtk_button_new_with_label ("Rebuild tree");
4834 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
4836 ctree = GTK_CTREE (gtk_ctree_new_with_titles (2, 0, title));
4837 gtk_ctree_set_line_style (ctree, GTK_CTREE_LINES_DOTTED);
4838 line_style = GTK_CTREE_LINES_DOTTED;
4840 gtk_ctree_set_reorderable (ctree, TRUE);
4841 gtk_signal_connect (GTK_OBJECT (ctree), "click_column",
4842 (GtkSignalFunc) ctree_click_column,
4844 gtk_signal_connect (GTK_OBJECT (ctree), "button_press_event",
4845 GTK_SIGNAL_FUNC (button_press), NULL);
4846 gtk_signal_connect_after (GTK_OBJECT (ctree), "button_press_event",
4847 GTK_SIGNAL_FUNC (after_press), NULL);
4848 gtk_signal_connect (GTK_OBJECT (ctree), "button_release_event",
4849 GTK_SIGNAL_FUNC (button_release), NULL);
4850 gtk_signal_connect_after (GTK_OBJECT (ctree), "button_release_event",
4851 GTK_SIGNAL_FUNC (after_press), NULL);
4852 gtk_signal_connect_after (GTK_OBJECT (ctree), "tree_move",
4853 GTK_SIGNAL_FUNC (after_move), NULL);
4854 gtk_signal_connect_after (GTK_OBJECT (ctree), "end_selection",
4855 GTK_SIGNAL_FUNC (after_press), NULL);
4856 gtk_signal_connect_after (GTK_OBJECT (ctree), "toggle_focus_row",
4857 GTK_SIGNAL_FUNC (after_press), NULL);
4858 gtk_signal_connect_after (GTK_OBJECT (ctree), "select_all",
4859 GTK_SIGNAL_FUNC (after_press), NULL);
4860 gtk_signal_connect_after (GTK_OBJECT (ctree), "unselect_all",
4861 GTK_SIGNAL_FUNC (after_press), NULL);
4862 gtk_signal_connect_after (GTK_OBJECT (ctree), "scroll_vertical",
4863 GTK_SIGNAL_FUNC (after_press), NULL);
4865 gtk_box_pack_start (GTK_BOX (vbox), GTK_WIDGET (ctree), TRUE, TRUE, 0);
4866 gtk_clist_set_selection_mode (GTK_CLIST (ctree), GTK_SELECTION_EXTENDED);
4867 gtk_clist_set_policy (GTK_CLIST (ctree), GTK_POLICY_ALWAYS,
4868 GTK_POLICY_AUTOMATIC);
4869 gtk_clist_set_column_width (GTK_CLIST (ctree), 0, 200);
4870 gtk_clist_set_column_width (GTK_CLIST (ctree), 1, 200);
4872 gtk_signal_connect (GTK_OBJECT (button), "clicked",
4873 GTK_SIGNAL_FUNC (rebuild_tree), ctree);
4875 bbox = gtk_hbox_new (FALSE, 5);
4876 gtk_container_border_width (GTK_CONTAINER (bbox), 5);
4877 gtk_box_pack_start (GTK_BOX (vbox), bbox, FALSE, TRUE, 0);
4879 mbox = gtk_vbox_new (TRUE, 5);
4880 gtk_box_pack_start (GTK_BOX (bbox), mbox, FALSE, TRUE, 0);
4882 label = gtk_label_new ("Row height :");
4883 gtk_box_pack_start (GTK_BOX (mbox), label, FALSE, FALSE, 0);
4885 label = gtk_label_new ("Indent :");
4886 gtk_box_pack_start (GTK_BOX (mbox), label, FALSE, FALSE, 0);
4888 label = gtk_label_new ("Spacing :");
4889 gtk_box_pack_start (GTK_BOX (mbox), label, FALSE, FALSE, 0);
4891 mbox = gtk_vbox_new (TRUE, 5);
4892 gtk_box_pack_start (GTK_BOX (bbox), mbox, FALSE, TRUE, 0);
4894 adj = (GtkAdjustment *) gtk_adjustment_new (20, 12, 100, 1, 10, 0);
4895 spinner = gtk_spin_button_new (adj, 0, 0);
4896 gtk_tooltips_set_tip (tooltips, spinner,
4897 "Row height of list items", NULL);
4898 gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
4899 GTK_SIGNAL_FUNC (change_row_height), ctree);
4900 gtk_box_pack_start (GTK_BOX (mbox), spinner, FALSE, FALSE, 5);
4901 gtk_clist_set_row_height ( GTK_CLIST (ctree), adj->value);
4903 adj = (GtkAdjustment *) gtk_adjustment_new (20, 0, 60, 1, 10, 0);
4904 spinner = gtk_spin_button_new (adj, 0, 0);
4905 gtk_tooltips_set_tip (tooltips, spinner, "Tree indentation.", NULL);
4906 gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
4907 GTK_SIGNAL_FUNC (change_indent), ctree);
4908 gtk_box_pack_start (GTK_BOX (mbox), spinner, FALSE, FALSE, 5);
4910 adj = (GtkAdjustment *) gtk_adjustment_new (5, 0, 60, 1, 10, 0);
4911 spinner = gtk_spin_button_new (adj, 0, 0);
4912 gtk_tooltips_set_tip (tooltips, spinner, "Tree spacing.", NULL);
4913 gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
4914 GTK_SIGNAL_FUNC (change_spacing), ctree);
4915 gtk_box_pack_start (GTK_BOX (mbox), spinner, FALSE, FALSE, 5);
4917 mbox = gtk_vbox_new (TRUE, 5);
4918 gtk_box_pack_start (GTK_BOX (bbox), mbox, FALSE, TRUE, 0);
4920 hbox = gtk_hbox_new (FALSE, 5);
4921 gtk_box_pack_start (GTK_BOX (mbox), hbox, FALSE, FALSE, 0);
4923 button = gtk_button_new_with_label ("Expand all");
4924 gtk_signal_connect (GTK_OBJECT (button), "clicked",
4925 GTK_SIGNAL_FUNC (expand_all), ctree);
4926 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
4928 button = gtk_button_new_with_label ("Collapse all");
4929 gtk_signal_connect (GTK_OBJECT (button), "clicked",
4930 GTK_SIGNAL_FUNC (collapse_all), ctree);
4931 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
4933 button = gtk_button_new_with_label ("Change Style");
4934 gtk_signal_connect (GTK_OBJECT (button), "clicked",
4935 GTK_SIGNAL_FUNC (change_style), ctree);
4936 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
4938 button = gtk_button_new_with_label ("Export tree");
4939 gtk_signal_connect (GTK_OBJECT (button), "clicked",
4940 GTK_SIGNAL_FUNC (export_ctree), ctree);
4941 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
4943 hbox = gtk_hbox_new (FALSE, 5);
4944 gtk_box_pack_start (GTK_BOX (mbox), hbox, FALSE, FALSE, 0);
4946 button = gtk_button_new_with_label ("Select all");
4947 gtk_signal_connect (GTK_OBJECT (button), "clicked",
4948 GTK_SIGNAL_FUNC (select_all), ctree);
4949 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
4951 button = gtk_button_new_with_label ("Unselect all");
4952 gtk_signal_connect (GTK_OBJECT (button), "clicked",
4953 GTK_SIGNAL_FUNC (unselect_all), ctree);
4954 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
4956 button = gtk_button_new_with_label ("Remove selection");
4957 gtk_signal_connect (GTK_OBJECT (button), "clicked",
4958 GTK_SIGNAL_FUNC (remove_selection), ctree);
4959 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
4961 check = gtk_check_button_new_with_label ("Reorderable");
4962 gtk_tooltips_set_tip (tooltips, check,
4963 "Tree items can be reordered by dragging.", NULL);
4964 gtk_signal_connect (GTK_OBJECT (check), "clicked",
4965 GTK_SIGNAL_FUNC (toggle_reorderable), ctree);
4966 gtk_box_pack_start (GTK_BOX (hbox), check, FALSE, TRUE, 0);
4967 gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON (check), TRUE);
4969 hbox = gtk_hbox_new (TRUE, 5);
4970 gtk_box_pack_start (GTK_BOX (mbox), hbox, FALSE, FALSE, 0);
4972 omenu1 = build_option_menu (items1, 4, 2, ctree);
4973 gtk_tooltips_set_tip (tooltips, omenu1, "The tree's line style.", NULL);
4974 gtk_box_pack_start (GTK_BOX (hbox), omenu1, FALSE, TRUE, 0);
4976 omenu2 = build_option_menu (items2, 4, 1, ctree);
4977 gtk_tooltips_set_tip (tooltips, omenu2, "The tree's expander style.",
4979 gtk_box_pack_start (GTK_BOX (hbox), omenu2, FALSE, TRUE, 0);
4981 omenu3 = build_option_menu (items3, 2, 0, ctree);
4982 gtk_tooltips_set_tip (tooltips, omenu3, "The tree's justification.",
4984 gtk_box_pack_start (GTK_BOX (hbox), omenu3, FALSE, TRUE, 0);
4986 omenu4 = build_option_menu (items4, 4, 3, ctree);
4987 gtk_tooltips_set_tip (tooltips, omenu4, "The list's selection mode.",
4989 gtk_box_pack_start (GTK_BOX (hbox), omenu4, FALSE, TRUE, 0);
4991 gtk_widget_realize (window);
4993 pixmap1 = gdk_pixmap_create_from_xpm_d (window->window, &mask1,
4994 &transparent, book_closed_xpm);
4995 pixmap2 = gdk_pixmap_create_from_xpm_d (window->window, &mask2,
4996 &transparent, book_open_xpm);
4997 pixmap3 = gdk_pixmap_create_from_xpm_d (window->window, &mask3,
4998 &transparent, mini_page_xpm);
5000 gtk_widget_set_usize (GTK_WIDGET (ctree), 0, 300);
5002 frame = gtk_frame_new (NULL);
5003 gtk_container_border_width (GTK_CONTAINER (frame), 0);
5004 gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_OUT);
5005 gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, TRUE, 0);
5007 hbox = gtk_hbox_new (TRUE, 2);
5008 gtk_container_border_width (GTK_CONTAINER (hbox), 2);
5009 gtk_container_add (GTK_CONTAINER (frame), hbox);
5011 frame = gtk_frame_new (NULL);
5012 gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
5013 gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, TRUE, 0);
5015 hbox2 = gtk_hbox_new (FALSE, 0);
5016 gtk_container_border_width (GTK_CONTAINER (hbox2), 2);
5017 gtk_container_add (GTK_CONTAINER (frame), hbox2);
5019 label = gtk_label_new ("Books :");
5020 gtk_box_pack_start (GTK_BOX (hbox2), label, FALSE, TRUE, 0);
5022 sprintf (buf, "%d", books);
5023 book_label = gtk_label_new (buf);
5024 gtk_box_pack_end (GTK_BOX (hbox2), book_label, FALSE, TRUE, 5);
5026 frame = gtk_frame_new (NULL);
5027 gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
5028 gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, TRUE, 0);
5030 hbox2 = gtk_hbox_new (FALSE, 0);
5031 gtk_container_border_width (GTK_CONTAINER (hbox2), 2);
5032 gtk_container_add (GTK_CONTAINER (frame), hbox2);
5034 label = gtk_label_new ("Pages :");
5035 gtk_box_pack_start (GTK_BOX (hbox2), label, FALSE, TRUE, 0);
5037 sprintf (buf, "%d", pages);
5038 page_label = gtk_label_new (buf);
5039 gtk_box_pack_end (GTK_BOX (hbox2), page_label, FALSE, TRUE, 5);
5041 frame = gtk_frame_new (NULL);
5042 gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
5043 gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, TRUE, 0);
5045 hbox2 = gtk_hbox_new (FALSE, 0);
5046 gtk_container_border_width (GTK_CONTAINER (hbox2), 2);
5047 gtk_container_add (GTK_CONTAINER (frame), hbox2);
5049 label = gtk_label_new ("Selected :");
5050 gtk_box_pack_start (GTK_BOX (hbox2), label, FALSE, TRUE, 0);
5052 sprintf (buf, "%d", g_list_length (GTK_CLIST (ctree)->selection));
5053 sel_label = gtk_label_new (buf);
5054 gtk_box_pack_end (GTK_BOX (hbox2), sel_label, FALSE, TRUE, 5);
5056 frame = gtk_frame_new (NULL);
5057 gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
5058 gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, TRUE, 0);
5060 hbox2 = gtk_hbox_new (FALSE, 0);
5061 gtk_container_border_width (GTK_CONTAINER (hbox2), 2);
5062 gtk_container_add (GTK_CONTAINER (frame), hbox2);
5064 label = gtk_label_new ("Visible :");
5065 gtk_box_pack_start (GTK_BOX (hbox2), label, FALSE, TRUE, 0);
5067 sprintf (buf, "%d", g_list_length (GTK_CLIST (ctree)->row_list));
5068 vis_label = gtk_label_new (buf);
5069 gtk_box_pack_end (GTK_BOX (hbox2), vis_label, FALSE, TRUE, 5);
5071 rebuild_tree (NULL, ctree);
5074 if (!GTK_WIDGET_VISIBLE (window))
5075 gtk_widget_show_all (window);
5077 gtk_widget_destroy (window);
5085 color_selection_ok (GtkWidget *w,
5086 GtkColorSelectionDialog *cs)
5088 GtkColorSelection *colorsel;
5091 colorsel=GTK_COLOR_SELECTION(cs->colorsel);
5093 gtk_color_selection_get_color(colorsel,color);
5094 gtk_color_selection_set_color(colorsel,color);
5098 color_selection_changed (GtkWidget *w,
5099 GtkColorSelectionDialog *cs)
5101 GtkColorSelection *colorsel;
5104 colorsel=GTK_COLOR_SELECTION(cs->colorsel);
5105 gtk_color_selection_get_color(colorsel,color);
5109 create_color_selection (void)
5111 static GtkWidget *window = NULL;
5115 window = gtk_color_selection_dialog_new ("color selection dialog");
5117 gtk_color_selection_set_opacity (
5118 GTK_COLOR_SELECTION (GTK_COLOR_SELECTION_DIALOG (window)->colorsel),
5121 gtk_color_selection_set_update_policy(
5122 GTK_COLOR_SELECTION (GTK_COLOR_SELECTION_DIALOG (window)->colorsel),
5123 GTK_UPDATE_CONTINUOUS);
5125 gtk_window_position (GTK_WINDOW (window), GTK_WIN_POS_MOUSE);
5127 gtk_signal_connect (GTK_OBJECT (window), "destroy",
5128 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
5131 gtk_signal_connect (
5132 GTK_OBJECT (GTK_COLOR_SELECTION_DIALOG (window)->colorsel),
5134 GTK_SIGNAL_FUNC(color_selection_changed),
5137 gtk_signal_connect (
5138 GTK_OBJECT (GTK_COLOR_SELECTION_DIALOG (window)->ok_button),
5140 GTK_SIGNAL_FUNC(color_selection_ok),
5143 gtk_signal_connect_object (
5144 GTK_OBJECT (GTK_COLOR_SELECTION_DIALOG (window)->cancel_button),
5146 GTK_SIGNAL_FUNC(gtk_widget_destroy),
5147 GTK_OBJECT (window));
5150 if (!GTK_WIDGET_VISIBLE (window))
5151 gtk_widget_show (window);
5153 gtk_widget_destroy (window);
5161 file_selection_hide_fileops (GtkWidget *widget,
5162 GtkFileSelection *fs)
5164 gtk_file_selection_hide_fileop_buttons (fs);
5168 file_selection_ok (GtkWidget *w,
5169 GtkFileSelection *fs)
5171 g_print ("%s\n", gtk_file_selection_get_filename (fs));
5172 gtk_widget_destroy (GTK_WIDGET (fs));
5176 create_file_selection (void)
5178 static GtkWidget *window = NULL;
5183 window = gtk_file_selection_new ("file selection dialog");
5185 gtk_file_selection_hide_fileop_buttons (GTK_FILE_SELECTION (window));
5187 gtk_window_position (GTK_WINDOW (window), GTK_WIN_POS_MOUSE);
5189 gtk_signal_connect (GTK_OBJECT (window), "destroy",
5190 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
5193 gtk_signal_connect (GTK_OBJECT (GTK_FILE_SELECTION (window)->ok_button),
5194 "clicked", GTK_SIGNAL_FUNC(file_selection_ok),
5196 gtk_signal_connect_object (GTK_OBJECT (GTK_FILE_SELECTION (window)->cancel_button),
5197 "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy),
5198 GTK_OBJECT (window));
5200 button = gtk_button_new_with_label ("Hide Fileops");
5201 gtk_signal_connect (GTK_OBJECT (button), "clicked",
5202 (GtkSignalFunc) file_selection_hide_fileops,
5204 gtk_box_pack_start (GTK_BOX (GTK_FILE_SELECTION (window)->action_area),
5205 button, FALSE, FALSE, 0);
5206 gtk_widget_show (button);
5208 button = gtk_button_new_with_label ("Show Fileops");
5209 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
5210 (GtkSignalFunc) gtk_file_selection_show_fileop_buttons,
5212 gtk_box_pack_start (GTK_BOX (GTK_FILE_SELECTION (window)->action_area),
5213 button, FALSE, FALSE, 0);
5214 gtk_widget_show (button);
5217 if (!GTK_WIDGET_VISIBLE (window))
5218 gtk_widget_show (window);
5220 gtk_widget_destroy (window);
5228 font_selection_ok (GtkWidget *w,
5229 GtkFontSelectionDialog *fs)
5231 g_print ("%s\n", gtk_font_selection_dialog_get_font_name (fs));
5232 gtk_widget_destroy (GTK_WIDGET (fs));
5236 create_font_selection (void)
5238 static GtkWidget *window = NULL;
5242 window = gtk_font_selection_dialog_new ("Font Selection Dialog");
5244 gtk_window_position (GTK_WINDOW (window), GTK_WIN_POS_MOUSE);
5246 gtk_signal_connect (GTK_OBJECT (window), "destroy",
5247 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
5250 gtk_signal_connect (GTK_OBJECT (GTK_FONT_SELECTION_DIALOG (window)->ok_button),
5251 "clicked", GTK_SIGNAL_FUNC(font_selection_ok),
5252 GTK_FONT_SELECTION_DIALOG (window));
5253 gtk_signal_connect_object (GTK_OBJECT (GTK_FONT_SELECTION_DIALOG (window)->cancel_button),
5254 "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy),
5255 GTK_OBJECT (window));
5258 if (!GTK_WIDGET_VISIBLE (window))
5259 gtk_widget_show (window);
5261 gtk_widget_destroy (window);
5268 static GtkWidget *dialog_window = NULL;
5271 label_toggle (GtkWidget *widget,
5276 *label = gtk_label_new ("Dialog Test");
5277 gtk_signal_connect (GTK_OBJECT (*label),
5279 GTK_SIGNAL_FUNC (gtk_widget_destroyed),
5281 gtk_misc_set_padding (GTK_MISC (*label), 10, 10);
5282 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog_window)->vbox),
5283 *label, TRUE, TRUE, 0);
5284 gtk_widget_show (*label);
5287 gtk_widget_destroy (*label);
5291 create_dialog (void)
5293 static GtkWidget *label;
5298 dialog_window = gtk_dialog_new ();
5300 gtk_signal_connect (GTK_OBJECT (dialog_window), "destroy",
5301 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
5304 gtk_window_set_title (GTK_WINDOW (dialog_window), "GtkDialog");
5305 gtk_container_border_width (GTK_CONTAINER (dialog_window), 0);
5306 gtk_widget_set_usize (dialog_window, 200, 110);
5308 button = gtk_button_new_with_label ("OK");
5309 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
5310 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog_window)->action_area),
5311 button, TRUE, TRUE, 0);
5312 gtk_widget_grab_default (button);
5313 gtk_widget_show (button);
5315 button = gtk_button_new_with_label ("Toggle");
5316 gtk_signal_connect (GTK_OBJECT (button), "clicked",
5317 GTK_SIGNAL_FUNC (label_toggle),
5319 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
5320 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog_window)->action_area),
5321 button, TRUE, TRUE, 0);
5322 gtk_widget_show (button);
5327 if (!GTK_WIDGET_VISIBLE (dialog_window))
5328 gtk_widget_show (dialog_window);
5330 gtk_widget_destroy (dialog_window);
5338 create_range_controls (void)
5340 static GtkWidget *window = NULL;
5344 GtkWidget *scrollbar;
5346 GtkWidget *separator;
5347 GtkObject *adjustment;
5351 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
5353 gtk_signal_connect (GTK_OBJECT (window), "destroy",
5354 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
5357 gtk_window_set_title (GTK_WINDOW (window), "range controls");
5358 gtk_container_border_width (GTK_CONTAINER (window), 0);
5361 box1 = gtk_vbox_new (FALSE, 0);
5362 gtk_container_add (GTK_CONTAINER (window), box1);
5363 gtk_widget_show (box1);
5366 box2 = gtk_vbox_new (FALSE, 10);
5367 gtk_container_border_width (GTK_CONTAINER (box2), 10);
5368 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
5369 gtk_widget_show (box2);
5372 adjustment = gtk_adjustment_new (0.0, 0.0, 101.0, 0.1, 1.0, 1.0);
5374 scale = gtk_hscale_new (GTK_ADJUSTMENT (adjustment));
5375 gtk_widget_set_usize (GTK_WIDGET (scale), 150, 30);
5376 gtk_range_set_update_policy (GTK_RANGE (scale), GTK_UPDATE_DELAYED);
5377 gtk_scale_set_digits (GTK_SCALE (scale), 1);
5378 gtk_scale_set_draw_value (GTK_SCALE (scale), TRUE);
5379 gtk_box_pack_start (GTK_BOX (box2), scale, TRUE, TRUE, 0);
5380 gtk_widget_show (scale);
5382 scrollbar = gtk_hscrollbar_new (GTK_ADJUSTMENT (adjustment));
5383 gtk_range_set_update_policy (GTK_RANGE (scrollbar),
5384 GTK_UPDATE_CONTINUOUS);
5385 gtk_box_pack_start (GTK_BOX (box2), scrollbar, TRUE, TRUE, 0);
5386 gtk_widget_show (scrollbar);
5389 separator = gtk_hseparator_new ();
5390 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
5391 gtk_widget_show (separator);
5394 box2 = gtk_vbox_new (FALSE, 10);
5395 gtk_container_border_width (GTK_CONTAINER (box2), 10);
5396 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
5397 gtk_widget_show (box2);
5400 button = gtk_button_new_with_label ("close");
5401 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
5402 GTK_SIGNAL_FUNC(gtk_widget_destroy),
5403 GTK_OBJECT (window));
5404 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
5405 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
5406 gtk_widget_grab_default (button);
5407 gtk_widget_show (button);
5410 if (!GTK_WIDGET_VISIBLE (window))
5411 gtk_widget_show (window);
5413 gtk_widget_destroy (window);
5421 create_rulers (void)
5423 static GtkWidget *window = NULL;
5429 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
5430 gtk_window_set_policy (GTK_WINDOW (window), TRUE, TRUE, FALSE);
5432 gtk_signal_connect (GTK_OBJECT (window), "destroy",
5433 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
5436 gtk_window_set_title (GTK_WINDOW (window), "rulers");
5437 gtk_widget_set_usize (window, 300, 300);
5438 gtk_widget_set_events (window,
5439 GDK_POINTER_MOTION_MASK
5440 | GDK_POINTER_MOTION_HINT_MASK);
5441 gtk_container_border_width (GTK_CONTAINER (window), 0);
5443 table = gtk_table_new (2, 2, FALSE);
5444 gtk_container_add (GTK_CONTAINER (window), table);
5445 gtk_widget_show (table);
5447 ruler = gtk_hruler_new ();
5448 gtk_ruler_set_metric (GTK_RULER (ruler), GTK_CENTIMETERS);
5449 gtk_ruler_set_range (GTK_RULER (ruler), 100, 0, 0, 20);
5451 gtk_signal_connect_object (
5452 GTK_OBJECT (window),
5453 "motion_notify_event",
5455 GTK_WIDGET_CLASS (GTK_OBJECT (ruler)->klass)->motion_notify_event),
5456 GTK_OBJECT (ruler));
5458 gtk_table_attach (GTK_TABLE (table), ruler, 1, 2, 0, 1,
5459 GTK_EXPAND | GTK_FILL, GTK_FILL, 0, 0);
5460 gtk_widget_show (ruler);
5463 ruler = gtk_vruler_new ();
5464 gtk_ruler_set_range (GTK_RULER (ruler), 5, 15, 0, 20);
5466 gtk_signal_connect_object (
5467 GTK_OBJECT (window),
5468 "motion_notify_event",
5469 GTK_SIGNAL_FUNC (GTK_WIDGET_CLASS (GTK_OBJECT (ruler)->klass)->motion_notify_event),
5470 GTK_OBJECT (ruler));
5472 gtk_table_attach (GTK_TABLE (table), ruler, 0, 1, 1, 2,
5473 GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
5474 gtk_widget_show (ruler);
5477 if (!GTK_WIDGET_VISIBLE (window))
5478 gtk_widget_show (window);
5480 gtk_widget_destroy (window);
5484 text_toggle_editable (GtkWidget *checkbutton,
5487 gtk_text_set_editable(GTK_TEXT(text),
5488 GTK_TOGGLE_BUTTON(checkbutton)->active);
5492 text_toggle_word_wrap (GtkWidget *checkbutton,
5495 gtk_text_set_word_wrap(GTK_TEXT(text),
5496 GTK_TOGGLE_BUTTON(checkbutton)->active);
5503 { { 0, 0x0000, 0x0000, 0x0000 }, "black" },
5504 { { 0, 0xFFFF, 0xFFFF, 0xFFFF }, "white" },
5505 { { 0, 0xFFFF, 0x0000, 0x0000 }, "red" },
5506 { { 0, 0x0000, 0xFFFF, 0x0000 }, "green" },
5507 { { 0, 0x0000, 0x0000, 0xFFFF }, "blue" },
5508 { { 0, 0x0000, 0xFFFF, 0xFFFF }, "cyan" },
5509 { { 0, 0xFFFF, 0x0000, 0xFFFF }, "magenta" },
5510 { { 0, 0xFFFF, 0xFFFF, 0x0000 }, "yellow" }
5513 int ntext_colors = sizeof(text_colors) / sizeof(text_colors[0]);
5519 text_insert_random (GtkWidget *w, GtkText *text)
5523 for (i=0; i<10; i++)
5525 c = 'A' + rand() % ('Z' - 'A');
5526 gtk_text_set_point (text, rand() % gtk_text_get_length (text));
5527 gtk_text_insert (text, NULL, NULL, NULL, &c, 1);
5536 static GtkWidget *window = NULL;
5542 GtkWidget *separator;
5544 GtkWidget *hscrollbar;
5545 GtkWidget *vscrollbar;
5553 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
5554 gtk_widget_set_name (window, "text window");
5555 gtk_widget_set_usize (window, 500, 500);
5556 gtk_window_set_policy (GTK_WINDOW(window), TRUE, TRUE, FALSE);
5558 gtk_signal_connect (GTK_OBJECT (window), "destroy",
5559 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
5562 gtk_window_set_title (GTK_WINDOW (window), "test");
5563 gtk_container_border_width (GTK_CONTAINER (window), 0);
5566 box1 = gtk_vbox_new (FALSE, 0);
5567 gtk_container_add (GTK_CONTAINER (window), box1);
5568 gtk_widget_show (box1);
5571 box2 = gtk_vbox_new (FALSE, 10);
5572 gtk_container_border_width (GTK_CONTAINER (box2), 10);
5573 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
5574 gtk_widget_show (box2);
5577 table = gtk_table_new (2, 2, FALSE);
5578 gtk_table_set_row_spacing (GTK_TABLE (table), 0, 2);
5579 gtk_table_set_col_spacing (GTK_TABLE (table), 0, 2);
5580 gtk_box_pack_start (GTK_BOX (box2), table, TRUE, TRUE, 0);
5581 gtk_widget_show (table);
5583 text = gtk_text_new (NULL, NULL);
5584 gtk_text_set_editable (GTK_TEXT (text), TRUE);
5585 gtk_table_attach (GTK_TABLE (table), text, 0, 1, 0, 1,
5586 GTK_EXPAND | GTK_SHRINK | GTK_FILL,
5587 GTK_EXPAND | GTK_SHRINK | GTK_FILL, 0, 0);
5588 gtk_widget_grab_focus (text);
5589 gtk_widget_show (text);
5591 hscrollbar = gtk_hscrollbar_new (GTK_TEXT (text)->hadj);
5592 gtk_table_attach (GTK_TABLE (table), hscrollbar, 0, 1, 1, 2,
5593 GTK_EXPAND | GTK_FILL | GTK_SHRINK, GTK_FILL, 0, 0);
5594 gtk_widget_show (hscrollbar);
5596 vscrollbar = gtk_vscrollbar_new (GTK_TEXT (text)->vadj);
5597 gtk_table_attach (GTK_TABLE (table), vscrollbar, 1, 2, 0, 1,
5598 GTK_FILL, GTK_EXPAND | GTK_SHRINK | GTK_FILL, 0, 0);
5599 gtk_widget_show (vscrollbar);
5601 gtk_text_freeze (GTK_TEXT (text));
5603 font = gdk_font_load ("-adobe-courier-medium-r-normal--*-120-*-*-*-*-*-*");
5605 for (i=0; i<ntext_colors; i++)
5607 gtk_text_insert (GTK_TEXT (text), font, NULL, NULL,
5608 text_colors[i].name, -1);
5609 gtk_text_insert (GTK_TEXT (text), font, NULL, NULL, "\t", -1);
5611 for (j=0; j<ntext_colors; j++)
5613 gtk_text_insert (GTK_TEXT (text), font,
5614 &text_colors[j].color, &text_colors[i].color,
5617 gtk_text_insert (GTK_TEXT (text), NULL, NULL, NULL, "\n", -1);
5620 /* The Text widget will reference count the font, so we
5621 * unreference it here
5623 gdk_font_unref (font);
5625 infile = fopen("testgtk.c", "r");
5634 nchars = fread(buffer, 1, 1024, infile);
5635 gtk_text_insert (GTK_TEXT (text), NULL, NULL,
5636 NULL, buffer, nchars);
5645 gtk_text_thaw (GTK_TEXT (text));
5647 hbox = gtk_hbutton_box_new ();
5648 gtk_box_pack_start (GTK_BOX (box2), hbox, FALSE, FALSE, 0);
5649 gtk_widget_show (hbox);
5651 check = gtk_check_button_new_with_label("Editable");
5652 gtk_box_pack_start (GTK_BOX (hbox), check, FALSE, FALSE, 0);
5653 gtk_signal_connect (GTK_OBJECT(check), "toggled",
5654 GTK_SIGNAL_FUNC(text_toggle_editable), text);
5655 gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(check), TRUE);
5656 gtk_widget_show (check);
5658 check = gtk_check_button_new_with_label("Wrap Words");
5659 gtk_box_pack_start (GTK_BOX (hbox), check, FALSE, TRUE, 0);
5660 gtk_signal_connect (GTK_OBJECT(check), "toggled",
5661 GTK_SIGNAL_FUNC(text_toggle_word_wrap), text);
5662 gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(check), FALSE);
5663 gtk_widget_show (check);
5665 separator = gtk_hseparator_new ();
5666 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
5667 gtk_widget_show (separator);
5670 box2 = gtk_vbox_new (FALSE, 10);
5671 gtk_container_border_width (GTK_CONTAINER (box2), 10);
5672 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
5673 gtk_widget_show (box2);
5676 button = gtk_button_new_with_label ("insert random");
5677 gtk_signal_connect (GTK_OBJECT (button), "clicked",
5678 GTK_SIGNAL_FUNC(text_insert_random),
5680 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
5681 gtk_widget_show (button);
5683 button = gtk_button_new_with_label ("close");
5684 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
5685 GTK_SIGNAL_FUNC(gtk_widget_destroy),
5686 GTK_OBJECT (window));
5687 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
5688 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
5689 gtk_widget_grab_default (button);
5690 gtk_widget_show (button);
5693 if (!GTK_WIDGET_VISIBLE (window))
5694 gtk_widget_show (window);
5696 gtk_widget_destroy (window);
5703 GdkPixmap *book_open;
5704 GdkPixmap *book_closed;
5705 GdkBitmap *book_open_mask;
5706 GdkBitmap *book_closed_mask;
5709 page_switch (GtkWidget *widget, GtkNotebookPage *page, gint page_num)
5711 GtkNotebookPage *oldpage;
5714 oldpage = GTK_NOTEBOOK (widget)->cur_page;
5716 if (page == oldpage)
5719 pixwid = ((GtkBoxChild*)(GTK_BOX (page->tab_label)->children->data))->widget;
5720 gtk_pixmap_set (GTK_PIXMAP (pixwid), book_open, book_open_mask);
5721 pixwid = ((GtkBoxChild*) (GTK_BOX (page->menu_label)->children->data))->widget;
5722 gtk_pixmap_set (GTK_PIXMAP (pixwid), book_open, book_open_mask);
5726 pixwid = ((GtkBoxChild*) (GTK_BOX
5727 (oldpage->tab_label)->children->data))->widget;
5728 gtk_pixmap_set (GTK_PIXMAP (pixwid), book_closed, book_closed_mask);
5729 pixwid = ((GtkBoxChild*) (GTK_BOX (oldpage->menu_label)->children->data))->widget;
5730 gtk_pixmap_set (GTK_PIXMAP (pixwid), book_closed, book_closed_mask);
5735 create_pages (GtkNotebook *notebook, gint start, gint end)
5737 GtkWidget *child = NULL;
5742 GtkWidget *label_box;
5743 GtkWidget *menu_box;
5749 for (i = start; i <= end; i++)
5751 sprintf (buffer, "Page %d", i);
5756 child = gtk_button_new_with_label (buffer);
5757 gtk_container_border_width (GTK_CONTAINER(child), 10);
5760 child = gtk_label_new (buffer);
5763 child = gtk_frame_new (buffer);
5764 gtk_container_border_width (GTK_CONTAINER (child), 10);
5766 box = gtk_vbox_new (TRUE,0);
5767 gtk_container_border_width (GTK_CONTAINER (box), 10);
5768 gtk_container_add (GTK_CONTAINER (child), box);
5770 label = gtk_label_new (buffer);
5771 gtk_box_pack_start (GTK_BOX(box), label, TRUE, TRUE, 5);
5773 entry = gtk_entry_new ();
5774 gtk_box_pack_start (GTK_BOX(box), entry, TRUE, TRUE, 5);
5776 hbox = gtk_hbox_new (TRUE,0);
5777 gtk_box_pack_start (GTK_BOX(box), hbox, TRUE, TRUE, 5);
5779 button = gtk_button_new_with_label ("Ok");
5780 gtk_box_pack_start (GTK_BOX(hbox), button, TRUE, TRUE, 5);
5782 button = gtk_button_new_with_label ("Cancel");
5783 gtk_box_pack_start (GTK_BOX(hbox), button, TRUE, TRUE, 5);
5786 child = gtk_frame_new (buffer);
5787 gtk_container_border_width (GTK_CONTAINER (child), 10);
5789 label = gtk_label_new (buffer);
5790 gtk_container_add (GTK_CONTAINER (child), label);
5794 gtk_widget_show_all (child);
5796 label_box = gtk_hbox_new (FALSE, 0);
5797 pixwid = gtk_pixmap_new (book_closed, book_closed_mask);
5798 gtk_box_pack_start (GTK_BOX (label_box), pixwid, FALSE, TRUE, 0);
5799 gtk_misc_set_padding (GTK_MISC (pixwid), 3, 1);
5800 label = gtk_label_new (buffer);
5801 gtk_box_pack_start (GTK_BOX (label_box), label, FALSE, TRUE, 0);
5802 gtk_widget_show_all (label_box);
5804 menu_box = gtk_hbox_new (FALSE, 0);
5805 pixwid = gtk_pixmap_new (book_closed, book_closed_mask);
5806 gtk_box_pack_start (GTK_BOX (menu_box), pixwid, FALSE, TRUE, 0);
5807 gtk_misc_set_padding (GTK_MISC (pixwid), 3, 1);
5808 label = gtk_label_new (buffer);
5809 gtk_box_pack_start (GTK_BOX (menu_box), label, FALSE, TRUE, 0);
5810 gtk_widget_show_all (menu_box);
5812 gtk_notebook_append_page_menu (notebook, child, label_box, menu_box);
5817 rotate_notebook (GtkButton *button,
5818 GtkNotebook *notebook)
5820 gtk_notebook_set_tab_pos (notebook, (notebook->tab_pos + 1) % 4);
5824 standard_notebook (GtkButton *button,
5825 GtkNotebook *notebook)
5829 gtk_notebook_set_show_tabs (notebook, TRUE);
5830 gtk_notebook_set_scrollable (notebook, FALSE);
5831 if (g_list_length (notebook->children) == 15)
5832 for (i = 0; i < 10; i++)
5833 gtk_notebook_remove_page (notebook, 5);
5837 notabs_notebook (GtkButton *button,
5838 GtkNotebook *notebook)
5842 gtk_notebook_set_show_tabs (notebook, FALSE);
5843 if (g_list_length (notebook->children) == 15)
5844 for (i = 0; i < 10; i++)
5845 gtk_notebook_remove_page (notebook, 5);
5849 scrollable_notebook (GtkButton *button,
5850 GtkNotebook *notebook)
5852 gtk_notebook_set_show_tabs (notebook, TRUE);
5853 gtk_notebook_set_scrollable (notebook, TRUE);
5854 if (g_list_length (notebook->children) == 5)
5855 create_pages (notebook, 6, 15);
5859 notebook_popup (GtkToggleButton *button,
5860 GtkNotebook *notebook)
5863 gtk_notebook_popup_enable (notebook);
5865 gtk_notebook_popup_disable (notebook);
5869 create_notebook (void)
5871 static GtkWidget *window = NULL;
5875 GtkWidget *separator;
5876 GtkWidget *notebook;
5878 GdkColor *transparent = NULL;
5880 static OptionMenuItem items[] =
5882 { "Standard", standard_notebook },
5883 { "No tabs", notabs_notebook },
5884 { "Scrollable", scrollable_notebook }
5889 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
5891 gtk_signal_connect (GTK_OBJECT (window), "destroy",
5892 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
5895 gtk_window_set_title (GTK_WINDOW (window), "notebook");
5896 gtk_container_border_width (GTK_CONTAINER (window), 0);
5898 box1 = gtk_vbox_new (FALSE, 0);
5899 gtk_container_add (GTK_CONTAINER (window), box1);
5901 notebook = gtk_notebook_new ();
5902 gtk_signal_connect (GTK_OBJECT (notebook), "switch_page",
5903 GTK_SIGNAL_FUNC (page_switch), NULL);
5904 gtk_notebook_set_tab_pos (GTK_NOTEBOOK (notebook), GTK_POS_TOP);
5905 gtk_box_pack_start (GTK_BOX (box1), notebook, TRUE, TRUE, 0);
5906 gtk_container_border_width (GTK_CONTAINER (notebook), 10);
5908 gtk_widget_realize (notebook);
5909 book_open = gdk_pixmap_create_from_xpm_d (notebook->window,
5913 book_closed = gdk_pixmap_create_from_xpm_d (notebook->window,
5918 create_pages (GTK_NOTEBOOK (notebook), 1, 5);
5920 separator = gtk_hseparator_new ();
5921 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 10);
5923 box2 = gtk_hbox_new (TRUE, 5);
5924 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
5926 omenu = build_option_menu (items, 3, 0, notebook);
5927 gtk_box_pack_start (GTK_BOX (box2), omenu, FALSE, FALSE, 0);
5929 button = gtk_check_button_new_with_label ("enable popup menu");
5930 gtk_box_pack_start (GTK_BOX (box2), button, FALSE, FALSE, 0);
5931 gtk_signal_connect (GTK_OBJECT(button), "clicked",
5932 GTK_SIGNAL_FUNC (notebook_popup),
5933 GTK_OBJECT (notebook));
5935 box2 = gtk_hbox_new (TRUE, 10);
5936 gtk_container_border_width (GTK_CONTAINER (box2), 10);
5937 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
5939 button = gtk_button_new_with_label ("close");
5940 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
5941 GTK_SIGNAL_FUNC (gtk_widget_destroy),
5942 GTK_OBJECT (window));
5943 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
5944 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
5945 gtk_widget_grab_default (button);
5947 button = gtk_button_new_with_label ("next");
5948 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
5949 GTK_SIGNAL_FUNC (gtk_notebook_next_page),
5950 GTK_OBJECT (notebook));
5951 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
5952 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
5954 button = gtk_button_new_with_label ("prev");
5955 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
5956 GTK_SIGNAL_FUNC (gtk_notebook_prev_page),
5957 GTK_OBJECT (notebook));
5958 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
5959 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
5961 button = gtk_button_new_with_label ("rotate");
5962 gtk_signal_connect (GTK_OBJECT (button), "clicked",
5963 GTK_SIGNAL_FUNC (rotate_notebook),
5965 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
5966 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
5969 if (!GTK_WIDGET_VISIBLE (window))
5970 gtk_widget_show_all (window);
5972 gtk_widget_destroy (window);
5982 static GtkWidget *window = NULL;
5990 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
5992 gtk_signal_connect (GTK_OBJECT (window), "destroy",
5993 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
5996 gtk_window_set_title (GTK_WINDOW (window), "Panes");
5997 gtk_container_border_width (GTK_CONTAINER (window), 0);
5999 vpaned = gtk_vpaned_new ();
6000 gtk_container_add (GTK_CONTAINER (window), vpaned);
6001 gtk_container_border_width (GTK_CONTAINER(vpaned), 5);
6002 gtk_widget_show (vpaned);
6004 hpaned = gtk_hpaned_new ();
6005 gtk_paned_add1 (GTK_PANED (vpaned), hpaned);
6007 frame = gtk_frame_new (NULL);
6008 gtk_frame_set_shadow_type (GTK_FRAME(frame), GTK_SHADOW_IN);
6009 gtk_widget_set_usize (frame, 60, 60);
6010 gtk_paned_add1 (GTK_PANED (hpaned), frame);
6011 gtk_widget_show (frame);
6013 button = gtk_button_new_with_label ("Hi there");
6014 gtk_container_add (GTK_CONTAINER(frame), button);
6015 gtk_widget_show (button);
6017 frame = gtk_frame_new (NULL);
6018 gtk_frame_set_shadow_type (GTK_FRAME(frame), GTK_SHADOW_IN);
6019 gtk_widget_set_usize (frame, 80, 60);
6020 gtk_paned_add2 (GTK_PANED (hpaned), frame);
6021 gtk_widget_show (frame);
6023 gtk_widget_show (hpaned);
6025 frame = gtk_frame_new (NULL);
6026 gtk_frame_set_shadow_type (GTK_FRAME(frame), GTK_SHADOW_IN);
6027 gtk_widget_set_usize (frame, 60, 80);
6028 gtk_paned_add2 (GTK_PANED (vpaned), frame);
6029 gtk_widget_show (frame);
6032 if (!GTK_WIDGET_VISIBLE (window))
6033 gtk_widget_show (window);
6035 gtk_widget_destroy (window);
6043 dnd_drop_destroy_popup (GtkWidget *widget, GtkWindow **window)
6045 if(GTK_IS_BUTTON(widget)) /* I.e. they clicked the close button */
6046 gtk_widget_destroy(GTK_WIDGET(*window));
6048 gtk_grab_remove(GTK_WIDGET(*window));
6056 dnd_drop (GtkWidget *button, GdkEvent *event)
6058 static GtkWidget *window = NULL;
6059 GtkWidget *vbox, *lbl, *btn;
6062 /* DND doesn't obey gtk_grab's, so check if we're already displaying
6063 * drop modal dialog first
6068 window = gtk_window_new(GTK_WINDOW_DIALOG);
6069 gtk_container_border_width (GTK_CONTAINER(window), 10);
6071 gtk_signal_connect (GTK_OBJECT (window), "destroy",
6072 GTK_SIGNAL_FUNC(dnd_drop_destroy_popup),
6074 gtk_signal_connect (GTK_OBJECT (window), "delete-event",
6075 GTK_SIGNAL_FUNC(gtk_false),
6078 vbox = gtk_vbox_new(FALSE, 5);
6080 /* Display message that we got from drop source */
6081 msg = g_malloc(strlen(event->dropdataavailable.data)
6082 + strlen(event->dropdataavailable.data_type) + 100);
6083 sprintf(msg, "Drop data of type %s was:\n\n%s",
6084 event->dropdataavailable.data_type,
6085 (char *)event->dropdataavailable.data);
6086 lbl = gtk_label_new(msg);
6087 gtk_label_set_justify(GTK_LABEL(lbl), GTK_JUSTIFY_FILL);
6089 gtk_widget_show(lbl);
6090 gtk_box_pack_start_defaults(GTK_BOX(vbox), lbl);
6092 /* Provide an obvious way out of this heinousness */
6093 btn = gtk_button_new_with_label("Continue with life in\nspite of this oppression");
6094 gtk_signal_connect_object (GTK_OBJECT (btn), "clicked",
6095 GTK_SIGNAL_FUNC(gtk_widget_destroy),
6096 GTK_OBJECT (window));
6097 gtk_widget_show(btn);
6098 gtk_box_pack_start_defaults(GTK_BOX(vbox), btn);
6100 gtk_container_add(GTK_CONTAINER(window), vbox);
6102 gtk_widget_show(vbox);
6103 gtk_grab_add(window);
6104 gtk_widget_show(window);
6108 dnd_drag_request (GtkWidget *button, GdkEvent *event)
6110 #define DND_STRING "Bill Gates demands royalties for\nyour use of his innovation."
6111 gtk_widget_dnd_data_set (button, event, DND_STRING, strlen(DND_STRING) + 1);
6117 static GtkWidget *window = NULL;
6123 GtkWidget *separator;
6125 /* For clarity... */
6126 char *possible_drag_types[] = {"text/plain"};
6127 char *accepted_drop_types[] = {"text/plain"};
6129 static GtkWidget *drag_icon = NULL;
6130 static GtkWidget *drop_icon = NULL;
6134 GdkPoint hotspot = {5,5};
6138 drag_icon = shape_create_icon ("Modeller.xpm",
6139 440, 140, 0,0, GTK_WINDOW_POPUP);
6141 gtk_signal_connect (GTK_OBJECT (drag_icon), "destroy",
6142 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
6145 gtk_widget_hide (drag_icon);
6150 drop_icon = shape_create_icon ("3DRings.xpm",
6151 440, 140, 0,0, GTK_WINDOW_POPUP);
6153 gtk_signal_connect (GTK_OBJECT (drop_icon), "destroy",
6154 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
6157 gtk_widget_hide (drop_icon);
6160 gdk_dnd_set_drag_shape(drag_icon->window,
6165 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
6167 gtk_signal_connect (GTK_OBJECT (window), "destroy",
6168 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
6171 gtk_window_set_title (GTK_WINDOW (window), "Drag -N- Drop");
6172 gtk_container_border_width (GTK_CONTAINER (window), 0);
6174 box1 = gtk_vbox_new (FALSE, 0);
6175 gtk_container_add (GTK_CONTAINER (window), box1);
6176 gtk_widget_show (box1);
6178 box2 = gtk_hbox_new (FALSE, 5);
6179 gtk_container_border_width (GTK_CONTAINER (box2), 10);
6180 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
6181 gtk_widget_show (box2);
6183 frame = gtk_frame_new ("Drag");
6184 gtk_box_pack_start (GTK_BOX (box2), frame, TRUE, TRUE, 0);
6185 gtk_widget_show (frame);
6187 box3 = gtk_vbox_new (FALSE, 5);
6188 gtk_container_border_width (GTK_CONTAINER (box3), 5);
6189 gtk_container_add (GTK_CONTAINER (frame), box3);
6190 gtk_widget_show (box3);
6195 button = gtk_button_new_with_label ("Drag me!");
6196 gtk_box_pack_start (GTK_BOX (box3), button, FALSE, TRUE, 0);
6197 gtk_widget_show (button);
6200 * currently, the widget has to be realized to
6201 * set dnd on it, this needs to change
6203 gtk_widget_realize (button);
6204 gtk_signal_connect (GTK_OBJECT (button),
6205 "drag_request_event",
6206 GTK_SIGNAL_FUNC(dnd_drag_request),
6209 gtk_widget_dnd_drag_set (button, TRUE, possible_drag_types, 1);
6212 frame = gtk_frame_new ("Drop");
6213 gtk_box_pack_start (GTK_BOX (box2), frame, TRUE, TRUE, 0);
6214 gtk_widget_show (frame);
6216 box3 = gtk_vbox_new (FALSE, 5);
6217 gtk_container_border_width (GTK_CONTAINER (box3), 5);
6218 gtk_container_add (GTK_CONTAINER (frame), box3);
6219 gtk_widget_show (box3);
6225 button = gtk_button_new_with_label ("To");
6226 gtk_box_pack_start (GTK_BOX (box3), button, FALSE, TRUE, 0);
6227 gtk_widget_show (button);
6229 gtk_widget_realize (button);
6230 gtk_signal_connect (GTK_OBJECT (button),
6231 "drop_data_available_event",
6232 GTK_SIGNAL_FUNC(dnd_drop),
6235 gtk_widget_dnd_drop_set (button, TRUE, accepted_drop_types, 1, FALSE);
6238 separator = gtk_hseparator_new ();
6239 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
6240 gtk_widget_show (separator);
6243 box2 = gtk_vbox_new (FALSE, 10);
6244 gtk_container_border_width (GTK_CONTAINER (box2), 10);
6245 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
6246 gtk_widget_show (box2);
6249 button = gtk_button_new_with_label ("close");
6251 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
6252 GTK_SIGNAL_FUNC(gtk_widget_destroy),
6253 GTK_OBJECT (window));
6255 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
6256 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
6257 gtk_widget_grab_default (button);
6258 gtk_widget_show (button);
6261 if (!GTK_WIDGET_VISIBLE (window))
6262 gtk_widget_show (window);
6264 gtk_widget_destroy (window);
6271 static GdkWindow *root_win = NULL;
6273 typedef struct _cursoroffset {gint x,y;} CursorOffset;
6276 shape_pressed (GtkWidget *widget, GdkEventButton *event)
6280 /* ignore double and triple click */
6281 if (event->type != GDK_BUTTON_PRESS)
6284 p = gtk_object_get_user_data (GTK_OBJECT(widget));
6285 p->x = (int) event->x;
6286 p->y = (int) event->y;
6288 gtk_grab_add (widget);
6289 gdk_pointer_grab (widget->window, TRUE,
6290 GDK_BUTTON_RELEASE_MASK |
6291 GDK_BUTTON_MOTION_MASK |
6292 GDK_POINTER_MOTION_HINT_MASK,
6297 shape_released (GtkWidget *widget)
6299 gtk_grab_remove (widget);
6300 gdk_pointer_ungrab (0);
6304 shape_motion (GtkWidget *widget,
6305 GdkEventMotion *event)
6309 GdkModifierType mask;
6311 p = gtk_object_get_user_data (GTK_OBJECT (widget));
6314 * Can't use event->x / event->y here
6315 * because I need absolute coordinates.
6317 gdk_window_get_pointer (root_win, &xp, &yp, &mask);
6318 gtk_widget_set_uposition (widget, xp - p->x, yp - p->y);
6322 shape_create_icon (char *xpm_file,
6332 CursorOffset* icon_pos;
6334 GdkBitmap *gdk_pixmap_mask;
6335 GdkPixmap *gdk_pixmap;
6338 style = gtk_widget_get_default_style ();
6339 gc = style->black_gc;
6342 * GDK_WINDOW_TOPLEVEL works also, giving you a title border
6344 window = gtk_window_new (window_type);
6346 fixed = gtk_fixed_new ();
6347 gtk_widget_set_usize (fixed, 100,100);
6348 gtk_container_add (GTK_CONTAINER (window), fixed);
6349 gtk_widget_show (fixed);
6351 gtk_widget_set_events (window,
6352 gtk_widget_get_events (window) |
6353 GDK_BUTTON_MOTION_MASK |
6354 GDK_POINTER_MOTION_HINT_MASK |
6355 GDK_BUTTON_PRESS_MASK);
6357 gtk_widget_realize (window);
6358 gdk_pixmap = gdk_pixmap_create_from_xpm (window->window, &gdk_pixmap_mask,
6359 &style->bg[GTK_STATE_NORMAL],
6362 pixmap = gtk_pixmap_new (gdk_pixmap, gdk_pixmap_mask);
6363 gtk_fixed_put (GTK_FIXED (fixed), pixmap, px,py);
6364 gtk_widget_show (pixmap);
6366 gtk_widget_shape_combine_mask (window, gdk_pixmap_mask, px,py);
6369 gtk_signal_connect (GTK_OBJECT (window), "button_press_event",
6370 GTK_SIGNAL_FUNC (shape_pressed),NULL);
6371 gtk_signal_connect (GTK_OBJECT (window), "button_release_event",
6372 GTK_SIGNAL_FUNC (shape_released),NULL);
6373 gtk_signal_connect (GTK_OBJECT (window), "motion_notify_event",
6374 GTK_SIGNAL_FUNC (shape_motion),NULL);
6376 icon_pos = g_new (CursorOffset, 1);
6377 gtk_object_set_user_data(GTK_OBJECT(window), icon_pos);
6379 gtk_widget_set_uposition (window, x, y);
6380 gtk_widget_show (window);
6386 create_shapes (void)
6388 /* Variables used by the Drag/Drop and Shape Window demos */
6389 static GtkWidget *modeller = NULL;
6390 static GtkWidget *sheets = NULL;
6391 static GtkWidget *rings = NULL;
6393 root_win = gdk_window_foreign_new (GDK_ROOT_WINDOW ());
6397 modeller = shape_create_icon ("Modeller.xpm",
6398 440, 140, 0,0, GTK_WINDOW_POPUP);
6400 gtk_signal_connect (GTK_OBJECT (modeller), "destroy",
6401 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
6405 gtk_widget_destroy (modeller);
6409 sheets = shape_create_icon ("FilesQueue.xpm",
6410 580, 170, 0,0, GTK_WINDOW_POPUP);
6412 gtk_signal_connect (GTK_OBJECT (sheets), "destroy",
6413 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
6418 gtk_widget_destroy (sheets);
6422 rings = shape_create_icon ("3DRings.xpm",
6423 460, 270, 25,25, GTK_WINDOW_TOPLEVEL);
6425 gtk_signal_connect (GTK_OBJECT (rings), "destroy",
6426 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
6430 gtk_widget_destroy (rings);
6438 create_wmhints (void)
6440 static GtkWidget *window = NULL;
6442 GtkWidget *separator;
6451 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
6453 gtk_signal_connect (GTK_OBJECT (window), "destroy",
6454 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
6457 gtk_window_set_title (GTK_WINDOW (window), "WM Hints");
6458 gtk_container_border_width (GTK_CONTAINER (window), 0);
6460 gtk_widget_realize (window);
6462 circles = gdk_bitmap_create_from_data (window->window,
6466 gdk_window_set_icon (window->window, NULL,
6469 gdk_window_set_icon_name (window->window, "WMHints Test Icon");
6471 gdk_window_set_decorations (window->window, GDK_DECOR_ALL | GDK_DECOR_MENU);
6472 gdk_window_set_functions (window->window, GDK_FUNC_ALL | GDK_FUNC_RESIZE);
6474 box1 = gtk_vbox_new (FALSE, 0);
6475 gtk_container_add (GTK_CONTAINER (window), box1);
6476 gtk_widget_show (box1);
6478 label = gtk_label_new ("Try iconizing me!");
6479 gtk_widget_set_usize (label, 150, 50);
6480 gtk_box_pack_start (GTK_BOX (box1), label, TRUE, TRUE, 0);
6481 gtk_widget_show (label);
6484 separator = gtk_hseparator_new ();
6485 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
6486 gtk_widget_show (separator);
6489 box2 = gtk_vbox_new (FALSE, 10);
6490 gtk_container_border_width (GTK_CONTAINER (box2), 10);
6491 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
6492 gtk_widget_show (box2);
6495 button = gtk_button_new_with_label ("close");
6497 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
6498 GTK_SIGNAL_FUNC(gtk_widget_destroy),
6499 GTK_OBJECT (window));
6501 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
6502 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
6503 gtk_widget_grab_default (button);
6504 gtk_widget_show (button);
6507 if (!GTK_WIDGET_VISIBLE (window))
6508 gtk_widget_show (window);
6510 gtk_widget_destroy (window);
6517 typedef struct _ProgressData {
6520 GtkWidget *block_spin;
6521 GtkWidget *x_align_spin;
6522 GtkWidget *y_align_spin;
6523 GtkWidget *step_spin;
6524 GtkWidget *act_blocks_spin;
6533 progress_timeout (gpointer data)
6538 adj = GTK_PROGRESS (data)->adjustment;
6540 new_val = adj->value + 1;
6541 if (new_val > adj->upper)
6542 new_val = adj->lower;
6544 gtk_progress_set_value (GTK_PROGRESS (data), new_val);
6550 destroy_progress (GtkWidget *widget,
6551 ProgressData **pdata)
6553 gtk_timeout_remove ((*pdata)->timer);
6554 (*pdata)->timer = 0;
6555 (*pdata)->window = NULL;
6561 progressbar_toggle_orientation (GtkWidget *widget, ProgressData *pdata)
6565 if (!GTK_WIDGET_MAPPED (widget))
6568 RADIOMENUTOGGLED ((GtkRadioMenuItem *)
6569 (((GtkOptionMenu *)(pdata->omenu1))->menu_item), i);
6571 gtk_progress_bar_set_orientation (GTK_PROGRESS_BAR (pdata->pbar),
6572 (GtkProgressBarOrientation) (3-i));
6576 toggle_show_text (GtkWidget *widget, ProgressData *pdata)
6578 gtk_progress_set_show_text (GTK_PROGRESS (pdata->pbar),
6579 GTK_TOGGLE_BUTTON (widget)->active);
6580 gtk_widget_set_sensitive (pdata->entry, GTK_TOGGLE_BUTTON (widget)->active);
6581 gtk_widget_set_sensitive (pdata->x_align_spin,
6582 GTK_TOGGLE_BUTTON (widget)->active);
6583 gtk_widget_set_sensitive (pdata->y_align_spin,
6584 GTK_TOGGLE_BUTTON (widget)->active);
6588 progressbar_toggle_bar_style (GtkWidget *widget, ProgressData *pdata)
6592 if (!GTK_WIDGET_MAPPED (widget))
6595 RADIOMENUTOGGLED ((GtkRadioMenuItem *)
6596 (((GtkOptionMenu *)(pdata->omenu2))->menu_item), i);
6601 gtk_widget_set_sensitive (pdata->block_spin, TRUE);
6603 gtk_widget_set_sensitive (pdata->block_spin, FALSE);
6605 gtk_progress_bar_set_bar_style (GTK_PROGRESS_BAR (pdata->pbar),
6606 (GtkProgressBarStyle) i);
6610 progress_value_changed (GtkAdjustment *adj, ProgressData *pdata)
6614 if (GTK_PROGRESS (pdata->pbar)->activity_mode)
6615 sprintf (buf, "???");
6617 sprintf (buf, "%.0f%%", 100 *
6618 gtk_progress_get_current_percentage (GTK_PROGRESS (pdata->pbar)));
6619 gtk_label_set (GTK_LABEL (pdata->label), buf);
6623 adjust_blocks (GtkAdjustment *adj, ProgressData *pdata)
6625 gtk_progress_set_percentage (GTK_PROGRESS (pdata->pbar), 0);
6626 gtk_progress_bar_set_discrete_blocks (GTK_PROGRESS_BAR (pdata->pbar),
6627 gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (pdata->block_spin)));
6631 adjust_step (GtkAdjustment *adj, ProgressData *pdata)
6633 gtk_progress_bar_set_activity_step (GTK_PROGRESS_BAR (pdata->pbar),
6634 gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (pdata->step_spin)));
6638 adjust_act_blocks (GtkAdjustment *adj, ProgressData *pdata)
6640 gtk_progress_bar_set_activity_blocks (GTK_PROGRESS_BAR (pdata->pbar),
6641 gtk_spin_button_get_value_as_int
6642 (GTK_SPIN_BUTTON (pdata->act_blocks_spin)));
6646 adjust_align (GtkAdjustment *adj, ProgressData *pdata)
6648 gtk_progress_set_text_alignment (GTK_PROGRESS (pdata->pbar),
6649 gtk_spin_button_get_value_as_float
6650 (GTK_SPIN_BUTTON (pdata->x_align_spin)),
6651 gtk_spin_button_get_value_as_float
6652 (GTK_SPIN_BUTTON (pdata->y_align_spin)));
6656 toggle_activity_mode (GtkWidget *widget, ProgressData *pdata)
6658 gtk_progress_set_activity_mode (GTK_PROGRESS (pdata->pbar),
6659 GTK_TOGGLE_BUTTON (widget)->active);
6660 gtk_widget_set_sensitive (pdata->step_spin,
6661 GTK_TOGGLE_BUTTON (widget)->active);
6662 gtk_widget_set_sensitive (pdata->act_blocks_spin,
6663 GTK_TOGGLE_BUTTON (widget)->active);
6667 entry_changed (GtkWidget *widget, ProgressData *pdata)
6669 gtk_progress_set_format_string (GTK_PROGRESS (pdata->pbar),
6670 gtk_entry_get_text (GTK_ENTRY (pdata->entry)));
6674 create_progress_bar (void)
6686 static ProgressData *pdata = NULL;
6688 static OptionMenuItem items1[] =
6690 { "Left-Right", progressbar_toggle_orientation },
6691 { "Right-Left", progressbar_toggle_orientation },
6692 { "Bottom-Top", progressbar_toggle_orientation },
6693 { "Top-Bottom", progressbar_toggle_orientation }
6696 static OptionMenuItem items2[] =
6698 { "Continuous", progressbar_toggle_bar_style },
6699 { "Discrete", progressbar_toggle_bar_style }
6703 pdata = g_new0 (ProgressData, 1);
6707 pdata->window = gtk_dialog_new ();
6709 gtk_window_set_policy (GTK_WINDOW (pdata->window), FALSE, FALSE, TRUE);
6711 gtk_signal_connect (GTK_OBJECT (pdata->window), "destroy",
6712 GTK_SIGNAL_FUNC (destroy_progress),
6717 gtk_window_set_title (GTK_WINDOW (pdata->window), "GtkProgressBar");
6718 gtk_container_border_width (GTK_CONTAINER (pdata->window), 0);
6720 vbox = gtk_vbox_new (FALSE, 5);
6721 gtk_container_border_width (GTK_CONTAINER (vbox), 10);
6722 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (pdata->window)->vbox),
6723 vbox, FALSE, TRUE, 0);
6725 frame = gtk_frame_new ("Progress");
6726 gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, TRUE, 0);
6728 vbox2 = gtk_vbox_new (FALSE, 5);
6729 gtk_container_add (GTK_CONTAINER (frame), vbox2);
6731 align = gtk_alignment_new (0.5, 0.5, 0, 0);
6732 gtk_box_pack_start (GTK_BOX (vbox2), align, FALSE, FALSE, 5);
6734 adj = (GtkAdjustment *) gtk_adjustment_new (0, 1, 300, 0, 0, 0);
6735 gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
6736 GTK_SIGNAL_FUNC (progress_value_changed), pdata);
6738 pdata->pbar = gtk_progress_bar_new_with_adjustment (adj);
6739 gtk_progress_set_format_string (GTK_PROGRESS (pdata->pbar),
6740 "%v from [%l,%u] (=%p%%)");
6741 gtk_container_add (GTK_CONTAINER (align), pdata->pbar);
6742 pdata->timer = gtk_timeout_add (100, progress_timeout, pdata->pbar);
6744 align = gtk_alignment_new (0.5, 0.5, 0, 0);
6745 gtk_box_pack_start (GTK_BOX (vbox2), align, FALSE, FALSE, 5);
6747 hbox = gtk_hbox_new (FALSE, 5);
6748 gtk_container_add (GTK_CONTAINER (align), hbox);
6749 label = gtk_label_new ("Label updated by user :");
6750 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
6751 pdata->label = gtk_label_new ("");
6752 gtk_box_pack_start (GTK_BOX (hbox), pdata->label, FALSE, TRUE, 0);
6754 frame = gtk_frame_new ("Options");
6755 gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, TRUE, 0);
6757 vbox2 = gtk_vbox_new (FALSE, 5);
6758 gtk_container_add (GTK_CONTAINER (frame), vbox2);
6760 tab = gtk_table_new (7, 2, FALSE);
6761 gtk_box_pack_start (GTK_BOX (vbox2), tab, FALSE, TRUE, 0);
6763 label = gtk_label_new ("Orientation :");
6764 gtk_table_attach (GTK_TABLE (tab), label, 0, 1, 0, 1,
6765 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
6767 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
6769 pdata->omenu1 = build_option_menu (items1, 4, 0, pdata);
6770 hbox = gtk_hbox_new (FALSE, 0);
6771 gtk_table_attach (GTK_TABLE (tab), hbox, 1, 2, 0, 1,
6772 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
6774 gtk_box_pack_start (GTK_BOX (hbox), pdata->omenu1, TRUE, TRUE, 0);
6776 check = gtk_check_button_new_with_label ("Show text");
6777 gtk_signal_connect (GTK_OBJECT (check), "clicked",
6778 GTK_SIGNAL_FUNC (toggle_show_text),
6780 gtk_table_attach (GTK_TABLE (tab), check, 0, 1, 1, 2,
6781 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
6784 hbox = gtk_hbox_new (FALSE, 0);
6785 gtk_table_attach (GTK_TABLE (tab), hbox, 1, 2, 1, 2,
6786 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
6789 label = gtk_label_new ("Format : ");
6790 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
6792 pdata->entry = gtk_entry_new ();
6793 gtk_signal_connect (GTK_OBJECT (pdata->entry), "changed",
6794 GTK_SIGNAL_FUNC (entry_changed),
6796 gtk_box_pack_start (GTK_BOX (hbox), pdata->entry, TRUE, TRUE, 0);
6797 gtk_entry_set_text (GTK_ENTRY (pdata->entry), "%v from [%l,%u] (=%p%%)");
6798 gtk_widget_set_usize (pdata->entry, 100, -1);
6799 gtk_widget_set_sensitive (pdata->entry, FALSE);
6801 label = gtk_label_new ("Text align :");
6802 gtk_table_attach (GTK_TABLE (tab), label, 0, 1, 2, 3,
6803 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
6805 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
6807 hbox = gtk_hbox_new (FALSE, 0);
6808 gtk_table_attach (GTK_TABLE (tab), hbox, 1, 2, 2, 3,
6809 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
6812 label = gtk_label_new ("x :");
6813 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 5);
6815 adj = (GtkAdjustment *) gtk_adjustment_new (0.5, 0, 1, 0.1, 0.1, 0);
6816 pdata->x_align_spin = gtk_spin_button_new (adj, 0, 1);
6817 gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
6818 GTK_SIGNAL_FUNC (adjust_align), pdata);
6819 gtk_box_pack_start (GTK_BOX (hbox), pdata->x_align_spin, FALSE, TRUE, 0);
6820 gtk_widget_set_sensitive (pdata->x_align_spin, FALSE);
6822 label = gtk_label_new ("y :");
6823 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 5);
6825 adj = (GtkAdjustment *) gtk_adjustment_new (0.5, 0, 1, 0.1, 0.1, 0);
6826 pdata->y_align_spin = gtk_spin_button_new (adj, 0, 1);
6827 gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
6828 GTK_SIGNAL_FUNC (adjust_align), pdata);
6829 gtk_box_pack_start (GTK_BOX (hbox), pdata->y_align_spin, FALSE, TRUE, 0);
6830 gtk_widget_set_sensitive (pdata->y_align_spin, FALSE);
6832 label = gtk_label_new ("Bar Style :");
6833 gtk_table_attach (GTK_TABLE (tab), label, 0, 1, 3, 4,
6834 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
6836 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
6838 pdata->omenu2 = build_option_menu (items2, 2, 0, pdata);
6839 hbox = gtk_hbox_new (FALSE, 0);
6840 gtk_table_attach (GTK_TABLE (tab), hbox, 1, 2, 3, 4,
6841 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
6843 gtk_box_pack_start (GTK_BOX (hbox), pdata->omenu2, TRUE, TRUE, 0);
6845 label = gtk_label_new ("Block count :");
6846 gtk_table_attach (GTK_TABLE (tab), label, 0, 1, 4, 5,
6847 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
6849 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
6851 hbox = gtk_hbox_new (FALSE, 0);
6852 gtk_table_attach (GTK_TABLE (tab), hbox, 1, 2, 4, 5,
6853 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
6855 adj = (GtkAdjustment *) gtk_adjustment_new (10, 2, 20, 1, 5, 0);
6856 pdata->block_spin = gtk_spin_button_new (adj, 0, 0);
6857 gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
6858 GTK_SIGNAL_FUNC (adjust_blocks), pdata);
6859 gtk_box_pack_start (GTK_BOX (hbox), pdata->block_spin, FALSE, TRUE, 0);
6860 gtk_widget_set_sensitive (pdata->block_spin, FALSE);
6862 check = gtk_check_button_new_with_label ("Activity mode");
6863 gtk_signal_connect (GTK_OBJECT (check), "clicked",
6864 GTK_SIGNAL_FUNC (toggle_activity_mode),
6866 gtk_table_attach (GTK_TABLE (tab), check, 0, 1, 5, 6,
6867 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
6870 hbox = gtk_hbox_new (FALSE, 0);
6871 gtk_table_attach (GTK_TABLE (tab), hbox, 1, 2, 5, 6,
6872 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
6874 label = gtk_label_new ("Step size : ");
6875 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
6876 adj = (GtkAdjustment *) gtk_adjustment_new (3, 1, 20, 1, 5, 0);
6877 pdata->step_spin = gtk_spin_button_new (adj, 0, 0);
6878 gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
6879 GTK_SIGNAL_FUNC (adjust_step), pdata);
6880 gtk_box_pack_start (GTK_BOX (hbox), pdata->step_spin, FALSE, TRUE, 0);
6881 gtk_widget_set_sensitive (pdata->step_spin, FALSE);
6883 hbox = gtk_hbox_new (FALSE, 0);
6884 gtk_table_attach (GTK_TABLE (tab), hbox, 1, 2, 6, 7,
6885 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
6887 label = gtk_label_new ("Blocks : ");
6888 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
6889 adj = (GtkAdjustment *) gtk_adjustment_new (5, 2, 10, 1, 5, 0);
6890 pdata->act_blocks_spin = gtk_spin_button_new (adj, 0, 0);
6891 gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
6892 GTK_SIGNAL_FUNC (adjust_act_blocks), pdata);
6893 gtk_box_pack_start (GTK_BOX (hbox), pdata->act_blocks_spin, FALSE, TRUE,
6895 gtk_widget_set_sensitive (pdata->act_blocks_spin, FALSE);
6897 button = gtk_button_new_with_label ("close");
6898 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
6899 GTK_SIGNAL_FUNC (gtk_widget_destroy),
6900 GTK_OBJECT (pdata->window));
6901 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
6902 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (pdata->window)->action_area),
6903 button, TRUE, TRUE, 0);
6904 gtk_widget_grab_default (button);
6907 if (!GTK_WIDGET_VISIBLE (pdata->window))
6908 gtk_widget_show_all (pdata->window);
6910 gtk_widget_destroy (pdata->window);
6917 static int color_idle = 0;
6920 color_idle_func (GtkWidget *preview)
6922 static int count = 1;
6926 for (i = 0; i < 256; i++)
6928 for (j = 0, k = 0; j < 256; j++)
6930 buf[k+0] = i + count;
6932 buf[k+2] = j + count;
6936 gtk_preview_draw_row (GTK_PREVIEW (preview), buf, 0, i, 256);
6941 gtk_widget_draw (preview, NULL);
6947 color_preview_destroy (GtkWidget *widget,
6950 gtk_idle_remove (color_idle);
6957 create_color_preview (void)
6959 static GtkWidget *window = NULL;
6966 gtk_widget_push_visual (gdk_rgb_get_visual ());
6967 gtk_widget_push_colormap (gdk_rgb_get_cmap ());
6968 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
6969 gtk_widget_pop_colormap ();
6970 gtk_widget_pop_visual ();
6972 gtk_signal_connect (GTK_OBJECT (window), "destroy",
6973 GTK_SIGNAL_FUNC(color_preview_destroy),
6976 gtk_window_set_title (GTK_WINDOW (window), "test");
6977 gtk_container_border_width (GTK_CONTAINER (window), 10);
6979 preview = gtk_preview_new (GTK_PREVIEW_COLOR);
6980 gtk_preview_size (GTK_PREVIEW (preview), 256, 256);
6981 gtk_container_add (GTK_CONTAINER (window), preview);
6983 for (i = 0; i < 256; i++)
6985 for (j = 0, k = 0; j < 256; j++)
6993 gtk_preview_draw_row (GTK_PREVIEW (preview), buf, 0, i, 256);
6996 color_idle = gtk_idle_add ((GtkFunction) color_idle_func, preview);
6999 if (!GTK_WIDGET_VISIBLE (window))
7000 gtk_widget_show_all (window);
7002 gtk_widget_destroy (window);
7009 static int gray_idle = 0;
7012 gray_idle_func (GtkWidget *preview)
7014 static int count = 1;
7018 for (i = 0; i < 256; i++)
7020 for (j = 0; j < 256; j++)
7021 buf[j] = i + j + count;
7023 gtk_preview_draw_row (GTK_PREVIEW (preview), buf, 0, i, 256);
7028 gtk_widget_draw (preview, NULL);
7034 gray_preview_destroy (GtkWidget *widget,
7037 gtk_idle_remove (gray_idle);
7044 create_gray_preview (void)
7046 static GtkWidget *window = NULL;
7053 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
7055 gtk_signal_connect (GTK_OBJECT (window), "destroy",
7056 GTK_SIGNAL_FUNC(gray_preview_destroy),
7059 gtk_window_set_title (GTK_WINDOW (window), "test");
7060 gtk_container_border_width (GTK_CONTAINER (window), 10);
7062 preview = gtk_preview_new (GTK_PREVIEW_GRAYSCALE);
7063 gtk_preview_size (GTK_PREVIEW (preview), 256, 256);
7064 gtk_container_add (GTK_CONTAINER (window), preview);
7066 for (i = 0; i < 256; i++)
7068 for (j = 0; j < 256; j++)
7071 gtk_preview_draw_row (GTK_PREVIEW (preview), buf, 0, i, 256);
7074 gray_idle = gtk_idle_add ((GtkFunction) gray_idle_func, preview);
7077 if (!GTK_WIDGET_VISIBLE (window))
7078 gtk_widget_show_all (window);
7080 gtk_widget_destroy (window);
7089 selection_test_received (GtkWidget *list, GtkSelectionData *data)
7092 GtkWidget *list_item;
7096 if (data->length < 0)
7098 g_print ("Selection retrieval failed\n");
7101 if (data->type != GDK_SELECTION_TYPE_ATOM)
7103 g_print ("Selection \"TARGETS\" was not returned as atoms!\n");
7107 /* Clear out any current list items */
7109 gtk_list_clear_items (GTK_LIST(list), 0, -1);
7111 /* Add new items to list */
7113 atoms = (GdkAtom *)data->data;
7116 l = data->length / sizeof (GdkAtom);
7117 for (i = 0; i < l; i++)
7120 name = gdk_atom_name (atoms[i]);
7123 list_item = gtk_list_item_new_with_label (name);
7127 list_item = gtk_list_item_new_with_label ("(bad atom)");
7129 gtk_widget_show (list_item);
7130 item_list = g_list_append (item_list, list_item);
7133 gtk_list_append_items (GTK_LIST (list), item_list);
7139 selection_test_get_targets (GtkWidget *widget, GtkWidget *list)
7141 static GdkAtom targets_atom = GDK_NONE;
7143 if (targets_atom == GDK_NONE)
7144 targets_atom = gdk_atom_intern ("TARGETS", FALSE);
7146 gtk_selection_convert (list, GDK_SELECTION_PRIMARY, targets_atom,
7151 create_selection_test (void)
7153 static GtkWidget *window = NULL;
7156 GtkWidget *scrolled_win;
7162 window = gtk_dialog_new ();
7164 gtk_signal_connect (GTK_OBJECT (window), "destroy",
7165 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
7168 gtk_window_set_title (GTK_WINDOW (window), "Selection Test");
7169 gtk_container_border_width (GTK_CONTAINER (window), 0);
7171 /* Create the list */
7173 vbox = gtk_vbox_new (FALSE, 5);
7174 gtk_container_border_width (GTK_CONTAINER (vbox), 10);
7175 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), vbox,
7178 label = gtk_label_new ("Gets available targets for current selection");
7179 gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
7181 scrolled_win = gtk_scrolled_window_new (NULL, NULL);
7182 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
7183 GTK_POLICY_AUTOMATIC,
7184 GTK_POLICY_AUTOMATIC);
7185 gtk_box_pack_start (GTK_BOX (vbox), scrolled_win, TRUE, TRUE, 0);
7186 gtk_widget_set_usize (scrolled_win, 100, 200);
7188 list = gtk_list_new ();
7189 gtk_container_add (GTK_CONTAINER (scrolled_win), list);
7191 gtk_signal_connect (GTK_OBJECT(list), "selection_received",
7192 GTK_SIGNAL_FUNC (selection_test_received), NULL);
7194 /* .. And create some buttons */
7195 button = gtk_button_new_with_label ("Get Targets");
7196 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
7197 button, TRUE, TRUE, 0);
7199 gtk_signal_connect (GTK_OBJECT (button), "clicked",
7200 GTK_SIGNAL_FUNC (selection_test_get_targets), list);
7202 button = gtk_button_new_with_label ("Quit");
7203 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
7204 button, TRUE, TRUE, 0);
7206 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
7207 GTK_SIGNAL_FUNC (gtk_widget_destroy),
7208 GTK_OBJECT (window));
7211 if (!GTK_WIDGET_VISIBLE (window))
7212 gtk_widget_show_all (window);
7214 gtk_widget_destroy (window);
7222 create_gamma_curve (void)
7224 static GtkWidget *window = NULL, *curve;
7225 static int count = 0;
7232 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
7233 gtk_window_set_title (GTK_WINDOW (window), "test");
7234 gtk_container_border_width (GTK_CONTAINER (window), 10);
7236 gtk_signal_connect (GTK_OBJECT (window), "destroy",
7237 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
7240 curve = gtk_gamma_curve_new ();
7241 gtk_container_add (GTK_CONTAINER (window), curve);
7242 gtk_widget_show (curve);
7245 max = 127 + (count % 2)*128;
7246 gtk_curve_set_range (GTK_CURVE (GTK_GAMMA_CURVE (curve)->curve),
7248 for (i = 0; i < max; ++i)
7249 vec[i] = (127 / sqrt (max)) * sqrt (i);
7250 gtk_curve_set_vector (GTK_CURVE (GTK_GAMMA_CURVE (curve)->curve),
7253 if (!GTK_WIDGET_VISIBLE (window))
7254 gtk_widget_show (window);
7255 else if (count % 4 == 3)
7257 gtk_widget_destroy (window);
7268 static int scroll_test_pos = 0.0;
7269 static GdkGC *scroll_test_gc = NULL;
7272 scroll_test_expose (GtkWidget *widget, GdkEventExpose *event,
7276 gint imin, imax, jmin, jmax;
7278 imin = (event->area.x) / 10;
7279 imax = (event->area.x + event->area.width + 9) / 10;
7281 jmin = ((int)adj->value + event->area.y) / 10;
7282 jmax = ((int)adj->value + event->area.y + event->area.height + 9) / 10;
7284 gdk_window_clear_area (widget->window,
7285 event->area.x, event->area.y,
7286 event->area.width, event->area.height);
7288 for (i=imin; i<imax; i++)
7289 for (j=jmin; j<jmax; j++)
7291 gdk_draw_rectangle (widget->window,
7292 widget->style->black_gc,
7294 10*i, 10*j - (int)adj->value, 1+i%10, 1+j%10);
7300 scroll_test_configure (GtkWidget *widget, GdkEventConfigure *event,
7303 adj->page_increment = 0.9 * widget->allocation.height;
7304 adj->page_size = widget->allocation.height;
7306 gtk_signal_emit_by_name (GTK_OBJECT (adj), "changed");
7310 scroll_test_adjustment_changed (GtkAdjustment *adj, GtkWidget *widget)
7312 gint source_min = (int)adj->value - scroll_test_pos;
7313 gint source_max = source_min + widget->allocation.height;
7315 gint dest_max = widget->allocation.height;
7319 scroll_test_pos = adj->value;
7321 if (!GTK_WIDGET_DRAWABLE (widget))
7328 rect.width = widget->allocation.width;
7329 rect.height = -source_min;
7330 if (rect.height > widget->allocation.height)
7331 rect.height = widget->allocation.height;
7334 dest_min = rect.height;
7339 rect.y = 2*widget->allocation.height - source_max;
7342 rect.width = widget->allocation.width;
7343 rect.height = widget->allocation.height - rect.y;
7345 source_max = widget->allocation.height;
7349 if (source_min != source_max)
7351 if (scroll_test_gc == NULL)
7353 scroll_test_gc = gdk_gc_new (widget->window);
7354 gdk_gc_set_exposures (scroll_test_gc, TRUE);
7357 gdk_draw_pixmap (widget->window,
7362 widget->allocation.width,
7363 source_max - source_min);
7365 /* Make sure graphics expose events are processed before scrolling
7368 while ((event = gdk_event_get_graphics_expose (widget->window)) != NULL)
7370 gtk_widget_event (widget, event);
7371 if (event->expose.count == 0)
7373 gdk_event_free (event);
7376 gdk_event_free (event);
7380 if (rect.height != 0)
7381 gtk_widget_draw (widget, &rect);
7386 create_scroll_test (void)
7388 static GtkWidget *window = NULL;
7390 GtkWidget *drawing_area;
7391 GtkWidget *scrollbar;
7397 window = gtk_dialog_new ();
7399 gtk_signal_connect (GTK_OBJECT (window), "destroy",
7400 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
7403 gtk_window_set_title (GTK_WINDOW (window), "Scroll Test");
7404 gtk_container_border_width (GTK_CONTAINER (window), 0);
7406 hbox = gtk_hbox_new (FALSE, 0);
7407 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), hbox,
7409 gtk_widget_show (hbox);
7411 drawing_area = gtk_drawing_area_new ();
7412 gtk_drawing_area_size (GTK_DRAWING_AREA (drawing_area), 200, 200);
7413 gtk_box_pack_start (GTK_BOX (hbox), drawing_area, TRUE, TRUE, 0);
7414 gtk_widget_show (drawing_area);
7416 gtk_widget_set_events (drawing_area, GDK_EXPOSURE_MASK);
7418 adj = GTK_ADJUSTMENT (gtk_adjustment_new (0.0, 0.0, 1000.0, 1.0, 180.0, 200.0));
7419 scroll_test_pos = 0.0;
7421 scrollbar = gtk_vscrollbar_new (adj);
7422 gtk_box_pack_start (GTK_BOX (hbox), scrollbar, FALSE, FALSE, 0);
7423 gtk_widget_show (scrollbar);
7425 gtk_signal_connect (GTK_OBJECT (drawing_area), "expose_event",
7426 GTK_SIGNAL_FUNC (scroll_test_expose), adj);
7427 gtk_signal_connect (GTK_OBJECT (drawing_area), "configure_event",
7428 GTK_SIGNAL_FUNC (scroll_test_configure), adj);
7431 gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
7432 GTK_SIGNAL_FUNC (scroll_test_adjustment_changed),
7435 /* .. And create some buttons */
7437 button = gtk_button_new_with_label ("Quit");
7438 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
7439 button, TRUE, TRUE, 0);
7441 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
7442 GTK_SIGNAL_FUNC (gtk_widget_destroy),
7443 GTK_OBJECT (window));
7444 gtk_widget_show (button);
7447 if (!GTK_WIDGET_VISIBLE (window))
7448 gtk_widget_show (window);
7450 gtk_widget_destroy (window);
7457 static int timer = 0;
7460 timeout_test (GtkWidget *label)
7462 static int count = 0;
7463 static char buffer[32];
7465 sprintf (buffer, "count: %d", ++count);
7466 gtk_label_set (GTK_LABEL (label), buffer);
7472 start_timeout_test (GtkWidget *widget,
7477 timer = gtk_timeout_add (100, (GtkFunction) timeout_test, label);
7482 stop_timeout_test (GtkWidget *widget,
7487 gtk_timeout_remove (timer);
7493 destroy_timeout_test (GtkWidget *widget,
7496 stop_timeout_test (NULL, NULL);
7502 create_timeout_test (void)
7504 static GtkWidget *window = NULL;
7510 window = gtk_dialog_new ();
7512 gtk_signal_connect (GTK_OBJECT (window), "destroy",
7513 GTK_SIGNAL_FUNC(destroy_timeout_test),
7516 gtk_window_set_title (GTK_WINDOW (window), "Timeout Test");
7517 gtk_container_border_width (GTK_CONTAINER (window), 0);
7519 label = gtk_label_new ("count: 0");
7520 gtk_misc_set_padding (GTK_MISC (label), 10, 10);
7521 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox),
7522 label, TRUE, TRUE, 0);
7523 gtk_widget_show (label);
7525 button = gtk_button_new_with_label ("close");
7526 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
7527 GTK_SIGNAL_FUNC(gtk_widget_destroy),
7528 GTK_OBJECT (window));
7529 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
7530 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
7531 button, TRUE, TRUE, 0);
7532 gtk_widget_grab_default (button);
7533 gtk_widget_show (button);
7535 button = gtk_button_new_with_label ("start");
7536 gtk_signal_connect (GTK_OBJECT (button), "clicked",
7537 GTK_SIGNAL_FUNC(start_timeout_test),
7539 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
7540 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
7541 button, TRUE, TRUE, 0);
7542 gtk_widget_show (button);
7544 button = gtk_button_new_with_label ("stop");
7545 gtk_signal_connect (GTK_OBJECT (button), "clicked",
7546 GTK_SIGNAL_FUNC(stop_timeout_test),
7548 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
7549 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
7550 button, TRUE, TRUE, 0);
7551 gtk_widget_show (button);
7554 if (!GTK_WIDGET_VISIBLE (window))
7555 gtk_widget_show (window);
7557 gtk_widget_destroy (window);
7564 static int idle = 0;
7567 idle_test (GtkWidget *label)
7569 static int count = 0;
7570 static char buffer[32];
7572 sprintf (buffer, "count: %d", ++count);
7573 gtk_label_set (GTK_LABEL (label), buffer);
7579 start_idle_test (GtkWidget *widget,
7584 idle = gtk_idle_add ((GtkFunction) idle_test, label);
7589 stop_idle_test (GtkWidget *widget,
7594 gtk_idle_remove (idle);
7600 destroy_idle_test (GtkWidget *widget,
7603 stop_idle_test (NULL, NULL);
7609 toggle_idle_container (GtkObject *button,
7610 GtkContainer *container)
7612 gtk_container_set_resize_mode (container, (guint) gtk_object_get_user_data (button));
7616 create_idle_test (void)
7618 static GtkWidget *window = NULL;
7621 GtkWidget *container;
7628 window = gtk_dialog_new ();
7630 gtk_signal_connect (GTK_OBJECT (window), "destroy",
7631 GTK_SIGNAL_FUNC(destroy_idle_test),
7634 gtk_window_set_title (GTK_WINDOW (window), "Idle Test");
7635 gtk_container_border_width (GTK_CONTAINER (window), 0);
7637 label = gtk_label_new ("count: 0");
7638 gtk_misc_set_padding (GTK_MISC (label), 10, 10);
7639 gtk_widget_show (label);
7642 gtk_widget_new (GTK_TYPE_HBOX,
7643 "GtkWidget::visible", TRUE,
7644 /* "GtkContainer::child", gtk_widget_new (GTK_TYPE_HBOX,
7645 * "GtkWidget::visible", TRUE,
7647 "GtkContainer::child", label,
7650 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox),
7651 container, TRUE, TRUE, 0);
7654 gtk_widget_new (GTK_TYPE_FRAME,
7655 "GtkContainer::border_width", 5,
7656 "GtkFrame::label", "Label Container",
7657 "GtkWidget::visible", TRUE,
7658 "GtkWidget::parent", GTK_DIALOG (window)->vbox,
7661 gtk_widget_new (GTK_TYPE_VBOX,
7662 "GtkWidget::visible", TRUE,
7663 "GtkWidget::parent", frame,
7666 gtk_widget_new (GTK_TYPE_RADIO_BUTTON,
7667 "GtkButton::label", "Resize-Parent",
7668 "GtkObject::user_data", (void*)GTK_RESIZE_PARENT,
7669 "GtkObject::signal::clicked", toggle_idle_container, container,
7670 "GtkWidget::visible", TRUE,
7671 "GtkWidget::parent", box,
7674 gtk_widget_new (GTK_TYPE_RADIO_BUTTON,
7675 "GtkButton::label", "Resize-Queue",
7676 "GtkObject::user_data", (void*)GTK_RESIZE_QUEUE,
7677 "GtkObject::signal::clicked", toggle_idle_container, container,
7678 "GtkRadioButton::group", button,
7679 "GtkWidget::visible", TRUE,
7680 "GtkWidget::parent", box,
7683 gtk_widget_new (GTK_TYPE_RADIO_BUTTON,
7684 "GtkButton::label", "Resize-Immediate",
7685 "GtkObject::user_data", (void*)GTK_RESIZE_IMMEDIATE,
7686 "GtkObject::signal::clicked", toggle_idle_container, container,
7687 "GtkRadioButton::group", button,
7688 "GtkWidget::visible", TRUE,
7689 "GtkWidget::parent", box,
7693 button = gtk_button_new_with_label ("close");
7694 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
7695 GTK_SIGNAL_FUNC(gtk_widget_destroy),
7696 GTK_OBJECT (window));
7697 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
7698 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
7699 button, TRUE, TRUE, 0);
7700 gtk_widget_grab_default (button);
7701 gtk_widget_show (button);
7703 button = gtk_button_new_with_label ("start");
7704 gtk_signal_connect (GTK_OBJECT (button), "clicked",
7705 GTK_SIGNAL_FUNC(start_idle_test),
7707 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
7708 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
7709 button, TRUE, TRUE, 0);
7710 gtk_widget_show (button);
7712 button = gtk_button_new_with_label ("stop");
7713 gtk_signal_connect (GTK_OBJECT (button), "clicked",
7714 GTK_SIGNAL_FUNC(stop_idle_test),
7716 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
7717 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
7718 button, TRUE, TRUE, 0);
7719 gtk_widget_show (button);
7722 if (!GTK_WIDGET_VISIBLE (window))
7723 gtk_widget_show (window);
7725 gtk_widget_destroy (window);
7733 reload_rc_file (void)
7737 if (gtk_rc_reparse_all ())
7739 toplevels = gdk_window_get_toplevels();
7743 gdk_window_get_user_data (toplevels->data, (gpointer *)&widget);
7746 gtk_widget_reset_rc_styles (widget);
7748 toplevels = toplevels->next;
7750 g_list_free (toplevels);
7755 reload_all_rc_files (void)
7757 static GdkAtom atom_rcfiles = GDK_NONE;
7763 atom_rcfiles = gdk_atom_intern("_GTK_READ_RCFILES", FALSE);
7765 for(i = 0; i < 5; i++)
7767 sev.data_format = 32;
7768 sev.message_type = atom_rcfiles;
7769 gdk_event_send_clientmessage_toall ((GdkEvent *) &sev);
7773 create_rc_file (void)
7775 static GtkWidget *window = NULL;
7780 window = gtk_dialog_new ();
7782 gtk_signal_connect (GTK_OBJECT (window), "destroy",
7783 GTK_SIGNAL_FUNC(destroy_idle_test),
7786 gtk_window_set_title (GTK_WINDOW (window), "Reload Rc file");
7787 gtk_container_border_width (GTK_CONTAINER (window), 0);
7789 button = gtk_button_new_with_label ("Reload");
7790 gtk_signal_connect (GTK_OBJECT (button), "clicked",
7791 GTK_SIGNAL_FUNC(reload_rc_file), NULL);
7792 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
7793 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
7794 button, TRUE, TRUE, 0);
7795 gtk_widget_grab_default (button);
7796 gtk_widget_show (button);
7798 button = gtk_button_new_with_label ("Reload All");
7799 gtk_signal_connect (GTK_OBJECT (button), "clicked",
7800 GTK_SIGNAL_FUNC(reload_all_rc_files), NULL);
7801 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
7802 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
7803 button, TRUE, TRUE, 0);
7804 gtk_widget_show (button);
7806 button = gtk_button_new_with_label ("Close");
7807 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
7808 GTK_SIGNAL_FUNC(gtk_widget_destroy),
7809 GTK_OBJECT (window));
7810 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
7811 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
7812 button, TRUE, TRUE, 0);
7813 gtk_widget_show (button);
7817 if (!GTK_WIDGET_VISIBLE (window))
7818 gtk_widget_show (window);
7820 gtk_widget_destroy (window);
7824 * Test of recursive mainloop
7828 mainloop_destroyed (GtkWidget *w, GtkWidget **window)
7835 create_mainloop (void)
7837 static GtkWidget *window = NULL;
7843 window = gtk_dialog_new ();
7845 gtk_window_set_title (GTK_WINDOW (window), "Test Main Loop");
7847 gtk_signal_connect (GTK_OBJECT (window), "destroy",
7848 GTK_SIGNAL_FUNC(mainloop_destroyed),
7851 label = gtk_label_new ("In recursive main loop...");
7852 gtk_misc_set_padding (GTK_MISC(label), 20, 20);
7854 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), label,
7856 gtk_widget_show (label);
7858 button = gtk_button_new_with_label ("Leave");
7859 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area), button,
7862 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
7863 GTK_SIGNAL_FUNC (gtk_widget_destroy),
7864 GTK_OBJECT (window));
7866 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
7867 gtk_widget_grab_default (button);
7869 gtk_widget_show (button);
7872 if (!GTK_WIDGET_VISIBLE (window))
7874 gtk_widget_show (window);
7876 g_print ("create_mainloop: start\n");
7878 g_print ("create_mainloop: done\n");
7881 gtk_widget_destroy (window);
7885 * Main Window and Exit
7889 do_exit (GtkWidget *widget, GtkWidget *window)
7891 gtk_widget_destroy (window);
7896 create_main_window (void)
7903 { "button box", create_button_box },
7904 { "buttons", create_buttons },
7905 { "check buttons", create_check_buttons },
7906 { "clist", create_clist},
7907 { "color selection", create_color_selection },
7908 { "ctree", create_ctree },
7909 { "cursors", create_cursors },
7910 { "dialog", create_dialog },
7911 { "dnd", create_dnd },
7912 { "entry", create_entry },
7913 { "file selection", create_file_selection },
7914 { "font selection", create_font_selection },
7915 { "gamma curve", create_gamma_curve },
7916 { "handle box", create_handle_box },
7917 { "item factory", create_item_factory },
7918 { "list", create_list },
7919 { "menus", create_menus },
7920 { "modal window", create_modal_window },
7921 { "notebook", create_notebook },
7922 { "panes", create_panes },
7923 { "pixmap", create_pixmap },
7924 { "preview color", create_color_preview },
7925 { "preview gray", create_gray_preview },
7926 { "progress bar", create_progress_bar },
7927 { "radio buttons", create_radio_buttons },
7928 { "range controls", create_range_controls },
7929 { "rc file", create_rc_file },
7930 { "reparent", create_reparent },
7931 { "rulers", create_rulers },
7932 { "saved position", create_saved_position },
7933 { "scrolled windows", create_scrolled_windows },
7934 { "shapes", create_shapes },
7935 { "spinbutton", create_spins },
7936 { "statusbar", create_statusbar },
7937 { "test idle", create_idle_test },
7938 { "test mainloop", create_mainloop },
7939 { "test scrolling", create_scroll_test },
7940 { "test selection", create_selection_test },
7941 { "test timeout", create_timeout_test },
7942 { "text", create_text },
7943 { "toggle buttons", create_toggle_buttons },
7944 { "toolbar", create_toolbar },
7945 { "tooltips", create_tooltips },
7946 { "tree", create_tree_mode_window},
7947 { "WM hints", create_wmhints },
7949 int nbuttons = sizeof (buttons) / sizeof (buttons[0]);
7953 GtkWidget *scrolled_window;
7957 GtkWidget *separator;
7960 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
7961 gtk_window_set_policy (GTK_WINDOW (window), FALSE, FALSE, FALSE);
7962 gtk_widget_set_name (window, "main window");
7963 gtk_widget_set_usize (window, 200, 400);
7964 gtk_widget_set_uposition (window, 20, 20);
7966 gtk_signal_connect (GTK_OBJECT (window), "destroy",
7967 GTK_SIGNAL_FUNC(gtk_main_quit),
7969 gtk_signal_connect (GTK_OBJECT (window), "delete-event",
7970 GTK_SIGNAL_FUNC (gtk_false),
7973 box1 = gtk_vbox_new (FALSE, 0);
7974 gtk_container_add (GTK_CONTAINER (window), box1);
7976 if (gtk_micro_version > 0)
7988 label = gtk_label_new (buffer);
7989 gtk_box_pack_start (GTK_BOX (box1), label, FALSE, FALSE, 0);
7991 scrolled_window = gtk_scrolled_window_new (NULL, NULL);
7992 gtk_container_border_width (GTK_CONTAINER (scrolled_window), 10);
7993 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
7994 GTK_POLICY_AUTOMATIC,
7995 GTK_POLICY_AUTOMATIC);
7996 GTK_WIDGET_UNSET_FLAGS (GTK_SCROLLED_WINDOW (scrolled_window)->vscrollbar, GTK_CAN_FOCUS);
7997 gtk_box_pack_start (GTK_BOX (box1), scrolled_window, TRUE, TRUE, 0);
7999 box2 = gtk_vbox_new (FALSE, 0);
8000 gtk_container_border_width (GTK_CONTAINER (box2), 10);
8001 gtk_container_add (GTK_CONTAINER (scrolled_window), box2);
8002 gtk_container_set_focus_vadjustment (GTK_CONTAINER (box2),
8003 gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (scrolled_window)));
8004 gtk_widget_show (box2);
8006 for (i = 0; i < nbuttons; i++)
8008 button = gtk_button_new_with_label (buttons[i].label);
8009 if (buttons[i].func)
8010 gtk_signal_connect (GTK_OBJECT (button),
8012 GTK_SIGNAL_FUNC(buttons[i].func),
8015 gtk_widget_set_sensitive (button, FALSE);
8016 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
8019 separator = gtk_hseparator_new ();
8020 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
8022 box2 = gtk_vbox_new (FALSE, 10);
8023 gtk_container_border_width (GTK_CONTAINER (box2), 10);
8024 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
8026 button = gtk_button_new_with_label ("close");
8027 gtk_signal_connect (GTK_OBJECT (button), "clicked",
8028 GTK_SIGNAL_FUNC (do_exit),
8030 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
8031 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
8032 gtk_widget_grab_default (button);
8034 gtk_widget_show_all (window);
8038 main (int argc, char *argv[])
8040 GtkBindingSet *binding_set;
8042 srand (time (NULL));
8046 gtk_init (&argc, &argv);
8052 binding_set = gtk_binding_set_by_class (gtk_type_class (GTK_TYPE_WIDGET));
8053 gtk_binding_entry_add_signal (binding_set,
8054 '9', GDK_CONTROL_MASK | GDK_RELEASE_MASK,
8057 GTK_TYPE_STRING, "GtkWidgetClass <ctrl><release>9 test");
8059 gtk_rc_parse ("testgtkrc");
8061 create_main_window ();