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);
1630 reparent_label (GtkWidget *widget,
1631 GtkWidget *new_parent)
1635 label = gtk_object_get_user_data (GTK_OBJECT (widget));
1637 gtk_widget_reparent (label, new_parent);
1641 set_parent_signal (GtkWidget *child,
1642 GtkWidget *old_parent,
1645 g_print ("set_parent for \"%s\": new parent: \"%s\", old parent: \"%s\", data: %d\n",
1646 gtk_type_name (GTK_OBJECT_TYPE (child)),
1647 child->parent ? gtk_type_name (GTK_OBJECT_TYPE (child->parent)) : "NULL",
1648 old_parent ? gtk_type_name (GTK_OBJECT_TYPE (old_parent)) : "NULL",
1649 GPOINTER_TO_INT (func_data));
1653 create_reparent (void)
1655 static GtkWidget *window = NULL;
1662 GtkWidget *separator;
1666 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
1668 gtk_signal_connect (GTK_OBJECT (window), "destroy",
1669 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
1672 gtk_window_set_title (GTK_WINDOW (window), "reparent");
1673 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
1675 box1 = gtk_vbox_new (FALSE, 0);
1676 gtk_container_add (GTK_CONTAINER (window), box1);
1678 box2 = gtk_hbox_new (FALSE, 5);
1679 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
1680 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
1682 label = gtk_label_new ("Hello World");
1684 frame = gtk_frame_new ("Frame 1");
1685 gtk_box_pack_start (GTK_BOX (box2), frame, TRUE, TRUE, 0);
1687 box3 = gtk_vbox_new (FALSE, 5);
1688 gtk_container_set_border_width (GTK_CONTAINER (box3), 5);
1689 gtk_container_add (GTK_CONTAINER (frame), box3);
1691 button = gtk_button_new_with_label ("switch");
1692 gtk_signal_connect (GTK_OBJECT (button), "clicked",
1693 GTK_SIGNAL_FUNC(reparent_label),
1695 gtk_object_set_user_data (GTK_OBJECT (button), label);
1696 gtk_box_pack_start (GTK_BOX (box3), button, FALSE, TRUE, 0);
1698 gtk_box_pack_start (GTK_BOX (box3), label, FALSE, TRUE, 0);
1699 gtk_signal_connect (GTK_OBJECT (label),
1701 GTK_SIGNAL_FUNC (set_parent_signal),
1702 GINT_TO_POINTER (42));
1704 frame = gtk_frame_new ("Frame 2");
1705 gtk_box_pack_start (GTK_BOX (box2), frame, TRUE, TRUE, 0);
1707 box3 = gtk_vbox_new (FALSE, 5);
1708 gtk_container_set_border_width (GTK_CONTAINER (box3), 5);
1709 gtk_container_add (GTK_CONTAINER (frame), box3);
1711 button = gtk_button_new_with_label ("switch");
1712 gtk_signal_connect (GTK_OBJECT (button), "clicked",
1713 GTK_SIGNAL_FUNC(reparent_label),
1715 gtk_object_set_user_data (GTK_OBJECT (button), label);
1716 gtk_box_pack_start (GTK_BOX (box3), button, FALSE, TRUE, 0);
1718 separator = gtk_hseparator_new ();
1719 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
1721 box2 = gtk_vbox_new (FALSE, 10);
1722 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
1723 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
1725 button = gtk_button_new_with_label ("close");
1726 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
1727 GTK_SIGNAL_FUNC(gtk_widget_destroy),
1728 GTK_OBJECT (window));
1729 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
1730 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
1731 gtk_widget_grab_default (button);
1734 if (!GTK_WIDGET_VISIBLE (window))
1735 gtk_widget_show_all (window);
1737 gtk_widget_destroy (window);
1743 gint upositionx = 0;
1744 gint upositiony = 0;
1747 uposition_configure (GtkWidget *window)
1753 lx = gtk_object_get_data (GTK_OBJECT (window), "x");
1754 ly = gtk_object_get_data (GTK_OBJECT (window), "y");
1756 gdk_window_get_root_origin (window->window, &upositionx, &upositiony);
1757 sprintf (buffer, "%d", upositionx);
1758 gtk_label_set (lx, buffer);
1759 sprintf (buffer, "%d", upositiony);
1760 gtk_label_set (ly, buffer);
1766 create_saved_position (void)
1768 static GtkWidget *window = NULL;
1773 GtkWidget *main_vbox;
1781 window = gtk_widget_new (GTK_TYPE_WINDOW,
1782 "type", GTK_WINDOW_TOPLEVEL,
1783 "signal::configure_event", uposition_configure, NULL,
1786 "title", "Saved Position",
1789 gtk_signal_connect (GTK_OBJECT (window), "destroy",
1790 GTK_SIGNAL_FUNC (gtk_widget_destroyed),
1793 main_vbox = gtk_vbox_new (FALSE, 5);
1794 gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 0);
1795 gtk_container_add (GTK_CONTAINER (window), main_vbox);
1798 gtk_widget_new (gtk_vbox_get_type (),
1799 "GtkBox::homogeneous", FALSE,
1800 "GtkBox::spacing", 5,
1801 "GtkContainer::border_width", 10,
1802 "GtkWidget::parent", main_vbox,
1803 "GtkWidget::visible", TRUE,
1806 hbox = gtk_hbox_new (FALSE, 0);
1807 gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
1808 gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0);
1810 label = gtk_label_new ("X Origin : ");
1811 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
1812 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
1814 x_label = gtk_label_new ("");
1815 gtk_box_pack_start (GTK_BOX (hbox), x_label, TRUE, TRUE, 0);
1816 gtk_object_set_data (GTK_OBJECT (window), "x", x_label);
1818 hbox = gtk_hbox_new (FALSE, 0);
1819 gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
1820 gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0);
1822 label = gtk_label_new ("Y Origin : ");
1823 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
1824 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
1826 y_label = gtk_label_new ("");
1827 gtk_box_pack_start (GTK_BOX (hbox), y_label, TRUE, TRUE, 0);
1828 gtk_object_set_data (GTK_OBJECT (window), "y", y_label);
1831 gtk_widget_new (gtk_hseparator_get_type (),
1832 "GtkWidget::visible", TRUE,
1834 gtk_box_pack_start (GTK_BOX (main_vbox), any, FALSE, TRUE, 0);
1836 hbox = gtk_hbox_new (FALSE, 0);
1837 gtk_container_set_border_width (GTK_CONTAINER (hbox), 10);
1838 gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, TRUE, 0);
1840 button = gtk_button_new_with_label ("Close");
1841 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
1842 GTK_SIGNAL_FUNC (gtk_widget_destroy),
1843 GTK_OBJECT (window));
1844 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
1845 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
1846 gtk_widget_grab_default (button);
1848 gtk_widget_show_all (window);
1851 gtk_widget_destroy (window);
1859 create_pixmap (void)
1861 static GtkWidget *window = NULL;
1867 GtkWidget *separator;
1868 GtkWidget *pixmapwid;
1874 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
1876 gtk_signal_connect (GTK_OBJECT (window), "destroy",
1877 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
1880 gtk_window_set_title (GTK_WINDOW (window), "GtkPixmap");
1881 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
1882 gtk_widget_realize(window);
1884 box1 = gtk_vbox_new (FALSE, 0);
1885 gtk_container_add (GTK_CONTAINER (window), box1);
1887 box2 = gtk_vbox_new (FALSE, 10);
1888 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
1889 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
1891 button = gtk_button_new ();
1892 gtk_box_pack_start (GTK_BOX (box2), button, FALSE, FALSE, 0);
1894 pixmap = gdk_pixmap_create_from_xpm (window->window, &mask, NULL,
1896 pixmapwid = gtk_pixmap_new (pixmap, mask);
1897 gdk_pixmap_unref (pixmap);
1898 gdk_pixmap_unref (mask);
1900 label = gtk_label_new ("Pixmap\ntest");
1901 box3 = gtk_hbox_new (FALSE, 0);
1902 gtk_container_set_border_width (GTK_CONTAINER (box3), 2);
1903 gtk_container_add (GTK_CONTAINER (box3), pixmapwid);
1904 gtk_container_add (GTK_CONTAINER (box3), label);
1905 gtk_container_add (GTK_CONTAINER (button), box3);
1907 separator = gtk_hseparator_new ();
1908 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
1910 box2 = gtk_vbox_new (FALSE, 10);
1911 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
1912 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
1914 button = gtk_button_new_with_label ("close");
1915 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
1916 GTK_SIGNAL_FUNC(gtk_widget_destroy),
1917 GTK_OBJECT (window));
1918 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
1919 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
1920 gtk_widget_grab_default (button);
1923 if (!GTK_WIDGET_VISIBLE (window))
1924 gtk_widget_show_all (window);
1926 gtk_widget_destroy (window);
1930 tips_query_widget_entered (GtkTipsQuery *tips_query,
1932 const gchar *tip_text,
1933 const gchar *tip_private,
1936 if (GTK_TOGGLE_BUTTON (toggle)->active)
1938 gtk_label_set (GTK_LABEL (tips_query), tip_text ? "There is a Tip!" : "There is no Tip!");
1939 /* don't let GtkTipsQuery reset it's label */
1940 gtk_signal_emit_stop_by_name (GTK_OBJECT (tips_query), "widget_entered");
1945 tips_query_widget_selected (GtkWidget *tips_query,
1947 const gchar *tip_text,
1948 const gchar *tip_private,
1949 GdkEventButton *event,
1953 g_print ("Help \"%s\" requested for <%s>\n",
1954 tip_private ? tip_private : "None",
1955 gtk_type_name (GTK_OBJECT_TYPE (widget)));
1960 create_tooltips (void)
1962 static GtkWidget *window = NULL;
1969 GtkWidget *tips_query;
1970 GtkWidget *separator;
1971 GtkTooltips *tooltips;
1976 gtk_widget_new (gtk_window_get_type (),
1977 "GtkWindow::type", GTK_WINDOW_TOPLEVEL,
1978 "GtkContainer::border_width", 0,
1979 "GtkWindow::title", "Tooltips",
1980 "GtkWindow::allow_shrink", TRUE,
1981 "GtkWindow::allow_grow", FALSE,
1982 "GtkWindow::auto_shrink", TRUE,
1983 "GtkWidget::width", 200,
1986 gtk_signal_connect (GTK_OBJECT (window), "destroy",
1987 GTK_SIGNAL_FUNC (destroy_tooltips),
1990 tooltips=gtk_tooltips_new();
1991 gtk_object_set_data (GTK_OBJECT (window), "tooltips", tooltips);
1993 box1 = gtk_vbox_new (FALSE, 0);
1994 gtk_container_add (GTK_CONTAINER (window), box1);
1996 box2 = gtk_vbox_new (FALSE, 10);
1997 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
1998 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
2000 button = gtk_toggle_button_new_with_label ("button1");
2001 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
2003 gtk_tooltips_set_tip (tooltips,button,"This is button 1", "ContextHelp/buttons/1");
2005 button = gtk_toggle_button_new_with_label ("button2");
2006 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
2008 gtk_tooltips_set_tip (tooltips,
2010 "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.",
2011 "ContextHelp/buttons/2_long");
2013 toggle = gtk_toggle_button_new_with_label ("Override TipsQuery Label");
2014 gtk_box_pack_start (GTK_BOX (box2), toggle, TRUE, TRUE, 0);
2016 gtk_tooltips_set_tip (tooltips, toggle, "Toggle TipsQuery view.", "Hi msw! ;)");
2019 gtk_widget_new (gtk_vbox_get_type (),
2020 "GtkBox::homogeneous", FALSE,
2021 "GtkBox::spacing", 5,
2022 "GtkContainer::border_width", 5,
2023 "GtkWidget::visible", TRUE,
2026 tips_query = gtk_tips_query_new ();
2029 gtk_widget_new (gtk_button_get_type (),
2030 "GtkButton::label", "[?]",
2031 "GtkWidget::visible", TRUE,
2032 "GtkWidget::parent", box3,
2033 "GtkObject::object_signal::clicked", gtk_tips_query_start_query, tips_query,
2035 gtk_box_set_child_packing (GTK_BOX (box3), button, FALSE, FALSE, 0, GTK_PACK_START);
2036 gtk_tooltips_set_tip (tooltips,
2038 "Start the Tooltips Inspector",
2039 "ContextHelp/buttons/?");
2042 gtk_widget_set (tips_query,
2043 "GtkWidget::visible", TRUE,
2044 "GtkWidget::parent", box3,
2045 "GtkTipsQuery::caller", button,
2046 "GtkObject::signal::widget_entered", tips_query_widget_entered, toggle,
2047 "GtkObject::signal::widget_selected", tips_query_widget_selected, NULL,
2051 gtk_widget_new (gtk_frame_get_type (),
2052 "GtkFrame::label", "ToolTips Inspector",
2053 "GtkFrame::label_xalign", (double) 0.5,
2054 "GtkContainer::border_width", 0,
2055 "GtkWidget::visible", TRUE,
2056 "GtkWidget::parent", box2,
2057 "GtkContainer::child", box3,
2059 gtk_box_set_child_packing (GTK_BOX (box2), frame, TRUE, TRUE, 10, GTK_PACK_START);
2061 separator = gtk_hseparator_new ();
2062 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
2064 box2 = gtk_vbox_new (FALSE, 10);
2065 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
2066 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
2068 button = gtk_button_new_with_label ("close");
2069 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
2070 GTK_SIGNAL_FUNC(gtk_widget_destroy),
2071 GTK_OBJECT (window));
2072 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
2073 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
2074 gtk_widget_grab_default (button);
2076 gtk_tooltips_set_tip (tooltips, button, "Push this button to close window", "ContextHelp/buttons/Close");
2079 if (!GTK_WIDGET_VISIBLE (window))
2080 gtk_widget_show_all (window);
2082 gtk_widget_destroy (window);
2090 create_menu (gint depth, gboolean tearoff)
2093 GtkWidget *menuitem;
2101 menu = gtk_menu_new ();
2106 menuitem = gtk_tearoff_menu_item_new ();
2107 gtk_menu_append (GTK_MENU (menu), menuitem);
2108 gtk_widget_show (menuitem);
2111 for (i = 0, j = 1; i < 5; i++, j++)
2113 sprintf (buf, "item %2d - %d", depth, j);
2114 menuitem = gtk_radio_menu_item_new_with_label (group, buf);
2115 group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menuitem));
2117 gtk_check_menu_item_set_show_toggle (GTK_CHECK_MENU_ITEM (menuitem), TRUE);
2118 gtk_menu_append (GTK_MENU (menu), menuitem);
2119 gtk_widget_show (menuitem);
2121 gtk_widget_set_sensitive (menuitem, FALSE);
2123 gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), create_menu (depth - 1, TRUE));
2132 static GtkWidget *window = NULL;
2136 GtkWidget *optionmenu;
2137 GtkWidget *separator;
2143 GtkWidget *menuitem;
2144 GtkAccelGroup *accel_group;
2146 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
2148 gtk_signal_connect (GTK_OBJECT (window), "destroy",
2149 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
2151 gtk_signal_connect (GTK_OBJECT (window), "delete-event",
2152 GTK_SIGNAL_FUNC (gtk_true),
2155 accel_group = gtk_accel_group_new ();
2156 gtk_accel_group_attach (accel_group, GTK_OBJECT (window));
2158 gtk_window_set_title (GTK_WINDOW (window), "menus");
2159 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
2162 box1 = gtk_vbox_new (FALSE, 0);
2163 gtk_container_add (GTK_CONTAINER (window), box1);
2164 gtk_widget_show (box1);
2166 menubar = gtk_menu_bar_new ();
2167 gtk_box_pack_start (GTK_BOX (box1), menubar, FALSE, TRUE, 0);
2168 gtk_widget_show (menubar);
2170 menu = create_menu (2, TRUE);
2172 menuitem = gtk_menu_item_new_with_label ("test\nline2");
2173 gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), menu);
2174 gtk_menu_bar_append (GTK_MENU_BAR (menubar), menuitem);
2175 gtk_widget_show (menuitem);
2177 menuitem = gtk_menu_item_new_with_label ("foo");
2178 gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), create_menu (3, TRUE));
2179 gtk_menu_bar_append (GTK_MENU_BAR (menubar), menuitem);
2180 gtk_widget_show (menuitem);
2182 menuitem = gtk_menu_item_new_with_label ("bar");
2183 gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), create_menu (4, TRUE));
2184 gtk_menu_item_right_justify (GTK_MENU_ITEM (menuitem));
2185 gtk_menu_bar_append (GTK_MENU_BAR (menubar), menuitem);
2186 gtk_widget_show (menuitem);
2188 box2 = gtk_vbox_new (FALSE, 10);
2189 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
2190 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
2191 gtk_widget_show (box2);
2193 menu = create_menu (1, FALSE);
2194 gtk_menu_set_accel_group (GTK_MENU (menu), accel_group);
2196 menuitem = gtk_check_menu_item_new_with_label ("Accelerate Me");
2197 gtk_menu_append (GTK_MENU (menu), menuitem);
2198 gtk_widget_show (menuitem);
2199 gtk_widget_add_accelerator (menuitem,
2204 GTK_ACCEL_VISIBLE | GTK_ACCEL_SIGNAL_VISIBLE);
2205 menuitem = gtk_check_menu_item_new_with_label ("Accelerator Locked");
2206 gtk_menu_append (GTK_MENU (menu), menuitem);
2207 gtk_widget_show (menuitem);
2208 gtk_widget_add_accelerator (menuitem,
2213 GTK_ACCEL_VISIBLE | GTK_ACCEL_LOCKED);
2214 menuitem = gtk_check_menu_item_new_with_label ("Accelerators Frozen");
2215 gtk_menu_append (GTK_MENU (menu), menuitem);
2216 gtk_widget_show (menuitem);
2217 gtk_widget_add_accelerator (menuitem,
2223 gtk_widget_add_accelerator (menuitem,
2229 gtk_widget_lock_accelerators (menuitem);
2231 optionmenu = gtk_option_menu_new ();
2232 gtk_option_menu_set_menu (GTK_OPTION_MENU (optionmenu), menu);
2233 gtk_option_menu_set_history (GTK_OPTION_MENU (optionmenu), 3);
2234 gtk_box_pack_start (GTK_BOX (box2), optionmenu, TRUE, TRUE, 0);
2235 gtk_widget_show (optionmenu);
2237 separator = gtk_hseparator_new ();
2238 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
2239 gtk_widget_show (separator);
2241 box2 = gtk_vbox_new (FALSE, 10);
2242 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
2243 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
2244 gtk_widget_show (box2);
2246 button = gtk_button_new_with_label ("close");
2247 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
2248 GTK_SIGNAL_FUNC(gtk_widget_destroy),
2249 GTK_OBJECT (window));
2250 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
2251 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
2252 gtk_widget_grab_default (button);
2253 gtk_widget_show (button);
2256 if (!GTK_WIDGET_VISIBLE (window))
2257 gtk_widget_show (window);
2259 gtk_widget_destroy (window);
2263 gtk_ifactory_cb (gpointer callback_data,
2264 guint callback_action,
2267 g_message ("ItemFactory: activated \"%s\"", gtk_item_factory_path_from_widget (widget));
2270 static GtkItemFactoryEntry menu_items[] =
2272 { "/_File", NULL, 0, 0, "<Branch>" },
2273 { "/File/tearoff1", NULL, gtk_ifactory_cb, 0, "<Tearoff>" },
2274 { "/File/_New", "<control>N", gtk_ifactory_cb, 0 },
2275 { "/File/_Open", "<control>O", gtk_ifactory_cb, 0 },
2276 { "/File/_Save", "<control>S", gtk_ifactory_cb, 0 },
2277 { "/File/Save _As...", NULL, gtk_ifactory_cb, 0 },
2278 { "/File/sep1", NULL, gtk_ifactory_cb, 0, "<Separator>" },
2279 { "/File/_Quit", "<control>Q", gtk_ifactory_cb, 0 },
2281 { "/_Preferences", NULL, 0, 0, "<Branch>" },
2282 { "/_Preferences/_Color", NULL, 0, 0, "<Branch>" },
2283 { "/_Preferences/Color/_Red", NULL, gtk_ifactory_cb, 0, "<RadioItem>" },
2284 { "/_Preferences/Color/_Green", NULL, gtk_ifactory_cb, 0, "<RadioItem>" },
2285 { "/_Preferences/Color/_Blue", NULL, gtk_ifactory_cb, 0, "<RadioItem>" },
2286 { "/_Preferences/_Shape", NULL, 0, 0, "<Branch>" },
2287 { "/_Preferences/Shape/_Square", NULL, gtk_ifactory_cb, 0, "<RadioItem>" },
2288 { "/_Preferences/Shape/_Rectangle", NULL, gtk_ifactory_cb, 0, "<RadioItem>" },
2289 { "/_Preferences/Shape/_Oval", NULL, gtk_ifactory_cb, 0, "<RadioItem>" },
2291 { "/_Help", NULL, 0, 0, "<LastBranch>" },
2292 { "/Help/_About", NULL, gtk_ifactory_cb, 0 },
2295 static int nmenu_items = sizeof (menu_items) / sizeof (menu_items[0]);
2298 create_item_factory (void)
2300 static GtkWidget *window = NULL;
2306 GtkWidget *separator;
2309 GtkAccelGroup *accel_group;
2310 GtkItemFactory *item_factory;
2312 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
2314 gtk_signal_connect (GTK_OBJECT (window), "destroy",
2315 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
2317 gtk_signal_connect (GTK_OBJECT (window), "delete-event",
2318 GTK_SIGNAL_FUNC (gtk_true),
2321 accel_group = gtk_accel_group_new ();
2322 item_factory = gtk_item_factory_new (GTK_TYPE_MENU_BAR, "<main>", accel_group);
2323 gtk_item_factory_create_items (item_factory, nmenu_items, menu_items, NULL);
2324 gtk_accel_group_attach (accel_group, GTK_OBJECT (window));
2325 gtk_window_set_title (GTK_WINDOW (window), "Item Factory");
2326 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
2328 box1 = gtk_vbox_new (FALSE, 0);
2329 gtk_container_add (GTK_CONTAINER (window), box1);
2331 gtk_box_pack_start (GTK_BOX (box1),
2332 gtk_item_factory_get_widget (item_factory, "<main>"),
2335 label = gtk_label_new ("Type\n<alt>\nto start");
2336 gtk_widget_set_usize (label, 200, 200);
2337 gtk_misc_set_alignment (GTK_MISC (label), 0.5, 0.5);
2338 gtk_box_pack_start (GTK_BOX (box1), label, TRUE, TRUE, 0);
2341 separator = gtk_hseparator_new ();
2342 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
2345 box2 = gtk_vbox_new (FALSE, 10);
2346 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
2347 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
2349 button = gtk_button_new_with_label ("close");
2350 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
2351 GTK_SIGNAL_FUNC(gtk_widget_destroy),
2352 GTK_OBJECT (window));
2353 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
2354 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
2355 gtk_widget_grab_default (button);
2357 gtk_widget_show_all (window);
2360 gtk_widget_destroy (window);
2368 scrolled_windows_remove (GtkWidget *widget, GtkWidget *scrollwin)
2370 static GtkWidget *parent = NULL;
2371 static GtkWidget *float_parent;
2375 gtk_widget_reparent (scrollwin, parent);
2376 gtk_widget_destroy (float_parent);
2377 float_parent = NULL;
2382 parent = widget->parent;
2383 float_parent = gtk_window_new (GTK_WINDOW_TOPLEVEL);
2384 gtk_widget_reparent (scrollwin, float_parent);
2385 gtk_widget_show (float_parent);
2394 cmw_destroy_cb(GtkWidget *widget)
2396 /* This is needed to get out of gtk_main */
2403 cmw_color (GtkWidget *widget, GtkWidget *parent)
2407 csd=gtk_color_selection_dialog_new ("This is a modal color selection dialog");
2410 gtk_window_set_modal (GTK_WINDOW(csd),TRUE);
2412 /* And mark it as a transient dialog */
2413 gtk_window_set_transient_for (GTK_WINDOW (csd), GTK_WINDOW (parent));
2415 gtk_signal_connect (GTK_OBJECT(csd), "destroy",
2416 GTK_SIGNAL_FUNC(cmw_destroy_cb),NULL);
2418 gtk_signal_connect_object (GTK_OBJECT(GTK_COLOR_SELECTION_DIALOG(csd)->ok_button),
2419 "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy),
2421 gtk_signal_connect_object (GTK_OBJECT(GTK_COLOR_SELECTION_DIALOG(csd)->cancel_button),
2422 "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy),
2425 /* wait until destroy calls gtk_main_quit */
2426 gtk_widget_show (csd);
2431 cmw_file (GtkWidget *widget, GtkWidget *parent)
2435 fs = gtk_file_selection_new("This is a modal file selection dialog");
2438 gtk_window_set_modal (GTK_WINDOW(fs),TRUE);
2440 /* And mark it as a transient dialog */
2441 gtk_window_set_transient_for (GTK_WINDOW (fs), GTK_WINDOW (parent));
2443 gtk_signal_connect (GTK_OBJECT(fs), "destroy",
2444 GTK_SIGNAL_FUNC(cmw_destroy_cb),NULL);
2446 gtk_signal_connect_object (GTK_OBJECT(GTK_FILE_SELECTION(fs)->ok_button),
2447 "clicked",GTK_SIGNAL_FUNC(gtk_widget_destroy),
2449 gtk_signal_connect_object (GTK_OBJECT(GTK_FILE_SELECTION(fs)->cancel_button),
2450 "clicked",GTK_SIGNAL_FUNC(gtk_widget_destroy),
2453 /* wait until destroy calls gtk_main_quit */
2454 gtk_widget_show (fs);
2461 create_modal_window (void)
2463 GtkWidget *window = NULL;
2464 GtkWidget *box1,*box2;
2466 GtkWidget *btnColor,*btnFile,*btnClose;
2468 /* Create modal window (Here you can use any window descendent )*/
2469 window=gtk_window_new (GTK_WINDOW_TOPLEVEL);
2470 gtk_window_set_title (GTK_WINDOW(window),"This window is modal");
2472 /* Set window as modal */
2473 gtk_window_set_modal (GTK_WINDOW(window),TRUE);
2475 /* Create widgets */
2476 box1 = gtk_vbox_new (FALSE,5);
2477 frame1 = gtk_frame_new ("Standard dialogs in modal form");
2478 box2 = gtk_vbox_new (TRUE,5);
2479 btnColor = gtk_button_new_with_label ("Color");
2480 btnFile = gtk_button_new_with_label ("File Selection");
2481 btnClose = gtk_button_new_with_label ("Close");
2484 gtk_container_set_border_width (GTK_CONTAINER(box1),3);
2485 gtk_container_set_border_width (GTK_CONTAINER(box2),3);
2488 gtk_container_add (GTK_CONTAINER (window), box1);
2489 gtk_box_pack_start (GTK_BOX (box1), frame1, TRUE, TRUE, 4);
2490 gtk_container_add (GTK_CONTAINER (frame1), box2);
2491 gtk_box_pack_start (GTK_BOX (box2), btnColor, FALSE, FALSE, 4);
2492 gtk_box_pack_start (GTK_BOX (box2), btnFile, FALSE, FALSE, 4);
2493 gtk_box_pack_start (GTK_BOX (box1), gtk_hseparator_new (), FALSE, FALSE, 4);
2494 gtk_box_pack_start (GTK_BOX (box1), btnClose, FALSE, FALSE, 4);
2496 /* connect signals */
2497 gtk_signal_connect_object (GTK_OBJECT (btnClose), "clicked",
2498 GTK_SIGNAL_FUNC (gtk_widget_destroy),
2499 GTK_OBJECT (window));
2501 gtk_signal_connect (GTK_OBJECT (window), "destroy",
2502 GTK_SIGNAL_FUNC (cmw_destroy_cb),NULL);
2504 gtk_signal_connect (GTK_OBJECT (btnColor), "clicked",
2505 GTK_SIGNAL_FUNC (cmw_color),window);
2506 gtk_signal_connect (GTK_OBJECT (btnFile), "clicked",
2507 GTK_SIGNAL_FUNC (cmw_file),window);
2510 gtk_widget_show_all (window);
2512 /* wait until dialog get destroyed */
2521 create_scrolled_windows (void)
2523 static GtkWidget *window;
2524 GtkWidget *scrolled_window;
2532 window = gtk_dialog_new ();
2534 gtk_signal_connect (GTK_OBJECT (window), "destroy",
2535 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
2538 gtk_window_set_title (GTK_WINDOW (window), "dialog");
2539 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
2542 scrolled_window = gtk_scrolled_window_new (NULL, NULL);
2543 gtk_container_set_border_width (GTK_CONTAINER (scrolled_window), 10);
2544 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
2545 GTK_POLICY_AUTOMATIC,
2546 GTK_POLICY_AUTOMATIC);
2547 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox),
2548 scrolled_window, TRUE, TRUE, 0);
2549 gtk_widget_show (scrolled_window);
2551 table = gtk_table_new (20, 20, FALSE);
2552 gtk_table_set_row_spacings (GTK_TABLE (table), 10);
2553 gtk_table_set_col_spacings (GTK_TABLE (table), 10);
2554 gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (scrolled_window), table);
2555 gtk_container_set_focus_hadjustment (GTK_CONTAINER (table),
2556 gtk_scrolled_window_get_hadjustment (GTK_SCROLLED_WINDOW (scrolled_window)));
2557 gtk_container_set_focus_vadjustment (GTK_CONTAINER (table),
2558 gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (scrolled_window)));
2559 gtk_widget_show (table);
2561 for (i = 0; i < 20; i++)
2562 for (j = 0; j < 20; j++)
2564 sprintf (buffer, "button (%d,%d)\n", i, j);
2565 button = gtk_toggle_button_new_with_label (buffer);
2566 gtk_table_attach_defaults (GTK_TABLE (table), button,
2568 gtk_widget_show (button);
2572 button = gtk_button_new_with_label ("close");
2573 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
2574 GTK_SIGNAL_FUNC(gtk_widget_destroy),
2575 GTK_OBJECT (window));
2576 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
2577 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
2578 button, TRUE, TRUE, 0);
2579 gtk_widget_grab_default (button);
2580 gtk_widget_show (button);
2582 button = gtk_button_new_with_label ("remove");
2583 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
2584 GTK_SIGNAL_FUNC(scrolled_windows_remove),
2585 GTK_OBJECT (scrolled_window));
2586 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
2587 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
2588 button, TRUE, TRUE, 0);
2589 gtk_widget_grab_default (button);
2590 gtk_widget_show (button);
2592 gtk_window_set_default_size (GTK_WINDOW (window), 300, 300);
2595 if (!GTK_WIDGET_VISIBLE (window))
2596 gtk_widget_show (window);
2598 gtk_widget_destroy (window);
2606 entry_toggle_editable (GtkWidget *checkbutton,
2609 gtk_entry_set_editable(GTK_ENTRY(entry),
2610 GTK_TOGGLE_BUTTON(checkbutton)->active);
2614 entry_toggle_sensitive (GtkWidget *checkbutton,
2617 gtk_widget_set_sensitive (entry, GTK_TOGGLE_BUTTON(checkbutton)->active);
2621 entry_toggle_visibility (GtkWidget *checkbutton,
2624 gtk_entry_set_visibility(GTK_ENTRY(entry),
2625 GTK_TOGGLE_BUTTON(checkbutton)->active);
2631 static GtkWidget *window = NULL;
2634 GtkWidget *editable_check;
2635 GtkWidget *sensitive_check;
2636 GtkWidget *entry, *cb;
2638 GtkWidget *separator;
2639 GList *cbitems = NULL;
2643 cbitems = g_list_append(cbitems, "item0");
2644 cbitems = g_list_append(cbitems, "item1 item1");
2645 cbitems = g_list_append(cbitems, "item2 item2 item2");
2646 cbitems = g_list_append(cbitems, "item3 item3 item3 item3");
2647 cbitems = g_list_append(cbitems, "item4 item4 item4 item4 item4");
2648 cbitems = g_list_append(cbitems, "item5 item5 item5 item5 item5 item5");
2649 cbitems = g_list_append(cbitems, "item6 item6 item6 item6 item6");
2650 cbitems = g_list_append(cbitems, "item7 item7 item7 item7");
2651 cbitems = g_list_append(cbitems, "item8 item8 item8");
2652 cbitems = g_list_append(cbitems, "item9 item9");
2654 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
2656 gtk_signal_connect (GTK_OBJECT (window), "destroy",
2657 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
2660 gtk_window_set_title (GTK_WINDOW (window), "entry");
2661 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
2664 box1 = gtk_vbox_new (FALSE, 0);
2665 gtk_container_add (GTK_CONTAINER (window), box1);
2666 gtk_widget_show (box1);
2669 box2 = gtk_vbox_new (FALSE, 10);
2670 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
2671 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
2672 gtk_widget_show (box2);
2674 entry = gtk_entry_new ();
2675 gtk_entry_set_text (GTK_ENTRY (entry), "hello world");
2676 gtk_editable_select_region (GTK_EDITABLE (entry), 0, 5);
2677 gtk_box_pack_start (GTK_BOX (box2), entry, TRUE, TRUE, 0);
2678 gtk_widget_show (entry);
2680 cb = gtk_combo_new ();
2681 gtk_combo_set_popdown_strings (GTK_COMBO (cb), cbitems);
2682 gtk_entry_set_text (GTK_ENTRY (GTK_COMBO(cb)->entry), "hello world");
2683 gtk_editable_select_region (GTK_EDITABLE (GTK_COMBO(cb)->entry),
2685 gtk_box_pack_start (GTK_BOX (box2), cb, TRUE, TRUE, 0);
2686 gtk_widget_show (cb);
2688 editable_check = gtk_check_button_new_with_label("Editable");
2689 gtk_box_pack_start (GTK_BOX (box2), editable_check, FALSE, TRUE, 0);
2690 gtk_signal_connect (GTK_OBJECT(editable_check), "toggled",
2691 GTK_SIGNAL_FUNC(entry_toggle_editable), entry);
2692 gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(editable_check), TRUE);
2693 gtk_widget_show (editable_check);
2695 editable_check = gtk_check_button_new_with_label("Visible");
2696 gtk_box_pack_start (GTK_BOX (box2), editable_check, FALSE, TRUE, 0);
2697 gtk_signal_connect (GTK_OBJECT(editable_check), "toggled",
2698 GTK_SIGNAL_FUNC(entry_toggle_visibility), entry);
2699 gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(editable_check), TRUE);
2700 gtk_widget_show (editable_check);
2702 sensitive_check = gtk_check_button_new_with_label("Sensitive");
2703 gtk_box_pack_start (GTK_BOX (box2), sensitive_check, FALSE, TRUE, 0);
2704 gtk_signal_connect (GTK_OBJECT(sensitive_check), "toggled",
2705 GTK_SIGNAL_FUNC(entry_toggle_sensitive), entry);
2706 gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(sensitive_check), TRUE);
2707 gtk_widget_show (sensitive_check);
2709 separator = gtk_hseparator_new ();
2710 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
2711 gtk_widget_show (separator);
2714 box2 = gtk_vbox_new (FALSE, 10);
2715 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
2716 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
2717 gtk_widget_show (box2);
2720 button = gtk_button_new_with_label ("close");
2721 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
2722 GTK_SIGNAL_FUNC(gtk_widget_destroy),
2723 GTK_OBJECT (window));
2724 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
2725 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
2726 gtk_widget_grab_default (button);
2727 gtk_widget_show (button);
2730 if (!GTK_WIDGET_VISIBLE (window))
2731 gtk_widget_show (window);
2733 gtk_widget_destroy (window);
2740 static GtkWidget *spinner1;
2743 toggle_snap (GtkWidget *widget, GtkSpinButton *spin)
2745 gtk_spin_button_set_snap_to_ticks (spin, GTK_TOGGLE_BUTTON (widget)->active);
2749 toggle_numeric (GtkWidget *widget, GtkSpinButton *spin)
2751 gtk_spin_button_set_numeric (spin, GTK_TOGGLE_BUTTON (widget)->active);
2755 change_digits (GtkWidget *widget, GtkSpinButton *spin)
2757 gtk_spin_button_set_digits (GTK_SPIN_BUTTON (spinner1),
2758 gtk_spin_button_get_value_as_int (spin));
2762 get_value (GtkWidget *widget, gpointer data)
2766 GtkSpinButton *spin;
2768 spin = GTK_SPIN_BUTTON (spinner1);
2769 label = GTK_LABEL (gtk_object_get_user_data (GTK_OBJECT (widget)));
2770 if (GPOINTER_TO_INT (data) == 1)
2771 sprintf (buf, "%d", gtk_spin_button_get_value_as_int (spin));
2773 sprintf (buf, "%0.*f", spin->digits,
2774 gtk_spin_button_get_value_as_float (spin));
2775 gtk_label_set (label, buf);
2781 static GtkWidget *window = NULL;
2784 GtkWidget *main_vbox;
2787 GtkWidget *spinner2;
2791 GtkWidget *val_label;
2796 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
2798 gtk_signal_connect (GTK_OBJECT (window), "destroy",
2799 GTK_SIGNAL_FUNC (gtk_widget_destroyed),
2802 gtk_window_set_title (GTK_WINDOW (window), "GtkSpinButton");
2804 main_vbox = gtk_vbox_new (FALSE, 5);
2805 gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 10);
2806 gtk_container_add (GTK_CONTAINER (window), main_vbox);
2808 frame = gtk_frame_new ("Not accelerated");
2809 gtk_box_pack_start (GTK_BOX (main_vbox), frame, TRUE, TRUE, 0);
2811 vbox = gtk_vbox_new (FALSE, 0);
2812 gtk_container_set_border_width (GTK_CONTAINER (vbox), 5);
2813 gtk_container_add (GTK_CONTAINER (frame), vbox);
2815 /* Day, month, year spinners */
2817 hbox = gtk_hbox_new (FALSE, 0);
2818 gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 5);
2820 vbox2 = gtk_vbox_new (FALSE, 0);
2821 gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 5);
2823 label = gtk_label_new ("Day :");
2824 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
2825 gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, TRUE, 0);
2827 adj = (GtkAdjustment *) gtk_adjustment_new (1.0, 1.0, 31.0, 1.0,
2829 spinner = gtk_spin_button_new (adj, 0, 0);
2830 gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spinner), TRUE);
2831 gtk_spin_button_set_shadow_type (GTK_SPIN_BUTTON (spinner),
2833 gtk_box_pack_start (GTK_BOX (vbox2), spinner, FALSE, TRUE, 0);
2835 vbox2 = gtk_vbox_new (FALSE, 0);
2836 gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 5);
2838 label = gtk_label_new ("Month :");
2839 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
2840 gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, TRUE, 0);
2842 adj = (GtkAdjustment *) gtk_adjustment_new (1.0, 1.0, 12.0, 1.0,
2844 spinner = gtk_spin_button_new (adj, 0, 0);
2845 gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spinner), TRUE);
2846 gtk_spin_button_set_shadow_type (GTK_SPIN_BUTTON (spinner),
2847 GTK_SHADOW_ETCHED_IN);
2848 gtk_box_pack_start (GTK_BOX (vbox2), spinner, FALSE, TRUE, 0);
2850 vbox2 = gtk_vbox_new (FALSE, 0);
2851 gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 5);
2853 label = gtk_label_new ("Year :");
2854 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
2855 gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, TRUE, 0);
2857 adj = (GtkAdjustment *) gtk_adjustment_new (1998.0, 0.0, 2100.0,
2859 spinner = gtk_spin_button_new (adj, 0, 0);
2860 gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spinner), TRUE);
2861 gtk_spin_button_set_shadow_type (GTK_SPIN_BUTTON (spinner),
2863 gtk_widget_set_usize (spinner, 55, 0);
2864 gtk_box_pack_start (GTK_BOX (vbox2), spinner, FALSE, TRUE, 0);
2866 frame = gtk_frame_new ("Accelerated");
2867 gtk_box_pack_start (GTK_BOX (main_vbox), frame, TRUE, TRUE, 0);
2869 vbox = gtk_vbox_new (FALSE, 0);
2870 gtk_container_set_border_width (GTK_CONTAINER (vbox), 5);
2871 gtk_container_add (GTK_CONTAINER (frame), vbox);
2873 hbox = gtk_hbox_new (FALSE, 0);
2874 gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 5);
2876 vbox2 = gtk_vbox_new (FALSE, 0);
2877 gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 5);
2879 label = gtk_label_new ("Value :");
2880 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
2881 gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, TRUE, 0);
2883 adj = (GtkAdjustment *) gtk_adjustment_new (0.0, -10000.0, 10000.0,
2885 spinner1 = gtk_spin_button_new (adj, 1.0, 2);
2886 gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spinner1), TRUE);
2887 gtk_widget_set_usize (spinner1, 100, 0);
2888 gtk_box_pack_start (GTK_BOX (vbox2), spinner1, FALSE, TRUE, 0);
2890 vbox2 = gtk_vbox_new (FALSE, 0);
2891 gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 5);
2893 label = gtk_label_new ("Digits :");
2894 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
2895 gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, TRUE, 0);
2897 adj = (GtkAdjustment *) gtk_adjustment_new (2, 1, 5, 1, 1, 0);
2898 spinner2 = gtk_spin_button_new (adj, 0.0, 0);
2899 gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spinner2), TRUE);
2900 gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
2901 GTK_SIGNAL_FUNC (change_digits),
2902 (gpointer) spinner2);
2903 gtk_box_pack_start (GTK_BOX (vbox2), spinner2, FALSE, TRUE, 0);
2905 hbox = gtk_hbox_new (FALSE, 0);
2906 gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 5);
2908 button = gtk_check_button_new_with_label ("Snap to 0.5-ticks");
2909 gtk_signal_connect (GTK_OBJECT (button), "clicked",
2910 GTK_SIGNAL_FUNC (toggle_snap),
2912 gtk_box_pack_start (GTK_BOX (vbox), button, TRUE, TRUE, 0);
2913 gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON (button), TRUE);
2915 button = gtk_check_button_new_with_label ("Numeric only input mode");
2916 gtk_signal_connect (GTK_OBJECT (button), "clicked",
2917 GTK_SIGNAL_FUNC (toggle_numeric),
2919 gtk_box_pack_start (GTK_BOX (vbox), button, TRUE, TRUE, 0);
2920 gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON (button), TRUE);
2922 val_label = gtk_label_new ("");
2924 hbox = gtk_hbox_new (FALSE, 0);
2925 gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 5);
2927 button = gtk_button_new_with_label ("Value as Int");
2928 gtk_object_set_user_data (GTK_OBJECT (button), val_label);
2929 gtk_signal_connect (GTK_OBJECT (button), "clicked",
2930 GTK_SIGNAL_FUNC (get_value),
2931 GINT_TO_POINTER (1));
2932 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
2934 button = gtk_button_new_with_label ("Value as Float");
2935 gtk_object_set_user_data (GTK_OBJECT (button), val_label);
2936 gtk_signal_connect (GTK_OBJECT (button), "clicked",
2937 GTK_SIGNAL_FUNC (get_value),
2938 GINT_TO_POINTER (2));
2939 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
2941 gtk_box_pack_start (GTK_BOX (vbox), val_label, TRUE, TRUE, 0);
2942 gtk_label_set (GTK_LABEL (val_label), "0");
2944 hbox = gtk_hbox_new (FALSE, 0);
2945 gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, TRUE, 0);
2947 button = gtk_button_new_with_label ("Close");
2948 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
2949 GTK_SIGNAL_FUNC (gtk_widget_destroy),
2950 GTK_OBJECT (window));
2951 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
2954 if (!GTK_WIDGET_VISIBLE (window))
2955 gtk_widget_show_all (window);
2957 gtk_widget_destroy (window);
2965 cursor_expose_event (GtkWidget *widget,
2969 GtkDrawingArea *darea;
2970 GdkDrawable *drawable;
2977 g_return_val_if_fail (widget != NULL, TRUE);
2978 g_return_val_if_fail (GTK_IS_DRAWING_AREA (widget), TRUE);
2980 darea = GTK_DRAWING_AREA (widget);
2981 drawable = widget->window;
2982 white_gc = widget->style->white_gc;
2983 gray_gc = widget->style->bg_gc[GTK_STATE_NORMAL];
2984 black_gc = widget->style->black_gc;
2985 max_width = widget->allocation.width;
2986 max_height = widget->allocation.height;
2988 gdk_draw_rectangle (drawable, white_gc,
2995 gdk_draw_rectangle (drawable, black_gc,
3002 gdk_draw_rectangle (drawable, gray_gc,
3013 set_cursor (GtkWidget *spinner,
3021 c = CLAMP (gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (spinner)), 0, 152);
3024 label = gtk_object_get_user_data (GTK_OBJECT (spinner));
3025 vals = gtk_type_enum_get_values (GTK_TYPE_GDK_CURSOR_TYPE);
3026 while (vals && vals->value != c)
3029 gtk_label_set (GTK_LABEL (label), vals->value_nick);
3031 gtk_label_set (GTK_LABEL (label), "<unknown>");
3033 cursor = gdk_cursor_new (c);
3034 gdk_window_set_cursor (widget->window, cursor);
3035 gdk_cursor_destroy (cursor);
3039 cursor_event (GtkWidget *widget,
3041 GtkSpinButton *spinner)
3043 if ((event->type == GDK_BUTTON_PRESS) &&
3044 ((event->button.button == 1) ||
3045 (event->button.button == 3)))
3047 gtk_spin_button_spin (spinner, event->button.button == 1 ?
3048 GTK_SPIN_STEP_FORWARD : GTK_SPIN_STEP_BACKWARD, 0);
3056 create_cursors (void)
3058 static GtkWidget *window = NULL;
3061 GtkWidget *main_vbox;
3072 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
3074 gtk_signal_connect (GTK_OBJECT (window), "destroy",
3075 GTK_SIGNAL_FUNC (gtk_widget_destroyed),
3078 gtk_window_set_title (GTK_WINDOW (window), "Cursors");
3080 main_vbox = gtk_vbox_new (FALSE, 5);
3081 gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 0);
3082 gtk_container_add (GTK_CONTAINER (window), main_vbox);
3085 gtk_widget_new (gtk_vbox_get_type (),
3086 "GtkBox::homogeneous", FALSE,
3087 "GtkBox::spacing", 5,
3088 "GtkContainer::border_width", 10,
3089 "GtkWidget::parent", main_vbox,
3090 "GtkWidget::visible", TRUE,
3093 hbox = gtk_hbox_new (FALSE, 0);
3094 gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
3095 gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0);
3097 label = gtk_label_new ("Cursor Value : ");
3098 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
3099 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
3101 adj = (GtkAdjustment *) gtk_adjustment_new (0,
3105 spinner = gtk_spin_button_new (adj, 0, 0);
3106 gtk_box_pack_start (GTK_BOX (hbox), spinner, TRUE, TRUE, 0);
3109 gtk_widget_new (gtk_frame_get_type (),
3110 "GtkFrame::shadow", GTK_SHADOW_ETCHED_IN,
3111 "GtkFrame::label_xalign", 0.5,
3112 "GtkFrame::label", "Cursor Area",
3113 "GtkContainer::border_width", 10,
3114 "GtkWidget::parent", vbox,
3115 "GtkWidget::visible", TRUE,
3118 darea = gtk_drawing_area_new ();
3119 gtk_widget_set_usize (darea, 80, 80);
3120 gtk_container_add (GTK_CONTAINER (frame), darea);
3121 gtk_signal_connect (GTK_OBJECT (darea),
3123 GTK_SIGNAL_FUNC (cursor_expose_event),
3125 gtk_widget_set_events (darea, GDK_EXPOSURE_MASK | GDK_BUTTON_PRESS_MASK);
3126 gtk_signal_connect (GTK_OBJECT (darea),
3127 "button_press_event",
3128 GTK_SIGNAL_FUNC (cursor_event),
3130 gtk_widget_show (darea);
3132 gtk_signal_connect (GTK_OBJECT (spinner), "changed",
3133 GTK_SIGNAL_FUNC (set_cursor),
3136 label = gtk_widget_new (GTK_TYPE_LABEL,
3141 gtk_container_child_set (GTK_CONTAINER (vbox), label,
3144 gtk_object_set_user_data (GTK_OBJECT (spinner), label);
3147 gtk_widget_new (gtk_hseparator_get_type (),
3148 "GtkWidget::visible", TRUE,
3150 gtk_box_pack_start (GTK_BOX (main_vbox), any, FALSE, TRUE, 0);
3152 hbox = gtk_hbox_new (FALSE, 0);
3153 gtk_container_set_border_width (GTK_CONTAINER (hbox), 10);
3154 gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, TRUE, 0);
3156 button = gtk_button_new_with_label ("Close");
3157 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
3158 GTK_SIGNAL_FUNC (gtk_widget_destroy),
3159 GTK_OBJECT (window));
3160 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
3162 gtk_widget_show_all (window);
3164 set_cursor (spinner, darea);
3167 gtk_widget_destroy (window);
3175 list_add (GtkWidget *widget,
3180 GtkWidget *list_item;
3181 GtkContainer *container;
3183 container = GTK_CONTAINER (list);
3185 sprintf (buffer, "added item %d", i++);
3186 list_item = gtk_list_item_new_with_label (buffer);
3187 gtk_widget_show (list_item);
3189 gtk_container_add (container, list_item);
3193 list_remove (GtkWidget *widget,
3199 tmp_list = GTK_LIST (list)->selection;
3204 clear_list = g_list_prepend (clear_list, tmp_list->data);
3205 tmp_list = tmp_list->next;
3208 clear_list = g_list_reverse (clear_list);
3210 gtk_list_remove_items (GTK_LIST (list), clear_list);
3212 g_list_free (clear_list);
3216 list_clear (GtkWidget *widget,
3219 gtk_list_clear_items (GTK_LIST (list), 0, -1);
3223 list_undo_selection (GtkWidget *widget,
3226 gtk_list_undo_selection (GTK_LIST (list));
3229 #define RADIOMENUTOGGLED(_rmi_, __i) { \
3232 __g = gtk_radio_menu_item_group(_rmi_); \
3233 while( __g && !((GtkCheckMenuItem *)(__g->data))->active) { \
3239 static GtkWidget *list_omenu;
3242 list_toggle_sel_mode (GtkWidget *widget, GtkList *list)
3246 if (!GTK_WIDGET_MAPPED (widget))
3249 RADIOMENUTOGGLED ((GtkRadioMenuItem *)
3250 (((GtkOptionMenu *)list_omenu)->menu_item), i);
3252 gtk_list_set_selection_mode (list, (GtkSelectionMode) (3-i));
3258 static GtkWidget *window = NULL;
3263 GtkWidget *scrolled_win;
3266 GtkWidget *separator;
3268 GtkWidget *menu_item;
3274 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
3276 gtk_signal_connect (GTK_OBJECT (window), "destroy",
3277 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
3280 gtk_window_set_title (GTK_WINDOW (window), "list");
3281 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
3283 box1 = gtk_vbox_new (FALSE, 0);
3284 gtk_container_add (GTK_CONTAINER (window), box1);
3286 box2 = gtk_vbox_new (FALSE, 10);
3287 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
3288 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
3290 scrolled_win = gtk_scrolled_window_new (NULL, NULL);
3291 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
3292 GTK_POLICY_AUTOMATIC,
3293 GTK_POLICY_AUTOMATIC);
3294 gtk_box_pack_start (GTK_BOX (box2), scrolled_win, TRUE, TRUE, 0);
3295 gtk_widget_set_usize (scrolled_win, -1, 300);
3297 list = gtk_list_new ();
3298 gtk_list_set_selection_mode (GTK_LIST (list), GTK_SELECTION_EXTENDED);
3299 gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (scrolled_win), list);
3300 gtk_container_set_focus_vadjustment
3301 (GTK_CONTAINER (list),
3302 gtk_scrolled_window_get_vadjustment
3303 (GTK_SCROLLED_WINDOW (scrolled_win)));
3304 gtk_container_set_focus_hadjustment
3305 (GTK_CONTAINER (list),
3306 gtk_scrolled_window_get_hadjustment
3307 (GTK_SCROLLED_WINDOW (scrolled_win)));
3309 if ((infile = fopen("gtkenums.h", "r")))
3315 while (fgets (buffer, 256, infile))
3317 if ((pos = strchr (buffer, '\n')))
3319 item = gtk_list_item_new_with_label (buffer);
3320 gtk_container_add (GTK_CONTAINER (list), item);
3326 hbox = gtk_hbox_new (TRUE, 10);
3327 gtk_box_pack_start (GTK_BOX (box2), hbox, FALSE, TRUE, 0);
3329 button = gtk_button_new_with_label ("Undo Selection");
3330 gtk_signal_connect (GTK_OBJECT (button), "clicked",
3331 GTK_SIGNAL_FUNC(list_undo_selection),
3333 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
3335 button = gtk_button_new_with_label ("Remove Selection");
3336 gtk_signal_connect (GTK_OBJECT (button), "clicked",
3337 GTK_SIGNAL_FUNC (list_remove),
3339 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
3341 button = gtk_button_new_with_label ("Clear List");
3342 gtk_signal_connect (GTK_OBJECT (button), "clicked",
3343 GTK_SIGNAL_FUNC (list_clear),
3345 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
3347 hbox = gtk_hbox_new (FALSE, 10);
3348 gtk_box_pack_start (GTK_BOX (box2), hbox, FALSE, TRUE, 0);
3350 button = gtk_button_new_with_label ("Insert Row");
3351 gtk_signal_connect (GTK_OBJECT (button), "clicked",
3352 GTK_SIGNAL_FUNC (list_add),
3354 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
3356 label = gtk_label_new ("Selection Mode :");
3357 gtk_signal_connect (GTK_OBJECT (button), "clicked",
3358 GTK_SIGNAL_FUNC(list_remove),
3360 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
3362 list_omenu = gtk_option_menu_new ();
3363 menu = gtk_menu_new ();
3366 menu_item = gtk_radio_menu_item_new_with_label (group, "Single");
3367 gtk_signal_connect (GTK_OBJECT (menu_item), "activate",
3368 GTK_SIGNAL_FUNC (list_toggle_sel_mode), list);
3369 group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menu_item));
3370 gtk_menu_append (GTK_MENU (menu), menu_item);
3371 gtk_widget_show (menu_item);
3373 menu_item = gtk_radio_menu_item_new_with_label (group, "Browse");
3374 gtk_signal_connect (GTK_OBJECT (menu_item), "activate",
3375 GTK_SIGNAL_FUNC (list_toggle_sel_mode), list);
3376 group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menu_item));
3377 gtk_menu_append (GTK_MENU (menu), menu_item);
3378 gtk_widget_show (menu_item);
3380 menu_item = gtk_radio_menu_item_new_with_label (group, "Multiple");
3381 gtk_signal_connect (GTK_OBJECT (menu_item), "activate",
3382 GTK_SIGNAL_FUNC (list_toggle_sel_mode), list);
3383 group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menu_item));
3384 gtk_menu_append (GTK_MENU (menu), menu_item);
3385 gtk_widget_show (menu_item);
3387 menu_item = gtk_radio_menu_item_new_with_label (group, "Extended");
3388 gtk_signal_connect (GTK_OBJECT (menu_item), "activate",
3389 GTK_SIGNAL_FUNC (list_toggle_sel_mode), list);
3390 group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menu_item));
3391 gtk_menu_append (GTK_MENU (menu), menu_item);
3392 gtk_check_menu_item_set_state (GTK_CHECK_MENU_ITEM (menu_item), TRUE);
3393 gtk_widget_show (menu_item);
3395 gtk_option_menu_set_menu (GTK_OPTION_MENU (list_omenu), menu);
3396 gtk_box_pack_start (GTK_BOX (hbox), list_omenu, FALSE, TRUE, 0);
3398 gtk_option_menu_set_history (GTK_OPTION_MENU (list_omenu), 3);
3400 separator = gtk_hseparator_new ();
3401 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
3404 box2 = gtk_vbox_new (FALSE, 10);
3405 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
3406 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
3408 button = gtk_button_new_with_label ("close");
3409 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
3410 GTK_SIGNAL_FUNC(gtk_widget_destroy),
3411 GTK_OBJECT (window));
3412 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
3414 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
3415 gtk_widget_grab_default (button);
3418 if (!GTK_WIDGET_VISIBLE (window))
3419 gtk_widget_show_all (window);
3421 gtk_widget_destroy (window);
3428 static char * book_open_xpm[] = {
3451 static char * book_closed_xpm[] = {
3476 static char * mini_page_xpm[] = {
3499 static char * gtk_mini_xpm[] = {
3539 #define TESTGTK_CLIST_COLUMNS 20
3540 static gint clist_rows = 0;
3541 static GtkWidget *clist_omenu;
3544 add1000_clist (GtkWidget *widget, gpointer data)
3547 char text[TESTGTK_CLIST_COLUMNS][50];
3548 char *texts[TESTGTK_CLIST_COLUMNS];
3553 clist = GTK_CLIST (data);
3555 pixmap = gdk_pixmap_create_from_xpm_d (clist->clist_window,
3557 >K_WIDGET (data)->style->white,
3560 for (i = 0; i < TESTGTK_CLIST_COLUMNS; i++)
3563 sprintf (text[i], "Column %d", i);
3567 sprintf (text[1], "Right");
3568 sprintf (text[2], "Center");
3570 gtk_clist_freeze (GTK_CLIST (data));
3571 for (i = 0; i < 1000; i++)
3573 sprintf (text[0], "CListRow %d", rand() % 10000);
3574 row = gtk_clist_append (clist, texts);
3575 gtk_clist_set_pixtext (clist, row, 3, "gtk+", 5, pixmap, mask);
3578 gtk_clist_thaw (GTK_CLIST (data));
3580 gdk_pixmap_unref (pixmap);
3581 gdk_bitmap_unref (mask);
3585 add10000_clist (GtkWidget *widget, gpointer data)
3588 char text[TESTGTK_CLIST_COLUMNS][50];
3589 char *texts[TESTGTK_CLIST_COLUMNS];
3591 for (i = 0; i < TESTGTK_CLIST_COLUMNS; i++)
3594 sprintf (text[i], "Column %d", i);
3597 sprintf (text[1], "Right");
3598 sprintf (text[2], "Center");
3600 gtk_clist_freeze (GTK_CLIST (data));
3601 for (i = 0; i < 10000; i++)
3603 sprintf (text[0], "CListRow %d", rand() % 10000);
3604 gtk_clist_append (GTK_CLIST (data), texts);
3606 gtk_clist_thaw (GTK_CLIST (data));
3610 clear_clist (GtkWidget *widget, gpointer data)
3612 gtk_clist_clear (GTK_CLIST (data));
3617 remove_row_clist (GtkWidget *widget, gpointer data)
3619 gtk_clist_remove (GTK_CLIST (data), GTK_CLIST (data)->focus_row);
3624 show_titles_clist (GtkWidget *widget, gpointer data)
3626 gtk_clist_column_titles_show (GTK_CLIST (data));
3630 hide_titles_clist (GtkWidget *widget, gpointer data)
3632 gtk_clist_column_titles_hide (GTK_CLIST (data));
3636 select_clist (GtkWidget *widget,
3639 GdkEventButton * bevent,
3649 g_print ("GtkCList Selection: row %d column %d button %d\n",
3650 row, column, bevent ? bevent->button : 0);
3652 for (i = 0; i < TESTGTK_CLIST_COLUMNS; i++)
3654 switch (gtk_clist_get_cell_type (GTK_CLIST (widget), row, i))
3657 g_print ("CELL %d GTK_CELL_TEXT\n", i);
3658 gtk_clist_get_text (GTK_CLIST (widget), row, i, &text);
3659 g_print ("TEXT: %s\n", text);
3662 case GTK_CELL_PIXMAP:
3663 g_print ("CELL %d GTK_CELL_PIXMAP\n", i);
3664 gtk_clist_get_pixmap (GTK_CLIST (widget), row, i, &pixmap, &mask);
3665 g_print ("PIXMAP: %p\n", pixmap);
3666 g_print ("MASK: %p\n", mask);
3669 case GTK_CELL_PIXTEXT:
3670 g_print ("CELL %d GTK_CELL_PIXTEXT\n", i);
3671 gtk_clist_get_pixtext (GTK_CLIST (widget), row, i, &text, &spacing, &pixmap, &mask);
3672 g_print ("TEXT: %s\n", text);
3673 g_print ("SPACING: %d\n", spacing);
3674 g_print ("PIXMAP: %p\n", pixmap);
3675 g_print ("MASK: %p\n", mask);
3683 /* print selections list */
3684 g_print ("\nSelected Rows:");
3685 list = GTK_CLIST (widget)->selection;
3688 g_print (" %d ", GPOINTER_TO_INT (list->data));
3696 unselect_clist (GtkWidget *widget,
3699 GdkEventButton * bevent,
3709 g_print ("GtkCList Unselection: row %d column %d button %d\n",
3710 row, column, bevent ? bevent->button : 0);
3712 for (i = 0; i < TESTGTK_CLIST_COLUMNS; i++)
3714 switch (gtk_clist_get_cell_type (GTK_CLIST (widget), row, i))
3717 g_print ("CELL %d GTK_CELL_TEXT\n", i);
3718 gtk_clist_get_text (GTK_CLIST (widget), row, i, &text);
3719 g_print ("TEXT: %s\n", text);
3722 case GTK_CELL_PIXMAP:
3723 g_print ("CELL %d GTK_CELL_PIXMAP\n", i);
3724 gtk_clist_get_pixmap (GTK_CLIST (widget), row, i, &pixmap, &mask);
3725 g_print ("PIXMAP: %p\n", pixmap);
3726 g_print ("MASK: %p\n", mask);
3729 case GTK_CELL_PIXTEXT:
3730 g_print ("CELL %d GTK_CELL_PIXTEXT\n", i);
3731 gtk_clist_get_pixtext (GTK_CLIST (widget), row, i, &text, &spacing, &pixmap, &mask);
3732 g_print ("TEXT: %s\n", text);
3733 g_print ("SPACING: %d\n", spacing);
3734 g_print ("PIXMAP: %p\n", pixmap);
3735 g_print ("MASK: %p\n", mask);
3743 /* print selections list */
3744 g_print ("\nSelected Rows:");
3745 list = GTK_CLIST (widget)->selection;
3748 g_print (" %d ", GPOINTER_TO_INT (list->data));
3756 insert_row_clist (GtkWidget *widget, gpointer data)
3758 static char *text[] =
3760 "This", "is", "an", "inserted", "row.",
3761 "This", "is", "an", "inserted", "row.",
3762 "This", "is", "an", "inserted", "row.",
3763 "This", "is", "an", "inserted", "row."
3766 static GtkStyle *style1 = NULL;
3767 static GtkStyle *style2 = NULL;
3768 static GtkStyle *style3 = NULL;
3771 if (GTK_CLIST (data)->focus_row >= 0)
3772 row = gtk_clist_insert (GTK_CLIST (data), GTK_CLIST (data)->focus_row,
3775 row = gtk_clist_prepend (GTK_CLIST (data), text);
3789 style1 = gtk_style_copy (GTK_WIDGET (data)->style);
3790 style1->bg[GTK_STATE_PRELIGHT] = col1;
3791 style1->bg[GTK_STATE_SELECTED] = col2;
3793 style2 = gtk_style_copy (GTK_WIDGET (data)->style);
3794 style2->fg[GTK_STATE_PRELIGHT] = col1;
3795 style2->fg[GTK_STATE_SELECTED] = col2;
3797 style3 = gtk_style_copy (GTK_WIDGET (data)->style);
3798 style3->fg[GTK_STATE_PRELIGHT] = col1;
3799 style3->bg[GTK_STATE_PRELIGHT] = col2;
3800 gdk_font_unref (style3->font);
3802 gdk_font_load ("-*-courier-medium-*-*-*-*-120-*-*-*-*-*-*");
3805 gtk_clist_set_cell_style (GTK_CLIST (data), row, 3, style1);
3806 gtk_clist_set_cell_style (GTK_CLIST (data), row, 4, style2);
3807 gtk_clist_set_cell_style (GTK_CLIST (data), row, 0, style3);
3813 clist_warning_test (GtkWidget *button,
3817 static gboolean add_remove = FALSE;
3819 add_remove = !add_remove;
3821 child = gtk_label_new ("Test");
3822 gtk_widget_ref (child);
3823 gtk_object_sink (GTK_OBJECT (child));
3826 gtk_container_add (GTK_CONTAINER (clist), child);
3829 child->parent = clist;
3830 gtk_container_remove (GTK_CONTAINER (clist), child);
3831 child->parent = NULL;
3834 gtk_widget_destroy (child);
3835 gtk_widget_unref (child);
3839 undo_selection (GtkWidget *button, GtkCList *clist)
3841 gtk_clist_undo_selection (clist);
3845 clist_toggle_sel_mode (GtkWidget *widget, GtkCList *clist)
3849 if (!GTK_WIDGET_MAPPED (widget))
3852 RADIOMENUTOGGLED ((GtkRadioMenuItem *)
3853 (((GtkOptionMenu *)clist_omenu)->menu_item), i);
3855 gtk_clist_set_selection_mode (clist, (GtkSelectionMode) (3-i));
3859 clist_click_column (GtkCList *clist, gint column, gpointer data)
3862 gtk_clist_set_column_visibility (clist, column, FALSE);
3863 else if (column == clist->sort_column)
3865 if (clist->sort_type == GTK_SORT_ASCENDING)
3866 clist->sort_type = GTK_SORT_DESCENDING;
3868 clist->sort_type = GTK_SORT_ASCENDING;
3871 gtk_clist_set_sort_column (clist, column);
3873 gtk_clist_sort (clist);
3880 static GtkWidget *window = NULL;
3882 static char *titles[] =
3884 "auto resize", "not resizeable", "max width 100", "min width 50",
3885 "hide column", "Title 5", "Title 6", "Title 7",
3886 "Title 8", "Title 9", "Title 10", "Title 11", "Title 12",
3887 "Title 13", "Title 14", "Title 15", "Title 16", "Title 17",
3888 "Title 18", "Title 19"
3891 static OptionMenuItem items[] =
3893 { "Single", clist_toggle_sel_mode },
3894 { "Browse", clist_toggle_sel_mode },
3895 { "Multiple", clist_toggle_sel_mode },
3896 { "Extended", clist_toggle_sel_mode }
3899 char text[TESTGTK_CLIST_COLUMNS][50];
3900 char *texts[TESTGTK_CLIST_COLUMNS];
3906 GtkWidget *separator;
3907 GtkWidget *scrolled_win;
3909 GtkWidget *undo_button;
3919 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
3921 gtk_signal_connect (GTK_OBJECT (window), "destroy",
3922 GTK_SIGNAL_FUNC (gtk_widget_destroyed), &window);
3924 gtk_window_set_title (GTK_WINDOW (window), "clist");
3925 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
3927 box1 = gtk_vbox_new (FALSE, 0);
3928 gtk_container_add (GTK_CONTAINER (window), box1);
3930 box2 = gtk_hbox_new (FALSE, 10);
3931 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
3932 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0);
3934 /* create GtkCList here so we have a pointer to throw at the
3935 * button callbacks -- more is done with it later */
3936 clist = gtk_clist_new_with_titles (TESTGTK_CLIST_COLUMNS, titles);
3937 gtk_widget_show (clist);
3938 scrolled_win = gtk_scrolled_window_new (NULL, NULL);
3939 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
3940 GTK_POLICY_AUTOMATIC,
3941 GTK_POLICY_AUTOMATIC);
3942 gtk_container_add (GTK_CONTAINER (scrolled_win), clist);
3944 gtk_signal_connect (GTK_OBJECT (clist), "click_column",
3945 (GtkSignalFunc) clist_click_column, NULL);
3947 /* control buttons */
3948 button = gtk_button_new_with_label ("Add 1,000 Rows With Pixmaps");
3949 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
3951 gtk_signal_connect (GTK_OBJECT (button), "clicked",
3952 (GtkSignalFunc) add1000_clist, (gpointer) clist);
3954 button = gtk_button_new_with_label ("Add 10,000 Rows");
3955 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
3957 gtk_signal_connect (GTK_OBJECT (button), "clicked",
3958 (GtkSignalFunc) add10000_clist, (gpointer) clist);
3960 button = gtk_button_new_with_label ("Clear List");
3961 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
3963 gtk_signal_connect (GTK_OBJECT (button), "clicked",
3964 (GtkSignalFunc) clear_clist, (gpointer) clist);
3966 button = gtk_button_new_with_label ("Remove Row");
3967 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
3969 gtk_signal_connect (GTK_OBJECT (button), "clicked",
3970 (GtkSignalFunc) remove_row_clist, (gpointer) clist);
3972 /* second layer of buttons */
3973 box2 = gtk_hbox_new (FALSE, 10);
3974 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
3975 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0);
3977 button = gtk_button_new_with_label ("Insert Row");
3978 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
3980 gtk_signal_connect (GTK_OBJECT (button), "clicked",
3981 (GtkSignalFunc) insert_row_clist, (gpointer) clist);
3983 button = gtk_button_new_with_label ("Show Title Buttons");
3984 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
3986 gtk_signal_connect (GTK_OBJECT (button), "clicked",
3987 (GtkSignalFunc) show_titles_clist, (gpointer) clist);
3989 button = gtk_button_new_with_label ("Hide Title Buttons");
3990 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
3992 gtk_signal_connect (GTK_OBJECT (button), "clicked",
3993 (GtkSignalFunc) hide_titles_clist, (gpointer) clist);
3995 button = gtk_button_new_with_label ("Warning Test");
3996 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
3998 gtk_signal_connect (GTK_OBJECT (button), "clicked",
3999 (GtkSignalFunc) clist_warning_test,(gpointer) clist);
4001 box2 = gtk_hbox_new (FALSE, 10);
4002 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
4003 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0);
4005 undo_button = gtk_button_new_with_label ("Undo last selection");
4006 gtk_box_pack_start (GTK_BOX (box2), undo_button, TRUE, TRUE, 0);
4007 gtk_signal_connect (GTK_OBJECT (undo_button), "clicked",
4008 (GtkSignalFunc) undo_selection, (gpointer) clist);
4010 label = gtk_label_new ("Selection Mode :");
4011 gtk_box_pack_start (GTK_BOX (box2), label, FALSE, TRUE, 0);
4013 clist_omenu = build_option_menu (items, 4, 3, clist);
4014 gtk_box_pack_start (GTK_BOX (box2), clist_omenu, FALSE, TRUE, 0);
4016 /* vbox for the list itself */
4017 box2 = gtk_vbox_new (FALSE, 10);
4018 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
4019 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
4022 * the rest of the clist configuration
4026 gtk_signal_connect (GTK_OBJECT (clist),
4028 (GtkSignalFunc) select_clist,
4031 gtk_signal_connect (GTK_OBJECT (clist),
4033 (GtkSignalFunc) unselect_clist,
4037 gtk_clist_set_row_height (GTK_CLIST (clist), 18);
4038 gtk_widget_set_usize (clist, -1, 300);
4040 for (i = 1; i < TESTGTK_CLIST_COLUMNS; i++)
4041 gtk_clist_set_column_width (GTK_CLIST (clist), i, 80);
4043 gtk_clist_set_column_auto_resize (GTK_CLIST (clist), 0, TRUE);
4044 gtk_clist_set_column_resizeable (GTK_CLIST (clist), 1, FALSE);
4045 gtk_clist_set_column_max_width (GTK_CLIST (clist), 2, 100);
4046 gtk_clist_set_column_min_width (GTK_CLIST (clist), 3, 50);
4048 gtk_clist_set_selection_mode (GTK_CLIST (clist), GTK_SELECTION_EXTENDED);
4050 gtk_clist_set_column_justification (GTK_CLIST (clist), 1,
4052 gtk_clist_set_column_justification (GTK_CLIST (clist), 2,
4053 GTK_JUSTIFY_CENTER);
4055 for (i = 0; i < TESTGTK_CLIST_COLUMNS; i++)
4058 sprintf (text[i], "Column %d", i);
4061 sprintf (text[1], "Right");
4062 sprintf (text[2], "Center");
4071 style = gtk_style_new ();
4072 style->fg[GTK_STATE_PRELIGHT] = col1;
4073 style->bg[GTK_STATE_PRELIGHT] = col2;
4075 gdk_font_unref (style->font);
4077 gdk_font_load ("-adobe-helvetica-bold-r-*-*-*-140-*-*-*-*-*-*");
4079 for (i = 0; i < 10; i++)
4081 sprintf (text[0], "CListRow %d", clist_rows++);
4082 gtk_clist_append (GTK_CLIST (clist), texts);
4087 gtk_clist_set_row_style (GTK_CLIST (clist), i, style);
4090 gtk_clist_set_cell_style (GTK_CLIST (clist), i, i % 4, style);
4095 gtk_container_set_border_width (GTK_CONTAINER (scrolled_win), 5);
4096 gtk_box_pack_start (GTK_BOX (box2), scrolled_win, TRUE, TRUE, 0);
4098 separator = gtk_hseparator_new ();
4099 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
4101 box2 = gtk_vbox_new (FALSE, 10);
4102 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
4103 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
4105 button = gtk_button_new_with_label ("close");
4106 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
4107 GTK_SIGNAL_FUNC(gtk_widget_destroy),
4108 GTK_OBJECT (window));
4110 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
4111 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
4112 gtk_widget_grab_default (button);
4115 if (!GTK_WIDGET_VISIBLE (window))
4116 gtk_widget_show_all (window);
4120 gtk_widget_destroy (window);
4135 static gint books = 0;
4136 static gint pages = 0;
4138 static GtkWidget *book_label;
4139 static GtkWidget *page_label;
4140 static GtkWidget *sel_label;
4141 static GtkWidget *vis_label;
4142 static GtkWidget *omenu1;
4143 static GtkWidget *omenu2;
4144 static GtkWidget *omenu3;
4145 static GtkWidget *omenu4;
4146 static GtkWidget *spin1;
4147 static GtkWidget *spin2;
4148 static GtkWidget *spin3;
4149 static gint line_style;
4151 void after_press (GtkCTree *ctree, gpointer data)
4155 sprintf (buf, "%d", g_list_length (GTK_CLIST (ctree)->selection));
4156 gtk_label_set (GTK_LABEL (sel_label), buf);
4158 sprintf (buf, "%d", g_list_length (GTK_CLIST (ctree)->row_list));
4159 gtk_label_set (GTK_LABEL (vis_label), buf);
4161 sprintf (buf, "%d", books);
4162 gtk_label_set (GTK_LABEL (book_label), buf);
4164 sprintf (buf, "%d", pages);
4165 gtk_label_set (GTK_LABEL (page_label), buf);
4168 void after_move (GtkCTree *ctree, GtkCTreeNode *child, GtkCTreeNode *parent,
4169 GtkCTreeNode *sibling, gpointer data)
4175 gtk_ctree_get_node_info (ctree, child, &source,
4176 NULL, NULL, NULL, NULL, NULL, NULL, NULL);
4178 gtk_ctree_get_node_info (ctree, parent, &target1,
4179 NULL, NULL, NULL, NULL, NULL, NULL, NULL);
4181 gtk_ctree_get_node_info (ctree, sibling, &target2,
4182 NULL, NULL, NULL, NULL, NULL, NULL, NULL);
4184 g_print ("Moving \"%s\" to \"%s\" with sibling \"%s\".\n", source,
4185 (parent) ? target1 : "nil", (sibling) ? target2 : "nil");
4188 gint button_press (GtkCTree *ctree, GdkEventButton *event, gpointer data)
4195 res = gtk_clist_get_selection_info (GTK_CLIST (ctree), event->x, event->y,
4197 if (!res && event->button != 3)
4200 work = GTK_CTREE_NODE (g_list_nth (GTK_CLIST (ctree)->row_list, row));
4202 switch (event->button)
4205 if (GTK_CLIST (ctree)->selection_mode == GTK_SELECTION_MULTIPLE &&
4206 event->state & GDK_SHIFT_MASK)
4207 gtk_signal_emit_stop_by_name (GTK_OBJECT (ctree),"button_press_event");
4210 if (GTK_CTREE_ROW (work)->children &&
4211 gtk_ctree_is_hot_spot (ctree, event->x, event->y))
4213 if (GTK_CTREE_ROW (work)->expanded)
4214 gtk_ctree_collapse_recursive (ctree, work);
4216 gtk_ctree_expand_recursive (ctree, work);
4217 after_press (ctree, NULL);
4218 gtk_signal_emit_stop_by_name (GTK_OBJECT (ctree),
4219 "button_press_event");
4228 gint button_release (GtkCTree *ctree, GdkEventButton *event, gpointer data)
4235 res = gtk_clist_get_selection_info (GTK_CLIST (ctree), event->x, event->y,
4237 if (!res || event->button != 1)
4240 work = GTK_CTREE_NODE (g_list_nth (GTK_CLIST (ctree)->row_list, row));
4242 if (GTK_CLIST (ctree)->selection_mode == GTK_SELECTION_MULTIPLE &&
4243 event->state & GDK_SHIFT_MASK)
4245 if (GTK_CTREE_ROW (work)->row.state == GTK_STATE_SELECTED)
4246 gtk_ctree_unselect_recursive (ctree, work);
4248 gtk_ctree_select_recursive (ctree, work);
4249 after_press (ctree, NULL);
4250 gtk_signal_emit_stop_by_name (GTK_OBJECT (ctree),
4251 "button_release_event");
4256 void count_items (GtkCTree *ctree, GtkCTreeNode *list)
4258 if (GTK_CTREE_ROW (list)->is_leaf)
4264 void expand_all (GtkWidget *widget, GtkCTree *ctree)
4266 gtk_ctree_expand_recursive (ctree, NULL);
4267 after_press (ctree, NULL);
4270 void collapse_all (GtkWidget *widget, GtkCTree *ctree)
4272 gtk_ctree_collapse_recursive (ctree, NULL);
4273 after_press (ctree, NULL);
4276 void select_all (GtkWidget *widget, GtkCTree *ctree)
4278 gtk_ctree_select_recursive (ctree, NULL);
4279 after_press (ctree, NULL);
4282 void change_style (GtkWidget *widget, GtkCTree *ctree)
4284 static GtkStyle *style1 = NULL;
4285 static GtkStyle *style2 = NULL;
4291 if (GTK_CLIST (ctree)->focus_row >= 0)
4292 node = GTK_CTREE_NODE
4293 (g_list_nth (GTK_CLIST (ctree)->row_list,GTK_CLIST (ctree)->focus_row));
4295 node = GTK_CTREE_NODE (GTK_CLIST (ctree)->row_list);
4309 style1 = gtk_style_new ();
4310 style1->bg[GTK_STATE_PRELIGHT] = col1;
4311 style1->fg[GTK_STATE_SELECTED] = col2;
4313 style2 = gtk_style_new ();
4314 style2->bg[GTK_STATE_SELECTED] = col2;
4315 style2->fg[GTK_STATE_PRELIGHT] = col1;
4316 style2->bg[GTK_STATE_PRELIGHT] = col2;
4317 gdk_font_unref (style2->font);
4319 gdk_font_load ("-*-courier-medium-*-*-*-*-300-*-*-*-*-*-*");
4322 gtk_ctree_node_set_cell_style (ctree, node, 1, style1);
4323 gtk_ctree_node_set_cell_style (ctree, node, 0, style2);
4325 if (GTK_CTREE_ROW (node)->children)
4326 gtk_ctree_node_set_row_style (ctree, GTK_CTREE_ROW (node)->children,
4330 void unselect_all (GtkWidget *widget, GtkCTree *ctree)
4332 gtk_ctree_unselect_recursive (ctree, NULL);
4333 after_press (ctree, NULL);
4336 void remove_selection (GtkWidget *widget, GtkCTree *ctree)
4343 clist = GTK_CLIST (ctree);
4345 gtk_clist_freeze (clist);
4347 for (selection = clist->selection; selection; selection = selection->next)
4348 list = g_list_prepend (list, selection->data);
4350 selection = clist->selection;
4353 node = selection->data;
4355 if (!g_list_find (list, node))
4358 if (GTK_CTREE_ROW (node)->is_leaf)
4361 gtk_ctree_post_recursive (ctree, node,
4362 (GtkCTreeFunc) count_items, NULL);
4364 gtk_ctree_remove_node (ctree, node);
4365 selection = clist->selection;
4368 gtk_clist_thaw (clist);
4369 after_press (ctree, NULL);
4372 struct _ExportStruct {
4378 typedef struct _ExportStruct ExportStruct;
4381 gnode2ctree (GtkCTree *ctree,
4384 GtkCTreeNode *cnode,
4388 GdkPixmap *pixmap_closed;
4389 GdkBitmap *mask_closed;
4390 GdkPixmap *pixmap_opened;
4391 GdkBitmap *mask_opened;
4393 if (!cnode || !gnode || (!(es = gnode->data)))
4398 pixmap_closed = pixmap3;
4399 mask_closed = mask3;
4400 pixmap_opened = NULL;
4405 pixmap_closed = pixmap1;
4406 mask_closed = mask1;
4407 pixmap_opened = pixmap2;
4408 mask_opened = mask2;
4411 gtk_ctree_set_node_info (ctree, cnode, es->tree, 2, pixmap_closed,
4412 mask_closed, pixmap_opened, mask_opened,
4413 es->is_leaf, (depth < 3));
4414 gtk_ctree_node_set_text (ctree, cnode, 1, es->info);
4422 ctree2gnode (GtkCTree *ctree,
4425 GtkCTreeNode *cnode,
4430 if (!cnode || !gnode)
4433 es = g_new (ExportStruct, 1);
4435 es->is_leaf = GTK_CTREE_ROW (cnode)->is_leaf;
4436 es->tree = GTK_CELL_PIXTEXT (GTK_CTREE_ROW (cnode)->row.cell[0])->text;
4437 es->info = GTK_CELL_PIXTEXT (GTK_CTREE_ROW (cnode)->row.cell[1])->text;
4441 void export_ctree (GtkWidget *widget, GtkCTree *ctree)
4443 char *title[] = { "Tree" , "Info" };
4444 static GtkWidget *export_window = NULL;
4445 static GtkCTree *export_ctree;
4447 GtkWidget *scrolled_win;
4455 export_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
4457 gtk_signal_connect (GTK_OBJECT (export_window), "destroy",
4458 GTK_SIGNAL_FUNC (gtk_widget_destroyed),
4461 gtk_window_set_title (GTK_WINDOW (export_window), "exported ctree");
4462 gtk_container_set_border_width (GTK_CONTAINER (export_window), 5);
4464 vbox = gtk_vbox_new (FALSE, 0);
4465 gtk_container_add (GTK_CONTAINER (export_window), vbox);
4467 button = gtk_button_new_with_label ("Close");
4468 gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, TRUE, 0);
4470 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
4471 (GtkSignalFunc) gtk_widget_destroy,
4472 GTK_OBJECT(export_window));
4474 sep = gtk_hseparator_new ();
4475 gtk_box_pack_end (GTK_BOX (vbox), sep, FALSE, TRUE, 10);
4477 export_ctree = GTK_CTREE (gtk_ctree_new_with_titles (2, 0, title));
4478 gtk_ctree_set_line_style (export_ctree, GTK_CTREE_LINES_DOTTED);
4480 scrolled_win = gtk_scrolled_window_new (NULL, NULL);
4481 gtk_container_add (GTK_CONTAINER (scrolled_win),
4482 GTK_WIDGET (export_ctree));
4483 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
4484 GTK_POLICY_AUTOMATIC,
4485 GTK_POLICY_AUTOMATIC);
4486 gtk_box_pack_start (GTK_BOX (vbox), scrolled_win, TRUE, TRUE, 0);
4487 gtk_clist_set_selection_mode (GTK_CLIST (export_ctree),
4488 GTK_SELECTION_EXTENDED);
4489 gtk_clist_set_column_width (GTK_CLIST (export_ctree), 0, 200);
4490 gtk_clist_set_column_width (GTK_CLIST (export_ctree), 1, 200);
4491 gtk_widget_set_usize (GTK_WIDGET (export_ctree), 300, 200);
4494 if (!GTK_WIDGET_VISIBLE (export_window))
4495 gtk_widget_show_all (export_window);
4497 gtk_clist_clear (GTK_CLIST (export_ctree));
4499 node = GTK_CTREE_NODE (g_list_nth (GTK_CLIST (ctree)->row_list,
4500 GTK_CLIST (ctree)->focus_row));
4504 gnode = gtk_ctree_export_to_gnode (ctree, NULL, NULL, node,
4508 gtk_ctree_insert_gnode (export_ctree, NULL, NULL, gnode,
4510 g_node_destroy (gnode);
4514 void change_indent (GtkWidget *widget, GtkCTree *ctree)
4516 gtk_ctree_set_indent (ctree, GTK_ADJUSTMENT (widget)->value);
4519 void change_spacing (GtkWidget *widget, GtkCTree *ctree)
4521 gtk_ctree_set_spacing (ctree, GTK_ADJUSTMENT (widget)->value);
4524 void change_row_height (GtkWidget *widget, GtkCList *clist)
4526 gtk_clist_set_row_height (clist, GTK_ADJUSTMENT (widget)->value);
4529 void toggle_reorderable (GtkWidget *widget, GtkCTree *ctree)
4531 gtk_ctree_set_reorderable (ctree, GTK_TOGGLE_BUTTON (widget)->active);
4534 void set_background (GtkCTree *ctree, GtkCTreeNode *node, gpointer data)
4536 GtkStyle *style = NULL;
4541 if (ctree->line_style != GTK_CTREE_LINES_TABBED)
4543 if (!GTK_CTREE_ROW (node)->is_leaf)
4544 style = GTK_CTREE_ROW (node)->row.data;
4545 else if (GTK_CTREE_ROW (node)->parent)
4546 style = GTK_CTREE_ROW (GTK_CTREE_ROW (node)->parent)->row.data;
4549 gtk_ctree_node_set_row_style (ctree, node, style);
4552 void ctree_toggle_line_style (GtkWidget *widget, GtkCTree *ctree)
4556 if (!GTK_WIDGET_MAPPED (widget))
4559 RADIOMENUTOGGLED ((GtkRadioMenuItem *)
4560 (((GtkOptionMenu *)omenu1)->menu_item), i);
4562 if ((ctree->line_style == GTK_CTREE_LINES_TABBED &&
4563 ((GtkCTreeLineStyle) (3 - i)) != GTK_CTREE_LINES_TABBED) ||
4564 (ctree->line_style != GTK_CTREE_LINES_TABBED &&
4565 ((GtkCTreeLineStyle) (3 - i)) == GTK_CTREE_LINES_TABBED))
4566 gtk_ctree_pre_recursive (ctree, NULL, set_background, NULL);
4567 gtk_ctree_set_line_style (ctree, 3 - i);
4571 void ctree_toggle_expander_style (GtkWidget *widget, GtkCTree *ctree)
4575 if (!GTK_WIDGET_MAPPED (widget))
4578 RADIOMENUTOGGLED ((GtkRadioMenuItem *)
4579 (((GtkOptionMenu *)omenu2)->menu_item), i);
4581 gtk_ctree_set_expander_style (ctree, (GtkCTreeExpanderStyle) (3 - i));
4584 void ctree_toggle_justify (GtkWidget *widget, GtkCTree *ctree)
4588 if (!GTK_WIDGET_MAPPED (widget))
4591 RADIOMENUTOGGLED ((GtkRadioMenuItem *)
4592 (((GtkOptionMenu *)omenu3)->menu_item), i);
4594 gtk_clist_set_column_justification (GTK_CLIST (ctree), ctree->tree_column,
4595 (GtkJustification) (1 - i));
4598 void ctree_toggle_sel_mode (GtkWidget *widget, GtkCTree *ctree)
4602 if (!GTK_WIDGET_MAPPED (widget))
4605 RADIOMENUTOGGLED ((GtkRadioMenuItem *)
4606 (((GtkOptionMenu *)omenu4)->menu_item), i);
4608 gtk_clist_set_selection_mode (GTK_CLIST (ctree), (GtkSelectionMode) (3 - i));
4609 after_press (ctree, NULL);
4612 void build_recursive (GtkCTree *ctree, gint cur_depth, gint depth,
4613 gint num_books, gint num_pages, GtkCTreeNode *parent)
4618 GtkCTreeNode *sibling;
4625 for (i = num_pages + num_books; i > num_books; i--)
4628 sprintf (buf1, "Page %02d", (gint) rand() % 100);
4629 sprintf (buf2, "Item %d-%d", cur_depth, i);
4630 sibling = gtk_ctree_insert_node (ctree, parent, sibling, text, 5,
4631 pixmap3, mask3, NULL, NULL,
4634 if (parent && ctree->line_style == GTK_CTREE_LINES_TABBED)
4635 gtk_ctree_node_set_row_style (ctree, sibling,
4636 GTK_CTREE_ROW (parent)->row.style);
4639 if (cur_depth == depth)
4642 for (i = num_books; i > 0; i--)
4647 sprintf (buf1, "Book %02d", (gint) rand() % 100);
4648 sprintf (buf2, "Item %d-%d", cur_depth, i);
4649 sibling = gtk_ctree_insert_node (ctree, parent, sibling, text, 5,
4650 pixmap1, mask1, pixmap2, mask2,
4653 style = gtk_style_new ();
4654 switch (cur_depth % 3)
4657 style->bg[GTK_STATE_PRELIGHT].red = 10000 * (cur_depth % 6);
4658 style->bg[GTK_STATE_PRELIGHT].green = 0;
4659 style->bg[GTK_STATE_PRELIGHT].blue = 65535 - ((i * 10000) % 65535);
4662 style->bg[GTK_STATE_PRELIGHT].red = 10000 * (cur_depth % 6);
4663 style->bg[GTK_STATE_PRELIGHT].green = 65535 - ((i * 10000) % 65535);
4664 style->bg[GTK_STATE_PRELIGHT].blue = 0;
4667 style->bg[GTK_STATE_PRELIGHT].red = 65535 - ((i * 10000) % 65535);
4668 style->bg[GTK_STATE_PRELIGHT].green = 0;
4669 style->bg[GTK_STATE_PRELIGHT].blue = 10000 * (cur_depth % 6);
4672 gtk_ctree_node_set_row_data_full (ctree, sibling, style,
4673 (GtkDestroyNotify) gtk_style_unref);
4675 if (ctree->line_style == GTK_CTREE_LINES_TABBED)
4676 gtk_ctree_node_set_row_style (ctree, sibling, style);
4678 build_recursive (ctree, cur_depth + 1, depth, num_books, num_pages,
4683 void rebuild_tree (GtkWidget *widget, GtkCTree *ctree)
4686 gchar label1[] = "Root";
4687 gchar label2[] = "";
4688 GtkCTreeNode *parent;
4695 d = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (spin1));
4696 b = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (spin2));
4697 p = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (spin3));
4699 n = ((pow (b, d) - 1) / (b - 1)) * (p + 1);
4703 g_print ("%d total items? Try less\n",n);
4707 gtk_clist_freeze (GTK_CLIST (ctree));
4708 gtk_clist_clear (GTK_CLIST (ctree));
4713 parent = gtk_ctree_insert_node (ctree, NULL, NULL, text, 5, pixmap1,
4714 mask1, pixmap2, mask2, FALSE, TRUE);
4716 style = gtk_style_new ();
4717 style->bg[GTK_STATE_PRELIGHT].red = 0;
4718 style->bg[GTK_STATE_PRELIGHT].green = 45000;
4719 style->bg[GTK_STATE_PRELIGHT].blue = 55000;
4720 gtk_ctree_node_set_row_data_full (ctree, parent, style,
4721 (GtkDestroyNotify) gtk_style_unref);
4723 if (ctree->line_style == GTK_CTREE_LINES_TABBED)
4724 gtk_ctree_node_set_row_style (ctree, parent, style);
4726 build_recursive (ctree, 1, d, b, p, parent);
4727 gtk_clist_thaw (GTK_CLIST (ctree));
4728 after_press (ctree, NULL);
4732 ctree_click_column (GtkCTree *ctree, gint column, gpointer data)
4736 clist = GTK_CLIST (ctree);
4738 if (column == clist->sort_column)
4740 if (clist->sort_type == GTK_SORT_ASCENDING)
4741 clist->sort_type = GTK_SORT_DESCENDING;
4743 clist->sort_type = GTK_SORT_ASCENDING;
4746 gtk_clist_set_sort_column (clist, column);
4748 gtk_ctree_sort_recursive (ctree, NULL);
4751 void create_ctree (void)
4753 static GtkWidget *window = NULL;
4754 GtkTooltips *tooltips;
4756 GtkWidget *scrolled_win;
4768 GdkColor transparent;
4770 char *title[] = { "Tree" , "Info" };
4773 static OptionMenuItem items1[] =
4775 { "No lines", ctree_toggle_line_style },
4776 { "Solid", ctree_toggle_line_style },
4777 { "Dotted", ctree_toggle_line_style },
4778 { "Tabbed", ctree_toggle_line_style }
4781 static OptionMenuItem items2[] =
4783 { "None", ctree_toggle_expander_style },
4784 { "Square", ctree_toggle_expander_style },
4785 { "Triangle", ctree_toggle_expander_style },
4786 { "Circular", ctree_toggle_expander_style }
4789 static OptionMenuItem items3[] =
4791 { "Left", ctree_toggle_justify },
4792 { "Right", ctree_toggle_justify }
4795 static OptionMenuItem items4[] =
4797 { "Single", ctree_toggle_sel_mode },
4798 { "Browse", ctree_toggle_sel_mode },
4799 { "Multiple", ctree_toggle_sel_mode },
4800 { "Extended", ctree_toggle_sel_mode }
4805 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
4807 gtk_signal_connect (GTK_OBJECT (window), "destroy",
4808 GTK_SIGNAL_FUNC (gtk_widget_destroyed),
4811 gtk_window_set_title (GTK_WINDOW (window), "GtkCTree");
4812 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
4814 tooltips = gtk_tooltips_new ();
4815 gtk_object_ref (GTK_OBJECT (tooltips));
4816 gtk_object_sink (GTK_OBJECT (tooltips));
4818 gtk_object_set_data_full (GTK_OBJECT (window), "tooltips", tooltips,
4819 (GtkDestroyNotify) gtk_object_unref);
4821 vbox = gtk_vbox_new (FALSE, 0);
4822 gtk_container_add (GTK_CONTAINER (window), vbox);
4824 hbox = gtk_hbox_new (FALSE, 5);
4825 gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
4826 gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0);
4828 label = gtk_label_new ("Depth :");
4829 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
4831 adj = (GtkAdjustment *) gtk_adjustment_new (4, 1, 10, 1, 5, 0);
4832 spin1 = gtk_spin_button_new (adj, 0, 0);
4833 gtk_box_pack_start (GTK_BOX (hbox), spin1, FALSE, TRUE, 5);
4835 label = gtk_label_new ("Books :");
4836 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
4838 adj = (GtkAdjustment *) gtk_adjustment_new (3, 1, 20, 1, 5, 0);
4839 spin2 = gtk_spin_button_new (adj, 0, 0);
4840 gtk_box_pack_start (GTK_BOX (hbox), spin2, FALSE, TRUE, 5);
4842 label = gtk_label_new ("Pages :");
4843 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
4845 adj = (GtkAdjustment *) gtk_adjustment_new (5, 1, 20, 1, 5, 0);
4846 spin3 = gtk_spin_button_new (adj, 0, 0);
4847 gtk_box_pack_start (GTK_BOX (hbox), spin3, FALSE, TRUE, 5);
4849 button = gtk_button_new_with_label ("Close");
4850 gtk_box_pack_end (GTK_BOX (hbox), button, TRUE, TRUE, 0);
4852 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
4853 (GtkSignalFunc) gtk_widget_destroy,
4854 GTK_OBJECT(window));
4856 button = gtk_button_new_with_label ("Rebuild tree");
4857 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
4859 ctree = GTK_CTREE (gtk_ctree_new_with_titles (2, 0, title));
4860 gtk_signal_connect (GTK_OBJECT (button), "clicked",
4861 GTK_SIGNAL_FUNC (rebuild_tree), ctree);
4863 gtk_ctree_set_line_style (ctree, GTK_CTREE_LINES_DOTTED);
4864 line_style = GTK_CTREE_LINES_DOTTED;
4866 gtk_ctree_set_reorderable (ctree, TRUE);
4867 gtk_signal_connect (GTK_OBJECT (ctree), "click_column",
4868 (GtkSignalFunc) ctree_click_column,
4870 gtk_signal_connect (GTK_OBJECT (ctree), "button_press_event",
4871 GTK_SIGNAL_FUNC (button_press), NULL);
4872 gtk_signal_connect_after (GTK_OBJECT (ctree), "button_press_event",
4873 GTK_SIGNAL_FUNC (after_press), NULL);
4874 gtk_signal_connect (GTK_OBJECT (ctree), "button_release_event",
4875 GTK_SIGNAL_FUNC (button_release), NULL);
4876 gtk_signal_connect_after (GTK_OBJECT (ctree), "button_release_event",
4877 GTK_SIGNAL_FUNC (after_press), NULL);
4878 gtk_signal_connect_after (GTK_OBJECT (ctree), "tree_move",
4879 GTK_SIGNAL_FUNC (after_move), NULL);
4880 gtk_signal_connect_after (GTK_OBJECT (ctree), "end_selection",
4881 GTK_SIGNAL_FUNC (after_press), NULL);
4882 gtk_signal_connect_after (GTK_OBJECT (ctree), "toggle_focus_row",
4883 GTK_SIGNAL_FUNC (after_press), NULL);
4884 gtk_signal_connect_after (GTK_OBJECT (ctree), "select_all",
4885 GTK_SIGNAL_FUNC (after_press), NULL);
4886 gtk_signal_connect_after (GTK_OBJECT (ctree), "unselect_all",
4887 GTK_SIGNAL_FUNC (after_press), NULL);
4888 gtk_signal_connect_after (GTK_OBJECT (ctree), "scroll_vertical",
4889 GTK_SIGNAL_FUNC (after_press), NULL);
4891 scrolled_win = gtk_scrolled_window_new (NULL, NULL);
4892 gtk_container_add (GTK_CONTAINER (scrolled_win), GTK_WIDGET (ctree));
4893 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
4894 GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
4895 gtk_container_set_border_width (GTK_CONTAINER (scrolled_win), 5);
4896 gtk_box_pack_start (GTK_BOX (vbox), scrolled_win, TRUE, TRUE, 0);
4897 gtk_clist_set_selection_mode (GTK_CLIST (ctree), GTK_SELECTION_EXTENDED);
4898 gtk_clist_set_column_auto_resize (GTK_CLIST (ctree), 0, TRUE);
4899 gtk_clist_set_column_width (GTK_CLIST (ctree), 1, 200);
4901 bbox = gtk_hbox_new (FALSE, 5);
4902 gtk_container_set_border_width (GTK_CONTAINER (bbox), 5);
4903 gtk_box_pack_start (GTK_BOX (vbox), bbox, FALSE, TRUE, 0);
4905 mbox = gtk_vbox_new (TRUE, 5);
4906 gtk_box_pack_start (GTK_BOX (bbox), mbox, FALSE, TRUE, 0);
4908 label = gtk_label_new ("Row height :");
4909 gtk_box_pack_start (GTK_BOX (mbox), label, FALSE, FALSE, 0);
4911 label = gtk_label_new ("Indent :");
4912 gtk_box_pack_start (GTK_BOX (mbox), label, FALSE, FALSE, 0);
4914 label = gtk_label_new ("Spacing :");
4915 gtk_box_pack_start (GTK_BOX (mbox), label, FALSE, FALSE, 0);
4917 mbox = gtk_vbox_new (TRUE, 5);
4918 gtk_box_pack_start (GTK_BOX (bbox), mbox, FALSE, TRUE, 0);
4920 adj = (GtkAdjustment *) gtk_adjustment_new (20, 12, 100, 1, 10, 0);
4921 spinner = gtk_spin_button_new (adj, 0, 0);
4922 gtk_tooltips_set_tip (tooltips, spinner,
4923 "Row height of list items", NULL);
4924 gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
4925 GTK_SIGNAL_FUNC (change_row_height), ctree);
4926 gtk_box_pack_start (GTK_BOX (mbox), spinner, FALSE, FALSE, 5);
4927 gtk_clist_set_row_height ( GTK_CLIST (ctree), adj->value);
4929 adj = (GtkAdjustment *) gtk_adjustment_new (20, 0, 60, 1, 10, 0);
4930 spinner = gtk_spin_button_new (adj, 0, 0);
4931 gtk_tooltips_set_tip (tooltips, spinner, "Tree indentation.", NULL);
4932 gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
4933 GTK_SIGNAL_FUNC (change_indent), ctree);
4934 gtk_box_pack_start (GTK_BOX (mbox), spinner, FALSE, FALSE, 5);
4936 adj = (GtkAdjustment *) gtk_adjustment_new (5, 0, 60, 1, 10, 0);
4937 spinner = gtk_spin_button_new (adj, 0, 0);
4938 gtk_tooltips_set_tip (tooltips, spinner, "Tree spacing.", NULL);
4939 gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
4940 GTK_SIGNAL_FUNC (change_spacing), ctree);
4941 gtk_box_pack_start (GTK_BOX (mbox), spinner, FALSE, FALSE, 5);
4943 mbox = gtk_vbox_new (TRUE, 5);
4944 gtk_box_pack_start (GTK_BOX (bbox), mbox, FALSE, TRUE, 0);
4946 hbox = gtk_hbox_new (FALSE, 5);
4947 gtk_box_pack_start (GTK_BOX (mbox), hbox, FALSE, FALSE, 0);
4949 button = gtk_button_new_with_label ("Expand all");
4950 gtk_signal_connect (GTK_OBJECT (button), "clicked",
4951 GTK_SIGNAL_FUNC (expand_all), ctree);
4952 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
4954 button = gtk_button_new_with_label ("Collapse all");
4955 gtk_signal_connect (GTK_OBJECT (button), "clicked",
4956 GTK_SIGNAL_FUNC (collapse_all), ctree);
4957 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
4959 button = gtk_button_new_with_label ("Change Style");
4960 gtk_signal_connect (GTK_OBJECT (button), "clicked",
4961 GTK_SIGNAL_FUNC (change_style), ctree);
4962 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
4964 button = gtk_button_new_with_label ("Export tree");
4965 gtk_signal_connect (GTK_OBJECT (button), "clicked",
4966 GTK_SIGNAL_FUNC (export_ctree), ctree);
4967 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
4969 hbox = gtk_hbox_new (FALSE, 5);
4970 gtk_box_pack_start (GTK_BOX (mbox), hbox, FALSE, FALSE, 0);
4972 button = gtk_button_new_with_label ("Select all");
4973 gtk_signal_connect (GTK_OBJECT (button), "clicked",
4974 GTK_SIGNAL_FUNC (select_all), ctree);
4975 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
4977 button = gtk_button_new_with_label ("Unselect all");
4978 gtk_signal_connect (GTK_OBJECT (button), "clicked",
4979 GTK_SIGNAL_FUNC (unselect_all), ctree);
4980 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
4982 button = gtk_button_new_with_label ("Remove selection");
4983 gtk_signal_connect (GTK_OBJECT (button), "clicked",
4984 GTK_SIGNAL_FUNC (remove_selection), ctree);
4985 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
4987 check = gtk_check_button_new_with_label ("Reorderable");
4988 gtk_tooltips_set_tip (tooltips, check,
4989 "Tree items can be reordered by dragging.", NULL);
4990 gtk_signal_connect (GTK_OBJECT (check), "clicked",
4991 GTK_SIGNAL_FUNC (toggle_reorderable), ctree);
4992 gtk_box_pack_start (GTK_BOX (hbox), check, FALSE, TRUE, 0);
4993 gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON (check), TRUE);
4995 hbox = gtk_hbox_new (TRUE, 5);
4996 gtk_box_pack_start (GTK_BOX (mbox), hbox, FALSE, FALSE, 0);
4998 omenu1 = build_option_menu (items1, 4, 2, ctree);
4999 gtk_tooltips_set_tip (tooltips, omenu1, "The tree's line style.", NULL);
5000 gtk_box_pack_start (GTK_BOX (hbox), omenu1, FALSE, TRUE, 0);
5002 omenu2 = build_option_menu (items2, 4, 1, ctree);
5003 gtk_tooltips_set_tip (tooltips, omenu2, "The tree's expander style.",
5005 gtk_box_pack_start (GTK_BOX (hbox), omenu2, FALSE, TRUE, 0);
5007 omenu3 = build_option_menu (items3, 2, 0, ctree);
5008 gtk_tooltips_set_tip (tooltips, omenu3, "The tree's justification.",
5010 gtk_box_pack_start (GTK_BOX (hbox), omenu3, FALSE, TRUE, 0);
5012 omenu4 = build_option_menu (items4, 4, 3, ctree);
5013 gtk_tooltips_set_tip (tooltips, omenu4, "The list's selection mode.",
5015 gtk_box_pack_start (GTK_BOX (hbox), omenu4, FALSE, TRUE, 0);
5017 gtk_widget_realize (window);
5019 pixmap1 = gdk_pixmap_create_from_xpm_d (window->window, &mask1,
5020 &transparent, book_closed_xpm);
5021 pixmap2 = gdk_pixmap_create_from_xpm_d (window->window, &mask2,
5022 &transparent, book_open_xpm);
5023 pixmap3 = gdk_pixmap_create_from_xpm_d (window->window, &mask3,
5024 &transparent, mini_page_xpm);
5026 gtk_widget_set_usize (GTK_WIDGET (ctree), 0, 300);
5028 frame = gtk_frame_new (NULL);
5029 gtk_container_set_border_width (GTK_CONTAINER (frame), 0);
5030 gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_OUT);
5031 gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, TRUE, 0);
5033 hbox = gtk_hbox_new (TRUE, 2);
5034 gtk_container_set_border_width (GTK_CONTAINER (hbox), 2);
5035 gtk_container_add (GTK_CONTAINER (frame), hbox);
5037 frame = gtk_frame_new (NULL);
5038 gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
5039 gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, TRUE, 0);
5041 hbox2 = gtk_hbox_new (FALSE, 0);
5042 gtk_container_set_border_width (GTK_CONTAINER (hbox2), 2);
5043 gtk_container_add (GTK_CONTAINER (frame), hbox2);
5045 label = gtk_label_new ("Books :");
5046 gtk_box_pack_start (GTK_BOX (hbox2), label, FALSE, TRUE, 0);
5048 sprintf (buf, "%d", books);
5049 book_label = gtk_label_new (buf);
5050 gtk_box_pack_end (GTK_BOX (hbox2), book_label, FALSE, TRUE, 5);
5052 frame = gtk_frame_new (NULL);
5053 gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
5054 gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, TRUE, 0);
5056 hbox2 = gtk_hbox_new (FALSE, 0);
5057 gtk_container_set_border_width (GTK_CONTAINER (hbox2), 2);
5058 gtk_container_add (GTK_CONTAINER (frame), hbox2);
5060 label = gtk_label_new ("Pages :");
5061 gtk_box_pack_start (GTK_BOX (hbox2), label, FALSE, TRUE, 0);
5063 sprintf (buf, "%d", pages);
5064 page_label = gtk_label_new (buf);
5065 gtk_box_pack_end (GTK_BOX (hbox2), page_label, FALSE, TRUE, 5);
5067 frame = gtk_frame_new (NULL);
5068 gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
5069 gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, TRUE, 0);
5071 hbox2 = gtk_hbox_new (FALSE, 0);
5072 gtk_container_set_border_width (GTK_CONTAINER (hbox2), 2);
5073 gtk_container_add (GTK_CONTAINER (frame), hbox2);
5075 label = gtk_label_new ("Selected :");
5076 gtk_box_pack_start (GTK_BOX (hbox2), label, FALSE, TRUE, 0);
5078 sprintf (buf, "%d", g_list_length (GTK_CLIST (ctree)->selection));
5079 sel_label = gtk_label_new (buf);
5080 gtk_box_pack_end (GTK_BOX (hbox2), sel_label, FALSE, TRUE, 5);
5082 frame = gtk_frame_new (NULL);
5083 gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
5084 gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, TRUE, 0);
5086 hbox2 = gtk_hbox_new (FALSE, 0);
5087 gtk_container_set_border_width (GTK_CONTAINER (hbox2), 2);
5088 gtk_container_add (GTK_CONTAINER (frame), hbox2);
5090 label = gtk_label_new ("Visible :");
5091 gtk_box_pack_start (GTK_BOX (hbox2), label, FALSE, TRUE, 0);
5093 sprintf (buf, "%d", g_list_length (GTK_CLIST (ctree)->row_list));
5094 vis_label = gtk_label_new (buf);
5095 gtk_box_pack_end (GTK_BOX (hbox2), vis_label, FALSE, TRUE, 5);
5097 rebuild_tree (NULL, ctree);
5100 if (!GTK_WIDGET_VISIBLE (window))
5101 gtk_widget_show_all (window);
5103 gtk_widget_destroy (window);
5111 color_selection_ok (GtkWidget *w,
5112 GtkColorSelectionDialog *cs)
5114 GtkColorSelection *colorsel;
5117 colorsel=GTK_COLOR_SELECTION(cs->colorsel);
5119 gtk_color_selection_get_color(colorsel,color);
5120 gtk_color_selection_set_color(colorsel,color);
5124 color_selection_changed (GtkWidget *w,
5125 GtkColorSelectionDialog *cs)
5127 GtkColorSelection *colorsel;
5130 colorsel=GTK_COLOR_SELECTION(cs->colorsel);
5131 gtk_color_selection_get_color(colorsel,color);
5135 create_color_selection (void)
5137 static GtkWidget *window = NULL;
5141 window = gtk_color_selection_dialog_new ("color selection dialog");
5143 gtk_color_selection_set_opacity (
5144 GTK_COLOR_SELECTION (GTK_COLOR_SELECTION_DIALOG (window)->colorsel),
5147 gtk_color_selection_set_update_policy(
5148 GTK_COLOR_SELECTION (GTK_COLOR_SELECTION_DIALOG (window)->colorsel),
5149 GTK_UPDATE_CONTINUOUS);
5151 gtk_window_set_position (GTK_WINDOW (window), GTK_WIN_POS_MOUSE);
5153 gtk_signal_connect (GTK_OBJECT (window), "destroy",
5154 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
5157 gtk_signal_connect (
5158 GTK_OBJECT (GTK_COLOR_SELECTION_DIALOG (window)->colorsel),
5160 GTK_SIGNAL_FUNC(color_selection_changed),
5163 gtk_signal_connect (
5164 GTK_OBJECT (GTK_COLOR_SELECTION_DIALOG (window)->ok_button),
5166 GTK_SIGNAL_FUNC(color_selection_ok),
5169 gtk_signal_connect_object (
5170 GTK_OBJECT (GTK_COLOR_SELECTION_DIALOG (window)->cancel_button),
5172 GTK_SIGNAL_FUNC(gtk_widget_destroy),
5173 GTK_OBJECT (window));
5176 if (!GTK_WIDGET_VISIBLE (window))
5177 gtk_widget_show (window);
5179 gtk_widget_destroy (window);
5187 file_selection_hide_fileops (GtkWidget *widget,
5188 GtkFileSelection *fs)
5190 gtk_file_selection_hide_fileop_buttons (fs);
5194 file_selection_ok (GtkWidget *w,
5195 GtkFileSelection *fs)
5197 g_print ("%s\n", gtk_file_selection_get_filename (fs));
5198 gtk_widget_destroy (GTK_WIDGET (fs));
5202 create_file_selection (void)
5204 static GtkWidget *window = NULL;
5209 window = gtk_file_selection_new ("file selection dialog");
5211 gtk_file_selection_hide_fileop_buttons (GTK_FILE_SELECTION (window));
5213 gtk_window_set_position (GTK_WINDOW (window), GTK_WIN_POS_MOUSE);
5215 gtk_signal_connect (GTK_OBJECT (window), "destroy",
5216 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
5219 gtk_signal_connect (GTK_OBJECT (GTK_FILE_SELECTION (window)->ok_button),
5220 "clicked", GTK_SIGNAL_FUNC(file_selection_ok),
5222 gtk_signal_connect_object (GTK_OBJECT (GTK_FILE_SELECTION (window)->cancel_button),
5223 "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy),
5224 GTK_OBJECT (window));
5226 button = gtk_button_new_with_label ("Hide Fileops");
5227 gtk_signal_connect (GTK_OBJECT (button), "clicked",
5228 (GtkSignalFunc) file_selection_hide_fileops,
5230 gtk_box_pack_start (GTK_BOX (GTK_FILE_SELECTION (window)->action_area),
5231 button, FALSE, FALSE, 0);
5232 gtk_widget_show (button);
5234 button = gtk_button_new_with_label ("Show Fileops");
5235 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
5236 (GtkSignalFunc) gtk_file_selection_show_fileop_buttons,
5238 gtk_box_pack_start (GTK_BOX (GTK_FILE_SELECTION (window)->action_area),
5239 button, FALSE, FALSE, 0);
5240 gtk_widget_show (button);
5243 if (!GTK_WIDGET_VISIBLE (window))
5244 gtk_widget_show (window);
5246 gtk_widget_destroy (window);
5254 font_selection_ok (GtkWidget *w,
5255 GtkFontSelectionDialog *fs)
5257 g_print ("%s\n", gtk_font_selection_dialog_get_font_name (fs));
5258 gtk_widget_destroy (GTK_WIDGET (fs));
5262 create_font_selection (void)
5264 static GtkWidget *window = NULL;
5268 window = gtk_font_selection_dialog_new ("Font Selection Dialog");
5270 gtk_window_set_position (GTK_WINDOW (window), GTK_WIN_POS_MOUSE);
5272 gtk_signal_connect (GTK_OBJECT (window), "destroy",
5273 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
5276 gtk_signal_connect (GTK_OBJECT (GTK_FONT_SELECTION_DIALOG (window)->ok_button),
5277 "clicked", GTK_SIGNAL_FUNC(font_selection_ok),
5278 GTK_FONT_SELECTION_DIALOG (window));
5279 gtk_signal_connect_object (GTK_OBJECT (GTK_FONT_SELECTION_DIALOG (window)->cancel_button),
5280 "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy),
5281 GTK_OBJECT (window));
5284 if (!GTK_WIDGET_VISIBLE (window))
5285 gtk_widget_show (window);
5287 gtk_widget_destroy (window);
5294 static GtkWidget *dialog_window = NULL;
5297 label_toggle (GtkWidget *widget,
5302 *label = gtk_label_new ("Dialog Test");
5303 gtk_signal_connect (GTK_OBJECT (*label),
5305 GTK_SIGNAL_FUNC (gtk_widget_destroyed),
5307 gtk_misc_set_padding (GTK_MISC (*label), 10, 10);
5308 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog_window)->vbox),
5309 *label, TRUE, TRUE, 0);
5310 gtk_widget_show (*label);
5313 gtk_widget_destroy (*label);
5317 create_dialog (void)
5319 static GtkWidget *label;
5324 dialog_window = gtk_dialog_new ();
5326 gtk_signal_connect (GTK_OBJECT (dialog_window), "destroy",
5327 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
5330 gtk_window_set_title (GTK_WINDOW (dialog_window), "GtkDialog");
5331 gtk_container_set_border_width (GTK_CONTAINER (dialog_window), 0);
5332 gtk_widget_set_usize (dialog_window, 200, 110);
5334 button = gtk_button_new_with_label ("OK");
5335 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
5336 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog_window)->action_area),
5337 button, TRUE, TRUE, 0);
5338 gtk_widget_grab_default (button);
5339 gtk_widget_show (button);
5341 button = gtk_button_new_with_label ("Toggle");
5342 gtk_signal_connect (GTK_OBJECT (button), "clicked",
5343 GTK_SIGNAL_FUNC (label_toggle),
5345 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
5346 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog_window)->action_area),
5347 button, TRUE, TRUE, 0);
5348 gtk_widget_show (button);
5353 if (!GTK_WIDGET_VISIBLE (dialog_window))
5354 gtk_widget_show (dialog_window);
5356 gtk_widget_destroy (dialog_window);
5361 static gboolean event_watcher_enter_id = 0;
5362 static gboolean event_watcher_leave_id = 0;
5365 event_watcher (GtkObject *object,
5371 g_print ("Watch: \"%s\" emitted for %s\n",
5372 gtk_signal_name (signal_id),
5373 gtk_type_name (GTK_OBJECT_TYPE (object)));
5379 event_watcher_down (void)
5381 if (event_watcher_enter_id)
5385 signal_id = gtk_signal_lookup ("enter_notify_event", GTK_TYPE_WIDGET);
5386 gtk_signal_remove_emission_hook (signal_id, event_watcher_enter_id);
5387 event_watcher_enter_id = 0;
5388 signal_id = gtk_signal_lookup ("leave_notify_event", GTK_TYPE_WIDGET);
5389 gtk_signal_remove_emission_hook (signal_id, event_watcher_leave_id);
5390 event_watcher_leave_id = 0;
5395 event_watcher_toggle (void)
5397 if (event_watcher_enter_id)
5398 event_watcher_down ();
5403 signal_id = gtk_signal_lookup ("enter_notify_event", GTK_TYPE_WIDGET);
5404 event_watcher_enter_id = gtk_signal_add_emission_hook (signal_id, event_watcher, NULL);
5405 signal_id = gtk_signal_lookup ("leave_notify_event", GTK_TYPE_WIDGET);
5406 event_watcher_leave_id = gtk_signal_add_emission_hook (signal_id, event_watcher, NULL);
5411 create_event_watcher (void)
5417 dialog_window = gtk_dialog_new ();
5419 gtk_signal_connect (GTK_OBJECT (dialog_window), "destroy",
5420 GTK_SIGNAL_FUNC (gtk_widget_destroyed),
5422 gtk_signal_connect (GTK_OBJECT (dialog_window),
5424 GTK_SIGNAL_FUNC (event_watcher_down),
5427 gtk_window_set_title (GTK_WINDOW (dialog_window), "Event Watcher");
5428 gtk_container_set_border_width (GTK_CONTAINER (dialog_window), 0);
5429 gtk_widget_set_usize (dialog_window, 200, 110);
5431 button = gtk_toggle_button_new_with_label ("Activate Watch");
5432 gtk_signal_connect (GTK_OBJECT (button), "clicked",
5433 GTK_SIGNAL_FUNC (event_watcher_toggle),
5435 gtk_container_set_border_width (GTK_CONTAINER (button), 10);
5436 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog_window)->vbox),
5437 button, TRUE, TRUE, 0);
5438 gtk_widget_show (button);
5440 button = gtk_button_new_with_label ("Close");
5441 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
5442 GTK_SIGNAL_FUNC (gtk_widget_destroy),
5443 (GtkObject*) dialog_window);
5444 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
5445 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog_window)->action_area),
5446 button, TRUE, TRUE, 0);
5447 gtk_widget_grab_default (button);
5448 gtk_widget_show (button);
5451 if (!GTK_WIDGET_VISIBLE (dialog_window))
5452 gtk_widget_show (dialog_window);
5454 gtk_widget_destroy (dialog_window);
5462 create_range_controls (void)
5464 static GtkWidget *window = NULL;
5468 GtkWidget *scrollbar;
5470 GtkWidget *separator;
5471 GtkObject *adjustment;
5475 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
5477 gtk_signal_connect (GTK_OBJECT (window), "destroy",
5478 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
5481 gtk_window_set_title (GTK_WINDOW (window), "range controls");
5482 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
5485 box1 = gtk_vbox_new (FALSE, 0);
5486 gtk_container_add (GTK_CONTAINER (window), box1);
5487 gtk_widget_show (box1);
5490 box2 = gtk_vbox_new (FALSE, 10);
5491 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
5492 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
5493 gtk_widget_show (box2);
5496 adjustment = gtk_adjustment_new (0.0, 0.0, 101.0, 0.1, 1.0, 1.0);
5498 scale = gtk_hscale_new (GTK_ADJUSTMENT (adjustment));
5499 gtk_widget_set_usize (GTK_WIDGET (scale), 150, 30);
5500 gtk_range_set_update_policy (GTK_RANGE (scale), GTK_UPDATE_DELAYED);
5501 gtk_scale_set_digits (GTK_SCALE (scale), 1);
5502 gtk_scale_set_draw_value (GTK_SCALE (scale), TRUE);
5503 gtk_box_pack_start (GTK_BOX (box2), scale, TRUE, TRUE, 0);
5504 gtk_widget_show (scale);
5506 scrollbar = gtk_hscrollbar_new (GTK_ADJUSTMENT (adjustment));
5507 gtk_range_set_update_policy (GTK_RANGE (scrollbar),
5508 GTK_UPDATE_CONTINUOUS);
5509 gtk_box_pack_start (GTK_BOX (box2), scrollbar, TRUE, TRUE, 0);
5510 gtk_widget_show (scrollbar);
5513 separator = gtk_hseparator_new ();
5514 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
5515 gtk_widget_show (separator);
5518 box2 = gtk_vbox_new (FALSE, 10);
5519 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
5520 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
5521 gtk_widget_show (box2);
5524 button = gtk_button_new_with_label ("close");
5525 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
5526 GTK_SIGNAL_FUNC(gtk_widget_destroy),
5527 GTK_OBJECT (window));
5528 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
5529 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
5530 gtk_widget_grab_default (button);
5531 gtk_widget_show (button);
5534 if (!GTK_WIDGET_VISIBLE (window))
5535 gtk_widget_show (window);
5537 gtk_widget_destroy (window);
5545 create_rulers (void)
5547 static GtkWidget *window = NULL;
5553 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
5554 gtk_window_set_policy (GTK_WINDOW (window), TRUE, TRUE, FALSE);
5556 gtk_signal_connect (GTK_OBJECT (window), "destroy",
5557 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
5560 gtk_window_set_title (GTK_WINDOW (window), "rulers");
5561 gtk_widget_set_usize (window, 300, 300);
5562 gtk_widget_set_events (window,
5563 GDK_POINTER_MOTION_MASK
5564 | GDK_POINTER_MOTION_HINT_MASK);
5565 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
5567 table = gtk_table_new (2, 2, FALSE);
5568 gtk_container_add (GTK_CONTAINER (window), table);
5569 gtk_widget_show (table);
5571 ruler = gtk_hruler_new ();
5572 gtk_ruler_set_metric (GTK_RULER (ruler), GTK_CENTIMETERS);
5573 gtk_ruler_set_range (GTK_RULER (ruler), 100, 0, 0, 20);
5575 gtk_signal_connect_object (
5576 GTK_OBJECT (window),
5577 "motion_notify_event",
5579 GTK_WIDGET_CLASS (GTK_OBJECT (ruler)->klass)->motion_notify_event),
5580 GTK_OBJECT (ruler));
5582 gtk_table_attach (GTK_TABLE (table), ruler, 1, 2, 0, 1,
5583 GTK_EXPAND | GTK_FILL, GTK_FILL, 0, 0);
5584 gtk_widget_show (ruler);
5587 ruler = gtk_vruler_new ();
5588 gtk_ruler_set_range (GTK_RULER (ruler), 5, 15, 0, 20);
5590 gtk_signal_connect_object (
5591 GTK_OBJECT (window),
5592 "motion_notify_event",
5593 GTK_SIGNAL_FUNC (GTK_WIDGET_CLASS (GTK_OBJECT (ruler)->klass)->motion_notify_event),
5594 GTK_OBJECT (ruler));
5596 gtk_table_attach (GTK_TABLE (table), ruler, 0, 1, 1, 2,
5597 GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
5598 gtk_widget_show (ruler);
5601 if (!GTK_WIDGET_VISIBLE (window))
5602 gtk_widget_show (window);
5604 gtk_widget_destroy (window);
5608 text_toggle_editable (GtkWidget *checkbutton,
5611 gtk_text_set_editable(GTK_TEXT(text),
5612 GTK_TOGGLE_BUTTON(checkbutton)->active);
5616 text_toggle_word_wrap (GtkWidget *checkbutton,
5619 gtk_text_set_word_wrap(GTK_TEXT(text),
5620 GTK_TOGGLE_BUTTON(checkbutton)->active);
5627 { { 0, 0x0000, 0x0000, 0x0000 }, "black" },
5628 { { 0, 0xFFFF, 0xFFFF, 0xFFFF }, "white" },
5629 { { 0, 0xFFFF, 0x0000, 0x0000 }, "red" },
5630 { { 0, 0x0000, 0xFFFF, 0x0000 }, "green" },
5631 { { 0, 0x0000, 0x0000, 0xFFFF }, "blue" },
5632 { { 0, 0x0000, 0xFFFF, 0xFFFF }, "cyan" },
5633 { { 0, 0xFFFF, 0x0000, 0xFFFF }, "magenta" },
5634 { { 0, 0xFFFF, 0xFFFF, 0x0000 }, "yellow" }
5637 int ntext_colors = sizeof(text_colors) / sizeof(text_colors[0]);
5643 text_insert_random (GtkWidget *w, GtkText *text)
5647 for (i=0; i<10; i++)
5649 c = 'A' + rand() % ('Z' - 'A');
5650 gtk_text_set_point (text, rand() % gtk_text_get_length (text));
5651 gtk_text_insert (text, NULL, NULL, NULL, &c, 1);
5660 static GtkWidget *window = NULL;
5666 GtkWidget *separator;
5668 GtkWidget *hscrollbar;
5669 GtkWidget *vscrollbar;
5677 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
5678 gtk_widget_set_name (window, "text window");
5679 gtk_widget_set_usize (window, 500, 500);
5680 gtk_window_set_policy (GTK_WINDOW(window), TRUE, TRUE, FALSE);
5682 gtk_signal_connect (GTK_OBJECT (window), "destroy",
5683 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
5686 gtk_window_set_title (GTK_WINDOW (window), "test");
5687 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
5690 box1 = gtk_vbox_new (FALSE, 0);
5691 gtk_container_add (GTK_CONTAINER (window), box1);
5692 gtk_widget_show (box1);
5695 box2 = gtk_vbox_new (FALSE, 10);
5696 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
5697 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
5698 gtk_widget_show (box2);
5701 table = gtk_table_new (2, 2, FALSE);
5702 gtk_table_set_row_spacing (GTK_TABLE (table), 0, 2);
5703 gtk_table_set_col_spacing (GTK_TABLE (table), 0, 2);
5704 gtk_box_pack_start (GTK_BOX (box2), table, TRUE, TRUE, 0);
5705 gtk_widget_show (table);
5707 text = gtk_text_new (NULL, NULL);
5708 gtk_text_set_editable (GTK_TEXT (text), TRUE);
5709 gtk_table_attach (GTK_TABLE (table), text, 0, 1, 0, 1,
5710 GTK_EXPAND | GTK_SHRINK | GTK_FILL,
5711 GTK_EXPAND | GTK_SHRINK | GTK_FILL, 0, 0);
5712 gtk_widget_grab_focus (text);
5713 gtk_widget_show (text);
5715 hscrollbar = gtk_hscrollbar_new (GTK_TEXT (text)->hadj);
5716 gtk_table_attach (GTK_TABLE (table), hscrollbar, 0, 1, 1, 2,
5717 GTK_EXPAND | GTK_FILL | GTK_SHRINK, GTK_FILL, 0, 0);
5718 gtk_widget_show (hscrollbar);
5720 vscrollbar = gtk_vscrollbar_new (GTK_TEXT (text)->vadj);
5721 gtk_table_attach (GTK_TABLE (table), vscrollbar, 1, 2, 0, 1,
5722 GTK_FILL, GTK_EXPAND | GTK_SHRINK | GTK_FILL, 0, 0);
5723 gtk_widget_show (vscrollbar);
5725 gtk_text_freeze (GTK_TEXT (text));
5727 font = gdk_font_load ("-adobe-courier-medium-r-normal--*-120-*-*-*-*-*-*");
5729 for (i=0; i<ntext_colors; i++)
5731 gtk_text_insert (GTK_TEXT (text), font, NULL, NULL,
5732 text_colors[i].name, -1);
5733 gtk_text_insert (GTK_TEXT (text), font, NULL, NULL, "\t", -1);
5735 for (j=0; j<ntext_colors; j++)
5737 gtk_text_insert (GTK_TEXT (text), font,
5738 &text_colors[j].color, &text_colors[i].color,
5741 gtk_text_insert (GTK_TEXT (text), NULL, NULL, NULL, "\n", -1);
5744 /* The Text widget will reference count the font, so we
5745 * unreference it here
5747 gdk_font_unref (font);
5749 infile = fopen("testgtk.c", "r");
5758 nchars = fread(buffer, 1, 1024, infile);
5759 gtk_text_insert (GTK_TEXT (text), NULL, NULL,
5760 NULL, buffer, nchars);
5769 gtk_text_thaw (GTK_TEXT (text));
5771 hbox = gtk_hbutton_box_new ();
5772 gtk_box_pack_start (GTK_BOX (box2), hbox, FALSE, FALSE, 0);
5773 gtk_widget_show (hbox);
5775 check = gtk_check_button_new_with_label("Editable");
5776 gtk_box_pack_start (GTK_BOX (hbox), check, FALSE, FALSE, 0);
5777 gtk_signal_connect (GTK_OBJECT(check), "toggled",
5778 GTK_SIGNAL_FUNC(text_toggle_editable), text);
5779 gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(check), TRUE);
5780 gtk_widget_show (check);
5782 check = gtk_check_button_new_with_label("Wrap Words");
5783 gtk_box_pack_start (GTK_BOX (hbox), check, FALSE, TRUE, 0);
5784 gtk_signal_connect (GTK_OBJECT(check), "toggled",
5785 GTK_SIGNAL_FUNC(text_toggle_word_wrap), text);
5786 gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(check), FALSE);
5787 gtk_widget_show (check);
5789 separator = gtk_hseparator_new ();
5790 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
5791 gtk_widget_show (separator);
5794 box2 = gtk_vbox_new (FALSE, 10);
5795 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
5796 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
5797 gtk_widget_show (box2);
5800 button = gtk_button_new_with_label ("insert random");
5801 gtk_signal_connect (GTK_OBJECT (button), "clicked",
5802 GTK_SIGNAL_FUNC(text_insert_random),
5804 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
5805 gtk_widget_show (button);
5807 button = gtk_button_new_with_label ("close");
5808 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
5809 GTK_SIGNAL_FUNC(gtk_widget_destroy),
5810 GTK_OBJECT (window));
5811 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
5812 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
5813 gtk_widget_grab_default (button);
5814 gtk_widget_show (button);
5817 if (!GTK_WIDGET_VISIBLE (window))
5818 gtk_widget_show (window);
5820 gtk_widget_destroy (window);
5827 GdkPixmap *book_open;
5828 GdkPixmap *book_closed;
5829 GdkBitmap *book_open_mask;
5830 GdkBitmap *book_closed_mask;
5831 GtkWidget *sample_notebook;
5834 page_switch (GtkWidget *widget, GtkNotebookPage *page, gint page_num)
5836 GtkNotebookPage *oldpage;
5839 oldpage = GTK_NOTEBOOK (widget)->cur_page;
5841 if (page == oldpage)
5843 pixwid = ((GtkBoxChild*)
5844 (GTK_BOX (page->tab_label)->children->data))->widget;
5845 gtk_pixmap_set (GTK_PIXMAP (pixwid), book_open, book_open_mask);
5846 pixwid = ((GtkBoxChild*)
5847 (GTK_BOX (page->menu_label)->children->data))->widget;
5848 gtk_pixmap_set (GTK_PIXMAP (pixwid), book_open, book_open_mask);
5852 pixwid = ((GtkBoxChild*)
5853 (GTK_BOX (oldpage->tab_label)->children->data))->widget;
5854 gtk_pixmap_set (GTK_PIXMAP (pixwid), book_closed, book_closed_mask);
5855 pixwid = ((GtkBoxChild*)
5856 (GTK_BOX (oldpage->menu_label)->children->data))->widget;
5857 gtk_pixmap_set (GTK_PIXMAP (pixwid), book_closed, book_closed_mask);
5862 tab_fill (GtkToggleButton *button, GtkWidget *child)
5865 GtkPackType pack_type;
5867 gtk_notebook_query_tab_label_packing (GTK_NOTEBOOK (sample_notebook), child,
5868 &expand, NULL, &pack_type);
5869 gtk_notebook_set_tab_label_packing (GTK_NOTEBOOK (sample_notebook), child,
5870 expand, button->active, pack_type);
5874 tab_expand (GtkToggleButton *button, GtkWidget *child)
5877 GtkPackType pack_type;
5879 gtk_notebook_query_tab_label_packing (GTK_NOTEBOOK (sample_notebook), child,
5880 NULL, &fill, &pack_type);
5881 gtk_notebook_set_tab_label_packing (GTK_NOTEBOOK (sample_notebook), child,
5882 button->active, fill, pack_type);
5886 tab_pack (GtkToggleButton *button, GtkWidget *child)
5892 gtk_notebook_query_tab_label_packing (GTK_NOTEBOOK (sample_notebook), child,
5893 &expand, &fill, NULL);
5894 gtk_notebook_set_tab_label_packing (GTK_NOTEBOOK (sample_notebook), child,
5895 expand, fill, button->active);
5899 create_pages (GtkNotebook *notebook, gint start, gint end)
5901 GtkWidget *child = NULL;
5906 GtkWidget *label_box;
5907 GtkWidget *menu_box;
5912 for (i = start; i <= end; i++)
5914 sprintf (buffer, "Page %d", i);
5916 child = gtk_frame_new (buffer);
5917 gtk_container_set_border_width (GTK_CONTAINER (child), 10);
5919 vbox = gtk_vbox_new (TRUE,0);
5920 gtk_container_set_border_width (GTK_CONTAINER (vbox), 10);
5921 gtk_container_add (GTK_CONTAINER (child), vbox);
5923 hbox = gtk_hbox_new (TRUE,0);
5924 gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 5);
5926 button = gtk_check_button_new_with_label ("Fill Tab");
5927 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
5928 gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON (button), TRUE);
5929 gtk_signal_connect (GTK_OBJECT (button), "toggled",
5930 GTK_SIGNAL_FUNC (tab_fill), child);
5932 button = gtk_check_button_new_with_label ("Expand Tab");
5933 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
5934 gtk_signal_connect (GTK_OBJECT (button), "toggled",
5935 GTK_SIGNAL_FUNC (tab_expand), child);
5937 button = gtk_check_button_new_with_label ("Pack end");
5938 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
5939 gtk_signal_connect (GTK_OBJECT (button), "toggled",
5940 GTK_SIGNAL_FUNC (tab_pack), child);
5942 button = gtk_button_new_with_label ("Hide Page");
5943 gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 5);
5944 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
5945 GTK_SIGNAL_FUNC (gtk_widget_hide),
5946 GTK_OBJECT (child));
5948 gtk_widget_show_all (child);
5950 label_box = gtk_hbox_new (FALSE, 0);
5951 pixwid = gtk_pixmap_new (book_closed, book_closed_mask);
5952 gtk_box_pack_start (GTK_BOX (label_box), pixwid, FALSE, TRUE, 0);
5953 gtk_misc_set_padding (GTK_MISC (pixwid), 3, 1);
5954 label = gtk_label_new (buffer);
5955 gtk_box_pack_start (GTK_BOX (label_box), label, FALSE, TRUE, 0);
5956 gtk_widget_show_all (label_box);
5958 menu_box = gtk_hbox_new (FALSE, 0);
5959 pixwid = gtk_pixmap_new (book_closed, book_closed_mask);
5960 gtk_box_pack_start (GTK_BOX (menu_box), pixwid, FALSE, TRUE, 0);
5961 gtk_misc_set_padding (GTK_MISC (pixwid), 3, 1);
5962 label = gtk_label_new (buffer);
5963 gtk_box_pack_start (GTK_BOX (menu_box), label, FALSE, TRUE, 0);
5964 gtk_widget_show_all (menu_box);
5965 gtk_notebook_append_page_menu (notebook, child, label_box, menu_box);
5970 rotate_notebook (GtkButton *button,
5971 GtkNotebook *notebook)
5973 gtk_notebook_set_tab_pos (notebook, (notebook->tab_pos + 1) % 4);
5977 show_all_pages (GtkButton *button,
5978 GtkNotebook *notebook)
5980 gtk_container_foreach (GTK_CONTAINER (notebook),
5981 (GtkCallback) gtk_widget_show, NULL);
5985 standard_notebook (GtkButton *button,
5986 GtkNotebook *notebook)
5990 gtk_notebook_set_show_tabs (notebook, TRUE);
5991 gtk_notebook_set_scrollable (notebook, FALSE);
5992 if (g_list_length (notebook->children) == 15)
5993 for (i = 0; i < 10; i++)
5994 gtk_notebook_remove_page (notebook, 5);
5998 notabs_notebook (GtkButton *button,
5999 GtkNotebook *notebook)
6003 gtk_notebook_set_show_tabs (notebook, FALSE);
6004 if (g_list_length (notebook->children) == 15)
6005 for (i = 0; i < 10; i++)
6006 gtk_notebook_remove_page (notebook, 5);
6010 scrollable_notebook (GtkButton *button,
6011 GtkNotebook *notebook)
6013 gtk_notebook_set_show_tabs (notebook, TRUE);
6014 gtk_notebook_set_scrollable (notebook, TRUE);
6015 if (g_list_length (notebook->children) == 5)
6016 create_pages (notebook, 6, 15);
6020 notebook_popup (GtkToggleButton *button,
6021 GtkNotebook *notebook)
6024 gtk_notebook_popup_enable (notebook);
6026 gtk_notebook_popup_disable (notebook);
6030 notebook_homogeneous (GtkToggleButton *button,
6031 GtkNotebook *notebook)
6033 gtk_notebook_set_homogeneous_tabs (notebook, button->active);
6037 create_notebook (void)
6039 static GtkWidget *window = NULL;
6043 GtkWidget *separator;
6045 GdkColor *transparent = NULL;
6048 static OptionMenuItem items[] =
6050 { "Standard", standard_notebook },
6051 { "No tabs", notabs_notebook },
6052 { "Scrollable", scrollable_notebook }
6057 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
6059 gtk_signal_connect (GTK_OBJECT (window), "destroy",
6060 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
6063 gtk_window_set_title (GTK_WINDOW (window), "notebook");
6064 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
6066 box1 = gtk_vbox_new (FALSE, 0);
6067 gtk_container_add (GTK_CONTAINER (window), box1);
6069 sample_notebook = gtk_notebook_new ();
6070 gtk_signal_connect (GTK_OBJECT (sample_notebook), "switch_page",
6071 GTK_SIGNAL_FUNC (page_switch), NULL);
6072 gtk_notebook_set_tab_pos (GTK_NOTEBOOK (sample_notebook), GTK_POS_TOP);
6073 gtk_box_pack_start (GTK_BOX (box1), sample_notebook, TRUE, TRUE, 0);
6074 gtk_container_set_border_width (GTK_CONTAINER (sample_notebook), 10);
6076 gtk_widget_realize (sample_notebook);
6077 book_open = gdk_pixmap_create_from_xpm_d (sample_notebook->window,
6081 book_closed = gdk_pixmap_create_from_xpm_d (sample_notebook->window,
6086 create_pages (GTK_NOTEBOOK (sample_notebook), 1, 5);
6088 separator = gtk_hseparator_new ();
6089 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 10);
6091 box2 = gtk_hbox_new (FALSE, 5);
6092 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
6093 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
6095 button = gtk_check_button_new_with_label ("popup menu");
6096 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, FALSE, 0);
6097 gtk_signal_connect (GTK_OBJECT(button), "clicked",
6098 GTK_SIGNAL_FUNC (notebook_popup),
6099 GTK_OBJECT (sample_notebook));
6101 button = gtk_check_button_new_with_label ("homogeneous tabs");
6102 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, FALSE, 0);
6103 gtk_signal_connect (GTK_OBJECT(button), "clicked",
6104 GTK_SIGNAL_FUNC (notebook_homogeneous),
6105 GTK_OBJECT (sample_notebook));
6107 box2 = gtk_hbox_new (FALSE, 5);
6108 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
6109 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
6111 label = gtk_label_new ("Notebook Style :");
6112 gtk_box_pack_start (GTK_BOX (box2), label, FALSE, TRUE, 0);
6114 omenu = build_option_menu (items, 3, 0, sample_notebook);
6115 gtk_box_pack_start (GTK_BOX (box2), omenu, FALSE, TRUE, 0);
6117 button = gtk_button_new_with_label ("Show all Pages");
6118 gtk_box_pack_start (GTK_BOX (box2), button, FALSE, TRUE, 0);
6119 gtk_signal_connect (GTK_OBJECT (button), "clicked",
6120 GTK_SIGNAL_FUNC (show_all_pages), sample_notebook);
6122 box2 = gtk_hbox_new (TRUE, 10);
6123 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
6124 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
6126 button = gtk_button_new_with_label ("prev");
6127 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
6128 GTK_SIGNAL_FUNC (gtk_notebook_prev_page),
6129 GTK_OBJECT (sample_notebook));
6130 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
6132 button = gtk_button_new_with_label ("next");
6133 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
6134 GTK_SIGNAL_FUNC (gtk_notebook_next_page),
6135 GTK_OBJECT (sample_notebook));
6136 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
6138 button = gtk_button_new_with_label ("rotate");
6139 gtk_signal_connect (GTK_OBJECT (button), "clicked",
6140 GTK_SIGNAL_FUNC (rotate_notebook), sample_notebook);
6141 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
6143 separator = gtk_hseparator_new ();
6144 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 5);
6146 button = gtk_button_new_with_label ("close");
6147 gtk_container_set_border_width (GTK_CONTAINER (button), 5);
6148 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
6149 GTK_SIGNAL_FUNC (gtk_widget_destroy),
6150 GTK_OBJECT (window));
6151 gtk_box_pack_start (GTK_BOX (box1), button, FALSE, FALSE, 0);
6152 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
6153 gtk_widget_grab_default (button);
6156 if (!GTK_WIDGET_VISIBLE (window))
6157 gtk_widget_show_all (window);
6159 gtk_widget_destroy (window);
6169 static GtkWidget *window = NULL;
6177 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
6179 gtk_signal_connect (GTK_OBJECT (window), "destroy",
6180 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
6183 gtk_window_set_title (GTK_WINDOW (window), "Panes");
6184 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
6186 vpaned = gtk_vpaned_new ();
6187 gtk_container_add (GTK_CONTAINER (window), vpaned);
6188 gtk_container_set_border_width (GTK_CONTAINER(vpaned), 5);
6189 gtk_widget_show (vpaned);
6191 hpaned = gtk_hpaned_new ();
6192 gtk_paned_add1 (GTK_PANED (vpaned), hpaned);
6194 frame = gtk_frame_new (NULL);
6195 gtk_frame_set_shadow_type (GTK_FRAME(frame), GTK_SHADOW_IN);
6196 gtk_widget_set_usize (frame, 60, 60);
6197 gtk_paned_add1 (GTK_PANED (hpaned), frame);
6198 gtk_widget_show (frame);
6200 button = gtk_button_new_with_label ("Hi there");
6201 gtk_container_add (GTK_CONTAINER(frame), button);
6202 gtk_widget_show (button);
6204 frame = gtk_frame_new (NULL);
6205 gtk_frame_set_shadow_type (GTK_FRAME(frame), GTK_SHADOW_IN);
6206 gtk_widget_set_usize (frame, 80, 60);
6207 gtk_paned_add2 (GTK_PANED (hpaned), frame);
6208 gtk_widget_show (frame);
6210 gtk_widget_show (hpaned);
6212 frame = gtk_frame_new (NULL);
6213 gtk_frame_set_shadow_type (GTK_FRAME(frame), GTK_SHADOW_IN);
6214 gtk_widget_set_usize (frame, 60, 80);
6215 gtk_paned_add2 (GTK_PANED (vpaned), frame);
6216 gtk_widget_show (frame);
6219 if (!GTK_WIDGET_VISIBLE (window))
6220 gtk_widget_show (window);
6222 gtk_widget_destroy (window);
6231 dnd_drop_destroy_popup (GtkWidget *widget, GtkWindow **window)
6233 if(GTK_IS_BUTTON(widget)) /* I.e. they clicked the close button */
6234 gtk_widget_destroy(GTK_WIDGET(*window));
6236 gtk_grab_remove(GTK_WIDGET(*window));
6244 dnd_drop (GtkWidget *button, GdkEvent *event)
6246 static GtkWidget *window = NULL;
6247 GtkWidget *vbox, *lbl, *btn;
6250 /* DND doesn't obey gtk_grab's, so check if we're already displaying
6251 * drop modal dialog first
6256 window = gtk_window_new(GTK_WINDOW_DIALOG);
6257 gtk_container_set_border_width (GTK_CONTAINER(window), 10);
6259 gtk_signal_connect (GTK_OBJECT (window), "destroy",
6260 GTK_SIGNAL_FUNC(dnd_drop_destroy_popup),
6262 gtk_signal_connect (GTK_OBJECT (window), "delete-event",
6263 GTK_SIGNAL_FUNC(gtk_false),
6266 vbox = gtk_vbox_new(FALSE, 5);
6268 /* Display message that we got from drop source */
6269 msg = g_malloc(strlen(event->dropdataavailable.data)
6270 + strlen(event->dropdataavailable.data_type) + 100);
6271 sprintf(msg, "Drop data of type %s was:\n\n%s",
6272 event->dropdataavailable.data_type,
6273 (char *)event->dropdataavailable.data);
6274 lbl = gtk_label_new(msg);
6275 gtk_label_set_justify(GTK_LABEL(lbl), GTK_JUSTIFY_FILL);
6277 gtk_widget_show(lbl);
6278 gtk_box_pack_start_defaults(GTK_BOX(vbox), lbl);
6280 /* Provide an obvious way out of this heinousness */
6281 btn = gtk_button_new_with_label("Continue with life in\nspite of this oppression");
6282 gtk_signal_connect_object (GTK_OBJECT (btn), "clicked",
6283 GTK_SIGNAL_FUNC(gtk_widget_destroy),
6284 GTK_OBJECT (window));
6285 gtk_widget_show(btn);
6286 gtk_box_pack_start_defaults(GTK_BOX(vbox), btn);
6288 gtk_container_add(GTK_CONTAINER(window), vbox);
6290 gtk_widget_show(vbox);
6291 gtk_grab_add(window);
6292 gtk_widget_show(window);
6296 dnd_drag_request (GtkWidget *button, GdkEvent *event)
6298 #define DND_STRING "Bill Gates demands royalties for\nyour use of his innovation."
6299 gtk_widget_dnd_data_set (button, event, DND_STRING, strlen(DND_STRING) + 1);
6305 static GtkWidget *window = NULL;
6311 GtkWidget *separator;
6313 /* For clarity... */
6314 char *possible_drag_types[] = {"text/plain"};
6315 char *accepted_drop_types[] = {"text/plain"};
6317 static GtkWidget *drag_icon = NULL;
6318 static GtkWidget *drop_icon = NULL;
6322 GdkPoint hotspot = {5,5};
6326 drag_icon = shape_create_icon ("Modeller.xpm",
6327 440, 140, 0,0, GTK_WINDOW_POPUP);
6329 gtk_signal_connect (GTK_OBJECT (drag_icon), "destroy",
6330 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
6333 gtk_widget_hide (drag_icon);
6338 drop_icon = shape_create_icon ("3DRings.xpm",
6339 440, 140, 0,0, GTK_WINDOW_POPUP);
6341 gtk_signal_connect (GTK_OBJECT (drop_icon), "destroy",
6342 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
6345 gtk_widget_hide (drop_icon);
6348 gdk_dnd_set_drag_shape(drag_icon->window,
6353 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
6355 gtk_signal_connect (GTK_OBJECT (window), "destroy",
6356 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
6359 gtk_window_set_title (GTK_WINDOW (window), "Drag -N- Drop");
6360 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
6362 box1 = gtk_vbox_new (FALSE, 0);
6363 gtk_container_add (GTK_CONTAINER (window), box1);
6364 gtk_widget_show (box1);
6366 box2 = gtk_hbox_new (FALSE, 5);
6367 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
6368 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
6369 gtk_widget_show (box2);
6371 frame = gtk_frame_new ("Drag");
6372 gtk_box_pack_start (GTK_BOX (box2), frame, TRUE, TRUE, 0);
6373 gtk_widget_show (frame);
6375 box3 = gtk_vbox_new (FALSE, 5);
6376 gtk_container_set_border_width (GTK_CONTAINER (box3), 5);
6377 gtk_container_add (GTK_CONTAINER (frame), box3);
6378 gtk_widget_show (box3);
6383 button = gtk_button_new_with_label ("Drag me!");
6384 gtk_box_pack_start (GTK_BOX (box3), button, FALSE, TRUE, 0);
6385 gtk_widget_show (button);
6388 * currently, the widget has to be realized to
6389 * set dnd on it, this needs to change
6391 gtk_widget_realize (button);
6392 gtk_signal_connect (GTK_OBJECT (button),
6393 "drag_request_event",
6394 GTK_SIGNAL_FUNC(dnd_drag_request),
6397 gtk_widget_dnd_drag_set (button, TRUE, possible_drag_types, 1);
6400 frame = gtk_frame_new ("Drop");
6401 gtk_box_pack_start (GTK_BOX (box2), frame, TRUE, TRUE, 0);
6402 gtk_widget_show (frame);
6404 box3 = gtk_vbox_new (FALSE, 5);
6405 gtk_container_set_border_width (GTK_CONTAINER (box3), 5);
6406 gtk_container_add (GTK_CONTAINER (frame), box3);
6407 gtk_widget_show (box3);
6413 button = gtk_button_new_with_label ("To");
6414 gtk_box_pack_start (GTK_BOX (box3), button, FALSE, TRUE, 0);
6415 gtk_widget_show (button);
6417 gtk_widget_realize (button);
6418 gtk_signal_connect (GTK_OBJECT (button),
6419 "drop_data_available_event",
6420 GTK_SIGNAL_FUNC(dnd_drop),
6423 gtk_widget_dnd_drop_set (button, TRUE, accepted_drop_types, 1, FALSE);
6426 separator = gtk_hseparator_new ();
6427 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
6428 gtk_widget_show (separator);
6431 box2 = gtk_vbox_new (FALSE, 10);
6432 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
6433 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
6434 gtk_widget_show (box2);
6437 button = gtk_button_new_with_label ("close");
6439 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
6440 GTK_SIGNAL_FUNC(gtk_widget_destroy),
6441 GTK_OBJECT (window));
6443 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
6444 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
6445 gtk_widget_grab_default (button);
6446 gtk_widget_show (button);
6449 if (!GTK_WIDGET_VISIBLE (window))
6450 gtk_widget_show (window);
6452 gtk_widget_destroy (window);
6460 static GdkWindow *root_win = NULL;
6462 typedef struct _cursoroffset {gint x,y;} CursorOffset;
6465 shape_pressed (GtkWidget *widget, GdkEventButton *event)
6469 /* ignore double and triple click */
6470 if (event->type != GDK_BUTTON_PRESS)
6473 p = gtk_object_get_user_data (GTK_OBJECT(widget));
6474 p->x = (int) event->x;
6475 p->y = (int) event->y;
6477 gtk_grab_add (widget);
6478 gdk_pointer_grab (widget->window, TRUE,
6479 GDK_BUTTON_RELEASE_MASK |
6480 GDK_BUTTON_MOTION_MASK |
6481 GDK_POINTER_MOTION_HINT_MASK,
6486 shape_released (GtkWidget *widget)
6488 gtk_grab_remove (widget);
6489 gdk_pointer_ungrab (0);
6493 shape_motion (GtkWidget *widget,
6494 GdkEventMotion *event)
6498 GdkModifierType mask;
6500 p = gtk_object_get_user_data (GTK_OBJECT (widget));
6503 * Can't use event->x / event->y here
6504 * because I need absolute coordinates.
6506 gdk_window_get_pointer (root_win, &xp, &yp, &mask);
6507 gtk_widget_set_uposition (widget, xp - p->x, yp - p->y);
6511 shape_create_icon (char *xpm_file,
6521 CursorOffset* icon_pos;
6523 GdkBitmap *gdk_pixmap_mask;
6524 GdkPixmap *gdk_pixmap;
6527 style = gtk_widget_get_default_style ();
6528 gc = style->black_gc;
6531 * GDK_WINDOW_TOPLEVEL works also, giving you a title border
6533 window = gtk_window_new (window_type);
6535 fixed = gtk_fixed_new ();
6536 gtk_widget_set_usize (fixed, 100,100);
6537 gtk_container_add (GTK_CONTAINER (window), fixed);
6538 gtk_widget_show (fixed);
6540 gtk_widget_set_events (window,
6541 gtk_widget_get_events (window) |
6542 GDK_BUTTON_MOTION_MASK |
6543 GDK_POINTER_MOTION_HINT_MASK |
6544 GDK_BUTTON_PRESS_MASK);
6546 gtk_widget_realize (window);
6547 gdk_pixmap = gdk_pixmap_create_from_xpm (window->window, &gdk_pixmap_mask,
6548 &style->bg[GTK_STATE_NORMAL],
6551 pixmap = gtk_pixmap_new (gdk_pixmap, gdk_pixmap_mask);
6552 gtk_fixed_put (GTK_FIXED (fixed), pixmap, px,py);
6553 gtk_widget_show (pixmap);
6555 gtk_widget_shape_combine_mask (window, gdk_pixmap_mask, px,py);
6558 gtk_signal_connect (GTK_OBJECT (window), "button_press_event",
6559 GTK_SIGNAL_FUNC (shape_pressed),NULL);
6560 gtk_signal_connect (GTK_OBJECT (window), "button_release_event",
6561 GTK_SIGNAL_FUNC (shape_released),NULL);
6562 gtk_signal_connect (GTK_OBJECT (window), "motion_notify_event",
6563 GTK_SIGNAL_FUNC (shape_motion),NULL);
6565 icon_pos = g_new (CursorOffset, 1);
6566 gtk_object_set_user_data(GTK_OBJECT(window), icon_pos);
6568 gtk_widget_set_uposition (window, x, y);
6569 gtk_widget_show (window);
6575 create_shapes (void)
6577 /* Variables used by the Drag/Drop and Shape Window demos */
6578 static GtkWidget *modeller = NULL;
6579 static GtkWidget *sheets = NULL;
6580 static GtkWidget *rings = NULL;
6582 root_win = gdk_window_foreign_new (GDK_ROOT_WINDOW ());
6586 modeller = shape_create_icon ("Modeller.xpm",
6587 440, 140, 0,0, GTK_WINDOW_POPUP);
6589 gtk_signal_connect (GTK_OBJECT (modeller), "destroy",
6590 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
6594 gtk_widget_destroy (modeller);
6598 sheets = shape_create_icon ("FilesQueue.xpm",
6599 580, 170, 0,0, GTK_WINDOW_POPUP);
6601 gtk_signal_connect (GTK_OBJECT (sheets), "destroy",
6602 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
6607 gtk_widget_destroy (sheets);
6611 rings = shape_create_icon ("3DRings.xpm",
6612 460, 270, 25,25, GTK_WINDOW_TOPLEVEL);
6614 gtk_signal_connect (GTK_OBJECT (rings), "destroy",
6615 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
6619 gtk_widget_destroy (rings);
6627 create_wmhints (void)
6629 static GtkWidget *window = NULL;
6631 GtkWidget *separator;
6640 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
6642 gtk_signal_connect (GTK_OBJECT (window), "destroy",
6643 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
6646 gtk_window_set_title (GTK_WINDOW (window), "WM Hints");
6647 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
6649 gtk_widget_realize (window);
6651 circles = gdk_bitmap_create_from_data (window->window,
6655 gdk_window_set_icon (window->window, NULL,
6658 gdk_window_set_icon_name (window->window, "WMHints Test Icon");
6660 gdk_window_set_decorations (window->window, GDK_DECOR_ALL | GDK_DECOR_MENU);
6661 gdk_window_set_functions (window->window, GDK_FUNC_ALL | GDK_FUNC_RESIZE);
6663 box1 = gtk_vbox_new (FALSE, 0);
6664 gtk_container_add (GTK_CONTAINER (window), box1);
6665 gtk_widget_show (box1);
6667 label = gtk_label_new ("Try iconizing me!");
6668 gtk_widget_set_usize (label, 150, 50);
6669 gtk_box_pack_start (GTK_BOX (box1), label, TRUE, TRUE, 0);
6670 gtk_widget_show (label);
6673 separator = gtk_hseparator_new ();
6674 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
6675 gtk_widget_show (separator);
6678 box2 = gtk_vbox_new (FALSE, 10);
6679 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
6680 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
6681 gtk_widget_show (box2);
6684 button = gtk_button_new_with_label ("close");
6686 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
6687 GTK_SIGNAL_FUNC(gtk_widget_destroy),
6688 GTK_OBJECT (window));
6690 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
6691 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
6692 gtk_widget_grab_default (button);
6693 gtk_widget_show (button);
6696 if (!GTK_WIDGET_VISIBLE (window))
6697 gtk_widget_show (window);
6699 gtk_widget_destroy (window);
6706 typedef struct _ProgressData {
6709 GtkWidget *block_spin;
6710 GtkWidget *x_align_spin;
6711 GtkWidget *y_align_spin;
6712 GtkWidget *step_spin;
6713 GtkWidget *act_blocks_spin;
6722 progress_timeout (gpointer data)
6727 adj = GTK_PROGRESS (data)->adjustment;
6729 new_val = adj->value + 1;
6730 if (new_val > adj->upper)
6731 new_val = adj->lower;
6733 gtk_progress_set_value (GTK_PROGRESS (data), new_val);
6739 destroy_progress (GtkWidget *widget,
6740 ProgressData **pdata)
6742 gtk_timeout_remove ((*pdata)->timer);
6743 (*pdata)->timer = 0;
6744 (*pdata)->window = NULL;
6750 progressbar_toggle_orientation (GtkWidget *widget, ProgressData *pdata)
6754 if (!GTK_WIDGET_MAPPED (widget))
6757 RADIOMENUTOGGLED ((GtkRadioMenuItem *)
6758 (((GtkOptionMenu *)(pdata->omenu1))->menu_item), i);
6760 gtk_progress_bar_set_orientation (GTK_PROGRESS_BAR (pdata->pbar),
6761 (GtkProgressBarOrientation) (3-i));
6765 toggle_show_text (GtkWidget *widget, ProgressData *pdata)
6767 gtk_progress_set_show_text (GTK_PROGRESS (pdata->pbar),
6768 GTK_TOGGLE_BUTTON (widget)->active);
6769 gtk_widget_set_sensitive (pdata->entry, GTK_TOGGLE_BUTTON (widget)->active);
6770 gtk_widget_set_sensitive (pdata->x_align_spin,
6771 GTK_TOGGLE_BUTTON (widget)->active);
6772 gtk_widget_set_sensitive (pdata->y_align_spin,
6773 GTK_TOGGLE_BUTTON (widget)->active);
6777 progressbar_toggle_bar_style (GtkWidget *widget, ProgressData *pdata)
6781 if (!GTK_WIDGET_MAPPED (widget))
6784 RADIOMENUTOGGLED ((GtkRadioMenuItem *)
6785 (((GtkOptionMenu *)(pdata->omenu2))->menu_item), i);
6790 gtk_widget_set_sensitive (pdata->block_spin, TRUE);
6792 gtk_widget_set_sensitive (pdata->block_spin, FALSE);
6794 gtk_progress_bar_set_bar_style (GTK_PROGRESS_BAR (pdata->pbar),
6795 (GtkProgressBarStyle) i);
6799 progress_value_changed (GtkAdjustment *adj, ProgressData *pdata)
6803 if (GTK_PROGRESS (pdata->pbar)->activity_mode)
6804 sprintf (buf, "???");
6806 sprintf (buf, "%.0f%%", 100 *
6807 gtk_progress_get_current_percentage (GTK_PROGRESS (pdata->pbar)));
6808 gtk_label_set (GTK_LABEL (pdata->label), buf);
6812 adjust_blocks (GtkAdjustment *adj, ProgressData *pdata)
6814 gtk_progress_set_percentage (GTK_PROGRESS (pdata->pbar), 0);
6815 gtk_progress_bar_set_discrete_blocks (GTK_PROGRESS_BAR (pdata->pbar),
6816 gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (pdata->block_spin)));
6820 adjust_step (GtkAdjustment *adj, ProgressData *pdata)
6822 gtk_progress_bar_set_activity_step (GTK_PROGRESS_BAR (pdata->pbar),
6823 gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (pdata->step_spin)));
6827 adjust_act_blocks (GtkAdjustment *adj, ProgressData *pdata)
6829 gtk_progress_bar_set_activity_blocks (GTK_PROGRESS_BAR (pdata->pbar),
6830 gtk_spin_button_get_value_as_int
6831 (GTK_SPIN_BUTTON (pdata->act_blocks_spin)));
6835 adjust_align (GtkAdjustment *adj, ProgressData *pdata)
6837 gtk_progress_set_text_alignment (GTK_PROGRESS (pdata->pbar),
6838 gtk_spin_button_get_value_as_float
6839 (GTK_SPIN_BUTTON (pdata->x_align_spin)),
6840 gtk_spin_button_get_value_as_float
6841 (GTK_SPIN_BUTTON (pdata->y_align_spin)));
6845 toggle_activity_mode (GtkWidget *widget, ProgressData *pdata)
6847 gtk_progress_set_activity_mode (GTK_PROGRESS (pdata->pbar),
6848 GTK_TOGGLE_BUTTON (widget)->active);
6849 gtk_widget_set_sensitive (pdata->step_spin,
6850 GTK_TOGGLE_BUTTON (widget)->active);
6851 gtk_widget_set_sensitive (pdata->act_blocks_spin,
6852 GTK_TOGGLE_BUTTON (widget)->active);
6856 entry_changed (GtkWidget *widget, ProgressData *pdata)
6858 gtk_progress_set_format_string (GTK_PROGRESS (pdata->pbar),
6859 gtk_entry_get_text (GTK_ENTRY (pdata->entry)));
6863 create_progress_bar (void)
6875 static ProgressData *pdata = NULL;
6877 static OptionMenuItem items1[] =
6879 { "Left-Right", progressbar_toggle_orientation },
6880 { "Right-Left", progressbar_toggle_orientation },
6881 { "Bottom-Top", progressbar_toggle_orientation },
6882 { "Top-Bottom", progressbar_toggle_orientation }
6885 static OptionMenuItem items2[] =
6887 { "Continuous", progressbar_toggle_bar_style },
6888 { "Discrete", progressbar_toggle_bar_style }
6892 pdata = g_new0 (ProgressData, 1);
6896 pdata->window = gtk_dialog_new ();
6898 gtk_window_set_policy (GTK_WINDOW (pdata->window), FALSE, FALSE, TRUE);
6900 gtk_signal_connect (GTK_OBJECT (pdata->window), "destroy",
6901 GTK_SIGNAL_FUNC (destroy_progress),
6906 gtk_window_set_title (GTK_WINDOW (pdata->window), "GtkProgressBar");
6907 gtk_container_set_border_width (GTK_CONTAINER (pdata->window), 0);
6909 vbox = gtk_vbox_new (FALSE, 5);
6910 gtk_container_set_border_width (GTK_CONTAINER (vbox), 10);
6911 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (pdata->window)->vbox),
6912 vbox, FALSE, TRUE, 0);
6914 frame = gtk_frame_new ("Progress");
6915 gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, TRUE, 0);
6917 vbox2 = gtk_vbox_new (FALSE, 5);
6918 gtk_container_add (GTK_CONTAINER (frame), vbox2);
6920 align = gtk_alignment_new (0.5, 0.5, 0, 0);
6921 gtk_box_pack_start (GTK_BOX (vbox2), align, FALSE, FALSE, 5);
6923 adj = (GtkAdjustment *) gtk_adjustment_new (0, 1, 300, 0, 0, 0);
6924 gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
6925 GTK_SIGNAL_FUNC (progress_value_changed), pdata);
6927 pdata->pbar = gtk_progress_bar_new_with_adjustment (adj);
6928 gtk_progress_set_format_string (GTK_PROGRESS (pdata->pbar),
6929 "%v from [%l,%u] (=%p%%)");
6930 gtk_container_add (GTK_CONTAINER (align), pdata->pbar);
6931 pdata->timer = gtk_timeout_add (100, progress_timeout, pdata->pbar);
6933 align = gtk_alignment_new (0.5, 0.5, 0, 0);
6934 gtk_box_pack_start (GTK_BOX (vbox2), align, FALSE, FALSE, 5);
6936 hbox = gtk_hbox_new (FALSE, 5);
6937 gtk_container_add (GTK_CONTAINER (align), hbox);
6938 label = gtk_label_new ("Label updated by user :");
6939 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
6940 pdata->label = gtk_label_new ("");
6941 gtk_box_pack_start (GTK_BOX (hbox), pdata->label, FALSE, TRUE, 0);
6943 frame = gtk_frame_new ("Options");
6944 gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, TRUE, 0);
6946 vbox2 = gtk_vbox_new (FALSE, 5);
6947 gtk_container_add (GTK_CONTAINER (frame), vbox2);
6949 tab = gtk_table_new (7, 2, FALSE);
6950 gtk_box_pack_start (GTK_BOX (vbox2), tab, FALSE, TRUE, 0);
6952 label = gtk_label_new ("Orientation :");
6953 gtk_table_attach (GTK_TABLE (tab), label, 0, 1, 0, 1,
6954 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
6956 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
6958 pdata->omenu1 = build_option_menu (items1, 4, 0, pdata);
6959 hbox = gtk_hbox_new (FALSE, 0);
6960 gtk_table_attach (GTK_TABLE (tab), hbox, 1, 2, 0, 1,
6961 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
6963 gtk_box_pack_start (GTK_BOX (hbox), pdata->omenu1, TRUE, TRUE, 0);
6965 check = gtk_check_button_new_with_label ("Show text");
6966 gtk_signal_connect (GTK_OBJECT (check), "clicked",
6967 GTK_SIGNAL_FUNC (toggle_show_text),
6969 gtk_table_attach (GTK_TABLE (tab), check, 0, 1, 1, 2,
6970 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
6973 hbox = gtk_hbox_new (FALSE, 0);
6974 gtk_table_attach (GTK_TABLE (tab), hbox, 1, 2, 1, 2,
6975 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
6978 label = gtk_label_new ("Format : ");
6979 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
6981 pdata->entry = gtk_entry_new ();
6982 gtk_signal_connect (GTK_OBJECT (pdata->entry), "changed",
6983 GTK_SIGNAL_FUNC (entry_changed),
6985 gtk_box_pack_start (GTK_BOX (hbox), pdata->entry, TRUE, TRUE, 0);
6986 gtk_entry_set_text (GTK_ENTRY (pdata->entry), "%v from [%l,%u] (=%p%%)");
6987 gtk_widget_set_usize (pdata->entry, 100, -1);
6988 gtk_widget_set_sensitive (pdata->entry, FALSE);
6990 label = gtk_label_new ("Text align :");
6991 gtk_table_attach (GTK_TABLE (tab), label, 0, 1, 2, 3,
6992 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
6994 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
6996 hbox = gtk_hbox_new (FALSE, 0);
6997 gtk_table_attach (GTK_TABLE (tab), hbox, 1, 2, 2, 3,
6998 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
7001 label = gtk_label_new ("x :");
7002 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 5);
7004 adj = (GtkAdjustment *) gtk_adjustment_new (0.5, 0, 1, 0.1, 0.1, 0);
7005 pdata->x_align_spin = gtk_spin_button_new (adj, 0, 1);
7006 gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
7007 GTK_SIGNAL_FUNC (adjust_align), pdata);
7008 gtk_box_pack_start (GTK_BOX (hbox), pdata->x_align_spin, FALSE, TRUE, 0);
7009 gtk_widget_set_sensitive (pdata->x_align_spin, FALSE);
7011 label = gtk_label_new ("y :");
7012 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 5);
7014 adj = (GtkAdjustment *) gtk_adjustment_new (0.5, 0, 1, 0.1, 0.1, 0);
7015 pdata->y_align_spin = gtk_spin_button_new (adj, 0, 1);
7016 gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
7017 GTK_SIGNAL_FUNC (adjust_align), pdata);
7018 gtk_box_pack_start (GTK_BOX (hbox), pdata->y_align_spin, FALSE, TRUE, 0);
7019 gtk_widget_set_sensitive (pdata->y_align_spin, FALSE);
7021 label = gtk_label_new ("Bar Style :");
7022 gtk_table_attach (GTK_TABLE (tab), label, 0, 1, 3, 4,
7023 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
7025 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
7027 pdata->omenu2 = build_option_menu (items2, 2, 0, pdata);
7028 hbox = gtk_hbox_new (FALSE, 0);
7029 gtk_table_attach (GTK_TABLE (tab), hbox, 1, 2, 3, 4,
7030 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
7032 gtk_box_pack_start (GTK_BOX (hbox), pdata->omenu2, TRUE, TRUE, 0);
7034 label = gtk_label_new ("Block count :");
7035 gtk_table_attach (GTK_TABLE (tab), label, 0, 1, 4, 5,
7036 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
7038 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
7040 hbox = gtk_hbox_new (FALSE, 0);
7041 gtk_table_attach (GTK_TABLE (tab), hbox, 1, 2, 4, 5,
7042 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
7044 adj = (GtkAdjustment *) gtk_adjustment_new (10, 2, 20, 1, 5, 0);
7045 pdata->block_spin = gtk_spin_button_new (adj, 0, 0);
7046 gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
7047 GTK_SIGNAL_FUNC (adjust_blocks), pdata);
7048 gtk_box_pack_start (GTK_BOX (hbox), pdata->block_spin, FALSE, TRUE, 0);
7049 gtk_widget_set_sensitive (pdata->block_spin, FALSE);
7051 check = gtk_check_button_new_with_label ("Activity mode");
7052 gtk_signal_connect (GTK_OBJECT (check), "clicked",
7053 GTK_SIGNAL_FUNC (toggle_activity_mode),
7055 gtk_table_attach (GTK_TABLE (tab), check, 0, 1, 5, 6,
7056 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
7059 hbox = gtk_hbox_new (FALSE, 0);
7060 gtk_table_attach (GTK_TABLE (tab), hbox, 1, 2, 5, 6,
7061 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
7063 label = gtk_label_new ("Step size : ");
7064 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
7065 adj = (GtkAdjustment *) gtk_adjustment_new (3, 1, 20, 1, 5, 0);
7066 pdata->step_spin = gtk_spin_button_new (adj, 0, 0);
7067 gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
7068 GTK_SIGNAL_FUNC (adjust_step), pdata);
7069 gtk_box_pack_start (GTK_BOX (hbox), pdata->step_spin, FALSE, TRUE, 0);
7070 gtk_widget_set_sensitive (pdata->step_spin, FALSE);
7072 hbox = gtk_hbox_new (FALSE, 0);
7073 gtk_table_attach (GTK_TABLE (tab), hbox, 1, 2, 6, 7,
7074 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
7076 label = gtk_label_new ("Blocks : ");
7077 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
7078 adj = (GtkAdjustment *) gtk_adjustment_new (5, 2, 10, 1, 5, 0);
7079 pdata->act_blocks_spin = gtk_spin_button_new (adj, 0, 0);
7080 gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
7081 GTK_SIGNAL_FUNC (adjust_act_blocks), pdata);
7082 gtk_box_pack_start (GTK_BOX (hbox), pdata->act_blocks_spin, FALSE, TRUE,
7084 gtk_widget_set_sensitive (pdata->act_blocks_spin, FALSE);
7086 button = gtk_button_new_with_label ("close");
7087 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
7088 GTK_SIGNAL_FUNC (gtk_widget_destroy),
7089 GTK_OBJECT (pdata->window));
7090 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
7091 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (pdata->window)->action_area),
7092 button, TRUE, TRUE, 0);
7093 gtk_widget_grab_default (button);
7096 if (!GTK_WIDGET_VISIBLE (pdata->window))
7097 gtk_widget_show_all (pdata->window);
7099 gtk_widget_destroy (pdata->window);
7106 static int color_idle = 0;
7109 color_idle_func (GtkWidget *preview)
7111 static int count = 1;
7115 for (i = 0; i < 256; i++)
7117 for (j = 0, k = 0; j < 256; j++)
7119 buf[k+0] = i + count;
7121 buf[k+2] = j + count;
7125 gtk_preview_draw_row (GTK_PREVIEW (preview), buf, 0, i, 256);
7130 gtk_widget_draw (preview, NULL);
7136 color_preview_destroy (GtkWidget *widget,
7139 gtk_idle_remove (color_idle);
7146 create_color_preview (void)
7148 static GtkWidget *window = NULL;
7155 gtk_widget_push_visual (gdk_rgb_get_visual ());
7156 gtk_widget_push_colormap (gdk_rgb_get_cmap ());
7157 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
7158 gtk_widget_pop_colormap ();
7159 gtk_widget_pop_visual ();
7161 gtk_signal_connect (GTK_OBJECT (window), "destroy",
7162 GTK_SIGNAL_FUNC(color_preview_destroy),
7165 gtk_window_set_title (GTK_WINDOW (window), "test");
7166 gtk_container_set_border_width (GTK_CONTAINER (window), 10);
7168 preview = gtk_preview_new (GTK_PREVIEW_COLOR);
7169 gtk_preview_size (GTK_PREVIEW (preview), 256, 256);
7170 gtk_container_add (GTK_CONTAINER (window), preview);
7172 for (i = 0; i < 256; i++)
7174 for (j = 0, k = 0; j < 256; j++)
7182 gtk_preview_draw_row (GTK_PREVIEW (preview), buf, 0, i, 256);
7185 color_idle = gtk_idle_add ((GtkFunction) color_idle_func, preview);
7188 if (!GTK_WIDGET_VISIBLE (window))
7189 gtk_widget_show_all (window);
7191 gtk_widget_destroy (window);
7198 static int gray_idle = 0;
7201 gray_idle_func (GtkWidget *preview)
7203 static int count = 1;
7207 for (i = 0; i < 256; i++)
7209 for (j = 0; j < 256; j++)
7210 buf[j] = i + j + count;
7212 gtk_preview_draw_row (GTK_PREVIEW (preview), buf, 0, i, 256);
7217 gtk_widget_draw (preview, NULL);
7223 gray_preview_destroy (GtkWidget *widget,
7226 gtk_idle_remove (gray_idle);
7233 create_gray_preview (void)
7235 static GtkWidget *window = NULL;
7242 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
7244 gtk_signal_connect (GTK_OBJECT (window), "destroy",
7245 GTK_SIGNAL_FUNC(gray_preview_destroy),
7248 gtk_window_set_title (GTK_WINDOW (window), "test");
7249 gtk_container_set_border_width (GTK_CONTAINER (window), 10);
7251 preview = gtk_preview_new (GTK_PREVIEW_GRAYSCALE);
7252 gtk_preview_size (GTK_PREVIEW (preview), 256, 256);
7253 gtk_container_add (GTK_CONTAINER (window), preview);
7255 for (i = 0; i < 256; i++)
7257 for (j = 0; j < 256; j++)
7260 gtk_preview_draw_row (GTK_PREVIEW (preview), buf, 0, i, 256);
7263 gray_idle = gtk_idle_add ((GtkFunction) gray_idle_func, preview);
7266 if (!GTK_WIDGET_VISIBLE (window))
7267 gtk_widget_show_all (window);
7269 gtk_widget_destroy (window);
7278 selection_test_received (GtkWidget *list, GtkSelectionData *data)
7281 GtkWidget *list_item;
7285 if (data->length < 0)
7287 g_print ("Selection retrieval failed\n");
7290 if (data->type != GDK_SELECTION_TYPE_ATOM)
7292 g_print ("Selection \"TARGETS\" was not returned as atoms!\n");
7296 /* Clear out any current list items */
7298 gtk_list_clear_items (GTK_LIST(list), 0, -1);
7300 /* Add new items to list */
7302 atoms = (GdkAtom *)data->data;
7305 l = data->length / sizeof (GdkAtom);
7306 for (i = 0; i < l; i++)
7309 name = gdk_atom_name (atoms[i]);
7312 list_item = gtk_list_item_new_with_label (name);
7316 list_item = gtk_list_item_new_with_label ("(bad atom)");
7318 gtk_widget_show (list_item);
7319 item_list = g_list_append (item_list, list_item);
7322 gtk_list_append_items (GTK_LIST (list), item_list);
7328 selection_test_get_targets (GtkWidget *widget, GtkWidget *list)
7330 static GdkAtom targets_atom = GDK_NONE;
7332 if (targets_atom == GDK_NONE)
7333 targets_atom = gdk_atom_intern ("TARGETS", FALSE);
7335 gtk_selection_convert (list, GDK_SELECTION_PRIMARY, targets_atom,
7340 create_selection_test (void)
7342 static GtkWidget *window = NULL;
7345 GtkWidget *scrolled_win;
7351 window = gtk_dialog_new ();
7353 gtk_signal_connect (GTK_OBJECT (window), "destroy",
7354 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
7357 gtk_window_set_title (GTK_WINDOW (window), "Selection Test");
7358 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
7360 /* Create the list */
7362 vbox = gtk_vbox_new (FALSE, 5);
7363 gtk_container_set_border_width (GTK_CONTAINER (vbox), 10);
7364 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), vbox,
7367 label = gtk_label_new ("Gets available targets for current selection");
7368 gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
7370 scrolled_win = gtk_scrolled_window_new (NULL, NULL);
7371 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
7372 GTK_POLICY_AUTOMATIC,
7373 GTK_POLICY_AUTOMATIC);
7374 gtk_box_pack_start (GTK_BOX (vbox), scrolled_win, TRUE, TRUE, 0);
7375 gtk_widget_set_usize (scrolled_win, 100, 200);
7377 list = gtk_list_new ();
7378 gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (scrolled_win), list);
7380 gtk_signal_connect (GTK_OBJECT(list), "selection_received",
7381 GTK_SIGNAL_FUNC (selection_test_received), NULL);
7383 /* .. And create some buttons */
7384 button = gtk_button_new_with_label ("Get Targets");
7385 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
7386 button, TRUE, TRUE, 0);
7388 gtk_signal_connect (GTK_OBJECT (button), "clicked",
7389 GTK_SIGNAL_FUNC (selection_test_get_targets), list);
7391 button = gtk_button_new_with_label ("Quit");
7392 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
7393 button, TRUE, TRUE, 0);
7395 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
7396 GTK_SIGNAL_FUNC (gtk_widget_destroy),
7397 GTK_OBJECT (window));
7400 if (!GTK_WIDGET_VISIBLE (window))
7401 gtk_widget_show_all (window);
7403 gtk_widget_destroy (window);
7411 create_gamma_curve (void)
7413 static GtkWidget *window = NULL, *curve;
7414 static int count = 0;
7421 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
7422 gtk_window_set_title (GTK_WINDOW (window), "test");
7423 gtk_container_set_border_width (GTK_CONTAINER (window), 10);
7425 gtk_signal_connect (GTK_OBJECT (window), "destroy",
7426 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
7429 curve = gtk_gamma_curve_new ();
7430 gtk_container_add (GTK_CONTAINER (window), curve);
7431 gtk_widget_show (curve);
7434 max = 127 + (count % 2)*128;
7435 gtk_curve_set_range (GTK_CURVE (GTK_GAMMA_CURVE (curve)->curve),
7437 for (i = 0; i < max; ++i)
7438 vec[i] = (127 / sqrt (max)) * sqrt (i);
7439 gtk_curve_set_vector (GTK_CURVE (GTK_GAMMA_CURVE (curve)->curve),
7442 if (!GTK_WIDGET_VISIBLE (window))
7443 gtk_widget_show (window);
7444 else if (count % 4 == 3)
7446 gtk_widget_destroy (window);
7457 static int scroll_test_pos = 0.0;
7458 static GdkGC *scroll_test_gc = NULL;
7461 scroll_test_expose (GtkWidget *widget, GdkEventExpose *event,
7465 gint imin, imax, jmin, jmax;
7467 imin = (event->area.x) / 10;
7468 imax = (event->area.x + event->area.width + 9) / 10;
7470 jmin = ((int)adj->value + event->area.y) / 10;
7471 jmax = ((int)adj->value + event->area.y + event->area.height + 9) / 10;
7473 gdk_window_clear_area (widget->window,
7474 event->area.x, event->area.y,
7475 event->area.width, event->area.height);
7477 for (i=imin; i<imax; i++)
7478 for (j=jmin; j<jmax; j++)
7480 gdk_draw_rectangle (widget->window,
7481 widget->style->black_gc,
7483 10*i, 10*j - (int)adj->value, 1+i%10, 1+j%10);
7489 scroll_test_configure (GtkWidget *widget, GdkEventConfigure *event,
7492 adj->page_increment = 0.9 * widget->allocation.height;
7493 adj->page_size = widget->allocation.height;
7495 gtk_signal_emit_by_name (GTK_OBJECT (adj), "changed");
7499 scroll_test_adjustment_changed (GtkAdjustment *adj, GtkWidget *widget)
7501 gint source_min = (int)adj->value - scroll_test_pos;
7502 gint source_max = source_min + widget->allocation.height;
7504 gint dest_max = widget->allocation.height;
7508 scroll_test_pos = adj->value;
7510 if (!GTK_WIDGET_DRAWABLE (widget))
7517 rect.width = widget->allocation.width;
7518 rect.height = -source_min;
7519 if (rect.height > widget->allocation.height)
7520 rect.height = widget->allocation.height;
7523 dest_min = rect.height;
7528 rect.y = 2*widget->allocation.height - source_max;
7531 rect.width = widget->allocation.width;
7532 rect.height = widget->allocation.height - rect.y;
7534 source_max = widget->allocation.height;
7538 if (source_min != source_max)
7540 if (scroll_test_gc == NULL)
7542 scroll_test_gc = gdk_gc_new (widget->window);
7543 gdk_gc_set_exposures (scroll_test_gc, TRUE);
7546 gdk_draw_pixmap (widget->window,
7551 widget->allocation.width,
7552 source_max - source_min);
7554 /* Make sure graphics expose events are processed before scrolling
7557 while ((event = gdk_event_get_graphics_expose (widget->window)) != NULL)
7559 gtk_widget_event (widget, event);
7560 if (event->expose.count == 0)
7562 gdk_event_free (event);
7565 gdk_event_free (event);
7569 if (rect.height != 0)
7570 gtk_widget_draw (widget, &rect);
7575 create_scroll_test (void)
7577 static GtkWidget *window = NULL;
7579 GtkWidget *drawing_area;
7580 GtkWidget *scrollbar;
7583 GdkGeometry geometry;
7584 GdkWindowHints geometry_mask;
7588 window = gtk_dialog_new ();
7590 gtk_signal_connect (GTK_OBJECT (window), "destroy",
7591 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
7594 gtk_window_set_title (GTK_WINDOW (window), "Scroll Test");
7595 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
7597 hbox = gtk_hbox_new (FALSE, 0);
7598 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), hbox,
7600 gtk_widget_show (hbox);
7602 drawing_area = gtk_drawing_area_new ();
7603 gtk_drawing_area_size (GTK_DRAWING_AREA (drawing_area), 200, 200);
7604 gtk_box_pack_start (GTK_BOX (hbox), drawing_area, TRUE, TRUE, 0);
7605 gtk_widget_show (drawing_area);
7607 gtk_widget_set_events (drawing_area, GDK_EXPOSURE_MASK);
7609 adj = GTK_ADJUSTMENT (gtk_adjustment_new (0.0, 0.0, 1000.0, 1.0, 180.0, 200.0));
7610 scroll_test_pos = 0.0;
7612 scrollbar = gtk_vscrollbar_new (adj);
7613 gtk_box_pack_start (GTK_BOX (hbox), scrollbar, FALSE, FALSE, 0);
7614 gtk_widget_show (scrollbar);
7616 gtk_signal_connect (GTK_OBJECT (drawing_area), "expose_event",
7617 GTK_SIGNAL_FUNC (scroll_test_expose), adj);
7618 gtk_signal_connect (GTK_OBJECT (drawing_area), "configure_event",
7619 GTK_SIGNAL_FUNC (scroll_test_configure), adj);
7622 gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
7623 GTK_SIGNAL_FUNC (scroll_test_adjustment_changed),
7626 /* .. And create some buttons */
7628 button = gtk_button_new_with_label ("Quit");
7629 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
7630 button, TRUE, TRUE, 0);
7632 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
7633 GTK_SIGNAL_FUNC (gtk_widget_destroy),
7634 GTK_OBJECT (window));
7635 gtk_widget_show (button);
7637 /* Set up gridded geometry */
7639 geometry_mask = GDK_HINT_MIN_SIZE |
7640 GDK_HINT_BASE_SIZE |
7641 GDK_HINT_RESIZE_INC;
7643 geometry.min_width = 20;
7644 geometry.min_height = 20;
7645 geometry.base_width = 0;
7646 geometry.base_height = 0;
7647 geometry.width_inc = 10;
7648 geometry.height_inc = 10;
7650 gtk_window_set_geometry_hints (GTK_WINDOW (window),
7651 drawing_area, &geometry, geometry_mask);
7654 if (!GTK_WIDGET_VISIBLE (window))
7655 gtk_widget_show (window);
7657 gtk_widget_destroy (window);
7664 static int timer = 0;
7667 timeout_test (GtkWidget *label)
7669 static int count = 0;
7670 static char buffer[32];
7672 sprintf (buffer, "count: %d", ++count);
7673 gtk_label_set (GTK_LABEL (label), buffer);
7679 start_timeout_test (GtkWidget *widget,
7684 timer = gtk_timeout_add (100, (GtkFunction) timeout_test, label);
7689 stop_timeout_test (GtkWidget *widget,
7694 gtk_timeout_remove (timer);
7700 destroy_timeout_test (GtkWidget *widget,
7703 stop_timeout_test (NULL, NULL);
7709 create_timeout_test (void)
7711 static GtkWidget *window = NULL;
7717 window = gtk_dialog_new ();
7719 gtk_signal_connect (GTK_OBJECT (window), "destroy",
7720 GTK_SIGNAL_FUNC(destroy_timeout_test),
7723 gtk_window_set_title (GTK_WINDOW (window), "Timeout Test");
7724 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
7726 label = gtk_label_new ("count: 0");
7727 gtk_misc_set_padding (GTK_MISC (label), 10, 10);
7728 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox),
7729 label, TRUE, TRUE, 0);
7730 gtk_widget_show (label);
7732 button = gtk_button_new_with_label ("close");
7733 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
7734 GTK_SIGNAL_FUNC(gtk_widget_destroy),
7735 GTK_OBJECT (window));
7736 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
7737 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
7738 button, TRUE, TRUE, 0);
7739 gtk_widget_grab_default (button);
7740 gtk_widget_show (button);
7742 button = gtk_button_new_with_label ("start");
7743 gtk_signal_connect (GTK_OBJECT (button), "clicked",
7744 GTK_SIGNAL_FUNC(start_timeout_test),
7746 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
7747 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
7748 button, TRUE, TRUE, 0);
7749 gtk_widget_show (button);
7751 button = gtk_button_new_with_label ("stop");
7752 gtk_signal_connect (GTK_OBJECT (button), "clicked",
7753 GTK_SIGNAL_FUNC(stop_timeout_test),
7755 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
7756 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
7757 button, TRUE, TRUE, 0);
7758 gtk_widget_show (button);
7761 if (!GTK_WIDGET_VISIBLE (window))
7762 gtk_widget_show (window);
7764 gtk_widget_destroy (window);
7771 static int idle = 0;
7774 idle_test (GtkWidget *label)
7776 static int count = 0;
7777 static char buffer[32];
7779 sprintf (buffer, "count: %d", ++count);
7780 gtk_label_set (GTK_LABEL (label), buffer);
7786 start_idle_test (GtkWidget *widget,
7791 idle = gtk_idle_add ((GtkFunction) idle_test, label);
7796 stop_idle_test (GtkWidget *widget,
7801 gtk_idle_remove (idle);
7807 destroy_idle_test (GtkWidget *widget,
7810 stop_idle_test (NULL, NULL);
7816 toggle_idle_container (GtkObject *button,
7817 GtkContainer *container)
7819 gtk_container_set_resize_mode (container, (guint) gtk_object_get_user_data (button));
7823 create_idle_test (void)
7825 static GtkWidget *window = NULL;
7828 GtkWidget *container;
7835 window = gtk_dialog_new ();
7837 gtk_signal_connect (GTK_OBJECT (window), "destroy",
7838 GTK_SIGNAL_FUNC(destroy_idle_test),
7841 gtk_window_set_title (GTK_WINDOW (window), "Idle Test");
7842 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
7844 label = gtk_label_new ("count: 0");
7845 gtk_misc_set_padding (GTK_MISC (label), 10, 10);
7846 gtk_widget_show (label);
7849 gtk_widget_new (GTK_TYPE_HBOX,
7850 "GtkWidget::visible", TRUE,
7851 /* "GtkContainer::child", gtk_widget_new (GTK_TYPE_HBOX,
7852 * "GtkWidget::visible", TRUE,
7854 "GtkContainer::child", label,
7857 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox),
7858 container, TRUE, TRUE, 0);
7861 gtk_widget_new (GTK_TYPE_FRAME,
7862 "GtkContainer::border_width", 5,
7863 "GtkFrame::label", "Label Container",
7864 "GtkWidget::visible", TRUE,
7865 "GtkWidget::parent", GTK_DIALOG (window)->vbox,
7868 gtk_widget_new (GTK_TYPE_VBOX,
7869 "GtkWidget::visible", TRUE,
7870 "GtkWidget::parent", frame,
7873 gtk_widget_new (GTK_TYPE_RADIO_BUTTON,
7874 "GtkButton::label", "Resize-Parent",
7875 "GtkObject::user_data", (void*)GTK_RESIZE_PARENT,
7876 "GtkObject::signal::clicked", toggle_idle_container, container,
7877 "GtkWidget::visible", TRUE,
7878 "GtkWidget::parent", box,
7881 gtk_widget_new (GTK_TYPE_RADIO_BUTTON,
7882 "GtkButton::label", "Resize-Queue",
7883 "GtkObject::user_data", (void*)GTK_RESIZE_QUEUE,
7884 "GtkObject::signal::clicked", toggle_idle_container, container,
7885 "GtkRadioButton::group", button,
7886 "GtkWidget::visible", TRUE,
7887 "GtkWidget::parent", box,
7890 gtk_widget_new (GTK_TYPE_RADIO_BUTTON,
7891 "GtkButton::label", "Resize-Immediate",
7892 "GtkObject::user_data", (void*)GTK_RESIZE_IMMEDIATE,
7893 "GtkObject::signal::clicked", toggle_idle_container, container,
7894 "GtkRadioButton::group", button,
7895 "GtkWidget::visible", TRUE,
7896 "GtkWidget::parent", box,
7900 button = gtk_button_new_with_label ("close");
7901 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
7902 GTK_SIGNAL_FUNC(gtk_widget_destroy),
7903 GTK_OBJECT (window));
7904 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
7905 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
7906 button, TRUE, TRUE, 0);
7907 gtk_widget_grab_default (button);
7908 gtk_widget_show (button);
7910 button = gtk_button_new_with_label ("start");
7911 gtk_signal_connect (GTK_OBJECT (button), "clicked",
7912 GTK_SIGNAL_FUNC(start_idle_test),
7914 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
7915 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
7916 button, TRUE, TRUE, 0);
7917 gtk_widget_show (button);
7919 button = gtk_button_new_with_label ("stop");
7920 gtk_signal_connect (GTK_OBJECT (button), "clicked",
7921 GTK_SIGNAL_FUNC(stop_idle_test),
7923 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
7924 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
7925 button, TRUE, TRUE, 0);
7926 gtk_widget_show (button);
7929 if (!GTK_WIDGET_VISIBLE (window))
7930 gtk_widget_show (window);
7932 gtk_widget_destroy (window);
7940 reload_rc_file (void)
7944 if (gtk_rc_reparse_all ())
7946 toplevels = gdk_window_get_toplevels();
7950 gdk_window_get_user_data (toplevels->data, (gpointer *)&widget);
7953 gtk_widget_reset_rc_styles (widget);
7955 toplevels = toplevels->next;
7957 g_list_free (toplevels);
7962 reload_all_rc_files (void)
7964 static GdkAtom atom_rcfiles = GDK_NONE;
7970 atom_rcfiles = gdk_atom_intern("_GTK_READ_RCFILES", FALSE);
7972 for(i = 0; i < 5; i++)
7974 sev.data_format = 32;
7975 sev.message_type = atom_rcfiles;
7976 gdk_event_send_clientmessage_toall ((GdkEvent *) &sev);
7980 create_rc_file (void)
7982 static GtkWidget *window = NULL;
7987 window = gtk_dialog_new ();
7989 gtk_signal_connect (GTK_OBJECT (window), "destroy",
7990 GTK_SIGNAL_FUNC(destroy_idle_test),
7993 gtk_window_set_title (GTK_WINDOW (window), "Reload Rc file");
7994 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
7996 button = gtk_button_new_with_label ("Reload");
7997 gtk_signal_connect (GTK_OBJECT (button), "clicked",
7998 GTK_SIGNAL_FUNC(reload_rc_file), NULL);
7999 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
8000 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
8001 button, TRUE, TRUE, 0);
8002 gtk_widget_grab_default (button);
8003 gtk_widget_show (button);
8005 button = gtk_button_new_with_label ("Reload All");
8006 gtk_signal_connect (GTK_OBJECT (button), "clicked",
8007 GTK_SIGNAL_FUNC(reload_all_rc_files), NULL);
8008 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
8009 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
8010 button, TRUE, TRUE, 0);
8011 gtk_widget_show (button);
8013 button = gtk_button_new_with_label ("Close");
8014 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
8015 GTK_SIGNAL_FUNC(gtk_widget_destroy),
8016 GTK_OBJECT (window));
8017 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
8018 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
8019 button, TRUE, TRUE, 0);
8020 gtk_widget_show (button);
8024 if (!GTK_WIDGET_VISIBLE (window))
8025 gtk_widget_show (window);
8027 gtk_widget_destroy (window);
8031 * Test of recursive mainloop
8035 mainloop_destroyed (GtkWidget *w, GtkWidget **window)
8042 create_mainloop (void)
8044 static GtkWidget *window = NULL;
8050 window = gtk_dialog_new ();
8052 gtk_window_set_title (GTK_WINDOW (window), "Test Main Loop");
8054 gtk_signal_connect (GTK_OBJECT (window), "destroy",
8055 GTK_SIGNAL_FUNC(mainloop_destroyed),
8058 label = gtk_label_new ("In recursive main loop...");
8059 gtk_misc_set_padding (GTK_MISC(label), 20, 20);
8061 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), label,
8063 gtk_widget_show (label);
8065 button = gtk_button_new_with_label ("Leave");
8066 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area), button,
8069 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
8070 GTK_SIGNAL_FUNC (gtk_widget_destroy),
8071 GTK_OBJECT (window));
8073 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
8074 gtk_widget_grab_default (button);
8076 gtk_widget_show (button);
8079 if (!GTK_WIDGET_VISIBLE (window))
8081 gtk_widget_show (window);
8083 g_print ("create_mainloop: start\n");
8085 g_print ("create_mainloop: done\n");
8088 gtk_widget_destroy (window);
8092 layout_expose_handler (GtkWidget *widget, GdkEventExpose *event)
8097 gint imin, imax, jmin, jmax;
8099 layout = GTK_LAYOUT (widget);
8101 imin = (layout->xoffset + event->area.x) / 10;
8102 imax = (layout->xoffset + event->area.x + event->area.width + 9) / 10;
8104 jmin = (layout->yoffset + event->area.y) / 10;
8105 jmax = (layout->yoffset + event->area.y + event->area.height + 9) / 10;
8107 gdk_window_clear_area (widget->window,
8108 event->area.x, event->area.y,
8109 event->area.width, event->area.height);
8111 for (i=imin; i<imax; i++)
8112 for (j=jmin; j<jmax; j++)
8114 gdk_draw_rectangle (layout->bin_window,
8115 widget->style->black_gc,
8117 10*i - layout->xoffset, 10*j - layout->yoffset,
8123 void create_layout (void)
8125 static GtkWidget *window = NULL;
8127 GtkWidget *scrolledwindow;
8136 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
8137 gtk_signal_connect (GTK_OBJECT (window), "destroy",
8138 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
8141 gtk_window_set_title (GTK_WINDOW (window), "Layout");
8142 gtk_widget_set_usize (window, 200, 200);
8144 scrolledwindow = gtk_scrolled_window_new (NULL, NULL);
8146 gtk_container_add (GTK_CONTAINER (window), scrolledwindow);
8148 layout = gtk_layout_new (NULL, NULL);
8149 gtk_container_add (GTK_CONTAINER (scrolledwindow), layout);
8151 gtk_widget_set_events (layout, GDK_EXPOSURE_MASK);
8152 gtk_signal_connect (GTK_OBJECT (layout), "expose_event",
8153 GTK_SIGNAL_FUNC (layout_expose_handler), NULL);
8155 gtk_layout_set_size (GTK_LAYOUT (layout), 1600, 64000);
8157 for (i=0 ; i < 16 ; i++)
8158 for (j=0 ; j < 16 ; j++)
8160 sprintf(buf, "Button %d, %d", i, j);
8162 // button = gtk_button_new_with_label (buf);
8163 button = gtk_combo_new();
8165 button = gtk_label_new (buf);
8167 gtk_layout_put (GTK_LAYOUT (layout), button,
8171 for (i=16; i < 640; i++)
8173 sprintf(buf, "Button %d, %d", i, 0);
8175 button = gtk_button_new_with_label (buf);
8177 button = gtk_label_new (buf);
8179 gtk_layout_put (GTK_LAYOUT (layout), button,
8184 if (!GTK_WIDGET_VISIBLE (window))
8185 gtk_widget_show_all (window);
8187 gtk_widget_destroy (window);
8191 * Main Window and Exit
8195 do_exit (GtkWidget *widget, GtkWidget *window)
8197 gtk_widget_destroy (window);
8202 create_main_window (void)
8209 { "button box", create_button_box },
8210 { "buttons", create_buttons },
8211 { "check buttons", create_check_buttons },
8212 { "clist", create_clist},
8213 { "color selection", create_color_selection },
8214 { "ctree", create_ctree },
8215 { "cursors", create_cursors },
8216 { "dialog", create_dialog },
8217 /* { "dnd", create_dnd }, */
8218 { "entry", create_entry },
8219 { "event watcher", create_event_watcher },
8220 { "file selection", create_file_selection },
8221 { "font selection", create_font_selection },
8222 { "gamma curve", create_gamma_curve },
8223 { "handle box", create_handle_box },
8224 { "item factory", create_item_factory },
8225 { "layout", create_layout },
8226 { "list", create_list },
8227 { "menus", create_menus },
8228 { "modal window", create_modal_window },
8229 { "notebook", create_notebook },
8230 { "panes", create_panes },
8231 { "pixmap", create_pixmap },
8232 { "preview color", create_color_preview },
8233 { "preview gray", create_gray_preview },
8234 { "progress bar", create_progress_bar },
8235 { "radio buttons", create_radio_buttons },
8236 { "range controls", create_range_controls },
8237 { "rc file", create_rc_file },
8238 { "reparent", create_reparent },
8239 { "rulers", create_rulers },
8240 { "saved position", create_saved_position },
8241 { "scrolled windows", create_scrolled_windows },
8242 { "shapes", create_shapes },
8243 { "spinbutton", create_spins },
8244 { "statusbar", create_statusbar },
8245 { "test idle", create_idle_test },
8246 { "test mainloop", create_mainloop },
8247 { "test scrolling", create_scroll_test },
8248 { "test selection", create_selection_test },
8249 { "test timeout", create_timeout_test },
8250 { "text", create_text },
8251 { "toggle buttons", create_toggle_buttons },
8252 { "toolbar", create_toolbar },
8253 { "tooltips", create_tooltips },
8254 { "tree", create_tree_mode_window},
8255 { "WM hints", create_wmhints },
8257 int nbuttons = sizeof (buttons) / sizeof (buttons[0]);
8261 GtkWidget *scrolled_window;
8265 GtkWidget *separator;
8268 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
8269 gtk_window_set_policy (GTK_WINDOW (window), FALSE, FALSE, FALSE);
8270 gtk_widget_set_name (window, "main window");
8271 gtk_widget_set_usize (window, 200, 400);
8272 gtk_widget_set_uposition (window, 20, 20);
8274 gtk_signal_connect (GTK_OBJECT (window), "destroy",
8275 GTK_SIGNAL_FUNC(gtk_main_quit),
8277 gtk_signal_connect (GTK_OBJECT (window), "delete-event",
8278 GTK_SIGNAL_FUNC (gtk_false),
8281 box1 = gtk_vbox_new (FALSE, 0);
8282 gtk_container_add (GTK_CONTAINER (window), box1);
8284 if (gtk_micro_version > 0)
8296 label = gtk_label_new (buffer);
8297 gtk_box_pack_start (GTK_BOX (box1), label, FALSE, FALSE, 0);
8299 scrolled_window = gtk_scrolled_window_new (NULL, NULL);
8300 gtk_container_set_border_width (GTK_CONTAINER (scrolled_window), 10);
8301 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
8302 GTK_POLICY_AUTOMATIC,
8303 GTK_POLICY_AUTOMATIC);
8304 gtk_box_pack_start (GTK_BOX (box1), scrolled_window, TRUE, TRUE, 0);
8306 box2 = gtk_vbox_new (FALSE, 0);
8307 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
8308 gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (scrolled_window), box2);
8309 gtk_container_set_focus_vadjustment (GTK_CONTAINER (box2),
8310 gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (scrolled_window)));
8311 gtk_widget_show (box2);
8313 for (i = 0; i < nbuttons; i++)
8315 button = gtk_button_new_with_label (buttons[i].label);
8316 if (buttons[i].func)
8317 gtk_signal_connect (GTK_OBJECT (button),
8319 GTK_SIGNAL_FUNC(buttons[i].func),
8322 gtk_widget_set_sensitive (button, FALSE);
8323 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
8326 separator = gtk_hseparator_new ();
8327 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
8329 box2 = gtk_vbox_new (FALSE, 10);
8330 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
8331 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
8333 button = gtk_button_new_with_label ("close");
8334 gtk_signal_connect (GTK_OBJECT (button), "clicked",
8335 GTK_SIGNAL_FUNC (do_exit),
8337 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
8338 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
8339 gtk_widget_grab_default (button);
8341 gtk_widget_show_all (window);
8345 main (int argc, char *argv[])
8347 GtkBindingSet *binding_set;
8349 srand (time (NULL));
8353 gtk_rc_add_default_file ("testgtkrc");
8355 gtk_init (&argc, &argv);
8361 binding_set = gtk_binding_set_by_class (gtk_type_class (GTK_TYPE_WIDGET));
8362 gtk_binding_entry_add_signal (binding_set,
8363 '9', GDK_CONTROL_MASK | GDK_RELEASE_MASK,
8366 GTK_TYPE_STRING, "GtkWidgetClass <ctrl><release>9 test");
8368 create_main_window ();