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_set_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_set_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_set_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_set_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_set_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_set_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_set_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_set_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_set_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_set_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_set_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_set_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_set_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_set_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_set_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_set_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 set_toolbar_space_style_empty (GtkWidget *widget,
664 gtk_toolbar_set_space_style (GTK_TOOLBAR (data), GTK_TOOLBAR_SPACE_EMPTY);
668 set_toolbar_space_style_line (GtkWidget *widget,
671 gtk_toolbar_set_space_style (GTK_TOOLBAR (data), GTK_TOOLBAR_SPACE_LINE);
675 create_toolbar (void)
677 static GtkWidget *window = NULL;
683 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
684 gtk_window_set_title (GTK_WINDOW (window), "Toolbar test");
685 gtk_window_set_policy (GTK_WINDOW (window), FALSE, TRUE, TRUE);
687 gtk_signal_connect (GTK_OBJECT (window), "destroy",
688 GTK_SIGNAL_FUNC (gtk_widget_destroyed),
691 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
692 gtk_widget_realize (window);
694 toolbar = gtk_toolbar_new (GTK_ORIENTATION_HORIZONTAL, GTK_TOOLBAR_BOTH);
695 gtk_toolbar_set_button_relief (GTK_TOOLBAR (toolbar), GTK_RELIEF_NONE);
697 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
698 "Horizontal", "Horizontal toolbar layout", "Toolbar/Horizontal",
699 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
700 (GtkSignalFunc) set_toolbar_horizontal, toolbar);
701 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
702 "Vertical", "Vertical toolbar layout", "Toolbar/Vertical",
703 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
704 (GtkSignalFunc) set_toolbar_vertical, toolbar);
706 gtk_toolbar_append_space (GTK_TOOLBAR(toolbar));
708 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
709 "Icons", "Only show toolbar icons", "Toolbar/IconsOnly",
710 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
711 (GtkSignalFunc) set_toolbar_icons, toolbar);
712 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
713 "Text", "Only show toolbar text", "Toolbar/TextOnly",
714 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
715 (GtkSignalFunc) set_toolbar_text, toolbar);
716 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
717 "Both", "Show toolbar icons and text", "Toolbar/Both",
718 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
719 (GtkSignalFunc) set_toolbar_both, toolbar);
721 gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
723 entry = gtk_entry_new ();
725 gtk_toolbar_append_widget (GTK_TOOLBAR (toolbar), entry, "This is an unusable GtkEntry ;)", "Hey don't click me!!!");
727 gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
729 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
730 "Small", "Use small spaces", "Toolbar/Small",
731 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
732 (GtkSignalFunc) set_toolbar_small_space, toolbar);
733 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
734 "Big", "Use big spaces", "Toolbar/Big",
735 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
736 (GtkSignalFunc) set_toolbar_big_space, toolbar);
738 gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
740 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
741 "Enable", "Enable tooltips", NULL,
742 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
743 (GtkSignalFunc) set_toolbar_enable, toolbar);
744 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
745 "Disable", "Disable tooltips", NULL,
746 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
747 (GtkSignalFunc) set_toolbar_disable, toolbar);
749 gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
751 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
752 "Borders", "Show Borders", NULL,
753 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
754 (GtkSignalFunc) set_toolbar_borders, toolbar);
755 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
756 "Borderless", "Hide Borders", NULL,
757 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
758 (GtkSignalFunc) set_toolbar_borderless, toolbar);
760 gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
762 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
763 "Empty", "Empty spaces", NULL,
764 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
765 (GtkSignalFunc) set_toolbar_space_style_empty, toolbar);
766 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
767 "Lines", "Lines in spaces", NULL,
768 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
769 (GtkSignalFunc) set_toolbar_space_style_line, toolbar);
771 gtk_container_add (GTK_CONTAINER (window), toolbar);
774 if (!GTK_WIDGET_VISIBLE (window))
775 gtk_widget_show_all (window);
777 gtk_widget_destroy (window);
781 make_toolbar (GtkWidget *window)
785 if (!GTK_WIDGET_REALIZED (window))
786 gtk_widget_realize (window);
788 toolbar = gtk_toolbar_new (GTK_ORIENTATION_HORIZONTAL, GTK_TOOLBAR_BOTH);
789 gtk_toolbar_set_button_relief (GTK_TOOLBAR (toolbar), GTK_RELIEF_NONE);
791 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
792 "Horizontal", "Horizontal toolbar layout", NULL,
793 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
794 (GtkSignalFunc) set_toolbar_horizontal, toolbar);
795 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
796 "Vertical", "Vertical toolbar layout", NULL,
797 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
798 (GtkSignalFunc) set_toolbar_vertical, toolbar);
800 gtk_toolbar_append_space (GTK_TOOLBAR(toolbar));
802 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
803 "Icons", "Only show toolbar icons", NULL,
804 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
805 (GtkSignalFunc) set_toolbar_icons, toolbar);
806 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
807 "Text", "Only show toolbar text", NULL,
808 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
809 (GtkSignalFunc) set_toolbar_text, toolbar);
810 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
811 "Both", "Show toolbar icons and text", NULL,
812 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
813 (GtkSignalFunc) set_toolbar_both, toolbar);
815 gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
817 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
818 "Small", "Use small spaces", NULL,
819 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
820 (GtkSignalFunc) set_toolbar_small_space, toolbar);
821 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
822 "Big", "Use big spaces", "Toolbar/Big",
823 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
824 (GtkSignalFunc) set_toolbar_big_space, toolbar);
826 gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
828 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
829 "Enable", "Enable tooltips", NULL,
830 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
831 (GtkSignalFunc) set_toolbar_enable, toolbar);
832 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
833 "Disable", "Disable tooltips", NULL,
834 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
835 (GtkSignalFunc) set_toolbar_disable, toolbar);
837 gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
839 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
840 "Borders", "Show Borders", NULL,
841 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
842 (GtkSignalFunc) set_toolbar_borders, toolbar);
843 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
844 "Borderless", "Hide Borders", NULL,
845 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
846 (GtkSignalFunc) set_toolbar_borderless, toolbar);
855 static guint statusbar_counter = 1;
858 statusbar_push (GtkWidget *button,
859 GtkStatusbar *statusbar)
863 sprintf (text, "something %d", statusbar_counter++);
865 gtk_statusbar_push (statusbar, 1, text);
869 statusbar_pop (GtkWidget *button,
870 GtkStatusbar *statusbar)
872 gtk_statusbar_pop (statusbar, 1);
876 statusbar_steal (GtkWidget *button,
877 GtkStatusbar *statusbar)
879 gtk_statusbar_remove (statusbar, 1, 4);
883 statusbar_popped (GtkStatusbar *statusbar,
887 if (!statusbar->messages)
888 statusbar_counter = 1;
892 statusbar_contexts (GtkStatusbar *statusbar)
896 string = "any context";
897 g_print ("GtkStatusBar: context=\"%s\", context_id=%d\n",
899 gtk_statusbar_get_context_id (statusbar, string));
901 string = "idle messages";
902 g_print ("GtkStatusBar: context=\"%s\", context_id=%d\n",
904 gtk_statusbar_get_context_id (statusbar, string));
906 string = "some text";
907 g_print ("GtkStatusBar: context=\"%s\", context_id=%d\n",
909 gtk_statusbar_get_context_id (statusbar, string));
911 string = "hit the mouse";
912 g_print ("GtkStatusBar: context=\"%s\", context_id=%d\n",
914 gtk_statusbar_get_context_id (statusbar, string));
916 string = "hit the mouse2";
917 g_print ("GtkStatusBar: context=\"%s\", context_id=%d\n",
919 gtk_statusbar_get_context_id (statusbar, string));
923 statusbar_dump_stack (GtkStatusbar *statusbar)
927 for (list = statusbar->messages; list; list = list->next)
929 GtkStatusbarMsg *msg;
932 g_print ("context_id: %d, message_id: %d, status_text: \"%s\"\n",
940 create_statusbar (void)
942 static GtkWidget *window = NULL;
946 GtkWidget *separator;
947 GtkWidget *statusbar;
951 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
953 gtk_signal_connect (GTK_OBJECT (window), "destroy",
954 GTK_SIGNAL_FUNC (gtk_widget_destroyed),
957 gtk_window_set_title (GTK_WINDOW (window), "statusbar");
958 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
960 box1 = gtk_vbox_new (FALSE, 0);
961 gtk_container_add (GTK_CONTAINER (window), box1);
963 box2 = gtk_vbox_new (FALSE, 10);
964 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
965 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
967 statusbar = gtk_statusbar_new ();
968 gtk_box_pack_end (GTK_BOX (box1), statusbar, TRUE, TRUE, 0);
969 gtk_signal_connect (GTK_OBJECT (statusbar),
971 GTK_SIGNAL_FUNC (statusbar_popped),
974 button = gtk_widget_new (gtk_button_get_type (),
975 "label", "push something",
978 "signal::clicked", statusbar_push, statusbar,
981 button = gtk_widget_new (gtk_button_get_type (),
985 "signal_after::clicked", statusbar_pop, statusbar,
988 button = gtk_widget_new (gtk_button_get_type (),
992 "signal_after::clicked", statusbar_steal, statusbar,
995 button = gtk_widget_new (gtk_button_get_type (),
996 "label", "dump stack",
999 "object_signal::clicked", statusbar_dump_stack, statusbar,
1002 button = gtk_widget_new (gtk_button_get_type (),
1003 "label", "test contexts",
1006 "object_signal_after::clicked", statusbar_contexts, statusbar,
1009 separator = gtk_hseparator_new ();
1010 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
1012 box2 = gtk_vbox_new (FALSE, 10);
1013 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
1014 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
1016 button = gtk_button_new_with_label ("close");
1017 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
1018 GTK_SIGNAL_FUNC(gtk_widget_destroy),
1019 GTK_OBJECT (window));
1020 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
1021 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
1022 gtk_widget_grab_default (button);
1025 if (!GTK_WIDGET_VISIBLE (window))
1026 gtk_widget_show_all (window);
1028 gtk_widget_destroy (window);
1036 cb_tree_destroy_event(GtkWidget* w)
1038 sTreeButtons* tree_buttons;
1040 /* free buttons structure associate at this tree */
1041 tree_buttons = gtk_object_get_user_data (GTK_OBJECT (w));
1042 g_free (tree_buttons);
1046 cb_add_new_item(GtkWidget* w, GtkTree* tree)
1048 sTreeButtons* tree_buttons;
1049 GList* selected_list;
1050 GtkWidget* selected_item;
1052 GtkWidget* item_new;
1055 tree_buttons = gtk_object_get_user_data(GTK_OBJECT(tree));
1057 selected_list = GTK_TREE_SELECTION(tree);
1059 if(selected_list == NULL)
1061 /* there is no item in tree */
1062 subtree = GTK_WIDGET(tree);
1066 /* list can have only one element */
1067 selected_item = GTK_WIDGET(selected_list->data);
1069 subtree = GTK_TREE_ITEM_SUBTREE(selected_item);
1073 /* current selected item have not subtree ... create it */
1074 subtree = gtk_tree_new();
1075 gtk_tree_item_set_subtree(GTK_TREE_ITEM(selected_item),
1080 /* at this point, we know which subtree will be used to add new item */
1081 /* create a new item */
1082 sprintf(buffer, "item add %d", tree_buttons->nb_item_add);
1083 item_new = gtk_tree_item_new_with_label(buffer);
1084 gtk_tree_append(GTK_TREE(subtree), item_new);
1085 gtk_widget_show(item_new);
1087 tree_buttons->nb_item_add++;
1091 cb_remove_item(GtkWidget*w, GtkTree* tree)
1093 GList* selected_list;
1096 selected_list = GTK_TREE_SELECTION(tree);
1100 while (selected_list)
1102 clear_list = g_list_prepend (clear_list, selected_list->data);
1103 selected_list = selected_list->next;
1106 clear_list = g_list_reverse (clear_list);
1107 gtk_tree_remove_items(tree, clear_list);
1109 g_list_free (clear_list);
1113 cb_remove_subtree(GtkWidget*w, GtkTree* tree)
1115 GList* selected_list;
1118 selected_list = GTK_TREE_SELECTION(tree);
1122 item = GTK_TREE_ITEM (selected_list->data);
1124 gtk_tree_item_remove_subtree (item);
1129 cb_tree_changed(GtkTree* tree)
1131 sTreeButtons* tree_buttons;
1132 GList* selected_list;
1135 tree_buttons = gtk_object_get_user_data(GTK_OBJECT(tree));
1137 selected_list = GTK_TREE_SELECTION(tree);
1138 nb_selected = g_list_length(selected_list);
1140 if(nb_selected == 0)
1142 if(tree->children == NULL)
1143 gtk_widget_set_sensitive(tree_buttons->add_button, TRUE);
1145 gtk_widget_set_sensitive(tree_buttons->add_button, FALSE);
1146 gtk_widget_set_sensitive(tree_buttons->remove_button, FALSE);
1147 gtk_widget_set_sensitive(tree_buttons->subtree_button, FALSE);
1151 gtk_widget_set_sensitive(tree_buttons->remove_button, TRUE);
1152 gtk_widget_set_sensitive(tree_buttons->add_button, (nb_selected == 1));
1153 gtk_widget_set_sensitive(tree_buttons->subtree_button, (nb_selected == 1));
1158 create_subtree(GtkWidget* item, guint level, guint nb_item_max, guint recursion_level_max)
1160 GtkWidget* item_subtree;
1161 GtkWidget* item_new;
1166 if(level == recursion_level_max) return;
1170 /* query with no root item */
1172 item_subtree = item;
1177 /* query with no root item */
1178 /* create subtree and associate it with current item */
1179 item_subtree = gtk_tree_new();
1183 for(nb_item = 0; nb_item < nb_item_max; nb_item++)
1185 sprintf(buffer, "item %d-%d", level, nb_item);
1186 item_new = gtk_tree_item_new_with_label(buffer);
1187 gtk_tree_append(GTK_TREE(item_subtree), item_new);
1188 create_subtree(item_new, level+1, nb_item_max, recursion_level_max);
1189 gtk_widget_show(item_new);
1193 gtk_tree_item_set_subtree(GTK_TREE_ITEM(item), item_subtree);
1197 create_tree_sample(guint selection_mode,
1198 guint draw_line, guint view_line, guint no_root_item,
1199 guint nb_item_max, guint recursion_level_max)
1204 GtkWidget* separator;
1206 GtkWidget* scrolled_win;
1207 GtkWidget* root_tree;
1208 GtkWidget* root_item;
1209 sTreeButtons* tree_buttons;
1211 /* create tree buttons struct */
1212 if ((tree_buttons = g_malloc (sizeof (sTreeButtons))) == NULL)
1214 g_error("can't allocate memory for tree structure !\n");
1217 tree_buttons->nb_item_add = 0;
1219 /* create top level window */
1220 window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
1221 gtk_window_set_title(GTK_WINDOW(window), "Tree Sample");
1222 gtk_signal_connect(GTK_OBJECT(window), "destroy",
1223 (GtkSignalFunc) cb_tree_destroy_event, NULL);
1224 gtk_object_set_user_data(GTK_OBJECT(window), tree_buttons);
1226 box1 = gtk_vbox_new(FALSE, 0);
1227 gtk_container_add(GTK_CONTAINER(window), box1);
1228 gtk_widget_show(box1);
1230 /* create tree box */
1231 box2 = gtk_vbox_new(FALSE, 0);
1232 gtk_box_pack_start(GTK_BOX(box1), box2, TRUE, TRUE, 0);
1233 gtk_container_set_border_width(GTK_CONTAINER(box2), 5);
1234 gtk_widget_show(box2);
1236 /* create scrolled window */
1237 scrolled_win = gtk_scrolled_window_new (NULL, NULL);
1238 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
1239 GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
1240 gtk_box_pack_start (GTK_BOX (box2), scrolled_win, TRUE, TRUE, 0);
1241 gtk_widget_set_usize (scrolled_win, 200, 200);
1242 gtk_widget_show (scrolled_win);
1244 /* create root tree widget */
1245 root_tree = gtk_tree_new();
1246 gtk_signal_connect(GTK_OBJECT(root_tree), "selection_changed",
1247 (GtkSignalFunc)cb_tree_changed,
1249 gtk_object_set_user_data(GTK_OBJECT(root_tree), tree_buttons);
1250 gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (scrolled_win), root_tree);
1251 gtk_tree_set_selection_mode(GTK_TREE(root_tree), selection_mode);
1252 gtk_tree_set_view_lines(GTK_TREE(root_tree), draw_line);
1253 gtk_tree_set_view_mode(GTK_TREE(root_tree), !view_line);
1254 gtk_widget_show(root_tree);
1258 /* set root tree to subtree function with root item variable */
1259 root_item = GTK_WIDGET(root_tree);
1263 /* create root tree item widget */
1264 root_item = gtk_tree_item_new_with_label("root item");
1265 gtk_tree_append(GTK_TREE(root_tree), root_item);
1266 gtk_widget_show(root_item);
1268 create_subtree(root_item, -no_root_item, nb_item_max, recursion_level_max);
1270 box2 = gtk_vbox_new(FALSE, 0);
1271 gtk_box_pack_start(GTK_BOX(box1), box2, FALSE, FALSE, 0);
1272 gtk_container_set_border_width(GTK_CONTAINER(box2), 5);
1273 gtk_widget_show(box2);
1275 button = gtk_button_new_with_label("Add Item");
1276 gtk_widget_set_sensitive(button, FALSE);
1277 gtk_signal_connect(GTK_OBJECT (button), "clicked",
1278 (GtkSignalFunc) cb_add_new_item,
1279 (gpointer)root_tree);
1280 gtk_box_pack_start(GTK_BOX(box2), button, TRUE, TRUE, 0);
1281 gtk_widget_show(button);
1282 tree_buttons->add_button = button;
1284 button = gtk_button_new_with_label("Remove Item(s)");
1285 gtk_widget_set_sensitive(button, FALSE);
1286 gtk_signal_connect(GTK_OBJECT (button), "clicked",
1287 (GtkSignalFunc) cb_remove_item,
1288 (gpointer)root_tree);
1289 gtk_box_pack_start(GTK_BOX(box2), button, TRUE, TRUE, 0);
1290 gtk_widget_show(button);
1291 tree_buttons->remove_button = button;
1293 button = gtk_button_new_with_label("Remove Subtree");
1294 gtk_widget_set_sensitive(button, FALSE);
1295 gtk_signal_connect(GTK_OBJECT (button), "clicked",
1296 (GtkSignalFunc) cb_remove_subtree,
1297 (gpointer)root_tree);
1298 gtk_box_pack_start(GTK_BOX(box2), button, TRUE, TRUE, 0);
1299 gtk_widget_show(button);
1300 tree_buttons->subtree_button = button;
1302 /* create separator */
1303 separator = gtk_hseparator_new();
1304 gtk_box_pack_start(GTK_BOX(box1), separator, FALSE, FALSE, 0);
1305 gtk_widget_show(separator);
1307 /* create button box */
1308 box2 = gtk_vbox_new(FALSE, 0);
1309 gtk_box_pack_start(GTK_BOX(box1), box2, FALSE, FALSE, 0);
1310 gtk_container_set_border_width(GTK_CONTAINER(box2), 5);
1311 gtk_widget_show(box2);
1313 button = gtk_button_new_with_label("Close");
1314 gtk_box_pack_start(GTK_BOX(box2), button, TRUE, TRUE, 0);
1315 gtk_signal_connect_object(GTK_OBJECT (button), "clicked",
1316 (GtkSignalFunc) gtk_widget_destroy,
1317 GTK_OBJECT(window));
1318 gtk_widget_show(button);
1320 gtk_widget_show(window);
1324 cb_create_tree(GtkWidget* w)
1326 guint selection_mode = GTK_SELECTION_SINGLE;
1331 guint recursion_level;
1333 /* get selection mode choice */
1334 if(GTK_TOGGLE_BUTTON(sTreeSampleSelection.single_button)->active)
1335 selection_mode = GTK_SELECTION_SINGLE;
1337 if(GTK_TOGGLE_BUTTON(sTreeSampleSelection.browse_button)->active)
1338 selection_mode = GTK_SELECTION_BROWSE;
1340 selection_mode = GTK_SELECTION_MULTIPLE;
1342 /* get options choice */
1343 draw_line = GTK_TOGGLE_BUTTON(sTreeSampleSelection.draw_line_button)->active;
1344 view_line = GTK_TOGGLE_BUTTON(sTreeSampleSelection.view_line_button)->active;
1345 no_root_item = GTK_TOGGLE_BUTTON(sTreeSampleSelection.no_root_item_button)->active;
1348 nb_item = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(sTreeSampleSelection.nb_item_spinner));
1349 recursion_level = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(sTreeSampleSelection.recursion_spinner));
1351 if (pow (nb_item, recursion_level) > 10000)
1353 g_print ("%g total items? That will take a very long time. Try less\n",
1354 pow (nb_item, recursion_level));
1358 create_tree_sample(selection_mode, draw_line, view_line, no_root_item, nb_item, recursion_level);
1362 create_tree_mode_window(void)
1364 static GtkWidget* window;
1372 GtkWidget* separator;
1379 /* create toplevel window */
1380 window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
1381 gtk_window_set_title(GTK_WINDOW(window), "Set Tree Parameters");
1382 gtk_signal_connect (GTK_OBJECT (window), "destroy",
1383 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
1385 box1 = gtk_vbox_new(FALSE, 0);
1386 gtk_container_add(GTK_CONTAINER(window), box1);
1388 /* create upper box - selection box */
1389 box2 = gtk_vbox_new(FALSE, 5);
1390 gtk_box_pack_start(GTK_BOX(box1), box2, TRUE, TRUE, 0);
1391 gtk_container_set_border_width(GTK_CONTAINER(box2), 5);
1393 box3 = gtk_hbox_new(FALSE, 5);
1394 gtk_box_pack_start(GTK_BOX(box2), box3, TRUE, TRUE, 0);
1396 /* create selection mode frame */
1397 frame = gtk_frame_new("Selection Mode");
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_set_border_width(GTK_CONTAINER(box4), 5);
1404 /* create radio button */
1405 button = gtk_radio_button_new_with_label(NULL, "SINGLE");
1406 gtk_box_pack_start(GTK_BOX(box4), button, TRUE, TRUE, 0);
1407 sTreeSampleSelection.single_button = button;
1409 button = gtk_radio_button_new_with_label(gtk_radio_button_group (GTK_RADIO_BUTTON (button)),
1411 gtk_box_pack_start(GTK_BOX(box4), button, TRUE, TRUE, 0);
1412 sTreeSampleSelection.browse_button = button;
1414 button = gtk_radio_button_new_with_label(gtk_radio_button_group (GTK_RADIO_BUTTON (button)),
1416 gtk_box_pack_start(GTK_BOX(box4), button, TRUE, TRUE, 0);
1417 sTreeSampleSelection.multiple_button = button;
1419 sTreeSampleSelection.selection_mode_group = gtk_radio_button_group (GTK_RADIO_BUTTON (button));
1421 /* create option mode frame */
1422 frame = gtk_frame_new("Options");
1423 gtk_box_pack_start(GTK_BOX(box3), frame, TRUE, TRUE, 0);
1425 box4 = gtk_vbox_new(FALSE, 0);
1426 gtk_container_add(GTK_CONTAINER(frame), box4);
1427 gtk_container_set_border_width(GTK_CONTAINER(box4), 5);
1429 /* create check button */
1430 button = gtk_check_button_new_with_label("Draw line");
1431 gtk_box_pack_start(GTK_BOX(box4), button, TRUE, TRUE, 0);
1432 gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(button), TRUE);
1433 sTreeSampleSelection.draw_line_button = button;
1435 button = gtk_check_button_new_with_label("View Line mode");
1436 gtk_box_pack_start(GTK_BOX(box4), button, TRUE, TRUE, 0);
1437 gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(button), TRUE);
1438 sTreeSampleSelection.view_line_button = button;
1440 button = gtk_check_button_new_with_label("Without Root item");
1441 gtk_box_pack_start(GTK_BOX(box4), button, TRUE, TRUE, 0);
1442 sTreeSampleSelection.no_root_item_button = button;
1444 /* create recursion parameter */
1445 frame = gtk_frame_new("Size Parameters");
1446 gtk_box_pack_start(GTK_BOX(box2), frame, TRUE, TRUE, 0);
1448 box4 = gtk_hbox_new(FALSE, 5);
1449 gtk_container_add(GTK_CONTAINER(frame), box4);
1450 gtk_container_set_border_width(GTK_CONTAINER(box4), 5);
1452 /* create number of item spin button */
1453 box5 = gtk_hbox_new(FALSE, 5);
1454 gtk_box_pack_start(GTK_BOX(box4), box5, FALSE, FALSE, 0);
1456 label = gtk_label_new("Number of items : ");
1457 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
1458 gtk_box_pack_start (GTK_BOX (box5), label, FALSE, TRUE, 0);
1460 adj = (GtkAdjustment *) gtk_adjustment_new ((gfloat)DEFAULT_NUMBER_OF_ITEM, 1.0, 255.0, 1.0,
1462 spinner = gtk_spin_button_new (adj, 0, 0);
1463 gtk_box_pack_start (GTK_BOX (box5), spinner, FALSE, TRUE, 0);
1464 sTreeSampleSelection.nb_item_spinner = spinner;
1466 /* create recursion level spin button */
1467 box5 = gtk_hbox_new(FALSE, 5);
1468 gtk_box_pack_start(GTK_BOX(box4), box5, FALSE, FALSE, 0);
1470 label = gtk_label_new("Depth : ");
1471 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
1472 gtk_box_pack_start (GTK_BOX (box5), label, FALSE, TRUE, 0);
1474 adj = (GtkAdjustment *) gtk_adjustment_new ((gfloat)DEFAULT_RECURSION_LEVEL, 0.0, 255.0, 1.0,
1476 spinner = gtk_spin_button_new (adj, 0, 0);
1477 gtk_box_pack_start (GTK_BOX (box5), spinner, FALSE, TRUE, 0);
1478 sTreeSampleSelection.recursion_spinner = spinner;
1480 /* create horizontal separator */
1481 separator = gtk_hseparator_new();
1482 gtk_box_pack_start(GTK_BOX(box1), separator, FALSE, FALSE, 0);
1484 /* create bottom button box */
1485 box2 = gtk_hbox_new(TRUE, 10);
1486 gtk_box_pack_start(GTK_BOX(box1), box2, FALSE, FALSE, 0);
1487 gtk_container_set_border_width(GTK_CONTAINER(box2), 5);
1489 button = gtk_button_new_with_label("Create Tree");
1490 gtk_box_pack_start(GTK_BOX(box2), button, TRUE, TRUE, 0);
1491 gtk_signal_connect(GTK_OBJECT (button), "clicked",
1492 (GtkSignalFunc) cb_create_tree, NULL);
1494 button = gtk_button_new_with_label("Close");
1495 gtk_box_pack_start(GTK_BOX(box2), button, TRUE, TRUE, 0);
1496 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
1497 GTK_SIGNAL_FUNC(gtk_widget_destroy),
1498 GTK_OBJECT (window));
1500 if (!GTK_WIDGET_VISIBLE (window))
1501 gtk_widget_show_all (window);
1503 gtk_widget_destroy (window);
1511 handle_box_child_signal (GtkHandleBox *hb,
1513 const gchar *action)
1515 printf ("%s: child <%s> %sed\n",
1516 gtk_type_name (GTK_OBJECT_TYPE (hb)),
1517 gtk_type_name (GTK_OBJECT_TYPE (child)),
1522 create_handle_box (void)
1524 static GtkWidget* window = NULL;
1525 GtkWidget *handle_box;
1526 GtkWidget *handle_box2;
1531 GtkWidget *separator;
1535 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
1536 gtk_window_set_title (GTK_WINDOW (window),
1538 gtk_window_set_policy (GTK_WINDOW (window),
1543 gtk_signal_connect (GTK_OBJECT (window), "destroy",
1544 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
1547 gtk_container_set_border_width (GTK_CONTAINER (window), 20);
1549 vbox = gtk_vbox_new (FALSE, 0);
1550 gtk_container_add (GTK_CONTAINER (window), vbox);
1551 gtk_widget_show (vbox);
1553 label = gtk_label_new ("Above");
1554 gtk_container_add (GTK_CONTAINER (vbox), label);
1555 gtk_widget_show (label);
1557 separator = gtk_hseparator_new ();
1558 gtk_container_add (GTK_CONTAINER (vbox), separator);
1559 gtk_widget_show (separator);
1561 hbox = gtk_hbox_new (FALSE, 10);
1562 gtk_container_add (GTK_CONTAINER (vbox), hbox);
1563 gtk_widget_show (hbox);
1565 separator = gtk_hseparator_new ();
1566 gtk_container_add (GTK_CONTAINER (vbox), separator);
1567 gtk_widget_show (separator);
1569 label = gtk_label_new ("Below");
1570 gtk_container_add (GTK_CONTAINER (vbox), label);
1571 gtk_widget_show (label);
1573 handle_box = gtk_handle_box_new ();
1574 gtk_container_add (GTK_CONTAINER (hbox), handle_box);
1575 gtk_signal_connect (GTK_OBJECT (handle_box),
1577 GTK_SIGNAL_FUNC (handle_box_child_signal),
1579 gtk_signal_connect (GTK_OBJECT (handle_box),
1581 GTK_SIGNAL_FUNC (handle_box_child_signal),
1583 gtk_widget_show (handle_box);
1585 toolbar = make_toolbar (window);
1586 gtk_toolbar_set_button_relief (GTK_TOOLBAR (toolbar), GTK_RELIEF_NORMAL);
1587 gtk_container_add (GTK_CONTAINER (handle_box), toolbar);
1588 gtk_widget_show (toolbar);
1590 handle_box = gtk_handle_box_new ();
1591 gtk_container_add (GTK_CONTAINER (hbox), handle_box);
1592 gtk_signal_connect (GTK_OBJECT (handle_box),
1594 GTK_SIGNAL_FUNC (handle_box_child_signal),
1596 gtk_signal_connect (GTK_OBJECT (handle_box),
1598 GTK_SIGNAL_FUNC (handle_box_child_signal),
1600 gtk_widget_show (handle_box);
1602 handle_box2 = gtk_handle_box_new ();
1603 gtk_container_add (GTK_CONTAINER (handle_box), handle_box2);
1604 gtk_signal_connect (GTK_OBJECT (handle_box2),
1606 GTK_SIGNAL_FUNC (handle_box_child_signal),
1608 gtk_signal_connect (GTK_OBJECT (handle_box2),
1610 GTK_SIGNAL_FUNC (handle_box_child_signal),
1612 gtk_widget_show (handle_box2);
1614 label = gtk_label_new ("Fooo!");
1615 gtk_container_add (GTK_CONTAINER (handle_box2), label);
1616 gtk_widget_show (label);
1619 if (!GTK_WIDGET_VISIBLE (window))
1620 gtk_widget_show (window);
1622 gtk_widget_destroy (window);
1628 void create_labels (void)
1630 static GtkWidget *window = NULL;
1638 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
1639 gtk_signal_connect (GTK_OBJECT (window), "destroy",
1640 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
1643 gtk_window_set_title (GTK_WINDOW (window), "Label");
1644 vbox = gtk_vbox_new (FALSE, 5);
1645 hbox = gtk_hbox_new (FALSE, 5);
1646 gtk_container_add (GTK_CONTAINER (window), hbox);
1647 gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 0);
1648 gtk_container_set_border_width (GTK_CONTAINER (window), 5);
1650 frame = gtk_frame_new ("Normal Label");
1651 label = gtk_label_new ("This is a Normal label");
1652 gtk_container_add (GTK_CONTAINER (frame), label);
1653 gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
1655 frame = gtk_frame_new ("Multi-line Label");
1656 label = gtk_label_new ("This is a Multi-line label.\nSecond line\nThird line");
1657 gtk_container_add (GTK_CONTAINER (frame), label);
1658 gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
1660 frame = gtk_frame_new ("Left Justified Label");
1661 label = gtk_label_new ("This is a Left-Justified\nMulti-line label.\nThird line");
1662 gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
1663 gtk_container_add (GTK_CONTAINER (frame), label);
1664 gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
1666 frame = gtk_frame_new ("Right Justified Label");
1667 label = gtk_label_new ("This is a Right-Justified\nMulti-line label.\nFourth line, (j/k)");
1668 gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_RIGHT);
1669 gtk_container_add (GTK_CONTAINER (frame), label);
1670 gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
1672 vbox = gtk_vbox_new (FALSE, 5);
1673 gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 0);
1674 frame = gtk_frame_new ("Line wrapped label");
1675 label = gtk_label_new ("This is an example of a line-wrapped label. It should not be taking "\
1676 "up the entire "/* big space to test spacing */\
1677 "width allocated to it, but automatically wraps the words to fit. "\
1678 "The time has come, for all good men, to come to the aid of their party. "\
1679 "The sixth sheik's six sheep's sick.\n"\
1680 " It supports multiple paragraphs correctly, and correctly adds "\
1681 "many extra spaces. ");
1683 gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
1684 gtk_container_add (GTK_CONTAINER (frame), label);
1685 gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
1687 frame = gtk_frame_new ("Filled, wrapped label");
1688 label = gtk_label_new ("This is an example of a line-wrapped, filled label. It should be taking "\
1689 "up the entire width allocated to it. Here is a seneance to prove "\
1690 "my point. Here is another sentence. "\
1691 "Here comes the sun, do de do de do.\n"\
1692 " This is a new paragraph.\n"\
1693 " This is another newer, longer, better paragraph. It is coming to an end, "\
1695 gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_FILL);
1696 gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
1697 gtk_container_add (GTK_CONTAINER (frame), label);
1698 gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
1700 frame = gtk_frame_new ("Underlined label");
1701 label = gtk_label_new ("This label is underlined!\n"
1702 "This one is underlined in ÆüËܸì¤ÎÆþÍÑquite a funky fashion");
1703 gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
1704 gtk_label_set_pattern (GTK_LABEL (label), "_________________________ _ _________ _ _____ _ __ __ ___ ____ _____");
1705 gtk_container_add (GTK_CONTAINER (frame), label);
1706 gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
1709 if (!GTK_WIDGET_VISIBLE (window))
1710 gtk_widget_show_all (window);
1712 gtk_widget_destroy (window);
1720 reparent_label (GtkWidget *widget,
1721 GtkWidget *new_parent)
1725 label = gtk_object_get_user_data (GTK_OBJECT (widget));
1727 gtk_widget_reparent (label, new_parent);
1731 set_parent_signal (GtkWidget *child,
1732 GtkWidget *old_parent,
1735 g_print ("set_parent for \"%s\": new parent: \"%s\", old parent: \"%s\", data: %d\n",
1736 gtk_type_name (GTK_OBJECT_TYPE (child)),
1737 child->parent ? gtk_type_name (GTK_OBJECT_TYPE (child->parent)) : "NULL",
1738 old_parent ? gtk_type_name (GTK_OBJECT_TYPE (old_parent)) : "NULL",
1739 GPOINTER_TO_INT (func_data));
1743 create_reparent (void)
1745 static GtkWidget *window = NULL;
1752 GtkWidget *separator;
1756 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
1758 gtk_signal_connect (GTK_OBJECT (window), "destroy",
1759 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
1762 gtk_window_set_title (GTK_WINDOW (window), "reparent");
1763 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
1765 box1 = gtk_vbox_new (FALSE, 0);
1766 gtk_container_add (GTK_CONTAINER (window), box1);
1768 box2 = gtk_hbox_new (FALSE, 5);
1769 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
1770 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
1772 label = gtk_label_new ("Hello World");
1774 frame = gtk_frame_new ("Frame 1");
1775 gtk_box_pack_start (GTK_BOX (box2), frame, TRUE, TRUE, 0);
1777 box3 = gtk_vbox_new (FALSE, 5);
1778 gtk_container_set_border_width (GTK_CONTAINER (box3), 5);
1779 gtk_container_add (GTK_CONTAINER (frame), box3);
1781 button = gtk_button_new_with_label ("switch");
1782 gtk_signal_connect (GTK_OBJECT (button), "clicked",
1783 GTK_SIGNAL_FUNC(reparent_label),
1785 gtk_object_set_user_data (GTK_OBJECT (button), label);
1786 gtk_box_pack_start (GTK_BOX (box3), button, FALSE, TRUE, 0);
1788 gtk_box_pack_start (GTK_BOX (box3), label, FALSE, TRUE, 0);
1789 gtk_signal_connect (GTK_OBJECT (label),
1791 GTK_SIGNAL_FUNC (set_parent_signal),
1792 GINT_TO_POINTER (42));
1794 frame = gtk_frame_new ("Frame 2");
1795 gtk_box_pack_start (GTK_BOX (box2), frame, TRUE, TRUE, 0);
1797 box3 = gtk_vbox_new (FALSE, 5);
1798 gtk_container_set_border_width (GTK_CONTAINER (box3), 5);
1799 gtk_container_add (GTK_CONTAINER (frame), box3);
1801 button = gtk_button_new_with_label ("switch");
1802 gtk_signal_connect (GTK_OBJECT (button), "clicked",
1803 GTK_SIGNAL_FUNC(reparent_label),
1805 gtk_object_set_user_data (GTK_OBJECT (button), label);
1806 gtk_box_pack_start (GTK_BOX (box3), button, FALSE, TRUE, 0);
1808 separator = gtk_hseparator_new ();
1809 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
1811 box2 = gtk_vbox_new (FALSE, 10);
1812 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
1813 gtk_box_pack_start (GTK_BOX (box1), box2, 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 (box2), button, TRUE, TRUE, 0);
1820 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
1821 gtk_widget_grab_default (button);
1824 if (!GTK_WIDGET_VISIBLE (window))
1825 gtk_widget_show_all (window);
1827 gtk_widget_destroy (window);
1833 gint upositionx = 0;
1834 gint upositiony = 0;
1837 uposition_configure (GtkWidget *window)
1843 lx = gtk_object_get_data (GTK_OBJECT (window), "x");
1844 ly = gtk_object_get_data (GTK_OBJECT (window), "y");
1846 gdk_window_get_root_origin (window->window, &upositionx, &upositiony);
1847 sprintf (buffer, "%d", upositionx);
1848 gtk_label_set_text (lx, buffer);
1849 sprintf (buffer, "%d", upositiony);
1850 gtk_label_set_text (ly, buffer);
1856 create_saved_position (void)
1858 static GtkWidget *window = NULL;
1863 GtkWidget *main_vbox;
1871 window = gtk_widget_new (GTK_TYPE_WINDOW,
1872 "type", GTK_WINDOW_TOPLEVEL,
1873 "signal::configure_event", uposition_configure, NULL,
1876 "title", "Saved Position",
1879 gtk_signal_connect (GTK_OBJECT (window), "destroy",
1880 GTK_SIGNAL_FUNC (gtk_widget_destroyed),
1883 main_vbox = gtk_vbox_new (FALSE, 5);
1884 gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 0);
1885 gtk_container_add (GTK_CONTAINER (window), main_vbox);
1888 gtk_widget_new (gtk_vbox_get_type (),
1889 "GtkBox::homogeneous", FALSE,
1890 "GtkBox::spacing", 5,
1891 "GtkContainer::border_width", 10,
1892 "GtkWidget::parent", main_vbox,
1893 "GtkWidget::visible", TRUE,
1896 hbox = gtk_hbox_new (FALSE, 0);
1897 gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
1898 gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0);
1900 label = gtk_label_new ("X Origin : ");
1901 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
1902 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
1904 x_label = gtk_label_new ("");
1905 gtk_box_pack_start (GTK_BOX (hbox), x_label, TRUE, TRUE, 0);
1906 gtk_object_set_data (GTK_OBJECT (window), "x", x_label);
1908 hbox = gtk_hbox_new (FALSE, 0);
1909 gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
1910 gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0);
1912 label = gtk_label_new ("Y Origin : ");
1913 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
1914 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
1916 y_label = gtk_label_new ("");
1917 gtk_box_pack_start (GTK_BOX (hbox), y_label, TRUE, TRUE, 0);
1918 gtk_object_set_data (GTK_OBJECT (window), "y", y_label);
1921 gtk_widget_new (gtk_hseparator_get_type (),
1922 "GtkWidget::visible", TRUE,
1924 gtk_box_pack_start (GTK_BOX (main_vbox), any, FALSE, TRUE, 0);
1926 hbox = gtk_hbox_new (FALSE, 0);
1927 gtk_container_set_border_width (GTK_CONTAINER (hbox), 10);
1928 gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, TRUE, 0);
1930 button = gtk_button_new_with_label ("Close");
1931 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
1932 GTK_SIGNAL_FUNC (gtk_widget_destroy),
1933 GTK_OBJECT (window));
1934 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
1935 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
1936 gtk_widget_grab_default (button);
1938 gtk_widget_show_all (window);
1941 gtk_widget_destroy (window);
1949 create_pixmap (void)
1951 static GtkWidget *window = NULL;
1957 GtkWidget *separator;
1958 GtkWidget *pixmapwid;
1964 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
1966 gtk_signal_connect (GTK_OBJECT (window), "destroy",
1967 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
1970 gtk_window_set_title (GTK_WINDOW (window), "GtkPixmap");
1971 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
1972 gtk_widget_realize(window);
1974 box1 = gtk_vbox_new (FALSE, 0);
1975 gtk_container_add (GTK_CONTAINER (window), box1);
1977 box2 = gtk_vbox_new (FALSE, 10);
1978 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
1979 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
1981 button = gtk_button_new ();
1982 gtk_box_pack_start (GTK_BOX (box2), button, FALSE, FALSE, 0);
1984 pixmap = gdk_pixmap_create_from_xpm (window->window, &mask, NULL,
1986 pixmapwid = gtk_pixmap_new (pixmap, mask);
1987 gdk_pixmap_unref (pixmap);
1988 gdk_pixmap_unref (mask);
1990 label = gtk_label_new ("Pixmap\ntest");
1991 box3 = gtk_hbox_new (FALSE, 0);
1992 gtk_container_set_border_width (GTK_CONTAINER (box3), 2);
1993 gtk_container_add (GTK_CONTAINER (box3), pixmapwid);
1994 gtk_container_add (GTK_CONTAINER (box3), label);
1995 gtk_container_add (GTK_CONTAINER (button), box3);
1997 separator = gtk_hseparator_new ();
1998 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
2000 box2 = gtk_vbox_new (FALSE, 10);
2001 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
2002 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
2004 button = gtk_button_new_with_label ("close");
2005 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
2006 GTK_SIGNAL_FUNC(gtk_widget_destroy),
2007 GTK_OBJECT (window));
2008 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
2009 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
2010 gtk_widget_grab_default (button);
2013 if (!GTK_WIDGET_VISIBLE (window))
2014 gtk_widget_show_all (window);
2016 gtk_widget_destroy (window);
2020 tips_query_widget_entered (GtkTipsQuery *tips_query,
2022 const gchar *tip_text,
2023 const gchar *tip_private,
2026 if (GTK_TOGGLE_BUTTON (toggle)->active)
2028 gtk_label_set_text (GTK_LABEL (tips_query), tip_text ? "There is a Tip!" : "There is no Tip!");
2029 /* don't let GtkTipsQuery reset it's label */
2030 gtk_signal_emit_stop_by_name (GTK_OBJECT (tips_query), "widget_entered");
2035 tips_query_widget_selected (GtkWidget *tips_query,
2037 const gchar *tip_text,
2038 const gchar *tip_private,
2039 GdkEventButton *event,
2043 g_print ("Help \"%s\" requested for <%s>\n",
2044 tip_private ? tip_private : "None",
2045 gtk_type_name (GTK_OBJECT_TYPE (widget)));
2050 create_tooltips (void)
2052 static GtkWidget *window = NULL;
2059 GtkWidget *tips_query;
2060 GtkWidget *separator;
2061 GtkTooltips *tooltips;
2066 gtk_widget_new (gtk_window_get_type (),
2067 "GtkWindow::type", GTK_WINDOW_TOPLEVEL,
2068 "GtkContainer::border_width", 0,
2069 "GtkWindow::title", "Tooltips",
2070 "GtkWindow::allow_shrink", TRUE,
2071 "GtkWindow::allow_grow", FALSE,
2072 "GtkWindow::auto_shrink", TRUE,
2073 "GtkWidget::width", 200,
2076 gtk_signal_connect (GTK_OBJECT (window), "destroy",
2077 GTK_SIGNAL_FUNC (destroy_tooltips),
2080 tooltips=gtk_tooltips_new();
2081 gtk_object_set_data (GTK_OBJECT (window), "tooltips", tooltips);
2083 box1 = gtk_vbox_new (FALSE, 0);
2084 gtk_container_add (GTK_CONTAINER (window), box1);
2086 box2 = gtk_vbox_new (FALSE, 10);
2087 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
2088 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
2090 button = gtk_toggle_button_new_with_label ("button1");
2091 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
2093 gtk_tooltips_set_tip (tooltips,button,"This is button 1", "ContextHelp/buttons/1");
2095 button = gtk_toggle_button_new_with_label ("button2");
2096 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
2098 gtk_tooltips_set_tip (tooltips,
2100 "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.",
2101 "ContextHelp/buttons/2_long");
2103 toggle = gtk_toggle_button_new_with_label ("Override TipsQuery Label");
2104 gtk_box_pack_start (GTK_BOX (box2), toggle, TRUE, TRUE, 0);
2106 gtk_tooltips_set_tip (tooltips, toggle, "Toggle TipsQuery view.", "Hi msw! ;)");
2109 gtk_widget_new (gtk_vbox_get_type (),
2110 "GtkBox::homogeneous", FALSE,
2111 "GtkBox::spacing", 5,
2112 "GtkContainer::border_width", 5,
2113 "GtkWidget::visible", TRUE,
2116 tips_query = gtk_tips_query_new ();
2119 gtk_widget_new (gtk_button_get_type (),
2120 "GtkButton::label", "[?]",
2121 "GtkWidget::visible", TRUE,
2122 "GtkWidget::parent", box3,
2123 "GtkObject::object_signal::clicked", gtk_tips_query_start_query, tips_query,
2125 gtk_box_set_child_packing (GTK_BOX (box3), button, FALSE, FALSE, 0, GTK_PACK_START);
2126 gtk_tooltips_set_tip (tooltips,
2128 "Start the Tooltips Inspector",
2129 "ContextHelp/buttons/?");
2132 gtk_widget_set (tips_query,
2133 "GtkWidget::visible", TRUE,
2134 "GtkWidget::parent", box3,
2135 "GtkTipsQuery::caller", button,
2136 "GtkObject::signal::widget_entered", tips_query_widget_entered, toggle,
2137 "GtkObject::signal::widget_selected", tips_query_widget_selected, NULL,
2141 gtk_widget_new (gtk_frame_get_type (),
2142 "GtkFrame::label", "ToolTips Inspector",
2143 "GtkFrame::label_xalign", (double) 0.5,
2144 "GtkContainer::border_width", 0,
2145 "GtkWidget::visible", TRUE,
2146 "GtkWidget::parent", box2,
2147 "GtkContainer::child", box3,
2149 gtk_box_set_child_packing (GTK_BOX (box2), frame, TRUE, TRUE, 10, GTK_PACK_START);
2151 separator = gtk_hseparator_new ();
2152 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
2154 box2 = gtk_vbox_new (FALSE, 10);
2155 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
2156 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
2158 button = gtk_button_new_with_label ("close");
2159 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
2160 GTK_SIGNAL_FUNC(gtk_widget_destroy),
2161 GTK_OBJECT (window));
2162 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
2163 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
2164 gtk_widget_grab_default (button);
2166 gtk_tooltips_set_tip (tooltips, button, "Push this button to close window", "ContextHelp/buttons/Close");
2169 if (!GTK_WIDGET_VISIBLE (window))
2170 gtk_widget_show_all (window);
2172 gtk_widget_destroy (window);
2180 create_menu (gint depth, gboolean tearoff)
2183 GtkWidget *menuitem;
2191 menu = gtk_menu_new ();
2196 menuitem = gtk_tearoff_menu_item_new ();
2197 gtk_menu_append (GTK_MENU (menu), menuitem);
2198 gtk_widget_show (menuitem);
2201 for (i = 0, j = 1; i < 5; i++, j++)
2203 sprintf (buf, "item %2d - %d", depth, j);
2204 menuitem = gtk_radio_menu_item_new_with_label (group, buf);
2205 group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menuitem));
2207 gtk_check_menu_item_set_show_toggle (GTK_CHECK_MENU_ITEM (menuitem), TRUE);
2208 gtk_menu_append (GTK_MENU (menu), menuitem);
2209 gtk_widget_show (menuitem);
2211 gtk_widget_set_sensitive (menuitem, FALSE);
2213 gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), create_menu (depth - 1, TRUE));
2222 static GtkWidget *window = NULL;
2226 GtkWidget *optionmenu;
2227 GtkWidget *separator;
2233 GtkWidget *menuitem;
2234 GtkAccelGroup *accel_group;
2236 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
2238 gtk_signal_connect (GTK_OBJECT (window), "destroy",
2239 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
2241 gtk_signal_connect (GTK_OBJECT (window), "delete-event",
2242 GTK_SIGNAL_FUNC (gtk_true),
2245 accel_group = gtk_accel_group_new ();
2246 gtk_accel_group_attach (accel_group, GTK_OBJECT (window));
2248 gtk_window_set_title (GTK_WINDOW (window), "menus");
2249 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
2252 box1 = gtk_vbox_new (FALSE, 0);
2253 gtk_container_add (GTK_CONTAINER (window), box1);
2254 gtk_widget_show (box1);
2256 menubar = gtk_menu_bar_new ();
2257 gtk_box_pack_start (GTK_BOX (box1), menubar, FALSE, TRUE, 0);
2258 gtk_widget_show (menubar);
2260 menu = create_menu (2, TRUE);
2262 menuitem = gtk_menu_item_new_with_label ("test\nline2");
2263 gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), menu);
2264 gtk_menu_bar_append (GTK_MENU_BAR (menubar), menuitem);
2265 gtk_widget_show (menuitem);
2267 menuitem = gtk_menu_item_new_with_label ("foo");
2268 gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), create_menu (3, TRUE));
2269 gtk_menu_bar_append (GTK_MENU_BAR (menubar), menuitem);
2270 gtk_widget_show (menuitem);
2272 menuitem = gtk_menu_item_new_with_label ("bar");
2273 gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), create_menu (4, TRUE));
2274 gtk_menu_item_right_justify (GTK_MENU_ITEM (menuitem));
2275 gtk_menu_bar_append (GTK_MENU_BAR (menubar), menuitem);
2276 gtk_widget_show (menuitem);
2278 box2 = gtk_vbox_new (FALSE, 10);
2279 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
2280 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
2281 gtk_widget_show (box2);
2283 menu = create_menu (1, FALSE);
2284 gtk_menu_set_accel_group (GTK_MENU (menu), accel_group);
2286 menuitem = gtk_check_menu_item_new_with_label ("Accelerate Me");
2287 gtk_menu_append (GTK_MENU (menu), menuitem);
2288 gtk_widget_show (menuitem);
2289 gtk_widget_add_accelerator (menuitem,
2294 GTK_ACCEL_VISIBLE | GTK_ACCEL_SIGNAL_VISIBLE);
2295 menuitem = gtk_check_menu_item_new_with_label ("Accelerator Locked");
2296 gtk_menu_append (GTK_MENU (menu), menuitem);
2297 gtk_widget_show (menuitem);
2298 gtk_widget_add_accelerator (menuitem,
2303 GTK_ACCEL_VISIBLE | GTK_ACCEL_LOCKED);
2304 menuitem = gtk_check_menu_item_new_with_label ("Accelerators Frozen");
2305 gtk_menu_append (GTK_MENU (menu), menuitem);
2306 gtk_widget_show (menuitem);
2307 gtk_widget_add_accelerator (menuitem,
2313 gtk_widget_add_accelerator (menuitem,
2319 gtk_widget_lock_accelerators (menuitem);
2321 optionmenu = gtk_option_menu_new ();
2322 gtk_option_menu_set_menu (GTK_OPTION_MENU (optionmenu), menu);
2323 gtk_option_menu_set_history (GTK_OPTION_MENU (optionmenu), 3);
2324 gtk_box_pack_start (GTK_BOX (box2), optionmenu, TRUE, TRUE, 0);
2325 gtk_widget_show (optionmenu);
2327 separator = gtk_hseparator_new ();
2328 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
2329 gtk_widget_show (separator);
2331 box2 = gtk_vbox_new (FALSE, 10);
2332 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
2333 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
2334 gtk_widget_show (box2);
2336 button = gtk_button_new_with_label ("close");
2337 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
2338 GTK_SIGNAL_FUNC(gtk_widget_destroy),
2339 GTK_OBJECT (window));
2340 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
2341 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
2342 gtk_widget_grab_default (button);
2343 gtk_widget_show (button);
2346 if (!GTK_WIDGET_VISIBLE (window))
2347 gtk_widget_show (window);
2349 gtk_widget_destroy (window);
2353 gtk_ifactory_cb (gpointer callback_data,
2354 guint callback_action,
2357 g_message ("ItemFactory: activated \"%s\"", gtk_item_factory_path_from_widget (widget));
2360 static GtkItemFactoryEntry menu_items[] =
2362 { "/_File", NULL, 0, 0, "<Branch>" },
2363 { "/File/tearoff1", NULL, gtk_ifactory_cb, 0, "<Tearoff>" },
2364 { "/File/_New", "<control>N", gtk_ifactory_cb, 0 },
2365 { "/File/_Open", "<control>O", gtk_ifactory_cb, 0 },
2366 { "/File/_Save", "<control>S", gtk_ifactory_cb, 0 },
2367 { "/File/Save _As...", NULL, gtk_ifactory_cb, 0 },
2368 { "/File/sep1", NULL, gtk_ifactory_cb, 0, "<Separator>" },
2369 { "/File/_Quit", "<control>Q", gtk_ifactory_cb, 0 },
2371 { "/_Preferences", NULL, 0, 0, "<Branch>" },
2372 { "/_Preferences/_Color", NULL, 0, 0, "<Branch>" },
2373 { "/_Preferences/Color/_Red", NULL, gtk_ifactory_cb, 0, "<RadioItem>" },
2374 { "/_Preferences/Color/_Green", NULL, gtk_ifactory_cb, 0, "<RadioItem>" },
2375 { "/_Preferences/Color/_Blue", NULL, gtk_ifactory_cb, 0, "<RadioItem>" },
2376 { "/_Preferences/_Shape", NULL, 0, 0, "<Branch>" },
2377 { "/_Preferences/Shape/_Square", NULL, gtk_ifactory_cb, 0, "<RadioItem>" },
2378 { "/_Preferences/Shape/_Rectangle", NULL, gtk_ifactory_cb, 0, "<RadioItem>" },
2379 { "/_Preferences/Shape/_Oval", NULL, gtk_ifactory_cb, 0, "<RadioItem>" },
2381 { "/_Help", NULL, 0, 0, "<LastBranch>" },
2382 { "/Help/_About", NULL, gtk_ifactory_cb, 0 },
2385 static int nmenu_items = sizeof (menu_items) / sizeof (menu_items[0]);
2388 create_item_factory (void)
2390 static GtkWidget *window = NULL;
2396 GtkWidget *separator;
2399 GtkAccelGroup *accel_group;
2400 GtkItemFactory *item_factory;
2402 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
2404 gtk_signal_connect (GTK_OBJECT (window), "destroy",
2405 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
2407 gtk_signal_connect (GTK_OBJECT (window), "delete-event",
2408 GTK_SIGNAL_FUNC (gtk_true),
2411 accel_group = gtk_accel_group_new ();
2412 item_factory = gtk_item_factory_new (GTK_TYPE_MENU_BAR, "<main>", accel_group);
2413 gtk_item_factory_create_items (item_factory, nmenu_items, menu_items, NULL);
2414 gtk_accel_group_attach (accel_group, GTK_OBJECT (window));
2415 gtk_window_set_title (GTK_WINDOW (window), "Item Factory");
2416 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
2418 box1 = gtk_vbox_new (FALSE, 0);
2419 gtk_container_add (GTK_CONTAINER (window), box1);
2421 gtk_box_pack_start (GTK_BOX (box1),
2422 gtk_item_factory_get_widget (item_factory, "<main>"),
2425 label = gtk_label_new ("Type\n<alt>\nto start");
2426 gtk_widget_set_usize (label, 200, 200);
2427 gtk_misc_set_alignment (GTK_MISC (label), 0.5, 0.5);
2428 gtk_box_pack_start (GTK_BOX (box1), label, TRUE, TRUE, 0);
2431 separator = gtk_hseparator_new ();
2432 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
2435 box2 = gtk_vbox_new (FALSE, 10);
2436 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
2437 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
2439 button = gtk_button_new_with_label ("close");
2440 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
2441 GTK_SIGNAL_FUNC(gtk_widget_destroy),
2442 GTK_OBJECT (window));
2443 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
2444 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
2445 gtk_widget_grab_default (button);
2447 gtk_widget_show_all (window);
2450 gtk_widget_destroy (window);
2458 scrolled_windows_remove (GtkWidget *widget, GtkWidget *scrollwin)
2460 static GtkWidget *parent = NULL;
2461 static GtkWidget *float_parent;
2465 gtk_widget_reparent (scrollwin, parent);
2466 gtk_widget_destroy (float_parent);
2467 float_parent = NULL;
2472 parent = widget->parent;
2473 float_parent = gtk_window_new (GTK_WINDOW_TOPLEVEL);
2474 gtk_widget_reparent (scrollwin, float_parent);
2475 gtk_widget_show (float_parent);
2484 cmw_destroy_cb(GtkWidget *widget)
2486 /* This is needed to get out of gtk_main */
2493 cmw_color (GtkWidget *widget, GtkWidget *parent)
2497 csd=gtk_color_selection_dialog_new ("This is a modal color selection dialog");
2500 gtk_window_set_modal (GTK_WINDOW(csd),TRUE);
2502 /* And mark it as a transient dialog */
2503 gtk_window_set_transient_for (GTK_WINDOW (csd), GTK_WINDOW (parent));
2505 gtk_signal_connect (GTK_OBJECT(csd), "destroy",
2506 GTK_SIGNAL_FUNC(cmw_destroy_cb),NULL);
2508 gtk_signal_connect_object (GTK_OBJECT(GTK_COLOR_SELECTION_DIALOG(csd)->ok_button),
2509 "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy),
2511 gtk_signal_connect_object (GTK_OBJECT(GTK_COLOR_SELECTION_DIALOG(csd)->cancel_button),
2512 "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy),
2515 /* wait until destroy calls gtk_main_quit */
2516 gtk_widget_show (csd);
2521 cmw_file (GtkWidget *widget, GtkWidget *parent)
2525 fs = gtk_file_selection_new("This is a modal file selection dialog");
2528 gtk_window_set_modal (GTK_WINDOW(fs),TRUE);
2530 /* And mark it as a transient dialog */
2531 gtk_window_set_transient_for (GTK_WINDOW (fs), GTK_WINDOW (parent));
2533 gtk_signal_connect (GTK_OBJECT(fs), "destroy",
2534 GTK_SIGNAL_FUNC(cmw_destroy_cb),NULL);
2536 gtk_signal_connect_object (GTK_OBJECT(GTK_FILE_SELECTION(fs)->ok_button),
2537 "clicked",GTK_SIGNAL_FUNC(gtk_widget_destroy),
2539 gtk_signal_connect_object (GTK_OBJECT(GTK_FILE_SELECTION(fs)->cancel_button),
2540 "clicked",GTK_SIGNAL_FUNC(gtk_widget_destroy),
2543 /* wait until destroy calls gtk_main_quit */
2544 gtk_widget_show (fs);
2551 create_modal_window (void)
2553 GtkWidget *window = NULL;
2554 GtkWidget *box1,*box2;
2556 GtkWidget *btnColor,*btnFile,*btnClose;
2558 /* Create modal window (Here you can use any window descendent )*/
2559 window=gtk_window_new (GTK_WINDOW_TOPLEVEL);
2560 gtk_window_set_title (GTK_WINDOW(window),"This window is modal");
2562 /* Set window as modal */
2563 gtk_window_set_modal (GTK_WINDOW(window),TRUE);
2565 /* Create widgets */
2566 box1 = gtk_vbox_new (FALSE,5);
2567 frame1 = gtk_frame_new ("Standard dialogs in modal form");
2568 box2 = gtk_vbox_new (TRUE,5);
2569 btnColor = gtk_button_new_with_label ("Color");
2570 btnFile = gtk_button_new_with_label ("File Selection");
2571 btnClose = gtk_button_new_with_label ("Close");
2574 gtk_container_set_border_width (GTK_CONTAINER(box1),3);
2575 gtk_container_set_border_width (GTK_CONTAINER(box2),3);
2578 gtk_container_add (GTK_CONTAINER (window), box1);
2579 gtk_box_pack_start (GTK_BOX (box1), frame1, TRUE, TRUE, 4);
2580 gtk_container_add (GTK_CONTAINER (frame1), box2);
2581 gtk_box_pack_start (GTK_BOX (box2), btnColor, FALSE, FALSE, 4);
2582 gtk_box_pack_start (GTK_BOX (box2), btnFile, FALSE, FALSE, 4);
2583 gtk_box_pack_start (GTK_BOX (box1), gtk_hseparator_new (), FALSE, FALSE, 4);
2584 gtk_box_pack_start (GTK_BOX (box1), btnClose, FALSE, FALSE, 4);
2586 /* connect signals */
2587 gtk_signal_connect_object (GTK_OBJECT (btnClose), "clicked",
2588 GTK_SIGNAL_FUNC (gtk_widget_destroy),
2589 GTK_OBJECT (window));
2591 gtk_signal_connect (GTK_OBJECT (window), "destroy",
2592 GTK_SIGNAL_FUNC (cmw_destroy_cb),NULL);
2594 gtk_signal_connect (GTK_OBJECT (btnColor), "clicked",
2595 GTK_SIGNAL_FUNC (cmw_color),window);
2596 gtk_signal_connect (GTK_OBJECT (btnFile), "clicked",
2597 GTK_SIGNAL_FUNC (cmw_file),window);
2600 gtk_widget_show_all (window);
2602 /* wait until dialog get destroyed */
2611 create_scrolled_windows (void)
2613 static GtkWidget *window;
2614 GtkWidget *scrolled_window;
2622 window = gtk_dialog_new ();
2624 gtk_signal_connect (GTK_OBJECT (window), "destroy",
2625 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
2628 gtk_window_set_title (GTK_WINDOW (window), "dialog");
2629 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
2632 scrolled_window = gtk_scrolled_window_new (NULL, NULL);
2633 gtk_container_set_border_width (GTK_CONTAINER (scrolled_window), 10);
2634 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
2635 GTK_POLICY_AUTOMATIC,
2636 GTK_POLICY_AUTOMATIC);
2637 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox),
2638 scrolled_window, TRUE, TRUE, 0);
2639 gtk_widget_show (scrolled_window);
2641 table = gtk_table_new (20, 20, FALSE);
2642 gtk_table_set_row_spacings (GTK_TABLE (table), 10);
2643 gtk_table_set_col_spacings (GTK_TABLE (table), 10);
2644 gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (scrolled_window), table);
2645 gtk_container_set_focus_hadjustment (GTK_CONTAINER (table),
2646 gtk_scrolled_window_get_hadjustment (GTK_SCROLLED_WINDOW (scrolled_window)));
2647 gtk_container_set_focus_vadjustment (GTK_CONTAINER (table),
2648 gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (scrolled_window)));
2649 gtk_widget_show (table);
2651 for (i = 0; i < 20; i++)
2652 for (j = 0; j < 20; j++)
2654 sprintf (buffer, "button (%d,%d)\n", i, j);
2655 button = gtk_toggle_button_new_with_label (buffer);
2656 gtk_table_attach_defaults (GTK_TABLE (table), button,
2658 gtk_widget_show (button);
2662 button = gtk_button_new_with_label ("close");
2663 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
2664 GTK_SIGNAL_FUNC(gtk_widget_destroy),
2665 GTK_OBJECT (window));
2666 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
2667 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
2668 button, TRUE, TRUE, 0);
2669 gtk_widget_grab_default (button);
2670 gtk_widget_show (button);
2672 button = gtk_button_new_with_label ("remove");
2673 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
2674 GTK_SIGNAL_FUNC(scrolled_windows_remove),
2675 GTK_OBJECT (scrolled_window));
2676 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
2677 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
2678 button, TRUE, TRUE, 0);
2679 gtk_widget_grab_default (button);
2680 gtk_widget_show (button);
2682 gtk_window_set_default_size (GTK_WINDOW (window), 300, 300);
2685 if (!GTK_WIDGET_VISIBLE (window))
2686 gtk_widget_show (window);
2688 gtk_widget_destroy (window);
2696 entry_toggle_editable (GtkWidget *checkbutton,
2699 gtk_entry_set_editable(GTK_ENTRY(entry),
2700 GTK_TOGGLE_BUTTON(checkbutton)->active);
2704 entry_toggle_sensitive (GtkWidget *checkbutton,
2707 gtk_widget_set_sensitive (entry, GTK_TOGGLE_BUTTON(checkbutton)->active);
2711 entry_toggle_visibility (GtkWidget *checkbutton,
2714 gtk_entry_set_visibility(GTK_ENTRY(entry),
2715 GTK_TOGGLE_BUTTON(checkbutton)->active);
2721 static GtkWidget *window = NULL;
2724 GtkWidget *editable_check;
2725 GtkWidget *sensitive_check;
2726 GtkWidget *entry, *cb;
2728 GtkWidget *separator;
2729 GList *cbitems = NULL;
2733 cbitems = g_list_append(cbitems, "item0");
2734 cbitems = g_list_append(cbitems, "item1 item1");
2735 cbitems = g_list_append(cbitems, "item2 item2 item2");
2736 cbitems = g_list_append(cbitems, "item3 item3 item3 item3");
2737 cbitems = g_list_append(cbitems, "item4 item4 item4 item4 item4");
2738 cbitems = g_list_append(cbitems, "item5 item5 item5 item5 item5 item5");
2739 cbitems = g_list_append(cbitems, "item6 item6 item6 item6 item6");
2740 cbitems = g_list_append(cbitems, "item7 item7 item7 item7");
2741 cbitems = g_list_append(cbitems, "item8 item8 item8");
2742 cbitems = g_list_append(cbitems, "item9 item9");
2744 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
2746 gtk_signal_connect (GTK_OBJECT (window), "destroy",
2747 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
2750 gtk_window_set_title (GTK_WINDOW (window), "entry");
2751 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
2754 box1 = gtk_vbox_new (FALSE, 0);
2755 gtk_container_add (GTK_CONTAINER (window), box1);
2756 gtk_widget_show (box1);
2759 box2 = gtk_vbox_new (FALSE, 10);
2760 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
2761 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
2762 gtk_widget_show (box2);
2764 entry = gtk_entry_new ();
2765 gtk_entry_set_text (GTK_ENTRY (entry), "hello world");
2766 gtk_editable_select_region (GTK_EDITABLE (entry), 0, 5);
2767 gtk_box_pack_start (GTK_BOX (box2), entry, TRUE, TRUE, 0);
2768 gtk_widget_show (entry);
2770 cb = gtk_combo_new ();
2771 gtk_combo_set_popdown_strings (GTK_COMBO (cb), cbitems);
2772 gtk_entry_set_text (GTK_ENTRY (GTK_COMBO(cb)->entry), "hello world");
2773 gtk_editable_select_region (GTK_EDITABLE (GTK_COMBO(cb)->entry),
2775 gtk_box_pack_start (GTK_BOX (box2), cb, TRUE, TRUE, 0);
2776 gtk_widget_show (cb);
2778 editable_check = gtk_check_button_new_with_label("Editable");
2779 gtk_box_pack_start (GTK_BOX (box2), editable_check, FALSE, TRUE, 0);
2780 gtk_signal_connect (GTK_OBJECT(editable_check), "toggled",
2781 GTK_SIGNAL_FUNC(entry_toggle_editable), entry);
2782 gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(editable_check), TRUE);
2783 gtk_widget_show (editable_check);
2785 editable_check = gtk_check_button_new_with_label("Visible");
2786 gtk_box_pack_start (GTK_BOX (box2), editable_check, FALSE, TRUE, 0);
2787 gtk_signal_connect (GTK_OBJECT(editable_check), "toggled",
2788 GTK_SIGNAL_FUNC(entry_toggle_visibility), entry);
2789 gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(editable_check), TRUE);
2790 gtk_widget_show (editable_check);
2792 sensitive_check = gtk_check_button_new_with_label("Sensitive");
2793 gtk_box_pack_start (GTK_BOX (box2), sensitive_check, FALSE, TRUE, 0);
2794 gtk_signal_connect (GTK_OBJECT(sensitive_check), "toggled",
2795 GTK_SIGNAL_FUNC(entry_toggle_sensitive), entry);
2796 gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(sensitive_check), TRUE);
2797 gtk_widget_show (sensitive_check);
2799 separator = gtk_hseparator_new ();
2800 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
2801 gtk_widget_show (separator);
2804 box2 = gtk_vbox_new (FALSE, 10);
2805 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
2806 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
2807 gtk_widget_show (box2);
2810 button = gtk_button_new_with_label ("close");
2811 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
2812 GTK_SIGNAL_FUNC(gtk_widget_destroy),
2813 GTK_OBJECT (window));
2814 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
2815 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
2816 gtk_widget_grab_default (button);
2817 gtk_widget_show (button);
2820 if (!GTK_WIDGET_VISIBLE (window))
2821 gtk_widget_show (window);
2823 gtk_widget_destroy (window);
2830 static GtkWidget *spinner1;
2833 toggle_snap (GtkWidget *widget, GtkSpinButton *spin)
2835 gtk_spin_button_set_snap_to_ticks (spin, GTK_TOGGLE_BUTTON (widget)->active);
2839 toggle_numeric (GtkWidget *widget, GtkSpinButton *spin)
2841 gtk_spin_button_set_numeric (spin, GTK_TOGGLE_BUTTON (widget)->active);
2845 change_digits (GtkWidget *widget, GtkSpinButton *spin)
2847 gtk_spin_button_set_digits (GTK_SPIN_BUTTON (spinner1),
2848 gtk_spin_button_get_value_as_int (spin));
2852 get_value (GtkWidget *widget, gpointer data)
2856 GtkSpinButton *spin;
2858 spin = GTK_SPIN_BUTTON (spinner1);
2859 label = GTK_LABEL (gtk_object_get_user_data (GTK_OBJECT (widget)));
2860 if (GPOINTER_TO_INT (data) == 1)
2861 sprintf (buf, "%d", gtk_spin_button_get_value_as_int (spin));
2863 sprintf (buf, "%0.*f", spin->digits,
2864 gtk_spin_button_get_value_as_float (spin));
2865 gtk_label_set_text (label, buf);
2871 static GtkWidget *window = NULL;
2874 GtkWidget *main_vbox;
2877 GtkWidget *spinner2;
2881 GtkWidget *val_label;
2886 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
2888 gtk_signal_connect (GTK_OBJECT (window), "destroy",
2889 GTK_SIGNAL_FUNC (gtk_widget_destroyed),
2892 gtk_window_set_title (GTK_WINDOW (window), "GtkSpinButton");
2894 main_vbox = gtk_vbox_new (FALSE, 5);
2895 gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 10);
2896 gtk_container_add (GTK_CONTAINER (window), main_vbox);
2898 frame = gtk_frame_new ("Not accelerated");
2899 gtk_box_pack_start (GTK_BOX (main_vbox), frame, TRUE, TRUE, 0);
2901 vbox = gtk_vbox_new (FALSE, 0);
2902 gtk_container_set_border_width (GTK_CONTAINER (vbox), 5);
2903 gtk_container_add (GTK_CONTAINER (frame), vbox);
2905 /* Day, month, year spinners */
2907 hbox = gtk_hbox_new (FALSE, 0);
2908 gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 5);
2910 vbox2 = gtk_vbox_new (FALSE, 0);
2911 gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 5);
2913 label = gtk_label_new ("Day :");
2914 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
2915 gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, TRUE, 0);
2917 adj = (GtkAdjustment *) gtk_adjustment_new (1.0, 1.0, 31.0, 1.0,
2919 spinner = gtk_spin_button_new (adj, 0, 0);
2920 gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spinner), TRUE);
2921 gtk_spin_button_set_shadow_type (GTK_SPIN_BUTTON (spinner),
2923 gtk_box_pack_start (GTK_BOX (vbox2), spinner, FALSE, TRUE, 0);
2925 vbox2 = gtk_vbox_new (FALSE, 0);
2926 gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 5);
2928 label = gtk_label_new ("Month :");
2929 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
2930 gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, TRUE, 0);
2932 adj = (GtkAdjustment *) gtk_adjustment_new (1.0, 1.0, 12.0, 1.0,
2934 spinner = gtk_spin_button_new (adj, 0, 0);
2935 gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spinner), TRUE);
2936 gtk_spin_button_set_shadow_type (GTK_SPIN_BUTTON (spinner),
2937 GTK_SHADOW_ETCHED_IN);
2938 gtk_box_pack_start (GTK_BOX (vbox2), spinner, FALSE, TRUE, 0);
2940 vbox2 = gtk_vbox_new (FALSE, 0);
2941 gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 5);
2943 label = gtk_label_new ("Year :");
2944 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
2945 gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, TRUE, 0);
2947 adj = (GtkAdjustment *) gtk_adjustment_new (1998.0, 0.0, 2100.0,
2949 spinner = gtk_spin_button_new (adj, 0, 0);
2950 gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spinner), TRUE);
2951 gtk_spin_button_set_shadow_type (GTK_SPIN_BUTTON (spinner),
2953 gtk_widget_set_usize (spinner, 55, 0);
2954 gtk_box_pack_start (GTK_BOX (vbox2), spinner, FALSE, TRUE, 0);
2956 frame = gtk_frame_new ("Accelerated");
2957 gtk_box_pack_start (GTK_BOX (main_vbox), frame, TRUE, TRUE, 0);
2959 vbox = gtk_vbox_new (FALSE, 0);
2960 gtk_container_set_border_width (GTK_CONTAINER (vbox), 5);
2961 gtk_container_add (GTK_CONTAINER (frame), vbox);
2963 hbox = gtk_hbox_new (FALSE, 0);
2964 gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 5);
2966 vbox2 = gtk_vbox_new (FALSE, 0);
2967 gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 5);
2969 label = gtk_label_new ("Value :");
2970 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
2971 gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, TRUE, 0);
2973 adj = (GtkAdjustment *) gtk_adjustment_new (0.0, -10000.0, 10000.0,
2975 spinner1 = gtk_spin_button_new (adj, 1.0, 2);
2976 gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spinner1), TRUE);
2977 gtk_widget_set_usize (spinner1, 100, 0);
2978 gtk_box_pack_start (GTK_BOX (vbox2), spinner1, FALSE, TRUE, 0);
2980 vbox2 = gtk_vbox_new (FALSE, 0);
2981 gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 5);
2983 label = gtk_label_new ("Digits :");
2984 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
2985 gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, TRUE, 0);
2987 adj = (GtkAdjustment *) gtk_adjustment_new (2, 1, 5, 1, 1, 0);
2988 spinner2 = gtk_spin_button_new (adj, 0.0, 0);
2989 gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spinner2), TRUE);
2990 gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
2991 GTK_SIGNAL_FUNC (change_digits),
2992 (gpointer) spinner2);
2993 gtk_box_pack_start (GTK_BOX (vbox2), spinner2, FALSE, TRUE, 0);
2995 hbox = gtk_hbox_new (FALSE, 0);
2996 gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 5);
2998 button = gtk_check_button_new_with_label ("Snap to 0.5-ticks");
2999 gtk_signal_connect (GTK_OBJECT (button), "clicked",
3000 GTK_SIGNAL_FUNC (toggle_snap),
3002 gtk_box_pack_start (GTK_BOX (vbox), button, TRUE, TRUE, 0);
3003 gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON (button), TRUE);
3005 button = gtk_check_button_new_with_label ("Numeric only input mode");
3006 gtk_signal_connect (GTK_OBJECT (button), "clicked",
3007 GTK_SIGNAL_FUNC (toggle_numeric),
3009 gtk_box_pack_start (GTK_BOX (vbox), button, TRUE, TRUE, 0);
3010 gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON (button), TRUE);
3012 val_label = gtk_label_new ("");
3014 hbox = gtk_hbox_new (FALSE, 0);
3015 gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 5);
3017 button = gtk_button_new_with_label ("Value as Int");
3018 gtk_object_set_user_data (GTK_OBJECT (button), val_label);
3019 gtk_signal_connect (GTK_OBJECT (button), "clicked",
3020 GTK_SIGNAL_FUNC (get_value),
3021 GINT_TO_POINTER (1));
3022 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
3024 button = gtk_button_new_with_label ("Value as Float");
3025 gtk_object_set_user_data (GTK_OBJECT (button), val_label);
3026 gtk_signal_connect (GTK_OBJECT (button), "clicked",
3027 GTK_SIGNAL_FUNC (get_value),
3028 GINT_TO_POINTER (2));
3029 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
3031 gtk_box_pack_start (GTK_BOX (vbox), val_label, TRUE, TRUE, 0);
3032 gtk_label_set_text (GTK_LABEL (val_label), "0");
3034 hbox = gtk_hbox_new (FALSE, 0);
3035 gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, TRUE, 0);
3037 button = gtk_button_new_with_label ("Close");
3038 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
3039 GTK_SIGNAL_FUNC (gtk_widget_destroy),
3040 GTK_OBJECT (window));
3041 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
3044 if (!GTK_WIDGET_VISIBLE (window))
3045 gtk_widget_show_all (window);
3047 gtk_widget_destroy (window);
3055 cursor_expose_event (GtkWidget *widget,
3059 GtkDrawingArea *darea;
3060 GdkDrawable *drawable;
3067 g_return_val_if_fail (widget != NULL, TRUE);
3068 g_return_val_if_fail (GTK_IS_DRAWING_AREA (widget), TRUE);
3070 darea = GTK_DRAWING_AREA (widget);
3071 drawable = widget->window;
3072 white_gc = widget->style->white_gc;
3073 gray_gc = widget->style->bg_gc[GTK_STATE_NORMAL];
3074 black_gc = widget->style->black_gc;
3075 max_width = widget->allocation.width;
3076 max_height = widget->allocation.height;
3078 gdk_draw_rectangle (drawable, white_gc,
3085 gdk_draw_rectangle (drawable, black_gc,
3092 gdk_draw_rectangle (drawable, gray_gc,
3103 set_cursor (GtkWidget *spinner,
3111 c = CLAMP (gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (spinner)), 0, 152);
3114 label = gtk_object_get_user_data (GTK_OBJECT (spinner));
3115 vals = gtk_type_enum_get_values (GTK_TYPE_GDK_CURSOR_TYPE);
3116 while (vals && vals->value != c)
3119 gtk_label_set_text (GTK_LABEL (label), vals->value_nick);
3121 gtk_label_set_text (GTK_LABEL (label), "<unknown>");
3123 cursor = gdk_cursor_new (c);
3124 gdk_window_set_cursor (widget->window, cursor);
3125 gdk_cursor_destroy (cursor);
3129 cursor_event (GtkWidget *widget,
3131 GtkSpinButton *spinner)
3133 if ((event->type == GDK_BUTTON_PRESS) &&
3134 ((event->button.button == 1) ||
3135 (event->button.button == 3)))
3137 gtk_spin_button_spin (spinner, event->button.button == 1 ?
3138 GTK_SPIN_STEP_FORWARD : GTK_SPIN_STEP_BACKWARD, 0);
3146 create_cursors (void)
3148 static GtkWidget *window = NULL;
3151 GtkWidget *main_vbox;
3162 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
3164 gtk_signal_connect (GTK_OBJECT (window), "destroy",
3165 GTK_SIGNAL_FUNC (gtk_widget_destroyed),
3168 gtk_window_set_title (GTK_WINDOW (window), "Cursors");
3170 main_vbox = gtk_vbox_new (FALSE, 5);
3171 gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 0);
3172 gtk_container_add (GTK_CONTAINER (window), main_vbox);
3175 gtk_widget_new (gtk_vbox_get_type (),
3176 "GtkBox::homogeneous", FALSE,
3177 "GtkBox::spacing", 5,
3178 "GtkContainer::border_width", 10,
3179 "GtkWidget::parent", main_vbox,
3180 "GtkWidget::visible", TRUE,
3183 hbox = gtk_hbox_new (FALSE, 0);
3184 gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
3185 gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0);
3187 label = gtk_label_new ("Cursor Value : ");
3188 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
3189 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
3191 adj = (GtkAdjustment *) gtk_adjustment_new (0,
3195 spinner = gtk_spin_button_new (adj, 0, 0);
3196 gtk_box_pack_start (GTK_BOX (hbox), spinner, TRUE, TRUE, 0);
3199 gtk_widget_new (gtk_frame_get_type (),
3200 "GtkFrame::shadow", GTK_SHADOW_ETCHED_IN,
3201 "GtkFrame::label_xalign", 0.5,
3202 "GtkFrame::label", "Cursor Area",
3203 "GtkContainer::border_width", 10,
3204 "GtkWidget::parent", vbox,
3205 "GtkWidget::visible", TRUE,
3208 darea = gtk_drawing_area_new ();
3209 gtk_widget_set_usize (darea, 80, 80);
3210 gtk_container_add (GTK_CONTAINER (frame), darea);
3211 gtk_signal_connect (GTK_OBJECT (darea),
3213 GTK_SIGNAL_FUNC (cursor_expose_event),
3215 gtk_widget_set_events (darea, GDK_EXPOSURE_MASK | GDK_BUTTON_PRESS_MASK);
3216 gtk_signal_connect (GTK_OBJECT (darea),
3217 "button_press_event",
3218 GTK_SIGNAL_FUNC (cursor_event),
3220 gtk_widget_show (darea);
3222 gtk_signal_connect (GTK_OBJECT (spinner), "changed",
3223 GTK_SIGNAL_FUNC (set_cursor),
3226 label = gtk_widget_new (GTK_TYPE_LABEL,
3231 gtk_container_child_set (GTK_CONTAINER (vbox), label,
3234 gtk_object_set_user_data (GTK_OBJECT (spinner), label);
3237 gtk_widget_new (gtk_hseparator_get_type (),
3238 "GtkWidget::visible", TRUE,
3240 gtk_box_pack_start (GTK_BOX (main_vbox), any, FALSE, TRUE, 0);
3242 hbox = gtk_hbox_new (FALSE, 0);
3243 gtk_container_set_border_width (GTK_CONTAINER (hbox), 10);
3244 gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, TRUE, 0);
3246 button = gtk_button_new_with_label ("Close");
3247 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
3248 GTK_SIGNAL_FUNC (gtk_widget_destroy),
3249 GTK_OBJECT (window));
3250 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
3252 gtk_widget_show_all (window);
3254 set_cursor (spinner, darea);
3257 gtk_widget_destroy (window);
3265 list_add (GtkWidget *widget,
3270 GtkWidget *list_item;
3271 GtkContainer *container;
3273 container = GTK_CONTAINER (list);
3275 sprintf (buffer, "added item %d", i++);
3276 list_item = gtk_list_item_new_with_label (buffer);
3277 gtk_widget_show (list_item);
3279 gtk_container_add (container, list_item);
3283 list_remove (GtkWidget *widget,
3289 tmp_list = GTK_LIST (list)->selection;
3294 clear_list = g_list_prepend (clear_list, tmp_list->data);
3295 tmp_list = tmp_list->next;
3298 clear_list = g_list_reverse (clear_list);
3300 gtk_list_remove_items (GTK_LIST (list), clear_list);
3302 g_list_free (clear_list);
3306 list_clear (GtkWidget *widget,
3309 gtk_list_clear_items (GTK_LIST (list), 0, -1);
3313 list_undo_selection (GtkWidget *widget,
3316 gtk_list_undo_selection (GTK_LIST (list));
3319 #define RADIOMENUTOGGLED(_rmi_, __i) { \
3322 __g = gtk_radio_menu_item_group(_rmi_); \
3323 while( __g && !((GtkCheckMenuItem *)(__g->data))->active) { \
3329 static GtkWidget *list_omenu;
3332 list_toggle_sel_mode (GtkWidget *widget, GtkList *list)
3336 if (!GTK_WIDGET_MAPPED (widget))
3339 RADIOMENUTOGGLED ((GtkRadioMenuItem *)
3340 (((GtkOptionMenu *)list_omenu)->menu_item), i);
3342 gtk_list_set_selection_mode (list, (GtkSelectionMode) (3-i));
3348 static GtkWidget *window = NULL;
3353 GtkWidget *scrolled_win;
3356 GtkWidget *separator;
3358 GtkWidget *menu_item;
3364 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
3366 gtk_signal_connect (GTK_OBJECT (window), "destroy",
3367 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
3370 gtk_window_set_title (GTK_WINDOW (window), "list");
3371 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
3373 box1 = gtk_vbox_new (FALSE, 0);
3374 gtk_container_add (GTK_CONTAINER (window), box1);
3376 box2 = gtk_vbox_new (FALSE, 10);
3377 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
3378 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
3380 scrolled_win = gtk_scrolled_window_new (NULL, NULL);
3381 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
3382 GTK_POLICY_AUTOMATIC,
3383 GTK_POLICY_AUTOMATIC);
3384 gtk_box_pack_start (GTK_BOX (box2), scrolled_win, TRUE, TRUE, 0);
3385 gtk_widget_set_usize (scrolled_win, -1, 300);
3387 list = gtk_list_new ();
3388 gtk_list_set_selection_mode (GTK_LIST (list), GTK_SELECTION_EXTENDED);
3389 gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (scrolled_win), list);
3390 gtk_container_set_focus_vadjustment
3391 (GTK_CONTAINER (list),
3392 gtk_scrolled_window_get_vadjustment
3393 (GTK_SCROLLED_WINDOW (scrolled_win)));
3394 gtk_container_set_focus_hadjustment
3395 (GTK_CONTAINER (list),
3396 gtk_scrolled_window_get_hadjustment
3397 (GTK_SCROLLED_WINDOW (scrolled_win)));
3399 if ((infile = fopen("gtkenums.h", "r")))
3405 while (fgets (buffer, 256, infile))
3407 if ((pos = strchr (buffer, '\n')))
3409 item = gtk_list_item_new_with_label (buffer);
3410 gtk_container_add (GTK_CONTAINER (list), item);
3416 hbox = gtk_hbox_new (TRUE, 10);
3417 gtk_box_pack_start (GTK_BOX (box2), hbox, FALSE, TRUE, 0);
3419 button = gtk_button_new_with_label ("Undo Selection");
3420 gtk_signal_connect (GTK_OBJECT (button), "clicked",
3421 GTK_SIGNAL_FUNC(list_undo_selection),
3423 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
3425 button = gtk_button_new_with_label ("Remove Selection");
3426 gtk_signal_connect (GTK_OBJECT (button), "clicked",
3427 GTK_SIGNAL_FUNC (list_remove),
3429 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
3431 button = gtk_button_new_with_label ("Clear List");
3432 gtk_signal_connect (GTK_OBJECT (button), "clicked",
3433 GTK_SIGNAL_FUNC (list_clear),
3435 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
3437 hbox = gtk_hbox_new (FALSE, 10);
3438 gtk_box_pack_start (GTK_BOX (box2), hbox, FALSE, TRUE, 0);
3440 button = gtk_button_new_with_label ("Insert Row");
3441 gtk_signal_connect (GTK_OBJECT (button), "clicked",
3442 GTK_SIGNAL_FUNC (list_add),
3444 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
3446 label = gtk_label_new ("Selection Mode :");
3447 gtk_signal_connect (GTK_OBJECT (button), "clicked",
3448 GTK_SIGNAL_FUNC(list_remove),
3450 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
3452 list_omenu = gtk_option_menu_new ();
3453 menu = gtk_menu_new ();
3456 menu_item = gtk_radio_menu_item_new_with_label (group, "Single");
3457 gtk_signal_connect (GTK_OBJECT (menu_item), "activate",
3458 GTK_SIGNAL_FUNC (list_toggle_sel_mode), list);
3459 group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menu_item));
3460 gtk_menu_append (GTK_MENU (menu), menu_item);
3461 gtk_widget_show (menu_item);
3463 menu_item = gtk_radio_menu_item_new_with_label (group, "Browse");
3464 gtk_signal_connect (GTK_OBJECT (menu_item), "activate",
3465 GTK_SIGNAL_FUNC (list_toggle_sel_mode), list);
3466 group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menu_item));
3467 gtk_menu_append (GTK_MENU (menu), menu_item);
3468 gtk_widget_show (menu_item);
3470 menu_item = gtk_radio_menu_item_new_with_label (group, "Multiple");
3471 gtk_signal_connect (GTK_OBJECT (menu_item), "activate",
3472 GTK_SIGNAL_FUNC (list_toggle_sel_mode), list);
3473 group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menu_item));
3474 gtk_menu_append (GTK_MENU (menu), menu_item);
3475 gtk_widget_show (menu_item);
3477 menu_item = gtk_radio_menu_item_new_with_label (group, "Extended");
3478 gtk_signal_connect (GTK_OBJECT (menu_item), "activate",
3479 GTK_SIGNAL_FUNC (list_toggle_sel_mode), list);
3480 group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menu_item));
3481 gtk_menu_append (GTK_MENU (menu), menu_item);
3482 gtk_check_menu_item_set_state (GTK_CHECK_MENU_ITEM (menu_item), TRUE);
3483 gtk_widget_show (menu_item);
3485 gtk_option_menu_set_menu (GTK_OPTION_MENU (list_omenu), menu);
3486 gtk_box_pack_start (GTK_BOX (hbox), list_omenu, FALSE, TRUE, 0);
3488 gtk_option_menu_set_history (GTK_OPTION_MENU (list_omenu), 3);
3490 separator = gtk_hseparator_new ();
3491 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
3494 box2 = gtk_vbox_new (FALSE, 10);
3495 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
3496 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
3498 button = gtk_button_new_with_label ("close");
3499 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
3500 GTK_SIGNAL_FUNC(gtk_widget_destroy),
3501 GTK_OBJECT (window));
3502 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
3504 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
3505 gtk_widget_grab_default (button);
3508 if (!GTK_WIDGET_VISIBLE (window))
3509 gtk_widget_show_all (window);
3511 gtk_widget_destroy (window);
3518 static char * book_open_xpm[] = {
3541 static char * book_closed_xpm[] = {
3566 static char * mini_page_xpm[] = {
3589 static char * gtk_mini_xpm[] = {
3629 #define TESTGTK_CLIST_COLUMNS 20
3630 static gint clist_rows = 0;
3631 static GtkWidget *clist_omenu;
3634 add1000_clist (GtkWidget *widget, gpointer data)
3637 char text[TESTGTK_CLIST_COLUMNS][50];
3638 char *texts[TESTGTK_CLIST_COLUMNS];
3643 clist = GTK_CLIST (data);
3645 pixmap = gdk_pixmap_create_from_xpm_d (clist->clist_window,
3647 >K_WIDGET (data)->style->white,
3650 for (i = 0; i < TESTGTK_CLIST_COLUMNS; i++)
3653 sprintf (text[i], "Column %d", i);
3657 sprintf (text[1], "Right");
3658 sprintf (text[2], "Center");
3660 gtk_clist_freeze (GTK_CLIST (data));
3661 for (i = 0; i < 1000; i++)
3663 sprintf (text[0], "CListRow %d", rand() % 10000);
3664 row = gtk_clist_append (clist, texts);
3665 gtk_clist_set_pixtext (clist, row, 3, "gtk+", 5, pixmap, mask);
3668 gtk_clist_thaw (GTK_CLIST (data));
3670 gdk_pixmap_unref (pixmap);
3671 gdk_bitmap_unref (mask);
3675 add10000_clist (GtkWidget *widget, gpointer data)
3678 char text[TESTGTK_CLIST_COLUMNS][50];
3679 char *texts[TESTGTK_CLIST_COLUMNS];
3681 for (i = 0; i < TESTGTK_CLIST_COLUMNS; i++)
3684 sprintf (text[i], "Column %d", i);
3687 sprintf (text[1], "Right");
3688 sprintf (text[2], "Center");
3690 gtk_clist_freeze (GTK_CLIST (data));
3691 for (i = 0; i < 10000; i++)
3693 sprintf (text[0], "CListRow %d", rand() % 10000);
3694 gtk_clist_append (GTK_CLIST (data), texts);
3696 gtk_clist_thaw (GTK_CLIST (data));
3700 clear_clist (GtkWidget *widget, gpointer data)
3702 gtk_clist_clear (GTK_CLIST (data));
3707 remove_row_clist (GtkWidget *widget, gpointer data)
3709 gtk_clist_remove (GTK_CLIST (data), GTK_CLIST (data)->focus_row);
3714 show_titles_clist (GtkWidget *widget, gpointer data)
3716 gtk_clist_column_titles_show (GTK_CLIST (data));
3720 hide_titles_clist (GtkWidget *widget, gpointer data)
3722 gtk_clist_column_titles_hide (GTK_CLIST (data));
3725 void toggle_reorderable (GtkWidget *widget, GtkCList *clist)
3727 gtk_clist_set_reorderable (clist, GTK_TOGGLE_BUTTON (widget)->active);
3731 select_clist (GtkWidget *widget,
3734 GdkEventButton * bevent,
3744 g_print ("GtkCList Selection: row %d column %d button %d\n",
3745 row, column, bevent ? bevent->button : 0);
3747 for (i = 0; i < TESTGTK_CLIST_COLUMNS; i++)
3749 switch (gtk_clist_get_cell_type (GTK_CLIST (widget), row, i))
3752 g_print ("CELL %d GTK_CELL_TEXT\n", i);
3753 gtk_clist_get_text (GTK_CLIST (widget), row, i, &text);
3754 g_print ("TEXT: %s\n", text);
3757 case GTK_CELL_PIXMAP:
3758 g_print ("CELL %d GTK_CELL_PIXMAP\n", i);
3759 gtk_clist_get_pixmap (GTK_CLIST (widget), row, i, &pixmap, &mask);
3760 g_print ("PIXMAP: %p\n", pixmap);
3761 g_print ("MASK: %p\n", mask);
3764 case GTK_CELL_PIXTEXT:
3765 g_print ("CELL %d GTK_CELL_PIXTEXT\n", i);
3766 gtk_clist_get_pixtext (GTK_CLIST (widget), row, i, &text, &spacing, &pixmap, &mask);
3767 g_print ("TEXT: %s\n", text);
3768 g_print ("SPACING: %d\n", spacing);
3769 g_print ("PIXMAP: %p\n", pixmap);
3770 g_print ("MASK: %p\n", mask);
3778 /* print selections list */
3779 g_print ("\nSelected Rows:");
3780 list = GTK_CLIST (widget)->selection;
3783 g_print (" %d ", GPOINTER_TO_INT (list->data));
3791 unselect_clist (GtkWidget *widget,
3794 GdkEventButton * bevent,
3804 g_print ("GtkCList Unselection: row %d column %d button %d\n",
3805 row, column, bevent ? bevent->button : 0);
3807 for (i = 0; i < TESTGTK_CLIST_COLUMNS; i++)
3809 switch (gtk_clist_get_cell_type (GTK_CLIST (widget), row, i))
3812 g_print ("CELL %d GTK_CELL_TEXT\n", i);
3813 gtk_clist_get_text (GTK_CLIST (widget), row, i, &text);
3814 g_print ("TEXT: %s\n", text);
3817 case GTK_CELL_PIXMAP:
3818 g_print ("CELL %d GTK_CELL_PIXMAP\n", i);
3819 gtk_clist_get_pixmap (GTK_CLIST (widget), row, i, &pixmap, &mask);
3820 g_print ("PIXMAP: %p\n", pixmap);
3821 g_print ("MASK: %p\n", mask);
3824 case GTK_CELL_PIXTEXT:
3825 g_print ("CELL %d GTK_CELL_PIXTEXT\n", i);
3826 gtk_clist_get_pixtext (GTK_CLIST (widget), row, i, &text, &spacing, &pixmap, &mask);
3827 g_print ("TEXT: %s\n", text);
3828 g_print ("SPACING: %d\n", spacing);
3829 g_print ("PIXMAP: %p\n", pixmap);
3830 g_print ("MASK: %p\n", mask);
3838 /* print selections list */
3839 g_print ("\nSelected Rows:");
3840 list = GTK_CLIST (widget)->selection;
3843 g_print (" %d ", GPOINTER_TO_INT (list->data));
3851 insert_row_clist (GtkWidget *widget, gpointer data)
3853 static char *text[] =
3855 "This", "is", "an", "inserted", "row.",
3856 "This", "is", "an", "inserted", "row.",
3857 "This", "is", "an", "inserted", "row.",
3858 "This", "is", "an", "inserted", "row."
3861 static GtkStyle *style1 = NULL;
3862 static GtkStyle *style2 = NULL;
3863 static GtkStyle *style3 = NULL;
3866 if (GTK_CLIST (data)->focus_row >= 0)
3867 row = gtk_clist_insert (GTK_CLIST (data), GTK_CLIST (data)->focus_row,
3870 row = gtk_clist_prepend (GTK_CLIST (data), text);
3884 style1 = gtk_style_copy (GTK_WIDGET (data)->style);
3885 style1->base[GTK_STATE_NORMAL] = col1;
3886 style1->base[GTK_STATE_SELECTED] = col2;
3888 style2 = gtk_style_copy (GTK_WIDGET (data)->style);
3889 style2->fg[GTK_STATE_NORMAL] = col1;
3890 style2->fg[GTK_STATE_SELECTED] = col2;
3892 style3 = gtk_style_copy (GTK_WIDGET (data)->style);
3893 style3->fg[GTK_STATE_NORMAL] = col1;
3894 style3->base[GTK_STATE_NORMAL] = col2;
3895 gdk_font_unref (style3->font);
3897 gdk_font_load ("-*-courier-medium-*-*-*-*-120-*-*-*-*-*-*");
3900 gtk_clist_set_cell_style (GTK_CLIST (data), row, 3, style1);
3901 gtk_clist_set_cell_style (GTK_CLIST (data), row, 4, style2);
3902 gtk_clist_set_cell_style (GTK_CLIST (data), row, 0, style3);
3908 clist_warning_test (GtkWidget *button,
3912 static gboolean add_remove = FALSE;
3914 add_remove = !add_remove;
3916 child = gtk_label_new ("Test");
3917 gtk_widget_ref (child);
3918 gtk_object_sink (GTK_OBJECT (child));
3921 gtk_container_add (GTK_CONTAINER (clist), child);
3924 child->parent = clist;
3925 gtk_container_remove (GTK_CONTAINER (clist), child);
3926 child->parent = NULL;
3929 gtk_widget_destroy (child);
3930 gtk_widget_unref (child);
3934 undo_selection (GtkWidget *button, GtkCList *clist)
3936 gtk_clist_undo_selection (clist);
3940 clist_toggle_sel_mode (GtkWidget *widget, GtkCList *clist)
3944 if (!GTK_WIDGET_MAPPED (widget))
3947 RADIOMENUTOGGLED ((GtkRadioMenuItem *)
3948 (((GtkOptionMenu *)clist_omenu)->menu_item), i);
3950 gtk_clist_set_selection_mode (clist, (GtkSelectionMode) (3-i));
3954 clist_click_column (GtkCList *clist, gint column, gpointer data)
3957 gtk_clist_set_column_visibility (clist, column, FALSE);
3958 else if (column == clist->sort_column)
3960 if (clist->sort_type == GTK_SORT_ASCENDING)
3961 clist->sort_type = GTK_SORT_DESCENDING;
3963 clist->sort_type = GTK_SORT_ASCENDING;
3966 gtk_clist_set_sort_column (clist, column);
3968 gtk_clist_sort (clist);
3975 static GtkWidget *window = NULL;
3977 static char *titles[] =
3979 "auto resize", "not resizeable", "max width 100", "min width 50",
3980 "hide column", "Title 5", "Title 6", "Title 7",
3981 "Title 8", "Title 9", "Title 10", "Title 11", "Title 12",
3982 "Title 13", "Title 14", "Title 15", "Title 16", "Title 17",
3983 "Title 18", "Title 19"
3986 static OptionMenuItem items[] =
3988 { "Single", clist_toggle_sel_mode },
3989 { "Browse", clist_toggle_sel_mode },
3990 { "Multiple", clist_toggle_sel_mode },
3991 { "Extended", clist_toggle_sel_mode }
3994 char text[TESTGTK_CLIST_COLUMNS][50];
3995 char *texts[TESTGTK_CLIST_COLUMNS];
4001 GtkWidget *separator;
4002 GtkWidget *scrolled_win;
4005 GtkWidget *undo_button;
4015 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
4017 gtk_signal_connect (GTK_OBJECT (window), "destroy",
4018 GTK_SIGNAL_FUNC (gtk_widget_destroyed), &window);
4020 gtk_window_set_title (GTK_WINDOW (window), "clist");
4021 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
4023 box1 = gtk_vbox_new (FALSE, 0);
4024 gtk_container_add (GTK_CONTAINER (window), box1);
4026 box2 = gtk_hbox_new (FALSE, 10);
4027 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
4028 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0);
4030 /* create GtkCList here so we have a pointer to throw at the
4031 * button callbacks -- more is done with it later */
4032 clist = gtk_clist_new_with_titles (TESTGTK_CLIST_COLUMNS, titles);
4033 gtk_widget_show (clist);
4034 scrolled_win = gtk_scrolled_window_new (NULL, NULL);
4035 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
4036 GTK_POLICY_AUTOMATIC,
4037 GTK_POLICY_AUTOMATIC);
4038 gtk_container_add (GTK_CONTAINER (scrolled_win), clist);
4040 gtk_signal_connect (GTK_OBJECT (clist), "click_column",
4041 (GtkSignalFunc) clist_click_column, NULL);
4043 /* control buttons */
4044 button = gtk_button_new_with_label ("Add 1,000 Rows With Pixmaps");
4045 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
4047 gtk_signal_connect (GTK_OBJECT (button), "clicked",
4048 (GtkSignalFunc) add1000_clist, (gpointer) clist);
4050 button = gtk_button_new_with_label ("Add 10,000 Rows");
4051 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
4053 gtk_signal_connect (GTK_OBJECT (button), "clicked",
4054 (GtkSignalFunc) add10000_clist, (gpointer) clist);
4056 button = gtk_button_new_with_label ("Clear List");
4057 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
4059 gtk_signal_connect (GTK_OBJECT (button), "clicked",
4060 (GtkSignalFunc) clear_clist, (gpointer) clist);
4062 button = gtk_button_new_with_label ("Remove Row");
4063 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
4065 gtk_signal_connect (GTK_OBJECT (button), "clicked",
4066 (GtkSignalFunc) remove_row_clist, (gpointer) clist);
4068 /* second layer of buttons */
4069 box2 = gtk_hbox_new (FALSE, 10);
4070 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
4071 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0);
4073 button = gtk_button_new_with_label ("Insert Row");
4074 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
4076 gtk_signal_connect (GTK_OBJECT (button), "clicked",
4077 (GtkSignalFunc) insert_row_clist, (gpointer) clist);
4079 button = gtk_button_new_with_label ("Show Title Buttons");
4080 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
4082 gtk_signal_connect (GTK_OBJECT (button), "clicked",
4083 (GtkSignalFunc) show_titles_clist, (gpointer) clist);
4085 button = gtk_button_new_with_label ("Hide Title Buttons");
4086 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
4088 gtk_signal_connect (GTK_OBJECT (button), "clicked",
4089 (GtkSignalFunc) hide_titles_clist, (gpointer) clist);
4091 button = gtk_button_new_with_label ("Warning Test");
4092 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
4094 gtk_signal_connect (GTK_OBJECT (button), "clicked",
4095 (GtkSignalFunc) clist_warning_test,(gpointer) clist);
4097 box2 = gtk_hbox_new (FALSE, 10);
4098 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
4099 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0);
4101 undo_button = gtk_button_new_with_label ("Undo last selection");
4102 gtk_box_pack_start (GTK_BOX (box2), undo_button, TRUE, TRUE, 0);
4103 gtk_signal_connect (GTK_OBJECT (undo_button), "clicked",
4104 (GtkSignalFunc) undo_selection, (gpointer) clist);
4106 check = gtk_check_button_new_with_label ("Reorderable");
4107 gtk_signal_connect (GTK_OBJECT (check), "clicked",
4108 GTK_SIGNAL_FUNC (toggle_reorderable), clist);
4109 gtk_box_pack_start (GTK_BOX (box2), check, FALSE, TRUE, 0);
4110 gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON (check), TRUE);
4112 label = gtk_label_new ("Selection Mode :");
4113 gtk_box_pack_start (GTK_BOX (box2), label, FALSE, TRUE, 0);
4115 clist_omenu = build_option_menu (items, 4, 3, clist);
4116 gtk_box_pack_start (GTK_BOX (box2), clist_omenu, FALSE, TRUE, 0);
4118 /* vbox for the list itself */
4119 box2 = gtk_vbox_new (FALSE, 10);
4120 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
4121 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
4124 * the rest of the clist configuration
4127 gtk_clist_set_row_height (GTK_CLIST (clist), 18);
4128 gtk_widget_set_usize (clist, -1, 300);
4130 for (i = 1; i < TESTGTK_CLIST_COLUMNS; i++)
4131 gtk_clist_set_column_width (GTK_CLIST (clist), i, 80);
4133 gtk_clist_set_column_auto_resize (GTK_CLIST (clist), 0, TRUE);
4134 gtk_clist_set_column_resizeable (GTK_CLIST (clist), 1, FALSE);
4135 gtk_clist_set_column_max_width (GTK_CLIST (clist), 2, 100);
4136 gtk_clist_set_column_min_width (GTK_CLIST (clist), 3, 50);
4138 gtk_clist_set_selection_mode (GTK_CLIST (clist), GTK_SELECTION_EXTENDED);
4140 gtk_clist_set_column_justification (GTK_CLIST (clist), 1,
4142 gtk_clist_set_column_justification (GTK_CLIST (clist), 2,
4143 GTK_JUSTIFY_CENTER);
4145 for (i = 0; i < TESTGTK_CLIST_COLUMNS; i++)
4148 sprintf (text[i], "Column %d", i);
4151 sprintf (text[1], "Right");
4152 sprintf (text[2], "Center");
4161 style = gtk_style_new ();
4162 style->fg[GTK_STATE_NORMAL] = col1;
4163 style->base[GTK_STATE_NORMAL] = col2;
4165 gdk_font_unref (style->font);
4167 gdk_font_load ("-adobe-helvetica-bold-r-*-*-*-140-*-*-*-*-*-*");
4169 for (i = 0; i < 10; i++)
4171 sprintf (text[0], "CListRow %d", clist_rows++);
4172 gtk_clist_append (GTK_CLIST (clist), texts);
4177 gtk_clist_set_row_style (GTK_CLIST (clist), i, style);
4180 gtk_clist_set_cell_style (GTK_CLIST (clist), i, i % 4, style);
4185 gtk_container_set_border_width (GTK_CONTAINER (scrolled_win), 5);
4186 gtk_box_pack_start (GTK_BOX (box2), scrolled_win, TRUE, TRUE, 0);
4188 separator = gtk_hseparator_new ();
4189 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
4191 box2 = gtk_vbox_new (FALSE, 10);
4192 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
4193 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
4195 button = gtk_button_new_with_label ("close");
4196 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
4197 GTK_SIGNAL_FUNC(gtk_widget_destroy),
4198 GTK_OBJECT (window));
4200 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
4201 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
4202 gtk_widget_grab_default (button);
4205 if (!GTK_WIDGET_VISIBLE (window))
4206 gtk_widget_show_all (window);
4210 gtk_widget_destroy (window);
4225 static gint books = 0;
4226 static gint pages = 0;
4228 static GtkWidget *book_label;
4229 static GtkWidget *page_label;
4230 static GtkWidget *sel_label;
4231 static GtkWidget *vis_label;
4232 static GtkWidget *omenu1;
4233 static GtkWidget *omenu2;
4234 static GtkWidget *omenu3;
4235 static GtkWidget *omenu4;
4236 static GtkWidget *spin1;
4237 static GtkWidget *spin2;
4238 static GtkWidget *spin3;
4239 static gint line_style;
4241 void after_press (GtkCTree *ctree, gpointer data)
4245 sprintf (buf, "%d", g_list_length (GTK_CLIST (ctree)->selection));
4246 gtk_label_set_text (GTK_LABEL (sel_label), buf);
4248 sprintf (buf, "%d", g_list_length (GTK_CLIST (ctree)->row_list));
4249 gtk_label_set_text (GTK_LABEL (vis_label), buf);
4251 sprintf (buf, "%d", books);
4252 gtk_label_set_text (GTK_LABEL (book_label), buf);
4254 sprintf (buf, "%d", pages);
4255 gtk_label_set_text (GTK_LABEL (page_label), buf);
4258 void after_move (GtkCTree *ctree, GtkCTreeNode *child, GtkCTreeNode *parent,
4259 GtkCTreeNode *sibling, gpointer data)
4265 gtk_ctree_get_node_info (ctree, child, &source,
4266 NULL, NULL, NULL, NULL, NULL, NULL, NULL);
4268 gtk_ctree_get_node_info (ctree, parent, &target1,
4269 NULL, NULL, NULL, NULL, NULL, NULL, NULL);
4271 gtk_ctree_get_node_info (ctree, sibling, &target2,
4272 NULL, NULL, NULL, NULL, NULL, NULL, NULL);
4274 g_print ("Moving \"%s\" to \"%s\" with sibling \"%s\".\n", source,
4275 (parent) ? target1 : "nil", (sibling) ? target2 : "nil");
4278 void count_items (GtkCTree *ctree, GtkCTreeNode *list)
4280 if (GTK_CTREE_ROW (list)->is_leaf)
4286 void expand_all (GtkWidget *widget, GtkCTree *ctree)
4288 gtk_ctree_expand_recursive (ctree, NULL);
4289 after_press (ctree, NULL);
4292 void collapse_all (GtkWidget *widget, GtkCTree *ctree)
4294 gtk_ctree_collapse_recursive (ctree, NULL);
4295 after_press (ctree, NULL);
4298 void select_all (GtkWidget *widget, GtkCTree *ctree)
4300 gtk_ctree_select_recursive (ctree, NULL);
4301 after_press (ctree, NULL);
4304 void change_style (GtkWidget *widget, GtkCTree *ctree)
4306 static GtkStyle *style1 = NULL;
4307 static GtkStyle *style2 = NULL;
4313 if (GTK_CLIST (ctree)->focus_row >= 0)
4314 node = GTK_CTREE_NODE
4315 (g_list_nth (GTK_CLIST (ctree)->row_list,GTK_CLIST (ctree)->focus_row));
4317 node = GTK_CTREE_NODE (GTK_CLIST (ctree)->row_list);
4331 style1 = gtk_style_new ();
4332 style1->base[GTK_STATE_NORMAL] = col1;
4333 style1->fg[GTK_STATE_SELECTED] = col2;
4335 style2 = gtk_style_new ();
4336 style2->base[GTK_STATE_SELECTED] = col2;
4337 style2->fg[GTK_STATE_NORMAL] = col1;
4338 style2->base[GTK_STATE_NORMAL] = col2;
4339 gdk_font_unref (style2->font);
4341 gdk_font_load ("-*-courier-medium-*-*-*-*-300-*-*-*-*-*-*");
4344 gtk_ctree_node_set_cell_style (ctree, node, 1, style1);
4345 gtk_ctree_node_set_cell_style (ctree, node, 0, style2);
4347 if (GTK_CTREE_ROW (node)->children)
4348 gtk_ctree_node_set_row_style (ctree, GTK_CTREE_ROW (node)->children,
4352 void unselect_all (GtkWidget *widget, GtkCTree *ctree)
4354 gtk_ctree_unselect_recursive (ctree, NULL);
4355 after_press (ctree, NULL);
4358 void remove_selection (GtkWidget *widget, GtkCTree *ctree)
4365 clist = GTK_CLIST (ctree);
4367 gtk_clist_freeze (clist);
4369 for (selection = clist->selection; selection; selection = selection->next)
4370 list = g_list_prepend (list, selection->data);
4372 selection = clist->selection;
4375 node = selection->data;
4377 if (!g_list_find (list, node))
4380 if (GTK_CTREE_ROW (node)->is_leaf)
4383 gtk_ctree_post_recursive (ctree, node,
4384 (GtkCTreeFunc) count_items, NULL);
4386 gtk_ctree_remove_node (ctree, node);
4387 selection = clist->selection;
4390 gtk_clist_thaw (clist);
4391 after_press (ctree, NULL);
4394 struct _ExportStruct {
4400 typedef struct _ExportStruct ExportStruct;
4403 gnode2ctree (GtkCTree *ctree,
4406 GtkCTreeNode *cnode,
4410 GdkPixmap *pixmap_closed;
4411 GdkBitmap *mask_closed;
4412 GdkPixmap *pixmap_opened;
4413 GdkBitmap *mask_opened;
4415 if (!cnode || !gnode || (!(es = gnode->data)))
4420 pixmap_closed = pixmap3;
4421 mask_closed = mask3;
4422 pixmap_opened = NULL;
4427 pixmap_closed = pixmap1;
4428 mask_closed = mask1;
4429 pixmap_opened = pixmap2;
4430 mask_opened = mask2;
4433 gtk_ctree_set_node_info (ctree, cnode, es->tree, 2, pixmap_closed,
4434 mask_closed, pixmap_opened, mask_opened,
4435 es->is_leaf, (depth < 3));
4436 gtk_ctree_node_set_text (ctree, cnode, 1, es->info);
4444 ctree2gnode (GtkCTree *ctree,
4447 GtkCTreeNode *cnode,
4452 if (!cnode || !gnode)
4455 es = g_new (ExportStruct, 1);
4457 es->is_leaf = GTK_CTREE_ROW (cnode)->is_leaf;
4458 es->tree = GTK_CELL_PIXTEXT (GTK_CTREE_ROW (cnode)->row.cell[0])->text;
4459 es->info = GTK_CELL_PIXTEXT (GTK_CTREE_ROW (cnode)->row.cell[1])->text;
4463 void export_ctree (GtkWidget *widget, GtkCTree *ctree)
4465 char *title[] = { "Tree" , "Info" };
4466 static GtkWidget *export_window = NULL;
4467 static GtkCTree *export_ctree;
4469 GtkWidget *scrolled_win;
4477 export_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
4479 gtk_signal_connect (GTK_OBJECT (export_window), "destroy",
4480 GTK_SIGNAL_FUNC (gtk_widget_destroyed),
4483 gtk_window_set_title (GTK_WINDOW (export_window), "exported ctree");
4484 gtk_container_set_border_width (GTK_CONTAINER (export_window), 5);
4486 vbox = gtk_vbox_new (FALSE, 0);
4487 gtk_container_add (GTK_CONTAINER (export_window), vbox);
4489 button = gtk_button_new_with_label ("Close");
4490 gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, TRUE, 0);
4492 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
4493 (GtkSignalFunc) gtk_widget_destroy,
4494 GTK_OBJECT(export_window));
4496 sep = gtk_hseparator_new ();
4497 gtk_box_pack_end (GTK_BOX (vbox), sep, FALSE, TRUE, 10);
4499 export_ctree = GTK_CTREE (gtk_ctree_new_with_titles (2, 0, title));
4500 gtk_ctree_set_line_style (export_ctree, GTK_CTREE_LINES_DOTTED);
4502 scrolled_win = gtk_scrolled_window_new (NULL, NULL);
4503 gtk_container_add (GTK_CONTAINER (scrolled_win),
4504 GTK_WIDGET (export_ctree));
4505 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
4506 GTK_POLICY_AUTOMATIC,
4507 GTK_POLICY_AUTOMATIC);
4508 gtk_box_pack_start (GTK_BOX (vbox), scrolled_win, TRUE, TRUE, 0);
4509 gtk_clist_set_selection_mode (GTK_CLIST (export_ctree),
4510 GTK_SELECTION_EXTENDED);
4511 gtk_clist_set_column_width (GTK_CLIST (export_ctree), 0, 200);
4512 gtk_clist_set_column_width (GTK_CLIST (export_ctree), 1, 200);
4513 gtk_widget_set_usize (GTK_WIDGET (export_ctree), 300, 200);
4516 if (!GTK_WIDGET_VISIBLE (export_window))
4517 gtk_widget_show_all (export_window);
4519 gtk_clist_clear (GTK_CLIST (export_ctree));
4521 node = GTK_CTREE_NODE (g_list_nth (GTK_CLIST (ctree)->row_list,
4522 GTK_CLIST (ctree)->focus_row));
4526 gnode = gtk_ctree_export_to_gnode (ctree, NULL, NULL, node,
4530 gtk_ctree_insert_gnode (export_ctree, NULL, NULL, gnode,
4532 g_node_destroy (gnode);
4536 void change_indent (GtkWidget *widget, GtkCTree *ctree)
4538 gtk_ctree_set_indent (ctree, GTK_ADJUSTMENT (widget)->value);
4541 void change_spacing (GtkWidget *widget, GtkCTree *ctree)
4543 gtk_ctree_set_spacing (ctree, GTK_ADJUSTMENT (widget)->value);
4546 void change_row_height (GtkWidget *widget, GtkCList *clist)
4548 gtk_clist_set_row_height (clist, GTK_ADJUSTMENT (widget)->value);
4551 void set_background (GtkCTree *ctree, GtkCTreeNode *node, gpointer data)
4553 GtkStyle *style = NULL;
4558 if (ctree->line_style != GTK_CTREE_LINES_TABBED)
4560 if (!GTK_CTREE_ROW (node)->is_leaf)
4561 style = GTK_CTREE_ROW (node)->row.data;
4562 else if (GTK_CTREE_ROW (node)->parent)
4563 style = GTK_CTREE_ROW (GTK_CTREE_ROW (node)->parent)->row.data;
4566 gtk_ctree_node_set_row_style (ctree, node, style);
4569 void ctree_toggle_line_style (GtkWidget *widget, GtkCTree *ctree)
4573 if (!GTK_WIDGET_MAPPED (widget))
4576 RADIOMENUTOGGLED ((GtkRadioMenuItem *)
4577 (((GtkOptionMenu *)omenu1)->menu_item), i);
4579 if ((ctree->line_style == GTK_CTREE_LINES_TABBED &&
4580 ((GtkCTreeLineStyle) (3 - i)) != GTK_CTREE_LINES_TABBED) ||
4581 (ctree->line_style != GTK_CTREE_LINES_TABBED &&
4582 ((GtkCTreeLineStyle) (3 - i)) == GTK_CTREE_LINES_TABBED))
4583 gtk_ctree_pre_recursive (ctree, NULL, set_background, NULL);
4584 gtk_ctree_set_line_style (ctree, 3 - i);
4588 void ctree_toggle_expander_style (GtkWidget *widget, GtkCTree *ctree)
4592 if (!GTK_WIDGET_MAPPED (widget))
4595 RADIOMENUTOGGLED ((GtkRadioMenuItem *)
4596 (((GtkOptionMenu *)omenu2)->menu_item), i);
4598 gtk_ctree_set_expander_style (ctree, (GtkCTreeExpanderStyle) (3 - i));
4601 void ctree_toggle_justify (GtkWidget *widget, GtkCTree *ctree)
4605 if (!GTK_WIDGET_MAPPED (widget))
4608 RADIOMENUTOGGLED ((GtkRadioMenuItem *)
4609 (((GtkOptionMenu *)omenu3)->menu_item), i);
4611 gtk_clist_set_column_justification (GTK_CLIST (ctree), ctree->tree_column,
4612 (GtkJustification) (1 - i));
4615 void ctree_toggle_sel_mode (GtkWidget *widget, GtkCTree *ctree)
4619 if (!GTK_WIDGET_MAPPED (widget))
4622 RADIOMENUTOGGLED ((GtkRadioMenuItem *)
4623 (((GtkOptionMenu *)omenu4)->menu_item), i);
4625 gtk_clist_set_selection_mode (GTK_CLIST (ctree), (GtkSelectionMode) (3 - i));
4626 after_press (ctree, NULL);
4629 void build_recursive (GtkCTree *ctree, gint cur_depth, gint depth,
4630 gint num_books, gint num_pages, GtkCTreeNode *parent)
4635 GtkCTreeNode *sibling;
4642 for (i = num_pages + num_books; i > num_books; i--)
4645 sprintf (buf1, "Page %02d", (gint) rand() % 100);
4646 sprintf (buf2, "Item %d-%d", cur_depth, i);
4647 sibling = gtk_ctree_insert_node (ctree, parent, sibling, text, 5,
4648 pixmap3, mask3, NULL, NULL,
4651 if (parent && ctree->line_style == GTK_CTREE_LINES_TABBED)
4652 gtk_ctree_node_set_row_style (ctree, sibling,
4653 GTK_CTREE_ROW (parent)->row.style);
4656 if (cur_depth == depth)
4659 for (i = num_books; i > 0; i--)
4664 sprintf (buf1, "Book %02d", (gint) rand() % 100);
4665 sprintf (buf2, "Item %d-%d", cur_depth, i);
4666 sibling = gtk_ctree_insert_node (ctree, parent, sibling, text, 5,
4667 pixmap1, mask1, pixmap2, mask2,
4670 style = gtk_style_new ();
4671 switch (cur_depth % 3)
4674 style->base[GTK_STATE_NORMAL].red = 10000 * (cur_depth % 6);
4675 style->base[GTK_STATE_NORMAL].green = 0;
4676 style->base[GTK_STATE_NORMAL].blue = 65535 - ((i * 10000) % 65535);
4679 style->base[GTK_STATE_NORMAL].red = 10000 * (cur_depth % 6);
4680 style->base[GTK_STATE_NORMAL].green = 65535 - ((i * 10000) % 65535);
4681 style->base[GTK_STATE_NORMAL].blue = 0;
4684 style->base[GTK_STATE_NORMAL].red = 65535 - ((i * 10000) % 65535);
4685 style->base[GTK_STATE_NORMAL].green = 0;
4686 style->base[GTK_STATE_NORMAL].blue = 10000 * (cur_depth % 6);
4689 gtk_ctree_node_set_row_data_full (ctree, sibling, style,
4690 (GtkDestroyNotify) gtk_style_unref);
4692 if (ctree->line_style == GTK_CTREE_LINES_TABBED)
4693 gtk_ctree_node_set_row_style (ctree, sibling, style);
4695 build_recursive (ctree, cur_depth + 1, depth, num_books, num_pages,
4700 void rebuild_tree (GtkWidget *widget, GtkCTree *ctree)
4703 gchar label1[] = "Root";
4704 gchar label2[] = "";
4705 GtkCTreeNode *parent;
4712 d = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (spin1));
4713 b = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (spin2));
4714 p = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (spin3));
4716 n = ((pow (b, d) - 1) / (b - 1)) * (p + 1);
4720 g_print ("%d total items? Try less\n",n);
4724 gtk_clist_freeze (GTK_CLIST (ctree));
4725 gtk_clist_clear (GTK_CLIST (ctree));
4730 parent = gtk_ctree_insert_node (ctree, NULL, NULL, text, 5, pixmap1,
4731 mask1, pixmap2, mask2, FALSE, TRUE);
4733 style = gtk_style_new ();
4734 style->base[GTK_STATE_NORMAL].red = 0;
4735 style->base[GTK_STATE_NORMAL].green = 45000;
4736 style->base[GTK_STATE_NORMAL].blue = 55000;
4737 gtk_ctree_node_set_row_data_full (ctree, parent, style,
4738 (GtkDestroyNotify) gtk_style_unref);
4740 if (ctree->line_style == GTK_CTREE_LINES_TABBED)
4741 gtk_ctree_node_set_row_style (ctree, parent, style);
4743 build_recursive (ctree, 1, d, b, p, parent);
4744 gtk_clist_thaw (GTK_CLIST (ctree));
4745 after_press (ctree, NULL);
4749 ctree_click_column (GtkCTree *ctree, gint column, gpointer data)
4753 clist = GTK_CLIST (ctree);
4755 if (column == clist->sort_column)
4757 if (clist->sort_type == GTK_SORT_ASCENDING)
4758 clist->sort_type = GTK_SORT_DESCENDING;
4760 clist->sort_type = GTK_SORT_ASCENDING;
4763 gtk_clist_set_sort_column (clist, column);
4765 gtk_ctree_sort_recursive (ctree, NULL);
4768 void create_ctree (void)
4770 static GtkWidget *window = NULL;
4771 GtkTooltips *tooltips;
4773 GtkWidget *scrolled_win;
4785 GdkColor transparent;
4787 char *title[] = { "Tree" , "Info" };
4790 static OptionMenuItem items1[] =
4792 { "No lines", ctree_toggle_line_style },
4793 { "Solid", ctree_toggle_line_style },
4794 { "Dotted", ctree_toggle_line_style },
4795 { "Tabbed", ctree_toggle_line_style }
4798 static OptionMenuItem items2[] =
4800 { "None", ctree_toggle_expander_style },
4801 { "Square", ctree_toggle_expander_style },
4802 { "Triangle", ctree_toggle_expander_style },
4803 { "Circular", ctree_toggle_expander_style }
4806 static OptionMenuItem items3[] =
4808 { "Left", ctree_toggle_justify },
4809 { "Right", ctree_toggle_justify }
4812 static OptionMenuItem items4[] =
4814 { "Single", ctree_toggle_sel_mode },
4815 { "Browse", ctree_toggle_sel_mode },
4816 { "Multiple", ctree_toggle_sel_mode },
4817 { "Extended", ctree_toggle_sel_mode }
4822 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
4824 gtk_signal_connect (GTK_OBJECT (window), "destroy",
4825 GTK_SIGNAL_FUNC (gtk_widget_destroyed),
4828 gtk_window_set_title (GTK_WINDOW (window), "GtkCTree");
4829 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
4831 tooltips = gtk_tooltips_new ();
4832 gtk_object_ref (GTK_OBJECT (tooltips));
4833 gtk_object_sink (GTK_OBJECT (tooltips));
4835 gtk_object_set_data_full (GTK_OBJECT (window), "tooltips", tooltips,
4836 (GtkDestroyNotify) gtk_object_unref);
4838 vbox = gtk_vbox_new (FALSE, 0);
4839 gtk_container_add (GTK_CONTAINER (window), vbox);
4841 hbox = gtk_hbox_new (FALSE, 5);
4842 gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
4843 gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0);
4845 label = gtk_label_new ("Depth :");
4846 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
4848 adj = (GtkAdjustment *) gtk_adjustment_new (4, 1, 10, 1, 5, 0);
4849 spin1 = gtk_spin_button_new (adj, 0, 0);
4850 gtk_box_pack_start (GTK_BOX (hbox), spin1, FALSE, TRUE, 5);
4852 label = gtk_label_new ("Books :");
4853 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
4855 adj = (GtkAdjustment *) gtk_adjustment_new (3, 1, 20, 1, 5, 0);
4856 spin2 = gtk_spin_button_new (adj, 0, 0);
4857 gtk_box_pack_start (GTK_BOX (hbox), spin2, FALSE, TRUE, 5);
4859 label = gtk_label_new ("Pages :");
4860 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
4862 adj = (GtkAdjustment *) gtk_adjustment_new (5, 1, 20, 1, 5, 0);
4863 spin3 = gtk_spin_button_new (adj, 0, 0);
4864 gtk_box_pack_start (GTK_BOX (hbox), spin3, FALSE, TRUE, 5);
4866 button = gtk_button_new_with_label ("Close");
4867 gtk_box_pack_end (GTK_BOX (hbox), button, TRUE, TRUE, 0);
4869 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
4870 (GtkSignalFunc) gtk_widget_destroy,
4871 GTK_OBJECT(window));
4873 button = gtk_button_new_with_label ("Rebuild tree");
4874 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
4876 ctree = GTK_CTREE (gtk_ctree_new_with_titles (2, 0, title));
4877 gtk_signal_connect (GTK_OBJECT (button), "clicked",
4878 GTK_SIGNAL_FUNC (rebuild_tree), ctree);
4880 gtk_ctree_set_line_style (ctree, GTK_CTREE_LINES_DOTTED);
4881 line_style = GTK_CTREE_LINES_DOTTED;
4883 gtk_signal_connect (GTK_OBJECT (ctree), "click_column",
4884 (GtkSignalFunc) ctree_click_column,
4886 gtk_signal_connect_after (GTK_OBJECT (ctree), "button_press_event",
4887 GTK_SIGNAL_FUNC (after_press), NULL);
4888 gtk_signal_connect_after (GTK_OBJECT (ctree), "button_release_event",
4889 GTK_SIGNAL_FUNC (after_press), NULL);
4890 gtk_signal_connect_after (GTK_OBJECT (ctree), "tree_move",
4891 GTK_SIGNAL_FUNC (after_move), NULL);
4892 gtk_signal_connect_after (GTK_OBJECT (ctree), "end_selection",
4893 GTK_SIGNAL_FUNC (after_press), NULL);
4894 gtk_signal_connect_after (GTK_OBJECT (ctree), "toggle_focus_row",
4895 GTK_SIGNAL_FUNC (after_press), NULL);
4896 gtk_signal_connect_after (GTK_OBJECT (ctree), "select_all",
4897 GTK_SIGNAL_FUNC (after_press), NULL);
4898 gtk_signal_connect_after (GTK_OBJECT (ctree), "unselect_all",
4899 GTK_SIGNAL_FUNC (after_press), NULL);
4900 gtk_signal_connect_after (GTK_OBJECT (ctree), "scroll_vertical",
4901 GTK_SIGNAL_FUNC (after_press), NULL);
4903 scrolled_win = gtk_scrolled_window_new (NULL, NULL);
4904 gtk_container_add (GTK_CONTAINER (scrolled_win), GTK_WIDGET (ctree));
4905 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
4906 GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
4907 gtk_container_set_border_width (GTK_CONTAINER (scrolled_win), 5);
4908 gtk_box_pack_start (GTK_BOX (vbox), scrolled_win, TRUE, TRUE, 0);
4909 gtk_clist_set_selection_mode (GTK_CLIST (ctree), GTK_SELECTION_EXTENDED);
4910 gtk_clist_set_column_auto_resize (GTK_CLIST (ctree), 0, TRUE);
4911 gtk_clist_set_column_width (GTK_CLIST (ctree), 1, 200);
4913 bbox = gtk_hbox_new (FALSE, 5);
4914 gtk_container_set_border_width (GTK_CONTAINER (bbox), 5);
4915 gtk_box_pack_start (GTK_BOX (vbox), bbox, FALSE, TRUE, 0);
4917 mbox = gtk_vbox_new (TRUE, 5);
4918 gtk_box_pack_start (GTK_BOX (bbox), mbox, FALSE, TRUE, 0);
4920 label = gtk_label_new ("Row height :");
4921 gtk_box_pack_start (GTK_BOX (mbox), label, FALSE, FALSE, 0);
4923 label = gtk_label_new ("Indent :");
4924 gtk_box_pack_start (GTK_BOX (mbox), label, FALSE, FALSE, 0);
4926 label = gtk_label_new ("Spacing :");
4927 gtk_box_pack_start (GTK_BOX (mbox), label, FALSE, FALSE, 0);
4929 mbox = gtk_vbox_new (TRUE, 5);
4930 gtk_box_pack_start (GTK_BOX (bbox), mbox, FALSE, TRUE, 0);
4932 adj = (GtkAdjustment *) gtk_adjustment_new (20, 12, 100, 1, 10, 0);
4933 spinner = gtk_spin_button_new (adj, 0, 0);
4934 gtk_tooltips_set_tip (tooltips, spinner,
4935 "Row height of list items", NULL);
4936 gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
4937 GTK_SIGNAL_FUNC (change_row_height), ctree);
4938 gtk_box_pack_start (GTK_BOX (mbox), spinner, FALSE, FALSE, 5);
4939 gtk_clist_set_row_height ( GTK_CLIST (ctree), adj->value);
4941 adj = (GtkAdjustment *) gtk_adjustment_new (20, 0, 60, 1, 10, 0);
4942 spinner = gtk_spin_button_new (adj, 0, 0);
4943 gtk_tooltips_set_tip (tooltips, spinner, "Tree indentation.", NULL);
4944 gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
4945 GTK_SIGNAL_FUNC (change_indent), ctree);
4946 gtk_box_pack_start (GTK_BOX (mbox), spinner, FALSE, FALSE, 5);
4948 adj = (GtkAdjustment *) gtk_adjustment_new (5, 0, 60, 1, 10, 0);
4949 spinner = gtk_spin_button_new (adj, 0, 0);
4950 gtk_tooltips_set_tip (tooltips, spinner, "Tree spacing.", NULL);
4951 gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
4952 GTK_SIGNAL_FUNC (change_spacing), ctree);
4953 gtk_box_pack_start (GTK_BOX (mbox), spinner, FALSE, FALSE, 5);
4955 mbox = gtk_vbox_new (TRUE, 5);
4956 gtk_box_pack_start (GTK_BOX (bbox), mbox, FALSE, TRUE, 0);
4958 hbox = gtk_hbox_new (FALSE, 5);
4959 gtk_box_pack_start (GTK_BOX (mbox), hbox, FALSE, FALSE, 0);
4961 button = gtk_button_new_with_label ("Expand all");
4962 gtk_signal_connect (GTK_OBJECT (button), "clicked",
4963 GTK_SIGNAL_FUNC (expand_all), ctree);
4964 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
4966 button = gtk_button_new_with_label ("Collapse all");
4967 gtk_signal_connect (GTK_OBJECT (button), "clicked",
4968 GTK_SIGNAL_FUNC (collapse_all), ctree);
4969 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
4971 button = gtk_button_new_with_label ("Change Style");
4972 gtk_signal_connect (GTK_OBJECT (button), "clicked",
4973 GTK_SIGNAL_FUNC (change_style), ctree);
4974 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
4976 button = gtk_button_new_with_label ("Export tree");
4977 gtk_signal_connect (GTK_OBJECT (button), "clicked",
4978 GTK_SIGNAL_FUNC (export_ctree), ctree);
4979 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
4981 hbox = gtk_hbox_new (FALSE, 5);
4982 gtk_box_pack_start (GTK_BOX (mbox), hbox, FALSE, FALSE, 0);
4984 button = gtk_button_new_with_label ("Select all");
4985 gtk_signal_connect (GTK_OBJECT (button), "clicked",
4986 GTK_SIGNAL_FUNC (select_all), ctree);
4987 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
4989 button = gtk_button_new_with_label ("Unselect all");
4990 gtk_signal_connect (GTK_OBJECT (button), "clicked",
4991 GTK_SIGNAL_FUNC (unselect_all), ctree);
4992 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
4994 button = gtk_button_new_with_label ("Remove selection");
4995 gtk_signal_connect (GTK_OBJECT (button), "clicked",
4996 GTK_SIGNAL_FUNC (remove_selection), ctree);
4997 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
4999 check = gtk_check_button_new_with_label ("Reorderable");
5000 gtk_tooltips_set_tip (tooltips, check,
5001 "Tree items can be reordered by dragging.", NULL);
5002 gtk_signal_connect (GTK_OBJECT (check), "clicked",
5003 GTK_SIGNAL_FUNC (toggle_reorderable), ctree);
5004 gtk_box_pack_start (GTK_BOX (hbox), check, FALSE, TRUE, 0);
5005 gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON (check), TRUE);
5007 hbox = gtk_hbox_new (TRUE, 5);
5008 gtk_box_pack_start (GTK_BOX (mbox), hbox, FALSE, FALSE, 0);
5010 omenu1 = build_option_menu (items1, 4, 2, ctree);
5011 gtk_tooltips_set_tip (tooltips, omenu1, "The tree's line style.", NULL);
5012 gtk_box_pack_start (GTK_BOX (hbox), omenu1, FALSE, TRUE, 0);
5014 omenu2 = build_option_menu (items2, 4, 1, ctree);
5015 gtk_tooltips_set_tip (tooltips, omenu2, "The tree's expander style.",
5017 gtk_box_pack_start (GTK_BOX (hbox), omenu2, FALSE, TRUE, 0);
5019 omenu3 = build_option_menu (items3, 2, 0, ctree);
5020 gtk_tooltips_set_tip (tooltips, omenu3, "The tree's justification.",
5022 gtk_box_pack_start (GTK_BOX (hbox), omenu3, FALSE, TRUE, 0);
5024 omenu4 = build_option_menu (items4, 4, 3, ctree);
5025 gtk_tooltips_set_tip (tooltips, omenu4, "The list's selection mode.",
5027 gtk_box_pack_start (GTK_BOX (hbox), omenu4, FALSE, TRUE, 0);
5029 gtk_widget_realize (window);
5031 pixmap1 = gdk_pixmap_create_from_xpm_d (window->window, &mask1,
5032 &transparent, book_closed_xpm);
5033 pixmap2 = gdk_pixmap_create_from_xpm_d (window->window, &mask2,
5034 &transparent, book_open_xpm);
5035 pixmap3 = gdk_pixmap_create_from_xpm_d (window->window, &mask3,
5036 &transparent, mini_page_xpm);
5038 gtk_widget_set_usize (GTK_WIDGET (ctree), 0, 300);
5040 frame = gtk_frame_new (NULL);
5041 gtk_container_set_border_width (GTK_CONTAINER (frame), 0);
5042 gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_OUT);
5043 gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, TRUE, 0);
5045 hbox = gtk_hbox_new (TRUE, 2);
5046 gtk_container_set_border_width (GTK_CONTAINER (hbox), 2);
5047 gtk_container_add (GTK_CONTAINER (frame), hbox);
5049 frame = gtk_frame_new (NULL);
5050 gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
5051 gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, TRUE, 0);
5053 hbox2 = gtk_hbox_new (FALSE, 0);
5054 gtk_container_set_border_width (GTK_CONTAINER (hbox2), 2);
5055 gtk_container_add (GTK_CONTAINER (frame), hbox2);
5057 label = gtk_label_new ("Books :");
5058 gtk_box_pack_start (GTK_BOX (hbox2), label, FALSE, TRUE, 0);
5060 sprintf (buf, "%d", books);
5061 book_label = gtk_label_new (buf);
5062 gtk_box_pack_end (GTK_BOX (hbox2), book_label, FALSE, TRUE, 5);
5064 frame = gtk_frame_new (NULL);
5065 gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
5066 gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, TRUE, 0);
5068 hbox2 = gtk_hbox_new (FALSE, 0);
5069 gtk_container_set_border_width (GTK_CONTAINER (hbox2), 2);
5070 gtk_container_add (GTK_CONTAINER (frame), hbox2);
5072 label = gtk_label_new ("Pages :");
5073 gtk_box_pack_start (GTK_BOX (hbox2), label, FALSE, TRUE, 0);
5075 sprintf (buf, "%d", pages);
5076 page_label = gtk_label_new (buf);
5077 gtk_box_pack_end (GTK_BOX (hbox2), page_label, FALSE, TRUE, 5);
5079 frame = gtk_frame_new (NULL);
5080 gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
5081 gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, TRUE, 0);
5083 hbox2 = gtk_hbox_new (FALSE, 0);
5084 gtk_container_set_border_width (GTK_CONTAINER (hbox2), 2);
5085 gtk_container_add (GTK_CONTAINER (frame), hbox2);
5087 label = gtk_label_new ("Selected :");
5088 gtk_box_pack_start (GTK_BOX (hbox2), label, FALSE, TRUE, 0);
5090 sprintf (buf, "%d", g_list_length (GTK_CLIST (ctree)->selection));
5091 sel_label = gtk_label_new (buf);
5092 gtk_box_pack_end (GTK_BOX (hbox2), sel_label, FALSE, TRUE, 5);
5094 frame = gtk_frame_new (NULL);
5095 gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
5096 gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, TRUE, 0);
5098 hbox2 = gtk_hbox_new (FALSE, 0);
5099 gtk_container_set_border_width (GTK_CONTAINER (hbox2), 2);
5100 gtk_container_add (GTK_CONTAINER (frame), hbox2);
5102 label = gtk_label_new ("Visible :");
5103 gtk_box_pack_start (GTK_BOX (hbox2), label, FALSE, TRUE, 0);
5105 sprintf (buf, "%d", g_list_length (GTK_CLIST (ctree)->row_list));
5106 vis_label = gtk_label_new (buf);
5107 gtk_box_pack_end (GTK_BOX (hbox2), vis_label, FALSE, TRUE, 5);
5109 rebuild_tree (NULL, ctree);
5112 if (!GTK_WIDGET_VISIBLE (window))
5113 gtk_widget_show_all (window);
5115 gtk_widget_destroy (window);
5123 color_selection_ok (GtkWidget *w,
5124 GtkColorSelectionDialog *cs)
5126 GtkColorSelection *colorsel;
5129 colorsel=GTK_COLOR_SELECTION(cs->colorsel);
5131 gtk_color_selection_get_color(colorsel,color);
5132 gtk_color_selection_set_color(colorsel,color);
5136 color_selection_changed (GtkWidget *w,
5137 GtkColorSelectionDialog *cs)
5139 GtkColorSelection *colorsel;
5142 colorsel=GTK_COLOR_SELECTION(cs->colorsel);
5143 gtk_color_selection_get_color(colorsel,color);
5147 create_color_selection (void)
5149 static GtkWidget *window = NULL;
5153 window = gtk_color_selection_dialog_new ("color selection dialog");
5155 gtk_color_selection_set_opacity (
5156 GTK_COLOR_SELECTION (GTK_COLOR_SELECTION_DIALOG (window)->colorsel),
5159 gtk_color_selection_set_update_policy(
5160 GTK_COLOR_SELECTION (GTK_COLOR_SELECTION_DIALOG (window)->colorsel),
5161 GTK_UPDATE_CONTINUOUS);
5163 gtk_window_set_position (GTK_WINDOW (window), GTK_WIN_POS_MOUSE);
5165 gtk_signal_connect (GTK_OBJECT (window), "destroy",
5166 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
5169 gtk_signal_connect (
5170 GTK_OBJECT (GTK_COLOR_SELECTION_DIALOG (window)->colorsel),
5172 GTK_SIGNAL_FUNC(color_selection_changed),
5175 gtk_signal_connect (
5176 GTK_OBJECT (GTK_COLOR_SELECTION_DIALOG (window)->ok_button),
5178 GTK_SIGNAL_FUNC(color_selection_ok),
5181 gtk_signal_connect_object (
5182 GTK_OBJECT (GTK_COLOR_SELECTION_DIALOG (window)->cancel_button),
5184 GTK_SIGNAL_FUNC(gtk_widget_destroy),
5185 GTK_OBJECT (window));
5188 if (!GTK_WIDGET_VISIBLE (window))
5189 gtk_widget_show (window);
5191 gtk_widget_destroy (window);
5199 file_selection_hide_fileops (GtkWidget *widget,
5200 GtkFileSelection *fs)
5202 gtk_file_selection_hide_fileop_buttons (fs);
5206 file_selection_ok (GtkWidget *w,
5207 GtkFileSelection *fs)
5209 g_print ("%s\n", gtk_file_selection_get_filename (fs));
5210 gtk_widget_destroy (GTK_WIDGET (fs));
5214 create_file_selection (void)
5216 static GtkWidget *window = NULL;
5221 window = gtk_file_selection_new ("file selection dialog");
5223 gtk_file_selection_hide_fileop_buttons (GTK_FILE_SELECTION (window));
5225 gtk_window_set_position (GTK_WINDOW (window), GTK_WIN_POS_MOUSE);
5227 gtk_signal_connect (GTK_OBJECT (window), "destroy",
5228 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
5231 gtk_signal_connect (GTK_OBJECT (GTK_FILE_SELECTION (window)->ok_button),
5232 "clicked", GTK_SIGNAL_FUNC(file_selection_ok),
5234 gtk_signal_connect_object (GTK_OBJECT (GTK_FILE_SELECTION (window)->cancel_button),
5235 "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy),
5236 GTK_OBJECT (window));
5238 button = gtk_button_new_with_label ("Hide Fileops");
5239 gtk_signal_connect (GTK_OBJECT (button), "clicked",
5240 (GtkSignalFunc) file_selection_hide_fileops,
5242 gtk_box_pack_start (GTK_BOX (GTK_FILE_SELECTION (window)->action_area),
5243 button, FALSE, FALSE, 0);
5244 gtk_widget_show (button);
5246 button = gtk_button_new_with_label ("Show Fileops");
5247 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
5248 (GtkSignalFunc) gtk_file_selection_show_fileop_buttons,
5250 gtk_box_pack_start (GTK_BOX (GTK_FILE_SELECTION (window)->action_area),
5251 button, FALSE, FALSE, 0);
5252 gtk_widget_show (button);
5255 if (!GTK_WIDGET_VISIBLE (window))
5256 gtk_widget_show (window);
5258 gtk_widget_destroy (window);
5266 font_selection_ok (GtkWidget *w,
5267 GtkFontSelectionDialog *fs)
5269 g_print ("%s\n", gtk_font_selection_dialog_get_font_name (fs));
5270 gtk_widget_destroy (GTK_WIDGET (fs));
5274 create_font_selection (void)
5276 static GtkWidget *window = NULL;
5280 window = gtk_font_selection_dialog_new ("Font Selection Dialog");
5282 gtk_window_set_position (GTK_WINDOW (window), GTK_WIN_POS_MOUSE);
5284 gtk_signal_connect (GTK_OBJECT (window), "destroy",
5285 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
5288 gtk_signal_connect (GTK_OBJECT (GTK_FONT_SELECTION_DIALOG (window)->ok_button),
5289 "clicked", GTK_SIGNAL_FUNC(font_selection_ok),
5290 GTK_FONT_SELECTION_DIALOG (window));
5291 gtk_signal_connect_object (GTK_OBJECT (GTK_FONT_SELECTION_DIALOG (window)->cancel_button),
5292 "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy),
5293 GTK_OBJECT (window));
5296 if (!GTK_WIDGET_VISIBLE (window))
5297 gtk_widget_show (window);
5299 gtk_widget_destroy (window);
5306 static GtkWidget *dialog_window = NULL;
5309 label_toggle (GtkWidget *widget,
5314 *label = gtk_label_new ("Dialog Test");
5315 gtk_signal_connect (GTK_OBJECT (*label),
5317 GTK_SIGNAL_FUNC (gtk_widget_destroyed),
5319 gtk_misc_set_padding (GTK_MISC (*label), 10, 10);
5320 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog_window)->vbox),
5321 *label, TRUE, TRUE, 0);
5322 gtk_widget_show (*label);
5325 gtk_widget_destroy (*label);
5329 create_dialog (void)
5331 static GtkWidget *label;
5336 dialog_window = gtk_dialog_new ();
5338 gtk_signal_connect (GTK_OBJECT (dialog_window), "destroy",
5339 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
5342 gtk_window_set_title (GTK_WINDOW (dialog_window), "GtkDialog");
5343 gtk_container_set_border_width (GTK_CONTAINER (dialog_window), 0);
5344 gtk_widget_set_usize (dialog_window, 200, 110);
5346 button = gtk_button_new_with_label ("OK");
5347 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
5348 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog_window)->action_area),
5349 button, TRUE, TRUE, 0);
5350 gtk_widget_grab_default (button);
5351 gtk_widget_show (button);
5353 button = gtk_button_new_with_label ("Toggle");
5354 gtk_signal_connect (GTK_OBJECT (button), "clicked",
5355 GTK_SIGNAL_FUNC (label_toggle),
5357 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
5358 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog_window)->action_area),
5359 button, TRUE, TRUE, 0);
5360 gtk_widget_show (button);
5365 if (!GTK_WIDGET_VISIBLE (dialog_window))
5366 gtk_widget_show (dialog_window);
5368 gtk_widget_destroy (dialog_window);
5373 static gboolean event_watcher_enter_id = 0;
5374 static gboolean event_watcher_leave_id = 0;
5377 event_watcher (GtkObject *object,
5383 g_print ("Watch: \"%s\" emitted for %s\n",
5384 gtk_signal_name (signal_id),
5385 gtk_type_name (GTK_OBJECT_TYPE (object)));
5391 event_watcher_down (void)
5393 if (event_watcher_enter_id)
5397 signal_id = gtk_signal_lookup ("enter_notify_event", GTK_TYPE_WIDGET);
5398 gtk_signal_remove_emission_hook (signal_id, event_watcher_enter_id);
5399 event_watcher_enter_id = 0;
5400 signal_id = gtk_signal_lookup ("leave_notify_event", GTK_TYPE_WIDGET);
5401 gtk_signal_remove_emission_hook (signal_id, event_watcher_leave_id);
5402 event_watcher_leave_id = 0;
5407 event_watcher_toggle (void)
5409 if (event_watcher_enter_id)
5410 event_watcher_down ();
5415 signal_id = gtk_signal_lookup ("enter_notify_event", GTK_TYPE_WIDGET);
5416 event_watcher_enter_id = gtk_signal_add_emission_hook (signal_id, event_watcher, NULL);
5417 signal_id = gtk_signal_lookup ("leave_notify_event", GTK_TYPE_WIDGET);
5418 event_watcher_leave_id = gtk_signal_add_emission_hook (signal_id, event_watcher, NULL);
5423 create_event_watcher (void)
5429 dialog_window = gtk_dialog_new ();
5431 gtk_signal_connect (GTK_OBJECT (dialog_window), "destroy",
5432 GTK_SIGNAL_FUNC (gtk_widget_destroyed),
5434 gtk_signal_connect (GTK_OBJECT (dialog_window),
5436 GTK_SIGNAL_FUNC (event_watcher_down),
5439 gtk_window_set_title (GTK_WINDOW (dialog_window), "Event Watcher");
5440 gtk_container_set_border_width (GTK_CONTAINER (dialog_window), 0);
5441 gtk_widget_set_usize (dialog_window, 200, 110);
5443 button = gtk_toggle_button_new_with_label ("Activate Watch");
5444 gtk_signal_connect (GTK_OBJECT (button), "clicked",
5445 GTK_SIGNAL_FUNC (event_watcher_toggle),
5447 gtk_container_set_border_width (GTK_CONTAINER (button), 10);
5448 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog_window)->vbox),
5449 button, TRUE, TRUE, 0);
5450 gtk_widget_show (button);
5452 button = gtk_button_new_with_label ("Close");
5453 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
5454 GTK_SIGNAL_FUNC (gtk_widget_destroy),
5455 (GtkObject*) dialog_window);
5456 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
5457 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog_window)->action_area),
5458 button, TRUE, TRUE, 0);
5459 gtk_widget_grab_default (button);
5460 gtk_widget_show (button);
5463 if (!GTK_WIDGET_VISIBLE (dialog_window))
5464 gtk_widget_show (dialog_window);
5466 gtk_widget_destroy (dialog_window);
5474 create_range_controls (void)
5476 static GtkWidget *window = NULL;
5480 GtkWidget *scrollbar;
5482 GtkWidget *separator;
5483 GtkObject *adjustment;
5487 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
5489 gtk_signal_connect (GTK_OBJECT (window), "destroy",
5490 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
5493 gtk_window_set_title (GTK_WINDOW (window), "range controls");
5494 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
5497 box1 = gtk_vbox_new (FALSE, 0);
5498 gtk_container_add (GTK_CONTAINER (window), box1);
5499 gtk_widget_show (box1);
5502 box2 = gtk_vbox_new (FALSE, 10);
5503 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
5504 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
5505 gtk_widget_show (box2);
5508 adjustment = gtk_adjustment_new (0.0, 0.0, 101.0, 0.1, 1.0, 1.0);
5510 scale = gtk_hscale_new (GTK_ADJUSTMENT (adjustment));
5511 gtk_widget_set_usize (GTK_WIDGET (scale), 150, 30);
5512 gtk_range_set_update_policy (GTK_RANGE (scale), GTK_UPDATE_DELAYED);
5513 gtk_scale_set_digits (GTK_SCALE (scale), 1);
5514 gtk_scale_set_draw_value (GTK_SCALE (scale), TRUE);
5515 gtk_box_pack_start (GTK_BOX (box2), scale, TRUE, TRUE, 0);
5516 gtk_widget_show (scale);
5518 scrollbar = gtk_hscrollbar_new (GTK_ADJUSTMENT (adjustment));
5519 gtk_range_set_update_policy (GTK_RANGE (scrollbar),
5520 GTK_UPDATE_CONTINUOUS);
5521 gtk_box_pack_start (GTK_BOX (box2), scrollbar, TRUE, TRUE, 0);
5522 gtk_widget_show (scrollbar);
5525 separator = gtk_hseparator_new ();
5526 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
5527 gtk_widget_show (separator);
5530 box2 = gtk_vbox_new (FALSE, 10);
5531 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
5532 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
5533 gtk_widget_show (box2);
5536 button = gtk_button_new_with_label ("close");
5537 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
5538 GTK_SIGNAL_FUNC(gtk_widget_destroy),
5539 GTK_OBJECT (window));
5540 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
5541 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
5542 gtk_widget_grab_default (button);
5543 gtk_widget_show (button);
5546 if (!GTK_WIDGET_VISIBLE (window))
5547 gtk_widget_show (window);
5549 gtk_widget_destroy (window);
5557 create_rulers (void)
5559 static GtkWidget *window = NULL;
5565 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
5566 gtk_window_set_policy (GTK_WINDOW (window), TRUE, TRUE, FALSE);
5568 gtk_signal_connect (GTK_OBJECT (window), "destroy",
5569 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
5572 gtk_window_set_title (GTK_WINDOW (window), "rulers");
5573 gtk_widget_set_usize (window, 300, 300);
5574 gtk_widget_set_events (window,
5575 GDK_POINTER_MOTION_MASK
5576 | GDK_POINTER_MOTION_HINT_MASK);
5577 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
5579 table = gtk_table_new (2, 2, FALSE);
5580 gtk_container_add (GTK_CONTAINER (window), table);
5581 gtk_widget_show (table);
5583 ruler = gtk_hruler_new ();
5584 gtk_ruler_set_metric (GTK_RULER (ruler), GTK_CENTIMETERS);
5585 gtk_ruler_set_range (GTK_RULER (ruler), 100, 0, 0, 20);
5587 gtk_signal_connect_object (
5588 GTK_OBJECT (window),
5589 "motion_notify_event",
5591 GTK_WIDGET_CLASS (GTK_OBJECT (ruler)->klass)->motion_notify_event),
5592 GTK_OBJECT (ruler));
5594 gtk_table_attach (GTK_TABLE (table), ruler, 1, 2, 0, 1,
5595 GTK_EXPAND | GTK_FILL, GTK_FILL, 0, 0);
5596 gtk_widget_show (ruler);
5599 ruler = gtk_vruler_new ();
5600 gtk_ruler_set_range (GTK_RULER (ruler), 5, 15, 0, 20);
5602 gtk_signal_connect_object (
5603 GTK_OBJECT (window),
5604 "motion_notify_event",
5605 GTK_SIGNAL_FUNC (GTK_WIDGET_CLASS (GTK_OBJECT (ruler)->klass)->motion_notify_event),
5606 GTK_OBJECT (ruler));
5608 gtk_table_attach (GTK_TABLE (table), ruler, 0, 1, 1, 2,
5609 GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
5610 gtk_widget_show (ruler);
5613 if (!GTK_WIDGET_VISIBLE (window))
5614 gtk_widget_show (window);
5616 gtk_widget_destroy (window);
5620 text_toggle_editable (GtkWidget *checkbutton,
5623 gtk_text_set_editable(GTK_TEXT(text),
5624 GTK_TOGGLE_BUTTON(checkbutton)->active);
5628 text_toggle_word_wrap (GtkWidget *checkbutton,
5631 gtk_text_set_word_wrap(GTK_TEXT(text),
5632 GTK_TOGGLE_BUTTON(checkbutton)->active);
5639 { { 0, 0x0000, 0x0000, 0x0000 }, "black" },
5640 { { 0, 0xFFFF, 0xFFFF, 0xFFFF }, "white" },
5641 { { 0, 0xFFFF, 0x0000, 0x0000 }, "red" },
5642 { { 0, 0x0000, 0xFFFF, 0x0000 }, "green" },
5643 { { 0, 0x0000, 0x0000, 0xFFFF }, "blue" },
5644 { { 0, 0x0000, 0xFFFF, 0xFFFF }, "cyan" },
5645 { { 0, 0xFFFF, 0x0000, 0xFFFF }, "magenta" },
5646 { { 0, 0xFFFF, 0xFFFF, 0x0000 }, "yellow" }
5649 int ntext_colors = sizeof(text_colors) / sizeof(text_colors[0]);
5655 text_insert_random (GtkWidget *w, GtkText *text)
5659 for (i=0; i<10; i++)
5661 c = 'A' + rand() % ('Z' - 'A');
5662 gtk_text_set_point (text, rand() % gtk_text_get_length (text));
5663 gtk_text_insert (text, NULL, NULL, NULL, &c, 1);
5672 static GtkWidget *window = NULL;
5678 GtkWidget *separator;
5680 GtkWidget *hscrollbar;
5681 GtkWidget *vscrollbar;
5689 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
5690 gtk_widget_set_name (window, "text window");
5691 gtk_widget_set_usize (window, 500, 500);
5692 gtk_window_set_policy (GTK_WINDOW(window), TRUE, TRUE, FALSE);
5694 gtk_signal_connect (GTK_OBJECT (window), "destroy",
5695 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
5698 gtk_window_set_title (GTK_WINDOW (window), "test");
5699 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
5702 box1 = gtk_vbox_new (FALSE, 0);
5703 gtk_container_add (GTK_CONTAINER (window), box1);
5704 gtk_widget_show (box1);
5707 box2 = gtk_vbox_new (FALSE, 10);
5708 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
5709 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
5710 gtk_widget_show (box2);
5713 table = gtk_table_new (2, 2, FALSE);
5714 gtk_table_set_row_spacing (GTK_TABLE (table), 0, 2);
5715 gtk_table_set_col_spacing (GTK_TABLE (table), 0, 2);
5716 gtk_box_pack_start (GTK_BOX (box2), table, TRUE, TRUE, 0);
5717 gtk_widget_show (table);
5719 text = gtk_text_new (NULL, NULL);
5720 gtk_text_set_editable (GTK_TEXT (text), TRUE);
5721 gtk_table_attach (GTK_TABLE (table), text, 0, 1, 0, 1,
5722 GTK_EXPAND | GTK_SHRINK | GTK_FILL,
5723 GTK_EXPAND | GTK_SHRINK | GTK_FILL, 0, 0);
5724 gtk_widget_grab_focus (text);
5725 gtk_widget_show (text);
5727 hscrollbar = gtk_hscrollbar_new (GTK_TEXT (text)->hadj);
5728 gtk_table_attach (GTK_TABLE (table), hscrollbar, 0, 1, 1, 2,
5729 GTK_EXPAND | GTK_FILL | GTK_SHRINK, GTK_FILL, 0, 0);
5730 gtk_widget_show (hscrollbar);
5732 vscrollbar = gtk_vscrollbar_new (GTK_TEXT (text)->vadj);
5733 gtk_table_attach (GTK_TABLE (table), vscrollbar, 1, 2, 0, 1,
5734 GTK_FILL, GTK_EXPAND | GTK_SHRINK | GTK_FILL, 0, 0);
5735 gtk_widget_show (vscrollbar);
5737 gtk_text_freeze (GTK_TEXT (text));
5739 font = gdk_font_load ("-adobe-courier-medium-r-normal--*-120-*-*-*-*-*-*");
5741 for (i=0; i<ntext_colors; i++)
5743 gtk_text_insert (GTK_TEXT (text), font, NULL, NULL,
5744 text_colors[i].name, -1);
5745 gtk_text_insert (GTK_TEXT (text), font, NULL, NULL, "\t", -1);
5747 for (j=0; j<ntext_colors; j++)
5749 gtk_text_insert (GTK_TEXT (text), font,
5750 &text_colors[j].color, &text_colors[i].color,
5753 gtk_text_insert (GTK_TEXT (text), NULL, NULL, NULL, "\n", -1);
5756 /* The Text widget will reference count the font, so we
5757 * unreference it here
5759 gdk_font_unref (font);
5761 infile = fopen("testgtk.c", "r");
5766 int nbytes_read, nbytes_alloc;
5769 nbytes_alloc = 1024;
5770 buffer = g_new (char, nbytes_alloc);
5774 if (nbytes_alloc < nbytes_read + 1024)
5777 buffer = g_realloc (buffer, nbytes_alloc);
5779 len = fread (buffer + nbytes_read, 1, 1024, infile);
5785 gtk_text_insert (GTK_TEXT (text), NULL, NULL,
5786 NULL, buffer, nbytes_read);
5791 gtk_text_thaw (GTK_TEXT (text));
5793 hbox = gtk_hbutton_box_new ();
5794 gtk_box_pack_start (GTK_BOX (box2), hbox, FALSE, FALSE, 0);
5795 gtk_widget_show (hbox);
5797 check = gtk_check_button_new_with_label("Editable");
5798 gtk_box_pack_start (GTK_BOX (hbox), check, FALSE, FALSE, 0);
5799 gtk_signal_connect (GTK_OBJECT(check), "toggled",
5800 GTK_SIGNAL_FUNC(text_toggle_editable), text);
5801 gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(check), TRUE);
5802 gtk_widget_show (check);
5804 check = gtk_check_button_new_with_label("Wrap Words");
5805 gtk_box_pack_start (GTK_BOX (hbox), check, FALSE, TRUE, 0);
5806 gtk_signal_connect (GTK_OBJECT(check), "toggled",
5807 GTK_SIGNAL_FUNC(text_toggle_word_wrap), text);
5808 gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(check), FALSE);
5809 gtk_widget_show (check);
5811 separator = gtk_hseparator_new ();
5812 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
5813 gtk_widget_show (separator);
5816 box2 = gtk_vbox_new (FALSE, 10);
5817 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
5818 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
5819 gtk_widget_show (box2);
5822 button = gtk_button_new_with_label ("insert random");
5823 gtk_signal_connect (GTK_OBJECT (button), "clicked",
5824 GTK_SIGNAL_FUNC(text_insert_random),
5826 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
5827 gtk_widget_show (button);
5829 button = gtk_button_new_with_label ("close");
5830 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
5831 GTK_SIGNAL_FUNC(gtk_widget_destroy),
5832 GTK_OBJECT (window));
5833 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
5834 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
5835 gtk_widget_grab_default (button);
5836 gtk_widget_show (button);
5839 if (!GTK_WIDGET_VISIBLE (window))
5840 gtk_widget_show (window);
5842 gtk_widget_destroy (window);
5849 GdkPixmap *book_open;
5850 GdkPixmap *book_closed;
5851 GdkBitmap *book_open_mask;
5852 GdkBitmap *book_closed_mask;
5853 GtkWidget *sample_notebook;
5856 page_switch (GtkWidget *widget, GtkNotebookPage *page, gint page_num)
5858 GtkNotebookPage *oldpage;
5861 oldpage = GTK_NOTEBOOK (widget)->cur_page;
5863 if (page == oldpage)
5865 pixwid = ((GtkBoxChild*)
5866 (GTK_BOX (page->tab_label)->children->data))->widget;
5867 gtk_pixmap_set (GTK_PIXMAP (pixwid), book_open, book_open_mask);
5868 pixwid = ((GtkBoxChild*)
5869 (GTK_BOX (page->menu_label)->children->data))->widget;
5870 gtk_pixmap_set (GTK_PIXMAP (pixwid), book_open, book_open_mask);
5874 pixwid = ((GtkBoxChild*)
5875 (GTK_BOX (oldpage->tab_label)->children->data))->widget;
5876 gtk_pixmap_set (GTK_PIXMAP (pixwid), book_closed, book_closed_mask);
5877 pixwid = ((GtkBoxChild*)
5878 (GTK_BOX (oldpage->menu_label)->children->data))->widget;
5879 gtk_pixmap_set (GTK_PIXMAP (pixwid), book_closed, book_closed_mask);
5884 tab_fill (GtkToggleButton *button, GtkWidget *child)
5887 GtkPackType pack_type;
5889 gtk_notebook_query_tab_label_packing (GTK_NOTEBOOK (sample_notebook), child,
5890 &expand, NULL, &pack_type);
5891 gtk_notebook_set_tab_label_packing (GTK_NOTEBOOK (sample_notebook), child,
5892 expand, button->active, pack_type);
5896 tab_expand (GtkToggleButton *button, GtkWidget *child)
5899 GtkPackType pack_type;
5901 gtk_notebook_query_tab_label_packing (GTK_NOTEBOOK (sample_notebook), child,
5902 NULL, &fill, &pack_type);
5903 gtk_notebook_set_tab_label_packing (GTK_NOTEBOOK (sample_notebook), child,
5904 button->active, fill, pack_type);
5908 tab_pack (GtkToggleButton *button, GtkWidget *child)
5914 gtk_notebook_query_tab_label_packing (GTK_NOTEBOOK (sample_notebook), child,
5915 &expand, &fill, NULL);
5916 gtk_notebook_set_tab_label_packing (GTK_NOTEBOOK (sample_notebook), child,
5917 expand, fill, button->active);
5921 create_pages (GtkNotebook *notebook, gint start, gint end)
5923 GtkWidget *child = NULL;
5928 GtkWidget *label_box;
5929 GtkWidget *menu_box;
5934 for (i = start; i <= end; i++)
5936 sprintf (buffer, "Page %d", i);
5938 child = gtk_frame_new (buffer);
5939 gtk_container_set_border_width (GTK_CONTAINER (child), 10);
5941 vbox = gtk_vbox_new (TRUE,0);
5942 gtk_container_set_border_width (GTK_CONTAINER (vbox), 10);
5943 gtk_container_add (GTK_CONTAINER (child), vbox);
5945 hbox = gtk_hbox_new (TRUE,0);
5946 gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 5);
5948 button = gtk_check_button_new_with_label ("Fill Tab");
5949 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
5950 gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON (button), TRUE);
5951 gtk_signal_connect (GTK_OBJECT (button), "toggled",
5952 GTK_SIGNAL_FUNC (tab_fill), child);
5954 button = gtk_check_button_new_with_label ("Expand Tab");
5955 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
5956 gtk_signal_connect (GTK_OBJECT (button), "toggled",
5957 GTK_SIGNAL_FUNC (tab_expand), child);
5959 button = gtk_check_button_new_with_label ("Pack end");
5960 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
5961 gtk_signal_connect (GTK_OBJECT (button), "toggled",
5962 GTK_SIGNAL_FUNC (tab_pack), child);
5964 button = gtk_button_new_with_label ("Hide Page");
5965 gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 5);
5966 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
5967 GTK_SIGNAL_FUNC (gtk_widget_hide),
5968 GTK_OBJECT (child));
5970 gtk_widget_show_all (child);
5972 label_box = gtk_hbox_new (FALSE, 0);
5973 pixwid = gtk_pixmap_new (book_closed, book_closed_mask);
5974 gtk_box_pack_start (GTK_BOX (label_box), pixwid, FALSE, TRUE, 0);
5975 gtk_misc_set_padding (GTK_MISC (pixwid), 3, 1);
5976 label = gtk_label_new (buffer);
5977 gtk_box_pack_start (GTK_BOX (label_box), label, FALSE, TRUE, 0);
5978 gtk_widget_show_all (label_box);
5980 menu_box = gtk_hbox_new (FALSE, 0);
5981 pixwid = gtk_pixmap_new (book_closed, book_closed_mask);
5982 gtk_box_pack_start (GTK_BOX (menu_box), pixwid, FALSE, TRUE, 0);
5983 gtk_misc_set_padding (GTK_MISC (pixwid), 3, 1);
5984 label = gtk_label_new (buffer);
5985 gtk_box_pack_start (GTK_BOX (menu_box), label, FALSE, TRUE, 0);
5986 gtk_widget_show_all (menu_box);
5987 gtk_notebook_append_page_menu (notebook, child, label_box, menu_box);
5992 rotate_notebook (GtkButton *button,
5993 GtkNotebook *notebook)
5995 gtk_notebook_set_tab_pos (notebook, (notebook->tab_pos + 1) % 4);
5999 show_all_pages (GtkButton *button,
6000 GtkNotebook *notebook)
6002 gtk_container_foreach (GTK_CONTAINER (notebook),
6003 (GtkCallback) gtk_widget_show, NULL);
6007 standard_notebook (GtkButton *button,
6008 GtkNotebook *notebook)
6012 gtk_notebook_set_show_tabs (notebook, TRUE);
6013 gtk_notebook_set_scrollable (notebook, FALSE);
6014 if (g_list_length (notebook->children) == 15)
6015 for (i = 0; i < 10; i++)
6016 gtk_notebook_remove_page (notebook, 5);
6020 notabs_notebook (GtkButton *button,
6021 GtkNotebook *notebook)
6025 gtk_notebook_set_show_tabs (notebook, FALSE);
6026 if (g_list_length (notebook->children) == 15)
6027 for (i = 0; i < 10; i++)
6028 gtk_notebook_remove_page (notebook, 5);
6032 scrollable_notebook (GtkButton *button,
6033 GtkNotebook *notebook)
6035 gtk_notebook_set_show_tabs (notebook, TRUE);
6036 gtk_notebook_set_scrollable (notebook, TRUE);
6037 if (g_list_length (notebook->children) == 5)
6038 create_pages (notebook, 6, 15);
6042 notebook_popup (GtkToggleButton *button,
6043 GtkNotebook *notebook)
6046 gtk_notebook_popup_enable (notebook);
6048 gtk_notebook_popup_disable (notebook);
6052 notebook_homogeneous (GtkToggleButton *button,
6053 GtkNotebook *notebook)
6055 gtk_notebook_set_homogeneous_tabs (notebook, button->active);
6059 create_notebook (void)
6061 static GtkWidget *window = NULL;
6065 GtkWidget *separator;
6067 GdkColor *transparent = NULL;
6070 static OptionMenuItem items[] =
6072 { "Standard", standard_notebook },
6073 { "No tabs", notabs_notebook },
6074 { "Scrollable", scrollable_notebook }
6079 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
6081 gtk_signal_connect (GTK_OBJECT (window), "destroy",
6082 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
6085 gtk_window_set_title (GTK_WINDOW (window), "notebook");
6086 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
6088 box1 = gtk_vbox_new (FALSE, 0);
6089 gtk_container_add (GTK_CONTAINER (window), box1);
6091 sample_notebook = gtk_notebook_new ();
6092 gtk_signal_connect (GTK_OBJECT (sample_notebook), "switch_page",
6093 GTK_SIGNAL_FUNC (page_switch), NULL);
6094 gtk_notebook_set_tab_pos (GTK_NOTEBOOK (sample_notebook), GTK_POS_TOP);
6095 gtk_box_pack_start (GTK_BOX (box1), sample_notebook, TRUE, TRUE, 0);
6096 gtk_container_set_border_width (GTK_CONTAINER (sample_notebook), 10);
6098 gtk_widget_realize (sample_notebook);
6099 book_open = gdk_pixmap_create_from_xpm_d (sample_notebook->window,
6103 book_closed = gdk_pixmap_create_from_xpm_d (sample_notebook->window,
6108 create_pages (GTK_NOTEBOOK (sample_notebook), 1, 5);
6110 separator = gtk_hseparator_new ();
6111 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 10);
6113 box2 = gtk_hbox_new (FALSE, 5);
6114 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
6115 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
6117 button = gtk_check_button_new_with_label ("popup menu");
6118 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, FALSE, 0);
6119 gtk_signal_connect (GTK_OBJECT(button), "clicked",
6120 GTK_SIGNAL_FUNC (notebook_popup),
6121 GTK_OBJECT (sample_notebook));
6123 button = gtk_check_button_new_with_label ("homogeneous tabs");
6124 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, FALSE, 0);
6125 gtk_signal_connect (GTK_OBJECT(button), "clicked",
6126 GTK_SIGNAL_FUNC (notebook_homogeneous),
6127 GTK_OBJECT (sample_notebook));
6129 box2 = gtk_hbox_new (FALSE, 5);
6130 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
6131 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
6133 label = gtk_label_new ("Notebook Style :");
6134 gtk_box_pack_start (GTK_BOX (box2), label, FALSE, TRUE, 0);
6136 omenu = build_option_menu (items, 3, 0, sample_notebook);
6137 gtk_box_pack_start (GTK_BOX (box2), omenu, FALSE, TRUE, 0);
6139 button = gtk_button_new_with_label ("Show all Pages");
6140 gtk_box_pack_start (GTK_BOX (box2), button, FALSE, TRUE, 0);
6141 gtk_signal_connect (GTK_OBJECT (button), "clicked",
6142 GTK_SIGNAL_FUNC (show_all_pages), sample_notebook);
6144 box2 = gtk_hbox_new (TRUE, 10);
6145 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
6146 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
6148 button = gtk_button_new_with_label ("prev");
6149 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
6150 GTK_SIGNAL_FUNC (gtk_notebook_prev_page),
6151 GTK_OBJECT (sample_notebook));
6152 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
6154 button = gtk_button_new_with_label ("next");
6155 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
6156 GTK_SIGNAL_FUNC (gtk_notebook_next_page),
6157 GTK_OBJECT (sample_notebook));
6158 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
6160 button = gtk_button_new_with_label ("rotate");
6161 gtk_signal_connect (GTK_OBJECT (button), "clicked",
6162 GTK_SIGNAL_FUNC (rotate_notebook), sample_notebook);
6163 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
6165 separator = gtk_hseparator_new ();
6166 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 5);
6168 button = gtk_button_new_with_label ("close");
6169 gtk_container_set_border_width (GTK_CONTAINER (button), 5);
6170 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
6171 GTK_SIGNAL_FUNC (gtk_widget_destroy),
6172 GTK_OBJECT (window));
6173 gtk_box_pack_start (GTK_BOX (box1), button, FALSE, FALSE, 0);
6174 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
6175 gtk_widget_grab_default (button);
6178 if (!GTK_WIDGET_VISIBLE (window))
6179 gtk_widget_show_all (window);
6181 gtk_widget_destroy (window);
6189 toggle_resize (GtkWidget *widget, GtkWidget *child)
6191 GtkPaned *paned = GTK_PANED (child->parent);
6192 gboolean is_child1 = (child == paned->child1);
6193 gboolean resize, shrink;
6195 resize = is_child1 ? paned->child1_resize : paned->child2_resize;
6196 shrink = is_child1 ? paned->child1_shrink : paned->child2_shrink;
6198 gtk_widget_ref (child);
6199 gtk_container_remove (GTK_CONTAINER (child->parent), child);
6201 gtk_paned_pack1 (paned, child, !resize, shrink);
6203 gtk_paned_pack2 (paned, child, !resize, shrink);
6204 gtk_widget_unref (child);
6208 toggle_shrink (GtkWidget *widget, GtkWidget *child)
6210 GtkPaned *paned = GTK_PANED (child->parent);
6211 gboolean is_child1 = (child == paned->child1);
6212 gboolean resize, shrink;
6214 resize = is_child1 ? paned->child1_resize : paned->child2_resize;
6215 shrink = is_child1 ? paned->child1_shrink : paned->child2_shrink;
6217 gtk_widget_ref (child);
6218 gtk_container_remove (GTK_CONTAINER (child->parent), child);
6220 gtk_paned_pack1 (paned, child, resize, !shrink);
6222 gtk_paned_pack2 (paned, child, resize, !shrink);
6223 gtk_widget_unref (child);
6227 create_pane_options (GtkPaned *paned,
6228 const gchar *frame_label,
6229 const gchar *label1,
6230 const gchar *label2)
6235 GtkWidget *check_button;
6237 frame = gtk_frame_new (frame_label);
6238 gtk_container_set_border_width (GTK_CONTAINER (frame), 4);
6240 table = gtk_table_new (3, 2, 4);
6241 gtk_container_add (GTK_CONTAINER (frame), table);
6243 label = gtk_label_new (label1);
6244 gtk_table_attach_defaults (GTK_TABLE (table), label,
6247 check_button = gtk_check_button_new_with_label ("Resize");
6248 gtk_table_attach_defaults (GTK_TABLE (table), check_button,
6250 gtk_signal_connect (GTK_OBJECT (check_button), "toggled",
6251 GTK_SIGNAL_FUNC (toggle_resize),
6254 check_button = gtk_check_button_new_with_label ("Shrink");
6255 gtk_table_attach_defaults (GTK_TABLE (table), check_button,
6257 gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON (check_button),
6259 gtk_signal_connect (GTK_OBJECT (check_button), "toggled",
6260 GTK_SIGNAL_FUNC (toggle_shrink),
6263 label = gtk_label_new (label2);
6264 gtk_table_attach_defaults (GTK_TABLE (table), label,
6267 check_button = gtk_check_button_new_with_label ("Resize");
6268 gtk_table_attach_defaults (GTK_TABLE (table), check_button,
6270 gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON (check_button),
6272 gtk_signal_connect (GTK_OBJECT (check_button), "toggled",
6273 GTK_SIGNAL_FUNC (toggle_resize),
6276 check_button = gtk_check_button_new_with_label ("Shrink");
6277 gtk_table_attach_defaults (GTK_TABLE (table), check_button,
6279 gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON (check_button),
6281 gtk_signal_connect (GTK_OBJECT (check_button), "toggled",
6282 GTK_SIGNAL_FUNC (toggle_shrink),
6291 static GtkWidget *window = NULL;
6300 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
6302 gtk_signal_connect (GTK_OBJECT (window), "destroy",
6303 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
6306 gtk_window_set_title (GTK_WINDOW (window), "Panes");
6307 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
6309 vbox = gtk_vbox_new (FALSE, 0);
6310 gtk_container_add (GTK_CONTAINER (window), vbox);
6312 vpaned = gtk_vpaned_new ();
6313 gtk_box_pack_start (GTK_BOX (vbox), vpaned, TRUE, TRUE, 0);
6314 gtk_container_set_border_width (GTK_CONTAINER(vpaned), 5);
6316 hpaned = gtk_hpaned_new ();
6317 gtk_paned_add1 (GTK_PANED (vpaned), hpaned);
6319 frame = gtk_frame_new (NULL);
6320 gtk_frame_set_shadow_type (GTK_FRAME(frame), GTK_SHADOW_IN);
6321 gtk_widget_set_usize (frame, 60, 60);
6322 gtk_paned_add1 (GTK_PANED (hpaned), frame);
6324 button = gtk_button_new_with_label ("Hi there");
6325 gtk_container_add (GTK_CONTAINER(frame), button);
6327 frame = gtk_frame_new (NULL);
6328 gtk_frame_set_shadow_type (GTK_FRAME(frame), GTK_SHADOW_IN);
6329 gtk_widget_set_usize (frame, 80, 60);
6330 gtk_paned_add2 (GTK_PANED (hpaned), frame);
6332 frame = gtk_frame_new (NULL);
6333 gtk_frame_set_shadow_type (GTK_FRAME(frame), GTK_SHADOW_IN);
6334 gtk_widget_set_usize (frame, 60, 80);
6335 gtk_paned_add2 (GTK_PANED (vpaned), frame);
6337 /* Now create toggle buttons to control sizing */
6339 gtk_box_pack_start (GTK_BOX (vbox),
6340 create_pane_options (GTK_PANED (hpaned),
6346 gtk_box_pack_start (GTK_BOX (vbox),
6347 create_pane_options (GTK_PANED (vpaned),
6353 gtk_widget_show_all (vbox);
6356 if (!GTK_WIDGET_VISIBLE (window))
6357 gtk_widget_show (window);
6359 gtk_widget_destroy (window);
6368 dnd_drop_destroy_popup (GtkWidget *widget, GtkWindow **window)
6370 if(GTK_IS_BUTTON(widget)) /* I.e. they clicked the close button */
6371 gtk_widget_destroy(GTK_WIDGET(*window));
6373 gtk_grab_remove(GTK_WIDGET(*window));
6381 dnd_drop (GtkWidget *button, GdkEvent *event)
6383 static GtkWidget *window = NULL;
6384 GtkWidget *vbox, *lbl, *btn;
6387 /* DND doesn't obey gtk_grab's, so check if we're already displaying
6388 * drop modal dialog first
6393 window = gtk_window_new(GTK_WINDOW_DIALOG);
6394 gtk_container_set_border_width (GTK_CONTAINER(window), 10);
6396 gtk_signal_connect (GTK_OBJECT (window), "destroy",
6397 GTK_SIGNAL_FUNC(dnd_drop_destroy_popup),
6399 gtk_signal_connect (GTK_OBJECT (window), "delete-event",
6400 GTK_SIGNAL_FUNC(gtk_false),
6403 vbox = gtk_vbox_new(FALSE, 5);
6405 /* Display message that we got from drop source */
6406 msg = g_malloc(strlen(event->dropdataavailable.data)
6407 + strlen(event->dropdataavailable.data_type) + 100);
6408 sprintf(msg, "Drop data of type %s was:\n\n%s",
6409 event->dropdataavailable.data_type,
6410 (char *)event->dropdataavailable.data);
6411 lbl = gtk_label_new(msg);
6412 gtk_label_set_justify(GTK_LABEL(lbl), GTK_JUSTIFY_FILL);
6414 gtk_widget_show(lbl);
6415 gtk_box_pack_start_defaults(GTK_BOX(vbox), lbl);
6417 /* Provide an obvious way out of this heinousness */
6418 btn = gtk_button_new_with_label("Continue with life in\nspite of this oppression");
6419 gtk_signal_connect_object (GTK_OBJECT (btn), "clicked",
6420 GTK_SIGNAL_FUNC(gtk_widget_destroy),
6421 GTK_OBJECT (window));
6422 gtk_widget_show(btn);
6423 gtk_box_pack_start_defaults(GTK_BOX(vbox), btn);
6425 gtk_container_add(GTK_CONTAINER(window), vbox);
6427 gtk_widget_show(vbox);
6428 gtk_grab_add(window);
6429 gtk_widget_show(window);
6433 dnd_drag_request (GtkWidget *button, GdkEvent *event)
6435 #define DND_STRING "Bill Gates demands royalties for\nyour use of his innovation."
6436 gtk_widget_dnd_data_set (button, event, DND_STRING, strlen(DND_STRING) + 1);
6442 static GtkWidget *window = NULL;
6448 GtkWidget *separator;
6450 /* For clarity... */
6451 char *possible_drag_types[] = {"text/plain"};
6452 char *accepted_drop_types[] = {"text/plain"};
6454 static GtkWidget *drag_icon = NULL;
6455 static GtkWidget *drop_icon = NULL;
6459 GdkPoint hotspot = {5,5};
6463 drag_icon = shape_create_icon ("Modeller.xpm",
6464 440, 140, 0,0, GTK_WINDOW_POPUP);
6466 gtk_signal_connect (GTK_OBJECT (drag_icon), "destroy",
6467 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
6470 gtk_widget_hide (drag_icon);
6475 drop_icon = shape_create_icon ("3DRings.xpm",
6476 440, 140, 0,0, GTK_WINDOW_POPUP);
6478 gtk_signal_connect (GTK_OBJECT (drop_icon), "destroy",
6479 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
6482 gtk_widget_hide (drop_icon);
6485 gdk_dnd_set_drag_shape(drag_icon->window,
6490 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
6492 gtk_signal_connect (GTK_OBJECT (window), "destroy",
6493 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
6496 gtk_window_set_title (GTK_WINDOW (window), "Drag -N- Drop");
6497 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
6499 box1 = gtk_vbox_new (FALSE, 0);
6500 gtk_container_add (GTK_CONTAINER (window), box1);
6501 gtk_widget_show (box1);
6503 box2 = gtk_hbox_new (FALSE, 5);
6504 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
6505 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
6506 gtk_widget_show (box2);
6508 frame = gtk_frame_new ("Drag");
6509 gtk_box_pack_start (GTK_BOX (box2), frame, TRUE, TRUE, 0);
6510 gtk_widget_show (frame);
6512 box3 = gtk_vbox_new (FALSE, 5);
6513 gtk_container_set_border_width (GTK_CONTAINER (box3), 5);
6514 gtk_container_add (GTK_CONTAINER (frame), box3);
6515 gtk_widget_show (box3);
6520 button = gtk_button_new_with_label ("Drag me!");
6521 gtk_box_pack_start (GTK_BOX (box3), button, FALSE, TRUE, 0);
6522 gtk_widget_show (button);
6525 * currently, the widget has to be realized to
6526 * set dnd on it, this needs to change
6528 gtk_widget_realize (button);
6529 gtk_signal_connect (GTK_OBJECT (button),
6530 "drag_request_event",
6531 GTK_SIGNAL_FUNC(dnd_drag_request),
6534 gtk_widget_dnd_drag_set (button, TRUE, possible_drag_types, 1);
6537 frame = gtk_frame_new ("Drop");
6538 gtk_box_pack_start (GTK_BOX (box2), frame, TRUE, TRUE, 0);
6539 gtk_widget_show (frame);
6541 box3 = gtk_vbox_new (FALSE, 5);
6542 gtk_container_set_border_width (GTK_CONTAINER (box3), 5);
6543 gtk_container_add (GTK_CONTAINER (frame), box3);
6544 gtk_widget_show (box3);
6550 button = gtk_button_new_with_label ("To");
6551 gtk_box_pack_start (GTK_BOX (box3), button, FALSE, TRUE, 0);
6552 gtk_widget_show (button);
6554 gtk_widget_realize (button);
6555 gtk_signal_connect (GTK_OBJECT (button),
6556 "drop_data_available_event",
6557 GTK_SIGNAL_FUNC(dnd_drop),
6560 gtk_widget_dnd_drop_set (button, TRUE, accepted_drop_types, 1, FALSE);
6563 separator = gtk_hseparator_new ();
6564 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
6565 gtk_widget_show (separator);
6568 box2 = gtk_vbox_new (FALSE, 10);
6569 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
6570 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
6571 gtk_widget_show (box2);
6574 button = gtk_button_new_with_label ("close");
6576 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
6577 GTK_SIGNAL_FUNC(gtk_widget_destroy),
6578 GTK_OBJECT (window));
6580 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
6581 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
6582 gtk_widget_grab_default (button);
6583 gtk_widget_show (button);
6586 if (!GTK_WIDGET_VISIBLE (window))
6587 gtk_widget_show (window);
6589 gtk_widget_destroy (window);
6597 static GdkWindow *root_win = NULL;
6599 typedef struct _cursoroffset {gint x,y;} CursorOffset;
6602 shape_pressed (GtkWidget *widget, GdkEventButton *event)
6606 /* ignore double and triple click */
6607 if (event->type != GDK_BUTTON_PRESS)
6610 p = gtk_object_get_user_data (GTK_OBJECT(widget));
6611 p->x = (int) event->x;
6612 p->y = (int) event->y;
6614 gtk_grab_add (widget);
6615 gdk_pointer_grab (widget->window, TRUE,
6616 GDK_BUTTON_RELEASE_MASK |
6617 GDK_BUTTON_MOTION_MASK |
6618 GDK_POINTER_MOTION_HINT_MASK,
6623 shape_released (GtkWidget *widget)
6625 gtk_grab_remove (widget);
6626 gdk_pointer_ungrab (0);
6630 shape_motion (GtkWidget *widget,
6631 GdkEventMotion *event)
6635 GdkModifierType mask;
6637 p = gtk_object_get_user_data (GTK_OBJECT (widget));
6640 * Can't use event->x / event->y here
6641 * because I need absolute coordinates.
6643 gdk_window_get_pointer (root_win, &xp, &yp, &mask);
6644 gtk_widget_set_uposition (widget, xp - p->x, yp - p->y);
6648 shape_create_icon (char *xpm_file,
6658 CursorOffset* icon_pos;
6660 GdkBitmap *gdk_pixmap_mask;
6661 GdkPixmap *gdk_pixmap;
6664 style = gtk_widget_get_default_style ();
6665 gc = style->black_gc;
6668 * GDK_WINDOW_TOPLEVEL works also, giving you a title border
6670 window = gtk_window_new (window_type);
6672 fixed = gtk_fixed_new ();
6673 gtk_widget_set_usize (fixed, 100,100);
6674 gtk_container_add (GTK_CONTAINER (window), fixed);
6675 gtk_widget_show (fixed);
6677 gtk_widget_set_events (window,
6678 gtk_widget_get_events (window) |
6679 GDK_BUTTON_MOTION_MASK |
6680 GDK_POINTER_MOTION_HINT_MASK |
6681 GDK_BUTTON_PRESS_MASK);
6683 gtk_widget_realize (window);
6684 gdk_pixmap = gdk_pixmap_create_from_xpm (window->window, &gdk_pixmap_mask,
6685 &style->bg[GTK_STATE_NORMAL],
6688 pixmap = gtk_pixmap_new (gdk_pixmap, gdk_pixmap_mask);
6689 gtk_fixed_put (GTK_FIXED (fixed), pixmap, px,py);
6690 gtk_widget_show (pixmap);
6692 gtk_widget_shape_combine_mask (window, gdk_pixmap_mask, px,py);
6695 gtk_signal_connect (GTK_OBJECT (window), "button_press_event",
6696 GTK_SIGNAL_FUNC (shape_pressed),NULL);
6697 gtk_signal_connect (GTK_OBJECT (window), "button_release_event",
6698 GTK_SIGNAL_FUNC (shape_released),NULL);
6699 gtk_signal_connect (GTK_OBJECT (window), "motion_notify_event",
6700 GTK_SIGNAL_FUNC (shape_motion),NULL);
6702 icon_pos = g_new (CursorOffset, 1);
6703 gtk_object_set_user_data(GTK_OBJECT(window), icon_pos);
6705 gtk_widget_set_uposition (window, x, y);
6706 gtk_widget_show (window);
6712 create_shapes (void)
6714 /* Variables used by the Drag/Drop and Shape Window demos */
6715 static GtkWidget *modeller = NULL;
6716 static GtkWidget *sheets = NULL;
6717 static GtkWidget *rings = NULL;
6719 root_win = gdk_window_foreign_new (GDK_ROOT_WINDOW ());
6723 modeller = shape_create_icon ("Modeller.xpm",
6724 440, 140, 0,0, GTK_WINDOW_POPUP);
6726 gtk_signal_connect (GTK_OBJECT (modeller), "destroy",
6727 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
6731 gtk_widget_destroy (modeller);
6735 sheets = shape_create_icon ("FilesQueue.xpm",
6736 580, 170, 0,0, GTK_WINDOW_POPUP);
6738 gtk_signal_connect (GTK_OBJECT (sheets), "destroy",
6739 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
6744 gtk_widget_destroy (sheets);
6748 rings = shape_create_icon ("3DRings.xpm",
6749 460, 270, 25,25, GTK_WINDOW_TOPLEVEL);
6751 gtk_signal_connect (GTK_OBJECT (rings), "destroy",
6752 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
6756 gtk_widget_destroy (rings);
6764 create_wmhints (void)
6766 static GtkWidget *window = NULL;
6768 GtkWidget *separator;
6777 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
6779 gtk_signal_connect (GTK_OBJECT (window), "destroy",
6780 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
6783 gtk_window_set_title (GTK_WINDOW (window), "WM Hints");
6784 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
6786 gtk_widget_realize (window);
6788 circles = gdk_bitmap_create_from_data (window->window,
6792 gdk_window_set_icon (window->window, NULL,
6795 gdk_window_set_icon_name (window->window, "WMHints Test Icon");
6797 gdk_window_set_decorations (window->window, GDK_DECOR_ALL | GDK_DECOR_MENU);
6798 gdk_window_set_functions (window->window, GDK_FUNC_ALL | GDK_FUNC_RESIZE);
6800 box1 = gtk_vbox_new (FALSE, 0);
6801 gtk_container_add (GTK_CONTAINER (window), box1);
6802 gtk_widget_show (box1);
6804 label = gtk_label_new ("Try iconizing me!");
6805 gtk_widget_set_usize (label, 150, 50);
6806 gtk_box_pack_start (GTK_BOX (box1), label, TRUE, TRUE, 0);
6807 gtk_widget_show (label);
6810 separator = gtk_hseparator_new ();
6811 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
6812 gtk_widget_show (separator);
6815 box2 = gtk_vbox_new (FALSE, 10);
6816 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
6817 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
6818 gtk_widget_show (box2);
6821 button = gtk_button_new_with_label ("close");
6823 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
6824 GTK_SIGNAL_FUNC(gtk_widget_destroy),
6825 GTK_OBJECT (window));
6827 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
6828 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
6829 gtk_widget_grab_default (button);
6830 gtk_widget_show (button);
6833 if (!GTK_WIDGET_VISIBLE (window))
6834 gtk_widget_show (window);
6836 gtk_widget_destroy (window);
6843 typedef struct _ProgressData {
6846 GtkWidget *block_spin;
6847 GtkWidget *x_align_spin;
6848 GtkWidget *y_align_spin;
6849 GtkWidget *step_spin;
6850 GtkWidget *act_blocks_spin;
6859 progress_timeout (gpointer data)
6864 adj = GTK_PROGRESS (data)->adjustment;
6866 new_val = adj->value + 1;
6867 if (new_val > adj->upper)
6868 new_val = adj->lower;
6870 gtk_progress_set_value (GTK_PROGRESS (data), new_val);
6876 destroy_progress (GtkWidget *widget,
6877 ProgressData **pdata)
6879 gtk_timeout_remove ((*pdata)->timer);
6880 (*pdata)->timer = 0;
6881 (*pdata)->window = NULL;
6887 progressbar_toggle_orientation (GtkWidget *widget, ProgressData *pdata)
6891 if (!GTK_WIDGET_MAPPED (widget))
6894 RADIOMENUTOGGLED ((GtkRadioMenuItem *)
6895 (((GtkOptionMenu *)(pdata->omenu1))->menu_item), i);
6897 gtk_progress_bar_set_orientation (GTK_PROGRESS_BAR (pdata->pbar),
6898 (GtkProgressBarOrientation) (3-i));
6902 toggle_show_text (GtkWidget *widget, ProgressData *pdata)
6904 gtk_progress_set_show_text (GTK_PROGRESS (pdata->pbar),
6905 GTK_TOGGLE_BUTTON (widget)->active);
6906 gtk_widget_set_sensitive (pdata->entry, GTK_TOGGLE_BUTTON (widget)->active);
6907 gtk_widget_set_sensitive (pdata->x_align_spin,
6908 GTK_TOGGLE_BUTTON (widget)->active);
6909 gtk_widget_set_sensitive (pdata->y_align_spin,
6910 GTK_TOGGLE_BUTTON (widget)->active);
6914 progressbar_toggle_bar_style (GtkWidget *widget, ProgressData *pdata)
6918 if (!GTK_WIDGET_MAPPED (widget))
6921 RADIOMENUTOGGLED ((GtkRadioMenuItem *)
6922 (((GtkOptionMenu *)(pdata->omenu2))->menu_item), i);
6927 gtk_widget_set_sensitive (pdata->block_spin, TRUE);
6929 gtk_widget_set_sensitive (pdata->block_spin, FALSE);
6931 gtk_progress_bar_set_bar_style (GTK_PROGRESS_BAR (pdata->pbar),
6932 (GtkProgressBarStyle) i);
6936 progress_value_changed (GtkAdjustment *adj, ProgressData *pdata)
6940 if (GTK_PROGRESS (pdata->pbar)->activity_mode)
6941 sprintf (buf, "???");
6943 sprintf (buf, "%.0f%%", 100 *
6944 gtk_progress_get_current_percentage (GTK_PROGRESS (pdata->pbar)));
6945 gtk_label_set_text (GTK_LABEL (pdata->label), buf);
6949 adjust_blocks (GtkAdjustment *adj, ProgressData *pdata)
6951 gtk_progress_set_percentage (GTK_PROGRESS (pdata->pbar), 0);
6952 gtk_progress_bar_set_discrete_blocks (GTK_PROGRESS_BAR (pdata->pbar),
6953 gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (pdata->block_spin)));
6957 adjust_step (GtkAdjustment *adj, ProgressData *pdata)
6959 gtk_progress_bar_set_activity_step (GTK_PROGRESS_BAR (pdata->pbar),
6960 gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (pdata->step_spin)));
6964 adjust_act_blocks (GtkAdjustment *adj, ProgressData *pdata)
6966 gtk_progress_bar_set_activity_blocks (GTK_PROGRESS_BAR (pdata->pbar),
6967 gtk_spin_button_get_value_as_int
6968 (GTK_SPIN_BUTTON (pdata->act_blocks_spin)));
6972 adjust_align (GtkAdjustment *adj, ProgressData *pdata)
6974 gtk_progress_set_text_alignment (GTK_PROGRESS (pdata->pbar),
6975 gtk_spin_button_get_value_as_float
6976 (GTK_SPIN_BUTTON (pdata->x_align_spin)),
6977 gtk_spin_button_get_value_as_float
6978 (GTK_SPIN_BUTTON (pdata->y_align_spin)));
6982 toggle_activity_mode (GtkWidget *widget, ProgressData *pdata)
6984 gtk_progress_set_activity_mode (GTK_PROGRESS (pdata->pbar),
6985 GTK_TOGGLE_BUTTON (widget)->active);
6986 gtk_widget_set_sensitive (pdata->step_spin,
6987 GTK_TOGGLE_BUTTON (widget)->active);
6988 gtk_widget_set_sensitive (pdata->act_blocks_spin,
6989 GTK_TOGGLE_BUTTON (widget)->active);
6993 entry_changed (GtkWidget *widget, ProgressData *pdata)
6995 gtk_progress_set_format_string (GTK_PROGRESS (pdata->pbar),
6996 gtk_entry_get_text (GTK_ENTRY (pdata->entry)));
7000 create_progress_bar (void)
7012 static ProgressData *pdata = NULL;
7014 static OptionMenuItem items1[] =
7016 { "Left-Right", progressbar_toggle_orientation },
7017 { "Right-Left", progressbar_toggle_orientation },
7018 { "Bottom-Top", progressbar_toggle_orientation },
7019 { "Top-Bottom", progressbar_toggle_orientation }
7022 static OptionMenuItem items2[] =
7024 { "Continuous", progressbar_toggle_bar_style },
7025 { "Discrete", progressbar_toggle_bar_style }
7029 pdata = g_new0 (ProgressData, 1);
7033 pdata->window = gtk_dialog_new ();
7035 gtk_window_set_policy (GTK_WINDOW (pdata->window), FALSE, FALSE, TRUE);
7037 gtk_signal_connect (GTK_OBJECT (pdata->window), "destroy",
7038 GTK_SIGNAL_FUNC (destroy_progress),
7043 gtk_window_set_title (GTK_WINDOW (pdata->window), "GtkProgressBar");
7044 gtk_container_set_border_width (GTK_CONTAINER (pdata->window), 0);
7046 vbox = gtk_vbox_new (FALSE, 5);
7047 gtk_container_set_border_width (GTK_CONTAINER (vbox), 10);
7048 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (pdata->window)->vbox),
7049 vbox, FALSE, TRUE, 0);
7051 frame = gtk_frame_new ("Progress");
7052 gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, TRUE, 0);
7054 vbox2 = gtk_vbox_new (FALSE, 5);
7055 gtk_container_add (GTK_CONTAINER (frame), vbox2);
7057 align = gtk_alignment_new (0.5, 0.5, 0, 0);
7058 gtk_box_pack_start (GTK_BOX (vbox2), align, FALSE, FALSE, 5);
7060 adj = (GtkAdjustment *) gtk_adjustment_new (0, 1, 300, 0, 0, 0);
7061 gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
7062 GTK_SIGNAL_FUNC (progress_value_changed), pdata);
7064 pdata->pbar = gtk_progress_bar_new_with_adjustment (adj);
7065 gtk_progress_set_format_string (GTK_PROGRESS (pdata->pbar),
7066 "%v from [%l,%u] (=%p%%)");
7067 gtk_container_add (GTK_CONTAINER (align), pdata->pbar);
7068 pdata->timer = gtk_timeout_add (100, progress_timeout, pdata->pbar);
7070 align = gtk_alignment_new (0.5, 0.5, 0, 0);
7071 gtk_box_pack_start (GTK_BOX (vbox2), align, FALSE, FALSE, 5);
7073 hbox = gtk_hbox_new (FALSE, 5);
7074 gtk_container_add (GTK_CONTAINER (align), hbox);
7075 label = gtk_label_new ("Label updated by user :");
7076 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
7077 pdata->label = gtk_label_new ("");
7078 gtk_box_pack_start (GTK_BOX (hbox), pdata->label, FALSE, TRUE, 0);
7080 frame = gtk_frame_new ("Options");
7081 gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, TRUE, 0);
7083 vbox2 = gtk_vbox_new (FALSE, 5);
7084 gtk_container_add (GTK_CONTAINER (frame), vbox2);
7086 tab = gtk_table_new (7, 2, FALSE);
7087 gtk_box_pack_start (GTK_BOX (vbox2), tab, FALSE, TRUE, 0);
7089 label = gtk_label_new ("Orientation :");
7090 gtk_table_attach (GTK_TABLE (tab), label, 0, 1, 0, 1,
7091 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
7093 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
7095 pdata->omenu1 = build_option_menu (items1, 4, 0, pdata);
7096 hbox = gtk_hbox_new (FALSE, 0);
7097 gtk_table_attach (GTK_TABLE (tab), hbox, 1, 2, 0, 1,
7098 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
7100 gtk_box_pack_start (GTK_BOX (hbox), pdata->omenu1, TRUE, TRUE, 0);
7102 check = gtk_check_button_new_with_label ("Show text");
7103 gtk_signal_connect (GTK_OBJECT (check), "clicked",
7104 GTK_SIGNAL_FUNC (toggle_show_text),
7106 gtk_table_attach (GTK_TABLE (tab), check, 0, 1, 1, 2,
7107 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
7110 hbox = gtk_hbox_new (FALSE, 0);
7111 gtk_table_attach (GTK_TABLE (tab), hbox, 1, 2, 1, 2,
7112 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
7115 label = gtk_label_new ("Format : ");
7116 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
7118 pdata->entry = gtk_entry_new ();
7119 gtk_signal_connect (GTK_OBJECT (pdata->entry), "changed",
7120 GTK_SIGNAL_FUNC (entry_changed),
7122 gtk_box_pack_start (GTK_BOX (hbox), pdata->entry, TRUE, TRUE, 0);
7123 gtk_entry_set_text (GTK_ENTRY (pdata->entry), "%v from [%l,%u] (=%p%%)");
7124 gtk_widget_set_usize (pdata->entry, 100, -1);
7125 gtk_widget_set_sensitive (pdata->entry, FALSE);
7127 label = gtk_label_new ("Text align :");
7128 gtk_table_attach (GTK_TABLE (tab), label, 0, 1, 2, 3,
7129 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
7131 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
7133 hbox = gtk_hbox_new (FALSE, 0);
7134 gtk_table_attach (GTK_TABLE (tab), hbox, 1, 2, 2, 3,
7135 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
7138 label = gtk_label_new ("x :");
7139 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 5);
7141 adj = (GtkAdjustment *) gtk_adjustment_new (0.5, 0, 1, 0.1, 0.1, 0);
7142 pdata->x_align_spin = gtk_spin_button_new (adj, 0, 1);
7143 gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
7144 GTK_SIGNAL_FUNC (adjust_align), pdata);
7145 gtk_box_pack_start (GTK_BOX (hbox), pdata->x_align_spin, FALSE, TRUE, 0);
7146 gtk_widget_set_sensitive (pdata->x_align_spin, FALSE);
7148 label = gtk_label_new ("y :");
7149 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 5);
7151 adj = (GtkAdjustment *) gtk_adjustment_new (0.5, 0, 1, 0.1, 0.1, 0);
7152 pdata->y_align_spin = gtk_spin_button_new (adj, 0, 1);
7153 gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
7154 GTK_SIGNAL_FUNC (adjust_align), pdata);
7155 gtk_box_pack_start (GTK_BOX (hbox), pdata->y_align_spin, FALSE, TRUE, 0);
7156 gtk_widget_set_sensitive (pdata->y_align_spin, FALSE);
7158 label = gtk_label_new ("Bar Style :");
7159 gtk_table_attach (GTK_TABLE (tab), label, 0, 1, 3, 4,
7160 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
7162 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
7164 pdata->omenu2 = build_option_menu (items2, 2, 0, pdata);
7165 hbox = gtk_hbox_new (FALSE, 0);
7166 gtk_table_attach (GTK_TABLE (tab), hbox, 1, 2, 3, 4,
7167 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
7169 gtk_box_pack_start (GTK_BOX (hbox), pdata->omenu2, TRUE, TRUE, 0);
7171 label = gtk_label_new ("Block count :");
7172 gtk_table_attach (GTK_TABLE (tab), label, 0, 1, 4, 5,
7173 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
7175 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
7177 hbox = gtk_hbox_new (FALSE, 0);
7178 gtk_table_attach (GTK_TABLE (tab), hbox, 1, 2, 4, 5,
7179 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
7181 adj = (GtkAdjustment *) gtk_adjustment_new (10, 2, 20, 1, 5, 0);
7182 pdata->block_spin = gtk_spin_button_new (adj, 0, 0);
7183 gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
7184 GTK_SIGNAL_FUNC (adjust_blocks), pdata);
7185 gtk_box_pack_start (GTK_BOX (hbox), pdata->block_spin, FALSE, TRUE, 0);
7186 gtk_widget_set_sensitive (pdata->block_spin, FALSE);
7188 check = gtk_check_button_new_with_label ("Activity mode");
7189 gtk_signal_connect (GTK_OBJECT (check), "clicked",
7190 GTK_SIGNAL_FUNC (toggle_activity_mode),
7192 gtk_table_attach (GTK_TABLE (tab), check, 0, 1, 5, 6,
7193 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
7196 hbox = gtk_hbox_new (FALSE, 0);
7197 gtk_table_attach (GTK_TABLE (tab), hbox, 1, 2, 5, 6,
7198 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
7200 label = gtk_label_new ("Step size : ");
7201 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
7202 adj = (GtkAdjustment *) gtk_adjustment_new (3, 1, 20, 1, 5, 0);
7203 pdata->step_spin = gtk_spin_button_new (adj, 0, 0);
7204 gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
7205 GTK_SIGNAL_FUNC (adjust_step), pdata);
7206 gtk_box_pack_start (GTK_BOX (hbox), pdata->step_spin, FALSE, TRUE, 0);
7207 gtk_widget_set_sensitive (pdata->step_spin, FALSE);
7209 hbox = gtk_hbox_new (FALSE, 0);
7210 gtk_table_attach (GTK_TABLE (tab), hbox, 1, 2, 6, 7,
7211 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
7213 label = gtk_label_new ("Blocks : ");
7214 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
7215 adj = (GtkAdjustment *) gtk_adjustment_new (5, 2, 10, 1, 5, 0);
7216 pdata->act_blocks_spin = gtk_spin_button_new (adj, 0, 0);
7217 gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
7218 GTK_SIGNAL_FUNC (adjust_act_blocks), pdata);
7219 gtk_box_pack_start (GTK_BOX (hbox), pdata->act_blocks_spin, FALSE, TRUE,
7221 gtk_widget_set_sensitive (pdata->act_blocks_spin, FALSE);
7223 button = gtk_button_new_with_label ("close");
7224 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
7225 GTK_SIGNAL_FUNC (gtk_widget_destroy),
7226 GTK_OBJECT (pdata->window));
7227 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
7228 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (pdata->window)->action_area),
7229 button, TRUE, TRUE, 0);
7230 gtk_widget_grab_default (button);
7233 if (!GTK_WIDGET_VISIBLE (pdata->window))
7234 gtk_widget_show_all (pdata->window);
7236 gtk_widget_destroy (pdata->window);
7243 static int color_idle = 0;
7246 color_idle_func (GtkWidget *preview)
7248 static int count = 1;
7252 for (i = 0; i < 256; i++)
7254 for (j = 0, k = 0; j < 256; j++)
7256 buf[k+0] = i + count;
7258 buf[k+2] = j + count;
7262 gtk_preview_draw_row (GTK_PREVIEW (preview), buf, 0, i, 256);
7267 gtk_widget_draw (preview, NULL);
7273 color_preview_destroy (GtkWidget *widget,
7276 gtk_idle_remove (color_idle);
7283 create_color_preview (void)
7285 static GtkWidget *window = NULL;
7292 gtk_widget_push_visual (gdk_rgb_get_visual ());
7293 gtk_widget_push_colormap (gdk_rgb_get_cmap ());
7294 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
7295 gtk_widget_pop_colormap ();
7296 gtk_widget_pop_visual ();
7298 gtk_signal_connect (GTK_OBJECT (window), "destroy",
7299 GTK_SIGNAL_FUNC(color_preview_destroy),
7302 gtk_window_set_title (GTK_WINDOW (window), "test");
7303 gtk_container_set_border_width (GTK_CONTAINER (window), 10);
7305 preview = gtk_preview_new (GTK_PREVIEW_COLOR);
7306 gtk_preview_size (GTK_PREVIEW (preview), 256, 256);
7307 gtk_container_add (GTK_CONTAINER (window), preview);
7309 for (i = 0; i < 256; i++)
7311 for (j = 0, k = 0; j < 256; j++)
7319 gtk_preview_draw_row (GTK_PREVIEW (preview), buf, 0, i, 256);
7322 color_idle = gtk_idle_add ((GtkFunction) color_idle_func, preview);
7325 if (!GTK_WIDGET_VISIBLE (window))
7326 gtk_widget_show_all (window);
7328 gtk_widget_destroy (window);
7335 static int gray_idle = 0;
7338 gray_idle_func (GtkWidget *preview)
7340 static int count = 1;
7344 for (i = 0; i < 256; i++)
7346 for (j = 0; j < 256; j++)
7347 buf[j] = i + j + count;
7349 gtk_preview_draw_row (GTK_PREVIEW (preview), buf, 0, i, 256);
7354 gtk_widget_draw (preview, NULL);
7360 gray_preview_destroy (GtkWidget *widget,
7363 gtk_idle_remove (gray_idle);
7370 create_gray_preview (void)
7372 static GtkWidget *window = NULL;
7379 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
7381 gtk_signal_connect (GTK_OBJECT (window), "destroy",
7382 GTK_SIGNAL_FUNC(gray_preview_destroy),
7385 gtk_window_set_title (GTK_WINDOW (window), "test");
7386 gtk_container_set_border_width (GTK_CONTAINER (window), 10);
7388 preview = gtk_preview_new (GTK_PREVIEW_GRAYSCALE);
7389 gtk_preview_size (GTK_PREVIEW (preview), 256, 256);
7390 gtk_container_add (GTK_CONTAINER (window), preview);
7392 for (i = 0; i < 256; i++)
7394 for (j = 0; j < 256; j++)
7397 gtk_preview_draw_row (GTK_PREVIEW (preview), buf, 0, i, 256);
7400 gray_idle = gtk_idle_add ((GtkFunction) gray_idle_func, preview);
7403 if (!GTK_WIDGET_VISIBLE (window))
7404 gtk_widget_show_all (window);
7406 gtk_widget_destroy (window);
7415 selection_test_received (GtkWidget *list, GtkSelectionData *data)
7418 GtkWidget *list_item;
7422 if (data->length < 0)
7424 g_print ("Selection retrieval failed\n");
7427 if (data->type != GDK_SELECTION_TYPE_ATOM)
7429 g_print ("Selection \"TARGETS\" was not returned as atoms!\n");
7433 /* Clear out any current list items */
7435 gtk_list_clear_items (GTK_LIST(list), 0, -1);
7437 /* Add new items to list */
7439 atoms = (GdkAtom *)data->data;
7442 l = data->length / sizeof (GdkAtom);
7443 for (i = 0; i < l; i++)
7446 name = gdk_atom_name (atoms[i]);
7449 list_item = gtk_list_item_new_with_label (name);
7453 list_item = gtk_list_item_new_with_label ("(bad atom)");
7455 gtk_widget_show (list_item);
7456 item_list = g_list_append (item_list, list_item);
7459 gtk_list_append_items (GTK_LIST (list), item_list);
7465 selection_test_get_targets (GtkWidget *widget, GtkWidget *list)
7467 static GdkAtom targets_atom = GDK_NONE;
7469 if (targets_atom == GDK_NONE)
7470 targets_atom = gdk_atom_intern ("TARGETS", FALSE);
7472 gtk_selection_convert (list, GDK_SELECTION_PRIMARY, targets_atom,
7477 create_selection_test (void)
7479 static GtkWidget *window = NULL;
7482 GtkWidget *scrolled_win;
7488 window = gtk_dialog_new ();
7490 gtk_signal_connect (GTK_OBJECT (window), "destroy",
7491 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
7494 gtk_window_set_title (GTK_WINDOW (window), "Selection Test");
7495 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
7497 /* Create the list */
7499 vbox = gtk_vbox_new (FALSE, 5);
7500 gtk_container_set_border_width (GTK_CONTAINER (vbox), 10);
7501 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), vbox,
7504 label = gtk_label_new ("Gets available targets for current selection");
7505 gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
7507 scrolled_win = gtk_scrolled_window_new (NULL, NULL);
7508 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
7509 GTK_POLICY_AUTOMATIC,
7510 GTK_POLICY_AUTOMATIC);
7511 gtk_box_pack_start (GTK_BOX (vbox), scrolled_win, TRUE, TRUE, 0);
7512 gtk_widget_set_usize (scrolled_win, 100, 200);
7514 list = gtk_list_new ();
7515 gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (scrolled_win), list);
7517 gtk_signal_connect (GTK_OBJECT(list), "selection_received",
7518 GTK_SIGNAL_FUNC (selection_test_received), NULL);
7520 /* .. And create some buttons */
7521 button = gtk_button_new_with_label ("Get Targets");
7522 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
7523 button, TRUE, TRUE, 0);
7525 gtk_signal_connect (GTK_OBJECT (button), "clicked",
7526 GTK_SIGNAL_FUNC (selection_test_get_targets), list);
7528 button = gtk_button_new_with_label ("Quit");
7529 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
7530 button, TRUE, TRUE, 0);
7532 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
7533 GTK_SIGNAL_FUNC (gtk_widget_destroy),
7534 GTK_OBJECT (window));
7537 if (!GTK_WIDGET_VISIBLE (window))
7538 gtk_widget_show_all (window);
7540 gtk_widget_destroy (window);
7548 create_gamma_curve (void)
7550 static GtkWidget *window = NULL, *curve;
7551 static int count = 0;
7558 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
7559 gtk_window_set_title (GTK_WINDOW (window), "test");
7560 gtk_container_set_border_width (GTK_CONTAINER (window), 10);
7562 gtk_signal_connect (GTK_OBJECT (window), "destroy",
7563 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
7566 curve = gtk_gamma_curve_new ();
7567 gtk_container_add (GTK_CONTAINER (window), curve);
7568 gtk_widget_show (curve);
7571 max = 127 + (count % 2)*128;
7572 gtk_curve_set_range (GTK_CURVE (GTK_GAMMA_CURVE (curve)->curve),
7574 for (i = 0; i < max; ++i)
7575 vec[i] = (127 / sqrt (max)) * sqrt (i);
7576 gtk_curve_set_vector (GTK_CURVE (GTK_GAMMA_CURVE (curve)->curve),
7579 if (!GTK_WIDGET_VISIBLE (window))
7580 gtk_widget_show (window);
7581 else if (count % 4 == 3)
7583 gtk_widget_destroy (window);
7594 static int scroll_test_pos = 0.0;
7595 static GdkGC *scroll_test_gc = NULL;
7598 scroll_test_expose (GtkWidget *widget, GdkEventExpose *event,
7602 gint imin, imax, jmin, jmax;
7604 imin = (event->area.x) / 10;
7605 imax = (event->area.x + event->area.width + 9) / 10;
7607 jmin = ((int)adj->value + event->area.y) / 10;
7608 jmax = ((int)adj->value + event->area.y + event->area.height + 9) / 10;
7610 gdk_window_clear_area (widget->window,
7611 event->area.x, event->area.y,
7612 event->area.width, event->area.height);
7614 for (i=imin; i<imax; i++)
7615 for (j=jmin; j<jmax; j++)
7617 gdk_draw_rectangle (widget->window,
7618 widget->style->black_gc,
7620 10*i, 10*j - (int)adj->value, 1+i%10, 1+j%10);
7626 scroll_test_configure (GtkWidget *widget, GdkEventConfigure *event,
7629 adj->page_increment = 0.9 * widget->allocation.height;
7630 adj->page_size = widget->allocation.height;
7632 gtk_signal_emit_by_name (GTK_OBJECT (adj), "changed");
7636 scroll_test_adjustment_changed (GtkAdjustment *adj, GtkWidget *widget)
7638 gint source_min = (int)adj->value - scroll_test_pos;
7639 gint source_max = source_min + widget->allocation.height;
7641 gint dest_max = widget->allocation.height;
7645 scroll_test_pos = adj->value;
7647 if (!GTK_WIDGET_DRAWABLE (widget))
7654 rect.width = widget->allocation.width;
7655 rect.height = -source_min;
7656 if (rect.height > widget->allocation.height)
7657 rect.height = widget->allocation.height;
7660 dest_min = rect.height;
7665 rect.y = 2*widget->allocation.height - source_max;
7668 rect.width = widget->allocation.width;
7669 rect.height = widget->allocation.height - rect.y;
7671 source_max = widget->allocation.height;
7675 if (source_min != source_max)
7677 if (scroll_test_gc == NULL)
7679 scroll_test_gc = gdk_gc_new (widget->window);
7680 gdk_gc_set_exposures (scroll_test_gc, TRUE);
7683 gdk_draw_pixmap (widget->window,
7688 widget->allocation.width,
7689 source_max - source_min);
7691 /* Make sure graphics expose events are processed before scrolling
7694 while ((event = gdk_event_get_graphics_expose (widget->window)) != NULL)
7696 gtk_widget_event (widget, event);
7697 if (event->expose.count == 0)
7699 gdk_event_free (event);
7702 gdk_event_free (event);
7706 if (rect.height != 0)
7707 gtk_widget_draw (widget, &rect);
7712 create_scroll_test (void)
7714 static GtkWidget *window = NULL;
7716 GtkWidget *drawing_area;
7717 GtkWidget *scrollbar;
7720 GdkGeometry geometry;
7721 GdkWindowHints geometry_mask;
7725 window = gtk_dialog_new ();
7727 gtk_signal_connect (GTK_OBJECT (window), "destroy",
7728 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
7731 gtk_window_set_title (GTK_WINDOW (window), "Scroll Test");
7732 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
7734 hbox = gtk_hbox_new (FALSE, 0);
7735 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), hbox,
7737 gtk_widget_show (hbox);
7739 drawing_area = gtk_drawing_area_new ();
7740 gtk_drawing_area_size (GTK_DRAWING_AREA (drawing_area), 200, 200);
7741 gtk_box_pack_start (GTK_BOX (hbox), drawing_area, TRUE, TRUE, 0);
7742 gtk_widget_show (drawing_area);
7744 gtk_widget_set_events (drawing_area, GDK_EXPOSURE_MASK);
7746 adj = GTK_ADJUSTMENT (gtk_adjustment_new (0.0, 0.0, 1000.0, 1.0, 180.0, 200.0));
7747 scroll_test_pos = 0.0;
7749 scrollbar = gtk_vscrollbar_new (adj);
7750 gtk_box_pack_start (GTK_BOX (hbox), scrollbar, FALSE, FALSE, 0);
7751 gtk_widget_show (scrollbar);
7753 gtk_signal_connect (GTK_OBJECT (drawing_area), "expose_event",
7754 GTK_SIGNAL_FUNC (scroll_test_expose), adj);
7755 gtk_signal_connect (GTK_OBJECT (drawing_area), "configure_event",
7756 GTK_SIGNAL_FUNC (scroll_test_configure), adj);
7759 gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
7760 GTK_SIGNAL_FUNC (scroll_test_adjustment_changed),
7763 /* .. And create some buttons */
7765 button = gtk_button_new_with_label ("Quit");
7766 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
7767 button, TRUE, TRUE, 0);
7769 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
7770 GTK_SIGNAL_FUNC (gtk_widget_destroy),
7771 GTK_OBJECT (window));
7772 gtk_widget_show (button);
7774 /* Set up gridded geometry */
7776 geometry_mask = GDK_HINT_MIN_SIZE |
7777 GDK_HINT_BASE_SIZE |
7778 GDK_HINT_RESIZE_INC;
7780 geometry.min_width = 20;
7781 geometry.min_height = 20;
7782 geometry.base_width = 0;
7783 geometry.base_height = 0;
7784 geometry.width_inc = 10;
7785 geometry.height_inc = 10;
7787 gtk_window_set_geometry_hints (GTK_WINDOW (window),
7788 drawing_area, &geometry, geometry_mask);
7791 if (!GTK_WIDGET_VISIBLE (window))
7792 gtk_widget_show (window);
7794 gtk_widget_destroy (window);
7801 static int timer = 0;
7804 timeout_test (GtkWidget *label)
7806 static int count = 0;
7807 static char buffer[32];
7809 sprintf (buffer, "count: %d", ++count);
7810 gtk_label_set_text (GTK_LABEL (label), buffer);
7816 start_timeout_test (GtkWidget *widget,
7821 timer = gtk_timeout_add (100, (GtkFunction) timeout_test, label);
7826 stop_timeout_test (GtkWidget *widget,
7831 gtk_timeout_remove (timer);
7837 destroy_timeout_test (GtkWidget *widget,
7840 stop_timeout_test (NULL, NULL);
7846 create_timeout_test (void)
7848 static GtkWidget *window = NULL;
7854 window = gtk_dialog_new ();
7856 gtk_signal_connect (GTK_OBJECT (window), "destroy",
7857 GTK_SIGNAL_FUNC(destroy_timeout_test),
7860 gtk_window_set_title (GTK_WINDOW (window), "Timeout Test");
7861 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
7863 label = gtk_label_new ("count: 0");
7864 gtk_misc_set_padding (GTK_MISC (label), 10, 10);
7865 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox),
7866 label, TRUE, TRUE, 0);
7867 gtk_widget_show (label);
7869 button = gtk_button_new_with_label ("close");
7870 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
7871 GTK_SIGNAL_FUNC(gtk_widget_destroy),
7872 GTK_OBJECT (window));
7873 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
7874 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
7875 button, TRUE, TRUE, 0);
7876 gtk_widget_grab_default (button);
7877 gtk_widget_show (button);
7879 button = gtk_button_new_with_label ("start");
7880 gtk_signal_connect (GTK_OBJECT (button), "clicked",
7881 GTK_SIGNAL_FUNC(start_timeout_test),
7883 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
7884 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
7885 button, TRUE, TRUE, 0);
7886 gtk_widget_show (button);
7888 button = gtk_button_new_with_label ("stop");
7889 gtk_signal_connect (GTK_OBJECT (button), "clicked",
7890 GTK_SIGNAL_FUNC(stop_timeout_test),
7892 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
7893 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
7894 button, TRUE, TRUE, 0);
7895 gtk_widget_show (button);
7898 if (!GTK_WIDGET_VISIBLE (window))
7899 gtk_widget_show (window);
7901 gtk_widget_destroy (window);
7908 static int idle = 0;
7911 idle_test (GtkWidget *label)
7913 static int count = 0;
7914 static char buffer[32];
7916 sprintf (buffer, "count: %d", ++count);
7917 gtk_label_set_text (GTK_LABEL (label), buffer);
7923 start_idle_test (GtkWidget *widget,
7928 idle = gtk_idle_add ((GtkFunction) idle_test, label);
7933 stop_idle_test (GtkWidget *widget,
7938 gtk_idle_remove (idle);
7944 destroy_idle_test (GtkWidget *widget,
7947 stop_idle_test (NULL, NULL);
7953 toggle_idle_container (GtkObject *button,
7954 GtkContainer *container)
7956 gtk_container_set_resize_mode (container, (guint) gtk_object_get_user_data (button));
7960 create_idle_test (void)
7962 static GtkWidget *window = NULL;
7965 GtkWidget *container;
7972 window = gtk_dialog_new ();
7974 gtk_signal_connect (GTK_OBJECT (window), "destroy",
7975 GTK_SIGNAL_FUNC(destroy_idle_test),
7978 gtk_window_set_title (GTK_WINDOW (window), "Idle Test");
7979 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
7981 label = gtk_label_new ("count: 0");
7982 gtk_misc_set_padding (GTK_MISC (label), 10, 10);
7983 gtk_widget_show (label);
7986 gtk_widget_new (GTK_TYPE_HBOX,
7987 "GtkWidget::visible", TRUE,
7988 /* "GtkContainer::child", gtk_widget_new (GTK_TYPE_HBOX,
7989 * "GtkWidget::visible", TRUE,
7991 "GtkContainer::child", label,
7994 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox),
7995 container, TRUE, TRUE, 0);
7998 gtk_widget_new (GTK_TYPE_FRAME,
7999 "GtkContainer::border_width", 5,
8000 "GtkFrame::label", "Label Container",
8001 "GtkWidget::visible", TRUE,
8002 "GtkWidget::parent", GTK_DIALOG (window)->vbox,
8005 gtk_widget_new (GTK_TYPE_VBOX,
8006 "GtkWidget::visible", TRUE,
8007 "GtkWidget::parent", frame,
8010 gtk_widget_new (GTK_TYPE_RADIO_BUTTON,
8011 "GtkButton::label", "Resize-Parent",
8012 "GtkObject::user_data", (void*)GTK_RESIZE_PARENT,
8013 "GtkObject::signal::clicked", toggle_idle_container, container,
8014 "GtkWidget::visible", TRUE,
8015 "GtkWidget::parent", box,
8018 gtk_widget_new (GTK_TYPE_RADIO_BUTTON,
8019 "GtkButton::label", "Resize-Queue",
8020 "GtkObject::user_data", (void*)GTK_RESIZE_QUEUE,
8021 "GtkObject::signal::clicked", toggle_idle_container, container,
8022 "GtkRadioButton::group", button,
8023 "GtkWidget::visible", TRUE,
8024 "GtkWidget::parent", box,
8027 gtk_widget_new (GTK_TYPE_RADIO_BUTTON,
8028 "GtkButton::label", "Resize-Immediate",
8029 "GtkObject::user_data", (void*)GTK_RESIZE_IMMEDIATE,
8030 "GtkObject::signal::clicked", toggle_idle_container, container,
8031 "GtkRadioButton::group", button,
8032 "GtkWidget::visible", TRUE,
8033 "GtkWidget::parent", box,
8037 button = gtk_button_new_with_label ("close");
8038 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
8039 GTK_SIGNAL_FUNC(gtk_widget_destroy),
8040 GTK_OBJECT (window));
8041 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
8042 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
8043 button, TRUE, TRUE, 0);
8044 gtk_widget_grab_default (button);
8045 gtk_widget_show (button);
8047 button = gtk_button_new_with_label ("start");
8048 gtk_signal_connect (GTK_OBJECT (button), "clicked",
8049 GTK_SIGNAL_FUNC(start_idle_test),
8051 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
8052 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
8053 button, TRUE, TRUE, 0);
8054 gtk_widget_show (button);
8056 button = gtk_button_new_with_label ("stop");
8057 gtk_signal_connect (GTK_OBJECT (button), "clicked",
8058 GTK_SIGNAL_FUNC(stop_idle_test),
8060 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
8061 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
8062 button, TRUE, TRUE, 0);
8063 gtk_widget_show (button);
8066 if (!GTK_WIDGET_VISIBLE (window))
8067 gtk_widget_show (window);
8069 gtk_widget_destroy (window);
8077 reload_rc_file (void)
8081 if (gtk_rc_reparse_all ())
8083 toplevels = gdk_window_get_toplevels();
8087 gdk_window_get_user_data (toplevels->data, (gpointer *)&widget);
8090 gtk_widget_reset_rc_styles (widget);
8092 toplevels = toplevels->next;
8094 g_list_free (toplevels);
8099 reload_all_rc_files (void)
8101 static GdkAtom atom_rcfiles = GDK_NONE;
8107 atom_rcfiles = gdk_atom_intern("_GTK_READ_RCFILES", FALSE);
8109 for(i = 0; i < 5; i++)
8111 sev.data_format = 32;
8112 sev.message_type = atom_rcfiles;
8113 gdk_event_send_clientmessage_toall ((GdkEvent *) &sev);
8117 create_rc_file (void)
8119 static GtkWidget *window = NULL;
8124 window = gtk_dialog_new ();
8126 gtk_signal_connect (GTK_OBJECT (window), "destroy",
8127 GTK_SIGNAL_FUNC(destroy_idle_test),
8130 gtk_window_set_title (GTK_WINDOW (window), "Reload Rc file");
8131 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
8133 button = gtk_button_new_with_label ("Reload");
8134 gtk_signal_connect (GTK_OBJECT (button), "clicked",
8135 GTK_SIGNAL_FUNC(reload_rc_file), NULL);
8136 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
8137 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
8138 button, TRUE, TRUE, 0);
8139 gtk_widget_grab_default (button);
8140 gtk_widget_show (button);
8142 button = gtk_button_new_with_label ("Reload All");
8143 gtk_signal_connect (GTK_OBJECT (button), "clicked",
8144 GTK_SIGNAL_FUNC(reload_all_rc_files), NULL);
8145 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
8146 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
8147 button, TRUE, TRUE, 0);
8148 gtk_widget_show (button);
8150 button = gtk_button_new_with_label ("Close");
8151 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
8152 GTK_SIGNAL_FUNC(gtk_widget_destroy),
8153 GTK_OBJECT (window));
8154 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
8155 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
8156 button, TRUE, TRUE, 0);
8157 gtk_widget_show (button);
8161 if (!GTK_WIDGET_VISIBLE (window))
8162 gtk_widget_show (window);
8164 gtk_widget_destroy (window);
8168 * Test of recursive mainloop
8172 mainloop_destroyed (GtkWidget *w, GtkWidget **window)
8179 create_mainloop (void)
8181 static GtkWidget *window = NULL;
8187 window = gtk_dialog_new ();
8189 gtk_window_set_title (GTK_WINDOW (window), "Test Main Loop");
8191 gtk_signal_connect (GTK_OBJECT (window), "destroy",
8192 GTK_SIGNAL_FUNC(mainloop_destroyed),
8195 label = gtk_label_new ("In recursive main loop...");
8196 gtk_misc_set_padding (GTK_MISC(label), 20, 20);
8198 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), label,
8200 gtk_widget_show (label);
8202 button = gtk_button_new_with_label ("Leave");
8203 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area), button,
8206 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
8207 GTK_SIGNAL_FUNC (gtk_widget_destroy),
8208 GTK_OBJECT (window));
8210 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
8211 gtk_widget_grab_default (button);
8213 gtk_widget_show (button);
8216 if (!GTK_WIDGET_VISIBLE (window))
8218 gtk_widget_show (window);
8220 g_print ("create_mainloop: start\n");
8222 g_print ("create_mainloop: done\n");
8225 gtk_widget_destroy (window);
8229 layout_expose_handler (GtkWidget *widget, GdkEventExpose *event)
8234 gint imin, imax, jmin, jmax;
8236 layout = GTK_LAYOUT (widget);
8238 imin = (layout->xoffset + event->area.x) / 10;
8239 imax = (layout->xoffset + event->area.x + event->area.width + 9) / 10;
8241 jmin = (layout->yoffset + event->area.y) / 10;
8242 jmax = (layout->yoffset + event->area.y + event->area.height + 9) / 10;
8244 gdk_window_clear_area (widget->window,
8245 event->area.x, event->area.y,
8246 event->area.width, event->area.height);
8248 for (i=imin; i<imax; i++)
8249 for (j=jmin; j<jmax; j++)
8251 gdk_draw_rectangle (layout->bin_window,
8252 widget->style->black_gc,
8254 10*i - layout->xoffset, 10*j - layout->yoffset,
8260 void create_layout (void)
8262 static GtkWidget *window = NULL;
8264 GtkWidget *scrolledwindow;
8273 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
8274 gtk_signal_connect (GTK_OBJECT (window), "destroy",
8275 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
8278 gtk_window_set_title (GTK_WINDOW (window), "Layout");
8279 gtk_widget_set_usize (window, 200, 200);
8281 scrolledwindow = gtk_scrolled_window_new (NULL, NULL);
8283 gtk_container_add (GTK_CONTAINER (window), scrolledwindow);
8285 layout = gtk_layout_new (NULL, NULL);
8286 gtk_container_add (GTK_CONTAINER (scrolledwindow), layout);
8288 gtk_widget_set_events (layout, GDK_EXPOSURE_MASK);
8289 gtk_signal_connect (GTK_OBJECT (layout), "expose_event",
8290 GTK_SIGNAL_FUNC (layout_expose_handler), NULL);
8292 gtk_layout_set_size (GTK_LAYOUT (layout), 1600, 64000);
8294 for (i=0 ; i < 16 ; i++)
8295 for (j=0 ; j < 16 ; j++)
8297 sprintf(buf, "Button %d, %d", i, j);
8299 button = gtk_button_new_with_label (buf);
8301 button = gtk_label_new (buf);
8303 gtk_layout_put (GTK_LAYOUT (layout), button,
8307 for (i=16; i < 640; i++)
8309 sprintf(buf, "Button %d, %d", i, 0);
8311 button = gtk_button_new_with_label (buf);
8313 button = gtk_label_new (buf);
8315 gtk_layout_put (GTK_LAYOUT (layout), button,
8320 if (!GTK_WIDGET_VISIBLE (window))
8321 gtk_widget_show_all (window);
8323 gtk_widget_destroy (window);
8327 * Main Window and Exit
8331 do_exit (GtkWidget *widget, GtkWidget *window)
8333 gtk_widget_destroy (window);
8338 create_main_window (void)
8345 { "button box", create_button_box },
8346 { "buttons", create_buttons },
8347 { "check buttons", create_check_buttons },
8348 { "clist", create_clist},
8349 { "color selection", create_color_selection },
8350 { "ctree", create_ctree },
8351 { "cursors", create_cursors },
8352 { "dialog", create_dialog },
8353 /* { "dnd", create_dnd }, */
8354 { "entry", create_entry },
8355 { "event watcher", create_event_watcher },
8356 { "file selection", create_file_selection },
8357 { "font selection", create_font_selection },
8358 { "gamma curve", create_gamma_curve },
8359 { "handle box", create_handle_box },
8360 { "item factory", create_item_factory },
8361 { "labels", create_labels },
8362 { "layout", create_layout },
8363 { "list", create_list },
8364 { "menus", create_menus },
8365 { "modal window", create_modal_window },
8366 { "notebook", create_notebook },
8367 { "panes", create_panes },
8368 { "pixmap", create_pixmap },
8369 { "preview color", create_color_preview },
8370 { "preview gray", create_gray_preview },
8371 { "progress bar", create_progress_bar },
8372 { "radio buttons", create_radio_buttons },
8373 { "range controls", create_range_controls },
8374 { "rc file", create_rc_file },
8375 { "reparent", create_reparent },
8376 { "rulers", create_rulers },
8377 { "saved position", create_saved_position },
8378 { "scrolled windows", create_scrolled_windows },
8379 { "shapes", create_shapes },
8380 { "spinbutton", create_spins },
8381 { "statusbar", create_statusbar },
8382 { "test idle", create_idle_test },
8383 { "test mainloop", create_mainloop },
8384 { "test scrolling", create_scroll_test },
8385 { "test selection", create_selection_test },
8386 { "test timeout", create_timeout_test },
8387 { "text", create_text },
8388 { "toggle buttons", create_toggle_buttons },
8389 { "toolbar", create_toolbar },
8390 { "tooltips", create_tooltips },
8391 { "tree", create_tree_mode_window},
8392 { "WM hints", create_wmhints },
8394 int nbuttons = sizeof (buttons) / sizeof (buttons[0]);
8398 GtkWidget *scrolled_window;
8402 GtkWidget *separator;
8405 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
8406 gtk_window_set_policy (GTK_WINDOW (window), FALSE, FALSE, FALSE);
8407 gtk_widget_set_name (window, "main window");
8408 gtk_widget_set_usize (window, 200, 400);
8409 gtk_widget_set_uposition (window, 20, 20);
8411 gtk_signal_connect (GTK_OBJECT (window), "destroy",
8412 GTK_SIGNAL_FUNC(gtk_main_quit),
8414 gtk_signal_connect (GTK_OBJECT (window), "delete-event",
8415 GTK_SIGNAL_FUNC (gtk_false),
8418 box1 = gtk_vbox_new (FALSE, 0);
8419 gtk_container_add (GTK_CONTAINER (window), box1);
8421 if (gtk_micro_version > 0)
8433 label = gtk_label_new (buffer);
8434 gtk_box_pack_start (GTK_BOX (box1), label, FALSE, FALSE, 0);
8436 scrolled_window = gtk_scrolled_window_new (NULL, NULL);
8437 gtk_container_set_border_width (GTK_CONTAINER (scrolled_window), 10);
8438 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
8439 GTK_POLICY_AUTOMATIC,
8440 GTK_POLICY_AUTOMATIC);
8441 gtk_box_pack_start (GTK_BOX (box1), scrolled_window, TRUE, TRUE, 0);
8443 box2 = gtk_vbox_new (FALSE, 0);
8444 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
8445 gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (scrolled_window), box2);
8446 gtk_container_set_focus_vadjustment (GTK_CONTAINER (box2),
8447 gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (scrolled_window)));
8448 gtk_widget_show (box2);
8450 for (i = 0; i < nbuttons; i++)
8452 button = gtk_button_new_with_label (buttons[i].label);
8453 if (buttons[i].func)
8454 gtk_signal_connect (GTK_OBJECT (button),
8456 GTK_SIGNAL_FUNC(buttons[i].func),
8459 gtk_widget_set_sensitive (button, FALSE);
8460 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
8463 separator = gtk_hseparator_new ();
8464 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
8466 box2 = gtk_vbox_new (FALSE, 10);
8467 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
8468 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
8470 button = gtk_button_new_with_label ("close");
8471 gtk_signal_connect (GTK_OBJECT (button), "clicked",
8472 GTK_SIGNAL_FUNC (do_exit),
8474 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
8475 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
8476 gtk_widget_grab_default (button);
8478 gtk_widget_show_all (window);
8482 main (int argc, char *argv[])
8484 GtkBindingSet *binding_set;
8486 srand (time (NULL));
8490 gtk_rc_add_default_file ("testgtkrc");
8492 gtk_init (&argc, &argv);
8498 binding_set = gtk_binding_set_by_class (gtk_type_class (GTK_TYPE_WIDGET));
8499 gtk_binding_entry_add_signal (binding_set,
8500 '9', GDK_CONTROL_MASK | GDK_RELEASE_MASK,
8503 GTK_TYPE_STRING, "GtkWidgetClass <ctrl><release>9 test");
8505 create_main_window ();