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.
21 * Modified by the GTK+ Team and others 1997-1999. See the AUTHORS
22 * file for a list of people on the GTK+ Team. See the ChangeLog
23 * files for a list of changes. These files are distributed with
24 * GTK+ at ftp://ftp.gtk.org/pub/gtk/.
43 #include "gdk/gdkkeysyms.h"
45 #include "circles.xbm"
48 typedef struct _OptionMenuItem
55 file_exists (const char *filename)
59 return stat (filename, &statbuf) == 0;
63 shape_create_icon (char *xpm_file,
71 build_option_menu (OptionMenuItem items[],
76 /* macro, structure and variables used by tree window demos */
77 #define DEFAULT_NUMBER_OF_ITEM 3
78 #define DEFAULT_RECURSION_LEVEL 3
81 GSList* selection_mode_group;
82 GtkWidget* single_button;
83 GtkWidget* browse_button;
84 GtkWidget* multiple_button;
85 GtkWidget* draw_line_button;
86 GtkWidget* view_line_button;
87 GtkWidget* no_root_item_button;
88 GtkWidget* nb_item_spinner;
89 GtkWidget* recursion_spinner;
90 } sTreeSampleSelection;
92 typedef struct sTreeButtons {
94 GtkWidget* add_button;
95 GtkWidget* remove_button;
96 GtkWidget* subtree_button;
98 /* end of tree section */
101 build_option_menu (OptionMenuItem items[],
108 GtkWidget *menu_item;
112 omenu = gtk_option_menu_new ();
114 menu = gtk_menu_new ();
117 for (i = 0; i < num_items; i++)
119 menu_item = gtk_radio_menu_item_new_with_label (group, items[i].name);
120 gtk_signal_connect (GTK_OBJECT (menu_item), "activate",
121 (GtkSignalFunc) items[i].func, data);
122 group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menu_item));
123 gtk_menu_append (GTK_MENU (menu), menu_item);
125 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (menu_item), TRUE);
126 gtk_widget_show (menu_item);
129 gtk_option_menu_set_menu (GTK_OPTION_MENU (omenu), menu);
130 gtk_option_menu_set_history (GTK_OPTION_MENU (omenu), history);
136 destroy_tooltips (GtkWidget *widget, GtkWindow **window)
138 GtkTooltips *tt = gtk_object_get_data (GTK_OBJECT (*window), "tooltips");
139 gtk_object_unref (GTK_OBJECT (tt));
148 button_window (GtkWidget *widget,
151 if (!GTK_WIDGET_VISIBLE (button))
152 gtk_widget_show (button);
154 gtk_widget_hide (button);
158 create_buttons (void)
160 static GtkWidget *window = NULL;
164 GtkWidget *button[10];
165 GtkWidget *separator;
169 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
171 gtk_signal_connect (GTK_OBJECT (window), "destroy",
172 GTK_SIGNAL_FUNC (gtk_widget_destroyed),
175 gtk_window_set_title (GTK_WINDOW (window), "GtkButton");
176 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
178 box1 = gtk_vbox_new (FALSE, 0);
179 gtk_container_add (GTK_CONTAINER (window), box1);
181 table = gtk_table_new (3, 3, FALSE);
182 gtk_table_set_row_spacings (GTK_TABLE (table), 5);
183 gtk_table_set_col_spacings (GTK_TABLE (table), 5);
184 gtk_container_set_border_width (GTK_CONTAINER (table), 10);
185 gtk_box_pack_start (GTK_BOX (box1), table, TRUE, TRUE, 0);
187 button[0] = gtk_button_new_with_label ("button1");
188 button[1] = gtk_button_new_with_label ("button2");
189 button[2] = gtk_button_new_with_label ("button3");
190 button[3] = gtk_button_new_with_label ("button4");
191 button[4] = gtk_button_new_with_label ("button5");
192 button[5] = gtk_button_new_with_label ("button6");
193 button[6] = gtk_button_new_with_label ("button7");
194 button[7] = gtk_button_new_with_label ("button8");
195 button[8] = gtk_button_new_with_label ("button9");
197 gtk_signal_connect (GTK_OBJECT (button[0]), "clicked",
198 GTK_SIGNAL_FUNC(button_window),
201 gtk_table_attach (GTK_TABLE (table), button[0], 0, 1, 0, 1,
202 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
204 gtk_signal_connect (GTK_OBJECT (button[1]), "clicked",
205 GTK_SIGNAL_FUNC(button_window),
208 gtk_table_attach (GTK_TABLE (table), button[1], 1, 2, 1, 2,
209 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
211 gtk_signal_connect (GTK_OBJECT (button[2]), "clicked",
212 GTK_SIGNAL_FUNC(button_window),
214 gtk_table_attach (GTK_TABLE (table), button[2], 2, 3, 2, 3,
215 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
217 gtk_signal_connect (GTK_OBJECT (button[3]), "clicked",
218 GTK_SIGNAL_FUNC(button_window),
220 gtk_table_attach (GTK_TABLE (table), button[3], 0, 1, 2, 3,
221 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
223 gtk_signal_connect (GTK_OBJECT (button[4]), "clicked",
224 GTK_SIGNAL_FUNC(button_window),
226 gtk_table_attach (GTK_TABLE (table), button[4], 2, 3, 0, 1,
227 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
229 gtk_signal_connect (GTK_OBJECT (button[5]), "clicked",
230 GTK_SIGNAL_FUNC(button_window),
232 gtk_table_attach (GTK_TABLE (table), button[5], 1, 2, 2, 3,
233 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
235 gtk_signal_connect (GTK_OBJECT (button[6]), "clicked",
236 GTK_SIGNAL_FUNC(button_window),
238 gtk_table_attach (GTK_TABLE (table), button[6], 1, 2, 0, 1,
239 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
241 gtk_signal_connect (GTK_OBJECT (button[7]), "clicked",
242 GTK_SIGNAL_FUNC(button_window),
244 gtk_table_attach (GTK_TABLE (table), button[7], 2, 3, 1, 2,
245 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
247 gtk_signal_connect (GTK_OBJECT (button[8]), "clicked",
248 GTK_SIGNAL_FUNC(button_window),
250 gtk_table_attach (GTK_TABLE (table), button[8], 0, 1, 1, 2,
251 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
253 separator = gtk_hseparator_new ();
254 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
256 box2 = gtk_vbox_new (FALSE, 10);
257 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
258 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
260 button[9] = gtk_button_new_with_label ("close");
261 gtk_signal_connect_object (GTK_OBJECT (button[9]), "clicked",
262 GTK_SIGNAL_FUNC(gtk_widget_destroy),
263 GTK_OBJECT (window));
264 gtk_box_pack_start (GTK_BOX (box2), button[9], TRUE, TRUE, 0);
265 GTK_WIDGET_SET_FLAGS (button[9], GTK_CAN_DEFAULT);
266 gtk_widget_grab_default (button[9]);
269 if (!GTK_WIDGET_VISIBLE (window))
270 gtk_widget_show_all (window);
272 gtk_widget_hide (window);
280 create_toggle_buttons (void)
282 static GtkWidget *window = NULL;
286 GtkWidget *separator;
290 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
292 gtk_signal_connect (GTK_OBJECT (window), "destroy",
293 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
296 gtk_window_set_title (GTK_WINDOW (window), "GtkToggleButton");
297 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
299 box1 = gtk_vbox_new (FALSE, 0);
300 gtk_container_add (GTK_CONTAINER (window), box1);
302 box2 = gtk_vbox_new (FALSE, 10);
303 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
304 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
306 button = gtk_toggle_button_new_with_label ("button1");
307 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
309 button = gtk_toggle_button_new_with_label ("button2");
310 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
312 button = gtk_toggle_button_new_with_label ("button3");
313 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
315 separator = gtk_hseparator_new ();
316 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
318 box2 = gtk_vbox_new (FALSE, 10);
319 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
320 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
322 button = gtk_button_new_with_label ("close");
323 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
324 GTK_SIGNAL_FUNC(gtk_widget_destroy),
325 GTK_OBJECT (window));
326 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
327 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
328 gtk_widget_grab_default (button);
331 if (!GTK_WIDGET_VISIBLE (window))
332 gtk_widget_show_all (window);
334 gtk_widget_destroy (window);
342 create_check_buttons (void)
344 static GtkWidget *window = NULL;
348 GtkWidget *separator;
352 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
354 gtk_signal_connect (GTK_OBJECT (window), "destroy",
355 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
358 gtk_window_set_title (GTK_WINDOW (window), "GtkCheckButton");
359 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
361 box1 = gtk_vbox_new (FALSE, 0);
362 gtk_container_add (GTK_CONTAINER (window), box1);
364 box2 = gtk_vbox_new (FALSE, 10);
365 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
366 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
368 button = gtk_check_button_new_with_label ("button1");
369 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
371 button = gtk_check_button_new_with_label ("button2");
372 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
374 button = gtk_check_button_new_with_label ("button3");
375 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
377 separator = gtk_hseparator_new ();
378 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
380 box2 = gtk_vbox_new (FALSE, 10);
381 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
382 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
384 button = gtk_button_new_with_label ("close");
385 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
386 GTK_SIGNAL_FUNC(gtk_widget_destroy),
387 GTK_OBJECT (window));
388 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
389 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
390 gtk_widget_grab_default (button);
393 if (!GTK_WIDGET_VISIBLE (window))
394 gtk_widget_show_all (window);
396 gtk_widget_destroy (window);
404 create_radio_buttons (void)
406 static GtkWidget *window = NULL;
410 GtkWidget *separator;
414 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
416 gtk_signal_connect (GTK_OBJECT (window), "destroy",
417 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
420 gtk_window_set_title (GTK_WINDOW (window), "radio buttons");
421 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
423 box1 = gtk_vbox_new (FALSE, 0);
424 gtk_container_add (GTK_CONTAINER (window), box1);
426 box2 = gtk_vbox_new (FALSE, 10);
427 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
428 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
430 button = gtk_radio_button_new_with_label (NULL, "button1");
431 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
433 button = gtk_radio_button_new_with_label (
434 gtk_radio_button_group (GTK_RADIO_BUTTON (button)),
436 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
437 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
439 button = gtk_radio_button_new_with_label (
440 gtk_radio_button_group (GTK_RADIO_BUTTON (button)),
442 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
444 separator = gtk_hseparator_new ();
445 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
447 box2 = gtk_vbox_new (FALSE, 10);
448 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
449 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
451 button = gtk_button_new_with_label ("close");
452 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
453 GTK_SIGNAL_FUNC(gtk_widget_destroy),
454 GTK_OBJECT (window));
455 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
456 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
457 gtk_widget_grab_default (button);
460 if (!GTK_WIDGET_VISIBLE (window))
461 gtk_widget_show_all (window);
463 gtk_widget_destroy (window);
471 create_bbox (gint horizontal,
482 frame = gtk_frame_new (title);
485 bbox = gtk_hbutton_box_new ();
487 bbox = gtk_vbutton_box_new ();
489 gtk_container_set_border_width (GTK_CONTAINER (bbox), 5);
490 gtk_container_add (GTK_CONTAINER (frame), bbox);
492 gtk_button_box_set_layout (GTK_BUTTON_BOX (bbox), layout);
493 gtk_button_box_set_spacing (GTK_BUTTON_BOX (bbox), spacing);
494 gtk_button_box_set_child_size (GTK_BUTTON_BOX (bbox), child_w, child_h);
496 button = gtk_button_new_with_label ("OK");
497 gtk_container_add (GTK_CONTAINER (bbox), button);
499 button = gtk_button_new_with_label ("Cancel");
500 gtk_container_add (GTK_CONTAINER (bbox), button);
502 button = gtk_button_new_with_label ("Help");
503 gtk_container_add (GTK_CONTAINER (bbox), button);
509 create_button_box (void)
511 static GtkWidget* window = NULL;
512 GtkWidget *main_vbox;
515 GtkWidget *frame_horz;
516 GtkWidget *frame_vert;
520 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
521 gtk_window_set_title (GTK_WINDOW (window), "Button Boxes");
523 gtk_signal_connect (GTK_OBJECT (window), "destroy",
524 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
527 gtk_container_set_border_width (GTK_CONTAINER (window), 10);
529 main_vbox = gtk_vbox_new (FALSE, 0);
530 gtk_container_add (GTK_CONTAINER (window), main_vbox);
532 frame_horz = gtk_frame_new ("Horizontal Button Boxes");
533 gtk_box_pack_start (GTK_BOX (main_vbox), frame_horz, TRUE, TRUE, 10);
535 vbox = gtk_vbox_new (FALSE, 0);
536 gtk_container_set_border_width (GTK_CONTAINER (vbox), 10);
537 gtk_container_add (GTK_CONTAINER (frame_horz), vbox);
539 gtk_box_pack_start (GTK_BOX (vbox),
540 create_bbox (TRUE, "Spread", 40, 85, 20, GTK_BUTTONBOX_SPREAD),
543 gtk_box_pack_start (GTK_BOX (vbox),
544 create_bbox (TRUE, "Edge", 40, 85, 20, GTK_BUTTONBOX_EDGE),
547 gtk_box_pack_start (GTK_BOX (vbox),
548 create_bbox (TRUE, "Start", 40, 85, 20, GTK_BUTTONBOX_START),
551 gtk_box_pack_start (GTK_BOX (vbox),
552 create_bbox (TRUE, "End", 40, 85, 20, GTK_BUTTONBOX_END),
555 frame_vert = gtk_frame_new ("Vertical Button Boxes");
556 gtk_box_pack_start (GTK_BOX (main_vbox), frame_vert, TRUE, TRUE, 10);
558 hbox = gtk_hbox_new (FALSE, 0);
559 gtk_container_set_border_width (GTK_CONTAINER (hbox), 10);
560 gtk_container_add (GTK_CONTAINER (frame_vert), hbox);
562 gtk_box_pack_start (GTK_BOX (hbox),
563 create_bbox (FALSE, "Spread", 30, 85, 20, GTK_BUTTONBOX_SPREAD),
566 gtk_box_pack_start (GTK_BOX (hbox),
567 create_bbox (FALSE, "Edge", 30, 85, 20, GTK_BUTTONBOX_EDGE),
570 gtk_box_pack_start (GTK_BOX (hbox),
571 create_bbox (FALSE, "Start", 30, 85, 20, GTK_BUTTONBOX_START),
574 gtk_box_pack_start (GTK_BOX (hbox),
575 create_bbox (FALSE, "End", 30, 85, 20, GTK_BUTTONBOX_END),
579 if (!GTK_WIDGET_VISIBLE (window))
580 gtk_widget_show_all (window);
582 gtk_widget_destroy (window);
590 new_pixmap (char *filename,
592 GdkColor *background)
598 if (strcmp (filename, "test.xpm") == 0 ||
599 !file_exists (filename))
601 pixmap = gdk_pixmap_create_from_xpm_d (window, &mask,
606 pixmap = gdk_pixmap_create_from_xpm (window, &mask,
610 wpixmap = gtk_pixmap_new (pixmap, mask);
616 set_toolbar_horizontal (GtkWidget *widget,
619 gtk_toolbar_set_orientation (GTK_TOOLBAR (data), GTK_ORIENTATION_HORIZONTAL);
623 set_toolbar_vertical (GtkWidget *widget,
626 gtk_toolbar_set_orientation (GTK_TOOLBAR (data), GTK_ORIENTATION_VERTICAL);
630 set_toolbar_icons (GtkWidget *widget,
633 gtk_toolbar_set_style (GTK_TOOLBAR (data), GTK_TOOLBAR_ICONS);
637 set_toolbar_text (GtkWidget *widget,
640 gtk_toolbar_set_style (GTK_TOOLBAR (data), GTK_TOOLBAR_TEXT);
644 set_toolbar_both (GtkWidget *widget,
647 gtk_toolbar_set_style (GTK_TOOLBAR (data), GTK_TOOLBAR_BOTH);
651 set_toolbar_both_horiz (GtkWidget *widget,
654 gtk_toolbar_set_style (GTK_TOOLBAR (data), GTK_TOOLBAR_BOTH_HORIZ);
658 set_toolbar_small_space (GtkWidget *widget,
661 gtk_toolbar_set_space_size (GTK_TOOLBAR (data), 5);
665 set_toolbar_big_space (GtkWidget *widget,
668 gtk_toolbar_set_space_size (GTK_TOOLBAR (data), 10);
672 set_toolbar_enable (GtkWidget *widget,
675 gtk_toolbar_set_tooltips (GTK_TOOLBAR (data), TRUE);
679 set_toolbar_disable (GtkWidget *widget,
682 gtk_toolbar_set_tooltips (GTK_TOOLBAR (data), FALSE);
686 set_toolbar_borders (GtkWidget *widget,
689 gtk_toolbar_set_button_relief (GTK_TOOLBAR (data), GTK_RELIEF_NORMAL);
693 set_toolbar_borderless (GtkWidget *widget,
696 gtk_toolbar_set_button_relief (GTK_TOOLBAR (data), GTK_RELIEF_NONE);
700 set_toolbar_space_style_empty (GtkWidget *widget,
703 gtk_toolbar_set_space_style (GTK_TOOLBAR (data), GTK_TOOLBAR_SPACE_EMPTY);
707 set_toolbar_space_style_line (GtkWidget *widget,
710 gtk_toolbar_set_space_style (GTK_TOOLBAR (data), GTK_TOOLBAR_SPACE_LINE);
714 create_toolbar (void)
716 static GtkWidget *window = NULL;
722 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
723 gtk_window_set_title (GTK_WINDOW (window), "Toolbar test");
724 gtk_window_set_policy (GTK_WINDOW (window), FALSE, TRUE, TRUE);
726 gtk_signal_connect (GTK_OBJECT (window), "destroy",
727 GTK_SIGNAL_FUNC (gtk_widget_destroyed),
730 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
731 gtk_widget_realize (window);
733 toolbar = gtk_toolbar_new (GTK_ORIENTATION_HORIZONTAL, GTK_TOOLBAR_BOTH);
734 gtk_toolbar_set_button_relief (GTK_TOOLBAR (toolbar), GTK_RELIEF_NONE);
736 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
737 "Horizontal", "Horizontal toolbar layout", "Toolbar/Horizontal",
738 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
739 (GtkSignalFunc) set_toolbar_horizontal, toolbar);
740 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
741 "Vertical", "Vertical toolbar layout", "Toolbar/Vertical",
742 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
743 (GtkSignalFunc) set_toolbar_vertical, toolbar);
745 gtk_toolbar_append_space (GTK_TOOLBAR(toolbar));
747 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
748 "Icons", "Only show toolbar icons", "Toolbar/IconsOnly",
749 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
750 (GtkSignalFunc) set_toolbar_icons, toolbar);
751 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
752 "Text", "Only show toolbar text", "Toolbar/TextOnly",
753 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
754 (GtkSignalFunc) set_toolbar_text, toolbar);
755 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
756 "Both", "Show toolbar icons and text", "Toolbar/Both",
757 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
758 (GtkSignalFunc) set_toolbar_both, toolbar);
759 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
761 "Show toolbar icons and text in a horizontal fashion",
763 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
764 (GtkSignalFunc) set_toolbar_both_horiz, toolbar);
766 gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
768 entry = gtk_entry_new ();
770 gtk_toolbar_append_widget (GTK_TOOLBAR (toolbar), entry, "This is an unusable GtkEntry ;)", "Hey don't click me!!!");
772 gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
774 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
775 "Small", "Use small spaces", "Toolbar/Small",
776 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
777 (GtkSignalFunc) set_toolbar_small_space, toolbar);
778 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
779 "Big", "Use big spaces", "Toolbar/Big",
780 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
781 (GtkSignalFunc) set_toolbar_big_space, toolbar);
783 gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
785 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
786 "Enable", "Enable tooltips", NULL,
787 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
788 (GtkSignalFunc) set_toolbar_enable, toolbar);
789 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
790 "Disable", "Disable tooltips", NULL,
791 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
792 (GtkSignalFunc) set_toolbar_disable, toolbar);
794 gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
796 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
797 "Borders", "Show Borders", NULL,
798 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
799 (GtkSignalFunc) set_toolbar_borders, toolbar);
800 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
801 "Borderless", "Hide Borders", NULL,
802 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
803 (GtkSignalFunc) set_toolbar_borderless, toolbar);
805 gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
807 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
808 "Empty", "Empty spaces", NULL,
809 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
810 (GtkSignalFunc) set_toolbar_space_style_empty, toolbar);
811 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
812 "Lines", "Lines in spaces", NULL,
813 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
814 (GtkSignalFunc) set_toolbar_space_style_line, toolbar);
816 gtk_container_add (GTK_CONTAINER (window), toolbar);
819 if (!GTK_WIDGET_VISIBLE (window))
820 gtk_widget_show_all (window);
822 gtk_widget_destroy (window);
826 make_toolbar (GtkWidget *window)
830 if (!GTK_WIDGET_REALIZED (window))
831 gtk_widget_realize (window);
833 toolbar = gtk_toolbar_new (GTK_ORIENTATION_HORIZONTAL, GTK_TOOLBAR_BOTH);
834 gtk_toolbar_set_button_relief (GTK_TOOLBAR (toolbar), GTK_RELIEF_NONE);
836 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
837 "Horizontal", "Horizontal toolbar layout", NULL,
838 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
839 (GtkSignalFunc) set_toolbar_horizontal, toolbar);
840 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
841 "Vertical", "Vertical toolbar layout", NULL,
842 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
843 (GtkSignalFunc) set_toolbar_vertical, toolbar);
845 gtk_toolbar_append_space (GTK_TOOLBAR(toolbar));
847 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
848 "Icons", "Only show toolbar icons", NULL,
849 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
850 (GtkSignalFunc) set_toolbar_icons, toolbar);
851 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
852 "Text", "Only show toolbar text", NULL,
853 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
854 (GtkSignalFunc) set_toolbar_text, toolbar);
855 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
856 "Both", "Show toolbar icons and text", NULL,
857 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
858 (GtkSignalFunc) set_toolbar_both, toolbar);
860 gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
862 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
863 "Small", "Use small spaces", NULL,
864 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
865 (GtkSignalFunc) set_toolbar_small_space, toolbar);
866 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
867 "Big", "Use big spaces", "Toolbar/Big",
868 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
869 (GtkSignalFunc) set_toolbar_big_space, toolbar);
871 gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
873 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
874 "Enable", "Enable tooltips", NULL,
875 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
876 (GtkSignalFunc) set_toolbar_enable, toolbar);
877 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
878 "Disable", "Disable tooltips", NULL,
879 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
880 (GtkSignalFunc) set_toolbar_disable, toolbar);
882 gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
884 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
885 "Borders", "Show Borders", NULL,
886 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
887 (GtkSignalFunc) set_toolbar_borders, toolbar);
888 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
889 "Borderless", "Hide Borders", NULL,
890 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
891 (GtkSignalFunc) set_toolbar_borderless, toolbar);
900 static guint statusbar_counter = 1;
903 statusbar_push (GtkWidget *button,
904 GtkStatusbar *statusbar)
908 sprintf (text, "something %d", statusbar_counter++);
910 gtk_statusbar_push (statusbar, 1, text);
914 statusbar_pop (GtkWidget *button,
915 GtkStatusbar *statusbar)
917 gtk_statusbar_pop (statusbar, 1);
921 statusbar_steal (GtkWidget *button,
922 GtkStatusbar *statusbar)
924 gtk_statusbar_remove (statusbar, 1, 4);
928 statusbar_popped (GtkStatusbar *statusbar,
932 if (!statusbar->messages)
933 statusbar_counter = 1;
937 statusbar_contexts (GtkStatusbar *statusbar)
941 string = "any context";
942 g_print ("GtkStatusBar: context=\"%s\", context_id=%d\n",
944 gtk_statusbar_get_context_id (statusbar, string));
946 string = "idle messages";
947 g_print ("GtkStatusBar: context=\"%s\", context_id=%d\n",
949 gtk_statusbar_get_context_id (statusbar, string));
951 string = "some text";
952 g_print ("GtkStatusBar: context=\"%s\", context_id=%d\n",
954 gtk_statusbar_get_context_id (statusbar, string));
956 string = "hit the mouse";
957 g_print ("GtkStatusBar: context=\"%s\", context_id=%d\n",
959 gtk_statusbar_get_context_id (statusbar, string));
961 string = "hit the mouse2";
962 g_print ("GtkStatusBar: context=\"%s\", context_id=%d\n",
964 gtk_statusbar_get_context_id (statusbar, string));
968 statusbar_dump_stack (GtkStatusbar *statusbar)
972 for (list = statusbar->messages; list; list = list->next)
974 GtkStatusbarMsg *msg;
977 g_print ("context_id: %d, message_id: %d, status_text: \"%s\"\n",
985 create_statusbar (void)
987 static GtkWidget *window = NULL;
991 GtkWidget *separator;
992 GtkWidget *statusbar;
996 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
998 gtk_signal_connect (GTK_OBJECT (window), "destroy",
999 GTK_SIGNAL_FUNC (gtk_widget_destroyed),
1002 gtk_window_set_title (GTK_WINDOW (window), "statusbar");
1003 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
1005 box1 = gtk_vbox_new (FALSE, 0);
1006 gtk_container_add (GTK_CONTAINER (window), box1);
1008 box2 = gtk_vbox_new (FALSE, 10);
1009 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
1010 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
1012 statusbar = gtk_statusbar_new ();
1013 gtk_box_pack_end (GTK_BOX (box1), statusbar, TRUE, TRUE, 0);
1014 gtk_signal_connect (GTK_OBJECT (statusbar),
1016 GTK_SIGNAL_FUNC (statusbar_popped),
1019 button = gtk_widget_new (gtk_button_get_type (),
1020 "label", "push something",
1023 "signal::clicked", statusbar_push, statusbar,
1026 button = gtk_widget_new (gtk_button_get_type (),
1030 "signal_after::clicked", statusbar_pop, statusbar,
1033 button = gtk_widget_new (gtk_button_get_type (),
1034 "label", "steal #4",
1037 "signal_after::clicked", statusbar_steal, statusbar,
1040 button = gtk_widget_new (gtk_button_get_type (),
1041 "label", "dump stack",
1044 "object_signal::clicked", statusbar_dump_stack, statusbar,
1047 button = gtk_widget_new (gtk_button_get_type (),
1048 "label", "test contexts",
1051 "object_signal_after::clicked", statusbar_contexts, statusbar,
1054 separator = gtk_hseparator_new ();
1055 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
1057 box2 = gtk_vbox_new (FALSE, 10);
1058 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
1059 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
1061 button = gtk_button_new_with_label ("close");
1062 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
1063 GTK_SIGNAL_FUNC(gtk_widget_destroy),
1064 GTK_OBJECT (window));
1065 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
1066 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
1067 gtk_widget_grab_default (button);
1070 if (!GTK_WIDGET_VISIBLE (window))
1071 gtk_widget_show_all (window);
1073 gtk_widget_destroy (window);
1081 cb_tree_destroy_event(GtkWidget* w)
1083 sTreeButtons* tree_buttons;
1085 /* free buttons structure associate at this tree */
1086 tree_buttons = gtk_object_get_user_data (GTK_OBJECT (w));
1087 g_free (tree_buttons);
1091 cb_add_new_item(GtkWidget* w, GtkTree* tree)
1093 sTreeButtons* tree_buttons;
1094 GList* selected_list;
1095 GtkWidget* selected_item;
1097 GtkWidget* item_new;
1100 tree_buttons = gtk_object_get_user_data(GTK_OBJECT(tree));
1102 selected_list = GTK_TREE_SELECTION(tree);
1104 if(selected_list == NULL)
1106 /* there is no item in tree */
1107 subtree = GTK_WIDGET(tree);
1111 /* list can have only one element */
1112 selected_item = GTK_WIDGET(selected_list->data);
1114 subtree = GTK_TREE_ITEM_SUBTREE(selected_item);
1118 /* current selected item have not subtree ... create it */
1119 subtree = gtk_tree_new();
1120 gtk_tree_item_set_subtree(GTK_TREE_ITEM(selected_item),
1125 /* at this point, we know which subtree will be used to add new item */
1126 /* create a new item */
1127 sprintf(buffer, "item add %d", tree_buttons->nb_item_add);
1128 item_new = gtk_tree_item_new_with_label(buffer);
1129 gtk_tree_append(GTK_TREE(subtree), item_new);
1130 gtk_widget_show(item_new);
1132 tree_buttons->nb_item_add++;
1136 cb_remove_item(GtkWidget*w, GtkTree* tree)
1138 GList* selected_list;
1141 selected_list = GTK_TREE_SELECTION(tree);
1145 while (selected_list)
1147 clear_list = g_list_prepend (clear_list, selected_list->data);
1148 selected_list = selected_list->next;
1151 clear_list = g_list_reverse (clear_list);
1152 gtk_tree_remove_items(tree, clear_list);
1154 g_list_free (clear_list);
1158 cb_remove_subtree(GtkWidget*w, GtkTree* tree)
1160 GList* selected_list;
1163 selected_list = GTK_TREE_SELECTION(tree);
1167 item = GTK_TREE_ITEM (selected_list->data);
1169 gtk_tree_item_remove_subtree (item);
1174 cb_tree_changed(GtkTree* tree)
1176 sTreeButtons* tree_buttons;
1177 GList* selected_list;
1180 tree_buttons = gtk_object_get_user_data(GTK_OBJECT(tree));
1182 selected_list = GTK_TREE_SELECTION(tree);
1183 nb_selected = g_list_length(selected_list);
1185 if(nb_selected == 0)
1187 if(tree->children == NULL)
1188 gtk_widget_set_sensitive(tree_buttons->add_button, TRUE);
1190 gtk_widget_set_sensitive(tree_buttons->add_button, FALSE);
1191 gtk_widget_set_sensitive(tree_buttons->remove_button, FALSE);
1192 gtk_widget_set_sensitive(tree_buttons->subtree_button, FALSE);
1196 gtk_widget_set_sensitive(tree_buttons->remove_button, TRUE);
1197 gtk_widget_set_sensitive(tree_buttons->add_button, (nb_selected == 1));
1198 gtk_widget_set_sensitive(tree_buttons->subtree_button, (nb_selected == 1));
1203 create_subtree(GtkWidget* item, guint level, guint nb_item_max, guint recursion_level_max)
1205 GtkWidget* item_subtree;
1206 GtkWidget* item_new;
1211 if(level == recursion_level_max) return;
1215 /* query with no root item */
1217 item_subtree = item;
1222 /* query with no root item */
1223 /* create subtree and associate it with current item */
1224 item_subtree = gtk_tree_new();
1228 for(nb_item = 0; nb_item < nb_item_max; nb_item++)
1230 sprintf(buffer, "item %d-%d", level, nb_item);
1231 item_new = gtk_tree_item_new_with_label(buffer);
1232 gtk_tree_append(GTK_TREE(item_subtree), item_new);
1233 create_subtree(item_new, level+1, nb_item_max, recursion_level_max);
1234 gtk_widget_show(item_new);
1238 gtk_tree_item_set_subtree(GTK_TREE_ITEM(item), item_subtree);
1242 create_tree_sample(guint selection_mode,
1243 guint draw_line, guint view_line, guint no_root_item,
1244 guint nb_item_max, guint recursion_level_max)
1249 GtkWidget* separator;
1251 GtkWidget* scrolled_win;
1252 GtkWidget* root_tree;
1253 GtkWidget* root_item;
1254 sTreeButtons* tree_buttons;
1256 /* create tree buttons struct */
1257 if ((tree_buttons = g_malloc (sizeof (sTreeButtons))) == NULL)
1259 g_error("can't allocate memory for tree structure !\n");
1262 tree_buttons->nb_item_add = 0;
1264 /* create top level window */
1265 window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
1266 gtk_window_set_title(GTK_WINDOW(window), "Tree Sample");
1267 gtk_signal_connect(GTK_OBJECT(window), "destroy",
1268 (GtkSignalFunc) cb_tree_destroy_event, NULL);
1269 gtk_object_set_user_data(GTK_OBJECT(window), tree_buttons);
1271 box1 = gtk_vbox_new(FALSE, 0);
1272 gtk_container_add(GTK_CONTAINER(window), box1);
1273 gtk_widget_show(box1);
1275 /* create tree box */
1276 box2 = gtk_vbox_new(FALSE, 0);
1277 gtk_box_pack_start(GTK_BOX(box1), box2, TRUE, TRUE, 0);
1278 gtk_container_set_border_width(GTK_CONTAINER(box2), 5);
1279 gtk_widget_show(box2);
1281 /* create scrolled window */
1282 scrolled_win = gtk_scrolled_window_new (NULL, NULL);
1283 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
1284 GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
1285 gtk_box_pack_start (GTK_BOX (box2), scrolled_win, TRUE, TRUE, 0);
1286 gtk_widget_set_usize (scrolled_win, 200, 200);
1287 gtk_widget_show (scrolled_win);
1289 /* create root tree widget */
1290 root_tree = gtk_tree_new();
1291 gtk_signal_connect(GTK_OBJECT(root_tree), "selection_changed",
1292 (GtkSignalFunc)cb_tree_changed,
1294 gtk_object_set_user_data(GTK_OBJECT(root_tree), tree_buttons);
1295 gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (scrolled_win), root_tree);
1296 gtk_tree_set_selection_mode(GTK_TREE(root_tree), selection_mode);
1297 gtk_tree_set_view_lines(GTK_TREE(root_tree), draw_line);
1298 gtk_tree_set_view_mode(GTK_TREE(root_tree), !view_line);
1299 gtk_widget_show(root_tree);
1303 /* set root tree to subtree function with root item variable */
1304 root_item = GTK_WIDGET(root_tree);
1308 /* create root tree item widget */
1309 root_item = gtk_tree_item_new_with_label("root item");
1310 gtk_tree_append(GTK_TREE(root_tree), root_item);
1311 gtk_widget_show(root_item);
1313 create_subtree(root_item, -no_root_item, nb_item_max, recursion_level_max);
1315 box2 = gtk_vbox_new(FALSE, 0);
1316 gtk_box_pack_start(GTK_BOX(box1), box2, FALSE, FALSE, 0);
1317 gtk_container_set_border_width(GTK_CONTAINER(box2), 5);
1318 gtk_widget_show(box2);
1320 button = gtk_button_new_with_label("Add Item");
1321 gtk_widget_set_sensitive(button, FALSE);
1322 gtk_signal_connect(GTK_OBJECT (button), "clicked",
1323 (GtkSignalFunc) cb_add_new_item,
1324 (gpointer)root_tree);
1325 gtk_box_pack_start(GTK_BOX(box2), button, TRUE, TRUE, 0);
1326 gtk_widget_show(button);
1327 tree_buttons->add_button = button;
1329 button = gtk_button_new_with_label("Remove Item(s)");
1330 gtk_widget_set_sensitive(button, FALSE);
1331 gtk_signal_connect(GTK_OBJECT (button), "clicked",
1332 (GtkSignalFunc) cb_remove_item,
1333 (gpointer)root_tree);
1334 gtk_box_pack_start(GTK_BOX(box2), button, TRUE, TRUE, 0);
1335 gtk_widget_show(button);
1336 tree_buttons->remove_button = button;
1338 button = gtk_button_new_with_label("Remove Subtree");
1339 gtk_widget_set_sensitive(button, FALSE);
1340 gtk_signal_connect(GTK_OBJECT (button), "clicked",
1341 (GtkSignalFunc) cb_remove_subtree,
1342 (gpointer)root_tree);
1343 gtk_box_pack_start(GTK_BOX(box2), button, TRUE, TRUE, 0);
1344 gtk_widget_show(button);
1345 tree_buttons->subtree_button = button;
1347 /* create separator */
1348 separator = gtk_hseparator_new();
1349 gtk_box_pack_start(GTK_BOX(box1), separator, FALSE, FALSE, 0);
1350 gtk_widget_show(separator);
1352 /* create button box */
1353 box2 = gtk_vbox_new(FALSE, 0);
1354 gtk_box_pack_start(GTK_BOX(box1), box2, FALSE, FALSE, 0);
1355 gtk_container_set_border_width(GTK_CONTAINER(box2), 5);
1356 gtk_widget_show(box2);
1358 button = gtk_button_new_with_label("Close");
1359 gtk_box_pack_start(GTK_BOX(box2), button, TRUE, TRUE, 0);
1360 gtk_signal_connect_object(GTK_OBJECT (button), "clicked",
1361 (GtkSignalFunc) gtk_widget_destroy,
1362 GTK_OBJECT(window));
1363 gtk_widget_show(button);
1365 gtk_widget_show(window);
1369 cb_create_tree(GtkWidget* w)
1371 guint selection_mode = GTK_SELECTION_SINGLE;
1376 guint recursion_level;
1378 /* get selection mode choice */
1379 if(GTK_TOGGLE_BUTTON(sTreeSampleSelection.single_button)->active)
1380 selection_mode = GTK_SELECTION_SINGLE;
1382 if(GTK_TOGGLE_BUTTON(sTreeSampleSelection.browse_button)->active)
1383 selection_mode = GTK_SELECTION_BROWSE;
1385 selection_mode = GTK_SELECTION_MULTIPLE;
1387 /* get options choice */
1388 draw_line = GTK_TOGGLE_BUTTON(sTreeSampleSelection.draw_line_button)->active;
1389 view_line = GTK_TOGGLE_BUTTON(sTreeSampleSelection.view_line_button)->active;
1390 no_root_item = GTK_TOGGLE_BUTTON(sTreeSampleSelection.no_root_item_button)->active;
1393 nb_item = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(sTreeSampleSelection.nb_item_spinner));
1394 recursion_level = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(sTreeSampleSelection.recursion_spinner));
1396 if (pow (nb_item, recursion_level) > 10000)
1398 g_print ("%g total items? That will take a very long time. Try less\n",
1399 pow (nb_item, recursion_level));
1403 create_tree_sample(selection_mode, draw_line, view_line, no_root_item, nb_item, recursion_level);
1407 create_tree_mode_window(void)
1409 static GtkWidget* window;
1417 GtkWidget* separator;
1424 /* create toplevel window */
1425 window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
1426 gtk_window_set_title(GTK_WINDOW(window), "Set Tree Parameters");
1427 gtk_signal_connect (GTK_OBJECT (window), "destroy",
1428 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
1430 box1 = gtk_vbox_new(FALSE, 0);
1431 gtk_container_add(GTK_CONTAINER(window), box1);
1433 /* create upper box - selection box */
1434 box2 = gtk_vbox_new(FALSE, 5);
1435 gtk_box_pack_start(GTK_BOX(box1), box2, TRUE, TRUE, 0);
1436 gtk_container_set_border_width(GTK_CONTAINER(box2), 5);
1438 box3 = gtk_hbox_new(FALSE, 5);
1439 gtk_box_pack_start(GTK_BOX(box2), box3, TRUE, TRUE, 0);
1441 /* create selection mode frame */
1442 frame = gtk_frame_new("Selection Mode");
1443 gtk_box_pack_start(GTK_BOX(box3), frame, TRUE, TRUE, 0);
1445 box4 = gtk_vbox_new(FALSE, 0);
1446 gtk_container_add(GTK_CONTAINER(frame), box4);
1447 gtk_container_set_border_width(GTK_CONTAINER(box4), 5);
1449 /* create radio button */
1450 button = gtk_radio_button_new_with_label(NULL, "SINGLE");
1451 gtk_box_pack_start(GTK_BOX(box4), button, TRUE, TRUE, 0);
1452 sTreeSampleSelection.single_button = button;
1454 button = gtk_radio_button_new_with_label(gtk_radio_button_group (GTK_RADIO_BUTTON (button)),
1456 gtk_box_pack_start(GTK_BOX(box4), button, TRUE, TRUE, 0);
1457 sTreeSampleSelection.browse_button = button;
1459 button = gtk_radio_button_new_with_label(gtk_radio_button_group (GTK_RADIO_BUTTON (button)),
1461 gtk_box_pack_start(GTK_BOX(box4), button, TRUE, TRUE, 0);
1462 sTreeSampleSelection.multiple_button = button;
1464 sTreeSampleSelection.selection_mode_group = gtk_radio_button_group (GTK_RADIO_BUTTON (button));
1466 /* create option mode frame */
1467 frame = gtk_frame_new("Options");
1468 gtk_box_pack_start(GTK_BOX(box3), frame, TRUE, TRUE, 0);
1470 box4 = gtk_vbox_new(FALSE, 0);
1471 gtk_container_add(GTK_CONTAINER(frame), box4);
1472 gtk_container_set_border_width(GTK_CONTAINER(box4), 5);
1474 /* create check button */
1475 button = gtk_check_button_new_with_label("Draw line");
1476 gtk_box_pack_start(GTK_BOX(box4), button, TRUE, TRUE, 0);
1477 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), TRUE);
1478 sTreeSampleSelection.draw_line_button = button;
1480 button = gtk_check_button_new_with_label("View Line mode");
1481 gtk_box_pack_start(GTK_BOX(box4), button, TRUE, TRUE, 0);
1482 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), TRUE);
1483 sTreeSampleSelection.view_line_button = button;
1485 button = gtk_check_button_new_with_label("Without Root item");
1486 gtk_box_pack_start(GTK_BOX(box4), button, TRUE, TRUE, 0);
1487 sTreeSampleSelection.no_root_item_button = button;
1489 /* create recursion parameter */
1490 frame = gtk_frame_new("Size Parameters");
1491 gtk_box_pack_start(GTK_BOX(box2), frame, TRUE, TRUE, 0);
1493 box4 = gtk_hbox_new(FALSE, 5);
1494 gtk_container_add(GTK_CONTAINER(frame), box4);
1495 gtk_container_set_border_width(GTK_CONTAINER(box4), 5);
1497 /* create number of item spin button */
1498 box5 = gtk_hbox_new(FALSE, 5);
1499 gtk_box_pack_start(GTK_BOX(box4), box5, FALSE, FALSE, 0);
1501 label = gtk_label_new("Number of items : ");
1502 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
1503 gtk_box_pack_start (GTK_BOX (box5), label, FALSE, TRUE, 0);
1505 adj = (GtkAdjustment *) gtk_adjustment_new ((gfloat)DEFAULT_NUMBER_OF_ITEM, 1.0, 255.0, 1.0,
1507 spinner = gtk_spin_button_new (adj, 0, 0);
1508 gtk_box_pack_start (GTK_BOX (box5), spinner, FALSE, TRUE, 0);
1509 sTreeSampleSelection.nb_item_spinner = spinner;
1511 /* create recursion level spin button */
1512 box5 = gtk_hbox_new(FALSE, 5);
1513 gtk_box_pack_start(GTK_BOX(box4), box5, FALSE, FALSE, 0);
1515 label = gtk_label_new("Depth : ");
1516 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
1517 gtk_box_pack_start (GTK_BOX (box5), label, FALSE, TRUE, 0);
1519 adj = (GtkAdjustment *) gtk_adjustment_new ((gfloat)DEFAULT_RECURSION_LEVEL, 0.0, 255.0, 1.0,
1521 spinner = gtk_spin_button_new (adj, 0, 0);
1522 gtk_box_pack_start (GTK_BOX (box5), spinner, FALSE, TRUE, 0);
1523 sTreeSampleSelection.recursion_spinner = spinner;
1525 /* create horizontal separator */
1526 separator = gtk_hseparator_new();
1527 gtk_box_pack_start(GTK_BOX(box1), separator, FALSE, FALSE, 0);
1529 /* create bottom button box */
1530 box2 = gtk_hbox_new(TRUE, 10);
1531 gtk_box_pack_start(GTK_BOX(box1), box2, FALSE, FALSE, 0);
1532 gtk_container_set_border_width(GTK_CONTAINER(box2), 5);
1534 button = gtk_button_new_with_label("Create Tree");
1535 gtk_box_pack_start(GTK_BOX(box2), button, TRUE, TRUE, 0);
1536 gtk_signal_connect(GTK_OBJECT (button), "clicked",
1537 (GtkSignalFunc) cb_create_tree, NULL);
1539 button = gtk_button_new_with_label("Close");
1540 gtk_box_pack_start(GTK_BOX(box2), button, TRUE, TRUE, 0);
1541 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
1542 GTK_SIGNAL_FUNC(gtk_widget_destroy),
1543 GTK_OBJECT (window));
1545 if (!GTK_WIDGET_VISIBLE (window))
1546 gtk_widget_show_all (window);
1548 gtk_widget_destroy (window);
1556 handle_box_child_signal (GtkHandleBox *hb,
1558 const gchar *action)
1560 printf ("%s: child <%s> %sed\n",
1561 gtk_type_name (GTK_OBJECT_TYPE (hb)),
1562 gtk_type_name (GTK_OBJECT_TYPE (child)),
1567 create_handle_box (void)
1569 static GtkWidget* window = NULL;
1570 GtkWidget *handle_box;
1571 GtkWidget *handle_box2;
1576 GtkWidget *separator;
1580 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
1581 gtk_window_set_title (GTK_WINDOW (window),
1583 gtk_window_set_policy (GTK_WINDOW (window),
1588 gtk_signal_connect (GTK_OBJECT (window), "destroy",
1589 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
1592 gtk_container_set_border_width (GTK_CONTAINER (window), 20);
1594 vbox = gtk_vbox_new (FALSE, 0);
1595 gtk_container_add (GTK_CONTAINER (window), vbox);
1596 gtk_widget_show (vbox);
1598 label = gtk_label_new ("Above");
1599 gtk_container_add (GTK_CONTAINER (vbox), label);
1600 gtk_widget_show (label);
1602 separator = gtk_hseparator_new ();
1603 gtk_container_add (GTK_CONTAINER (vbox), separator);
1604 gtk_widget_show (separator);
1606 hbox = gtk_hbox_new (FALSE, 10);
1607 gtk_container_add (GTK_CONTAINER (vbox), hbox);
1608 gtk_widget_show (hbox);
1610 separator = gtk_hseparator_new ();
1611 gtk_container_add (GTK_CONTAINER (vbox), separator);
1612 gtk_widget_show (separator);
1614 label = gtk_label_new ("Below");
1615 gtk_container_add (GTK_CONTAINER (vbox), label);
1616 gtk_widget_show (label);
1618 handle_box = gtk_handle_box_new ();
1619 gtk_box_pack_start (GTK_BOX (hbox), handle_box, FALSE, FALSE, 0);
1620 gtk_signal_connect (GTK_OBJECT (handle_box),
1622 GTK_SIGNAL_FUNC (handle_box_child_signal),
1624 gtk_signal_connect (GTK_OBJECT (handle_box),
1626 GTK_SIGNAL_FUNC (handle_box_child_signal),
1628 gtk_widget_show (handle_box);
1630 toolbar = make_toolbar (window);
1631 gtk_toolbar_set_button_relief (GTK_TOOLBAR (toolbar), GTK_RELIEF_NORMAL);
1632 gtk_container_add (GTK_CONTAINER (handle_box), toolbar);
1633 gtk_widget_show (toolbar);
1635 handle_box = gtk_handle_box_new ();
1636 gtk_box_pack_start (GTK_BOX (hbox), handle_box, FALSE, FALSE, 0);
1637 gtk_signal_connect (GTK_OBJECT (handle_box),
1639 GTK_SIGNAL_FUNC (handle_box_child_signal),
1641 gtk_signal_connect (GTK_OBJECT (handle_box),
1643 GTK_SIGNAL_FUNC (handle_box_child_signal),
1645 gtk_widget_show (handle_box);
1647 handle_box2 = gtk_handle_box_new ();
1648 gtk_container_add (GTK_CONTAINER (handle_box), handle_box2);
1649 gtk_signal_connect (GTK_OBJECT (handle_box2),
1651 GTK_SIGNAL_FUNC (handle_box_child_signal),
1653 gtk_signal_connect (GTK_OBJECT (handle_box2),
1655 GTK_SIGNAL_FUNC (handle_box_child_signal),
1657 gtk_widget_show (handle_box2);
1659 label = gtk_label_new ("Fooo!");
1660 gtk_container_add (GTK_CONTAINER (handle_box2), label);
1661 gtk_widget_show (label);
1664 if (!GTK_WIDGET_VISIBLE (window))
1665 gtk_widget_show (window);
1667 gtk_widget_destroy (window);
1673 void create_labels (void)
1675 static GtkWidget *window = NULL;
1683 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
1684 gtk_signal_connect (GTK_OBJECT (window), "destroy",
1685 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
1688 gtk_window_set_title (GTK_WINDOW (window), "Label");
1689 vbox = gtk_vbox_new (FALSE, 5);
1690 hbox = gtk_hbox_new (FALSE, 5);
1691 gtk_container_add (GTK_CONTAINER (window), hbox);
1692 gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 0);
1693 gtk_container_set_border_width (GTK_CONTAINER (window), 5);
1695 frame = gtk_frame_new ("Normal Label");
1696 label = gtk_label_new ("This is a Normal label");
1697 gtk_container_add (GTK_CONTAINER (frame), label);
1698 gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
1700 frame = gtk_frame_new ("Multi-line Label");
1701 label = gtk_label_new ("This is a Multi-line label.\nSecond line\nThird line");
1702 gtk_container_add (GTK_CONTAINER (frame), label);
1703 gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
1705 frame = gtk_frame_new ("Left Justified Label");
1706 label = gtk_label_new ("This is a Left-Justified\nMulti-line label.\nThird line");
1707 gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
1708 gtk_container_add (GTK_CONTAINER (frame), label);
1709 gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
1711 frame = gtk_frame_new ("Right Justified Label");
1712 label = gtk_label_new ("This is a Right-Justified\nMulti-line label.\nFourth line, (j/k)");
1713 gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_RIGHT);
1714 gtk_container_add (GTK_CONTAINER (frame), label);
1715 gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
1717 frame = gtk_frame_new ("Internationalized Label");
1718 label = gtk_label_new ("French (Français) Bonjour, Salut\n"
1719 "Korean (한글) 안녕하세요, 안녕하십니까\n"
1720 "Russian (Русский) Здравствуйте!");
1721 gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
1722 gtk_container_add (GTK_CONTAINER (frame), label);
1723 gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
1725 frame = gtk_frame_new ("Bidirection Label");
1726 label = gtk_label_new ("Arabic السلام عليكم\n"
1728 gtk_widget_set_direction (label, GTK_TEXT_DIR_RTL);
1729 gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_RIGHT);
1730 gtk_container_add (GTK_CONTAINER (frame), label);
1731 gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
1733 vbox = gtk_vbox_new (FALSE, 5);
1734 gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 0);
1735 frame = gtk_frame_new ("Line wrapped label");
1736 label = gtk_label_new ("This is an example of a line-wrapped label. It should not be taking "\
1737 "up the entire "/* big space to test spacing */\
1738 "width allocated to it, but automatically wraps the words to fit. "\
1739 "The time has come, for all good men, to come to the aid of their party. "\
1740 "The sixth sheik's six sheep's sick.\n"\
1741 " It supports multiple paragraphs correctly, and correctly adds "\
1742 "many extra spaces. ");
1744 gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
1745 gtk_container_add (GTK_CONTAINER (frame), label);
1746 gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
1748 frame = gtk_frame_new ("Filled, wrapped label");
1749 label = gtk_label_new ("This is an example of a line-wrapped, filled label. It should be taking "\
1750 "up the entire width allocated to it. Here is a seneance to prove "\
1751 "my point. Here is another sentence. "\
1752 "Here comes the sun, do de do de do.\n"\
1753 " This is a new paragraph.\n"\
1754 " This is another newer, longer, better paragraph. It is coming to an end, "\
1756 gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_FILL);
1757 gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
1758 gtk_container_add (GTK_CONTAINER (frame), label);
1759 gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
1761 frame = gtk_frame_new ("Underlined label");
1762 label = gtk_label_new ("This label is underlined!\n"
1763 "This one is underlined (こんにちは) in quite a funky fashion");
1764 gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
1765 gtk_label_set_pattern (GTK_LABEL (label), "_________________________ _ _________ _ _____ _ __ __ ___ ____ _____");
1766 gtk_container_add (GTK_CONTAINER (frame), label);
1767 gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
1769 if (!GTK_WIDGET_VISIBLE (window))
1770 gtk_widget_show_all (window);
1772 gtk_widget_destroy (window);
1780 reparent_label (GtkWidget *widget,
1781 GtkWidget *new_parent)
1785 label = gtk_object_get_user_data (GTK_OBJECT (widget));
1787 gtk_widget_reparent (label, new_parent);
1791 set_parent_signal (GtkWidget *child,
1792 GtkWidget *old_parent,
1795 g_print ("set_parent for \"%s\": new parent: \"%s\", old parent: \"%s\", data: %d\n",
1796 gtk_type_name (GTK_OBJECT_TYPE (child)),
1797 child->parent ? gtk_type_name (GTK_OBJECT_TYPE (child->parent)) : "NULL",
1798 old_parent ? gtk_type_name (GTK_OBJECT_TYPE (old_parent)) : "NULL",
1799 GPOINTER_TO_INT (func_data));
1803 create_reparent (void)
1805 static GtkWidget *window = NULL;
1812 GtkWidget *separator;
1816 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
1818 gtk_signal_connect (GTK_OBJECT (window), "destroy",
1819 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
1822 gtk_window_set_title (GTK_WINDOW (window), "reparent");
1823 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
1825 box1 = gtk_vbox_new (FALSE, 0);
1826 gtk_container_add (GTK_CONTAINER (window), box1);
1828 box2 = gtk_hbox_new (FALSE, 5);
1829 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
1830 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
1832 label = gtk_label_new ("Hello World");
1834 frame = gtk_frame_new ("Frame 1");
1835 gtk_box_pack_start (GTK_BOX (box2), frame, TRUE, TRUE, 0);
1837 box3 = gtk_vbox_new (FALSE, 5);
1838 gtk_container_set_border_width (GTK_CONTAINER (box3), 5);
1839 gtk_container_add (GTK_CONTAINER (frame), box3);
1841 button = gtk_button_new_with_label ("switch");
1842 gtk_signal_connect (GTK_OBJECT (button), "clicked",
1843 GTK_SIGNAL_FUNC(reparent_label),
1845 gtk_object_set_user_data (GTK_OBJECT (button), label);
1846 gtk_box_pack_start (GTK_BOX (box3), button, FALSE, TRUE, 0);
1848 gtk_box_pack_start (GTK_BOX (box3), label, FALSE, TRUE, 0);
1849 gtk_signal_connect (GTK_OBJECT (label),
1851 GTK_SIGNAL_FUNC (set_parent_signal),
1852 GINT_TO_POINTER (42));
1854 frame = gtk_frame_new ("Frame 2");
1855 gtk_box_pack_start (GTK_BOX (box2), frame, TRUE, TRUE, 0);
1857 box3 = gtk_vbox_new (FALSE, 5);
1858 gtk_container_set_border_width (GTK_CONTAINER (box3), 5);
1859 gtk_container_add (GTK_CONTAINER (frame), box3);
1861 button = gtk_button_new_with_label ("switch");
1862 gtk_signal_connect (GTK_OBJECT (button), "clicked",
1863 GTK_SIGNAL_FUNC(reparent_label),
1865 gtk_object_set_user_data (GTK_OBJECT (button), label);
1866 gtk_box_pack_start (GTK_BOX (box3), button, FALSE, TRUE, 0);
1868 separator = gtk_hseparator_new ();
1869 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
1871 box2 = gtk_vbox_new (FALSE, 10);
1872 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
1873 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
1875 button = gtk_button_new_with_label ("close");
1876 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
1877 GTK_SIGNAL_FUNC(gtk_widget_destroy),
1878 GTK_OBJECT (window));
1879 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
1880 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
1881 gtk_widget_grab_default (button);
1884 if (!GTK_WIDGET_VISIBLE (window))
1885 gtk_widget_show_all (window);
1887 gtk_widget_destroy (window);
1893 gint upositionx = 0;
1894 gint upositiony = 0;
1897 uposition_configure (GtkWidget *window)
1903 lx = gtk_object_get_data (GTK_OBJECT (window), "x");
1904 ly = gtk_object_get_data (GTK_OBJECT (window), "y");
1906 gdk_window_get_root_origin (window->window, &upositionx, &upositiony);
1907 sprintf (buffer, "%d", upositionx);
1908 gtk_label_set_text (lx, buffer);
1909 sprintf (buffer, "%d", upositiony);
1910 gtk_label_set_text (ly, buffer);
1916 create_saved_position (void)
1918 static GtkWidget *window = NULL;
1923 GtkWidget *main_vbox;
1931 window = gtk_widget_new (GTK_TYPE_WINDOW,
1932 "type", GTK_WINDOW_TOPLEVEL,
1933 "signal::configure_event", uposition_configure, NULL,
1936 "title", "Saved Position",
1939 gtk_signal_connect (GTK_OBJECT (window), "destroy",
1940 GTK_SIGNAL_FUNC (gtk_widget_destroyed),
1943 main_vbox = gtk_vbox_new (FALSE, 5);
1944 gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 0);
1945 gtk_container_add (GTK_CONTAINER (window), main_vbox);
1948 gtk_widget_new (gtk_vbox_get_type (),
1949 "GtkBox::homogeneous", FALSE,
1950 "GtkBox::spacing", 5,
1951 "GtkContainer::border_width", 10,
1952 "GtkWidget::parent", main_vbox,
1953 "GtkWidget::visible", TRUE,
1956 hbox = gtk_hbox_new (FALSE, 0);
1957 gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
1958 gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0);
1960 label = gtk_label_new ("X Origin : ");
1961 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
1962 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
1964 x_label = gtk_label_new ("");
1965 gtk_box_pack_start (GTK_BOX (hbox), x_label, TRUE, TRUE, 0);
1966 gtk_object_set_data (GTK_OBJECT (window), "x", x_label);
1968 hbox = gtk_hbox_new (FALSE, 0);
1969 gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
1970 gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0);
1972 label = gtk_label_new ("Y Origin : ");
1973 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
1974 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
1976 y_label = gtk_label_new ("");
1977 gtk_box_pack_start (GTK_BOX (hbox), y_label, TRUE, TRUE, 0);
1978 gtk_object_set_data (GTK_OBJECT (window), "y", y_label);
1981 gtk_widget_new (gtk_hseparator_get_type (),
1982 "GtkWidget::visible", TRUE,
1984 gtk_box_pack_start (GTK_BOX (main_vbox), any, FALSE, TRUE, 0);
1986 hbox = gtk_hbox_new (FALSE, 0);
1987 gtk_container_set_border_width (GTK_CONTAINER (hbox), 10);
1988 gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, TRUE, 0);
1990 button = gtk_button_new_with_label ("Close");
1991 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
1992 GTK_SIGNAL_FUNC (gtk_widget_destroy),
1993 GTK_OBJECT (window));
1994 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
1995 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
1996 gtk_widget_grab_default (button);
1998 gtk_widget_show_all (window);
2001 gtk_widget_destroy (window);
2009 create_pixmap (void)
2011 static GtkWidget *window = NULL;
2017 GtkWidget *separator;
2018 GtkWidget *pixmapwid;
2022 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
2024 gtk_signal_connect (GTK_OBJECT (window), "destroy",
2025 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
2028 gtk_window_set_title (GTK_WINDOW (window), "GtkPixmap");
2029 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
2030 gtk_widget_realize(window);
2032 box1 = gtk_vbox_new (FALSE, 0);
2033 gtk_container_add (GTK_CONTAINER (window), box1);
2035 box2 = gtk_vbox_new (FALSE, 10);
2036 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
2037 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
2039 button = gtk_button_new ();
2040 gtk_box_pack_start (GTK_BOX (box2), button, FALSE, FALSE, 0);
2042 pixmapwid = new_pixmap ("test.xpm", window->window, NULL);
2044 label = gtk_label_new ("Pixmap\ntest");
2045 box3 = gtk_hbox_new (FALSE, 0);
2046 gtk_container_set_border_width (GTK_CONTAINER (box3), 2);
2047 gtk_container_add (GTK_CONTAINER (box3), pixmapwid);
2048 gtk_container_add (GTK_CONTAINER (box3), label);
2049 gtk_container_add (GTK_CONTAINER (button), box3);
2051 separator = gtk_hseparator_new ();
2052 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
2054 box2 = gtk_vbox_new (FALSE, 10);
2055 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
2056 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
2058 button = gtk_button_new_with_label ("close");
2059 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
2060 GTK_SIGNAL_FUNC(gtk_widget_destroy),
2061 GTK_OBJECT (window));
2062 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
2063 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
2064 gtk_widget_grab_default (button);
2067 if (!GTK_WIDGET_VISIBLE (window))
2068 gtk_widget_show_all (window);
2070 gtk_widget_destroy (window);
2074 tips_query_widget_entered (GtkTipsQuery *tips_query,
2076 const gchar *tip_text,
2077 const gchar *tip_private,
2080 if (GTK_TOGGLE_BUTTON (toggle)->active)
2082 gtk_label_set_text (GTK_LABEL (tips_query), tip_text ? "There is a Tip!" : "There is no Tip!");
2083 /* don't let GtkTipsQuery reset its label */
2084 gtk_signal_emit_stop_by_name (GTK_OBJECT (tips_query), "widget_entered");
2089 tips_query_widget_selected (GtkWidget *tips_query,
2091 const gchar *tip_text,
2092 const gchar *tip_private,
2093 GdkEventButton *event,
2097 g_print ("Help \"%s\" requested for <%s>\n",
2098 tip_private ? tip_private : "None",
2099 gtk_type_name (GTK_OBJECT_TYPE (widget)));
2104 create_tooltips (void)
2106 static GtkWidget *window = NULL;
2113 GtkWidget *tips_query;
2114 GtkWidget *separator;
2115 GtkTooltips *tooltips;
2120 gtk_widget_new (gtk_window_get_type (),
2121 "GtkWindow::type", GTK_WINDOW_TOPLEVEL,
2122 "GtkContainer::border_width", 0,
2123 "GtkWindow::title", "Tooltips",
2124 "GtkWindow::allow_shrink", TRUE,
2125 "GtkWindow::allow_grow", FALSE,
2126 "GtkWindow::auto_shrink", TRUE,
2127 "GtkWidget::width", 200,
2130 gtk_signal_connect (GTK_OBJECT (window), "destroy",
2131 GTK_SIGNAL_FUNC (destroy_tooltips),
2134 tooltips=gtk_tooltips_new();
2135 gtk_object_set_data (GTK_OBJECT (window), "tooltips", tooltips);
2137 box1 = gtk_vbox_new (FALSE, 0);
2138 gtk_container_add (GTK_CONTAINER (window), box1);
2140 box2 = gtk_vbox_new (FALSE, 10);
2141 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
2142 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
2144 button = gtk_toggle_button_new_with_label ("button1");
2145 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
2147 gtk_tooltips_set_tip (tooltips,button,"This is button 1", "ContextHelp/buttons/1");
2149 button = gtk_toggle_button_new_with_label ("button2");
2150 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
2152 gtk_tooltips_set_tip (tooltips,
2154 "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.",
2155 "ContextHelp/buttons/2_long");
2157 toggle = gtk_toggle_button_new_with_label ("Override TipsQuery Label");
2158 gtk_box_pack_start (GTK_BOX (box2), toggle, TRUE, TRUE, 0);
2160 gtk_tooltips_set_tip (tooltips, toggle, "Toggle TipsQuery view.", "Hi msw! ;)");
2163 gtk_widget_new (gtk_vbox_get_type (),
2164 "GtkBox::homogeneous", FALSE,
2165 "GtkBox::spacing", 5,
2166 "GtkContainer::border_width", 5,
2167 "GtkWidget::visible", TRUE,
2170 tips_query = gtk_tips_query_new ();
2173 gtk_widget_new (gtk_button_get_type (),
2174 "GtkButton::label", "[?]",
2175 "GtkWidget::visible", TRUE,
2176 "GtkWidget::parent", box3,
2177 "GtkObject::object_signal::clicked", gtk_tips_query_start_query, tips_query,
2179 gtk_box_set_child_packing (GTK_BOX (box3), button, FALSE, FALSE, 0, GTK_PACK_START);
2180 gtk_tooltips_set_tip (tooltips,
2182 "Start the Tooltips Inspector",
2183 "ContextHelp/buttons/?");
2186 gtk_widget_set (tips_query,
2187 "GtkWidget::visible", TRUE,
2188 "GtkWidget::parent", box3,
2189 "GtkTipsQuery::caller", button,
2190 "GtkObject::signal::widget_entered", tips_query_widget_entered, toggle,
2191 "GtkObject::signal::widget_selected", tips_query_widget_selected, NULL,
2195 gtk_widget_new (gtk_frame_get_type (),
2196 "GtkFrame::label", "ToolTips Inspector",
2197 "GtkFrame::label_xalign", (double) 0.5,
2198 "GtkContainer::border_width", 0,
2199 "GtkWidget::visible", TRUE,
2200 "GtkWidget::parent", box2,
2201 "GtkContainer::child", box3,
2203 gtk_box_set_child_packing (GTK_BOX (box2), frame, TRUE, TRUE, 10, GTK_PACK_START);
2205 separator = gtk_hseparator_new ();
2206 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
2208 box2 = gtk_vbox_new (FALSE, 10);
2209 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
2210 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
2212 button = gtk_button_new_with_label ("close");
2213 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
2214 GTK_SIGNAL_FUNC(gtk_widget_destroy),
2215 GTK_OBJECT (window));
2216 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
2217 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
2218 gtk_widget_grab_default (button);
2220 gtk_tooltips_set_tip (tooltips, button, "Push this button to close window", "ContextHelp/buttons/Close");
2223 if (!GTK_WIDGET_VISIBLE (window))
2224 gtk_widget_show_all (window);
2226 gtk_widget_destroy (window);
2234 create_menu (gint depth, gboolean tearoff)
2237 GtkWidget *menuitem;
2245 menu = gtk_menu_new ();
2250 menuitem = gtk_tearoff_menu_item_new ();
2251 gtk_menu_append (GTK_MENU (menu), menuitem);
2252 gtk_widget_show (menuitem);
2255 for (i = 0, j = 1; i < 5; i++, j++)
2257 sprintf (buf, "item %2d - %d", depth, j);
2258 menuitem = gtk_radio_menu_item_new_with_label (group, buf);
2259 group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menuitem));
2261 gtk_check_menu_item_set_show_toggle (GTK_CHECK_MENU_ITEM (menuitem), TRUE);
2262 gtk_menu_append (GTK_MENU (menu), menuitem);
2263 gtk_widget_show (menuitem);
2265 gtk_widget_set_sensitive (menuitem, FALSE);
2267 gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), create_menu (depth - 1, TRUE));
2276 static GtkWidget *window = NULL;
2280 GtkWidget *optionmenu;
2281 GtkWidget *separator;
2287 GtkWidget *menuitem;
2288 GtkAccelGroup *accel_group;
2290 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
2292 gtk_signal_connect (GTK_OBJECT (window), "destroy",
2293 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
2295 gtk_signal_connect (GTK_OBJECT (window), "delete-event",
2296 GTK_SIGNAL_FUNC (gtk_true),
2299 accel_group = gtk_accel_group_new ();
2300 gtk_accel_group_attach (accel_group, GTK_OBJECT (window));
2302 gtk_window_set_title (GTK_WINDOW (window), "menus");
2303 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
2306 box1 = gtk_vbox_new (FALSE, 0);
2307 gtk_container_add (GTK_CONTAINER (window), box1);
2308 gtk_widget_show (box1);
2310 menubar = gtk_menu_bar_new ();
2311 gtk_box_pack_start (GTK_BOX (box1), menubar, FALSE, TRUE, 0);
2312 gtk_widget_show (menubar);
2314 menu = create_menu (2, TRUE);
2316 menuitem = gtk_menu_item_new_with_label ("test\nline2");
2317 gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), menu);
2318 gtk_menu_bar_append (GTK_MENU_BAR (menubar), menuitem);
2319 gtk_widget_show (menuitem);
2321 menuitem = gtk_menu_item_new_with_label ("foo");
2322 gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), create_menu (3, TRUE));
2323 gtk_menu_bar_append (GTK_MENU_BAR (menubar), menuitem);
2324 gtk_widget_show (menuitem);
2326 menuitem = gtk_menu_item_new_with_label ("bar");
2327 gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), create_menu (4, TRUE));
2328 gtk_menu_item_right_justify (GTK_MENU_ITEM (menuitem));
2329 gtk_menu_bar_append (GTK_MENU_BAR (menubar), menuitem);
2330 gtk_widget_show (menuitem);
2332 box2 = gtk_vbox_new (FALSE, 10);
2333 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
2334 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
2335 gtk_widget_show (box2);
2337 menu = create_menu (1, FALSE);
2338 gtk_menu_set_accel_group (GTK_MENU (menu), accel_group);
2340 menuitem = gtk_check_menu_item_new_with_label ("Accelerate Me");
2341 gtk_menu_append (GTK_MENU (menu), menuitem);
2342 gtk_widget_show (menuitem);
2343 gtk_widget_add_accelerator (menuitem,
2348 GTK_ACCEL_VISIBLE | GTK_ACCEL_SIGNAL_VISIBLE);
2349 menuitem = gtk_check_menu_item_new_with_label ("Accelerator Locked");
2350 gtk_menu_append (GTK_MENU (menu), menuitem);
2351 gtk_widget_show (menuitem);
2352 gtk_widget_add_accelerator (menuitem,
2357 GTK_ACCEL_VISIBLE | GTK_ACCEL_LOCKED);
2358 menuitem = gtk_check_menu_item_new_with_label ("Accelerators Frozen");
2359 gtk_menu_append (GTK_MENU (menu), menuitem);
2360 gtk_widget_show (menuitem);
2361 gtk_widget_add_accelerator (menuitem,
2367 gtk_widget_add_accelerator (menuitem,
2373 gtk_widget_lock_accelerators (menuitem);
2375 optionmenu = gtk_option_menu_new ();
2376 gtk_option_menu_set_menu (GTK_OPTION_MENU (optionmenu), menu);
2377 gtk_option_menu_set_history (GTK_OPTION_MENU (optionmenu), 3);
2378 gtk_box_pack_start (GTK_BOX (box2), optionmenu, TRUE, TRUE, 0);
2379 gtk_widget_show (optionmenu);
2381 separator = gtk_hseparator_new ();
2382 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
2383 gtk_widget_show (separator);
2385 box2 = gtk_vbox_new (FALSE, 10);
2386 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
2387 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
2388 gtk_widget_show (box2);
2390 button = gtk_button_new_with_label ("close");
2391 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
2392 GTK_SIGNAL_FUNC(gtk_widget_destroy),
2393 GTK_OBJECT (window));
2394 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
2395 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
2396 gtk_widget_grab_default (button);
2397 gtk_widget_show (button);
2400 if (!GTK_WIDGET_VISIBLE (window))
2401 gtk_widget_show (window);
2403 gtk_widget_destroy (window);
2407 gtk_ifactory_cb (gpointer callback_data,
2408 guint callback_action,
2411 g_message ("ItemFactory: activated \"%s\"", gtk_item_factory_path_from_widget (widget));
2414 static GtkItemFactoryEntry menu_items[] =
2416 { "/_File", NULL, 0, 0, "<Branch>" },
2417 { "/File/tearoff1", NULL, gtk_ifactory_cb, 0, "<Tearoff>" },
2418 { "/File/_New", "<control>N", gtk_ifactory_cb, 0 },
2419 { "/File/_Open", "<control>O", gtk_ifactory_cb, 0 },
2420 { "/File/_Save", "<control>S", gtk_ifactory_cb, 0 },
2421 { "/File/Save _As...", NULL, gtk_ifactory_cb, 0 },
2422 { "/File/sep1", NULL, gtk_ifactory_cb, 0, "<Separator>" },
2423 { "/File/_Quit", "<control>Q", gtk_ifactory_cb, 0 },
2425 { "/_Preferences", NULL, 0, 0, "<Branch>" },
2426 { "/_Preferences/_Color", NULL, 0, 0, "<Branch>" },
2427 { "/_Preferences/Color/_Red", NULL, gtk_ifactory_cb, 0, "<RadioItem>" },
2428 { "/_Preferences/Color/_Green", NULL, gtk_ifactory_cb, 0, "/Preferences/Color/Red" },
2429 { "/_Preferences/Color/_Blue", NULL, gtk_ifactory_cb, 0, "/Preferences/Color/Red" },
2430 { "/_Preferences/_Shape", NULL, 0, 0, "<Branch>" },
2431 { "/_Preferences/Shape/_Square", NULL, gtk_ifactory_cb, 0, "<RadioItem>" },
2432 { "/_Preferences/Shape/_Rectangle", NULL, gtk_ifactory_cb, 0, "/Preferences/Shape/Square" },
2433 { "/_Preferences/Shape/_Oval", NULL, gtk_ifactory_cb, 0, "/Preferences/Shape/Rectangle" },
2435 { "/_Help", NULL, 0, 0, "<LastBranch>" },
2436 { "/Help/_About", NULL, gtk_ifactory_cb, 0 },
2439 static int nmenu_items = sizeof (menu_items) / sizeof (menu_items[0]);
2442 create_item_factory (void)
2444 static GtkWidget *window = NULL;
2450 GtkWidget *separator;
2453 GtkAccelGroup *accel_group;
2454 GtkItemFactory *item_factory;
2456 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
2458 gtk_signal_connect (GTK_OBJECT (window), "destroy",
2459 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
2461 gtk_signal_connect (GTK_OBJECT (window), "delete-event",
2462 GTK_SIGNAL_FUNC (gtk_true),
2465 accel_group = gtk_accel_group_new ();
2466 item_factory = gtk_item_factory_new (GTK_TYPE_MENU_BAR, "<main>", accel_group);
2467 gtk_object_set_data_full (GTK_OBJECT (window),
2470 (GtkDestroyNotify) gtk_object_unref);
2471 gtk_accel_group_attach (accel_group, GTK_OBJECT (window));
2472 gtk_window_set_title (GTK_WINDOW (window), "Item Factory");
2473 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
2474 gtk_item_factory_create_items (item_factory, nmenu_items, menu_items, NULL);
2476 /* preselect /Preferences/Shape/Oval over the other radios
2478 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (gtk_item_factory_get_item (item_factory,
2479 "/Preferences/Shape/Oval")),
2482 box1 = gtk_vbox_new (FALSE, 0);
2483 gtk_container_add (GTK_CONTAINER (window), box1);
2485 gtk_box_pack_start (GTK_BOX (box1),
2486 gtk_item_factory_get_widget (item_factory, "<main>"),
2489 label = gtk_label_new ("Type\n<alt>\nto start");
2490 gtk_widget_set_usize (label, 200, 200);
2491 gtk_misc_set_alignment (GTK_MISC (label), 0.5, 0.5);
2492 gtk_box_pack_start (GTK_BOX (box1), label, TRUE, TRUE, 0);
2495 separator = gtk_hseparator_new ();
2496 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
2499 box2 = gtk_vbox_new (FALSE, 10);
2500 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
2501 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
2503 button = gtk_button_new_with_label ("close");
2504 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
2505 GTK_SIGNAL_FUNC(gtk_widget_destroy),
2506 GTK_OBJECT (window));
2507 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
2508 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
2509 gtk_widget_grab_default (button);
2511 gtk_widget_show_all (window);
2514 gtk_widget_destroy (window);
2522 cmw_destroy_cb(GtkWidget *widget)
2524 /* This is needed to get out of gtk_main */
2531 cmw_color (GtkWidget *widget, GtkWidget *parent)
2535 csd=gtk_color_selection_dialog_new ("This is a modal color selection dialog");
2538 gtk_window_set_modal (GTK_WINDOW(csd),TRUE);
2540 /* And mark it as a transient dialog */
2541 gtk_window_set_transient_for (GTK_WINDOW (csd), GTK_WINDOW (parent));
2543 gtk_signal_connect (GTK_OBJECT(csd), "destroy",
2544 GTK_SIGNAL_FUNC(cmw_destroy_cb),NULL);
2546 gtk_signal_connect_object (GTK_OBJECT(GTK_COLOR_SELECTION_DIALOG(csd)->ok_button),
2547 "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy),
2549 gtk_signal_connect_object (GTK_OBJECT(GTK_COLOR_SELECTION_DIALOG(csd)->cancel_button),
2550 "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy),
2553 /* wait until destroy calls gtk_main_quit */
2554 gtk_widget_show (csd);
2559 cmw_file (GtkWidget *widget, GtkWidget *parent)
2563 fs = gtk_file_selection_new("This is a modal file selection dialog");
2566 gtk_window_set_modal (GTK_WINDOW(fs),TRUE);
2568 /* And mark it as a transient dialog */
2569 gtk_window_set_transient_for (GTK_WINDOW (fs), GTK_WINDOW (parent));
2571 gtk_signal_connect (GTK_OBJECT(fs), "destroy",
2572 GTK_SIGNAL_FUNC(cmw_destroy_cb),NULL);
2574 gtk_signal_connect_object (GTK_OBJECT(GTK_FILE_SELECTION(fs)->ok_button),
2575 "clicked",GTK_SIGNAL_FUNC(gtk_widget_destroy),
2577 gtk_signal_connect_object (GTK_OBJECT(GTK_FILE_SELECTION(fs)->cancel_button),
2578 "clicked",GTK_SIGNAL_FUNC(gtk_widget_destroy),
2581 /* wait until destroy calls gtk_main_quit */
2582 gtk_widget_show (fs);
2589 create_modal_window (void)
2591 GtkWidget *window = NULL;
2592 GtkWidget *box1,*box2;
2594 GtkWidget *btnColor,*btnFile,*btnClose;
2596 /* Create modal window (Here you can use any window descendent )*/
2597 window=gtk_window_new (GTK_WINDOW_TOPLEVEL);
2598 gtk_window_set_title (GTK_WINDOW(window),"This window is modal");
2600 /* Set window as modal */
2601 gtk_window_set_modal (GTK_WINDOW(window),TRUE);
2603 /* Create widgets */
2604 box1 = gtk_vbox_new (FALSE,5);
2605 frame1 = gtk_frame_new ("Standard dialogs in modal form");
2606 box2 = gtk_vbox_new (TRUE,5);
2607 btnColor = gtk_button_new_with_label ("Color");
2608 btnFile = gtk_button_new_with_label ("File Selection");
2609 btnClose = gtk_button_new_with_label ("Close");
2612 gtk_container_set_border_width (GTK_CONTAINER(box1),3);
2613 gtk_container_set_border_width (GTK_CONTAINER(box2),3);
2616 gtk_container_add (GTK_CONTAINER (window), box1);
2617 gtk_box_pack_start (GTK_BOX (box1), frame1, TRUE, TRUE, 4);
2618 gtk_container_add (GTK_CONTAINER (frame1), box2);
2619 gtk_box_pack_start (GTK_BOX (box2), btnColor, FALSE, FALSE, 4);
2620 gtk_box_pack_start (GTK_BOX (box2), btnFile, FALSE, FALSE, 4);
2621 gtk_box_pack_start (GTK_BOX (box1), gtk_hseparator_new (), FALSE, FALSE, 4);
2622 gtk_box_pack_start (GTK_BOX (box1), btnClose, FALSE, FALSE, 4);
2624 /* connect signals */
2625 gtk_signal_connect_object (GTK_OBJECT (btnClose), "clicked",
2626 GTK_SIGNAL_FUNC (gtk_widget_destroy),
2627 GTK_OBJECT (window));
2629 gtk_signal_connect (GTK_OBJECT (window), "destroy",
2630 GTK_SIGNAL_FUNC (cmw_destroy_cb),NULL);
2632 gtk_signal_connect (GTK_OBJECT (btnColor), "clicked",
2633 GTK_SIGNAL_FUNC (cmw_color),window);
2634 gtk_signal_connect (GTK_OBJECT (btnFile), "clicked",
2635 GTK_SIGNAL_FUNC (cmw_file),window);
2638 gtk_widget_show_all (window);
2640 /* wait until dialog get destroyed */
2648 static GtkWidget *sw_parent = NULL;
2649 static GtkWidget *sw_float_parent;
2650 static guint sw_destroyed_handler = 0;
2653 scrolled_windows_delete_cb (GtkWidget *widget, GdkEventAny *event, GtkWidget *scrollwin)
2655 gtk_widget_reparent (scrollwin, sw_parent);
2657 gtk_signal_disconnect (GTK_OBJECT (sw_parent), sw_destroyed_handler);
2658 sw_float_parent = NULL;
2660 sw_destroyed_handler = 0;
2666 scrolled_windows_destroy_cb (GtkWidget *widget, GtkWidget *scrollwin)
2668 gtk_widget_destroy (sw_float_parent);
2670 sw_float_parent = NULL;
2672 sw_destroyed_handler = 0;
2676 scrolled_windows_remove (GtkWidget *widget, GtkWidget *scrollwin)
2680 gtk_widget_reparent (scrollwin, sw_parent);
2681 gtk_widget_destroy (sw_float_parent);
2683 gtk_signal_disconnect (GTK_OBJECT (sw_parent), sw_destroyed_handler);
2684 sw_float_parent = NULL;
2686 sw_destroyed_handler = 0;
2690 sw_parent = scrollwin->parent;
2691 sw_float_parent = gtk_window_new (GTK_WINDOW_TOPLEVEL);
2692 gtk_window_set_default_size (GTK_WINDOW (sw_float_parent), 200, 200);
2694 gtk_widget_reparent (scrollwin, sw_float_parent);
2695 gtk_widget_show (sw_float_parent);
2697 sw_destroyed_handler =
2698 gtk_signal_connect (GTK_OBJECT (sw_parent), "destroy",
2699 GTK_SIGNAL_FUNC (scrolled_windows_destroy_cb), scrollwin);
2700 gtk_signal_connect (GTK_OBJECT (sw_float_parent), "delete_event",
2701 GTK_SIGNAL_FUNC (scrolled_windows_delete_cb), scrollwin);
2706 create_scrolled_windows (void)
2708 static GtkWidget *window;
2709 GtkWidget *scrolled_window;
2717 window = gtk_dialog_new ();
2719 gtk_signal_connect (GTK_OBJECT (window), "destroy",
2720 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
2723 gtk_window_set_title (GTK_WINDOW (window), "dialog");
2724 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
2727 scrolled_window = gtk_scrolled_window_new (NULL, NULL);
2728 gtk_container_set_border_width (GTK_CONTAINER (scrolled_window), 10);
2729 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
2730 GTK_POLICY_AUTOMATIC,
2731 GTK_POLICY_AUTOMATIC);
2732 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox),
2733 scrolled_window, TRUE, TRUE, 0);
2734 gtk_widget_show (scrolled_window);
2736 table = gtk_table_new (20, 20, FALSE);
2737 gtk_table_set_row_spacings (GTK_TABLE (table), 10);
2738 gtk_table_set_col_spacings (GTK_TABLE (table), 10);
2739 gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (scrolled_window), table);
2740 gtk_container_set_focus_hadjustment (GTK_CONTAINER (table),
2741 gtk_scrolled_window_get_hadjustment (GTK_SCROLLED_WINDOW (scrolled_window)));
2742 gtk_container_set_focus_vadjustment (GTK_CONTAINER (table),
2743 gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (scrolled_window)));
2744 gtk_widget_show (table);
2746 for (i = 0; i < 20; i++)
2747 for (j = 0; j < 20; j++)
2749 sprintf (buffer, "button (%d,%d)\n", i, j);
2750 button = gtk_toggle_button_new_with_label (buffer);
2751 gtk_table_attach_defaults (GTK_TABLE (table), button,
2753 gtk_widget_show (button);
2757 button = gtk_button_new_with_label ("Close");
2758 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
2759 GTK_SIGNAL_FUNC(gtk_widget_destroy),
2760 GTK_OBJECT (window));
2761 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
2762 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
2763 button, TRUE, TRUE, 0);
2764 gtk_widget_grab_default (button);
2765 gtk_widget_show (button);
2767 button = gtk_button_new_with_label ("Reparent Out");
2768 gtk_signal_connect (GTK_OBJECT (button), "clicked",
2769 GTK_SIGNAL_FUNC(scrolled_windows_remove),
2771 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
2772 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
2773 button, TRUE, TRUE, 0);
2774 gtk_widget_grab_default (button);
2775 gtk_widget_show (button);
2777 gtk_window_set_default_size (GTK_WINDOW (window), 300, 300);
2780 if (!GTK_WIDGET_VISIBLE (window))
2781 gtk_widget_show (window);
2783 gtk_widget_destroy (window);
2791 entry_toggle_editable (GtkWidget *checkbutton,
2794 gtk_entry_set_editable(GTK_ENTRY(entry),
2795 GTK_TOGGLE_BUTTON(checkbutton)->active);
2799 entry_toggle_sensitive (GtkWidget *checkbutton,
2802 gtk_widget_set_sensitive (entry, GTK_TOGGLE_BUTTON(checkbutton)->active);
2806 entry_toggle_visibility (GtkWidget *checkbutton,
2809 gtk_entry_set_visibility(GTK_ENTRY(entry),
2810 GTK_TOGGLE_BUTTON(checkbutton)->active);
2816 static GtkWidget *window = NULL;
2819 GtkWidget *editable_check;
2820 GtkWidget *sensitive_check;
2821 GtkWidget *entry, *cb;
2823 GtkWidget *separator;
2824 GList *cbitems = NULL;
2828 cbitems = g_list_append(cbitems, "item0");
2829 cbitems = g_list_append(cbitems, "item1 item1");
2830 cbitems = g_list_append(cbitems, "item2 item2 item2");
2831 cbitems = g_list_append(cbitems, "item3 item3 item3 item3");
2832 cbitems = g_list_append(cbitems, "item4 item4 item4 item4 item4");
2833 cbitems = g_list_append(cbitems, "item5 item5 item5 item5 item5 item5");
2834 cbitems = g_list_append(cbitems, "item6 item6 item6 item6 item6");
2835 cbitems = g_list_append(cbitems, "item7 item7 item7 item7");
2836 cbitems = g_list_append(cbitems, "item8 item8 item8");
2837 cbitems = g_list_append(cbitems, "item9 item9");
2839 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
2841 gtk_signal_connect (GTK_OBJECT (window), "destroy",
2842 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
2845 gtk_window_set_title (GTK_WINDOW (window), "entry");
2846 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
2849 box1 = gtk_vbox_new (FALSE, 0);
2850 gtk_container_add (GTK_CONTAINER (window), box1);
2851 gtk_widget_show (box1);
2854 box2 = gtk_vbox_new (FALSE, 10);
2855 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
2856 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
2857 gtk_widget_show (box2);
2859 entry = gtk_entry_new ();
2860 gtk_entry_set_text (GTK_ENTRY (entry), "hello world السلام عليكم");
2861 gtk_editable_select_region (GTK_EDITABLE (entry), 0, 5);
2862 gtk_box_pack_start (GTK_BOX (box2), entry, TRUE, TRUE, 0);
2863 gtk_widget_show (entry);
2865 cb = gtk_combo_new ();
2866 gtk_combo_set_popdown_strings (GTK_COMBO (cb), cbitems);
2867 gtk_entry_set_text (GTK_ENTRY (GTK_COMBO(cb)->entry), "hello world");
2868 gtk_editable_select_region (GTK_EDITABLE (GTK_COMBO(cb)->entry),
2870 gtk_box_pack_start (GTK_BOX (box2), cb, TRUE, TRUE, 0);
2871 gtk_widget_show (cb);
2873 editable_check = gtk_check_button_new_with_label("Editable");
2874 gtk_box_pack_start (GTK_BOX (box2), editable_check, FALSE, TRUE, 0);
2875 gtk_signal_connect (GTK_OBJECT(editable_check), "toggled",
2876 GTK_SIGNAL_FUNC(entry_toggle_editable), entry);
2877 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(editable_check), TRUE);
2878 gtk_widget_show (editable_check);
2880 editable_check = gtk_check_button_new_with_label("Visible");
2881 gtk_box_pack_start (GTK_BOX (box2), editable_check, FALSE, TRUE, 0);
2882 gtk_signal_connect (GTK_OBJECT(editable_check), "toggled",
2883 GTK_SIGNAL_FUNC(entry_toggle_visibility), entry);
2884 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(editable_check), TRUE);
2885 gtk_widget_show (editable_check);
2887 sensitive_check = gtk_check_button_new_with_label("Sensitive");
2888 gtk_box_pack_start (GTK_BOX (box2), sensitive_check, FALSE, TRUE, 0);
2889 gtk_signal_connect (GTK_OBJECT(sensitive_check), "toggled",
2890 GTK_SIGNAL_FUNC(entry_toggle_sensitive), entry);
2891 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(sensitive_check), TRUE);
2892 gtk_widget_show (sensitive_check);
2894 separator = gtk_hseparator_new ();
2895 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
2896 gtk_widget_show (separator);
2899 box2 = gtk_vbox_new (FALSE, 10);
2900 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
2901 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
2902 gtk_widget_show (box2);
2905 button = gtk_button_new_with_label ("close");
2906 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
2907 GTK_SIGNAL_FUNC(gtk_widget_destroy),
2908 GTK_OBJECT (window));
2909 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
2910 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
2911 gtk_widget_grab_default (button);
2912 gtk_widget_show (button);
2915 if (!GTK_WIDGET_VISIBLE (window))
2916 gtk_widget_show (window);
2918 gtk_widget_destroy (window);
2925 static GtkWidget *spinner1;
2928 toggle_snap (GtkWidget *widget, GtkSpinButton *spin)
2930 gtk_spin_button_set_snap_to_ticks (spin, GTK_TOGGLE_BUTTON (widget)->active);
2934 toggle_numeric (GtkWidget *widget, GtkSpinButton *spin)
2936 gtk_spin_button_set_numeric (spin, GTK_TOGGLE_BUTTON (widget)->active);
2940 change_digits (GtkWidget *widget, GtkSpinButton *spin)
2942 gtk_spin_button_set_digits (GTK_SPIN_BUTTON (spinner1),
2943 gtk_spin_button_get_value_as_int (spin));
2947 get_value (GtkWidget *widget, gpointer data)
2951 GtkSpinButton *spin;
2953 spin = GTK_SPIN_BUTTON (spinner1);
2954 label = GTK_LABEL (gtk_object_get_user_data (GTK_OBJECT (widget)));
2955 if (GPOINTER_TO_INT (data) == 1)
2956 sprintf (buf, "%d", gtk_spin_button_get_value_as_int (spin));
2958 sprintf (buf, "%0.*f", spin->digits,
2959 gtk_spin_button_get_value_as_float (spin));
2960 gtk_label_set_text (label, buf);
2964 spin_button_time_output_func (GtkSpinButton *spin_button)
2966 static gchar buf[6];
2970 hours = spin_button->adjustment->value / 60.0;
2971 minutes = (fabs(floor (hours) - hours) < 1e-5) ? 0.0 : 30;
2972 sprintf (buf, "%02.0f:%02.0f", floor (hours), minutes);
2973 if (strcmp (buf, gtk_entry_get_text (GTK_ENTRY (spin_button))))
2974 gtk_entry_set_text (GTK_ENTRY (spin_button), buf);
2979 spin_button_month_input_func (GtkSpinButton *spin_button,
2983 static gchar *month[12] = { "January", "February", "March", "April",
2984 "May", "June", "July", "August",
2985 "September", "October", "November", "December" };
2987 gboolean found = FALSE;
2989 for (i = 1; i <= 12; i++)
2991 tmp1 = g_strdup (month[i-1]);
2993 tmp2 = g_strdup (gtk_entry_get_text (GTK_ENTRY (spin_button)));
2995 if (strstr (tmp1, tmp2) == tmp1)
3007 *new_val = (gfloat) i;
3012 spin_button_month_output_func (GtkSpinButton *spin_button)
3015 static gchar *month[12] = { "January", "February", "March", "April",
3016 "May", "June", "July", "August", "September",
3017 "October", "November", "December" };
3019 for (i = 1; i <= 12; i++)
3020 if (fabs (spin_button->adjustment->value - (double)i) < 1e-5)
3022 if (strcmp (month[i-1], gtk_entry_get_text (GTK_ENTRY (spin_button))))
3023 gtk_entry_set_text (GTK_ENTRY (spin_button), month[i-1]);
3029 spin_button_hex_input_func (GtkSpinButton *spin_button,
3036 buf = gtk_entry_get_text (GTK_ENTRY (spin_button));
3037 res = (gfloat)(strtol(buf, &err, 16));
3046 spin_button_hex_output_func (GtkSpinButton *spin_button)
3048 static gchar buf[7];
3051 val = (gint) spin_button->adjustment->value;
3052 if (fabs (val) < 1e-5)
3053 sprintf (buf, "0x00");
3055 sprintf (buf, "0x%.2X", val);
3056 if (strcmp (buf, gtk_entry_get_text (GTK_ENTRY (spin_button))))
3057 gtk_entry_set_text (GTK_ENTRY (spin_button), buf);
3064 static GtkWidget *window = NULL;
3067 GtkWidget *main_vbox;
3070 GtkWidget *spinner2;
3074 GtkWidget *val_label;
3079 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
3081 gtk_signal_connect (GTK_OBJECT (window), "destroy",
3082 GTK_SIGNAL_FUNC (gtk_widget_destroyed),
3085 gtk_window_set_title (GTK_WINDOW (window), "GtkSpinButton");
3087 main_vbox = gtk_vbox_new (FALSE, 5);
3088 gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 10);
3089 gtk_container_add (GTK_CONTAINER (window), main_vbox);
3091 frame = gtk_frame_new ("Not accelerated");
3092 gtk_box_pack_start (GTK_BOX (main_vbox), frame, TRUE, TRUE, 0);
3094 vbox = gtk_vbox_new (FALSE, 0);
3095 gtk_container_set_border_width (GTK_CONTAINER (vbox), 5);
3096 gtk_container_add (GTK_CONTAINER (frame), vbox);
3098 /* Time, month, hex spinners */
3100 hbox = gtk_hbox_new (FALSE, 0);
3101 gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 5);
3103 vbox2 = gtk_vbox_new (FALSE, 0);
3104 gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 5);
3106 label = gtk_label_new ("Time :");
3107 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
3108 gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, TRUE, 0);
3110 adj = (GtkAdjustment *) gtk_adjustment_new (0, 0, 1410, 30, 60, 0);
3111 spinner = gtk_spin_button_new (adj, 0, 0);
3112 gtk_editable_set_editable (GTK_EDITABLE (spinner), FALSE);
3113 gtk_signal_connect (GTK_OBJECT (spinner),
3115 GTK_SIGNAL_FUNC (spin_button_time_output_func),
3117 gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spinner), TRUE);
3118 gtk_widget_set_usize (spinner, 55, -1);
3119 gtk_box_pack_start (GTK_BOX (vbox2), spinner, FALSE, TRUE, 0);
3121 vbox2 = gtk_vbox_new (FALSE, 0);
3122 gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 5);
3124 label = gtk_label_new ("Month :");
3125 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
3126 gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, TRUE, 0);
3128 adj = (GtkAdjustment *) gtk_adjustment_new (1.0, 1.0, 12.0, 1.0,
3130 spinner = gtk_spin_button_new (adj, 0, 0);
3131 gtk_spin_button_set_update_policy (GTK_SPIN_BUTTON (spinner),
3132 GTK_UPDATE_IF_VALID);
3133 gtk_signal_connect (GTK_OBJECT (spinner),
3135 GTK_SIGNAL_FUNC (spin_button_month_input_func),
3137 gtk_signal_connect (GTK_OBJECT (spinner),
3139 GTK_SIGNAL_FUNC (spin_button_month_output_func),
3141 gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spinner), TRUE);
3142 gtk_widget_set_usize (spinner, 85, -1);
3143 gtk_box_pack_start (GTK_BOX (vbox2), spinner, FALSE, TRUE, 0);
3145 vbox2 = gtk_vbox_new (FALSE, 0);
3146 gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 5);
3148 label = gtk_label_new ("Hex :");
3149 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
3150 gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, TRUE, 0);
3152 adj = (GtkAdjustment *) gtk_adjustment_new (0, 0, 255, 1, 16, 0);
3153 spinner = gtk_spin_button_new (adj, 0, 0);
3154 gtk_editable_set_editable (GTK_EDITABLE (spinner), TRUE);
3155 gtk_signal_connect (GTK_OBJECT (spinner),
3157 GTK_SIGNAL_FUNC (spin_button_hex_input_func),
3159 gtk_signal_connect (GTK_OBJECT (spinner),
3161 GTK_SIGNAL_FUNC (spin_button_hex_output_func),
3163 gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spinner), TRUE);
3164 gtk_widget_set_usize (spinner, 55, 0);
3165 gtk_box_pack_start (GTK_BOX (vbox2), spinner, FALSE, TRUE, 0);
3167 frame = gtk_frame_new ("Accelerated");
3168 gtk_box_pack_start (GTK_BOX (main_vbox), frame, TRUE, TRUE, 0);
3170 vbox = gtk_vbox_new (FALSE, 0);
3171 gtk_container_set_border_width (GTK_CONTAINER (vbox), 5);
3172 gtk_container_add (GTK_CONTAINER (frame), vbox);
3174 hbox = gtk_hbox_new (FALSE, 0);
3175 gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 5);
3177 vbox2 = gtk_vbox_new (FALSE, 0);
3178 gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 5);
3180 label = gtk_label_new ("Value :");
3181 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
3182 gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, TRUE, 0);
3184 adj = (GtkAdjustment *) gtk_adjustment_new (0.0, -10000.0, 10000.0,
3186 spinner1 = gtk_spin_button_new (adj, 1.0, 2);
3187 gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spinner1), TRUE);
3188 gtk_widget_set_usize (spinner1, 100, 0);
3189 gtk_box_pack_start (GTK_BOX (vbox2), spinner1, FALSE, TRUE, 0);
3191 vbox2 = gtk_vbox_new (FALSE, 0);
3192 gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 5);
3194 label = gtk_label_new ("Digits :");
3195 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
3196 gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, TRUE, 0);
3198 adj = (GtkAdjustment *) gtk_adjustment_new (2, 1, 5, 1, 1, 0);
3199 spinner2 = gtk_spin_button_new (adj, 0.0, 0);
3200 gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
3201 GTK_SIGNAL_FUNC (change_digits),
3202 (gpointer) spinner2);
3203 gtk_box_pack_start (GTK_BOX (vbox2), spinner2, FALSE, TRUE, 0);
3205 hbox = gtk_hbox_new (FALSE, 0);
3206 gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 5);
3208 button = gtk_check_button_new_with_label ("Snap to 0.5-ticks");
3209 gtk_signal_connect (GTK_OBJECT (button), "clicked",
3210 GTK_SIGNAL_FUNC (toggle_snap),
3212 gtk_box_pack_start (GTK_BOX (vbox), button, TRUE, TRUE, 0);
3213 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
3215 button = gtk_check_button_new_with_label ("Numeric only input mode");
3216 gtk_signal_connect (GTK_OBJECT (button), "clicked",
3217 GTK_SIGNAL_FUNC (toggle_numeric),
3219 gtk_box_pack_start (GTK_BOX (vbox), button, TRUE, TRUE, 0);
3220 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
3222 val_label = gtk_label_new ("");
3224 hbox = gtk_hbox_new (FALSE, 0);
3225 gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 5);
3227 button = gtk_button_new_with_label ("Value as Int");
3228 gtk_object_set_user_data (GTK_OBJECT (button), val_label);
3229 gtk_signal_connect (GTK_OBJECT (button), "clicked",
3230 GTK_SIGNAL_FUNC (get_value),
3231 GINT_TO_POINTER (1));
3232 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
3234 button = gtk_button_new_with_label ("Value as Float");
3235 gtk_object_set_user_data (GTK_OBJECT (button), val_label);
3236 gtk_signal_connect (GTK_OBJECT (button), "clicked",
3237 GTK_SIGNAL_FUNC (get_value),
3238 GINT_TO_POINTER (2));
3239 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
3241 gtk_box_pack_start (GTK_BOX (vbox), val_label, TRUE, TRUE, 0);
3242 gtk_label_set_text (GTK_LABEL (val_label), "0");
3244 hbox = gtk_hbox_new (FALSE, 0);
3245 gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, TRUE, 0);
3247 button = gtk_button_new_with_label ("Close");
3248 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
3249 GTK_SIGNAL_FUNC (gtk_widget_destroy),
3250 GTK_OBJECT (window));
3251 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
3254 if (!GTK_WIDGET_VISIBLE (window))
3255 gtk_widget_show_all (window);
3257 gtk_widget_destroy (window);
3266 cursor_expose_event (GtkWidget *widget,
3270 GtkDrawingArea *darea;
3271 GdkDrawable *drawable;
3278 g_return_val_if_fail (widget != NULL, TRUE);
3279 g_return_val_if_fail (GTK_IS_DRAWING_AREA (widget), TRUE);
3281 darea = GTK_DRAWING_AREA (widget);
3282 drawable = widget->window;
3283 white_gc = widget->style->white_gc;
3284 gray_gc = widget->style->bg_gc[GTK_STATE_NORMAL];
3285 black_gc = widget->style->black_gc;
3286 max_width = widget->allocation.width;
3287 max_height = widget->allocation.height;
3289 gdk_draw_rectangle (drawable, white_gc,
3296 gdk_draw_rectangle (drawable, black_gc,
3303 gdk_draw_rectangle (drawable, gray_gc,
3314 set_cursor (GtkWidget *spinner,
3322 c = CLAMP (gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (spinner)), 0, 152);
3325 label = gtk_object_get_user_data (GTK_OBJECT (spinner));
3326 vals = gtk_type_enum_get_values (GTK_TYPE_GDK_CURSOR_TYPE);
3327 while (vals && vals->value != c)
3330 gtk_label_set_text (GTK_LABEL (label), vals->value_nick);
3332 gtk_label_set_text (GTK_LABEL (label), "<unknown>");
3334 cursor = gdk_cursor_new (c);
3335 gdk_window_set_cursor (widget->window, cursor);
3336 gdk_cursor_unref (cursor);
3340 cursor_event (GtkWidget *widget,
3342 GtkSpinButton *spinner)
3344 if ((event->type == GDK_BUTTON_PRESS) &&
3345 ((event->button.button == 1) ||
3346 (event->button.button == 3)))
3348 gtk_spin_button_spin (spinner, event->button.button == 1 ?
3349 GTK_SPIN_STEP_FORWARD : GTK_SPIN_STEP_BACKWARD, 0);
3357 create_cursors (void)
3359 static GtkWidget *window = NULL;
3362 GtkWidget *main_vbox;
3373 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
3375 gtk_signal_connect (GTK_OBJECT (window), "destroy",
3376 GTK_SIGNAL_FUNC (gtk_widget_destroyed),
3379 gtk_window_set_title (GTK_WINDOW (window), "Cursors");
3381 main_vbox = gtk_vbox_new (FALSE, 5);
3382 gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 0);
3383 gtk_container_add (GTK_CONTAINER (window), main_vbox);
3386 gtk_widget_new (gtk_vbox_get_type (),
3387 "GtkBox::homogeneous", FALSE,
3388 "GtkBox::spacing", 5,
3389 "GtkContainer::border_width", 10,
3390 "GtkWidget::parent", main_vbox,
3391 "GtkWidget::visible", TRUE,
3394 hbox = gtk_hbox_new (FALSE, 0);
3395 gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
3396 gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0);
3398 label = gtk_label_new ("Cursor Value : ");
3399 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
3400 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
3402 adj = (GtkAdjustment *) gtk_adjustment_new (0,
3406 spinner = gtk_spin_button_new (adj, 0, 0);
3407 gtk_box_pack_start (GTK_BOX (hbox), spinner, TRUE, TRUE, 0);
3410 gtk_widget_new (gtk_frame_get_type (),
3411 "GtkFrame::shadow", GTK_SHADOW_ETCHED_IN,
3412 "GtkFrame::label_xalign", 0.5,
3413 "GtkFrame::label", "Cursor Area",
3414 "GtkContainer::border_width", 10,
3415 "GtkWidget::parent", vbox,
3416 "GtkWidget::visible", TRUE,
3419 darea = gtk_drawing_area_new ();
3420 gtk_widget_set_usize (darea, 80, 80);
3421 gtk_container_add (GTK_CONTAINER (frame), darea);
3422 gtk_signal_connect (GTK_OBJECT (darea),
3424 GTK_SIGNAL_FUNC (cursor_expose_event),
3426 gtk_widget_set_events (darea, GDK_EXPOSURE_MASK | GDK_BUTTON_PRESS_MASK);
3427 gtk_signal_connect (GTK_OBJECT (darea),
3428 "button_press_event",
3429 GTK_SIGNAL_FUNC (cursor_event),
3431 gtk_widget_show (darea);
3433 gtk_signal_connect (GTK_OBJECT (spinner), "changed",
3434 GTK_SIGNAL_FUNC (set_cursor),
3437 label = gtk_widget_new (GTK_TYPE_LABEL,
3442 gtk_container_child_set (GTK_CONTAINER (vbox), label,
3445 gtk_object_set_user_data (GTK_OBJECT (spinner), label);
3448 gtk_widget_new (gtk_hseparator_get_type (),
3449 "GtkWidget::visible", TRUE,
3451 gtk_box_pack_start (GTK_BOX (main_vbox), any, FALSE, TRUE, 0);
3453 hbox = gtk_hbox_new (FALSE, 0);
3454 gtk_container_set_border_width (GTK_CONTAINER (hbox), 10);
3455 gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, TRUE, 0);
3457 button = gtk_button_new_with_label ("Close");
3458 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
3459 GTK_SIGNAL_FUNC (gtk_widget_destroy),
3460 GTK_OBJECT (window));
3461 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
3463 gtk_widget_show_all (window);
3465 set_cursor (spinner, darea);
3468 gtk_widget_destroy (window);
3476 list_add (GtkWidget *widget,
3481 GtkWidget *list_item;
3482 GtkContainer *container;
3484 container = GTK_CONTAINER (list);
3486 sprintf (buffer, "added item %d", i++);
3487 list_item = gtk_list_item_new_with_label (buffer);
3488 gtk_widget_show (list_item);
3490 gtk_container_add (container, list_item);
3494 list_remove (GtkWidget *widget,
3497 GList *clear_list = NULL;
3498 GList *sel_row = NULL;
3501 if (list->selection_mode == GTK_SELECTION_EXTENDED)
3505 item = GTK_CONTAINER (list)->focus_child;
3506 if (!item && list->selection)
3507 item = list->selection->data;
3511 work = g_list_find (list->children, item);
3512 for (sel_row = work; sel_row; sel_row = sel_row->next)
3513 if (GTK_WIDGET (sel_row->data)->state != GTK_STATE_SELECTED)
3518 for (sel_row = work; sel_row; sel_row = sel_row->prev)
3519 if (GTK_WIDGET (sel_row->data)->state != GTK_STATE_SELECTED)
3525 for (work = list->selection; work; work = work->next)
3526 clear_list = g_list_prepend (clear_list, work->data);
3528 clear_list = g_list_reverse (clear_list);
3529 gtk_list_remove_items (GTK_LIST (list), clear_list);
3530 g_list_free (clear_list);
3532 if (list->selection_mode == GTK_SELECTION_EXTENDED && sel_row)
3533 gtk_list_select_child (list, GTK_WIDGET(sel_row->data));
3537 list_clear (GtkWidget *widget,
3540 gtk_list_clear_items (GTK_LIST (list), 0, -1);
3543 #define RADIOMENUTOGGLED(_rmi_, __i) { \
3546 __g = gtk_radio_menu_item_group(_rmi_); \
3547 while( __g && !((GtkCheckMenuItem *)(__g->data))->active) { \
3553 static GtkWidget *list_omenu;
3556 list_toggle_sel_mode (GtkWidget *widget, GtkList *list)
3560 if (!GTK_WIDGET_MAPPED (widget))
3563 RADIOMENUTOGGLED ((GtkRadioMenuItem *)
3564 (((GtkOptionMenu *)list_omenu)->menu_item), i);
3566 gtk_list_set_selection_mode (list, (GtkSelectionMode) (3-i));
3572 static GtkWidget *window = NULL;
3574 static OptionMenuItem items[] =
3576 { "Single", list_toggle_sel_mode },
3577 { "Browse", list_toggle_sel_mode },
3578 { "Multiple", list_toggle_sel_mode },
3579 { "Extended", list_toggle_sel_mode }
3588 GtkWidget *scrolled_win;
3591 GtkWidget *separator;
3594 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
3596 gtk_signal_connect (GTK_OBJECT (window), "destroy",
3597 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
3600 gtk_window_set_title (GTK_WINDOW (window), "list");
3601 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
3603 vbox = gtk_vbox_new (FALSE, 0);
3604 gtk_container_add (GTK_CONTAINER (window), vbox);
3606 scrolled_win = gtk_scrolled_window_new (NULL, NULL);
3607 gtk_container_set_border_width (GTK_CONTAINER (scrolled_win), 5);
3608 gtk_widget_set_usize (scrolled_win, -1, 300);
3609 gtk_box_pack_start (GTK_BOX (vbox), scrolled_win, TRUE, TRUE, 0);
3610 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
3611 GTK_POLICY_AUTOMATIC,
3612 GTK_POLICY_AUTOMATIC);
3614 list = gtk_list_new ();
3615 gtk_list_set_selection_mode (GTK_LIST (list), GTK_SELECTION_EXTENDED);
3616 gtk_scrolled_window_add_with_viewport
3617 (GTK_SCROLLED_WINDOW (scrolled_win), list);
3618 gtk_container_set_focus_vadjustment
3619 (GTK_CONTAINER (list),
3620 gtk_scrolled_window_get_vadjustment
3621 (GTK_SCROLLED_WINDOW (scrolled_win)));
3622 gtk_container_set_focus_hadjustment
3623 (GTK_CONTAINER (list),
3624 gtk_scrolled_window_get_hadjustment
3625 (GTK_SCROLLED_WINDOW (scrolled_win)));
3627 if ((infile = fopen("gtkenums.h", "r")))
3633 while (fgets (buffer, 256, infile))
3635 if ((pos = strchr (buffer, '\n')))
3637 item = gtk_list_item_new_with_label (buffer);
3638 gtk_container_add (GTK_CONTAINER (list), item);
3645 hbox = gtk_hbox_new (TRUE, 5);
3646 gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
3647 gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0);
3649 button = gtk_button_new_with_label ("Insert Row");
3650 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
3651 gtk_signal_connect (GTK_OBJECT (button), "clicked",
3652 GTK_SIGNAL_FUNC (list_add),
3655 button = gtk_button_new_with_label ("Clear List");
3656 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
3657 gtk_signal_connect (GTK_OBJECT (button), "clicked",
3658 GTK_SIGNAL_FUNC (list_clear),
3661 button = gtk_button_new_with_label ("Remove Selection");
3662 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
3663 gtk_signal_connect (GTK_OBJECT (button), "clicked",
3664 GTK_SIGNAL_FUNC (list_remove),
3667 cbox = gtk_hbox_new (FALSE, 0);
3668 gtk_box_pack_start (GTK_BOX (vbox), cbox, FALSE, TRUE, 0);
3670 hbox = gtk_hbox_new (FALSE, 5);
3671 gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
3672 gtk_box_pack_start (GTK_BOX (cbox), hbox, TRUE, FALSE, 0);
3674 label = gtk_label_new ("Selection Mode :");
3675 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
3677 list_omenu = build_option_menu (items, 4, 3, list);
3678 gtk_box_pack_start (GTK_BOX (hbox), list_omenu, FALSE, TRUE, 0);
3680 separator = gtk_hseparator_new ();
3681 gtk_box_pack_start (GTK_BOX (vbox), separator, FALSE, TRUE, 0);
3683 cbox = gtk_hbox_new (FALSE, 0);
3684 gtk_box_pack_start (GTK_BOX (vbox), cbox, FALSE, TRUE, 0);
3686 button = gtk_button_new_with_label ("close");
3687 gtk_container_set_border_width (GTK_CONTAINER (button), 10);
3688 gtk_box_pack_start (GTK_BOX (cbox), button, TRUE, TRUE, 0);
3689 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
3690 GTK_SIGNAL_FUNC(gtk_widget_destroy),
3691 GTK_OBJECT (window));
3693 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
3694 gtk_widget_grab_default (button);
3697 if (!GTK_WIDGET_VISIBLE (window))
3698 gtk_widget_show_all (window);
3700 gtk_widget_destroy (window);
3707 static char * book_open_xpm[] = {
3730 static char * book_closed_xpm[] = {
3755 static char * mini_page_xpm[] = {
3778 static char * gtk_mini_xpm[] = {
3818 #define TESTGTK_CLIST_COLUMNS 12
3819 static gint clist_rows = 0;
3820 static GtkWidget *clist_omenu;
3823 add1000_clist (GtkWidget *widget, gpointer data)
3826 char text[TESTGTK_CLIST_COLUMNS][50];
3827 char *texts[TESTGTK_CLIST_COLUMNS];
3832 clist = GTK_CLIST (data);
3834 pixmap = gdk_pixmap_create_from_xpm_d (clist->clist_window,
3836 >K_WIDGET (data)->style->white,
3839 for (i = 0; i < TESTGTK_CLIST_COLUMNS; i++)
3842 sprintf (text[i], "Column %d", i);
3846 sprintf (text[1], "Right");
3847 sprintf (text[2], "Center");
3849 gtk_clist_freeze (GTK_CLIST (data));
3850 for (i = 0; i < 1000; i++)
3852 sprintf (text[0], "CListRow %d", rand() % 10000);
3853 row = gtk_clist_append (clist, texts);
3854 gtk_clist_set_pixtext (clist, row, 3, "gtk+", 5, pixmap, mask);
3857 gtk_clist_thaw (GTK_CLIST (data));
3859 gdk_pixmap_unref (pixmap);
3860 gdk_bitmap_unref (mask);
3864 add10000_clist (GtkWidget *widget, gpointer data)
3867 char text[TESTGTK_CLIST_COLUMNS][50];
3868 char *texts[TESTGTK_CLIST_COLUMNS];
3870 for (i = 0; i < TESTGTK_CLIST_COLUMNS; i++)
3873 sprintf (text[i], "Column %d", i);
3876 sprintf (text[1], "Right");
3877 sprintf (text[2], "Center");
3879 gtk_clist_freeze (GTK_CLIST (data));
3880 for (i = 0; i < 10000; i++)
3882 sprintf (text[0], "CListRow %d", rand() % 10000);
3883 gtk_clist_append (GTK_CLIST (data), texts);
3885 gtk_clist_thaw (GTK_CLIST (data));
3889 clear_clist (GtkWidget *widget, gpointer data)
3891 gtk_clist_clear (GTK_CLIST (data));
3895 void clist_remove_selection (GtkWidget *widget, GtkCList *clist)
3897 gtk_clist_freeze (clist);
3899 while (clist->selection)
3904 row = GPOINTER_TO_INT (clist->selection->data);
3906 gtk_clist_remove (clist, row);
3908 if (clist->selection_mode == GTK_SELECTION_BROWSE)
3912 if (clist->selection_mode == GTK_SELECTION_EXTENDED && !clist->selection &&
3913 clist->focus_row >= 0)
3914 gtk_clist_select_row (clist, clist->focus_row, -1);
3916 gtk_clist_thaw (clist);
3919 void toggle_title_buttons (GtkWidget *widget, GtkCList *clist)
3921 if (GTK_TOGGLE_BUTTON (widget)->active)
3922 gtk_clist_column_titles_show (clist);
3924 gtk_clist_column_titles_hide (clist);
3927 void toggle_reorderable (GtkWidget *widget, GtkCList *clist)
3929 gtk_clist_set_reorderable (clist, GTK_TOGGLE_BUTTON (widget)->active);
3933 insert_row_clist (GtkWidget *widget, gpointer data)
3935 static char *text[] =
3937 "This", "is an", "inserted", "row.",
3938 "This", "is an", "inserted", "row.",
3939 "This", "is an", "inserted", "row."
3942 static GtkStyle *style1 = NULL;
3943 static GtkStyle *style2 = NULL;
3944 static GtkStyle *style3 = NULL;
3947 if (GTK_CLIST (data)->focus_row >= 0)
3948 row = gtk_clist_insert (GTK_CLIST (data), GTK_CLIST (data)->focus_row,
3951 row = gtk_clist_prepend (GTK_CLIST (data), text);
3965 style1 = gtk_style_copy (GTK_WIDGET (data)->style);
3966 style1->base[GTK_STATE_NORMAL] = col1;
3967 style1->base[GTK_STATE_SELECTED] = col2;
3969 style2 = gtk_style_copy (GTK_WIDGET (data)->style);
3970 style2->fg[GTK_STATE_NORMAL] = col1;
3971 style2->fg[GTK_STATE_SELECTED] = col2;
3973 style3 = gtk_style_copy (GTK_WIDGET (data)->style);
3974 style3->fg[GTK_STATE_NORMAL] = col1;
3975 style3->base[GTK_STATE_NORMAL] = col2;
3976 pango_font_description_free (style3->font_desc);
3977 style3->font_desc = pango_font_description_from_string ("courier 12");
3980 gtk_clist_set_cell_style (GTK_CLIST (data), row, 3, style1);
3981 gtk_clist_set_cell_style (GTK_CLIST (data), row, 4, style2);
3982 gtk_clist_set_cell_style (GTK_CLIST (data), row, 0, style3);
3988 clist_warning_test (GtkWidget *button,
3992 static gboolean add_remove = FALSE;
3994 add_remove = !add_remove;
3996 child = gtk_label_new ("Test");
3997 gtk_widget_ref (child);
3998 gtk_object_sink (GTK_OBJECT (child));
4001 gtk_container_add (GTK_CONTAINER (clist), child);
4004 child->parent = clist;
4005 gtk_container_remove (GTK_CONTAINER (clist), child);
4006 child->parent = NULL;
4009 gtk_widget_destroy (child);
4010 gtk_widget_unref (child);
4014 undo_selection (GtkWidget *button, GtkCList *clist)
4016 gtk_clist_undo_selection (clist);
4020 clist_toggle_sel_mode (GtkWidget *widget, GtkCList *clist)
4024 if (!GTK_WIDGET_MAPPED (widget))
4027 RADIOMENUTOGGLED ((GtkRadioMenuItem *)
4028 (((GtkOptionMenu *)clist_omenu)->menu_item), i);
4030 gtk_clist_set_selection_mode (clist, (GtkSelectionMode) (3-i));
4034 clist_click_column (GtkCList *clist, gint column, gpointer data)
4037 gtk_clist_set_column_visibility (clist, column, FALSE);
4038 else if (column == clist->sort_column)
4040 if (clist->sort_type == GTK_SORT_ASCENDING)
4041 clist->sort_type = GTK_SORT_DESCENDING;
4043 clist->sort_type = GTK_SORT_ASCENDING;
4046 gtk_clist_set_sort_column (clist, column);
4048 gtk_clist_sort (clist);
4055 static GtkWidget *window = NULL;
4057 static char *titles[] =
4059 "auto resize", "not resizeable", "max width 100", "min width 50",
4060 "hide column", "Title 5", "Title 6", "Title 7",
4061 "Title 8", "Title 9", "Title 10", "Title 11"
4064 static OptionMenuItem items[] =
4066 { "Single", clist_toggle_sel_mode },
4067 { "Browse", clist_toggle_sel_mode },
4068 { "Multiple", clist_toggle_sel_mode },
4069 { "Extended", clist_toggle_sel_mode }
4072 char text[TESTGTK_CLIST_COLUMNS][50];
4073 char *texts[TESTGTK_CLIST_COLUMNS];
4079 GtkWidget *separator;
4080 GtkWidget *scrolled_win;
4083 GtkWidget *undo_button;
4093 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
4095 gtk_signal_connect (GTK_OBJECT (window), "destroy",
4096 GTK_SIGNAL_FUNC (gtk_widget_destroyed), &window);
4098 gtk_window_set_title (GTK_WINDOW (window), "clist");
4099 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
4101 vbox = gtk_vbox_new (FALSE, 0);
4102 gtk_container_add (GTK_CONTAINER (window), vbox);
4104 scrolled_win = gtk_scrolled_window_new (NULL, NULL);
4105 gtk_container_set_border_width (GTK_CONTAINER (scrolled_win), 5);
4106 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
4107 GTK_POLICY_AUTOMATIC,
4108 GTK_POLICY_AUTOMATIC);
4110 /* create GtkCList here so we have a pointer to throw at the
4111 * button callbacks -- more is done with it later */
4112 clist = gtk_clist_new_with_titles (TESTGTK_CLIST_COLUMNS, titles);
4113 gtk_container_add (GTK_CONTAINER (scrolled_win), clist);
4114 gtk_signal_connect (GTK_OBJECT (clist), "click_column",
4115 (GtkSignalFunc) clist_click_column, NULL);
4117 /* control buttons */
4118 hbox = gtk_hbox_new (FALSE, 5);
4119 gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
4120 gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
4122 button = gtk_button_new_with_label ("Insert Row");
4123 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
4124 gtk_signal_connect (GTK_OBJECT (button), "clicked",
4125 (GtkSignalFunc) insert_row_clist, (gpointer) clist);
4127 button = gtk_button_new_with_label ("Add 1,000 Rows With Pixmaps");
4128 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
4129 gtk_signal_connect (GTK_OBJECT (button), "clicked",
4130 (GtkSignalFunc) add1000_clist, (gpointer) clist);
4132 button = gtk_button_new_with_label ("Add 10,000 Rows");
4133 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
4134 gtk_signal_connect (GTK_OBJECT (button), "clicked",
4135 (GtkSignalFunc) add10000_clist, (gpointer) clist);
4137 /* second layer of buttons */
4138 hbox = gtk_hbox_new (FALSE, 5);
4139 gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
4140 gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
4142 button = gtk_button_new_with_label ("Clear List");
4143 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
4144 gtk_signal_connect (GTK_OBJECT (button), "clicked",
4145 (GtkSignalFunc) clear_clist, (gpointer) clist);
4147 button = gtk_button_new_with_label ("Remove Selection");
4148 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
4149 gtk_signal_connect (GTK_OBJECT (button), "clicked",
4150 (GtkSignalFunc) clist_remove_selection,
4153 undo_button = gtk_button_new_with_label ("Undo Selection");
4154 gtk_box_pack_start (GTK_BOX (hbox), undo_button, TRUE, TRUE, 0);
4155 gtk_signal_connect (GTK_OBJECT (undo_button), "clicked",
4156 (GtkSignalFunc) undo_selection, (gpointer) clist);
4158 button = gtk_button_new_with_label ("Warning Test");
4159 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
4160 gtk_signal_connect (GTK_OBJECT (button), "clicked",
4161 (GtkSignalFunc) clist_warning_test,(gpointer) clist);
4163 /* third layer of buttons */
4164 hbox = gtk_hbox_new (FALSE, 5);
4165 gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
4166 gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
4168 check = gtk_check_button_new_with_label ("Show Title Buttons");
4169 gtk_box_pack_start (GTK_BOX (hbox), check, FALSE, TRUE, 0);
4170 gtk_signal_connect (GTK_OBJECT (check), "clicked",
4171 GTK_SIGNAL_FUNC (toggle_title_buttons), clist);
4172 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check), TRUE);
4174 check = gtk_check_button_new_with_label ("Reorderable");
4175 gtk_box_pack_start (GTK_BOX (hbox), check, FALSE, TRUE, 0);
4176 gtk_signal_connect (GTK_OBJECT (check), "clicked",
4177 GTK_SIGNAL_FUNC (toggle_reorderable), clist);
4178 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check), TRUE);
4180 label = gtk_label_new ("Selection Mode :");
4181 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
4183 clist_omenu = build_option_menu (items, 4, 3, clist);
4184 gtk_box_pack_start (GTK_BOX (hbox), clist_omenu, FALSE, TRUE, 0);
4187 * the rest of the clist configuration
4190 gtk_box_pack_start (GTK_BOX (vbox), scrolled_win, TRUE, TRUE, 0);
4191 gtk_clist_set_row_height (GTK_CLIST (clist), 18);
4192 gtk_widget_set_usize (clist, -1, 300);
4194 for (i = 1; i < TESTGTK_CLIST_COLUMNS; i++)
4195 gtk_clist_set_column_width (GTK_CLIST (clist), i, 80);
4197 gtk_clist_set_column_auto_resize (GTK_CLIST (clist), 0, TRUE);
4198 gtk_clist_set_column_resizeable (GTK_CLIST (clist), 1, FALSE);
4199 gtk_clist_set_column_max_width (GTK_CLIST (clist), 2, 100);
4200 gtk_clist_set_column_min_width (GTK_CLIST (clist), 3, 50);
4201 gtk_clist_set_selection_mode (GTK_CLIST (clist), GTK_SELECTION_EXTENDED);
4202 gtk_clist_set_column_justification (GTK_CLIST (clist), 1,
4204 gtk_clist_set_column_justification (GTK_CLIST (clist), 2,
4205 GTK_JUSTIFY_CENTER);
4207 for (i = 0; i < TESTGTK_CLIST_COLUMNS; i++)
4210 sprintf (text[i], "Column %d", i);
4213 sprintf (text[1], "Right");
4214 sprintf (text[2], "Center");
4223 style = gtk_style_new ();
4224 style->fg[GTK_STATE_NORMAL] = col1;
4225 style->base[GTK_STATE_NORMAL] = col2;
4227 style->font_desc->size = 14 * PANGO_SCALE;
4228 style->font_desc->weight = PANGO_WEIGHT_BOLD;
4230 for (i = 0; i < 10; i++)
4232 sprintf (text[0], "CListRow %d", clist_rows++);
4233 gtk_clist_append (GTK_CLIST (clist), texts);
4238 gtk_clist_set_row_style (GTK_CLIST (clist), i, style);
4241 gtk_clist_set_cell_style (GTK_CLIST (clist), i, i % 4, style);
4246 separator = gtk_hseparator_new ();
4247 gtk_box_pack_start (GTK_BOX (vbox), separator, FALSE, TRUE, 0);
4249 hbox = gtk_hbox_new (FALSE, 0);
4250 gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0);
4252 button = gtk_button_new_with_label ("close");
4253 gtk_container_set_border_width (GTK_CONTAINER (button), 10);
4254 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
4255 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
4256 GTK_SIGNAL_FUNC(gtk_widget_destroy),
4257 GTK_OBJECT (window));
4259 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
4260 gtk_widget_grab_default (button);
4263 if (!GTK_WIDGET_VISIBLE (window))
4264 gtk_widget_show_all (window);
4268 gtk_widget_destroy (window);
4283 static gint books = 0;
4284 static gint pages = 0;
4286 static GtkWidget *book_label;
4287 static GtkWidget *page_label;
4288 static GtkWidget *sel_label;
4289 static GtkWidget *vis_label;
4290 static GtkWidget *omenu1;
4291 static GtkWidget *omenu2;
4292 static GtkWidget *omenu3;
4293 static GtkWidget *omenu4;
4294 static GtkWidget *spin1;
4295 static GtkWidget *spin2;
4296 static GtkWidget *spin3;
4297 static gint line_style;
4299 void after_press (GtkCTree *ctree, gpointer data)
4303 sprintf (buf, "%d", g_list_length (GTK_CLIST (ctree)->selection));
4304 gtk_label_set_text (GTK_LABEL (sel_label), buf);
4306 sprintf (buf, "%d", g_list_length (GTK_CLIST (ctree)->row_list));
4307 gtk_label_set_text (GTK_LABEL (vis_label), buf);
4309 sprintf (buf, "%d", books);
4310 gtk_label_set_text (GTK_LABEL (book_label), buf);
4312 sprintf (buf, "%d", pages);
4313 gtk_label_set_text (GTK_LABEL (page_label), buf);
4316 void after_move (GtkCTree *ctree, GtkCTreeNode *child, GtkCTreeNode *parent,
4317 GtkCTreeNode *sibling, gpointer data)
4323 gtk_ctree_get_node_info (ctree, child, &source,
4324 NULL, NULL, NULL, NULL, NULL, NULL, NULL);
4326 gtk_ctree_get_node_info (ctree, parent, &target1,
4327 NULL, NULL, NULL, NULL, NULL, NULL, NULL);
4329 gtk_ctree_get_node_info (ctree, sibling, &target2,
4330 NULL, NULL, NULL, NULL, NULL, NULL, NULL);
4332 g_print ("Moving \"%s\" to \"%s\" with sibling \"%s\".\n", source,
4333 (parent) ? target1 : "nil", (sibling) ? target2 : "nil");
4336 void count_items (GtkCTree *ctree, GtkCTreeNode *list)
4338 if (GTK_CTREE_ROW (list)->is_leaf)
4344 void expand_all (GtkWidget *widget, GtkCTree *ctree)
4346 gtk_ctree_expand_recursive (ctree, NULL);
4347 after_press (ctree, NULL);
4350 void collapse_all (GtkWidget *widget, GtkCTree *ctree)
4352 gtk_ctree_collapse_recursive (ctree, NULL);
4353 after_press (ctree, NULL);
4356 void select_all (GtkWidget *widget, GtkCTree *ctree)
4358 gtk_ctree_select_recursive (ctree, NULL);
4359 after_press (ctree, NULL);
4362 void change_style (GtkWidget *widget, GtkCTree *ctree)
4364 static GtkStyle *style1 = NULL;
4365 static GtkStyle *style2 = NULL;
4371 if (GTK_CLIST (ctree)->focus_row >= 0)
4372 node = GTK_CTREE_NODE
4373 (g_list_nth (GTK_CLIST (ctree)->row_list,GTK_CLIST (ctree)->focus_row));
4375 node = GTK_CTREE_NODE (GTK_CLIST (ctree)->row_list);
4389 style1 = gtk_style_new ();
4390 style1->base[GTK_STATE_NORMAL] = col1;
4391 style1->fg[GTK_STATE_SELECTED] = col2;
4393 style2 = gtk_style_new ();
4394 style2->base[GTK_STATE_SELECTED] = col2;
4395 style2->fg[GTK_STATE_NORMAL] = col1;
4396 style2->base[GTK_STATE_NORMAL] = col2;
4397 pango_font_description_free (style2->font_desc);
4398 style2->font_desc = pango_font_description_from_string ("courier 30");
4401 gtk_ctree_node_set_cell_style (ctree, node, 1, style1);
4402 gtk_ctree_node_set_cell_style (ctree, node, 0, style2);
4404 if (GTK_CTREE_ROW (node)->children)
4405 gtk_ctree_node_set_row_style (ctree, GTK_CTREE_ROW (node)->children,
4409 void unselect_all (GtkWidget *widget, GtkCTree *ctree)
4411 gtk_ctree_unselect_recursive (ctree, NULL);
4412 after_press (ctree, NULL);
4415 void remove_selection (GtkWidget *widget, GtkCTree *ctree)
4420 clist = GTK_CLIST (ctree);
4422 gtk_clist_freeze (clist);
4424 while (clist->selection)
4426 node = clist->selection->data;
4428 if (GTK_CTREE_ROW (node)->is_leaf)
4431 gtk_ctree_post_recursive (ctree, node,
4432 (GtkCTreeFunc) count_items, NULL);
4434 gtk_ctree_remove_node (ctree, node);
4436 if (clist->selection_mode == GTK_SELECTION_BROWSE)
4440 if (clist->selection_mode == GTK_SELECTION_EXTENDED && !clist->selection &&
4441 clist->focus_row >= 0)
4443 node = gtk_ctree_node_nth (ctree, clist->focus_row);
4446 gtk_ctree_select (ctree, node);
4449 gtk_clist_thaw (clist);
4450 after_press (ctree, NULL);
4453 struct _ExportStruct {
4459 typedef struct _ExportStruct ExportStruct;
4462 gnode2ctree (GtkCTree *ctree,
4465 GtkCTreeNode *cnode,
4469 GdkPixmap *pixmap_closed;
4470 GdkBitmap *mask_closed;
4471 GdkPixmap *pixmap_opened;
4472 GdkBitmap *mask_opened;
4474 if (!cnode || !gnode || (!(es = gnode->data)))
4479 pixmap_closed = pixmap3;
4480 mask_closed = mask3;
4481 pixmap_opened = NULL;
4486 pixmap_closed = pixmap1;
4487 mask_closed = mask1;
4488 pixmap_opened = pixmap2;
4489 mask_opened = mask2;
4492 gtk_ctree_set_node_info (ctree, cnode, es->tree, 2, pixmap_closed,
4493 mask_closed, pixmap_opened, mask_opened,
4494 es->is_leaf, (depth < 3));
4495 gtk_ctree_node_set_text (ctree, cnode, 1, es->info);
4503 ctree2gnode (GtkCTree *ctree,
4506 GtkCTreeNode *cnode,
4511 if (!cnode || !gnode)
4514 es = g_new (ExportStruct, 1);
4516 es->is_leaf = GTK_CTREE_ROW (cnode)->is_leaf;
4517 es->tree = GTK_CELL_PIXTEXT (GTK_CTREE_ROW (cnode)->row.cell[0])->text;
4518 es->info = GTK_CELL_PIXTEXT (GTK_CTREE_ROW (cnode)->row.cell[1])->text;
4522 void export_ctree (GtkWidget *widget, GtkCTree *ctree)
4524 char *title[] = { "Tree" , "Info" };
4525 static GtkWidget *export_window = NULL;
4526 static GtkCTree *export_ctree;
4528 GtkWidget *scrolled_win;
4536 export_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
4538 gtk_signal_connect (GTK_OBJECT (export_window), "destroy",
4539 GTK_SIGNAL_FUNC (gtk_widget_destroyed),
4542 gtk_window_set_title (GTK_WINDOW (export_window), "exported ctree");
4543 gtk_container_set_border_width (GTK_CONTAINER (export_window), 5);
4545 vbox = gtk_vbox_new (FALSE, 0);
4546 gtk_container_add (GTK_CONTAINER (export_window), vbox);
4548 button = gtk_button_new_with_label ("Close");
4549 gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, TRUE, 0);
4551 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
4552 (GtkSignalFunc) gtk_widget_destroy,
4553 GTK_OBJECT(export_window));
4555 sep = gtk_hseparator_new ();
4556 gtk_box_pack_end (GTK_BOX (vbox), sep, FALSE, TRUE, 10);
4558 export_ctree = GTK_CTREE (gtk_ctree_new_with_titles (2, 0, title));
4559 gtk_ctree_set_line_style (export_ctree, GTK_CTREE_LINES_DOTTED);
4561 scrolled_win = gtk_scrolled_window_new (NULL, NULL);
4562 gtk_container_add (GTK_CONTAINER (scrolled_win),
4563 GTK_WIDGET (export_ctree));
4564 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
4565 GTK_POLICY_AUTOMATIC,
4566 GTK_POLICY_AUTOMATIC);
4567 gtk_box_pack_start (GTK_BOX (vbox), scrolled_win, TRUE, TRUE, 0);
4568 gtk_clist_set_selection_mode (GTK_CLIST (export_ctree),
4569 GTK_SELECTION_EXTENDED);
4570 gtk_clist_set_column_width (GTK_CLIST (export_ctree), 0, 200);
4571 gtk_clist_set_column_width (GTK_CLIST (export_ctree), 1, 200);
4572 gtk_widget_set_usize (GTK_WIDGET (export_ctree), 300, 200);
4575 if (!GTK_WIDGET_VISIBLE (export_window))
4576 gtk_widget_show_all (export_window);
4578 gtk_clist_clear (GTK_CLIST (export_ctree));
4580 node = GTK_CTREE_NODE (g_list_nth (GTK_CLIST (ctree)->row_list,
4581 GTK_CLIST (ctree)->focus_row));
4585 gnode = gtk_ctree_export_to_gnode (ctree, NULL, NULL, node,
4589 gtk_ctree_insert_gnode (export_ctree, NULL, NULL, gnode,
4591 g_node_destroy (gnode);
4595 void change_indent (GtkWidget *widget, GtkCTree *ctree)
4597 gtk_ctree_set_indent (ctree, GTK_ADJUSTMENT (widget)->value);
4600 void change_spacing (GtkWidget *widget, GtkCTree *ctree)
4602 gtk_ctree_set_spacing (ctree, GTK_ADJUSTMENT (widget)->value);
4605 void change_row_height (GtkWidget *widget, GtkCList *clist)
4607 gtk_clist_set_row_height (clist, GTK_ADJUSTMENT (widget)->value);
4610 void set_background (GtkCTree *ctree, GtkCTreeNode *node, gpointer data)
4612 GtkStyle *style = NULL;
4617 if (ctree->line_style != GTK_CTREE_LINES_TABBED)
4619 if (!GTK_CTREE_ROW (node)->is_leaf)
4620 style = GTK_CTREE_ROW (node)->row.data;
4621 else if (GTK_CTREE_ROW (node)->parent)
4622 style = GTK_CTREE_ROW (GTK_CTREE_ROW (node)->parent)->row.data;
4625 gtk_ctree_node_set_row_style (ctree, node, style);
4628 void ctree_toggle_line_style (GtkWidget *widget, GtkCTree *ctree)
4632 if (!GTK_WIDGET_MAPPED (widget))
4635 RADIOMENUTOGGLED ((GtkRadioMenuItem *)
4636 (((GtkOptionMenu *)omenu1)->menu_item), i);
4638 if ((ctree->line_style == GTK_CTREE_LINES_TABBED &&
4639 ((GtkCTreeLineStyle) (3 - i)) != GTK_CTREE_LINES_TABBED) ||
4640 (ctree->line_style != GTK_CTREE_LINES_TABBED &&
4641 ((GtkCTreeLineStyle) (3 - i)) == GTK_CTREE_LINES_TABBED))
4642 gtk_ctree_pre_recursive (ctree, NULL, set_background, NULL);
4643 gtk_ctree_set_line_style (ctree, 3 - i);
4647 void ctree_toggle_expander_style (GtkWidget *widget, GtkCTree *ctree)
4651 if (!GTK_WIDGET_MAPPED (widget))
4654 RADIOMENUTOGGLED ((GtkRadioMenuItem *)
4655 (((GtkOptionMenu *)omenu2)->menu_item), i);
4657 gtk_ctree_set_expander_style (ctree, (GtkCTreeExpanderStyle) (3 - i));
4660 void ctree_toggle_justify (GtkWidget *widget, GtkCTree *ctree)
4664 if (!GTK_WIDGET_MAPPED (widget))
4667 RADIOMENUTOGGLED ((GtkRadioMenuItem *)
4668 (((GtkOptionMenu *)omenu3)->menu_item), i);
4670 gtk_clist_set_column_justification (GTK_CLIST (ctree), ctree->tree_column,
4671 (GtkJustification) (1 - i));
4674 void ctree_toggle_sel_mode (GtkWidget *widget, GtkCTree *ctree)
4678 if (!GTK_WIDGET_MAPPED (widget))
4681 RADIOMENUTOGGLED ((GtkRadioMenuItem *)
4682 (((GtkOptionMenu *)omenu4)->menu_item), i);
4684 gtk_clist_set_selection_mode (GTK_CLIST (ctree), (GtkSelectionMode) (3 - i));
4685 after_press (ctree, NULL);
4688 void build_recursive (GtkCTree *ctree, gint cur_depth, gint depth,
4689 gint num_books, gint num_pages, GtkCTreeNode *parent)
4694 GtkCTreeNode *sibling;
4701 for (i = num_pages + num_books; i > num_books; i--)
4704 sprintf (buf1, "Page %02d", (gint) rand() % 100);
4705 sprintf (buf2, "Item %d-%d", cur_depth, i);
4706 sibling = gtk_ctree_insert_node (ctree, parent, sibling, text, 5,
4707 pixmap3, mask3, NULL, NULL,
4710 if (parent && ctree->line_style == GTK_CTREE_LINES_TABBED)
4711 gtk_ctree_node_set_row_style (ctree, sibling,
4712 GTK_CTREE_ROW (parent)->row.style);
4715 if (cur_depth == depth)
4718 for (i = num_books; i > 0; i--)
4723 sprintf (buf1, "Book %02d", (gint) rand() % 100);
4724 sprintf (buf2, "Item %d-%d", cur_depth, i);
4725 sibling = gtk_ctree_insert_node (ctree, parent, sibling, text, 5,
4726 pixmap1, mask1, pixmap2, mask2,
4729 style = gtk_style_new ();
4730 switch (cur_depth % 3)
4733 style->base[GTK_STATE_NORMAL].red = 10000 * (cur_depth % 6);
4734 style->base[GTK_STATE_NORMAL].green = 0;
4735 style->base[GTK_STATE_NORMAL].blue = 65535 - ((i * 10000) % 65535);
4738 style->base[GTK_STATE_NORMAL].red = 10000 * (cur_depth % 6);
4739 style->base[GTK_STATE_NORMAL].green = 65535 - ((i * 10000) % 65535);
4740 style->base[GTK_STATE_NORMAL].blue = 0;
4743 style->base[GTK_STATE_NORMAL].red = 65535 - ((i * 10000) % 65535);
4744 style->base[GTK_STATE_NORMAL].green = 0;
4745 style->base[GTK_STATE_NORMAL].blue = 10000 * (cur_depth % 6);
4748 gtk_ctree_node_set_row_data_full (ctree, sibling, style,
4749 (GtkDestroyNotify) gtk_style_unref);
4751 if (ctree->line_style == GTK_CTREE_LINES_TABBED)
4752 gtk_ctree_node_set_row_style (ctree, sibling, style);
4754 build_recursive (ctree, cur_depth + 1, depth, num_books, num_pages,
4759 void rebuild_tree (GtkWidget *widget, GtkCTree *ctree)
4762 gchar label1[] = "Root";
4763 gchar label2[] = "";
4764 GtkCTreeNode *parent;
4771 d = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (spin1));
4772 b = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (spin2));
4773 p = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (spin3));
4775 n = ((pow (b, d) - 1) / (b - 1)) * (p + 1);
4779 g_print ("%d total items? Try less\n",n);
4783 gtk_clist_freeze (GTK_CLIST (ctree));
4784 gtk_clist_clear (GTK_CLIST (ctree));
4789 parent = gtk_ctree_insert_node (ctree, NULL, NULL, text, 5, pixmap1,
4790 mask1, pixmap2, mask2, FALSE, TRUE);
4792 style = gtk_style_new ();
4793 style->base[GTK_STATE_NORMAL].red = 0;
4794 style->base[GTK_STATE_NORMAL].green = 45000;
4795 style->base[GTK_STATE_NORMAL].blue = 55000;
4796 gtk_ctree_node_set_row_data_full (ctree, parent, style,
4797 (GtkDestroyNotify) gtk_style_unref);
4799 if (ctree->line_style == GTK_CTREE_LINES_TABBED)
4800 gtk_ctree_node_set_row_style (ctree, parent, style);
4802 build_recursive (ctree, 1, d, b, p, parent);
4803 gtk_clist_thaw (GTK_CLIST (ctree));
4804 after_press (ctree, NULL);
4808 ctree_click_column (GtkCTree *ctree, gint column, gpointer data)
4812 clist = GTK_CLIST (ctree);
4814 if (column == clist->sort_column)
4816 if (clist->sort_type == GTK_SORT_ASCENDING)
4817 clist->sort_type = GTK_SORT_DESCENDING;
4819 clist->sort_type = GTK_SORT_ASCENDING;
4822 gtk_clist_set_sort_column (clist, column);
4824 gtk_ctree_sort_recursive (ctree, NULL);
4827 void create_ctree (void)
4829 static GtkWidget *window = NULL;
4830 GtkTooltips *tooltips;
4832 GtkWidget *scrolled_win;
4844 GdkColor transparent = { 0 };
4846 char *title[] = { "Tree" , "Info" };
4849 static OptionMenuItem items1[] =
4851 { "No lines", ctree_toggle_line_style },
4852 { "Solid", ctree_toggle_line_style },
4853 { "Dotted", ctree_toggle_line_style },
4854 { "Tabbed", ctree_toggle_line_style }
4857 static OptionMenuItem items2[] =
4859 { "None", ctree_toggle_expander_style },
4860 { "Square", ctree_toggle_expander_style },
4861 { "Triangle", ctree_toggle_expander_style },
4862 { "Circular", ctree_toggle_expander_style }
4865 static OptionMenuItem items3[] =
4867 { "Left", ctree_toggle_justify },
4868 { "Right", ctree_toggle_justify }
4871 static OptionMenuItem items4[] =
4873 { "Single", ctree_toggle_sel_mode },
4874 { "Browse", ctree_toggle_sel_mode },
4875 { "Multiple", ctree_toggle_sel_mode },
4876 { "Extended", ctree_toggle_sel_mode }
4881 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
4883 gtk_signal_connect (GTK_OBJECT (window), "destroy",
4884 GTK_SIGNAL_FUNC (gtk_widget_destroyed),
4887 gtk_window_set_title (GTK_WINDOW (window), "GtkCTree");
4888 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
4890 tooltips = gtk_tooltips_new ();
4891 gtk_object_ref (GTK_OBJECT (tooltips));
4892 gtk_object_sink (GTK_OBJECT (tooltips));
4894 gtk_object_set_data_full (GTK_OBJECT (window), "tooltips", tooltips,
4895 (GtkDestroyNotify) gtk_object_unref);
4897 vbox = gtk_vbox_new (FALSE, 0);
4898 gtk_container_add (GTK_CONTAINER (window), vbox);
4900 hbox = gtk_hbox_new (FALSE, 5);
4901 gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
4902 gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0);
4904 label = gtk_label_new ("Depth :");
4905 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
4907 adj = (GtkAdjustment *) gtk_adjustment_new (4, 1, 10, 1, 5, 0);
4908 spin1 = gtk_spin_button_new (adj, 0, 0);
4909 gtk_box_pack_start (GTK_BOX (hbox), spin1, FALSE, TRUE, 5);
4911 label = gtk_label_new ("Books :");
4912 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
4914 adj = (GtkAdjustment *) gtk_adjustment_new (3, 1, 20, 1, 5, 0);
4915 spin2 = gtk_spin_button_new (adj, 0, 0);
4916 gtk_box_pack_start (GTK_BOX (hbox), spin2, FALSE, TRUE, 5);
4918 label = gtk_label_new ("Pages :");
4919 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
4921 adj = (GtkAdjustment *) gtk_adjustment_new (5, 1, 20, 1, 5, 0);
4922 spin3 = gtk_spin_button_new (adj, 0, 0);
4923 gtk_box_pack_start (GTK_BOX (hbox), spin3, FALSE, TRUE, 5);
4925 button = gtk_button_new_with_label ("Close");
4926 gtk_box_pack_end (GTK_BOX (hbox), button, TRUE, TRUE, 0);
4928 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
4929 (GtkSignalFunc) gtk_widget_destroy,
4930 GTK_OBJECT(window));
4932 button = gtk_button_new_with_label ("Rebuild Tree");
4933 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
4935 scrolled_win = gtk_scrolled_window_new (NULL, NULL);
4936 gtk_container_set_border_width (GTK_CONTAINER (scrolled_win), 5);
4937 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
4938 GTK_POLICY_AUTOMATIC,
4940 gtk_box_pack_start (GTK_BOX (vbox), scrolled_win, TRUE, TRUE, 0);
4942 ctree = GTK_CTREE (gtk_ctree_new_with_titles (2, 0, title));
4943 gtk_container_add (GTK_CONTAINER (scrolled_win), GTK_WIDGET (ctree));
4945 gtk_clist_set_column_auto_resize (GTK_CLIST (ctree), 0, TRUE);
4946 gtk_clist_set_column_width (GTK_CLIST (ctree), 1, 200);
4947 gtk_clist_set_selection_mode (GTK_CLIST (ctree), GTK_SELECTION_EXTENDED);
4948 gtk_ctree_set_line_style (ctree, GTK_CTREE_LINES_DOTTED);
4949 line_style = GTK_CTREE_LINES_DOTTED;
4951 gtk_signal_connect (GTK_OBJECT (button), "clicked",
4952 GTK_SIGNAL_FUNC (rebuild_tree), ctree);
4953 gtk_signal_connect (GTK_OBJECT (ctree), "click_column",
4954 (GtkSignalFunc) ctree_click_column, NULL);
4956 gtk_signal_connect_after (GTK_OBJECT (ctree), "button_press_event",
4957 GTK_SIGNAL_FUNC (after_press), NULL);
4958 gtk_signal_connect_after (GTK_OBJECT (ctree), "button_release_event",
4959 GTK_SIGNAL_FUNC (after_press), NULL);
4960 gtk_signal_connect_after (GTK_OBJECT (ctree), "tree_move",
4961 GTK_SIGNAL_FUNC (after_move), NULL);
4962 gtk_signal_connect_after (GTK_OBJECT (ctree), "end_selection",
4963 GTK_SIGNAL_FUNC (after_press), NULL);
4964 gtk_signal_connect_after (GTK_OBJECT (ctree), "toggle_focus_row",
4965 GTK_SIGNAL_FUNC (after_press), NULL);
4966 gtk_signal_connect_after (GTK_OBJECT (ctree), "select_all",
4967 GTK_SIGNAL_FUNC (after_press), NULL);
4968 gtk_signal_connect_after (GTK_OBJECT (ctree), "unselect_all",
4969 GTK_SIGNAL_FUNC (after_press), NULL);
4970 gtk_signal_connect_after (GTK_OBJECT (ctree), "scroll_vertical",
4971 GTK_SIGNAL_FUNC (after_press), NULL);
4973 bbox = gtk_hbox_new (FALSE, 5);
4974 gtk_container_set_border_width (GTK_CONTAINER (bbox), 5);
4975 gtk_box_pack_start (GTK_BOX (vbox), bbox, FALSE, TRUE, 0);
4977 mbox = gtk_vbox_new (TRUE, 5);
4978 gtk_box_pack_start (GTK_BOX (bbox), mbox, FALSE, TRUE, 0);
4980 label = gtk_label_new ("Row Height :");
4981 gtk_box_pack_start (GTK_BOX (mbox), label, FALSE, FALSE, 0);
4983 label = gtk_label_new ("Indent :");
4984 gtk_box_pack_start (GTK_BOX (mbox), label, FALSE, FALSE, 0);
4986 label = gtk_label_new ("Spacing :");
4987 gtk_box_pack_start (GTK_BOX (mbox), label, FALSE, FALSE, 0);
4989 mbox = gtk_vbox_new (TRUE, 5);
4990 gtk_box_pack_start (GTK_BOX (bbox), mbox, FALSE, TRUE, 0);
4992 adj = (GtkAdjustment *) gtk_adjustment_new (20, 12, 100, 1, 10, 0);
4993 spinner = gtk_spin_button_new (adj, 0, 0);
4994 gtk_box_pack_start (GTK_BOX (mbox), spinner, FALSE, FALSE, 5);
4995 gtk_tooltips_set_tip (tooltips, spinner,
4996 "Row height of list items", NULL);
4997 gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
4998 GTK_SIGNAL_FUNC (change_row_height), ctree);
4999 gtk_clist_set_row_height ( GTK_CLIST (ctree), adj->value);
5001 adj = (GtkAdjustment *) gtk_adjustment_new (20, 0, 60, 1, 10, 0);
5002 spinner = gtk_spin_button_new (adj, 0, 0);
5003 gtk_box_pack_start (GTK_BOX (mbox), spinner, FALSE, FALSE, 5);
5004 gtk_tooltips_set_tip (tooltips, spinner, "Tree Indentation.", NULL);
5005 gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
5006 GTK_SIGNAL_FUNC (change_indent), ctree);
5008 adj = (GtkAdjustment *) gtk_adjustment_new (5, 0, 60, 1, 10, 0);
5009 spinner = gtk_spin_button_new (adj, 0, 0);
5010 gtk_box_pack_start (GTK_BOX (mbox), spinner, FALSE, FALSE, 5);
5011 gtk_tooltips_set_tip (tooltips, spinner, "Tree Spacing.", NULL);
5012 gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
5013 GTK_SIGNAL_FUNC (change_spacing), ctree);
5015 mbox = gtk_vbox_new (TRUE, 5);
5016 gtk_box_pack_start (GTK_BOX (bbox), mbox, FALSE, TRUE, 0);
5018 hbox = gtk_hbox_new (FALSE, 5);
5019 gtk_box_pack_start (GTK_BOX (mbox), hbox, FALSE, FALSE, 0);
5021 button = gtk_button_new_with_label ("Expand All");
5022 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
5023 gtk_signal_connect (GTK_OBJECT (button), "clicked",
5024 GTK_SIGNAL_FUNC (expand_all), ctree);
5026 button = gtk_button_new_with_label ("Collapse All");
5027 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
5028 gtk_signal_connect (GTK_OBJECT (button), "clicked",
5029 GTK_SIGNAL_FUNC (collapse_all), ctree);
5031 button = gtk_button_new_with_label ("Change Style");
5032 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
5033 gtk_signal_connect (GTK_OBJECT (button), "clicked",
5034 GTK_SIGNAL_FUNC (change_style), ctree);
5036 button = gtk_button_new_with_label ("Export Tree");
5037 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
5038 gtk_signal_connect (GTK_OBJECT (button), "clicked",
5039 GTK_SIGNAL_FUNC (export_ctree), ctree);
5041 hbox = gtk_hbox_new (FALSE, 5);
5042 gtk_box_pack_start (GTK_BOX (mbox), hbox, FALSE, FALSE, 0);
5044 button = gtk_button_new_with_label ("Select All");
5045 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
5046 gtk_signal_connect (GTK_OBJECT (button), "clicked",
5047 GTK_SIGNAL_FUNC (select_all), ctree);
5049 button = gtk_button_new_with_label ("Unselect All");
5050 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
5051 gtk_signal_connect (GTK_OBJECT (button), "clicked",
5052 GTK_SIGNAL_FUNC (unselect_all), ctree);
5054 button = gtk_button_new_with_label ("Remove Selection");
5055 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
5056 gtk_signal_connect (GTK_OBJECT (button), "clicked",
5057 GTK_SIGNAL_FUNC (remove_selection), ctree);
5059 check = gtk_check_button_new_with_label ("Reorderable");
5060 gtk_box_pack_start (GTK_BOX (hbox), check, FALSE, TRUE, 0);
5061 gtk_tooltips_set_tip (tooltips, check,
5062 "Tree items can be reordered by dragging.", NULL);
5063 gtk_signal_connect (GTK_OBJECT (check), "clicked",
5064 GTK_SIGNAL_FUNC (toggle_reorderable), ctree);
5065 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check), TRUE);
5067 hbox = gtk_hbox_new (TRUE, 5);
5068 gtk_box_pack_start (GTK_BOX (mbox), hbox, FALSE, FALSE, 0);
5070 omenu1 = build_option_menu (items1, 4, 2, ctree);
5071 gtk_box_pack_start (GTK_BOX (hbox), omenu1, FALSE, TRUE, 0);
5072 gtk_tooltips_set_tip (tooltips, omenu1, "The tree's line style.", NULL);
5074 omenu2 = build_option_menu (items2, 4, 1, ctree);
5075 gtk_box_pack_start (GTK_BOX (hbox), omenu2, FALSE, TRUE, 0);
5076 gtk_tooltips_set_tip (tooltips, omenu2, "The tree's expander style.",
5079 omenu3 = build_option_menu (items3, 2, 0, ctree);
5080 gtk_box_pack_start (GTK_BOX (hbox), omenu3, FALSE, TRUE, 0);
5081 gtk_tooltips_set_tip (tooltips, omenu3, "The tree's justification.",
5084 omenu4 = build_option_menu (items4, 4, 3, ctree);
5085 gtk_box_pack_start (GTK_BOX (hbox), omenu4, FALSE, TRUE, 0);
5086 gtk_tooltips_set_tip (tooltips, omenu4, "The list's selection mode.",
5089 gtk_widget_realize (window);
5092 pixmap1 = gdk_pixmap_create_from_xpm_d (window->window, &mask1,
5093 &transparent, book_closed_xpm);
5095 pixmap2 = gdk_pixmap_create_from_xpm_d (window->window, &mask2,
5096 &transparent, book_open_xpm);
5098 pixmap3 = gdk_pixmap_create_from_xpm_d (window->window, &mask3,
5099 &transparent, mini_page_xpm);
5101 gtk_widget_set_usize (GTK_WIDGET (ctree), 0, 300);
5103 frame = gtk_frame_new (NULL);
5104 gtk_container_set_border_width (GTK_CONTAINER (frame), 0);
5105 gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_OUT);
5106 gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, TRUE, 0);
5108 hbox = gtk_hbox_new (TRUE, 2);
5109 gtk_container_set_border_width (GTK_CONTAINER (hbox), 2);
5110 gtk_container_add (GTK_CONTAINER (frame), hbox);
5112 frame = gtk_frame_new (NULL);
5113 gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
5114 gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, TRUE, 0);
5116 hbox2 = gtk_hbox_new (FALSE, 0);
5117 gtk_container_set_border_width (GTK_CONTAINER (hbox2), 2);
5118 gtk_container_add (GTK_CONTAINER (frame), hbox2);
5120 label = gtk_label_new ("Books :");
5121 gtk_box_pack_start (GTK_BOX (hbox2), label, FALSE, TRUE, 0);
5123 sprintf (buf, "%d", books);
5124 book_label = gtk_label_new (buf);
5125 gtk_box_pack_end (GTK_BOX (hbox2), book_label, FALSE, TRUE, 5);
5127 frame = gtk_frame_new (NULL);
5128 gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
5129 gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, TRUE, 0);
5131 hbox2 = gtk_hbox_new (FALSE, 0);
5132 gtk_container_set_border_width (GTK_CONTAINER (hbox2), 2);
5133 gtk_container_add (GTK_CONTAINER (frame), hbox2);
5135 label = gtk_label_new ("Pages :");
5136 gtk_box_pack_start (GTK_BOX (hbox2), label, FALSE, TRUE, 0);
5138 sprintf (buf, "%d", pages);
5139 page_label = gtk_label_new (buf);
5140 gtk_box_pack_end (GTK_BOX (hbox2), page_label, FALSE, TRUE, 5);
5142 frame = gtk_frame_new (NULL);
5143 gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
5144 gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, TRUE, 0);
5146 hbox2 = gtk_hbox_new (FALSE, 0);
5147 gtk_container_set_border_width (GTK_CONTAINER (hbox2), 2);
5148 gtk_container_add (GTK_CONTAINER (frame), hbox2);
5150 label = gtk_label_new ("Selected :");
5151 gtk_box_pack_start (GTK_BOX (hbox2), label, FALSE, TRUE, 0);
5153 sprintf (buf, "%d", g_list_length (GTK_CLIST (ctree)->selection));
5154 sel_label = gtk_label_new (buf);
5155 gtk_box_pack_end (GTK_BOX (hbox2), sel_label, FALSE, TRUE, 5);
5157 frame = gtk_frame_new (NULL);
5158 gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
5159 gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, TRUE, 0);
5161 hbox2 = gtk_hbox_new (FALSE, 0);
5162 gtk_container_set_border_width (GTK_CONTAINER (hbox2), 2);
5163 gtk_container_add (GTK_CONTAINER (frame), hbox2);
5165 label = gtk_label_new ("Visible :");
5166 gtk_box_pack_start (GTK_BOX (hbox2), label, FALSE, TRUE, 0);
5168 sprintf (buf, "%d", g_list_length (GTK_CLIST (ctree)->row_list));
5169 vis_label = gtk_label_new (buf);
5170 gtk_box_pack_end (GTK_BOX (hbox2), vis_label, FALSE, TRUE, 5);
5172 rebuild_tree (NULL, ctree);
5175 if (!GTK_WIDGET_VISIBLE (window))
5176 gtk_widget_show_all (window);
5178 gtk_widget_destroy (window);
5186 color_selection_ok (GtkWidget *w,
5187 GtkColorSelectionDialog *cs)
5189 GtkColorSelection *colorsel;
5192 colorsel=GTK_COLOR_SELECTION(cs->colorsel);
5194 gtk_color_selection_get_color(colorsel,color);
5195 gtk_color_selection_set_color(colorsel,color);
5199 color_selection_changed (GtkWidget *w,
5200 GtkColorSelectionDialog *cs)
5202 GtkColorSelection *colorsel;
5205 colorsel=GTK_COLOR_SELECTION(cs->colorsel);
5206 gtk_color_selection_get_color(colorsel,color);
5210 opacity_toggled_cb (GtkWidget *w,
5211 GtkColorSelectionDialog *cs)
5213 GtkColorSelection *colorsel;
5215 colorsel = GTK_COLOR_SELECTION (cs->colorsel);
5216 gtk_color_selection_set_use_opacity (colorsel,
5217 gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (w)));
5221 palette_toggled_cb (GtkWidget *w,
5222 GtkColorSelectionDialog *cs)
5224 GtkColorSelection *colorsel;
5226 colorsel = GTK_COLOR_SELECTION (cs->colorsel);
5227 gtk_color_selection_set_use_palette (colorsel,
5228 gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (w)));
5232 create_color_selection (void)
5234 static GtkWidget *window = NULL;
5238 GtkWidget *options_hbox;
5239 GtkWidget *check_button;
5241 window = gtk_color_selection_dialog_new ("color selection dialog");
5243 gtk_window_set_position (GTK_WINDOW (window), GTK_WIN_POS_MOUSE);
5245 gtk_signal_connect (GTK_OBJECT (window), "destroy",
5246 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
5249 options_hbox = gtk_hbox_new (FALSE, 0);
5250 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), options_hbox, FALSE, FALSE, 0);
5251 gtk_container_set_border_width (GTK_CONTAINER (options_hbox), 10);
5253 check_button = gtk_check_button_new_with_label ("Show Opacity");
5254 gtk_box_pack_start (GTK_BOX (options_hbox), check_button, FALSE, FALSE, 0);
5255 gtk_signal_connect (GTK_OBJECT (check_button), "toggled",
5256 GTK_SIGNAL_FUNC (opacity_toggled_cb), window);
5258 check_button = gtk_check_button_new_with_label ("Show Palette");
5259 gtk_box_pack_end (GTK_BOX (options_hbox), check_button, FALSE, FALSE, 0);
5260 gtk_signal_connect (GTK_OBJECT (check_button), "toggled",
5261 GTK_SIGNAL_FUNC (palette_toggled_cb), window);
5263 gtk_widget_show_all (options_hbox);
5265 gtk_signal_connect (
5266 GTK_OBJECT (GTK_COLOR_SELECTION_DIALOG (window)->colorsel),
5268 GTK_SIGNAL_FUNC(color_selection_changed),
5271 gtk_signal_connect (
5272 GTK_OBJECT (GTK_COLOR_SELECTION_DIALOG (window)->ok_button),
5274 GTK_SIGNAL_FUNC(color_selection_ok),
5277 gtk_signal_connect_object (
5278 GTK_OBJECT (GTK_COLOR_SELECTION_DIALOG (window)->cancel_button),
5280 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);
5295 file_selection_hide_fileops (GtkWidget *widget,
5296 GtkFileSelection *fs)
5298 gtk_file_selection_hide_fileop_buttons (fs);
5302 file_selection_ok (GtkWidget *w,
5303 GtkFileSelection *fs)
5305 g_print ("%s\n", gtk_file_selection_get_filename (fs));
5306 gtk_widget_destroy (GTK_WIDGET (fs));
5310 create_file_selection (void)
5312 static GtkWidget *window = NULL;
5317 window = gtk_file_selection_new ("file selection dialog");
5319 gtk_file_selection_hide_fileop_buttons (GTK_FILE_SELECTION (window));
5321 gtk_window_set_position (GTK_WINDOW (window), GTK_WIN_POS_MOUSE);
5323 gtk_signal_connect (GTK_OBJECT (window), "destroy",
5324 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
5327 gtk_signal_connect (GTK_OBJECT (GTK_FILE_SELECTION (window)->ok_button),
5328 "clicked", GTK_SIGNAL_FUNC(file_selection_ok),
5330 gtk_signal_connect_object (GTK_OBJECT (GTK_FILE_SELECTION (window)->cancel_button),
5331 "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy),
5332 GTK_OBJECT (window));
5334 button = gtk_button_new_with_label ("Hide Fileops");
5335 gtk_signal_connect (GTK_OBJECT (button), "clicked",
5336 (GtkSignalFunc) file_selection_hide_fileops,
5338 gtk_box_pack_start (GTK_BOX (GTK_FILE_SELECTION (window)->action_area),
5339 button, FALSE, FALSE, 0);
5340 gtk_widget_show (button);
5342 button = gtk_button_new_with_label ("Show Fileops");
5343 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
5344 (GtkSignalFunc) gtk_file_selection_show_fileop_buttons,
5346 gtk_box_pack_start (GTK_BOX (GTK_FILE_SELECTION (window)->action_area),
5347 button, FALSE, FALSE, 0);
5348 gtk_widget_show (button);
5351 if (!GTK_WIDGET_VISIBLE (window))
5352 gtk_widget_show (window);
5354 gtk_widget_destroy (window);
5358 flipping_toggled_cb (GtkWidget *widget, gpointer data)
5360 int state = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget));
5361 int new_direction = state ? GTK_TEXT_DIR_RTL : GTK_TEXT_DIR_LTR;
5363 if (new_direction != gtk_widget_get_default_direction ())
5367 gtk_widget_set_default_direction (new_direction);
5369 toplevels = gtk_window_list_toplevels ();
5372 gtk_widget_queue_resize (toplevels->data);
5373 g_object_unref (toplevels->data);
5374 toplevels = toplevels->next;
5377 g_list_free (toplevels);
5383 create_flipping (void)
5385 static GtkWidget *window = NULL;
5386 GtkWidget *check_button, *button;
5390 window = gtk_dialog_new ();
5392 gtk_signal_connect (GTK_OBJECT (window), "destroy",
5393 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
5396 gtk_window_set_title (GTK_WINDOW (window), "Bidirectional Flipping");
5398 check_button = gtk_check_button_new_with_label ("Right-to-left global direction");
5399 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox),
5400 check_button, TRUE, TRUE, 0);
5402 if (gtk_widget_get_default_direction () == GTK_TEXT_DIR_RTL)
5403 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check_button), TRUE);
5405 gtk_signal_connect (GTK_OBJECT (check_button), "toggled",
5406 flipping_toggled_cb, FALSE);
5408 gtk_container_set_border_width (GTK_CONTAINER (check_button), 10);
5410 button = gtk_button_new_with_label ("Close");
5411 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
5412 GTK_SIGNAL_FUNC (gtk_widget_destroy), GTK_OBJECT (window));
5413 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
5414 button, TRUE, TRUE, 0);
5417 if (!GTK_WIDGET_VISIBLE (window))
5418 gtk_widget_show_all (window);
5420 gtk_widget_destroy (window);
5428 font_selection_ok (GtkWidget *w,
5429 GtkFontSelectionDialog *fs)
5431 gchar *s = gtk_font_selection_dialog_get_font_name (fs);
5433 g_print ("%s\n", s);
5435 gtk_widget_destroy (GTK_WIDGET (fs));
5439 create_font_selection (void)
5441 static GtkWidget *window = NULL;
5445 window = gtk_font_selection_dialog_new ("Font Selection Dialog");
5447 gtk_window_set_position (GTK_WINDOW (window), GTK_WIN_POS_MOUSE);
5449 gtk_signal_connect (GTK_OBJECT (window), "destroy",
5450 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
5453 gtk_signal_connect (GTK_OBJECT (GTK_FONT_SELECTION_DIALOG (window)->ok_button),
5454 "clicked", GTK_SIGNAL_FUNC(font_selection_ok),
5455 GTK_FONT_SELECTION_DIALOG (window));
5456 gtk_signal_connect_object (GTK_OBJECT (GTK_FONT_SELECTION_DIALOG (window)->cancel_button),
5457 "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy),
5458 GTK_OBJECT (window));
5461 if (!GTK_WIDGET_VISIBLE (window))
5462 gtk_widget_show (window);
5464 gtk_widget_destroy (window);
5471 static GtkWidget *dialog_window = NULL;
5474 label_toggle (GtkWidget *widget,
5479 *label = gtk_label_new ("Dialog Test");
5480 gtk_signal_connect (GTK_OBJECT (*label),
5482 GTK_SIGNAL_FUNC (gtk_widget_destroyed),
5484 gtk_misc_set_padding (GTK_MISC (*label), 10, 10);
5485 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog_window)->vbox),
5486 *label, TRUE, TRUE, 0);
5487 gtk_widget_show (*label);
5490 gtk_widget_destroy (*label);
5494 create_dialog (void)
5496 static GtkWidget *label;
5501 dialog_window = gtk_dialog_new ();
5503 gtk_signal_connect (GTK_OBJECT (dialog_window), "destroy",
5504 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
5507 gtk_window_set_title (GTK_WINDOW (dialog_window), "GtkDialog");
5508 gtk_container_set_border_width (GTK_CONTAINER (dialog_window), 0);
5509 gtk_widget_set_usize (dialog_window, 200, 110);
5511 button = gtk_button_new_with_label ("OK");
5512 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
5513 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog_window)->action_area),
5514 button, TRUE, TRUE, 0);
5515 gtk_widget_grab_default (button);
5516 gtk_widget_show (button);
5518 button = gtk_button_new_with_label ("Toggle");
5519 gtk_signal_connect (GTK_OBJECT (button), "clicked",
5520 GTK_SIGNAL_FUNC (label_toggle),
5522 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
5523 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog_window)->action_area),
5524 button, TRUE, TRUE, 0);
5525 gtk_widget_show (button);
5530 if (!GTK_WIDGET_VISIBLE (dialog_window))
5531 gtk_widget_show (dialog_window);
5533 gtk_widget_destroy (dialog_window);
5538 static gboolean event_watcher_enter_id = 0;
5539 static gboolean event_watcher_leave_id = 0;
5542 event_watcher (GtkObject *object,
5548 g_print ("Watch: \"%s\" emitted for %s\n",
5549 gtk_signal_name (signal_id),
5550 gtk_type_name (GTK_OBJECT_TYPE (object)));
5556 event_watcher_down (void)
5558 if (event_watcher_enter_id)
5562 signal_id = gtk_signal_lookup ("enter_notify_event", GTK_TYPE_WIDGET);
5563 gtk_signal_remove_emission_hook (signal_id, event_watcher_enter_id);
5564 event_watcher_enter_id = 0;
5565 signal_id = gtk_signal_lookup ("leave_notify_event", GTK_TYPE_WIDGET);
5566 gtk_signal_remove_emission_hook (signal_id, event_watcher_leave_id);
5567 event_watcher_leave_id = 0;
5572 event_watcher_toggle (void)
5574 if (event_watcher_enter_id)
5575 event_watcher_down ();
5580 signal_id = gtk_signal_lookup ("enter_notify_event", GTK_TYPE_WIDGET);
5581 event_watcher_enter_id = gtk_signal_add_emission_hook (signal_id, event_watcher, NULL);
5582 signal_id = gtk_signal_lookup ("leave_notify_event", GTK_TYPE_WIDGET);
5583 event_watcher_leave_id = gtk_signal_add_emission_hook (signal_id, event_watcher, NULL);
5588 create_event_watcher (void)
5594 dialog_window = gtk_dialog_new ();
5596 gtk_signal_connect (GTK_OBJECT (dialog_window), "destroy",
5597 GTK_SIGNAL_FUNC (gtk_widget_destroyed),
5599 gtk_signal_connect (GTK_OBJECT (dialog_window),
5601 GTK_SIGNAL_FUNC (event_watcher_down),
5604 gtk_window_set_title (GTK_WINDOW (dialog_window), "Event Watcher");
5605 gtk_container_set_border_width (GTK_CONTAINER (dialog_window), 0);
5606 gtk_widget_set_usize (dialog_window, 200, 110);
5608 button = gtk_toggle_button_new_with_label ("Activate Watch");
5609 gtk_signal_connect (GTK_OBJECT (button), "clicked",
5610 GTK_SIGNAL_FUNC (event_watcher_toggle),
5612 gtk_container_set_border_width (GTK_CONTAINER (button), 10);
5613 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog_window)->vbox),
5614 button, TRUE, TRUE, 0);
5615 gtk_widget_show (button);
5617 button = gtk_button_new_with_label ("Close");
5618 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
5619 GTK_SIGNAL_FUNC (gtk_widget_destroy),
5620 (GtkObject*) dialog_window);
5621 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
5622 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog_window)->action_area),
5623 button, TRUE, TRUE, 0);
5624 gtk_widget_grab_default (button);
5625 gtk_widget_show (button);
5628 if (!GTK_WIDGET_VISIBLE (dialog_window))
5629 gtk_widget_show (dialog_window);
5631 gtk_widget_destroy (dialog_window);
5639 create_range_controls (void)
5641 static GtkWidget *window = NULL;
5645 GtkWidget *scrollbar;
5647 GtkWidget *separator;
5648 GtkObject *adjustment;
5652 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
5654 gtk_signal_connect (GTK_OBJECT (window), "destroy",
5655 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
5658 gtk_window_set_title (GTK_WINDOW (window), "range controls");
5659 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
5662 box1 = gtk_vbox_new (FALSE, 0);
5663 gtk_container_add (GTK_CONTAINER (window), box1);
5664 gtk_widget_show (box1);
5667 box2 = gtk_vbox_new (FALSE, 10);
5668 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
5669 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
5670 gtk_widget_show (box2);
5673 adjustment = gtk_adjustment_new (0.0, 0.0, 101.0, 0.1, 1.0, 1.0);
5675 scale = gtk_hscale_new (GTK_ADJUSTMENT (adjustment));
5676 gtk_widget_set_usize (GTK_WIDGET (scale), 150, 30);
5677 gtk_range_set_update_policy (GTK_RANGE (scale), GTK_UPDATE_DELAYED);
5678 gtk_scale_set_digits (GTK_SCALE (scale), 1);
5679 gtk_scale_set_draw_value (GTK_SCALE (scale), TRUE);
5680 gtk_box_pack_start (GTK_BOX (box2), scale, TRUE, TRUE, 0);
5681 gtk_widget_show (scale);
5683 scrollbar = gtk_hscrollbar_new (GTK_ADJUSTMENT (adjustment));
5684 gtk_range_set_update_policy (GTK_RANGE (scrollbar),
5685 GTK_UPDATE_CONTINUOUS);
5686 gtk_box_pack_start (GTK_BOX (box2), scrollbar, TRUE, TRUE, 0);
5687 gtk_widget_show (scrollbar);
5690 separator = gtk_hseparator_new ();
5691 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
5692 gtk_widget_show (separator);
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, FALSE, TRUE, 0);
5698 gtk_widget_show (box2);
5701 button = gtk_button_new_with_label ("close");
5702 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
5703 GTK_SIGNAL_FUNC(gtk_widget_destroy),
5704 GTK_OBJECT (window));
5705 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
5706 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
5707 gtk_widget_grab_default (button);
5708 gtk_widget_show (button);
5711 if (!GTK_WIDGET_VISIBLE (window))
5712 gtk_widget_show (window);
5714 gtk_widget_destroy (window);
5722 create_rulers (void)
5724 static GtkWidget *window = NULL;
5730 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
5731 gtk_window_set_policy (GTK_WINDOW (window), TRUE, TRUE, FALSE);
5733 gtk_signal_connect (GTK_OBJECT (window), "destroy",
5734 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
5737 gtk_window_set_title (GTK_WINDOW (window), "rulers");
5738 gtk_widget_set_usize (window, 300, 300);
5739 gtk_widget_set_events (window,
5740 GDK_POINTER_MOTION_MASK
5741 | GDK_POINTER_MOTION_HINT_MASK);
5742 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
5744 table = gtk_table_new (2, 2, FALSE);
5745 gtk_container_add (GTK_CONTAINER (window), table);
5746 gtk_widget_show (table);
5748 ruler = gtk_hruler_new ();
5749 gtk_ruler_set_metric (GTK_RULER (ruler), GTK_CENTIMETERS);
5750 gtk_ruler_set_range (GTK_RULER (ruler), 100, 0, 0, 20);
5752 gtk_signal_connect_object (GTK_OBJECT (window),
5753 "motion_notify_event",
5754 GTK_SIGNAL_FUNC (GTK_WIDGET_GET_CLASS (ruler)->motion_notify_event),
5755 GTK_OBJECT (ruler));
5757 gtk_table_attach (GTK_TABLE (table), ruler, 1, 2, 0, 1,
5758 GTK_EXPAND | GTK_FILL, GTK_FILL, 0, 0);
5759 gtk_widget_show (ruler);
5762 ruler = gtk_vruler_new ();
5763 gtk_ruler_set_range (GTK_RULER (ruler), 5, 15, 0, 20);
5765 gtk_signal_connect_object (GTK_OBJECT (window),
5766 "motion_notify_event",
5767 GTK_SIGNAL_FUNC (GTK_WIDGET_GET_CLASS (ruler)->motion_notify_event),
5768 GTK_OBJECT (ruler));
5770 gtk_table_attach (GTK_TABLE (table), ruler, 0, 1, 1, 2,
5771 GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
5772 gtk_widget_show (ruler);
5775 if (!GTK_WIDGET_VISIBLE (window))
5776 gtk_widget_show (window);
5778 gtk_widget_destroy (window);
5782 text_toggle_editable (GtkWidget *checkbutton,
5785 gtk_text_set_editable(GTK_TEXT(text),
5786 GTK_TOGGLE_BUTTON(checkbutton)->active);
5790 text_toggle_word_wrap (GtkWidget *checkbutton,
5793 gtk_text_set_word_wrap(GTK_TEXT(text),
5794 GTK_TOGGLE_BUTTON(checkbutton)->active);
5801 { { 0, 0x0000, 0x0000, 0x0000 }, "black" },
5802 { { 0, 0xFFFF, 0xFFFF, 0xFFFF }, "white" },
5803 { { 0, 0xFFFF, 0x0000, 0x0000 }, "red" },
5804 { { 0, 0x0000, 0xFFFF, 0x0000 }, "green" },
5805 { { 0, 0x0000, 0x0000, 0xFFFF }, "blue" },
5806 { { 0, 0x0000, 0xFFFF, 0xFFFF }, "cyan" },
5807 { { 0, 0xFFFF, 0x0000, 0xFFFF }, "magenta" },
5808 { { 0, 0xFFFF, 0xFFFF, 0x0000 }, "yellow" }
5811 int ntext_colors = sizeof(text_colors) / sizeof(text_colors[0]);
5817 text_insert_random (GtkWidget *w, GtkText *text)
5821 for (i=0; i<10; i++)
5823 c = 'A' + rand() % ('Z' - 'A');
5824 gtk_text_set_point (text, rand() % gtk_text_get_length (text));
5825 gtk_text_insert (text, NULL, NULL, NULL, &c, 1);
5834 static GtkWidget *window = NULL;
5840 GtkWidget *separator;
5841 GtkWidget *scrolled_window;
5848 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
5849 gtk_widget_set_name (window, "text window");
5850 gtk_widget_set_usize (window, 500, 500);
5851 gtk_window_set_policy (GTK_WINDOW(window), TRUE, TRUE, FALSE);
5853 gtk_signal_connect (GTK_OBJECT (window), "destroy",
5854 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
5857 gtk_window_set_title (GTK_WINDOW (window), "test");
5858 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
5861 box1 = gtk_vbox_new (FALSE, 0);
5862 gtk_container_add (GTK_CONTAINER (window), box1);
5863 gtk_widget_show (box1);
5866 box2 = gtk_vbox_new (FALSE, 10);
5867 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
5868 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
5869 gtk_widget_show (box2);
5872 scrolled_window = gtk_scrolled_window_new (NULL, NULL);
5873 gtk_box_pack_start (GTK_BOX (box2), scrolled_window, TRUE, TRUE, 0);
5874 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
5877 gtk_widget_show (scrolled_window);
5879 text = gtk_text_new (NULL, NULL);
5880 gtk_text_set_editable (GTK_TEXT (text), TRUE);
5881 gtk_container_add (GTK_CONTAINER (scrolled_window), text);
5882 gtk_widget_grab_focus (text);
5883 gtk_widget_show (text);
5886 gtk_text_freeze (GTK_TEXT (text));
5888 for (i=0; i<ntext_colors; i++)
5890 gtk_text_insert (GTK_TEXT (text), NULL, NULL, NULL,
5891 text_colors[i].name, -1);
5892 gtk_text_insert (GTK_TEXT (text), NULL, NULL, NULL, "\t", -1);
5894 for (j=0; j<ntext_colors; j++)
5896 gtk_text_insert (GTK_TEXT (text), NULL,
5897 &text_colors[j].color, &text_colors[i].color,
5900 gtk_text_insert (GTK_TEXT (text), NULL, NULL, NULL, "\n", -1);
5903 infile = fopen("testgtk.c", "r");
5908 int nbytes_read, nbytes_alloc;
5911 nbytes_alloc = 1024;
5912 buffer = g_new (char, nbytes_alloc);
5916 if (nbytes_alloc < nbytes_read + 1024)
5919 buffer = g_realloc (buffer, nbytes_alloc);
5921 len = fread (buffer + nbytes_read, 1, 1024, infile);
5927 gtk_text_insert (GTK_TEXT (text), NULL, NULL,
5928 NULL, buffer, nbytes_read);
5933 gtk_text_thaw (GTK_TEXT (text));
5935 hbox = gtk_hbutton_box_new ();
5936 gtk_box_pack_start (GTK_BOX (box2), hbox, FALSE, FALSE, 0);
5937 gtk_widget_show (hbox);
5939 check = gtk_check_button_new_with_label("Editable");
5940 gtk_box_pack_start (GTK_BOX (hbox), check, FALSE, FALSE, 0);
5941 gtk_signal_connect (GTK_OBJECT(check), "toggled",
5942 GTK_SIGNAL_FUNC(text_toggle_editable), text);
5943 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check), TRUE);
5944 gtk_widget_show (check);
5946 check = gtk_check_button_new_with_label("Wrap Words");
5947 gtk_box_pack_start (GTK_BOX (hbox), check, FALSE, TRUE, 0);
5948 gtk_signal_connect (GTK_OBJECT(check), "toggled",
5949 GTK_SIGNAL_FUNC(text_toggle_word_wrap), text);
5950 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check), FALSE);
5951 gtk_widget_show (check);
5953 separator = gtk_hseparator_new ();
5954 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
5955 gtk_widget_show (separator);
5958 box2 = gtk_vbox_new (FALSE, 10);
5959 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
5960 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
5961 gtk_widget_show (box2);
5964 button = gtk_button_new_with_label ("insert random");
5965 gtk_signal_connect (GTK_OBJECT (button), "clicked",
5966 GTK_SIGNAL_FUNC(text_insert_random),
5968 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
5969 gtk_widget_show (button);
5971 button = gtk_button_new_with_label ("close");
5972 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
5973 GTK_SIGNAL_FUNC(gtk_widget_destroy),
5974 GTK_OBJECT (window));
5975 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
5976 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
5977 gtk_widget_grab_default (button);
5978 gtk_widget_show (button);
5981 if (!GTK_WIDGET_VISIBLE (window))
5982 gtk_widget_show (window);
5984 gtk_widget_destroy (window);
5991 GdkPixmap *book_open;
5992 GdkPixmap *book_closed;
5993 GdkBitmap *book_open_mask;
5994 GdkBitmap *book_closed_mask;
5995 GtkWidget *sample_notebook;
5998 page_switch (GtkWidget *widget, GtkNotebookPage *page, gint page_num)
6000 GtkNotebookPage *oldpage;
6003 oldpage = GTK_NOTEBOOK (widget)->cur_page;
6005 if (page == oldpage)
6007 pixwid = ((GtkBoxChild*)
6008 (GTK_BOX (page->tab_label)->children->data))->widget;
6009 gtk_pixmap_set (GTK_PIXMAP (pixwid), book_open, book_open_mask);
6010 pixwid = ((GtkBoxChild*)
6011 (GTK_BOX (page->menu_label)->children->data))->widget;
6012 gtk_pixmap_set (GTK_PIXMAP (pixwid), book_open, book_open_mask);
6016 pixwid = ((GtkBoxChild*)
6017 (GTK_BOX (oldpage->tab_label)->children->data))->widget;
6018 gtk_pixmap_set (GTK_PIXMAP (pixwid), book_closed, book_closed_mask);
6019 pixwid = ((GtkBoxChild*)
6020 (GTK_BOX (oldpage->menu_label)->children->data))->widget;
6021 gtk_pixmap_set (GTK_PIXMAP (pixwid), book_closed, book_closed_mask);
6026 tab_fill (GtkToggleButton *button, GtkWidget *child)
6029 GtkPackType pack_type;
6031 gtk_notebook_query_tab_label_packing (GTK_NOTEBOOK (sample_notebook), child,
6032 &expand, NULL, &pack_type);
6033 gtk_notebook_set_tab_label_packing (GTK_NOTEBOOK (sample_notebook), child,
6034 expand, button->active, pack_type);
6038 tab_expand (GtkToggleButton *button, GtkWidget *child)
6041 GtkPackType pack_type;
6043 gtk_notebook_query_tab_label_packing (GTK_NOTEBOOK (sample_notebook), child,
6044 NULL, &fill, &pack_type);
6045 gtk_notebook_set_tab_label_packing (GTK_NOTEBOOK (sample_notebook), child,
6046 button->active, fill, pack_type);
6050 tab_pack (GtkToggleButton *button, GtkWidget *child)
6056 gtk_notebook_query_tab_label_packing (GTK_NOTEBOOK (sample_notebook), child,
6057 &expand, &fill, NULL);
6058 gtk_notebook_set_tab_label_packing (GTK_NOTEBOOK (sample_notebook), child,
6059 expand, fill, button->active);
6063 create_pages (GtkNotebook *notebook, gint start, gint end)
6065 GtkWidget *child = NULL;
6070 GtkWidget *label_box;
6071 GtkWidget *menu_box;
6076 for (i = start; i <= end; i++)
6078 sprintf (buffer, "Page %d", i);
6080 child = gtk_frame_new (buffer);
6081 gtk_container_set_border_width (GTK_CONTAINER (child), 10);
6083 vbox = gtk_vbox_new (TRUE,0);
6084 gtk_container_set_border_width (GTK_CONTAINER (vbox), 10);
6085 gtk_container_add (GTK_CONTAINER (child), vbox);
6087 hbox = gtk_hbox_new (TRUE,0);
6088 gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 5);
6090 button = gtk_check_button_new_with_label ("Fill Tab");
6091 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
6092 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
6093 gtk_signal_connect (GTK_OBJECT (button), "toggled",
6094 GTK_SIGNAL_FUNC (tab_fill), child);
6096 button = gtk_check_button_new_with_label ("Expand Tab");
6097 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
6098 gtk_signal_connect (GTK_OBJECT (button), "toggled",
6099 GTK_SIGNAL_FUNC (tab_expand), child);
6101 button = gtk_check_button_new_with_label ("Pack end");
6102 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
6103 gtk_signal_connect (GTK_OBJECT (button), "toggled",
6104 GTK_SIGNAL_FUNC (tab_pack), child);
6106 button = gtk_button_new_with_label ("Hide Page");
6107 gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 5);
6108 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
6109 GTK_SIGNAL_FUNC (gtk_widget_hide),
6110 GTK_OBJECT (child));
6112 gtk_widget_show_all (child);
6114 label_box = gtk_hbox_new (FALSE, 0);
6115 pixwid = gtk_pixmap_new (book_closed, book_closed_mask);
6116 gtk_box_pack_start (GTK_BOX (label_box), pixwid, FALSE, TRUE, 0);
6117 gtk_misc_set_padding (GTK_MISC (pixwid), 3, 1);
6118 label = gtk_label_new (buffer);
6119 gtk_box_pack_start (GTK_BOX (label_box), label, FALSE, TRUE, 0);
6120 gtk_widget_show_all (label_box);
6122 menu_box = gtk_hbox_new (FALSE, 0);
6123 pixwid = gtk_pixmap_new (book_closed, book_closed_mask);
6124 gtk_box_pack_start (GTK_BOX (menu_box), pixwid, FALSE, TRUE, 0);
6125 gtk_misc_set_padding (GTK_MISC (pixwid), 3, 1);
6126 label = gtk_label_new (buffer);
6127 gtk_box_pack_start (GTK_BOX (menu_box), label, FALSE, TRUE, 0);
6128 gtk_widget_show_all (menu_box);
6129 gtk_notebook_append_page_menu (notebook, child, label_box, menu_box);
6134 rotate_notebook (GtkButton *button,
6135 GtkNotebook *notebook)
6137 gtk_notebook_set_tab_pos (notebook, (notebook->tab_pos + 1) % 4);
6141 show_all_pages (GtkButton *button,
6142 GtkNotebook *notebook)
6144 gtk_container_foreach (GTK_CONTAINER (notebook),
6145 (GtkCallback) gtk_widget_show, NULL);
6149 standard_notebook (GtkButton *button,
6150 GtkNotebook *notebook)
6154 gtk_notebook_set_show_tabs (notebook, TRUE);
6155 gtk_notebook_set_scrollable (notebook, FALSE);
6156 if (g_list_length (notebook->children) == 15)
6157 for (i = 0; i < 10; i++)
6158 gtk_notebook_remove_page (notebook, 5);
6162 notabs_notebook (GtkButton *button,
6163 GtkNotebook *notebook)
6167 gtk_notebook_set_show_tabs (notebook, FALSE);
6168 if (g_list_length (notebook->children) == 15)
6169 for (i = 0; i < 10; i++)
6170 gtk_notebook_remove_page (notebook, 5);
6174 scrollable_notebook (GtkButton *button,
6175 GtkNotebook *notebook)
6177 gtk_notebook_set_show_tabs (notebook, TRUE);
6178 gtk_notebook_set_scrollable (notebook, TRUE);
6179 if (g_list_length (notebook->children) == 5)
6180 create_pages (notebook, 6, 15);
6184 notebook_popup (GtkToggleButton *button,
6185 GtkNotebook *notebook)
6188 gtk_notebook_popup_enable (notebook);
6190 gtk_notebook_popup_disable (notebook);
6194 notebook_homogeneous (GtkToggleButton *button,
6195 GtkNotebook *notebook)
6197 gtk_notebook_set_homogeneous_tabs (notebook, button->active);
6201 create_notebook (void)
6203 static GtkWidget *window = NULL;
6207 GtkWidget *separator;
6209 GdkColor *transparent = NULL;
6212 static OptionMenuItem items[] =
6214 { "Standard", standard_notebook },
6215 { "No tabs", notabs_notebook },
6216 { "Scrollable", scrollable_notebook }
6221 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
6223 gtk_signal_connect (GTK_OBJECT (window), "destroy",
6224 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
6227 gtk_window_set_title (GTK_WINDOW (window), "notebook");
6228 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
6230 box1 = gtk_vbox_new (FALSE, 0);
6231 gtk_container_add (GTK_CONTAINER (window), box1);
6233 sample_notebook = gtk_notebook_new ();
6234 gtk_signal_connect (GTK_OBJECT (sample_notebook), "switch_page",
6235 GTK_SIGNAL_FUNC (page_switch), NULL);
6236 gtk_notebook_set_tab_pos (GTK_NOTEBOOK (sample_notebook), GTK_POS_TOP);
6237 gtk_box_pack_start (GTK_BOX (box1), sample_notebook, TRUE, TRUE, 0);
6238 gtk_container_set_border_width (GTK_CONTAINER (sample_notebook), 10);
6240 gtk_widget_realize (sample_notebook);
6242 book_open = gdk_pixmap_create_from_xpm_d (sample_notebook->window,
6247 book_closed = gdk_pixmap_create_from_xpm_d (sample_notebook->window,
6252 create_pages (GTK_NOTEBOOK (sample_notebook), 1, 5);
6254 separator = gtk_hseparator_new ();
6255 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 10);
6257 box2 = gtk_hbox_new (FALSE, 5);
6258 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
6259 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
6261 button = gtk_check_button_new_with_label ("popup menu");
6262 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, FALSE, 0);
6263 gtk_signal_connect (GTK_OBJECT(button), "clicked",
6264 GTK_SIGNAL_FUNC (notebook_popup),
6265 GTK_OBJECT (sample_notebook));
6267 button = gtk_check_button_new_with_label ("homogeneous tabs");
6268 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, FALSE, 0);
6269 gtk_signal_connect (GTK_OBJECT(button), "clicked",
6270 GTK_SIGNAL_FUNC (notebook_homogeneous),
6271 GTK_OBJECT (sample_notebook));
6273 box2 = gtk_hbox_new (FALSE, 5);
6274 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
6275 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
6277 label = gtk_label_new ("Notebook Style :");
6278 gtk_box_pack_start (GTK_BOX (box2), label, FALSE, TRUE, 0);
6280 omenu = build_option_menu (items, 3, 0, sample_notebook);
6281 gtk_box_pack_start (GTK_BOX (box2), omenu, FALSE, TRUE, 0);
6283 button = gtk_button_new_with_label ("Show all Pages");
6284 gtk_box_pack_start (GTK_BOX (box2), button, FALSE, TRUE, 0);
6285 gtk_signal_connect (GTK_OBJECT (button), "clicked",
6286 GTK_SIGNAL_FUNC (show_all_pages), sample_notebook);
6288 box2 = gtk_hbox_new (TRUE, 10);
6289 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
6290 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
6292 button = gtk_button_new_with_label ("prev");
6293 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
6294 GTK_SIGNAL_FUNC (gtk_notebook_prev_page),
6295 GTK_OBJECT (sample_notebook));
6296 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
6298 button = gtk_button_new_with_label ("next");
6299 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
6300 GTK_SIGNAL_FUNC (gtk_notebook_next_page),
6301 GTK_OBJECT (sample_notebook));
6302 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
6304 button = gtk_button_new_with_label ("rotate");
6305 gtk_signal_connect (GTK_OBJECT (button), "clicked",
6306 GTK_SIGNAL_FUNC (rotate_notebook), sample_notebook);
6307 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
6309 separator = gtk_hseparator_new ();
6310 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 5);
6312 button = gtk_button_new_with_label ("close");
6313 gtk_container_set_border_width (GTK_CONTAINER (button), 5);
6314 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
6315 GTK_SIGNAL_FUNC (gtk_widget_destroy),
6316 GTK_OBJECT (window));
6317 gtk_box_pack_start (GTK_BOX (box1), button, FALSE, FALSE, 0);
6318 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
6319 gtk_widget_grab_default (button);
6322 if (!GTK_WIDGET_VISIBLE (window))
6323 gtk_widget_show_all (window);
6325 gtk_widget_destroy (window);
6333 toggle_resize (GtkWidget *widget, GtkWidget *child)
6335 GtkPaned *paned = GTK_PANED (child->parent);
6336 gboolean is_child1 = (child == paned->child1);
6337 gboolean resize, shrink;
6339 resize = is_child1 ? paned->child1_resize : paned->child2_resize;
6340 shrink = is_child1 ? paned->child1_shrink : paned->child2_shrink;
6342 gtk_widget_ref (child);
6343 gtk_container_remove (GTK_CONTAINER (child->parent), child);
6345 gtk_paned_pack1 (paned, child, !resize, shrink);
6347 gtk_paned_pack2 (paned, child, !resize, shrink);
6348 gtk_widget_unref (child);
6352 toggle_shrink (GtkWidget *widget, GtkWidget *child)
6354 GtkPaned *paned = GTK_PANED (child->parent);
6355 gboolean is_child1 = (child == paned->child1);
6356 gboolean resize, shrink;
6358 resize = is_child1 ? paned->child1_resize : paned->child2_resize;
6359 shrink = is_child1 ? paned->child1_shrink : paned->child2_shrink;
6361 gtk_widget_ref (child);
6362 gtk_container_remove (GTK_CONTAINER (child->parent), child);
6364 gtk_paned_pack1 (paned, child, resize, !shrink);
6366 gtk_paned_pack2 (paned, child, resize, !shrink);
6367 gtk_widget_unref (child);
6371 create_pane_options (GtkPaned *paned,
6372 const gchar *frame_label,
6373 const gchar *label1,
6374 const gchar *label2)
6379 GtkWidget *check_button;
6381 frame = gtk_frame_new (frame_label);
6382 gtk_container_set_border_width (GTK_CONTAINER (frame), 4);
6384 table = gtk_table_new (3, 2, 4);
6385 gtk_container_add (GTK_CONTAINER (frame), table);
6387 label = gtk_label_new (label1);
6388 gtk_table_attach_defaults (GTK_TABLE (table), label,
6391 check_button = gtk_check_button_new_with_label ("Resize");
6392 gtk_table_attach_defaults (GTK_TABLE (table), check_button,
6394 gtk_signal_connect (GTK_OBJECT (check_button), "toggled",
6395 GTK_SIGNAL_FUNC (toggle_resize),
6398 check_button = gtk_check_button_new_with_label ("Shrink");
6399 gtk_table_attach_defaults (GTK_TABLE (table), check_button,
6401 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check_button),
6403 gtk_signal_connect (GTK_OBJECT (check_button), "toggled",
6404 GTK_SIGNAL_FUNC (toggle_shrink),
6407 label = gtk_label_new (label2);
6408 gtk_table_attach_defaults (GTK_TABLE (table), label,
6411 check_button = gtk_check_button_new_with_label ("Resize");
6412 gtk_table_attach_defaults (GTK_TABLE (table), check_button,
6414 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check_button),
6416 gtk_signal_connect (GTK_OBJECT (check_button), "toggled",
6417 GTK_SIGNAL_FUNC (toggle_resize),
6420 check_button = gtk_check_button_new_with_label ("Shrink");
6421 gtk_table_attach_defaults (GTK_TABLE (table), check_button,
6423 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check_button),
6425 gtk_signal_connect (GTK_OBJECT (check_button), "toggled",
6426 GTK_SIGNAL_FUNC (toggle_shrink),
6435 static GtkWidget *window = NULL;
6444 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
6446 gtk_signal_connect (GTK_OBJECT (window), "destroy",
6447 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
6450 gtk_window_set_title (GTK_WINDOW (window), "Panes");
6451 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
6453 vbox = gtk_vbox_new (FALSE, 0);
6454 gtk_container_add (GTK_CONTAINER (window), vbox);
6456 vpaned = gtk_vpaned_new ();
6457 gtk_box_pack_start (GTK_BOX (vbox), vpaned, TRUE, TRUE, 0);
6458 gtk_container_set_border_width (GTK_CONTAINER(vpaned), 5);
6460 hpaned = gtk_hpaned_new ();
6461 gtk_paned_add1 (GTK_PANED (vpaned), hpaned);
6463 frame = gtk_frame_new (NULL);
6464 gtk_frame_set_shadow_type (GTK_FRAME(frame), GTK_SHADOW_IN);
6465 gtk_widget_set_usize (frame, 60, 60);
6466 gtk_paned_add1 (GTK_PANED (hpaned), frame);
6468 button = gtk_button_new_with_label ("Hi there");
6469 gtk_container_add (GTK_CONTAINER(frame), button);
6471 frame = gtk_frame_new (NULL);
6472 gtk_frame_set_shadow_type (GTK_FRAME(frame), GTK_SHADOW_IN);
6473 gtk_widget_set_usize (frame, 80, 60);
6474 gtk_paned_add2 (GTK_PANED (hpaned), frame);
6476 frame = gtk_frame_new (NULL);
6477 gtk_frame_set_shadow_type (GTK_FRAME(frame), GTK_SHADOW_IN);
6478 gtk_widget_set_usize (frame, 60, 80);
6479 gtk_paned_add2 (GTK_PANED (vpaned), frame);
6481 /* Now create toggle buttons to control sizing */
6483 gtk_box_pack_start (GTK_BOX (vbox),
6484 create_pane_options (GTK_PANED (hpaned),
6490 gtk_box_pack_start (GTK_BOX (vbox),
6491 create_pane_options (GTK_PANED (vpaned),
6497 gtk_widget_show_all (vbox);
6500 if (!GTK_WIDGET_VISIBLE (window))
6501 gtk_widget_show (window);
6503 gtk_widget_destroy (window);
6512 dnd_drop_destroy_popup (GtkWidget *widget, GtkWindow **window)
6514 if(GTK_IS_BUTTON(widget)) /* I.e. they clicked the close button */
6515 gtk_widget_destroy(GTK_WIDGET(*window));
6517 gtk_grab_remove(GTK_WIDGET(*window));
6525 dnd_drop (GtkWidget *button, GdkEvent *event)
6527 static GtkWidget *window = NULL;
6528 GtkWidget *vbox, *lbl, *btn;
6531 /* DND doesn't obey gtk_grab's, so check if we're already displaying
6532 * drop modal dialog first
6537 window = gtk_window_new(GTK_WINDOW_DIALOG);
6538 gtk_container_set_border_width (GTK_CONTAINER(window), 10);
6540 gtk_signal_connect (GTK_OBJECT (window), "destroy",
6541 GTK_SIGNAL_FUNC(dnd_drop_destroy_popup),
6543 gtk_signal_connect (GTK_OBJECT (window), "delete-event",
6544 GTK_SIGNAL_FUNC(gtk_false),
6547 vbox = gtk_vbox_new(FALSE, 5);
6549 /* Display message that we got from drop source */
6550 msg = g_malloc(strlen(event->dropdataavailable.data)
6551 + strlen(event->dropdataavailable.data_type) + 100);
6552 sprintf(msg, "Drop data of type %s was:\n\n%s",
6553 event->dropdataavailable.data_type,
6554 (char *)event->dropdataavailable.data);
6555 lbl = gtk_label_new(msg);
6556 gtk_label_set_justify(GTK_LABEL(lbl), GTK_JUSTIFY_FILL);
6558 gtk_widget_show(lbl);
6559 gtk_box_pack_start_defaults(GTK_BOX(vbox), lbl);
6561 /* Provide an obvious way out of this heinousness */
6562 btn = gtk_button_new_with_label("Continue with life in\nspite of this oppression");
6563 gtk_signal_connect_object (GTK_OBJECT (btn), "clicked",
6564 GTK_SIGNAL_FUNC(gtk_widget_destroy),
6565 GTK_OBJECT (window));
6566 gtk_widget_show(btn);
6567 gtk_box_pack_start_defaults(GTK_BOX(vbox), btn);
6569 gtk_container_add(GTK_CONTAINER(window), vbox);
6571 gtk_widget_show(vbox);
6572 gtk_grab_add(window);
6573 gtk_widget_show(window);
6577 dnd_drag_request (GtkWidget *button, GdkEvent *event)
6579 #define DND_STRING "Bill Gates demands royalties for\nyour use of his innovation."
6580 gtk_widget_dnd_data_set (button, event, DND_STRING, strlen(DND_STRING) + 1);
6586 static GtkWidget *window = NULL;
6592 GtkWidget *separator;
6594 /* For clarity... */
6595 char *possible_drag_types[] = {"text/plain"};
6596 char *accepted_drop_types[] = {"text/plain"};
6598 static GtkWidget *drag_icon = NULL;
6599 static GtkWidget *drop_icon = NULL;
6603 GdkPoint hotspot = {5,5};
6607 drag_icon = shape_create_icon ("Modeller.xpm",
6608 440, 140, 0,0, GTK_WINDOW_POPUP);
6610 gtk_signal_connect (GTK_OBJECT (drag_icon), "destroy",
6611 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
6614 gtk_widget_hide (drag_icon);
6619 drop_icon = shape_create_icon ("3DRings.xpm",
6620 440, 140, 0,0, GTK_WINDOW_POPUP);
6622 gtk_signal_connect (GTK_OBJECT (drop_icon), "destroy",
6623 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
6626 gtk_widget_hide (drop_icon);
6629 gdk_dnd_set_drag_shape(drag_icon->window,
6634 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
6636 gtk_signal_connect (GTK_OBJECT (window), "destroy",
6637 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
6640 gtk_window_set_title (GTK_WINDOW (window), "Drag -N- Drop");
6641 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
6643 box1 = gtk_vbox_new (FALSE, 0);
6644 gtk_container_add (GTK_CONTAINER (window), box1);
6645 gtk_widget_show (box1);
6647 box2 = gtk_hbox_new (FALSE, 5);
6648 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
6649 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
6650 gtk_widget_show (box2);
6652 frame = gtk_frame_new ("Drag");
6653 gtk_box_pack_start (GTK_BOX (box2), frame, TRUE, TRUE, 0);
6654 gtk_widget_show (frame);
6656 box3 = gtk_vbox_new (FALSE, 5);
6657 gtk_container_set_border_width (GTK_CONTAINER (box3), 5);
6658 gtk_container_add (GTK_CONTAINER (frame), box3);
6659 gtk_widget_show (box3);
6664 button = gtk_button_new_with_label ("Drag me!");
6665 gtk_box_pack_start (GTK_BOX (box3), button, FALSE, TRUE, 0);
6666 gtk_widget_show (button);
6669 * currently, the widget has to be realized to
6670 * set dnd on it, this needs to change
6672 gtk_widget_realize (button);
6673 gtk_signal_connect (GTK_OBJECT (button),
6674 "drag_request_event",
6675 GTK_SIGNAL_FUNC(dnd_drag_request),
6678 gtk_widget_dnd_drag_set (button, TRUE, possible_drag_types, 1);
6681 frame = gtk_frame_new ("Drop");
6682 gtk_box_pack_start (GTK_BOX (box2), frame, TRUE, TRUE, 0);
6683 gtk_widget_show (frame);
6685 box3 = gtk_vbox_new (FALSE, 5);
6686 gtk_container_set_border_width (GTK_CONTAINER (box3), 5);
6687 gtk_container_add (GTK_CONTAINER (frame), box3);
6688 gtk_widget_show (box3);
6694 button = gtk_button_new_with_label ("To");
6695 gtk_box_pack_start (GTK_BOX (box3), button, FALSE, TRUE, 0);
6696 gtk_widget_show (button);
6698 gtk_widget_realize (button);
6699 gtk_signal_connect (GTK_OBJECT (button),
6700 "drop_data_available_event",
6701 GTK_SIGNAL_FUNC(dnd_drop),
6704 gtk_widget_dnd_drop_set (button, TRUE, accepted_drop_types, 1, FALSE);
6707 separator = gtk_hseparator_new ();
6708 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
6709 gtk_widget_show (separator);
6712 box2 = gtk_vbox_new (FALSE, 10);
6713 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
6714 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
6715 gtk_widget_show (box2);
6718 button = gtk_button_new_with_label ("close");
6720 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
6721 GTK_SIGNAL_FUNC(gtk_widget_destroy),
6722 GTK_OBJECT (window));
6724 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
6725 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
6726 gtk_widget_grab_default (button);
6727 gtk_widget_show (button);
6730 if (!GTK_WIDGET_VISIBLE (window))
6731 gtk_widget_show (window);
6733 gtk_widget_destroy (window);
6741 typedef struct _cursoroffset {gint x,y;} CursorOffset;
6744 shape_pressed (GtkWidget *widget, GdkEventButton *event)
6748 /* ignore double and triple click */
6749 if (event->type != GDK_BUTTON_PRESS)
6752 p = gtk_object_get_user_data (GTK_OBJECT(widget));
6753 p->x = (int) event->x;
6754 p->y = (int) event->y;
6756 gtk_grab_add (widget);
6757 gdk_pointer_grab (widget->window, TRUE,
6758 GDK_BUTTON_RELEASE_MASK |
6759 GDK_BUTTON_MOTION_MASK |
6760 GDK_POINTER_MOTION_HINT_MASK,
6765 shape_released (GtkWidget *widget)
6767 gtk_grab_remove (widget);
6768 gdk_pointer_ungrab (0);
6772 shape_motion (GtkWidget *widget,
6773 GdkEventMotion *event)
6777 GdkModifierType mask;
6779 p = gtk_object_get_user_data (GTK_OBJECT (widget));
6782 * Can't use event->x / event->y here
6783 * because I need absolute coordinates.
6785 gdk_window_get_pointer (NULL, &xp, &yp, &mask);
6786 gtk_widget_set_uposition (widget, xp - p->x, yp - p->y);
6790 shape_create_icon (char *xpm_file,
6800 CursorOffset* icon_pos;
6802 GdkBitmap *gdk_pixmap_mask;
6803 GdkPixmap *gdk_pixmap;
6806 style = gtk_widget_get_default_style ();
6807 gc = style->black_gc;
6810 * GDK_WINDOW_TOPLEVEL works also, giving you a title border
6812 window = gtk_window_new (window_type);
6814 fixed = gtk_fixed_new ();
6815 gtk_widget_set_usize (fixed, 100,100);
6816 gtk_container_add (GTK_CONTAINER (window), fixed);
6817 gtk_widget_show (fixed);
6819 gtk_widget_set_events (window,
6820 gtk_widget_get_events (window) |
6821 GDK_BUTTON_MOTION_MASK |
6822 GDK_POINTER_MOTION_HINT_MASK |
6823 GDK_BUTTON_PRESS_MASK);
6825 gtk_widget_realize (window);
6826 gdk_pixmap = gdk_pixmap_create_from_xpm (window->window, &gdk_pixmap_mask,
6827 &style->bg[GTK_STATE_NORMAL],
6830 pixmap = gtk_pixmap_new (gdk_pixmap, gdk_pixmap_mask);
6831 gtk_fixed_put (GTK_FIXED (fixed), pixmap, px,py);
6832 gtk_widget_show (pixmap);
6834 gtk_widget_shape_combine_mask (window, gdk_pixmap_mask, px, py);
6836 gdk_drawable_unref (gdk_pixmap_mask);
6837 gdk_drawable_unref (gdk_pixmap);
6839 gtk_signal_connect (GTK_OBJECT (window), "button_press_event",
6840 GTK_SIGNAL_FUNC (shape_pressed),NULL);
6841 gtk_signal_connect (GTK_OBJECT (window), "button_release_event",
6842 GTK_SIGNAL_FUNC (shape_released),NULL);
6843 gtk_signal_connect (GTK_OBJECT (window), "motion_notify_event",
6844 GTK_SIGNAL_FUNC (shape_motion),NULL);
6846 icon_pos = g_new (CursorOffset, 1);
6847 gtk_object_set_user_data(GTK_OBJECT(window), icon_pos);
6849 gtk_widget_set_uposition (window, x, y);
6850 gtk_widget_show (window);
6856 create_shapes (void)
6858 /* Variables used by the Drag/Drop and Shape Window demos */
6859 static GtkWidget *modeller = NULL;
6860 static GtkWidget *sheets = NULL;
6861 static GtkWidget *rings = NULL;
6863 if (!(file_exists ("Modeller.xpm") &&
6864 file_exists ("FilesQueue.xpm") &&
6865 file_exists ("3DRings.xpm")))
6871 modeller = shape_create_icon ("Modeller.xpm",
6872 440, 140, 0,0, GTK_WINDOW_POPUP);
6874 gtk_signal_connect (GTK_OBJECT (modeller), "destroy",
6875 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
6879 gtk_widget_destroy (modeller);
6883 sheets = shape_create_icon ("FilesQueue.xpm",
6884 580, 170, 0,0, GTK_WINDOW_POPUP);
6886 gtk_signal_connect (GTK_OBJECT (sheets), "destroy",
6887 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
6892 gtk_widget_destroy (sheets);
6896 rings = shape_create_icon ("3DRings.xpm",
6897 460, 270, 25,25, GTK_WINDOW_TOPLEVEL);
6899 gtk_signal_connect (GTK_OBJECT (rings), "destroy",
6900 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
6904 gtk_widget_destroy (rings);
6912 create_wmhints (void)
6914 static GtkWidget *window = NULL;
6916 GtkWidget *separator;
6925 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
6927 gtk_signal_connect (GTK_OBJECT (window), "destroy",
6928 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
6931 gtk_window_set_title (GTK_WINDOW (window), "WM Hints");
6932 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
6934 gtk_widget_realize (window);
6936 circles = gdk_bitmap_create_from_data (window->window,
6940 gdk_window_set_icon (window->window, NULL,
6943 gdk_window_set_icon_name (window->window, "WMHints Test Icon");
6945 gdk_window_set_decorations (window->window, GDK_DECOR_ALL | GDK_DECOR_MENU);
6946 gdk_window_set_functions (window->window, GDK_FUNC_ALL | GDK_FUNC_RESIZE);
6948 box1 = gtk_vbox_new (FALSE, 0);
6949 gtk_container_add (GTK_CONTAINER (window), box1);
6950 gtk_widget_show (box1);
6952 label = gtk_label_new ("Try iconizing me!");
6953 gtk_widget_set_usize (label, 150, 50);
6954 gtk_box_pack_start (GTK_BOX (box1), label, TRUE, TRUE, 0);
6955 gtk_widget_show (label);
6958 separator = gtk_hseparator_new ();
6959 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
6960 gtk_widget_show (separator);
6963 box2 = gtk_vbox_new (FALSE, 10);
6964 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
6965 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
6966 gtk_widget_show (box2);
6969 button = gtk_button_new_with_label ("close");
6971 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
6972 GTK_SIGNAL_FUNC(gtk_widget_destroy),
6973 GTK_OBJECT (window));
6975 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
6976 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
6977 gtk_widget_grab_default (button);
6978 gtk_widget_show (button);
6981 if (!GTK_WIDGET_VISIBLE (window))
6982 gtk_widget_show (window);
6984 gtk_widget_destroy (window);
6991 typedef struct _ProgressData {
6994 GtkWidget *block_spin;
6995 GtkWidget *x_align_spin;
6996 GtkWidget *y_align_spin;
6997 GtkWidget *step_spin;
6998 GtkWidget *act_blocks_spin;
7007 progress_timeout (gpointer data)
7012 adj = GTK_PROGRESS (data)->adjustment;
7014 new_val = adj->value + 1;
7015 if (new_val > adj->upper)
7016 new_val = adj->lower;
7018 gtk_progress_set_value (GTK_PROGRESS (data), new_val);
7024 destroy_progress (GtkWidget *widget,
7025 ProgressData **pdata)
7027 gtk_timeout_remove ((*pdata)->timer);
7028 (*pdata)->timer = 0;
7029 (*pdata)->window = NULL;
7035 progressbar_toggle_orientation (GtkWidget *widget, ProgressData *pdata)
7039 if (!GTK_WIDGET_MAPPED (widget))
7042 RADIOMENUTOGGLED ((GtkRadioMenuItem *)
7043 (((GtkOptionMenu *)(pdata->omenu1))->menu_item), i);
7045 gtk_progress_bar_set_orientation (GTK_PROGRESS_BAR (pdata->pbar),
7046 (GtkProgressBarOrientation) (3-i));
7050 toggle_show_text (GtkWidget *widget, ProgressData *pdata)
7052 gtk_progress_set_show_text (GTK_PROGRESS (pdata->pbar),
7053 GTK_TOGGLE_BUTTON (widget)->active);
7054 gtk_widget_set_sensitive (pdata->entry, GTK_TOGGLE_BUTTON (widget)->active);
7055 gtk_widget_set_sensitive (pdata->x_align_spin,
7056 GTK_TOGGLE_BUTTON (widget)->active);
7057 gtk_widget_set_sensitive (pdata->y_align_spin,
7058 GTK_TOGGLE_BUTTON (widget)->active);
7062 progressbar_toggle_bar_style (GtkWidget *widget, ProgressData *pdata)
7066 if (!GTK_WIDGET_MAPPED (widget))
7069 RADIOMENUTOGGLED ((GtkRadioMenuItem *)
7070 (((GtkOptionMenu *)(pdata->omenu2))->menu_item), i);
7075 gtk_widget_set_sensitive (pdata->block_spin, TRUE);
7077 gtk_widget_set_sensitive (pdata->block_spin, FALSE);
7079 gtk_progress_bar_set_bar_style (GTK_PROGRESS_BAR (pdata->pbar),
7080 (GtkProgressBarStyle) i);
7084 progress_value_changed (GtkAdjustment *adj, ProgressData *pdata)
7088 if (GTK_PROGRESS (pdata->pbar)->activity_mode)
7089 sprintf (buf, "???");
7091 sprintf (buf, "%.0f%%", 100 *
7092 gtk_progress_get_current_percentage (GTK_PROGRESS (pdata->pbar)));
7093 gtk_label_set_text (GTK_LABEL (pdata->label), buf);
7097 adjust_blocks (GtkAdjustment *adj, ProgressData *pdata)
7099 gtk_progress_set_percentage (GTK_PROGRESS (pdata->pbar), 0);
7100 gtk_progress_bar_set_discrete_blocks (GTK_PROGRESS_BAR (pdata->pbar),
7101 gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (pdata->block_spin)));
7105 adjust_step (GtkAdjustment *adj, ProgressData *pdata)
7107 gtk_progress_bar_set_activity_step (GTK_PROGRESS_BAR (pdata->pbar),
7108 gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (pdata->step_spin)));
7112 adjust_act_blocks (GtkAdjustment *adj, ProgressData *pdata)
7114 gtk_progress_bar_set_activity_blocks (GTK_PROGRESS_BAR (pdata->pbar),
7115 gtk_spin_button_get_value_as_int
7116 (GTK_SPIN_BUTTON (pdata->act_blocks_spin)));
7120 adjust_align (GtkAdjustment *adj, ProgressData *pdata)
7122 gtk_progress_set_text_alignment (GTK_PROGRESS (pdata->pbar),
7123 gtk_spin_button_get_value_as_float
7124 (GTK_SPIN_BUTTON (pdata->x_align_spin)),
7125 gtk_spin_button_get_value_as_float
7126 (GTK_SPIN_BUTTON (pdata->y_align_spin)));
7130 toggle_activity_mode (GtkWidget *widget, ProgressData *pdata)
7132 gtk_progress_set_activity_mode (GTK_PROGRESS (pdata->pbar),
7133 GTK_TOGGLE_BUTTON (widget)->active);
7134 gtk_widget_set_sensitive (pdata->step_spin,
7135 GTK_TOGGLE_BUTTON (widget)->active);
7136 gtk_widget_set_sensitive (pdata->act_blocks_spin,
7137 GTK_TOGGLE_BUTTON (widget)->active);
7141 entry_changed (GtkWidget *widget, ProgressData *pdata)
7143 gtk_progress_set_format_string (GTK_PROGRESS (pdata->pbar),
7144 gtk_entry_get_text (GTK_ENTRY (pdata->entry)));
7148 create_progress_bar (void)
7160 static ProgressData *pdata = NULL;
7162 static OptionMenuItem items1[] =
7164 { "Left-Right", progressbar_toggle_orientation },
7165 { "Right-Left", progressbar_toggle_orientation },
7166 { "Bottom-Top", progressbar_toggle_orientation },
7167 { "Top-Bottom", progressbar_toggle_orientation }
7170 static OptionMenuItem items2[] =
7172 { "Continuous", progressbar_toggle_bar_style },
7173 { "Discrete", progressbar_toggle_bar_style }
7177 pdata = g_new0 (ProgressData, 1);
7181 pdata->window = gtk_dialog_new ();
7183 gtk_window_set_policy (GTK_WINDOW (pdata->window), FALSE, FALSE, TRUE);
7185 gtk_signal_connect (GTK_OBJECT (pdata->window), "destroy",
7186 GTK_SIGNAL_FUNC (destroy_progress),
7191 gtk_window_set_title (GTK_WINDOW (pdata->window), "GtkProgressBar");
7192 gtk_container_set_border_width (GTK_CONTAINER (pdata->window), 0);
7194 vbox = gtk_vbox_new (FALSE, 5);
7195 gtk_container_set_border_width (GTK_CONTAINER (vbox), 10);
7196 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (pdata->window)->vbox),
7197 vbox, FALSE, TRUE, 0);
7199 frame = gtk_frame_new ("Progress");
7200 gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, TRUE, 0);
7202 vbox2 = gtk_vbox_new (FALSE, 5);
7203 gtk_container_add (GTK_CONTAINER (frame), vbox2);
7205 align = gtk_alignment_new (0.5, 0.5, 0, 0);
7206 gtk_box_pack_start (GTK_BOX (vbox2), align, FALSE, FALSE, 5);
7208 adj = (GtkAdjustment *) gtk_adjustment_new (0, 1, 300, 0, 0, 0);
7209 gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
7210 GTK_SIGNAL_FUNC (progress_value_changed), pdata);
7212 pdata->pbar = gtk_progress_bar_new_with_adjustment (adj);
7213 gtk_progress_set_format_string (GTK_PROGRESS (pdata->pbar),
7214 "%v from [%l,%u] (=%p%%)");
7215 gtk_container_add (GTK_CONTAINER (align), pdata->pbar);
7216 pdata->timer = gtk_timeout_add (100, progress_timeout, pdata->pbar);
7218 align = gtk_alignment_new (0.5, 0.5, 0, 0);
7219 gtk_box_pack_start (GTK_BOX (vbox2), align, FALSE, FALSE, 5);
7221 hbox = gtk_hbox_new (FALSE, 5);
7222 gtk_container_add (GTK_CONTAINER (align), hbox);
7223 label = gtk_label_new ("Label updated by user :");
7224 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
7225 pdata->label = gtk_label_new ("");
7226 gtk_box_pack_start (GTK_BOX (hbox), pdata->label, FALSE, TRUE, 0);
7228 frame = gtk_frame_new ("Options");
7229 gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, TRUE, 0);
7231 vbox2 = gtk_vbox_new (FALSE, 5);
7232 gtk_container_add (GTK_CONTAINER (frame), vbox2);
7234 tab = gtk_table_new (7, 2, FALSE);
7235 gtk_box_pack_start (GTK_BOX (vbox2), tab, FALSE, TRUE, 0);
7237 label = gtk_label_new ("Orientation :");
7238 gtk_table_attach (GTK_TABLE (tab), label, 0, 1, 0, 1,
7239 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
7241 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
7243 pdata->omenu1 = build_option_menu (items1, 4, 0, pdata);
7244 hbox = gtk_hbox_new (FALSE, 0);
7245 gtk_table_attach (GTK_TABLE (tab), hbox, 1, 2, 0, 1,
7246 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
7248 gtk_box_pack_start (GTK_BOX (hbox), pdata->omenu1, TRUE, TRUE, 0);
7250 check = gtk_check_button_new_with_label ("Show text");
7251 gtk_signal_connect (GTK_OBJECT (check), "clicked",
7252 GTK_SIGNAL_FUNC (toggle_show_text),
7254 gtk_table_attach (GTK_TABLE (tab), check, 0, 1, 1, 2,
7255 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
7258 hbox = gtk_hbox_new (FALSE, 0);
7259 gtk_table_attach (GTK_TABLE (tab), hbox, 1, 2, 1, 2,
7260 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
7263 label = gtk_label_new ("Format : ");
7264 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
7266 pdata->entry = gtk_entry_new ();
7267 gtk_signal_connect (GTK_OBJECT (pdata->entry), "changed",
7268 GTK_SIGNAL_FUNC (entry_changed),
7270 gtk_box_pack_start (GTK_BOX (hbox), pdata->entry, TRUE, TRUE, 0);
7271 gtk_entry_set_text (GTK_ENTRY (pdata->entry), "%v from [%l,%u] (=%p%%)");
7272 gtk_widget_set_usize (pdata->entry, 100, -1);
7273 gtk_widget_set_sensitive (pdata->entry, FALSE);
7275 label = gtk_label_new ("Text align :");
7276 gtk_table_attach (GTK_TABLE (tab), label, 0, 1, 2, 3,
7277 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
7279 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
7281 hbox = gtk_hbox_new (FALSE, 0);
7282 gtk_table_attach (GTK_TABLE (tab), hbox, 1, 2, 2, 3,
7283 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
7286 label = gtk_label_new ("x :");
7287 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 5);
7289 adj = (GtkAdjustment *) gtk_adjustment_new (0.5, 0, 1, 0.1, 0.1, 0);
7290 pdata->x_align_spin = gtk_spin_button_new (adj, 0, 1);
7291 gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
7292 GTK_SIGNAL_FUNC (adjust_align), pdata);
7293 gtk_box_pack_start (GTK_BOX (hbox), pdata->x_align_spin, FALSE, TRUE, 0);
7294 gtk_widget_set_sensitive (pdata->x_align_spin, FALSE);
7296 label = gtk_label_new ("y :");
7297 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 5);
7299 adj = (GtkAdjustment *) gtk_adjustment_new (0.5, 0, 1, 0.1, 0.1, 0);
7300 pdata->y_align_spin = gtk_spin_button_new (adj, 0, 1);
7301 gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
7302 GTK_SIGNAL_FUNC (adjust_align), pdata);
7303 gtk_box_pack_start (GTK_BOX (hbox), pdata->y_align_spin, FALSE, TRUE, 0);
7304 gtk_widget_set_sensitive (pdata->y_align_spin, FALSE);
7306 label = gtk_label_new ("Bar Style :");
7307 gtk_table_attach (GTK_TABLE (tab), label, 0, 1, 3, 4,
7308 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
7310 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
7312 pdata->omenu2 = build_option_menu (items2, 2, 0, pdata);
7313 hbox = gtk_hbox_new (FALSE, 0);
7314 gtk_table_attach (GTK_TABLE (tab), hbox, 1, 2, 3, 4,
7315 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
7317 gtk_box_pack_start (GTK_BOX (hbox), pdata->omenu2, TRUE, TRUE, 0);
7319 label = gtk_label_new ("Block count :");
7320 gtk_table_attach (GTK_TABLE (tab), label, 0, 1, 4, 5,
7321 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
7323 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
7325 hbox = gtk_hbox_new (FALSE, 0);
7326 gtk_table_attach (GTK_TABLE (tab), hbox, 1, 2, 4, 5,
7327 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
7329 adj = (GtkAdjustment *) gtk_adjustment_new (10, 2, 20, 1, 5, 0);
7330 pdata->block_spin = gtk_spin_button_new (adj, 0, 0);
7331 gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
7332 GTK_SIGNAL_FUNC (adjust_blocks), pdata);
7333 gtk_box_pack_start (GTK_BOX (hbox), pdata->block_spin, FALSE, TRUE, 0);
7334 gtk_widget_set_sensitive (pdata->block_spin, FALSE);
7336 check = gtk_check_button_new_with_label ("Activity mode");
7337 gtk_signal_connect (GTK_OBJECT (check), "clicked",
7338 GTK_SIGNAL_FUNC (toggle_activity_mode),
7340 gtk_table_attach (GTK_TABLE (tab), check, 0, 1, 5, 6,
7341 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
7344 hbox = gtk_hbox_new (FALSE, 0);
7345 gtk_table_attach (GTK_TABLE (tab), hbox, 1, 2, 5, 6,
7346 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
7348 label = gtk_label_new ("Step size : ");
7349 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
7350 adj = (GtkAdjustment *) gtk_adjustment_new (3, 1, 20, 1, 5, 0);
7351 pdata->step_spin = gtk_spin_button_new (adj, 0, 0);
7352 gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
7353 GTK_SIGNAL_FUNC (adjust_step), pdata);
7354 gtk_box_pack_start (GTK_BOX (hbox), pdata->step_spin, FALSE, TRUE, 0);
7355 gtk_widget_set_sensitive (pdata->step_spin, FALSE);
7357 hbox = gtk_hbox_new (FALSE, 0);
7358 gtk_table_attach (GTK_TABLE (tab), hbox, 1, 2, 6, 7,
7359 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
7361 label = gtk_label_new ("Blocks : ");
7362 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
7363 adj = (GtkAdjustment *) gtk_adjustment_new (5, 2, 10, 1, 5, 0);
7364 pdata->act_blocks_spin = gtk_spin_button_new (adj, 0, 0);
7365 gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
7366 GTK_SIGNAL_FUNC (adjust_act_blocks), pdata);
7367 gtk_box_pack_start (GTK_BOX (hbox), pdata->act_blocks_spin, FALSE, TRUE,
7369 gtk_widget_set_sensitive (pdata->act_blocks_spin, FALSE);
7371 button = gtk_button_new_with_label ("close");
7372 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
7373 GTK_SIGNAL_FUNC (gtk_widget_destroy),
7374 GTK_OBJECT (pdata->window));
7375 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
7376 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (pdata->window)->action_area),
7377 button, TRUE, TRUE, 0);
7378 gtk_widget_grab_default (button);
7381 if (!GTK_WIDGET_VISIBLE (pdata->window))
7382 gtk_widget_show_all (pdata->window);
7384 gtk_widget_destroy (pdata->window);
7391 static int color_idle = 0;
7394 color_idle_func (GtkWidget *preview)
7396 static int count = 1;
7400 for (i = 0; i < 256; i++)
7402 for (j = 0, k = 0; j < 256; j++)
7404 buf[k+0] = i + count;
7406 buf[k+2] = j + count;
7410 gtk_preview_draw_row (GTK_PREVIEW (preview), buf, 0, i, 256);
7415 gtk_widget_draw (preview, NULL);
7421 color_preview_destroy (GtkWidget *widget,
7424 gtk_idle_remove (color_idle);
7431 create_color_preview (void)
7433 static GtkWidget *window = NULL;
7440 gtk_widget_push_visual (gdk_rgb_get_visual ());
7441 gtk_widget_push_colormap (gdk_rgb_get_cmap ());
7442 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
7443 gtk_widget_pop_colormap ();
7444 gtk_widget_pop_visual ();
7446 gtk_signal_connect (GTK_OBJECT (window), "destroy",
7447 GTK_SIGNAL_FUNC(color_preview_destroy),
7450 gtk_window_set_title (GTK_WINDOW (window), "test");
7451 gtk_container_set_border_width (GTK_CONTAINER (window), 10);
7453 preview = gtk_preview_new (GTK_PREVIEW_COLOR);
7454 gtk_preview_size (GTK_PREVIEW (preview), 256, 256);
7455 gtk_container_add (GTK_CONTAINER (window), preview);
7457 for (i = 0; i < 256; i++)
7459 for (j = 0, k = 0; j < 256; j++)
7467 gtk_preview_draw_row (GTK_PREVIEW (preview), buf, 0, i, 256);
7470 color_idle = gtk_idle_add ((GtkFunction) color_idle_func, preview);
7473 if (!GTK_WIDGET_VISIBLE (window))
7474 gtk_widget_show_all (window);
7476 gtk_widget_destroy (window);
7483 static int gray_idle = 0;
7486 gray_idle_func (GtkWidget *preview)
7488 static int count = 1;
7492 for (i = 0; i < 256; i++)
7494 for (j = 0; j < 256; j++)
7495 buf[j] = i + j + count;
7497 gtk_preview_draw_row (GTK_PREVIEW (preview), buf, 0, i, 256);
7502 gtk_widget_draw (preview, NULL);
7508 gray_preview_destroy (GtkWidget *widget,
7511 gtk_idle_remove (gray_idle);
7518 create_gray_preview (void)
7520 static GtkWidget *window = NULL;
7527 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
7529 gtk_signal_connect (GTK_OBJECT (window), "destroy",
7530 GTK_SIGNAL_FUNC(gray_preview_destroy),
7533 gtk_window_set_title (GTK_WINDOW (window), "test");
7534 gtk_container_set_border_width (GTK_CONTAINER (window), 10);
7536 preview = gtk_preview_new (GTK_PREVIEW_GRAYSCALE);
7537 gtk_preview_size (GTK_PREVIEW (preview), 256, 256);
7538 gtk_container_add (GTK_CONTAINER (window), preview);
7540 for (i = 0; i < 256; i++)
7542 for (j = 0; j < 256; j++)
7545 gtk_preview_draw_row (GTK_PREVIEW (preview), buf, 0, i, 256);
7548 gray_idle = gtk_idle_add ((GtkFunction) gray_idle_func, preview);
7551 if (!GTK_WIDGET_VISIBLE (window))
7552 gtk_widget_show_all (window);
7554 gtk_widget_destroy (window);
7563 selection_test_received (GtkWidget *list, GtkSelectionData *data)
7566 GtkWidget *list_item;
7570 if (data->length < 0)
7572 g_print ("Selection retrieval failed\n");
7575 if (data->type != GDK_SELECTION_TYPE_ATOM)
7577 g_print ("Selection \"TARGETS\" was not returned as atoms!\n");
7581 /* Clear out any current list items */
7583 gtk_list_clear_items (GTK_LIST(list), 0, -1);
7585 /* Add new items to list */
7587 atoms = (GdkAtom *)data->data;
7590 l = data->length / sizeof (GdkAtom);
7591 for (i = 0; i < l; i++)
7594 name = gdk_atom_name (atoms[i]);
7597 list_item = gtk_list_item_new_with_label (name);
7601 list_item = gtk_list_item_new_with_label ("(bad atom)");
7603 gtk_widget_show (list_item);
7604 item_list = g_list_append (item_list, list_item);
7607 gtk_list_append_items (GTK_LIST (list), item_list);
7613 selection_test_get_targets (GtkWidget *widget, GtkWidget *list)
7615 static GdkAtom targets_atom = GDK_NONE;
7617 if (targets_atom == GDK_NONE)
7618 targets_atom = gdk_atom_intern ("TARGETS", FALSE);
7620 gtk_selection_convert (list, GDK_SELECTION_PRIMARY, targets_atom,
7625 create_selection_test (void)
7627 static GtkWidget *window = NULL;
7630 GtkWidget *scrolled_win;
7636 window = gtk_dialog_new ();
7638 gtk_signal_connect (GTK_OBJECT (window), "destroy",
7639 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
7642 gtk_window_set_title (GTK_WINDOW (window), "Selection Test");
7643 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
7645 /* Create the list */
7647 vbox = gtk_vbox_new (FALSE, 5);
7648 gtk_container_set_border_width (GTK_CONTAINER (vbox), 10);
7649 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), vbox,
7652 label = gtk_label_new ("Gets available targets for current selection");
7653 gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
7655 scrolled_win = gtk_scrolled_window_new (NULL, NULL);
7656 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
7657 GTK_POLICY_AUTOMATIC,
7658 GTK_POLICY_AUTOMATIC);
7659 gtk_box_pack_start (GTK_BOX (vbox), scrolled_win, TRUE, TRUE, 0);
7660 gtk_widget_set_usize (scrolled_win, 100, 200);
7662 list = gtk_list_new ();
7663 gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (scrolled_win), list);
7665 gtk_signal_connect (GTK_OBJECT(list), "selection_received",
7666 GTK_SIGNAL_FUNC (selection_test_received), NULL);
7668 /* .. And create some buttons */
7669 button = gtk_button_new_with_label ("Get Targets");
7670 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
7671 button, TRUE, TRUE, 0);
7673 gtk_signal_connect (GTK_OBJECT (button), "clicked",
7674 GTK_SIGNAL_FUNC (selection_test_get_targets), list);
7676 button = gtk_button_new_with_label ("Quit");
7677 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
7678 button, TRUE, TRUE, 0);
7680 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
7681 GTK_SIGNAL_FUNC (gtk_widget_destroy),
7682 GTK_OBJECT (window));
7685 if (!GTK_WIDGET_VISIBLE (window))
7686 gtk_widget_show_all (window);
7688 gtk_widget_destroy (window);
7696 create_gamma_curve (void)
7698 static GtkWidget *window = NULL, *curve;
7699 static int count = 0;
7706 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
7707 gtk_window_set_title (GTK_WINDOW (window), "test");
7708 gtk_container_set_border_width (GTK_CONTAINER (window), 10);
7710 gtk_signal_connect (GTK_OBJECT (window), "destroy",
7711 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
7714 curve = gtk_gamma_curve_new ();
7715 gtk_container_add (GTK_CONTAINER (window), curve);
7716 gtk_widget_show (curve);
7719 max = 127 + (count % 2)*128;
7720 gtk_curve_set_range (GTK_CURVE (GTK_GAMMA_CURVE (curve)->curve),
7722 for (i = 0; i < max; ++i)
7723 vec[i] = (127 / sqrt (max)) * sqrt (i);
7724 gtk_curve_set_vector (GTK_CURVE (GTK_GAMMA_CURVE (curve)->curve),
7727 if (!GTK_WIDGET_VISIBLE (window))
7728 gtk_widget_show (window);
7729 else if (count % 4 == 3)
7731 gtk_widget_destroy (window);
7742 static int scroll_test_pos = 0.0;
7743 static GdkGC *scroll_test_gc = NULL;
7746 scroll_test_expose (GtkWidget *widget, GdkEventExpose *event,
7750 gint imin, imax, jmin, jmax;
7752 imin = (event->area.x) / 10;
7753 imax = (event->area.x + event->area.width + 9) / 10;
7755 jmin = ((int)adj->value + event->area.y) / 10;
7756 jmax = ((int)adj->value + event->area.y + event->area.height + 9) / 10;
7758 gdk_window_clear_area (widget->window,
7759 event->area.x, event->area.y,
7760 event->area.width, event->area.height);
7762 for (i=imin; i<imax; i++)
7763 for (j=jmin; j<jmax; j++)
7765 gdk_draw_rectangle (widget->window,
7766 widget->style->black_gc,
7768 10*i, 10*j - (int)adj->value, 1+i%10, 1+j%10);
7774 scroll_test_scroll (GtkWidget *widget, GdkEventScroll *event,
7777 gfloat new_value = adj->value + ((event->direction == GDK_SCROLL_UP) ?
7778 -adj->page_increment / 2:
7779 adj->page_increment / 2);
7780 new_value = CLAMP (new_value, adj->lower, adj->upper - adj->page_size);
7781 gtk_adjustment_set_value (adj, new_value);
7787 scroll_test_configure (GtkWidget *widget, GdkEventConfigure *event,
7790 adj->page_increment = 0.9 * widget->allocation.height;
7791 adj->page_size = widget->allocation.height;
7793 gtk_signal_emit_by_name (GTK_OBJECT (adj), "changed");
7797 scroll_test_adjustment_changed (GtkAdjustment *adj, GtkWidget *widget)
7799 gint source_min = (int)adj->value - scroll_test_pos;
7800 gint source_max = source_min + widget->allocation.height;
7802 gint dest_max = widget->allocation.height;
7806 scroll_test_pos = adj->value;
7808 if (!GTK_WIDGET_DRAWABLE (widget))
7815 rect.width = widget->allocation.width;
7816 rect.height = -source_min;
7817 if (rect.height > widget->allocation.height)
7818 rect.height = widget->allocation.height;
7821 dest_min = rect.height;
7826 rect.y = 2*widget->allocation.height - source_max;
7829 rect.width = widget->allocation.width;
7830 rect.height = widget->allocation.height - rect.y;
7832 source_max = widget->allocation.height;
7836 if (source_min != source_max)
7838 if (scroll_test_gc == NULL)
7840 scroll_test_gc = gdk_gc_new (widget->window);
7841 gdk_gc_set_exposures (scroll_test_gc, TRUE);
7844 gdk_draw_pixmap (widget->window,
7849 widget->allocation.width,
7850 source_max - source_min);
7852 /* Make sure graphics expose events are processed before scrolling
7855 while ((event = gdk_event_get_graphics_expose (widget->window)) != NULL)
7857 gtk_widget_event (widget, event);
7858 if (event->expose.count == 0)
7860 gdk_event_free (event);
7863 gdk_event_free (event);
7867 if (rect.height != 0)
7868 gtk_widget_draw (widget, &rect);
7873 create_scroll_test (void)
7875 static GtkWidget *window = NULL;
7877 GtkWidget *drawing_area;
7878 GtkWidget *scrollbar;
7881 GdkGeometry geometry;
7882 GdkWindowHints geometry_mask;
7886 window = gtk_dialog_new ();
7888 gtk_signal_connect (GTK_OBJECT (window), "destroy",
7889 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
7892 gtk_window_set_title (GTK_WINDOW (window), "Scroll Test");
7893 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
7895 hbox = gtk_hbox_new (FALSE, 0);
7896 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), hbox,
7898 gtk_widget_show (hbox);
7900 drawing_area = gtk_drawing_area_new ();
7901 gtk_drawing_area_size (GTK_DRAWING_AREA (drawing_area), 200, 200);
7902 gtk_box_pack_start (GTK_BOX (hbox), drawing_area, TRUE, TRUE, 0);
7903 gtk_widget_show (drawing_area);
7905 gtk_widget_set_events (drawing_area, GDK_EXPOSURE_MASK | GDK_SCROLL_MASK);
7907 adj = GTK_ADJUSTMENT (gtk_adjustment_new (0.0, 0.0, 1000.0, 1.0, 180.0, 200.0));
7908 scroll_test_pos = 0.0;
7910 scrollbar = gtk_vscrollbar_new (adj);
7911 gtk_box_pack_start (GTK_BOX (hbox), scrollbar, FALSE, FALSE, 0);
7912 gtk_widget_show (scrollbar);
7914 gtk_signal_connect (GTK_OBJECT (drawing_area), "expose_event",
7915 GTK_SIGNAL_FUNC (scroll_test_expose), adj);
7916 gtk_signal_connect (GTK_OBJECT (drawing_area), "configure_event",
7917 GTK_SIGNAL_FUNC (scroll_test_configure), adj);
7918 gtk_signal_connect (GTK_OBJECT (drawing_area), "scroll_event",
7919 GTK_SIGNAL_FUNC (scroll_test_scroll), adj);
7921 gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
7922 GTK_SIGNAL_FUNC (scroll_test_adjustment_changed),
7925 /* .. And create some buttons */
7927 button = gtk_button_new_with_label ("Quit");
7928 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
7929 button, TRUE, TRUE, 0);
7931 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
7932 GTK_SIGNAL_FUNC (gtk_widget_destroy),
7933 GTK_OBJECT (window));
7934 gtk_widget_show (button);
7936 /* Set up gridded geometry */
7938 geometry_mask = GDK_HINT_MIN_SIZE |
7939 GDK_HINT_BASE_SIZE |
7940 GDK_HINT_RESIZE_INC;
7942 geometry.min_width = 20;
7943 geometry.min_height = 20;
7944 geometry.base_width = 0;
7945 geometry.base_height = 0;
7946 geometry.width_inc = 10;
7947 geometry.height_inc = 10;
7949 gtk_window_set_geometry_hints (GTK_WINDOW (window),
7950 drawing_area, &geometry, geometry_mask);
7953 if (!GTK_WIDGET_VISIBLE (window))
7954 gtk_widget_show (window);
7956 gtk_widget_destroy (window);
7963 static int timer = 0;
7966 timeout_test (GtkWidget *label)
7968 static int count = 0;
7969 static char buffer[32];
7971 sprintf (buffer, "count: %d", ++count);
7972 gtk_label_set_text (GTK_LABEL (label), buffer);
7978 start_timeout_test (GtkWidget *widget,
7983 timer = gtk_timeout_add (100, (GtkFunction) timeout_test, label);
7988 stop_timeout_test (GtkWidget *widget,
7993 gtk_timeout_remove (timer);
7999 destroy_timeout_test (GtkWidget *widget,
8002 stop_timeout_test (NULL, NULL);
8008 create_timeout_test (void)
8010 static GtkWidget *window = NULL;
8016 window = gtk_dialog_new ();
8018 gtk_signal_connect (GTK_OBJECT (window), "destroy",
8019 GTK_SIGNAL_FUNC(destroy_timeout_test),
8022 gtk_window_set_title (GTK_WINDOW (window), "Timeout Test");
8023 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
8025 label = gtk_label_new ("count: 0");
8026 gtk_misc_set_padding (GTK_MISC (label), 10, 10);
8027 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox),
8028 label, TRUE, TRUE, 0);
8029 gtk_widget_show (label);
8031 button = gtk_button_new_with_label ("close");
8032 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
8033 GTK_SIGNAL_FUNC(gtk_widget_destroy),
8034 GTK_OBJECT (window));
8035 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
8036 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
8037 button, TRUE, TRUE, 0);
8038 gtk_widget_grab_default (button);
8039 gtk_widget_show (button);
8041 button = gtk_button_new_with_label ("start");
8042 gtk_signal_connect (GTK_OBJECT (button), "clicked",
8043 GTK_SIGNAL_FUNC(start_timeout_test),
8045 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
8046 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
8047 button, TRUE, TRUE, 0);
8048 gtk_widget_show (button);
8050 button = gtk_button_new_with_label ("stop");
8051 gtk_signal_connect (GTK_OBJECT (button), "clicked",
8052 GTK_SIGNAL_FUNC(stop_timeout_test),
8054 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
8055 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
8056 button, TRUE, TRUE, 0);
8057 gtk_widget_show (button);
8060 if (!GTK_WIDGET_VISIBLE (window))
8061 gtk_widget_show (window);
8063 gtk_widget_destroy (window);
8070 static int idle_id = 0;
8073 idle_test (GtkWidget *label)
8075 static int count = 0;
8076 static char buffer[32];
8078 sprintf (buffer, "count: %d", ++count);
8079 gtk_label_set_text (GTK_LABEL (label), buffer);
8085 start_idle_test (GtkWidget *widget,
8090 idle_id = gtk_idle_add ((GtkFunction) idle_test, label);
8095 stop_idle_test (GtkWidget *widget,
8100 gtk_idle_remove (idle_id);
8106 destroy_idle_test (GtkWidget *widget,
8109 stop_idle_test (NULL, NULL);
8115 toggle_idle_container (GtkObject *button,
8116 GtkContainer *container)
8118 gtk_container_set_resize_mode (container, GPOINTER_TO_INT (gtk_object_get_user_data (button)));
8122 create_idle_test (void)
8124 static GtkWidget *window = NULL;
8127 GtkWidget *container;
8134 window = gtk_dialog_new ();
8136 gtk_signal_connect (GTK_OBJECT (window), "destroy",
8137 GTK_SIGNAL_FUNC(destroy_idle_test),
8140 gtk_window_set_title (GTK_WINDOW (window), "Idle Test");
8141 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
8143 label = gtk_label_new ("count: 0");
8144 gtk_misc_set_padding (GTK_MISC (label), 10, 10);
8145 gtk_widget_show (label);
8148 gtk_widget_new (GTK_TYPE_HBOX,
8149 "GtkWidget::visible", TRUE,
8150 /* "GtkContainer::child", gtk_widget_new (GTK_TYPE_HBOX,
8151 * "GtkWidget::visible", TRUE,
8153 "GtkContainer::child", label,
8156 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox),
8157 container, TRUE, TRUE, 0);
8160 gtk_widget_new (GTK_TYPE_FRAME,
8161 "GtkContainer::border_width", 5,
8162 "GtkFrame::label", "Label Container",
8163 "GtkWidget::visible", TRUE,
8164 "GtkWidget::parent", GTK_DIALOG (window)->vbox,
8167 gtk_widget_new (GTK_TYPE_VBOX,
8168 "GtkWidget::visible", TRUE,
8169 "GtkWidget::parent", frame,
8172 gtk_widget_new (GTK_TYPE_RADIO_BUTTON,
8173 "GtkButton::label", "Resize-Parent",
8174 "GtkObject::user_data", (void*)GTK_RESIZE_PARENT,
8175 "GtkObject::signal::clicked", toggle_idle_container, container,
8176 "GtkWidget::visible", TRUE,
8177 "GtkWidget::parent", box,
8180 gtk_widget_new (GTK_TYPE_RADIO_BUTTON,
8181 "GtkButton::label", "Resize-Queue",
8182 "GtkObject::user_data", (void*)GTK_RESIZE_QUEUE,
8183 "GtkObject::signal::clicked", toggle_idle_container, container,
8184 "GtkRadioButton::group", button,
8185 "GtkWidget::visible", TRUE,
8186 "GtkWidget::parent", box,
8189 gtk_widget_new (GTK_TYPE_RADIO_BUTTON,
8190 "GtkButton::label", "Resize-Immediate",
8191 "GtkObject::user_data", (void*)GTK_RESIZE_IMMEDIATE,
8192 "GtkObject::signal::clicked", toggle_idle_container, container,
8193 "GtkRadioButton::group", button,
8194 "GtkWidget::visible", TRUE,
8195 "GtkWidget::parent", box,
8199 button = gtk_button_new_with_label ("close");
8200 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
8201 GTK_SIGNAL_FUNC(gtk_widget_destroy),
8202 GTK_OBJECT (window));
8203 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
8204 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
8205 button, TRUE, TRUE, 0);
8206 gtk_widget_grab_default (button);
8207 gtk_widget_show (button);
8209 button = gtk_button_new_with_label ("start");
8210 gtk_signal_connect (GTK_OBJECT (button), "clicked",
8211 GTK_SIGNAL_FUNC(start_idle_test),
8213 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
8214 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
8215 button, TRUE, TRUE, 0);
8216 gtk_widget_show (button);
8218 button = gtk_button_new_with_label ("stop");
8219 gtk_signal_connect (GTK_OBJECT (button), "clicked",
8220 GTK_SIGNAL_FUNC(stop_idle_test),
8222 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
8223 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
8224 button, TRUE, TRUE, 0);
8225 gtk_widget_show (button);
8228 if (!GTK_WIDGET_VISIBLE (window))
8229 gtk_widget_show (window);
8231 gtk_widget_destroy (window);
8239 reload_rc_file (void)
8243 if (gtk_rc_reparse_all ())
8245 toplevels = gdk_window_get_toplevels();
8249 gdk_window_get_user_data (toplevels->data, (gpointer *)&widget);
8252 gtk_widget_reset_rc_styles (widget);
8254 toplevels = toplevels->next;
8256 g_list_free (toplevels);
8261 reload_all_rc_files (void)
8263 static GdkAtom atom_rcfiles = GDK_NONE;
8269 atom_rcfiles = gdk_atom_intern("_GTK_READ_RCFILES", FALSE);
8271 for(i = 0; i < 5; i++)
8273 sev.data_format = 32;
8274 sev.message_type = atom_rcfiles;
8275 gdk_event_send_clientmessage_toall ((GdkEvent *) &sev);
8279 create_rc_file (void)
8281 static GtkWidget *window = NULL;
8286 window = gtk_dialog_new ();
8288 gtk_signal_connect (GTK_OBJECT (window), "destroy",
8289 GTK_SIGNAL_FUNC(destroy_idle_test),
8292 gtk_window_set_title (GTK_WINDOW (window), "Reload Rc file");
8293 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
8295 button = gtk_button_new_with_label ("Reload");
8296 gtk_signal_connect (GTK_OBJECT (button), "clicked",
8297 GTK_SIGNAL_FUNC(reload_rc_file), NULL);
8298 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
8299 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
8300 button, TRUE, TRUE, 0);
8301 gtk_widget_grab_default (button);
8302 gtk_widget_show (button);
8304 button = gtk_button_new_with_label ("Reload All");
8305 gtk_signal_connect (GTK_OBJECT (button), "clicked",
8306 GTK_SIGNAL_FUNC(reload_all_rc_files), NULL);
8307 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
8308 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
8309 button, TRUE, TRUE, 0);
8310 gtk_widget_show (button);
8312 button = gtk_button_new_with_label ("Close");
8313 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
8314 GTK_SIGNAL_FUNC(gtk_widget_destroy),
8315 GTK_OBJECT (window));
8316 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
8317 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
8318 button, TRUE, TRUE, 0);
8319 gtk_widget_show (button);
8323 if (!GTK_WIDGET_VISIBLE (window))
8324 gtk_widget_show (window);
8326 gtk_widget_destroy (window);
8330 * Test of recursive mainloop
8334 mainloop_destroyed (GtkWidget *w, GtkWidget **window)
8341 create_mainloop (void)
8343 static GtkWidget *window = NULL;
8349 window = gtk_dialog_new ();
8351 gtk_window_set_title (GTK_WINDOW (window), "Test Main Loop");
8353 gtk_signal_connect (GTK_OBJECT (window), "destroy",
8354 GTK_SIGNAL_FUNC(mainloop_destroyed),
8357 label = gtk_label_new ("In recursive main loop...");
8358 gtk_misc_set_padding (GTK_MISC(label), 20, 20);
8360 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), label,
8362 gtk_widget_show (label);
8364 button = gtk_button_new_with_label ("Leave");
8365 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area), button,
8368 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
8369 GTK_SIGNAL_FUNC (gtk_widget_destroy),
8370 GTK_OBJECT (window));
8372 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
8373 gtk_widget_grab_default (button);
8375 gtk_widget_show (button);
8378 if (!GTK_WIDGET_VISIBLE (window))
8380 gtk_widget_show (window);
8382 g_print ("create_mainloop: start\n");
8384 g_print ("create_mainloop: done\n");
8387 gtk_widget_destroy (window);
8391 layout_expose_handler (GtkWidget *widget, GdkEventExpose *event)
8396 gint imin, imax, jmin, jmax;
8398 layout = GTK_LAYOUT (widget);
8400 imin = (layout->xoffset + event->area.x) / 10;
8401 imax = (layout->xoffset + event->area.x + event->area.width + 9) / 10;
8403 jmin = (layout->yoffset + event->area.y) / 10;
8404 jmax = (layout->yoffset + event->area.y + event->area.height + 9) / 10;
8406 gdk_window_clear_area (widget->window,
8407 event->area.x, event->area.y,
8408 event->area.width, event->area.height);
8410 for (i=imin; i<imax; i++)
8411 for (j=jmin; j<jmax; j++)
8413 gdk_draw_rectangle (layout->bin_window,
8414 widget->style->black_gc,
8416 10*i - layout->xoffset, 10*j - layout->yoffset,
8422 void create_layout (void)
8424 static GtkWidget *window = NULL;
8426 GtkWidget *scrolledwindow;
8435 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
8436 gtk_signal_connect (GTK_OBJECT (window), "destroy",
8437 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
8440 gtk_window_set_title (GTK_WINDOW (window), "Layout");
8441 gtk_widget_set_usize (window, 200, 200);
8443 scrolledwindow = gtk_scrolled_window_new (NULL, NULL);
8445 gtk_container_add (GTK_CONTAINER (window), scrolledwindow);
8447 layout = gtk_layout_new (NULL, NULL);
8448 gtk_container_add (GTK_CONTAINER (scrolledwindow), layout);
8450 /* We set step sizes here since GtkLayout does not set
8453 GTK_LAYOUT (layout)->hadjustment->step_increment = 10.0;
8454 GTK_LAYOUT (layout)->vadjustment->step_increment = 10.0;
8456 gtk_widget_set_events (layout, GDK_EXPOSURE_MASK);
8457 gtk_signal_connect (GTK_OBJECT (layout), "expose_event",
8458 GTK_SIGNAL_FUNC (layout_expose_handler), NULL);
8460 gtk_layout_set_size (GTK_LAYOUT (layout), 1600, 128000);
8462 for (i=0 ; i < 16 ; i++)
8463 for (j=0 ; j < 16 ; j++)
8465 sprintf(buf, "Button %d, %d", i, j);
8467 button = gtk_button_new_with_label (buf);
8469 button = gtk_label_new (buf);
8471 gtk_layout_put (GTK_LAYOUT (layout), button,
8475 for (i=16; i < 1280; i++)
8477 sprintf(buf, "Button %d, %d", i, 0);
8479 button = gtk_button_new_with_label (buf);
8481 button = gtk_label_new (buf);
8483 gtk_layout_put (GTK_LAYOUT (layout), button,
8488 if (!GTK_WIDGET_VISIBLE (window))
8489 gtk_widget_show_all (window);
8491 gtk_widget_destroy (window);
8495 * Main Window and Exit
8499 do_exit (GtkWidget *widget, GtkWidget *window)
8501 gtk_widget_destroy (window);
8506 create_main_window (void)
8513 { "button box", create_button_box },
8514 { "buttons", create_buttons },
8515 { "check buttons", create_check_buttons },
8516 { "clist", create_clist},
8517 { "color selection", create_color_selection },
8518 { "ctree", create_ctree },
8519 { "cursors", create_cursors },
8520 { "dialog", create_dialog },
8521 /* { "dnd", create_dnd }, */
8522 { "entry", create_entry },
8523 { "event watcher", create_event_watcher },
8524 { "file selection", create_file_selection },
8525 { "flipping", create_flipping },
8526 { "font selection", create_font_selection },
8527 { "gamma curve", create_gamma_curve },
8528 { "handle box", create_handle_box },
8529 { "item factory", create_item_factory },
8530 { "labels", create_labels },
8531 { "layout", create_layout },
8532 { "list", create_list },
8533 { "menus", create_menus },
8534 { "modal window", create_modal_window },
8535 { "notebook", create_notebook },
8536 { "panes", create_panes },
8537 { "pixmap", create_pixmap },
8538 { "preview color", create_color_preview },
8539 { "preview gray", create_gray_preview },
8540 { "progress bar", create_progress_bar },
8541 { "radio buttons", create_radio_buttons },
8542 { "range controls", create_range_controls },
8543 { "rc file", create_rc_file },
8544 { "reparent", create_reparent },
8545 { "rulers", create_rulers },
8546 { "saved position", create_saved_position },
8547 { "scrolled windows", create_scrolled_windows },
8548 { "shapes", create_shapes },
8549 { "spinbutton", create_spins },
8550 { "statusbar", create_statusbar },
8551 { "test idle", create_idle_test },
8552 { "test mainloop", create_mainloop },
8553 { "test scrolling", create_scroll_test },
8554 { "test selection", create_selection_test },
8555 { "test timeout", create_timeout_test },
8556 { "text", create_text },
8557 { "toggle buttons", create_toggle_buttons },
8558 { "toolbar", create_toolbar },
8559 { "tooltips", create_tooltips },
8560 { "tree", create_tree_mode_window},
8561 { "WM hints", create_wmhints },
8563 int nbuttons = sizeof (buttons) / sizeof (buttons[0]);
8567 GtkWidget *scrolled_window;
8571 GtkWidget *separator;
8574 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
8575 gtk_window_set_policy (GTK_WINDOW (window), FALSE, FALSE, FALSE);
8576 gtk_widget_set_name (window, "main window");
8577 gtk_widget_set_usize (window, 200, 400);
8578 gtk_widget_set_uposition (window, 20, 20);
8580 gtk_signal_connect (GTK_OBJECT (window), "destroy",
8581 GTK_SIGNAL_FUNC(gtk_main_quit),
8583 gtk_signal_connect (GTK_OBJECT (window), "delete-event",
8584 GTK_SIGNAL_FUNC (gtk_false),
8587 box1 = gtk_vbox_new (FALSE, 0);
8588 gtk_container_add (GTK_CONTAINER (window), box1);
8590 if (gtk_micro_version > 0)
8602 label = gtk_label_new (buffer);
8603 gtk_box_pack_start (GTK_BOX (box1), label, FALSE, FALSE, 0);
8605 scrolled_window = gtk_scrolled_window_new (NULL, NULL);
8606 gtk_container_set_border_width (GTK_CONTAINER (scrolled_window), 10);
8607 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
8608 GTK_POLICY_AUTOMATIC,
8609 GTK_POLICY_AUTOMATIC);
8610 gtk_box_pack_start (GTK_BOX (box1), scrolled_window, TRUE, TRUE, 0);
8612 box2 = gtk_vbox_new (FALSE, 0);
8613 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
8614 gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (scrolled_window), box2);
8615 gtk_container_set_focus_vadjustment (GTK_CONTAINER (box2),
8616 gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (scrolled_window)));
8617 gtk_widget_show (box2);
8619 for (i = 0; i < nbuttons; i++)
8621 button = gtk_button_new_with_label (buttons[i].label);
8622 if (buttons[i].func)
8623 gtk_signal_connect (GTK_OBJECT (button),
8625 GTK_SIGNAL_FUNC(buttons[i].func),
8628 gtk_widget_set_sensitive (button, FALSE);
8629 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
8632 separator = gtk_hseparator_new ();
8633 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
8635 box2 = gtk_vbox_new (FALSE, 10);
8636 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
8637 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
8639 button = gtk_button_new_with_label ("close");
8640 gtk_signal_connect (GTK_OBJECT (button), "clicked",
8641 GTK_SIGNAL_FUNC (do_exit),
8643 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
8644 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
8645 gtk_widget_grab_default (button);
8647 gtk_widget_show_all (window);
8651 main (int argc, char *argv[])
8653 GtkBindingSet *binding_set;
8655 srand (time (NULL));
8659 /* Check to see if we are being run from the correct
8662 if (file_exists ("testgtkrc"))
8663 gtk_rc_add_default_file ("testgtkrc");
8665 gtk_init (&argc, &argv);
8671 binding_set = gtk_binding_set_by_class (gtk_type_class (GTK_TYPE_WIDGET));
8672 gtk_binding_entry_add_signal (binding_set,
8673 '9', GDK_CONTROL_MASK | GDK_RELEASE_MASK,
8676 GTK_TYPE_STRING, "GtkWidgetClass <ctrl><release>9 test");
8678 create_main_window ();