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.
25 #include "../gdk/gdk.h"
26 #include "../gdk/gdkx.h"
27 #include "../gdk/gdkkeysyms.h"
29 #include "circles.xbm"
31 GtkWidget *shape_create_icon (char *xpm_file,
38 /* macro, structure and variables used by tree window demos */
39 #define DEFAULT_NUMBER_OF_ITEM 3
40 #define DEFAULT_RECURSION_LEVEL 3
43 GSList* selection_mode_group;
44 GtkWidget* single_button;
45 GtkWidget* browse_button;
46 GtkWidget* multiple_button;
47 GtkWidget* draw_line_button;
48 GtkWidget* view_line_button;
49 GtkWidget* no_root_item_button;
50 GtkWidget* nb_item_spinner;
51 GtkWidget* recursion_spinner;
52 } sTreeSampleSelection;
54 typedef struct sTreeButtons {
56 GtkWidget* add_button;
57 GtkWidget* remove_button;
58 GtkWidget* subtree_button;
60 /* end of tree section */
63 destroy_tooltips (GtkWidget *widget, GtkWindow **window)
65 GtkTooltips *tt = gtk_object_get_data (GTK_OBJECT (*window), "tooltips");
66 gtk_object_unref (GTK_OBJECT (tt));
72 button_window (GtkWidget *widget,
75 if (!GTK_WIDGET_VISIBLE (button))
76 gtk_widget_show (button);
78 gtk_widget_hide (button);
84 static GtkWidget *window = NULL;
88 GtkWidget *button[10];
93 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
95 gtk_signal_connect (GTK_OBJECT (window), "destroy",
96 GTK_SIGNAL_FUNC (gtk_widget_destroyed),
99 gtk_window_set_title (GTK_WINDOW (window), "buttons");
100 gtk_container_border_width (GTK_CONTAINER (window), 0);
102 box1 = gtk_vbox_new (FALSE, 0);
103 gtk_container_add (GTK_CONTAINER (window), box1);
104 gtk_widget_show (box1);
107 table = gtk_table_new (3, 3, FALSE);
108 gtk_table_set_row_spacings (GTK_TABLE (table), 5);
109 gtk_table_set_col_spacings (GTK_TABLE (table), 5);
110 gtk_container_border_width (GTK_CONTAINER (table), 10);
111 gtk_box_pack_start (GTK_BOX (box1), table, TRUE, TRUE, 0);
112 gtk_widget_show (table);
115 button[0] = gtk_button_new_with_label ("button1");
116 button[1] = gtk_button_new_with_label ("button2");
117 button[2] = gtk_button_new_with_label ("button3");
118 button[3] = gtk_button_new_with_label ("button4");
119 button[4] = gtk_button_new_with_label ("button5");
120 button[5] = gtk_button_new_with_label ("button6");
121 button[6] = gtk_button_new_with_label ("button7");
122 button[7] = gtk_button_new_with_label ("button8");
123 button[8] = gtk_button_new_with_label ("button9");
125 gtk_signal_connect (GTK_OBJECT (button[0]), "clicked",
126 GTK_SIGNAL_FUNC(button_window),
129 gtk_table_attach (GTK_TABLE (table), button[0], 0, 1, 0, 1,
130 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
131 gtk_widget_show (button[0]);
133 gtk_signal_connect (GTK_OBJECT (button[1]), "clicked",
134 GTK_SIGNAL_FUNC(button_window),
137 gtk_table_attach (GTK_TABLE (table), button[1], 1, 2, 1, 2,
138 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
139 gtk_widget_show (button[1]);
141 gtk_signal_connect (GTK_OBJECT (button[2]), "clicked",
142 GTK_SIGNAL_FUNC(button_window),
144 gtk_table_attach (GTK_TABLE (table), button[2], 2, 3, 2, 3,
145 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
146 gtk_widget_show (button[2]);
148 gtk_signal_connect (GTK_OBJECT (button[3]), "clicked",
149 GTK_SIGNAL_FUNC(button_window),
151 gtk_table_attach (GTK_TABLE (table), button[3], 0, 1, 2, 3,
152 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
153 gtk_widget_show (button[3]);
155 gtk_signal_connect (GTK_OBJECT (button[4]), "clicked",
156 GTK_SIGNAL_FUNC(button_window),
158 gtk_table_attach (GTK_TABLE (table), button[4], 2, 3, 0, 1,
159 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
160 gtk_widget_show (button[4]);
162 gtk_signal_connect (GTK_OBJECT (button[5]), "clicked",
163 GTK_SIGNAL_FUNC(button_window),
165 gtk_table_attach (GTK_TABLE (table), button[5], 1, 2, 2, 3,
166 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
167 gtk_widget_show (button[5]);
169 gtk_signal_connect (GTK_OBJECT (button[6]), "clicked",
170 GTK_SIGNAL_FUNC(button_window),
172 gtk_table_attach (GTK_TABLE (table), button[6], 1, 2, 0, 1,
173 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
174 gtk_widget_show (button[6]);
176 gtk_signal_connect (GTK_OBJECT (button[7]), "clicked",
177 GTK_SIGNAL_FUNC(button_window),
179 gtk_table_attach (GTK_TABLE (table), button[7], 2, 3, 1, 2,
180 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
181 gtk_widget_show (button[7]);
183 gtk_signal_connect (GTK_OBJECT (button[8]), "clicked",
184 GTK_SIGNAL_FUNC(button_window),
186 gtk_table_attach (GTK_TABLE (table), button[8], 0, 1, 1, 2,
187 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
188 gtk_widget_show (button[8]);
191 separator = gtk_hseparator_new ();
192 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
193 gtk_widget_show (separator);
196 box2 = gtk_vbox_new (FALSE, 10);
197 gtk_container_border_width (GTK_CONTAINER (box2), 10);
198 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
199 gtk_widget_show (box2);
202 button[9] = gtk_button_new_with_label ("close");
203 gtk_signal_connect_object (GTK_OBJECT (button[9]), "clicked",
204 GTK_SIGNAL_FUNC(gtk_widget_destroy),
205 GTK_OBJECT (window));
206 gtk_box_pack_start (GTK_BOX (box2), button[9], TRUE, TRUE, 0);
207 GTK_WIDGET_SET_FLAGS (button[9], GTK_CAN_DEFAULT);
208 gtk_widget_grab_default (button[9]);
209 gtk_widget_show (button[9]);
212 if (!GTK_WIDGET_VISIBLE (window))
213 gtk_widget_show (window);
215 gtk_widget_destroy (window);
219 create_toggle_buttons (void)
221 static GtkWidget *window = NULL;
225 GtkWidget *separator;
229 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
231 gtk_signal_connect (GTK_OBJECT (window), "destroy",
232 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
235 gtk_window_set_title (GTK_WINDOW (window), "toggle buttons");
236 gtk_container_border_width (GTK_CONTAINER (window), 0);
239 box1 = gtk_vbox_new (FALSE, 0);
240 gtk_container_add (GTK_CONTAINER (window), box1);
241 gtk_widget_show (box1);
244 box2 = gtk_vbox_new (FALSE, 10);
245 gtk_container_border_width (GTK_CONTAINER (box2), 10);
246 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
247 gtk_widget_show (box2);
250 button = gtk_toggle_button_new_with_label ("button1");
251 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
252 gtk_widget_show (button);
254 button = gtk_toggle_button_new_with_label ("button2");
255 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
256 gtk_widget_show (button);
258 button = gtk_toggle_button_new_with_label ("button3");
259 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
260 gtk_widget_show (button);
263 separator = gtk_hseparator_new ();
264 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
265 gtk_widget_show (separator);
268 box2 = gtk_vbox_new (FALSE, 10);
269 gtk_container_border_width (GTK_CONTAINER (box2), 10);
270 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
271 gtk_widget_show (box2);
274 button = gtk_button_new_with_label ("close");
275 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
276 GTK_SIGNAL_FUNC(gtk_widget_destroy),
277 GTK_OBJECT (window));
278 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
279 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
280 gtk_widget_grab_default (button);
281 gtk_widget_show (button);
284 if (!GTK_WIDGET_VISIBLE (window))
285 gtk_widget_show (window);
287 gtk_widget_destroy (window);
291 create_check_buttons (void)
293 static GtkWidget *window = NULL;
297 GtkWidget *separator;
301 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
303 gtk_signal_connect (GTK_OBJECT (window), "destroy",
304 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
307 gtk_window_set_title (GTK_WINDOW (window), "check buttons");
308 gtk_container_border_width (GTK_CONTAINER (window), 0);
311 box1 = gtk_vbox_new (FALSE, 0);
312 gtk_container_add (GTK_CONTAINER (window), box1);
313 gtk_widget_show (box1);
316 box2 = gtk_vbox_new (FALSE, 10);
317 gtk_container_border_width (GTK_CONTAINER (box2), 10);
318 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
319 gtk_widget_show (box2);
322 button = gtk_check_button_new_with_label ("button1");
323 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
324 gtk_widget_show (button);
326 button = gtk_check_button_new_with_label ("button2");
327 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
328 gtk_widget_show (button);
330 button = gtk_check_button_new_with_label ("button3");
331 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
332 gtk_widget_show (button);
335 separator = gtk_hseparator_new ();
336 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
337 gtk_widget_show (separator);
340 box2 = gtk_vbox_new (FALSE, 10);
341 gtk_container_border_width (GTK_CONTAINER (box2), 10);
342 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
343 gtk_widget_show (box2);
346 button = gtk_button_new_with_label ("close");
347 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
348 GTK_SIGNAL_FUNC(gtk_widget_destroy),
349 GTK_OBJECT (window));
350 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
351 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
352 gtk_widget_grab_default (button);
353 gtk_widget_show (button);
356 if (!GTK_WIDGET_VISIBLE (window))
357 gtk_widget_show (window);
359 gtk_widget_destroy (window);
363 create_radio_buttons (void)
365 static GtkWidget *window = NULL;
369 GtkWidget *separator;
373 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
375 gtk_signal_connect (GTK_OBJECT (window), "destroy",
376 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
379 gtk_window_set_title (GTK_WINDOW (window), "radio buttons");
380 gtk_container_border_width (GTK_CONTAINER (window), 0);
383 box1 = gtk_vbox_new (FALSE, 0);
384 gtk_container_add (GTK_CONTAINER (window), box1);
385 gtk_widget_show (box1);
388 box2 = gtk_vbox_new (FALSE, 10);
389 gtk_container_border_width (GTK_CONTAINER (box2), 10);
390 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
391 gtk_widget_show (box2);
394 button = gtk_radio_button_new_with_label (NULL, "button1");
395 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
396 gtk_widget_show (button);
398 button = gtk_radio_button_new_with_label (
399 gtk_radio_button_group (GTK_RADIO_BUTTON (button)),
401 gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON (button), TRUE);
402 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
403 gtk_widget_show (button);
405 button = gtk_radio_button_new_with_label (
406 gtk_radio_button_group (GTK_RADIO_BUTTON (button)),
408 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
409 gtk_widget_show (button);
412 separator = gtk_hseparator_new ();
413 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
414 gtk_widget_show (separator);
417 box2 = gtk_vbox_new (FALSE, 10);
418 gtk_container_border_width (GTK_CONTAINER (box2), 10);
419 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
420 gtk_widget_show (box2);
423 button = gtk_button_new_with_label ("close");
424 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
425 GTK_SIGNAL_FUNC(gtk_widget_destroy),
426 GTK_OBJECT (window));
427 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
428 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
429 gtk_widget_grab_default (button);
430 gtk_widget_show (button);
433 if (!GTK_WIDGET_VISIBLE (window))
434 gtk_widget_show (window);
436 gtk_widget_destroy (window);
440 bbox_widget_destroy (GtkWidget* widget, GtkWidget* todestroy)
445 create_bbox_window (gint horizontal,
458 /* create a new window */
459 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
460 gtk_window_set_title (GTK_WINDOW (window), title);
462 gtk_signal_connect (GTK_OBJECT (window), "destroy",
463 GTK_SIGNAL_FUNC(bbox_widget_destroy), window);
467 gtk_widget_set_usize (window, 550, 60);
468 gtk_widget_set_uposition (window, 150, pos);
469 box1 = gtk_vbox_new (FALSE, 0);
473 gtk_widget_set_usize (window, 150, 400);
474 gtk_widget_set_uposition (window, pos, 200);
475 box1 = gtk_vbox_new (FALSE, 0);
478 gtk_container_add (GTK_CONTAINER (window), box1);
479 gtk_widget_show (box1);
482 bbox = gtk_hbutton_box_new();
484 bbox = gtk_vbutton_box_new();
485 gtk_button_box_set_layout (GTK_BUTTON_BOX (bbox), layout);
486 gtk_button_box_set_spacing (GTK_BUTTON_BOX (bbox), spacing);
487 gtk_button_box_set_child_size (GTK_BUTTON_BOX (bbox), child_w, child_h);
488 gtk_widget_show (bbox);
490 gtk_container_border_width (GTK_CONTAINER(box1), 25);
491 gtk_box_pack_start (GTK_BOX (box1), bbox, TRUE, TRUE, 0);
493 button = gtk_button_new_with_label ("OK");
494 gtk_container_add (GTK_CONTAINER(bbox), button);
496 gtk_signal_connect (GTK_OBJECT (button), "clicked",
497 GTK_SIGNAL_FUNC(bbox_widget_destroy), window);
499 gtk_widget_show (button);
501 button = gtk_button_new_with_label ("Cancel");
502 gtk_container_add (GTK_CONTAINER(bbox), button);
503 gtk_widget_show (button);
505 button = gtk_button_new_with_label ("Help");
506 gtk_container_add (GTK_CONTAINER(bbox), button);
507 gtk_widget_show (button);
509 gtk_widget_show (window);
515 create_bbox_window (TRUE, "Spread", 50, 40, 85, 28, GTK_BUTTONBOX_SPREAD);
516 create_bbox_window (TRUE, "Edge", 200, 40, 85, 25, GTK_BUTTONBOX_EDGE);
517 create_bbox_window (TRUE, "Start", 350, 40, 85, 25, GTK_BUTTONBOX_START);
518 create_bbox_window (TRUE, "End", 500, 15, 30, 25, GTK_BUTTONBOX_END);
524 create_bbox_window (FALSE, "Spread", 50, 40, 85, 25, GTK_BUTTONBOX_SPREAD);
525 create_bbox_window (FALSE, "Edge", 250, 40, 85, 28, GTK_BUTTONBOX_EDGE);
526 create_bbox_window (FALSE, "Start", 450, 40, 85, 25, GTK_BUTTONBOX_START);
527 create_bbox_window (FALSE, "End", 650, 15, 30, 25, GTK_BUTTONBOX_END);
531 create_button_box (void)
533 static GtkWidget* window = NULL;
539 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
540 gtk_window_set_title (GTK_WINDOW (window),
543 gtk_signal_connect (GTK_OBJECT (window), "destroy",
544 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
547 gtk_container_border_width (GTK_CONTAINER (window), 20);
550 *these 15 lines are a nice and easy example for GtkHButtonBox
552 bbox = gtk_hbutton_box_new ();
553 gtk_container_add (GTK_CONTAINER (window), bbox);
554 gtk_widget_show (bbox);
556 button = gtk_button_new_with_label ("Horizontal");
557 gtk_signal_connect (GTK_OBJECT (button), "clicked",
558 GTK_SIGNAL_FUNC(test_hbbox), 0);
559 gtk_container_add (GTK_CONTAINER (bbox), button);
560 gtk_widget_show (button);
562 button = gtk_button_new_with_label ("Vertical");
563 gtk_signal_connect (GTK_OBJECT (button), "clicked",
564 GTK_SIGNAL_FUNC(test_vbbox), 0);
565 gtk_container_add (GTK_CONTAINER (bbox), button);
566 gtk_widget_show (button);
569 if (!GTK_WIDGET_VISIBLE (window))
570 gtk_widget_show (window);
572 gtk_widget_destroy (window);
576 new_pixmap (char *filename,
578 GdkColor *background)
584 pixmap = gdk_pixmap_create_from_xpm (window, &mask,
587 wpixmap = gtk_pixmap_new (pixmap, mask);
593 set_toolbar_horizontal (GtkWidget *widget,
596 gtk_toolbar_set_orientation (GTK_TOOLBAR (data), GTK_ORIENTATION_HORIZONTAL);
600 set_toolbar_vertical (GtkWidget *widget,
603 gtk_toolbar_set_orientation (GTK_TOOLBAR (data), GTK_ORIENTATION_VERTICAL);
607 set_toolbar_icons (GtkWidget *widget,
610 gtk_toolbar_set_style (GTK_TOOLBAR (data), GTK_TOOLBAR_ICONS);
614 set_toolbar_text (GtkWidget *widget,
617 gtk_toolbar_set_style (GTK_TOOLBAR (data), GTK_TOOLBAR_TEXT);
621 set_toolbar_both (GtkWidget *widget,
624 gtk_toolbar_set_style (GTK_TOOLBAR (data), GTK_TOOLBAR_BOTH);
628 set_toolbar_small_space (GtkWidget *widget,
631 gtk_toolbar_set_space_size (GTK_TOOLBAR (data), 5);
635 set_toolbar_big_space (GtkWidget *widget,
638 gtk_toolbar_set_space_size (GTK_TOOLBAR (data), 10);
642 set_toolbar_enable (GtkWidget *widget,
645 gtk_toolbar_set_tooltips (GTK_TOOLBAR (data), TRUE);
649 set_toolbar_disable (GtkWidget *widget,
652 gtk_toolbar_set_tooltips (GTK_TOOLBAR (data), FALSE);
656 set_toolbar_borders (GtkWidget *widget,
659 gtk_toolbar_set_button_relief (GTK_TOOLBAR (data), GTK_RELIEF_NORMAL);
663 set_toolbar_borderless (GtkWidget *widget,
666 gtk_toolbar_set_button_relief (GTK_TOOLBAR (data), GTK_RELIEF_NONE);
670 create_toolbar (void)
672 static GtkWidget *window = NULL;
678 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
679 gtk_window_set_title (GTK_WINDOW (window), "Toolbar test");
680 gtk_window_set_policy (GTK_WINDOW (window), FALSE, TRUE, TRUE);
682 gtk_signal_connect (GTK_OBJECT (window), "destroy",
683 GTK_SIGNAL_FUNC (gtk_widget_destroyed),
686 gtk_container_border_width (GTK_CONTAINER (window), 0);
687 gtk_widget_realize (window);
689 toolbar = gtk_toolbar_new (GTK_ORIENTATION_HORIZONTAL, GTK_TOOLBAR_BOTH);
690 gtk_toolbar_set_button_relief (GTK_TOOLBAR (toolbar), GTK_RELIEF_NONE);
692 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
693 "Horizontal", "Horizontal toolbar layout", "Toolbar/Horizontal",
694 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
695 (GtkSignalFunc) set_toolbar_horizontal, toolbar);
696 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
697 "Vertical", "Vertical toolbar layout", "Toolbar/Vertical",
698 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
699 (GtkSignalFunc) set_toolbar_vertical, toolbar);
701 gtk_toolbar_append_space (GTK_TOOLBAR(toolbar));
703 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
704 "Icons", "Only show toolbar icons", "Toolbar/IconsOnly",
705 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
706 (GtkSignalFunc) set_toolbar_icons, toolbar);
707 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
708 "Text", "Only show toolbar text", "Toolbar/TextOnly",
709 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
710 (GtkSignalFunc) set_toolbar_text, toolbar);
711 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
712 "Both", "Show toolbar icons and text", "Toolbar/Both",
713 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
714 (GtkSignalFunc) set_toolbar_both, toolbar);
716 gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
718 entry = gtk_entry_new ();
719 gtk_widget_show(entry);
720 gtk_toolbar_append_widget (GTK_TOOLBAR (toolbar), entry, "This is an unusable GtkEntry ;)", "Hey don't click me!!!");
722 gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
724 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
725 "Small", "Use small spaces", "Toolbar/Small",
726 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
727 (GtkSignalFunc) set_toolbar_small_space, toolbar);
728 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
729 "Big", "Use big spaces", "Toolbar/Big",
730 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
731 (GtkSignalFunc) set_toolbar_big_space, toolbar);
733 gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
735 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
736 "Enable", "Enable tooltips", NULL,
737 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
738 (GtkSignalFunc) set_toolbar_enable, toolbar);
739 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
740 "Disable", "Disable tooltips", NULL,
741 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
742 (GtkSignalFunc) set_toolbar_disable, toolbar);
744 gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
746 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
747 "Borders", "Show Borders", NULL,
748 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
749 (GtkSignalFunc) set_toolbar_borders, toolbar);
750 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
751 "Borderless", "Hide Borders", NULL,
752 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
753 (GtkSignalFunc) set_toolbar_borderless, toolbar);
755 gtk_container_add (GTK_CONTAINER (window), toolbar);
756 gtk_widget_show (toolbar);
759 if (!GTK_WIDGET_VISIBLE (window))
760 gtk_widget_show (window);
762 gtk_widget_destroy (window);
766 make_toolbar (GtkWidget *window)
770 if (!GTK_WIDGET_REALIZED (window))
771 gtk_widget_realize (window);
773 toolbar = gtk_toolbar_new (GTK_ORIENTATION_HORIZONTAL, GTK_TOOLBAR_BOTH);
774 gtk_toolbar_set_button_relief (GTK_TOOLBAR (toolbar), GTK_RELIEF_NONE);
776 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
777 "Horizontal", "Horizontal toolbar layout", NULL,
778 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
779 (GtkSignalFunc) set_toolbar_horizontal, toolbar);
780 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
781 "Vertical", "Vertical toolbar layout", NULL,
782 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
783 (GtkSignalFunc) set_toolbar_vertical, toolbar);
785 gtk_toolbar_append_space (GTK_TOOLBAR(toolbar));
787 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
788 "Icons", "Only show toolbar icons", NULL,
789 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
790 (GtkSignalFunc) set_toolbar_icons, toolbar);
791 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
792 "Text", "Only show toolbar text", NULL,
793 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
794 (GtkSignalFunc) set_toolbar_text, toolbar);
795 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
796 "Both", "Show toolbar icons and text", NULL,
797 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
798 (GtkSignalFunc) set_toolbar_both, toolbar);
800 gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
802 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
803 "Small", "Use small spaces", NULL,
804 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
805 (GtkSignalFunc) set_toolbar_small_space, toolbar);
806 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
807 "Big", "Use big spaces", "Toolbar/Big",
808 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
809 (GtkSignalFunc) set_toolbar_big_space, toolbar);
811 gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
813 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
814 "Enable", "Enable tooltips", NULL,
815 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
816 (GtkSignalFunc) set_toolbar_enable, toolbar);
817 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
818 "Disable", "Disable tooltips", NULL,
819 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
820 (GtkSignalFunc) set_toolbar_disable, toolbar);
822 gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
824 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
825 "Borders", "Show Borders", NULL,
826 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
827 (GtkSignalFunc) set_toolbar_borders, toolbar);
828 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
829 "Borderless", "Hide Borders", NULL,
830 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
831 (GtkSignalFunc) set_toolbar_borderless, toolbar);
836 static guint statusbar_counter = 1;
839 statusbar_push (GtkWidget *button,
840 GtkStatusbar *statusbar)
844 sprintf (text, "something %d", statusbar_counter++);
846 gtk_statusbar_push (statusbar, 1, text);
850 statusbar_pop (GtkWidget *button,
851 GtkStatusbar *statusbar)
853 gtk_statusbar_pop (statusbar, 1);
857 statusbar_steal (GtkWidget *button,
858 GtkStatusbar *statusbar)
860 gtk_statusbar_remove (statusbar, 1, 4);
864 statusbar_popped (GtkStatusbar *statusbar,
868 if (!statusbar->messages)
869 statusbar_counter = 1;
873 statusbar_contexts (GtkStatusbar *statusbar)
877 string = "any context";
878 g_print ("GtkStatusBar: context=\"%s\", context_id=%d\n",
880 gtk_statusbar_get_context_id (statusbar, string));
882 string = "idle messages";
883 g_print ("GtkStatusBar: context=\"%s\", context_id=%d\n",
885 gtk_statusbar_get_context_id (statusbar, string));
887 string = "some text";
888 g_print ("GtkStatusBar: context=\"%s\", context_id=%d\n",
890 gtk_statusbar_get_context_id (statusbar, string));
892 string = "hit the mouse";
893 g_print ("GtkStatusBar: context=\"%s\", context_id=%d\n",
895 gtk_statusbar_get_context_id (statusbar, string));
897 string = "hit the mouse2";
898 g_print ("GtkStatusBar: context=\"%s\", context_id=%d\n",
900 gtk_statusbar_get_context_id (statusbar, string));
904 statusbar_dump_stack (GtkStatusbar *statusbar)
908 for (list = statusbar->messages; list; list = list->next)
910 GtkStatusbarMsg *msg;
913 g_print ("context_id: %d, message_id: %d, status_text: \"%s\"\n",
921 create_statusbar (void)
923 static GtkWidget *window = NULL;
927 GtkWidget *separator;
928 GtkWidget *statusbar;
932 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
934 gtk_signal_connect (GTK_OBJECT (window), "destroy",
935 GTK_SIGNAL_FUNC (gtk_widget_destroyed),
938 gtk_window_set_title (GTK_WINDOW (window), "statusbar");
939 gtk_container_border_width (GTK_CONTAINER (window), 0);
942 box1 = gtk_vbox_new (FALSE, 0);
943 gtk_container_add (GTK_CONTAINER (window), box1);
944 gtk_widget_show (box1);
947 box2 = gtk_vbox_new (FALSE, 10);
948 gtk_container_border_width (GTK_CONTAINER (box2), 10);
949 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
950 gtk_widget_show (box2);
952 statusbar = gtk_statusbar_new ();
953 gtk_box_pack_end (GTK_BOX (box1), statusbar, TRUE, TRUE, 0);
954 gtk_widget_show (statusbar);
955 gtk_signal_connect (GTK_OBJECT (statusbar),
957 GTK_SIGNAL_FUNC (statusbar_popped),
960 button = gtk_widget_new (gtk_button_get_type (),
961 "label", "push something",
964 "signal::clicked", statusbar_push, statusbar,
967 button = gtk_widget_new (gtk_button_get_type (),
971 "signal_after::clicked", statusbar_pop, statusbar,
974 button = gtk_widget_new (gtk_button_get_type (),
978 "signal_after::clicked", statusbar_steal, statusbar,
981 button = gtk_widget_new (gtk_button_get_type (),
982 "label", "dump stack",
985 "object_signal::clicked", statusbar_dump_stack, statusbar,
988 button = gtk_widget_new (gtk_button_get_type (),
989 "label", "test contexts",
992 "object_signal_after::clicked", statusbar_contexts, statusbar,
995 separator = gtk_hseparator_new ();
996 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
997 gtk_widget_show (separator);
1000 box2 = gtk_vbox_new (FALSE, 10);
1001 gtk_container_border_width (GTK_CONTAINER (box2), 10);
1002 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
1003 gtk_widget_show (box2);
1006 button = gtk_button_new_with_label ("close");
1007 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
1008 GTK_SIGNAL_FUNC(gtk_widget_destroy),
1009 GTK_OBJECT (window));
1010 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
1011 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
1012 gtk_widget_grab_default (button);
1013 gtk_widget_show (button);
1016 if (!GTK_WIDGET_VISIBLE (window))
1017 gtk_widget_show (window);
1019 gtk_widget_destroy (window);
1023 handle_box_child_signal (GtkHandleBox *hb,
1025 const gchar *action)
1027 printf ("%s: child <%s> %sed\n",
1028 gtk_type_name (GTK_OBJECT_TYPE (hb)),
1029 gtk_type_name (GTK_OBJECT_TYPE (child)),
1034 cb_tree_destroy_event(GtkWidget* w)
1036 sTreeButtons* tree_buttons;
1038 /* free buttons structure associate at this tree */
1039 tree_buttons = gtk_object_get_user_data(GTK_OBJECT(w));
1043 cb_add_new_item(GtkWidget* w, GtkTree* tree)
1045 sTreeButtons* tree_buttons;
1046 GList* selected_list;
1047 GtkWidget* selected_item;
1049 GtkWidget* item_new;
1052 tree_buttons = gtk_object_get_user_data(GTK_OBJECT(tree));
1054 selected_list = GTK_TREE_SELECTION(tree);
1056 if(selected_list == NULL)
1058 /* there is no item in tree */
1059 subtree = GTK_WIDGET(tree);
1063 /* list can have only one element */
1064 selected_item = GTK_WIDGET(selected_list->data);
1066 subtree = GTK_TREE_ITEM_SUBTREE(selected_item);
1070 /* current selected item have not subtree ... create it */
1071 subtree = gtk_tree_new();
1072 gtk_tree_item_set_subtree(GTK_TREE_ITEM(selected_item),
1077 /* at this point, we know which subtree will be used to add new item */
1078 /* create a new item */
1079 sprintf(buffer, "item add %d", tree_buttons->nb_item_add);
1080 item_new = gtk_tree_item_new_with_label(buffer);
1081 gtk_tree_append(GTK_TREE(subtree), item_new);
1082 gtk_widget_show(item_new);
1084 tree_buttons->nb_item_add++;
1088 cb_remove_item(GtkWidget*w, GtkTree* tree)
1090 GList* selected_list;
1093 selected_list = GTK_TREE_SELECTION(tree);
1097 while (selected_list)
1099 clear_list = g_list_prepend (clear_list, selected_list->data);
1100 selected_list = selected_list->next;
1103 clear_list = g_list_reverse (clear_list);
1104 gtk_tree_remove_items(tree, clear_list);
1106 g_list_free (clear_list);
1110 cb_remove_subtree(GtkWidget*w, GtkTree* tree)
1112 GList* selected_list;
1115 selected_list = GTK_TREE_SELECTION(tree);
1119 item = GTK_TREE_ITEM (selected_list->data);
1121 gtk_tree_item_remove_subtree (item);
1126 cb_tree_changed(GtkTree* tree)
1128 sTreeButtons* tree_buttons;
1129 GList* selected_list;
1132 tree_buttons = gtk_object_get_user_data(GTK_OBJECT(tree));
1134 selected_list = GTK_TREE_SELECTION(tree);
1135 nb_selected = g_list_length(selected_list);
1137 if(nb_selected == 0)
1139 if(tree->children == NULL)
1140 gtk_widget_set_sensitive(tree_buttons->add_button, TRUE);
1142 gtk_widget_set_sensitive(tree_buttons->add_button, FALSE);
1143 gtk_widget_set_sensitive(tree_buttons->remove_button, FALSE);
1144 gtk_widget_set_sensitive(tree_buttons->subtree_button, FALSE);
1148 gtk_widget_set_sensitive(tree_buttons->remove_button, TRUE);
1149 gtk_widget_set_sensitive(tree_buttons->add_button, (nb_selected == 1));
1150 gtk_widget_set_sensitive(tree_buttons->subtree_button, (nb_selected == 1));
1155 create_subtree(GtkWidget* item, guint level, guint nb_item_max, guint recursion_level_max)
1157 GtkWidget* item_subtree;
1158 GtkWidget* item_new;
1163 if(level == recursion_level_max) return;
1167 /* query with no root item */
1169 item_subtree = item;
1174 /* query with no root item */
1175 /* create subtree and associate it with current item */
1176 item_subtree = gtk_tree_new();
1180 for(nb_item = 0; nb_item < nb_item_max; nb_item++)
1182 sprintf(buffer, "item %d-%d", level, nb_item);
1183 item_new = gtk_tree_item_new_with_label(buffer);
1184 gtk_tree_append(GTK_TREE(item_subtree), item_new);
1185 create_subtree(item_new, level+1, nb_item_max, recursion_level_max);
1186 gtk_widget_show(item_new);
1190 gtk_tree_item_set_subtree(GTK_TREE_ITEM(item), item_subtree);
1194 create_tree_sample(guint selection_mode,
1195 guint draw_line, guint view_line, guint no_root_item,
1196 guint nb_item_max, guint recursion_level_max)
1201 GtkWidget* separator;
1203 GtkWidget* scrolled_win;
1204 GtkWidget* root_tree;
1205 GtkWidget* root_item;
1206 sTreeButtons* tree_buttons;
1208 /* create tree buttons struct */
1209 if((tree_buttons = g_malloc(sizeof(sTreeButtons))) == NULL)
1211 g_error("can't allocate memory for tree structure !\n");
1214 tree_buttons->nb_item_add = 0;
1216 /* create top level window */
1217 window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
1218 gtk_window_set_title(GTK_WINDOW(window), "Tree Sample");
1219 gtk_signal_connect(GTK_OBJECT(window), "destroy",
1220 (GtkSignalFunc) cb_tree_destroy_event, NULL);
1221 gtk_object_set_user_data(GTK_OBJECT(window), tree_buttons);
1223 box1 = gtk_vbox_new(FALSE, 0);
1224 gtk_container_add(GTK_CONTAINER(window), box1);
1225 gtk_widget_show(box1);
1227 /* create tree box */
1228 box2 = gtk_vbox_new(FALSE, 0);
1229 gtk_box_pack_start(GTK_BOX(box1), box2, TRUE, TRUE, 0);
1230 gtk_container_border_width(GTK_CONTAINER(box2), 5);
1231 gtk_widget_show(box2);
1233 /* create scrolled window */
1234 scrolled_win = gtk_scrolled_window_new (NULL, NULL);
1235 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
1236 GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
1237 gtk_box_pack_start (GTK_BOX (box2), scrolled_win, TRUE, TRUE, 0);
1238 gtk_widget_set_usize (scrolled_win, 200, 200);
1239 gtk_widget_show (scrolled_win);
1241 /* create root tree widget */
1242 root_tree = gtk_tree_new();
1243 gtk_signal_connect(GTK_OBJECT(root_tree), "selection_changed",
1244 (GtkSignalFunc)cb_tree_changed,
1246 gtk_object_set_user_data(GTK_OBJECT(root_tree), tree_buttons);
1247 gtk_container_add(GTK_CONTAINER(scrolled_win), root_tree);
1248 gtk_tree_set_selection_mode(GTK_TREE(root_tree), selection_mode);
1249 gtk_tree_set_view_lines(GTK_TREE(root_tree), draw_line);
1250 gtk_tree_set_view_mode(GTK_TREE(root_tree), !view_line);
1251 gtk_widget_show(root_tree);
1255 /* set root tree to subtree function with root item variable */
1256 root_item = GTK_WIDGET(root_tree);
1260 /* create root tree item widget */
1261 root_item = gtk_tree_item_new_with_label("root item");
1262 gtk_tree_append(GTK_TREE(root_tree), root_item);
1263 gtk_widget_show(root_item);
1265 create_subtree(root_item, -no_root_item, nb_item_max, recursion_level_max);
1267 box2 = gtk_vbox_new(FALSE, 0);
1268 gtk_box_pack_start(GTK_BOX(box1), box2, FALSE, FALSE, 0);
1269 gtk_container_border_width(GTK_CONTAINER(box2), 5);
1270 gtk_widget_show(box2);
1272 button = gtk_button_new_with_label("Add Item");
1273 gtk_widget_set_sensitive(button, FALSE);
1274 gtk_signal_connect(GTK_OBJECT (button), "clicked",
1275 (GtkSignalFunc) cb_add_new_item,
1276 (gpointer)root_tree);
1277 gtk_box_pack_start(GTK_BOX(box2), button, TRUE, TRUE, 0);
1278 gtk_widget_show(button);
1279 tree_buttons->add_button = button;
1281 button = gtk_button_new_with_label("Remove Item(s)");
1282 gtk_widget_set_sensitive(button, FALSE);
1283 gtk_signal_connect(GTK_OBJECT (button), "clicked",
1284 (GtkSignalFunc) cb_remove_item,
1285 (gpointer)root_tree);
1286 gtk_box_pack_start(GTK_BOX(box2), button, TRUE, TRUE, 0);
1287 gtk_widget_show(button);
1288 tree_buttons->remove_button = button;
1290 button = gtk_button_new_with_label("Remove Subtree");
1291 gtk_widget_set_sensitive(button, FALSE);
1292 gtk_signal_connect(GTK_OBJECT (button), "clicked",
1293 (GtkSignalFunc) cb_remove_subtree,
1294 (gpointer)root_tree);
1295 gtk_box_pack_start(GTK_BOX(box2), button, TRUE, TRUE, 0);
1296 gtk_widget_show(button);
1297 tree_buttons->subtree_button = button;
1299 /* create separator */
1300 separator = gtk_hseparator_new();
1301 gtk_box_pack_start(GTK_BOX(box1), separator, FALSE, FALSE, 0);
1302 gtk_widget_show(separator);
1304 /* create button box */
1305 box2 = gtk_vbox_new(FALSE, 0);
1306 gtk_box_pack_start(GTK_BOX(box1), box2, FALSE, FALSE, 0);
1307 gtk_container_border_width(GTK_CONTAINER(box2), 5);
1308 gtk_widget_show(box2);
1310 button = gtk_button_new_with_label("Close");
1311 gtk_box_pack_start(GTK_BOX(box2), button, TRUE, TRUE, 0);
1312 gtk_signal_connect_object(GTK_OBJECT (button), "clicked",
1313 (GtkSignalFunc) gtk_widget_destroy,
1314 GTK_OBJECT(window));
1315 gtk_widget_show(button);
1317 gtk_widget_show(window);
1321 cb_create_tree(GtkWidget* w)
1323 guint selection_mode = GTK_SELECTION_SINGLE;
1328 guint recursion_level;
1330 /* get selection mode choice */
1331 if(GTK_TOGGLE_BUTTON(sTreeSampleSelection.single_button)->active)
1332 selection_mode = GTK_SELECTION_SINGLE;
1334 if(GTK_TOGGLE_BUTTON(sTreeSampleSelection.browse_button)->active)
1335 selection_mode = GTK_SELECTION_BROWSE;
1337 selection_mode = GTK_SELECTION_MULTIPLE;
1339 /* get options choice */
1340 draw_line = GTK_TOGGLE_BUTTON(sTreeSampleSelection.draw_line_button)->active;
1341 view_line = GTK_TOGGLE_BUTTON(sTreeSampleSelection.view_line_button)->active;
1342 no_root_item = GTK_TOGGLE_BUTTON(sTreeSampleSelection.no_root_item_button)->active;
1345 nb_item = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(sTreeSampleSelection.nb_item_spinner));
1346 recursion_level = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(sTreeSampleSelection.recursion_spinner));
1348 if (pow (nb_item, recursion_level) > 10000)
1350 g_print ("%g total items? That will take a very long time. Try less\n",
1351 pow (nb_item, recursion_level));
1355 create_tree_sample(selection_mode, draw_line, view_line, no_root_item, nb_item, recursion_level);
1359 create_tree_mode_window(void)
1361 static GtkWidget* window;
1369 GtkWidget* separator;
1376 /* create toplevel window */
1377 window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
1378 gtk_window_set_title(GTK_WINDOW(window), "Tree Mode Selection Window");
1379 gtk_signal_connect (GTK_OBJECT (window), "destroy",
1380 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
1382 box1 = gtk_vbox_new(FALSE, 0);
1383 gtk_container_add(GTK_CONTAINER(window), box1);
1384 gtk_widget_show(box1);
1386 /* create upper box - selection box */
1387 box2 = gtk_vbox_new(FALSE, 5);
1388 gtk_box_pack_start(GTK_BOX(box1), box2, TRUE, TRUE, 0);
1389 gtk_container_border_width(GTK_CONTAINER(box2), 5);
1390 gtk_widget_show(box2);
1392 box3 = gtk_hbox_new(FALSE, 5);
1393 gtk_box_pack_start(GTK_BOX(box2), box3, TRUE, TRUE, 0);
1394 gtk_widget_show(box3);
1396 /* create selection mode frame */
1397 frame = gtk_frame_new("Selection Mode");
1398 gtk_box_pack_start(GTK_BOX(box3), frame, TRUE, TRUE, 0);
1399 gtk_widget_show(frame);
1401 box4 = gtk_vbox_new(FALSE, 0);
1402 gtk_container_add(GTK_CONTAINER(frame), box4);
1403 gtk_container_border_width(GTK_CONTAINER(box4), 5);
1404 gtk_widget_show(box4);
1406 /* create radio button */
1407 button = gtk_radio_button_new_with_label(NULL, "SINGLE");
1408 gtk_box_pack_start(GTK_BOX(box4), button, TRUE, TRUE, 0);
1409 gtk_widget_show(button);
1410 sTreeSampleSelection.single_button = button;
1412 button = gtk_radio_button_new_with_label(gtk_radio_button_group (GTK_RADIO_BUTTON (button)),
1414 gtk_box_pack_start(GTK_BOX(box4), button, TRUE, TRUE, 0);
1415 gtk_widget_show(button);
1416 sTreeSampleSelection.browse_button = button;
1418 button = gtk_radio_button_new_with_label(gtk_radio_button_group (GTK_RADIO_BUTTON (button)),
1420 gtk_box_pack_start(GTK_BOX(box4), button, TRUE, TRUE, 0);
1421 gtk_widget_show(button);
1422 sTreeSampleSelection.multiple_button = button;
1424 sTreeSampleSelection.selection_mode_group = gtk_radio_button_group (GTK_RADIO_BUTTON (button));
1426 /* create option mode frame */
1427 frame = gtk_frame_new("Options");
1428 gtk_box_pack_start(GTK_BOX(box3), frame, TRUE, TRUE, 0);
1429 gtk_widget_show(frame);
1431 box4 = gtk_vbox_new(FALSE, 0);
1432 gtk_container_add(GTK_CONTAINER(frame), box4);
1433 gtk_container_border_width(GTK_CONTAINER(box4), 5);
1434 gtk_widget_show(box4);
1436 /* create check button */
1437 button = gtk_check_button_new_with_label("Draw line");
1438 gtk_box_pack_start(GTK_BOX(box4), button, TRUE, TRUE, 0);
1439 gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(button), TRUE);
1440 gtk_widget_show(button);
1441 sTreeSampleSelection.draw_line_button = button;
1443 button = gtk_check_button_new_with_label("View Line mode");
1444 gtk_box_pack_start(GTK_BOX(box4), button, TRUE, TRUE, 0);
1445 gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(button), TRUE);
1446 gtk_widget_show(button);
1447 sTreeSampleSelection.view_line_button = button;
1449 button = gtk_check_button_new_with_label("Without Root item");
1450 gtk_box_pack_start(GTK_BOX(box4), button, TRUE, TRUE, 0);
1451 gtk_widget_show(button);
1452 sTreeSampleSelection.no_root_item_button = button;
1454 /* create recursion parameter */
1455 frame = gtk_frame_new("Size Parameters");
1456 gtk_box_pack_start(GTK_BOX(box2), frame, TRUE, TRUE, 0);
1457 gtk_widget_show(frame);
1459 box4 = gtk_hbox_new(FALSE, 5);
1460 gtk_container_add(GTK_CONTAINER(frame), box4);
1461 gtk_container_border_width(GTK_CONTAINER(box4), 5);
1462 gtk_widget_show(box4);
1464 /* create number of item spin button */
1465 box5 = gtk_hbox_new(FALSE, 5);
1466 gtk_box_pack_start(GTK_BOX(box4), box5, FALSE, FALSE, 0);
1467 gtk_widget_show(box5);
1469 label = gtk_label_new("Number of Item");
1470 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
1471 gtk_box_pack_start (GTK_BOX (box5), label, FALSE, TRUE, 0);
1472 gtk_widget_show(label);
1474 adj = (GtkAdjustment *) gtk_adjustment_new ((gfloat)DEFAULT_NUMBER_OF_ITEM, 1.0, 255.0, 1.0,
1476 spinner = gtk_spin_button_new (adj, 0, 0);
1477 gtk_box_pack_start (GTK_BOX (box5), spinner, FALSE, TRUE, 0);
1478 gtk_widget_show(spinner);
1479 sTreeSampleSelection.nb_item_spinner = spinner;
1481 /* create recursion level spin button */
1482 box5 = gtk_hbox_new(FALSE, 5);
1483 gtk_box_pack_start(GTK_BOX(box4), box5, FALSE, FALSE, 0);
1484 gtk_widget_show(box5);
1486 label = gtk_label_new("Depth Level");
1487 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
1488 gtk_box_pack_start (GTK_BOX (box5), label, FALSE, TRUE, 0);
1489 gtk_widget_show(label);
1491 adj = (GtkAdjustment *) gtk_adjustment_new ((gfloat)DEFAULT_RECURSION_LEVEL, 0.0, 255.0, 1.0,
1493 spinner = gtk_spin_button_new (adj, 0, 0);
1494 gtk_box_pack_start (GTK_BOX (box5), spinner, FALSE, TRUE, 0);
1495 gtk_widget_show(spinner);
1496 sTreeSampleSelection.recursion_spinner = spinner;
1498 /* create horizontal separator */
1499 separator = gtk_hseparator_new();
1500 gtk_box_pack_start(GTK_BOX(box1), separator, FALSE, FALSE, 0);
1501 gtk_widget_show(separator);
1503 /* create bottom button box */
1504 box2 = gtk_hbox_new(FALSE, 0);
1505 gtk_box_pack_start(GTK_BOX(box1), box2, FALSE, FALSE, 0);
1506 gtk_container_border_width(GTK_CONTAINER(box2), 5);
1507 gtk_widget_show(box2);
1509 button = gtk_button_new_with_label("Create Tree Sample");
1510 gtk_box_pack_start(GTK_BOX(box2), button, TRUE, TRUE, 0);
1511 gtk_signal_connect(GTK_OBJECT (button), "clicked",
1512 (GtkSignalFunc) cb_create_tree, NULL);
1513 gtk_widget_show(button);
1515 button = gtk_button_new_with_label("Close");
1516 gtk_box_pack_start(GTK_BOX(box2), button, TRUE, TRUE, 0);
1517 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
1518 GTK_SIGNAL_FUNC(gtk_widget_destroy),
1519 GTK_OBJECT (window));
1520 gtk_widget_show(button);
1523 if (!GTK_WIDGET_VISIBLE (window))
1524 gtk_widget_show (window);
1526 gtk_widget_destroy (window);
1529 /* end of function used by tree demos */
1532 create_handle_box (void)
1534 static GtkWidget* window = NULL;
1535 GtkWidget *handle_box;
1536 GtkWidget *handle_box2;
1541 GtkWidget *separator;
1545 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
1546 gtk_window_set_title (GTK_WINDOW (window),
1548 gtk_window_set_policy (GTK_WINDOW (window),
1553 gtk_signal_connect (GTK_OBJECT (window), "destroy",
1554 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
1557 gtk_container_border_width (GTK_CONTAINER (window), 20);
1559 vbox = gtk_vbox_new (FALSE, 0);
1560 gtk_container_add (GTK_CONTAINER (window), vbox);
1561 gtk_widget_show (vbox);
1563 label = gtk_label_new ("Above");
1564 gtk_container_add (GTK_CONTAINER (vbox), label);
1565 gtk_widget_show (label);
1567 separator = gtk_hseparator_new ();
1568 gtk_container_add (GTK_CONTAINER (vbox), separator);
1569 gtk_widget_show (separator);
1571 hbox = gtk_hbox_new (FALSE, 10);
1572 gtk_container_add (GTK_CONTAINER (vbox), hbox);
1573 gtk_widget_show (hbox);
1575 separator = gtk_hseparator_new ();
1576 gtk_container_add (GTK_CONTAINER (vbox), separator);
1577 gtk_widget_show (separator);
1579 label = gtk_label_new ("Below");
1580 gtk_container_add (GTK_CONTAINER (vbox), label);
1581 gtk_widget_show (label);
1583 handle_box = gtk_handle_box_new ();
1584 gtk_container_add (GTK_CONTAINER (hbox), handle_box);
1585 gtk_signal_connect (GTK_OBJECT (handle_box),
1587 GTK_SIGNAL_FUNC (handle_box_child_signal),
1589 gtk_signal_connect (GTK_OBJECT (handle_box),
1591 GTK_SIGNAL_FUNC (handle_box_child_signal),
1593 gtk_widget_show (handle_box);
1595 toolbar = make_toolbar (window);
1596 gtk_toolbar_set_button_relief (GTK_TOOLBAR (toolbar), GTK_RELIEF_NORMAL);
1597 gtk_container_add (GTK_CONTAINER (handle_box), toolbar);
1598 gtk_widget_show (toolbar);
1600 handle_box = gtk_handle_box_new ();
1601 gtk_container_add (GTK_CONTAINER (hbox), handle_box);
1602 gtk_signal_connect (GTK_OBJECT (handle_box),
1604 GTK_SIGNAL_FUNC (handle_box_child_signal),
1606 gtk_signal_connect (GTK_OBJECT (handle_box),
1608 GTK_SIGNAL_FUNC (handle_box_child_signal),
1610 gtk_widget_show (handle_box);
1612 handle_box2 = gtk_handle_box_new ();
1613 gtk_container_add (GTK_CONTAINER (handle_box), handle_box2);
1614 gtk_signal_connect (GTK_OBJECT (handle_box2),
1616 GTK_SIGNAL_FUNC (handle_box_child_signal),
1618 gtk_signal_connect (GTK_OBJECT (handle_box2),
1620 GTK_SIGNAL_FUNC (handle_box_child_signal),
1622 gtk_widget_show (handle_box2);
1624 label = gtk_label_new ("Fooo!");
1625 gtk_container_add (GTK_CONTAINER (handle_box2), label);
1626 gtk_widget_show (label);
1629 if (!GTK_WIDGET_VISIBLE (window))
1630 gtk_widget_show (window);
1632 gtk_widget_destroy (window);
1637 reparent_label (GtkWidget *widget,
1638 GtkWidget *new_parent)
1642 label = gtk_object_get_user_data (GTK_OBJECT (widget));
1644 gtk_widget_reparent (label, new_parent);
1648 set_parent_signal (GtkWidget *child,
1649 GtkWidget *old_parent,
1652 g_print ("set_parent for \"%s\": new parent: \"%s\", old parent: \"%s\", data: %d\n",
1653 gtk_type_name (GTK_OBJECT_TYPE (child)),
1654 child->parent ? gtk_type_name (GTK_OBJECT_TYPE (child->parent)) : "NULL",
1655 old_parent ? gtk_type_name (GTK_OBJECT_TYPE (old_parent)) : "NULL",
1656 GPOINTER_TO_INT (func_data));
1660 create_reparent (void)
1662 static GtkWidget *window = NULL;
1669 GtkWidget *separator;
1673 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
1675 gtk_signal_connect (GTK_OBJECT (window), "destroy",
1676 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
1679 gtk_window_set_title (GTK_WINDOW (window), "buttons");
1680 gtk_container_border_width (GTK_CONTAINER (window), 0);
1683 box1 = gtk_vbox_new (FALSE, 0);
1684 gtk_container_add (GTK_CONTAINER (window), box1);
1685 gtk_widget_show (box1);
1688 box2 = gtk_hbox_new (FALSE, 5);
1689 gtk_container_border_width (GTK_CONTAINER (box2), 10);
1690 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
1691 gtk_widget_show (box2);
1694 label = gtk_label_new ("Hello World");
1696 frame = gtk_frame_new ("Frame 1");
1697 gtk_box_pack_start (GTK_BOX (box2), frame, TRUE, TRUE, 0);
1698 gtk_widget_show (frame);
1700 box3 = gtk_vbox_new (FALSE, 5);
1701 gtk_container_border_width (GTK_CONTAINER (box3), 5);
1702 gtk_container_add (GTK_CONTAINER (frame), box3);
1703 gtk_widget_show (box3);
1705 button = gtk_button_new_with_label ("switch");
1706 gtk_signal_connect (GTK_OBJECT (button), "clicked",
1707 GTK_SIGNAL_FUNC(reparent_label),
1709 gtk_object_set_user_data (GTK_OBJECT (button), label);
1710 gtk_box_pack_start (GTK_BOX (box3), button, FALSE, TRUE, 0);
1711 gtk_widget_show (button);
1713 gtk_box_pack_start (GTK_BOX (box3), label, FALSE, TRUE, 0);
1714 gtk_signal_connect (GTK_OBJECT (label),
1716 GTK_SIGNAL_FUNC (set_parent_signal),
1717 GINT_TO_POINTER (42));
1718 gtk_widget_show (label);
1721 frame = gtk_frame_new ("Frame 2");
1722 gtk_box_pack_start (GTK_BOX (box2), frame, TRUE, TRUE, 0);
1723 gtk_widget_show (frame);
1725 box3 = gtk_vbox_new (FALSE, 5);
1726 gtk_container_border_width (GTK_CONTAINER (box3), 5);
1727 gtk_container_add (GTK_CONTAINER (frame), box3);
1728 gtk_widget_show (box3);
1730 button = gtk_button_new_with_label ("switch");
1731 gtk_signal_connect (GTK_OBJECT (button), "clicked",
1732 GTK_SIGNAL_FUNC(reparent_label),
1734 gtk_object_set_user_data (GTK_OBJECT (button), label);
1735 gtk_box_pack_start (GTK_BOX (box3), button, FALSE, TRUE, 0);
1736 gtk_widget_show (button);
1739 separator = gtk_hseparator_new ();
1740 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
1741 gtk_widget_show (separator);
1744 box2 = gtk_vbox_new (FALSE, 10);
1745 gtk_container_border_width (GTK_CONTAINER (box2), 10);
1746 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
1747 gtk_widget_show (box2);
1750 button = gtk_button_new_with_label ("close");
1751 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
1752 GTK_SIGNAL_FUNC(gtk_widget_destroy),
1753 GTK_OBJECT (window));
1754 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
1755 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
1756 gtk_widget_grab_default (button);
1757 gtk_widget_show (button);
1760 if (!GTK_WIDGET_VISIBLE (window))
1761 gtk_widget_show (window);
1763 gtk_widget_destroy (window);
1767 create_pixmap (void)
1769 static GtkWidget *window = NULL;
1775 GtkWidget *separator;
1776 GtkWidget *pixmapwid;
1783 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
1785 gtk_signal_connect (GTK_OBJECT (window), "destroy",
1786 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
1789 gtk_window_set_title (GTK_WINDOW (window), "pixmap");
1790 gtk_container_border_width (GTK_CONTAINER (window), 0);
1791 gtk_widget_realize(window);
1793 box1 = gtk_vbox_new (FALSE, 0);
1794 gtk_container_add (GTK_CONTAINER (window), box1);
1795 gtk_widget_show (box1);
1797 box2 = gtk_vbox_new (FALSE, 10);
1798 gtk_container_border_width (GTK_CONTAINER (box2), 10);
1799 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
1800 gtk_widget_show (box2);
1802 button = gtk_button_new ();
1803 gtk_box_pack_start (GTK_BOX (box2), button, FALSE, FALSE, 0);
1804 gtk_widget_show (button);
1806 style=gtk_widget_get_style(button);
1808 pixmap = gdk_pixmap_create_from_xpm (window->window, &mask,
1809 &style->bg[GTK_STATE_NORMAL],
1811 pixmapwid = gtk_pixmap_new (pixmap, mask);
1813 label = gtk_label_new ("Pixmap\ntest");
1814 box3 = gtk_hbox_new (FALSE, 0);
1815 gtk_container_border_width (GTK_CONTAINER (box3), 2);
1816 gtk_container_add (GTK_CONTAINER (box3), pixmapwid);
1817 gtk_container_add (GTK_CONTAINER (box3), label);
1818 gtk_container_add (GTK_CONTAINER (button), box3);
1819 gtk_widget_show (pixmapwid);
1820 gtk_widget_show (label);
1821 gtk_widget_show (box3);
1823 separator = gtk_hseparator_new ();
1824 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
1825 gtk_widget_show (separator);
1828 box2 = gtk_vbox_new (FALSE, 10);
1829 gtk_container_border_width (GTK_CONTAINER (box2), 10);
1830 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
1831 gtk_widget_show (box2);
1834 button = gtk_button_new_with_label ("close");
1835 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
1836 GTK_SIGNAL_FUNC(gtk_widget_destroy),
1837 GTK_OBJECT (window));
1838 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
1839 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
1840 gtk_widget_grab_default (button);
1841 gtk_widget_show (button);
1844 if (!GTK_WIDGET_VISIBLE (window))
1845 gtk_widget_show (window);
1847 gtk_widget_destroy (window);
1851 tips_query_widget_entered (GtkTipsQuery *tips_query,
1853 const gchar *tip_text,
1854 const gchar *tip_private,
1857 if (GTK_TOGGLE_BUTTON (toggle)->active)
1859 gtk_label_set (GTK_LABEL (tips_query), tip_text ? "There is a Tip!" : "There is no Tip!");
1860 /* don't let GtkTipsQuery reset it's label */
1861 gtk_signal_emit_stop_by_name (GTK_OBJECT (tips_query), "widget_entered");
1866 tips_query_widget_selected (GtkWidget *tips_query,
1868 const gchar *tip_text,
1869 const gchar *tip_private,
1870 GdkEventButton *event,
1874 g_print ("Help \"%s\" requested for <%s>\n",
1875 tip_private ? tip_private : "None",
1876 gtk_type_name (GTK_OBJECT_TYPE (widget)));
1882 create_tooltips (void)
1884 static GtkWidget *window = NULL;
1891 GtkWidget *tips_query;
1892 GtkWidget *separator;
1893 GtkTooltips *tooltips;
1898 gtk_widget_new (gtk_window_get_type (),
1899 "GtkWindow::type", GTK_WINDOW_TOPLEVEL,
1900 "GtkContainer::border_width", 0,
1901 "GtkWindow::title", "Tooltips",
1902 "GtkWindow::allow_shrink", TRUE,
1903 "GtkWindow::allow_grow", FALSE,
1904 "GtkWindow::auto_shrink", TRUE,
1905 "GtkWidget::width", 200,
1908 gtk_signal_connect (GTK_OBJECT (window), "destroy",
1909 GTK_SIGNAL_FUNC (destroy_tooltips),
1912 tooltips=gtk_tooltips_new();
1913 gtk_object_set_data (GTK_OBJECT (window), "tooltips", tooltips);
1915 box1 = gtk_vbox_new (FALSE, 0);
1916 gtk_container_add (GTK_CONTAINER (window), box1);
1917 gtk_widget_show (box1);
1920 box2 = gtk_vbox_new (FALSE, 10);
1921 gtk_container_border_width (GTK_CONTAINER (box2), 10);
1922 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
1923 gtk_widget_show (box2);
1926 button = gtk_toggle_button_new_with_label ("button1");
1927 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
1928 gtk_widget_show (button);
1930 gtk_tooltips_set_tip (tooltips,button,"This is button 1", "ContextHelp/buttons/1");
1932 button = gtk_toggle_button_new_with_label ("button2");
1933 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
1934 gtk_widget_show (button);
1936 gtk_tooltips_set_tip (tooltips,
1938 "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.",
1939 "ContextHelp/buttons/2_long");
1941 toggle = gtk_toggle_button_new_with_label ("Override TipsQuery Label");
1942 gtk_box_pack_start (GTK_BOX (box2), toggle, TRUE, TRUE, 0);
1943 gtk_widget_show (toggle);
1945 gtk_tooltips_set_tip (tooltips, toggle, "Toggle TipsQuery view.", "Hi msw! ;)");
1948 gtk_widget_new (gtk_vbox_get_type (),
1949 "GtkBox::homogeneous", FALSE,
1950 "GtkBox::spacing", 5,
1951 "GtkContainer::border_width", 5,
1952 "GtkWidget::visible", TRUE,
1955 tips_query = gtk_tips_query_new ();
1958 gtk_widget_new (gtk_button_get_type (),
1959 "GtkButton::label", "[?]",
1960 "GtkWidget::visible", TRUE,
1961 "GtkWidget::parent", box3,
1962 "GtkObject::object_signal::clicked", gtk_tips_query_start_query, tips_query,
1964 gtk_box_set_child_packing (GTK_BOX (box3), button, FALSE, FALSE, 0, GTK_PACK_START);
1965 gtk_tooltips_set_tip (tooltips,
1967 "Start the Tooltips Inspector",
1968 "ContextHelp/buttons/?");
1971 gtk_widget_set (tips_query,
1972 "GtkWidget::visible", TRUE,
1973 "GtkWidget::parent", box3,
1974 "GtkTipsQuery::caller", button,
1975 "GtkObject::signal::widget_entered", tips_query_widget_entered, toggle,
1976 "GtkObject::signal::widget_selected", tips_query_widget_selected, NULL,
1980 gtk_widget_new (gtk_frame_get_type (),
1981 "GtkFrame::label", "ToolTips Inspector",
1982 "GtkFrame::label_xalign", (double) 0.5,
1983 "GtkContainer::border_width", 0,
1984 "GtkWidget::visible", TRUE,
1985 "GtkWidget::parent", box2,
1986 "GtkContainer::child", box3,
1988 gtk_box_set_child_packing (GTK_BOX (box2), frame, TRUE, TRUE, 10, GTK_PACK_START);
1990 separator = gtk_hseparator_new ();
1991 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
1992 gtk_widget_show (separator);
1995 box2 = gtk_vbox_new (FALSE, 10);
1996 gtk_container_border_width (GTK_CONTAINER (box2), 10);
1997 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
1998 gtk_widget_show (box2);
2001 button = gtk_button_new_with_label ("close");
2002 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
2003 GTK_SIGNAL_FUNC(gtk_widget_destroy),
2004 GTK_OBJECT (window));
2005 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
2006 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
2007 gtk_widget_grab_default (button);
2008 gtk_widget_show (button);
2010 gtk_tooltips_set_tip (tooltips, button, "Push this button to close window", "ContextHelp/buttons/Close");
2013 if (!GTK_WIDGET_VISIBLE (window))
2014 gtk_widget_show (window);
2016 gtk_widget_destroy (window);
2020 create_menu (int depth)
2023 GtkWidget *menuitem;
2031 menu = gtk_menu_new ();
2034 for (i = 0, j = 1; i < 5; i++, j++)
2036 sprintf (buf, "item %2d - %d", depth, j);
2037 menuitem = gtk_radio_menu_item_new_with_label (group, buf);
2038 group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menuitem));
2040 gtk_check_menu_item_set_show_toggle (GTK_CHECK_MENU_ITEM (menuitem), TRUE);
2041 gtk_menu_append (GTK_MENU (menu), menuitem);
2042 gtk_widget_show (menuitem);
2044 gtk_widget_set_sensitive (menuitem, FALSE);
2046 gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), create_menu (depth - 1));
2055 static GtkWidget *window = NULL;
2059 GtkWidget *optionmenu;
2060 GtkWidget *separator;
2066 GtkWidget *menuitem;
2067 GtkAccelGroup *accel_group;
2069 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
2071 gtk_signal_connect (GTK_OBJECT (window), "destroy",
2072 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
2074 gtk_signal_connect (GTK_OBJECT (window), "delete-event",
2075 GTK_SIGNAL_FUNC (gtk_true),
2078 gtk_window_set_title (GTK_WINDOW (window), "menus");
2079 gtk_container_border_width (GTK_CONTAINER (window), 0);
2082 box1 = gtk_vbox_new (FALSE, 0);
2083 gtk_container_add (GTK_CONTAINER (window), box1);
2084 gtk_widget_show (box1);
2087 menubar = gtk_menu_bar_new ();
2088 gtk_box_pack_start (GTK_BOX (box1), menubar, FALSE, TRUE, 0);
2089 gtk_widget_show (menubar);
2091 menu = create_menu (2);
2093 menuitem = gtk_menu_item_new_with_label ("test\nline2");
2094 gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), menu);
2095 gtk_menu_bar_append (GTK_MENU_BAR (menubar), menuitem);
2096 gtk_widget_show (menuitem);
2098 menuitem = gtk_menu_item_new_with_label ("foo");
2099 gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), create_menu (3));
2100 gtk_menu_bar_append (GTK_MENU_BAR (menubar), menuitem);
2101 gtk_widget_show (menuitem);
2103 menuitem = gtk_menu_item_new_with_label ("bar");
2104 gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), create_menu (4));
2105 gtk_menu_item_right_justify (GTK_MENU_ITEM (menuitem));
2106 gtk_menu_bar_append (GTK_MENU_BAR (menubar), menuitem);
2107 gtk_widget_show (menuitem);
2110 box2 = gtk_vbox_new (FALSE, 10);
2111 gtk_container_border_width (GTK_CONTAINER (box2), 10);
2112 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
2113 gtk_widget_show (box2);
2115 menu = create_menu (1);
2116 accel_group = gtk_accel_group_get_default ();
2117 gtk_menu_set_accel_group (GTK_MENU (menu), accel_group);
2119 menuitem = gtk_check_menu_item_new_with_label ("Accelerate Me");
2120 gtk_menu_append (GTK_MENU (menu), menuitem);
2121 gtk_widget_show (menuitem);
2122 gtk_widget_add_accelerator (menuitem,
2127 GTK_ACCEL_VISIBLE | GTK_ACCEL_SIGNAL_VISIBLE);
2128 menuitem = gtk_check_menu_item_new_with_label ("Accelerator Locked");
2129 gtk_menu_append (GTK_MENU (menu), menuitem);
2130 gtk_widget_show (menuitem);
2131 gtk_widget_add_accelerator (menuitem,
2136 GTK_ACCEL_VISIBLE | GTK_ACCEL_LOCKED);
2137 menuitem = gtk_check_menu_item_new_with_label ("Accelerators Frozen");
2138 gtk_menu_append (GTK_MENU (menu), menuitem);
2139 gtk_widget_show (menuitem);
2140 gtk_widget_add_accelerator (menuitem,
2146 gtk_widget_add_accelerator (menuitem,
2152 gtk_widget_freeze_accelerators (menuitem);
2154 optionmenu = gtk_option_menu_new ();
2155 gtk_option_menu_set_menu (GTK_OPTION_MENU (optionmenu), menu);
2156 gtk_option_menu_set_history (GTK_OPTION_MENU (optionmenu), 3);
2157 gtk_box_pack_start (GTK_BOX (box2), optionmenu, TRUE, TRUE, 0);
2158 gtk_widget_show (optionmenu);
2161 separator = gtk_hseparator_new ();
2162 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
2163 gtk_widget_show (separator);
2166 box2 = gtk_vbox_new (FALSE, 10);
2167 gtk_container_border_width (GTK_CONTAINER (box2), 10);
2168 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
2169 gtk_widget_show (box2);
2172 button = gtk_button_new_with_label ("close");
2173 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
2174 GTK_SIGNAL_FUNC(gtk_widget_destroy),
2175 GTK_OBJECT (window));
2176 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
2177 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
2178 gtk_widget_grab_default (button);
2179 gtk_widget_show (button);
2182 if (!GTK_WIDGET_VISIBLE (window))
2183 gtk_widget_show (window);
2185 gtk_widget_destroy (window);
2192 scrolled_windows_remove (GtkWidget *widget, GtkWidget *scrollwin)
2194 static GtkWidget *parent = NULL;
2195 static GtkWidget *float_parent;
2199 gtk_widget_reparent (scrollwin, parent);
2200 gtk_widget_destroy (float_parent);
2201 float_parent = NULL;
2206 parent = widget->parent;
2207 float_parent = gtk_window_new (GTK_WINDOW_TOPLEVEL);
2208 gtk_widget_reparent (scrollwin, float_parent);
2209 gtk_widget_show (float_parent);
2217 create_scrolled_windows (void)
2219 static GtkWidget *window;
2220 GtkWidget *scrolled_window;
2228 window = gtk_dialog_new ();
2230 gtk_signal_connect (GTK_OBJECT (window), "destroy",
2231 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
2234 gtk_window_set_title (GTK_WINDOW (window), "dialog");
2235 gtk_container_border_width (GTK_CONTAINER (window), 0);
2238 scrolled_window = gtk_scrolled_window_new (NULL, NULL);
2239 gtk_container_border_width (GTK_CONTAINER (scrolled_window), 10);
2240 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
2241 GTK_POLICY_AUTOMATIC,
2242 GTK_POLICY_AUTOMATIC);
2243 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox),
2244 scrolled_window, TRUE, TRUE, 0);
2245 gtk_widget_show (scrolled_window);
2247 table = gtk_table_new (20, 20, FALSE);
2248 gtk_table_set_row_spacings (GTK_TABLE (table), 10);
2249 gtk_table_set_col_spacings (GTK_TABLE (table), 10);
2250 gtk_container_add (GTK_CONTAINER (scrolled_window), table);
2251 gtk_container_set_focus_hadjustment (GTK_CONTAINER (table),
2252 gtk_scrolled_window_get_hadjustment (GTK_SCROLLED_WINDOW (scrolled_window)));
2253 gtk_container_set_focus_vadjustment (GTK_CONTAINER (table),
2254 gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (scrolled_window)));
2255 gtk_widget_show (table);
2257 for (i = 0; i < 20; i++)
2258 for (j = 0; j < 20; j++)
2260 sprintf (buffer, "button (%d,%d)\n", i, j);
2261 button = gtk_toggle_button_new_with_label (buffer);
2262 gtk_table_attach_defaults (GTK_TABLE (table), button,
2264 gtk_widget_show (button);
2268 button = gtk_button_new_with_label ("close");
2269 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
2270 GTK_SIGNAL_FUNC(gtk_widget_destroy),
2271 GTK_OBJECT (window));
2272 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
2273 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
2274 button, TRUE, TRUE, 0);
2275 gtk_widget_grab_default (button);
2276 gtk_widget_show (button);
2278 button = gtk_button_new_with_label ("remove");
2279 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
2280 GTK_SIGNAL_FUNC(scrolled_windows_remove),
2281 GTK_OBJECT (scrolled_window));
2282 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
2283 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
2284 button, TRUE, TRUE, 0);
2285 gtk_widget_grab_default (button);
2286 gtk_widget_show (button);
2290 if (!GTK_WIDGET_VISIBLE (window))
2291 gtk_widget_show (window);
2293 gtk_widget_destroy (window);
2301 entry_toggle_editable (GtkWidget *checkbutton,
2304 gtk_entry_set_editable(GTK_ENTRY(entry),
2305 GTK_TOGGLE_BUTTON(checkbutton)->active);
2309 entry_toggle_sensitive (GtkWidget *checkbutton,
2312 gtk_widget_set_sensitive (entry, GTK_TOGGLE_BUTTON(checkbutton)->active);
2316 entry_toggle_visibility (GtkWidget *checkbutton,
2319 gtk_entry_set_visibility(GTK_ENTRY(entry),
2320 GTK_TOGGLE_BUTTON(checkbutton)->active);
2326 static GtkWidget *window = NULL;
2329 GtkWidget *editable_check;
2330 GtkWidget *sensitive_check;
2331 GtkWidget *entry, *cb;
2333 GtkWidget *separator;
2334 GList *cbitems = NULL;
2338 cbitems = g_list_append(cbitems, "item0");
2339 cbitems = g_list_append(cbitems, "item1 item1");
2340 cbitems = g_list_append(cbitems, "item2 item2 item2");
2341 cbitems = g_list_append(cbitems, "item3 item3 item3 item3");
2342 cbitems = g_list_append(cbitems, "item4 item4 item4 item4 item4");
2343 cbitems = g_list_append(cbitems, "item5 item5 item5 item5 item5 item5");
2344 cbitems = g_list_append(cbitems, "item6 item6 item6 item6 item6");
2345 cbitems = g_list_append(cbitems, "item7 item7 item7 item7");
2346 cbitems = g_list_append(cbitems, "item8 item8 item8");
2347 cbitems = g_list_append(cbitems, "item9 item9");
2349 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
2351 gtk_signal_connect (GTK_OBJECT (window), "destroy",
2352 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
2355 gtk_window_set_title (GTK_WINDOW (window), "entry");
2356 gtk_container_border_width (GTK_CONTAINER (window), 0);
2359 box1 = gtk_vbox_new (FALSE, 0);
2360 gtk_container_add (GTK_CONTAINER (window), box1);
2361 gtk_widget_show (box1);
2364 box2 = gtk_vbox_new (FALSE, 10);
2365 gtk_container_border_width (GTK_CONTAINER (box2), 10);
2366 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
2367 gtk_widget_show (box2);
2369 entry = gtk_entry_new ();
2370 gtk_entry_set_text (GTK_ENTRY (entry), "hello world");
2371 gtk_editable_select_region (GTK_EDITABLE (entry), 0, 5);
2372 gtk_box_pack_start (GTK_BOX (box2), entry, TRUE, TRUE, 0);
2373 gtk_widget_show (entry);
2375 cb = gtk_combo_new ();
2376 gtk_combo_set_popdown_strings (GTK_COMBO (cb), cbitems);
2377 gtk_entry_set_text (GTK_ENTRY (GTK_COMBO(cb)->entry), "hello world");
2378 gtk_editable_select_region (GTK_EDITABLE (GTK_COMBO(cb)->entry),
2380 gtk_box_pack_start (GTK_BOX (box2), cb, TRUE, TRUE, 0);
2381 gtk_widget_show (cb);
2383 editable_check = gtk_check_button_new_with_label("Editable");
2384 gtk_box_pack_start (GTK_BOX (box2), editable_check, FALSE, TRUE, 0);
2385 gtk_signal_connect (GTK_OBJECT(editable_check), "toggled",
2386 GTK_SIGNAL_FUNC(entry_toggle_editable), entry);
2387 gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(editable_check), TRUE);
2388 gtk_widget_show (editable_check);
2390 editable_check = gtk_check_button_new_with_label("Visible");
2391 gtk_box_pack_start (GTK_BOX (box2), editable_check, FALSE, TRUE, 0);
2392 gtk_signal_connect (GTK_OBJECT(editable_check), "toggled",
2393 GTK_SIGNAL_FUNC(entry_toggle_visibility), entry);
2394 gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(editable_check), TRUE);
2395 gtk_widget_show (editable_check);
2397 sensitive_check = gtk_check_button_new_with_label("Sensitive");
2398 gtk_box_pack_start (GTK_BOX (box2), sensitive_check, FALSE, TRUE, 0);
2399 gtk_signal_connect (GTK_OBJECT(sensitive_check), "toggled",
2400 GTK_SIGNAL_FUNC(entry_toggle_sensitive), entry);
2401 gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(sensitive_check), TRUE);
2402 gtk_widget_show (sensitive_check);
2404 separator = gtk_hseparator_new ();
2405 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
2406 gtk_widget_show (separator);
2409 box2 = gtk_vbox_new (FALSE, 10);
2410 gtk_container_border_width (GTK_CONTAINER (box2), 10);
2411 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
2412 gtk_widget_show (box2);
2415 button = gtk_button_new_with_label ("close");
2416 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
2417 GTK_SIGNAL_FUNC(gtk_widget_destroy),
2418 GTK_OBJECT (window));
2419 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
2420 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
2421 gtk_widget_grab_default (button);
2422 gtk_widget_show (button);
2425 if (!GTK_WIDGET_VISIBLE (window))
2426 gtk_widget_show (window);
2428 gtk_widget_destroy (window);
2435 static GtkWidget *spinner1;
2438 toggle_snap (GtkWidget *widget, GtkSpinButton *spin)
2440 gtk_spin_button_set_snap_to_ticks (spin, GTK_TOGGLE_BUTTON (widget)->active);
2444 toggle_numeric (GtkWidget *widget, GtkSpinButton *spin)
2446 gtk_spin_button_set_numeric (spin, GTK_TOGGLE_BUTTON (widget)->active);
2450 change_digits (GtkWidget *widget, GtkSpinButton *spin)
2452 gtk_spin_button_set_digits (GTK_SPIN_BUTTON (spinner1),
2453 gtk_spin_button_get_value_as_int (spin));
2457 get_value (GtkWidget *widget, gpointer data)
2461 GtkSpinButton *spin;
2463 spin = GTK_SPIN_BUTTON (spinner1);
2464 label = GTK_LABEL (gtk_object_get_user_data (GTK_OBJECT (widget)));
2465 if (GPOINTER_TO_INT (data) == 1)
2466 sprintf (buf, "%d", gtk_spin_button_get_value_as_int (spin));
2468 sprintf (buf, "%0.*f", spin->digits,
2469 gtk_spin_button_get_value_as_float (spin));
2470 gtk_label_set (label, buf);
2476 static GtkWidget *window = NULL;
2479 GtkWidget *main_vbox;
2482 GtkWidget *spinner2;
2486 GtkWidget *val_label;
2491 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
2493 gtk_signal_connect (GTK_OBJECT (window), "destroy",
2494 GTK_SIGNAL_FUNC (gtk_widget_destroyed),
2497 gtk_window_set_title (GTK_WINDOW (window), "GtkSpinButton");
2499 main_vbox = gtk_vbox_new (FALSE, 5);
2500 gtk_container_border_width (GTK_CONTAINER (main_vbox), 10);
2501 gtk_container_add (GTK_CONTAINER (window), main_vbox);
2503 frame = gtk_frame_new ("Not accelerated");
2504 gtk_box_pack_start (GTK_BOX (main_vbox), frame, TRUE, TRUE, 0);
2506 vbox = gtk_vbox_new (FALSE, 0);
2507 gtk_container_border_width (GTK_CONTAINER (vbox), 5);
2508 gtk_container_add (GTK_CONTAINER (frame), vbox);
2510 /* Day, month, year spinners */
2512 hbox = gtk_hbox_new (FALSE, 0);
2513 gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 5);
2515 vbox2 = gtk_vbox_new (FALSE, 0);
2516 gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 5);
2518 label = gtk_label_new ("Day :");
2519 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
2520 gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, TRUE, 0);
2522 adj = (GtkAdjustment *) gtk_adjustment_new (1.0, 1.0, 31.0, 1.0,
2524 spinner = gtk_spin_button_new (adj, 0, 0);
2525 gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spinner), TRUE);
2526 gtk_spin_button_set_shadow_type (GTK_SPIN_BUTTON (spinner),
2528 gtk_box_pack_start (GTK_BOX (vbox2), spinner, FALSE, TRUE, 0);
2530 vbox2 = gtk_vbox_new (FALSE, 0);
2531 gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 5);
2533 label = gtk_label_new ("Month :");
2534 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
2535 gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, TRUE, 0);
2537 adj = (GtkAdjustment *) gtk_adjustment_new (1.0, 1.0, 12.0, 1.0,
2539 spinner = gtk_spin_button_new (adj, 0, 0);
2540 gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spinner), TRUE);
2541 gtk_spin_button_set_shadow_type (GTK_SPIN_BUTTON (spinner),
2542 GTK_SHADOW_ETCHED_IN);
2543 gtk_box_pack_start (GTK_BOX (vbox2), spinner, FALSE, TRUE, 0);
2545 vbox2 = gtk_vbox_new (FALSE, 0);
2546 gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 5);
2548 label = gtk_label_new ("Year :");
2549 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
2550 gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, TRUE, 0);
2552 adj = (GtkAdjustment *) gtk_adjustment_new (1998.0, 0.0, 2100.0,
2554 spinner = gtk_spin_button_new (adj, 0, 0);
2555 gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spinner), TRUE);
2556 gtk_spin_button_set_shadow_type (GTK_SPIN_BUTTON (spinner),
2558 gtk_widget_set_usize (spinner, 55, 0);
2559 gtk_box_pack_start (GTK_BOX (vbox2), spinner, FALSE, TRUE, 0);
2561 frame = gtk_frame_new ("Accelerated");
2562 gtk_box_pack_start (GTK_BOX (main_vbox), frame, TRUE, TRUE, 0);
2564 vbox = gtk_vbox_new (FALSE, 0);
2565 gtk_container_border_width (GTK_CONTAINER (vbox), 5);
2566 gtk_container_add (GTK_CONTAINER (frame), vbox);
2568 hbox = gtk_hbox_new (FALSE, 0);
2569 gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 5);
2571 vbox2 = gtk_vbox_new (FALSE, 0);
2572 gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 5);
2574 label = gtk_label_new ("Value :");
2575 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
2576 gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, TRUE, 0);
2578 adj = (GtkAdjustment *) gtk_adjustment_new (0.0, -10000.0, 10000.0,
2580 spinner1 = gtk_spin_button_new (adj, 1.0, 2);
2581 gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spinner1), TRUE);
2582 gtk_widget_set_usize (spinner1, 100, 0);
2583 gtk_box_pack_start (GTK_BOX (vbox2), spinner1, FALSE, TRUE, 0);
2585 vbox2 = gtk_vbox_new (FALSE, 0);
2586 gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 5);
2588 label = gtk_label_new ("Digits :");
2589 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
2590 gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, TRUE, 0);
2592 adj = (GtkAdjustment *) gtk_adjustment_new (2, 1, 5, 1, 1, 0);
2593 spinner2 = gtk_spin_button_new (adj, 0.0, 0);
2594 gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spinner2), TRUE);
2595 gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
2596 GTK_SIGNAL_FUNC (change_digits),
2597 (gpointer) spinner2);
2598 gtk_box_pack_start (GTK_BOX (vbox2), spinner2, FALSE, TRUE, 0);
2600 hbox = gtk_hbox_new (FALSE, 0);
2601 gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 5);
2603 button = gtk_check_button_new_with_label ("Snap to 0.5-ticks");
2604 gtk_signal_connect (GTK_OBJECT (button), "clicked",
2605 GTK_SIGNAL_FUNC (toggle_snap),
2607 gtk_box_pack_start (GTK_BOX (vbox), button, TRUE, TRUE, 0);
2608 gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON (button), TRUE);
2610 button = gtk_check_button_new_with_label ("Numeric only input mode");
2611 gtk_signal_connect (GTK_OBJECT (button), "clicked",
2612 GTK_SIGNAL_FUNC (toggle_numeric),
2614 gtk_box_pack_start (GTK_BOX (vbox), button, TRUE, TRUE, 0);
2615 gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON (button), TRUE);
2617 val_label = gtk_label_new ("");
2619 hbox = gtk_hbox_new (FALSE, 0);
2620 gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 5);
2622 button = gtk_button_new_with_label ("Value as Int");
2623 gtk_object_set_user_data (GTK_OBJECT (button), val_label);
2624 gtk_signal_connect (GTK_OBJECT (button), "clicked",
2625 GTK_SIGNAL_FUNC (get_value),
2626 GINT_TO_POINTER (1));
2627 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
2629 button = gtk_button_new_with_label ("Value as Float");
2630 gtk_object_set_user_data (GTK_OBJECT (button), val_label);
2631 gtk_signal_connect (GTK_OBJECT (button), "clicked",
2632 GTK_SIGNAL_FUNC (get_value),
2633 GINT_TO_POINTER (2));
2634 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
2636 gtk_box_pack_start (GTK_BOX (vbox), val_label, TRUE, TRUE, 0);
2637 gtk_label_set (GTK_LABEL (val_label), "0");
2639 hbox = gtk_hbox_new (FALSE, 0);
2640 gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, TRUE, 0);
2642 button = gtk_button_new_with_label ("Close");
2643 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
2644 GTK_SIGNAL_FUNC (gtk_widget_destroy),
2645 GTK_OBJECT (window));
2646 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
2649 if (!GTK_WIDGET_VISIBLE (window))
2650 gtk_widget_show_all (window);
2652 gtk_widget_destroy (window);
2660 cursor_expose_event (GtkWidget *widget,
2664 GtkDrawingArea *darea;
2665 GdkDrawable *drawable;
2672 g_return_val_if_fail (widget != NULL, TRUE);
2673 g_return_val_if_fail (GTK_IS_DRAWING_AREA (widget), TRUE);
2675 darea = GTK_DRAWING_AREA (widget);
2676 drawable = widget->window;
2677 white_gc = widget->style->white_gc;
2678 gray_gc = widget->style->bg_gc[GTK_STATE_NORMAL];
2679 black_gc = widget->style->black_gc;
2680 max_width = widget->allocation.width;
2681 max_height = widget->allocation.height;
2683 gdk_draw_rectangle (drawable, white_gc,
2690 gdk_draw_rectangle (drawable, black_gc,
2697 gdk_draw_rectangle (drawable, gray_gc,
2708 set_cursor (GtkWidget *spinner,
2716 c = CLAMP (gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (spinner)), 0, 152);
2719 label = gtk_object_get_user_data (GTK_OBJECT (spinner));
2720 vals = gtk_type_enum_get_values (GTK_TYPE_GDK_CURSOR_TYPE);
2721 while (vals && vals->value != c)
2724 gtk_label_set (GTK_LABEL (label), vals->value_nick);
2726 gtk_label_set (GTK_LABEL (label), "<unknown>");
2728 cursor = gdk_cursor_new (c);
2729 gdk_window_set_cursor (widget->window, cursor);
2730 gdk_cursor_destroy (cursor);
2734 cursor_event (GtkWidget *widget,
2736 GtkSpinButton *spinner)
2738 if ((event->type == GDK_BUTTON_PRESS) &&
2739 ((event->button.button == 1) ||
2740 (event->button.button == 3)))
2742 gtk_spin_button_spin (spinner, event->button.button == 1 ?
2743 GTK_SPIN_STEP_FORWARD : GTK_SPIN_STEP_BACKWARD, 0);
2751 create_cursors (void)
2753 static GtkWidget *window = NULL;
2756 GtkWidget *main_vbox;
2767 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
2769 gtk_signal_connect (GTK_OBJECT (window), "destroy",
2770 GTK_SIGNAL_FUNC (gtk_widget_destroyed),
2773 gtk_window_set_title (GTK_WINDOW (window), "Cursors");
2775 main_vbox = gtk_vbox_new (FALSE, 5);
2776 gtk_container_border_width (GTK_CONTAINER (main_vbox), 0);
2777 gtk_container_add (GTK_CONTAINER (window), main_vbox);
2780 gtk_widget_new (gtk_vbox_get_type (),
2781 "GtkBox::homogeneous", FALSE,
2782 "GtkBox::spacing", 5,
2783 "GtkContainer::border_width", 10,
2784 "GtkWidget::parent", main_vbox,
2785 "GtkWidget::visible", TRUE,
2788 hbox = gtk_hbox_new (FALSE, 0);
2789 gtk_container_border_width (GTK_CONTAINER (hbox), 5);
2790 gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0);
2792 label = gtk_label_new ("Cursor Value:");
2793 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
2794 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
2796 adj = (GtkAdjustment *) gtk_adjustment_new (0,
2800 spinner = gtk_spin_button_new (adj, 0, 0);
2801 gtk_box_pack_start (GTK_BOX (hbox), spinner, TRUE, TRUE, 0);
2804 gtk_widget_new (gtk_frame_get_type (),
2805 "GtkFrame::shadow", GTK_SHADOW_ETCHED_IN,
2806 "GtkFrame::label_xalign", 0.5,
2807 "GtkFrame::label", "Cursor Area",
2808 "GtkContainer::border_width", 10,
2809 "GtkWidget::parent", vbox,
2810 "GtkWidget::visible", TRUE,
2813 darea = gtk_drawing_area_new ();
2814 gtk_widget_set_usize (darea, 80, 80);
2815 gtk_container_add (GTK_CONTAINER (frame), darea);
2816 gtk_signal_connect (GTK_OBJECT (darea),
2818 GTK_SIGNAL_FUNC (cursor_expose_event),
2820 gtk_widget_set_events (darea, GDK_EXPOSURE_MASK | GDK_BUTTON_PRESS_MASK);
2821 gtk_signal_connect (GTK_OBJECT (darea),
2822 "button_press_event",
2823 GTK_SIGNAL_FUNC (cursor_event),
2825 gtk_widget_show (darea);
2827 gtk_signal_connect (GTK_OBJECT (spinner), "changed",
2828 GTK_SIGNAL_FUNC (set_cursor),
2831 label = gtk_widget_new (GTK_TYPE_LABEL,
2836 gtk_container_child_set (GTK_CONTAINER (vbox), label,
2839 gtk_object_set_user_data (GTK_OBJECT (spinner), label);
2842 gtk_widget_new (gtk_hseparator_get_type (),
2843 "GtkWidget::visible", TRUE,
2845 gtk_box_pack_start (GTK_BOX (main_vbox), any, FALSE, TRUE, 0);
2847 hbox = gtk_hbox_new (FALSE, 0);
2848 gtk_container_border_width (GTK_CONTAINER (hbox), 10);
2849 gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, TRUE, 0);
2851 button = gtk_button_new_with_label ("Close");
2852 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
2853 GTK_SIGNAL_FUNC (gtk_widget_destroy),
2854 GTK_OBJECT (window));
2855 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
2857 gtk_widget_show_all (window);
2859 set_cursor (spinner, darea);
2862 gtk_widget_destroy (window);
2869 list_add (GtkWidget *widget,
2874 GtkWidget *list_item;
2876 sprintf (buffer, "added item %d", i++);
2877 list_item = gtk_list_item_new_with_label (buffer);
2878 gtk_widget_show (list_item);
2879 gtk_container_add (GTK_CONTAINER (list), list_item);
2883 list_remove (GtkWidget *widget,
2889 tmp_list = GTK_LIST (list)->selection;
2894 clear_list = g_list_prepend (clear_list, tmp_list->data);
2895 tmp_list = tmp_list->next;
2898 clear_list = g_list_reverse (clear_list);
2900 gtk_list_remove_items (GTK_LIST (list), clear_list);
2902 g_list_free (clear_list);
2906 list_clear (GtkWidget *widget,
2909 gtk_list_clear_items (GTK_LIST (list), 3 - 1, 6 - 1);
2915 static GtkWidget *window = NULL;
2916 static char *list_items[] =
2929 static int nlist_items = sizeof (list_items) / sizeof (list_items[0]);
2933 GtkWidget *scrolled_win;
2935 GtkWidget *list_item;
2937 GtkWidget *separator;
2942 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
2944 gtk_signal_connect (GTK_OBJECT (window), "destroy",
2945 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
2948 gtk_window_set_title (GTK_WINDOW (window), "list");
2949 gtk_container_border_width (GTK_CONTAINER (window), 0);
2952 box1 = gtk_vbox_new (FALSE, 0);
2953 gtk_container_add (GTK_CONTAINER (window), box1);
2954 gtk_widget_show (box1);
2957 box2 = gtk_vbox_new (FALSE, 10);
2958 gtk_container_border_width (GTK_CONTAINER (box2), 10);
2959 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
2960 gtk_widget_show (box2);
2963 scrolled_win = gtk_scrolled_window_new (NULL, NULL);
2964 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
2965 GTK_POLICY_AUTOMATIC,
2966 GTK_POLICY_AUTOMATIC);
2967 gtk_box_pack_start (GTK_BOX (box2), scrolled_win, TRUE, TRUE, 0);
2968 gtk_widget_show (scrolled_win);
2970 list = gtk_list_new ();
2971 gtk_list_set_selection_mode (GTK_LIST (list), GTK_SELECTION_MULTIPLE);
2972 gtk_list_set_selection_mode (GTK_LIST (list), GTK_SELECTION_BROWSE);
2973 gtk_container_add (GTK_CONTAINER (scrolled_win), list);
2974 gtk_container_set_focus_vadjustment (GTK_CONTAINER (list),
2975 gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (scrolled_win)));
2976 gtk_widget_show (list);
2978 for (i = 0; i < nlist_items; i++)
2980 list_item = gtk_list_item_new_with_label (list_items[i]);
2981 gtk_container_add (GTK_CONTAINER (list), list_item);
2982 gtk_widget_show (list_item);
2985 button = gtk_button_new_with_label ("add");
2986 GTK_WIDGET_UNSET_FLAGS (button, GTK_CAN_FOCUS);
2987 gtk_signal_connect (GTK_OBJECT (button), "clicked",
2988 GTK_SIGNAL_FUNC(list_add),
2990 gtk_box_pack_start (GTK_BOX (box2), button, FALSE, TRUE, 0);
2991 gtk_widget_show (button);
2993 button = gtk_button_new_with_label ("clear items 3 - 5");
2994 GTK_WIDGET_UNSET_FLAGS (button, GTK_CAN_FOCUS);
2995 gtk_signal_connect (GTK_OBJECT (button), "clicked",
2996 GTK_SIGNAL_FUNC(list_clear),
2998 gtk_box_pack_start (GTK_BOX (box2), button, FALSE, TRUE, 0);
2999 gtk_widget_show (button);
3001 button = gtk_button_new_with_label ("remove");
3002 GTK_WIDGET_UNSET_FLAGS (button, GTK_CAN_FOCUS);
3003 gtk_signal_connect (GTK_OBJECT (button), "clicked",
3004 GTK_SIGNAL_FUNC(list_remove),
3006 gtk_box_pack_start (GTK_BOX (box2), button, FALSE, TRUE, 0);
3007 gtk_widget_show (button);
3010 separator = gtk_hseparator_new ();
3011 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
3012 gtk_widget_show (separator);
3015 box2 = gtk_vbox_new (FALSE, 10);
3016 gtk_container_border_width (GTK_CONTAINER (box2), 10);
3017 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
3018 gtk_widget_show (box2);
3021 button = gtk_button_new_with_label ("close");
3022 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
3023 GTK_SIGNAL_FUNC(gtk_widget_destroy),
3024 GTK_OBJECT (window));
3025 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
3026 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
3027 gtk_widget_grab_default (button);
3028 gtk_widget_show (button);
3031 if (!GTK_WIDGET_VISIBLE (window))
3032 gtk_widget_show (window);
3034 gtk_widget_destroy (window);
3042 #define TESTGTK_CLIST_COLUMNS 20
3043 static gint clist_rows = 0;
3044 static GtkWidget *clist_omenu;
3047 add1000_clist (GtkWidget *widget, gpointer data)
3050 char text[TESTGTK_CLIST_COLUMNS][50];
3051 char *texts[TESTGTK_CLIST_COLUMNS];
3055 pixmap = gdk_pixmap_create_from_xpm (GTK_CLIST (data)->clist_window,
3057 >K_WIDGET (data)->style->white,
3060 for (i = 0; i < TESTGTK_CLIST_COLUMNS; i++)
3063 sprintf (text[i], "Column %d", i);
3067 sprintf (text[1], "Right");
3068 sprintf (text[2], "Center");
3070 gtk_clist_freeze (GTK_CLIST (data));
3071 for (i = 0; i < 1000; i++)
3073 sprintf (text[0], "Row %d", clist_rows++);
3074 row = gtk_clist_append (GTK_CLIST (data), texts);
3075 gtk_clist_set_pixtext (GTK_CLIST (data), row, 3, "Hello World", 5, pixmap, mask);
3077 gtk_clist_thaw (GTK_CLIST (data));
3079 gdk_pixmap_unref (pixmap);
3080 gdk_bitmap_unref (mask);
3084 add10000_clist (GtkWidget *widget, gpointer data)
3087 char text[TESTGTK_CLIST_COLUMNS][50];
3088 char *texts[TESTGTK_CLIST_COLUMNS];
3090 for (i = 0; i < TESTGTK_CLIST_COLUMNS; i++)
3093 sprintf (text[i], "Column %d", i);
3096 sprintf (text[1], "Right");
3097 sprintf (text[2], "Center");
3099 gtk_clist_freeze (GTK_CLIST (data));
3100 for (i = 0; i < 10000; i++)
3102 sprintf (text[0], "Row %d", clist_rows++);
3103 gtk_clist_append (GTK_CLIST (data), texts);
3105 gtk_clist_thaw (GTK_CLIST (data));
3109 clear_clist (GtkWidget *widget, gpointer data)
3111 gtk_clist_clear (GTK_CLIST (data));
3116 remove_row_clist (GtkWidget *widget, gpointer data)
3118 gtk_clist_remove (GTK_CLIST (data), GTK_CLIST (data)->focus_row);
3123 show_titles_clist (GtkWidget *widget, gpointer data)
3125 gtk_clist_column_titles_show (GTK_CLIST (data));
3129 hide_titles_clist (GtkWidget *widget, gpointer data)
3131 gtk_clist_column_titles_hide (GTK_CLIST (data));
3135 select_clist (GtkWidget *widget,
3138 GdkEventButton * bevent,
3148 g_print ("GtkCList Selection: row %d column %d button %d\n",
3149 row, column, bevent ? bevent->button : 0);
3151 for (i = 0; i < TESTGTK_CLIST_COLUMNS; i++)
3153 switch (gtk_clist_get_cell_type (GTK_CLIST (widget), row, i))
3156 g_print ("CELL %d GTK_CELL_TEXT\n", i);
3157 gtk_clist_get_text (GTK_CLIST (widget), row, i, &text);
3158 g_print ("TEXT: %s\n", text);
3161 case GTK_CELL_PIXMAP:
3162 g_print ("CELL %d GTK_CELL_PIXMAP\n", i);
3163 gtk_clist_get_pixmap (GTK_CLIST (widget), row, i, &pixmap, &mask);
3164 g_print ("PIXMAP: %p\n", pixmap);
3165 g_print ("MASK: %p\n", mask);
3168 case GTK_CELL_PIXTEXT:
3169 g_print ("CELL %d GTK_CELL_PIXTEXT\n", i);
3170 gtk_clist_get_pixtext (GTK_CLIST (widget), row, i, &text, &spacing, &pixmap, &mask);
3171 g_print ("TEXT: %s\n", text);
3172 g_print ("SPACING: %d\n", spacing);
3173 g_print ("PIXMAP: %p\n", pixmap);
3174 g_print ("MASK: %p\n", mask);
3182 /* print selections list */
3183 g_print ("\nSelected Rows:");
3184 list = GTK_CLIST (widget)->selection;
3187 g_print (" %d ", GPOINTER_TO_INT (list->data));
3195 unselect_clist (GtkWidget *widget,
3198 GdkEventButton * bevent,
3208 g_print ("GtkCList Unselection: row %d column %d button %d\n",
3209 row, column, bevent ? bevent->button : 0);
3211 for (i = 0; i < TESTGTK_CLIST_COLUMNS; i++)
3213 switch (gtk_clist_get_cell_type (GTK_CLIST (widget), row, i))
3216 g_print ("CELL %d GTK_CELL_TEXT\n", i);
3217 gtk_clist_get_text (GTK_CLIST (widget), row, i, &text);
3218 g_print ("TEXT: %s\n", text);
3221 case GTK_CELL_PIXMAP:
3222 g_print ("CELL %d GTK_CELL_PIXMAP\n", i);
3223 gtk_clist_get_pixmap (GTK_CLIST (widget), row, i, &pixmap, &mask);
3224 g_print ("PIXMAP: %p\n", pixmap);
3225 g_print ("MASK: %p\n", mask);
3228 case GTK_CELL_PIXTEXT:
3229 g_print ("CELL %d GTK_CELL_PIXTEXT\n", i);
3230 gtk_clist_get_pixtext (GTK_CLIST (widget), row, i, &text, &spacing, &pixmap, &mask);
3231 g_print ("TEXT: %s\n", text);
3232 g_print ("SPACING: %d\n", spacing);
3233 g_print ("PIXMAP: %p\n", pixmap);
3234 g_print ("MASK: %p\n", mask);
3242 /* print selections list */
3243 g_print ("\nSelected Rows:");
3244 list = GTK_CLIST (widget)->selection;
3247 g_print (" %d ", GPOINTER_TO_INT (list->data));
3255 insert_row_clist (GtkWidget *widget, gpointer data)
3257 static char *text[] =
3259 "This", "is", "a", "inserted", "row.",
3260 "This", "is", "a", "inserted", "row.",
3261 "This", "is", "a", "inserted", "row.",
3262 "This", "is", "a", "inserted", "row."
3265 gtk_clist_insert (GTK_CLIST (data), GTK_CLIST (data)->focus_row, text);
3271 clist_warning_test (GtkWidget *button,
3275 static gboolean add_remove = FALSE;
3277 add_remove = !add_remove;
3279 child = gtk_label_new ("Test");
3280 gtk_widget_ref (child);
3281 gtk_object_sink (GTK_OBJECT (child));
3284 gtk_container_add (GTK_CONTAINER (clist), child);
3287 child->parent = clist;
3288 gtk_container_remove (GTK_CONTAINER (clist), child);
3289 child->parent = NULL;
3292 gtk_widget_destroy (child);
3293 gtk_widget_unref (child);
3297 undo_selection (GtkWidget *button, GtkCList *clist)
3299 gtk_clist_undo_selection (clist);
3302 #define RADIOMENUTOGGLED(_rmi_, __i) { \
3305 __g = gtk_radio_menu_item_group(_rmi_); \
3306 while( __g && !((GtkCheckMenuItem *)(__g->data))->active) { \
3313 clist_toggle_sel_mode (GtkWidget *widget, GtkCList *clist)
3317 if (!GTK_WIDGET_MAPPED (widget))
3320 RADIOMENUTOGGLED ((GtkRadioMenuItem *)
3321 (((GtkOptionMenu *)clist_omenu)->menu_item), i);
3323 gtk_clist_set_selection_mode (clist, (GtkSelectionMode) (3-i));
3330 static GtkWidget *window = NULL;
3332 static char *titles[] =
3356 char text[TESTGTK_CLIST_COLUMNS][50];
3357 char *texts[TESTGTK_CLIST_COLUMNS];
3363 GtkWidget *separator;
3365 GtkWidget *undo_button;
3368 GtkWidget *menu_item;
3374 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
3376 gtk_signal_connect (GTK_OBJECT (window), "destroy",
3377 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
3380 gtk_window_set_title (GTK_WINDOW (window), "clist");
3381 gtk_container_border_width (GTK_CONTAINER (window), 0);
3383 box1 = gtk_vbox_new (FALSE, 0);
3384 gtk_container_add (GTK_CONTAINER (window), box1);
3386 box2 = gtk_hbox_new (FALSE, 10);
3387 gtk_container_border_width (GTK_CONTAINER (box2), 10);
3388 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0);
3390 /* create GtkCList here so we have a pointer to throw at the
3391 * button callbacks -- more is done with it later */
3392 clist = gtk_clist_new_with_titles (TESTGTK_CLIST_COLUMNS, titles);
3393 /*clist = gtk_clist_new (TESTGTK_CLIST_COLUMNS);*/
3395 /* control buttons */
3396 button = gtk_button_new_with_label ("Add 1,000 Rows With Pixmaps");
3397 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
3399 gtk_signal_connect (GTK_OBJECT (button),
3401 (GtkSignalFunc) add1000_clist,
3404 button = gtk_button_new_with_label ("Add 10,000 Rows");
3405 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
3407 gtk_signal_connect (GTK_OBJECT (button),
3409 (GtkSignalFunc) add10000_clist,
3412 button = gtk_button_new_with_label ("Clear List");
3413 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
3415 gtk_signal_connect (GTK_OBJECT (button),
3417 (GtkSignalFunc) clear_clist,
3420 button = gtk_button_new_with_label ("Remove Row");
3421 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
3423 gtk_signal_connect (GTK_OBJECT (button),
3425 (GtkSignalFunc) remove_row_clist,
3428 /* second layer of buttons */
3429 box2 = gtk_hbox_new (FALSE, 10);
3430 gtk_container_border_width (GTK_CONTAINER (box2), 10);
3431 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0);
3433 button = gtk_button_new_with_label ("Insert Row");
3434 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
3436 gtk_signal_connect (GTK_OBJECT (button),
3438 (GtkSignalFunc) insert_row_clist,
3441 button = gtk_button_new_with_label ("Show Title Buttons");
3442 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
3444 gtk_signal_connect (GTK_OBJECT (button),
3446 (GtkSignalFunc) show_titles_clist,
3449 button = gtk_button_new_with_label ("Hide Title Buttons");
3450 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
3452 gtk_signal_connect (GTK_OBJECT (button),
3454 (GtkSignalFunc) hide_titles_clist,
3457 button = gtk_button_new_with_label ("Warning Test");
3458 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
3460 gtk_signal_connect (GTK_OBJECT (button),
3462 (GtkSignalFunc) clist_warning_test,
3465 box2 = gtk_hbox_new (FALSE, 10);
3466 gtk_container_border_width (GTK_CONTAINER (box2), 10);
3467 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0);
3469 undo_button = gtk_button_new_with_label ("Undo last selection");
3470 gtk_box_pack_start (GTK_BOX (box2), undo_button, TRUE, TRUE, 0);
3471 gtk_signal_connect (GTK_OBJECT (undo_button),
3473 (GtkSignalFunc) undo_selection,
3476 label = gtk_label_new ("Selection Mode :");
3477 gtk_box_pack_start (GTK_BOX (box2), label, FALSE, TRUE, 0);
3479 clist_omenu = gtk_option_menu_new ();
3481 menu = gtk_menu_new ();
3484 menu_item = gtk_radio_menu_item_new_with_label (group, "Single");
3485 gtk_signal_connect (GTK_OBJECT (menu_item), "activate",
3486 GTK_SIGNAL_FUNC (clist_toggle_sel_mode), clist);
3487 group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menu_item));
3488 gtk_menu_append (GTK_MENU (menu), menu_item);
3489 gtk_widget_show (menu_item);
3491 menu_item = gtk_radio_menu_item_new_with_label (group, "Browse");
3492 gtk_signal_connect (GTK_OBJECT (menu_item), "activate",
3493 GTK_SIGNAL_FUNC (clist_toggle_sel_mode), clist);
3494 group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menu_item));
3495 gtk_menu_append (GTK_MENU (menu), menu_item);
3496 gtk_widget_show (menu_item);
3498 menu_item = gtk_radio_menu_item_new_with_label (group, "Multiple");
3499 gtk_signal_connect (GTK_OBJECT (menu_item), "activate",
3500 GTK_SIGNAL_FUNC (clist_toggle_sel_mode), clist);
3501 group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menu_item));
3502 gtk_menu_append (GTK_MENU (menu), menu_item);
3503 gtk_widget_show (menu_item);
3505 menu_item = gtk_radio_menu_item_new_with_label (group, "Extended");
3506 gtk_signal_connect (GTK_OBJECT (menu_item), "activate",
3507 GTK_SIGNAL_FUNC (clist_toggle_sel_mode), clist);
3508 group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menu_item));
3509 gtk_menu_append (GTK_MENU (menu), menu_item);
3510 gtk_check_menu_item_set_state (GTK_CHECK_MENU_ITEM (menu_item), TRUE);
3511 gtk_widget_show (menu_item);
3513 gtk_option_menu_set_menu (GTK_OPTION_MENU (clist_omenu), menu);
3514 gtk_box_pack_start (GTK_BOX (box2), clist_omenu, FALSE, TRUE, 0);
3516 gtk_option_menu_set_history (GTK_OPTION_MENU (clist_omenu), 3);
3518 /* vbox for the list itself */
3519 box2 = gtk_vbox_new (FALSE, 10);
3520 gtk_container_border_width (GTK_CONTAINER (box2), 10);
3521 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
3524 * the rest of the clist configuration
3528 gtk_signal_connect (GTK_OBJECT (clist),
3530 (GtkSignalFunc) select_clist,
3533 gtk_signal_connect (GTK_OBJECT (clist),
3535 (GtkSignalFunc) unselect_clist,
3539 gtk_clist_set_row_height (GTK_CLIST (clist), 18);
3540 gtk_widget_set_usize (clist, -1, 300);
3542 gtk_clist_set_column_width (GTK_CLIST (clist), 0, 100);
3544 for (i = 1; i < TESTGTK_CLIST_COLUMNS; i++)
3545 gtk_clist_set_column_width (GTK_CLIST (clist), i, 80);
3547 gtk_clist_set_selection_mode (GTK_CLIST (clist), GTK_SELECTION_EXTENDED);
3548 gtk_clist_set_policy (GTK_CLIST (clist), GTK_POLICY_AUTOMATIC,
3549 GTK_POLICY_AUTOMATIC);
3551 gtk_clist_set_column_justification (GTK_CLIST (clist), 1,
3553 gtk_clist_set_column_justification (GTK_CLIST (clist), 2,
3554 GTK_JUSTIFY_CENTER);
3556 for (i = 0; i < TESTGTK_CLIST_COLUMNS; i++)
3559 sprintf (text[i], "Column %d", i);
3562 sprintf (text[1], "Right");
3563 sprintf (text[2], "Center");
3565 for (i = 0; i < 10; i++)
3567 sprintf (text[0], "Row %d", clist_rows++);
3568 gtk_clist_append (GTK_CLIST (clist), texts);
3571 gtk_container_border_width (GTK_CONTAINER (clist), 5);
3572 gtk_box_pack_start (GTK_BOX (box2), clist, TRUE, TRUE, 0);
3574 separator = gtk_hseparator_new ();
3575 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
3577 box2 = gtk_vbox_new (FALSE, 10);
3578 gtk_container_border_width (GTK_CONTAINER (box2), 10);
3579 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
3581 button = gtk_button_new_with_label ("close");
3582 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
3583 GTK_SIGNAL_FUNC(gtk_widget_destroy),
3584 GTK_OBJECT (window));
3586 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
3587 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
3588 gtk_widget_grab_default (button);
3591 if (!GTK_WIDGET_VISIBLE (window))
3592 gtk_widget_show_all (window);
3596 gtk_widget_destroy (window);
3604 static char * book_open_xpm[] = {
3627 static char * book_closed_xpm[] = {
3652 static char * mini_page_xpm[] = {
3682 static gint books = 0;
3683 static gint pages = 0;
3685 static GtkWidget *book_label;
3686 static GtkWidget *page_label;
3687 static GtkWidget *sel_label;
3688 static GtkWidget *vis_label;
3689 static GtkWidget *omenu;
3690 static GtkWidget *omenu2;
3691 static GtkWidget *omenu3;
3692 static GtkWidget *spin1;
3693 static GtkWidget *spin2;
3694 static GtkWidget *spin3;
3695 static GdkColor *col_bg;
3697 void after_press (GtkCTree *ctree, gpointer data)
3701 sprintf (buf, "%d", g_list_length (GTK_CLIST (ctree)->selection));
3702 gtk_label_set (GTK_LABEL (sel_label), buf);
3704 sprintf (buf, "%d", g_list_length (GTK_CLIST (ctree)->row_list));
3705 gtk_label_set (GTK_LABEL (vis_label), buf);
3707 sprintf (buf, "%d", books);
3708 gtk_label_set (GTK_LABEL (book_label), buf);
3710 sprintf (buf, "%d", pages);
3711 gtk_label_set (GTK_LABEL (page_label), buf);
3714 void after_move (GtkCTree *ctree, GList *child, GList *parent,
3715 GList *sibling, gpointer data)
3721 gtk_ctree_get_node_info (ctree, child, &source,
3722 NULL, NULL, NULL, NULL, NULL, NULL, NULL);
3724 gtk_ctree_get_node_info (ctree, parent, &target1,
3725 NULL, NULL, NULL, NULL, NULL, NULL, NULL);
3727 gtk_ctree_get_node_info (ctree, sibling, &target2,
3728 NULL, NULL, NULL, NULL, NULL, NULL, NULL);
3730 g_print ("Moving \"%s\" to \"%s\" with sibling \"%s\".\n", source,
3731 (parent) ? target1 : "nil", (sibling) ? target2 : "nil");
3734 gint button_press (GtkCTree *ctree, GdkEventButton *event, gpointer data)
3741 res = gtk_clist_get_selection_info (GTK_CLIST (ctree), event->x, event->y,
3743 if (!res && event->button != 3)
3746 work = g_list_nth (GTK_CLIST (ctree)->row_list, row);
3748 switch (event->button)
3751 if (GTK_CLIST (ctree)->selection_mode == GTK_SELECTION_MULTIPLE &&
3752 event->state & GDK_SHIFT_MASK)
3753 gtk_signal_emit_stop_by_name (GTK_OBJECT (ctree),"button_press_event");
3756 if (GTK_CTREE_ROW (work)->children &&
3757 gtk_ctree_is_hot_spot (ctree, event->x, event->y))
3759 if (GTK_CTREE_ROW (work)->expanded)
3760 gtk_ctree_collapse_recursive (ctree, work);
3762 gtk_ctree_expand_recursive (ctree, work);
3763 after_press (ctree, NULL);
3764 gtk_signal_emit_stop_by_name (GTK_OBJECT (ctree),
3765 "button_press_event");
3774 gint button_release (GtkCTree *ctree, GdkEventButton *event, gpointer data)
3781 res = gtk_clist_get_selection_info (GTK_CLIST (ctree), event->x, event->y,
3783 if (!res || event->button != 1)
3786 work = g_list_nth (GTK_CLIST (ctree)->row_list, row);
3788 if (GTK_CLIST (ctree)->selection_mode == GTK_SELECTION_MULTIPLE &&
3789 event->state & GDK_SHIFT_MASK)
3791 if (GTK_CTREE_ROW (work)->row.state == GTK_STATE_SELECTED)
3792 gtk_ctree_unselect_recursive (ctree, work);
3794 gtk_ctree_select_recursive (ctree, work);
3795 after_press (ctree, NULL);
3796 gtk_signal_emit_stop_by_name (GTK_OBJECT (ctree),
3797 "button_release_event");
3802 void count_items (GtkCTree *ctree, GList *list)
3804 if (GTK_CTREE_ROW (list)->is_leaf)
3810 void expand_all (GtkWidget *widget, GtkCTree *ctree)
3812 gtk_ctree_expand_recursive (ctree, NULL);
3813 after_press (ctree, NULL);
3816 void collapse_all (GtkWidget *widget, GtkCTree *ctree)
3818 gtk_ctree_collapse_recursive (ctree, NULL);
3819 after_press (ctree, NULL);
3822 void select_all (GtkWidget *widget, GtkCTree *ctree)
3824 gtk_ctree_select_recursive (ctree, NULL);
3825 after_press (ctree, NULL);
3828 void unselect_all (GtkWidget *widget, GtkCTree *ctree)
3830 gtk_ctree_unselect_recursive (ctree, NULL);
3831 after_press (ctree, NULL);
3834 void remove_selection (GtkWidget *widget, GtkCTree *ctree)
3840 selection = GTK_CLIST (ctree)->selection;
3843 gtk_clist_freeze (GTK_CLIST (ctree));
3847 work = selection->data;
3848 if (GTK_CTREE_ROW (work)->is_leaf)
3851 gtk_ctree_post_recursive (ctree, work,
3852 (GtkCTreeFunc) count_items, NULL);
3854 if (GTK_CLIST (ctree)->selection_mode == GTK_SELECTION_BROWSE)
3856 if (GTK_CTREE_ROW (work)->children)
3858 new_sel = GTK_CTREE_ROW (work)->sibling;
3860 new_sel = work->prev;
3865 new_sel = work->next;
3867 new_sel = work->prev;
3871 gtk_ctree_remove (ctree, work);
3872 selection = GTK_CLIST (ctree)->selection;
3876 gtk_ctree_select (ctree, new_sel);
3878 gtk_clist_thaw (GTK_CLIST (ctree));
3879 after_press (ctree, NULL);
3882 void sort_all (GtkWidget *widget, GtkCTree *ctree)
3884 gtk_ctree_sort_recursive (ctree, NULL);
3887 void change_indent (GtkWidget *widget, GtkCTree *ctree)
3889 gtk_ctree_set_indent (ctree, GTK_ADJUSTMENT (widget)->value);
3892 void change_row_height (GtkWidget *widget, GtkCList *clist)
3894 gtk_clist_set_row_height (clist, GTK_ADJUSTMENT (widget)->value);
3897 void toggle_reorderable (GtkWidget *widget, GtkCTree *ctree)
3899 gtk_ctree_set_reorderable (ctree, GTK_TOGGLE_BUTTON (widget)->active);
3902 void set_background (GtkCTree *ctree, GList *node, gpointer data)
3907 if (ctree->line_style != GTK_CTREE_LINES_TABBED)
3909 if (GTK_CTREE_ROW (node)->is_leaf)
3910 gtk_ctree_set_background
3912 GTK_CTREE_ROW (GTK_CTREE_ROW (node)->parent)->row.data);
3914 gtk_ctree_set_background (ctree, node, GTK_CTREE_ROW (node)->row.data);
3917 gtk_ctree_set_background (ctree, node, NULL);
3920 void toggle_line_style (GtkWidget *widget, GtkCTree *ctree)
3924 if (!GTK_WIDGET_MAPPED (widget))
3927 RADIOMENUTOGGLED ((GtkRadioMenuItem *)
3928 (((GtkOptionMenu *)omenu2)->menu_item),i);
3930 if ((ctree->line_style == GTK_CTREE_LINES_TABBED &&
3931 ((GtkCTreeLineStyle) (3-i)) != GTK_CTREE_LINES_TABBED) ||
3932 (ctree->line_style != GTK_CTREE_LINES_TABBED &&
3933 ((GtkCTreeLineStyle) (3-i)) == GTK_CTREE_LINES_TABBED))
3934 gtk_ctree_pre_recursive (ctree, GTK_CLIST (ctree)->row_list,
3935 set_background, NULL);
3936 gtk_ctree_set_line_style (ctree, (GtkCTreeLineStyle) (3-i));
3939 void toggle_justify (GtkWidget *widget, GtkCTree *ctree)
3943 if (!GTK_WIDGET_MAPPED (widget))
3946 RADIOMENUTOGGLED ((GtkRadioMenuItem *)
3947 (((GtkOptionMenu *)omenu3)->menu_item),i);
3949 gtk_clist_set_column_justification (GTK_CLIST (ctree), ctree->tree_column,
3950 (GtkJustification) (1-i));
3953 void toggle_sel_mode (GtkWidget *widget, GtkCTree *ctree)
3957 if (!GTK_WIDGET_MAPPED (widget))
3960 RADIOMENUTOGGLED ((GtkRadioMenuItem *)
3961 (((GtkOptionMenu *)omenu)->menu_item), i);
3963 gtk_clist_set_selection_mode (GTK_CLIST (ctree), (GtkSelectionMode) (3-i));
3964 after_press (ctree, NULL);
3967 void build_recursive (GtkCTree *ctree, gint cur_depth, gint depth,
3968 gint num_books, gint num_pages, GList *parent)
3980 for (i = num_pages + num_books; i > num_books; i--)
3983 sprintf (buf1, "Page %02d", (gint) rand() % 100);
3984 sprintf (buf2, "Item %d-%d", cur_depth, i);
3985 sibling = gtk_ctree_insert (ctree, parent, sibling, text, 5, pixmap3,
3986 mask3, NULL, NULL, TRUE, FALSE);
3988 if (ctree->line_style == GTK_CTREE_LINES_TABBED)
3989 gtk_ctree_set_background (ctree, sibling, col_bg);
3992 if (cur_depth == depth)
3995 for (i = num_books; i > 0; i--)
3998 sprintf (buf1, "Book %02d", (gint) rand() % 100);
3999 sprintf (buf2, "Item %d-%d", cur_depth, i);
4000 sibling = gtk_ctree_insert (ctree, parent, sibling, text, 5, pixmap1,
4001 mask1, pixmap2, mask2, FALSE, FALSE);
4003 col_bg = g_new (GdkColor, 1);
4005 if (cur_depth % 3 == 0)
4007 col_bg->red = 10000 * (cur_depth % 6);
4009 col_bg->blue = 65535 - ((i * 10000) % 65535);
4011 else if (cur_depth % 3 == 1)
4013 col_bg->red = 10000 * (cur_depth % 6);
4014 col_bg->green = 65535 - ((i * 10000) % 65535);
4019 col_bg->red = 65535 - ((i * 10000) % 65535);
4021 col_bg->blue = 10000 * (cur_depth % 6);
4024 gdk_color_alloc (gtk_widget_get_colormap (GTK_WIDGET (ctree)), col_bg);
4025 gtk_ctree_set_row_data_full (ctree, sibling, col_bg, g_free);
4027 if (ctree->line_style == GTK_CTREE_LINES_TABBED)
4028 gtk_ctree_set_background (ctree, sibling, col_bg);
4030 build_recursive (ctree, cur_depth + 1, depth, num_books, num_pages,
4035 void rebuild_tree (GtkWidget *widget, GtkCTree *ctree)
4038 gchar label1[] = "Root";
4039 gchar label2[] = "";
4046 d = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (spin1));
4047 b = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (spin2));
4048 p = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (spin3));
4050 n = ((pow (b, d) - 1) / (b - 1)) * (p + 1);
4054 g_print ("%d total items? Try less\n",n);
4058 gtk_clist_freeze (GTK_CLIST (ctree));
4059 gtk_clist_clear (GTK_CLIST (ctree));
4064 parent = gtk_ctree_insert (ctree, NULL, NULL, text, 5, pixmap1,
4065 mask1, pixmap2, mask2, FALSE, TRUE);
4067 col_bg = g_new (GdkColor, 1);
4069 col_bg->green = 45000;
4070 col_bg->blue = 55000;
4071 gdk_color_alloc (gtk_widget_get_colormap (GTK_WIDGET (ctree)), col_bg);
4072 gtk_ctree_set_row_data_full (ctree, parent, col_bg, g_free);
4073 if (ctree->line_style == GTK_CTREE_LINES_TABBED)
4074 gtk_ctree_set_background (ctree, parent, col_bg);
4076 build_recursive (ctree, 1, d, b, p, parent);
4077 gtk_clist_thaw (GTK_CLIST (ctree));
4078 after_press (ctree, NULL);
4081 void create_ctree (void)
4083 static GtkWidget *window = NULL;
4084 GtkTooltips *tooltips;
4092 GtkWidget *menu_item;
4099 GdkColor transparent;
4101 char *title[] = { "Tree" , "Info" };
4106 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
4108 gtk_signal_connect (GTK_OBJECT (window), "destroy",
4109 GTK_SIGNAL_FUNC (gtk_widget_destroyed),
4112 gtk_window_set_title (GTK_WINDOW (window), "GtkCTree");
4113 gtk_container_border_width (GTK_CONTAINER (window), 0);
4115 tooltips = gtk_tooltips_new ();
4116 gtk_object_ref (GTK_OBJECT (tooltips));
4117 gtk_object_sink (GTK_OBJECT (tooltips));
4119 gtk_object_set_data_full (GTK_OBJECT (window), "tooltips", tooltips,
4120 (GtkDestroyNotify) gtk_object_unref);
4122 vbox = gtk_vbox_new (FALSE, 0);
4123 gtk_container_add (GTK_CONTAINER (window), vbox);
4125 hbox = gtk_hbox_new (FALSE, 5);
4126 gtk_container_border_width (GTK_CONTAINER (hbox), 5);
4127 gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0);
4129 label = gtk_label_new ("Depth :");
4130 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
4132 adj = (GtkAdjustment *) gtk_adjustment_new (4, 1, 10, 1, 5, 0);
4133 spin1 = gtk_spin_button_new (adj, 0, 0);
4134 gtk_box_pack_start (GTK_BOX (hbox), spin1, FALSE, TRUE, 5);
4136 label = gtk_label_new ("Books :");
4137 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
4139 adj = (GtkAdjustment *) gtk_adjustment_new (3, 1, 20, 1, 5, 0);
4140 spin2 = gtk_spin_button_new (adj, 0, 0);
4141 gtk_box_pack_start (GTK_BOX (hbox), spin2, FALSE, TRUE, 5);
4143 label = gtk_label_new ("Pages :");
4144 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
4146 adj = (GtkAdjustment *) gtk_adjustment_new (5, 1, 20, 1, 5, 0);
4147 spin3 = gtk_spin_button_new (adj, 0, 0);
4148 gtk_box_pack_start (GTK_BOX (hbox), spin3, FALSE, TRUE, 5);
4150 button = gtk_button_new_with_label ("Close");
4151 gtk_box_pack_end (GTK_BOX (hbox), button, TRUE, TRUE, 0);
4153 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
4154 (GtkSignalFunc) gtk_widget_destroy,
4155 GTK_OBJECT(window));
4157 button = gtk_button_new_with_label ("Rebuild tree");
4158 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
4160 ctree = GTK_CTREE (gtk_ctree_new_with_titles (2, 0, title));
4161 gtk_ctree_set_line_style (ctree, GTK_CTREE_LINES_DOTTED);
4162 gtk_ctree_set_reorderable (ctree, TRUE);
4163 gtk_signal_connect (GTK_OBJECT (ctree), "button_press_event",
4164 GTK_SIGNAL_FUNC (button_press), NULL);
4165 gtk_signal_connect_after (GTK_OBJECT (ctree), "button_press_event",
4166 GTK_SIGNAL_FUNC (after_press), NULL);
4167 gtk_signal_connect (GTK_OBJECT (ctree), "button_release_event",
4168 GTK_SIGNAL_FUNC (button_release), NULL);
4169 gtk_signal_connect_after (GTK_OBJECT (ctree), "button_release_event",
4170 GTK_SIGNAL_FUNC (after_press), NULL);
4171 gtk_signal_connect_after (GTK_OBJECT (ctree), "tree_move",
4172 GTK_SIGNAL_FUNC (after_move), NULL);
4173 gtk_signal_connect_after (GTK_OBJECT (ctree), "end_selection",
4174 GTK_SIGNAL_FUNC (after_press), NULL);
4175 gtk_signal_connect_after (GTK_OBJECT (ctree), "toggle_focus_row",
4176 GTK_SIGNAL_FUNC (after_press), NULL);
4177 gtk_signal_connect_after (GTK_OBJECT (ctree), "select_all",
4178 GTK_SIGNAL_FUNC (after_press), NULL);
4179 gtk_signal_connect_after (GTK_OBJECT (ctree), "unselect_all",
4180 GTK_SIGNAL_FUNC (after_press), NULL);
4181 gtk_signal_connect_after (GTK_OBJECT (ctree), "scroll_vertical",
4182 GTK_SIGNAL_FUNC (after_press), NULL);
4184 gtk_box_pack_start (GTK_BOX (vbox), GTK_WIDGET (ctree), TRUE, TRUE, 0);
4185 gtk_clist_column_titles_passive (GTK_CLIST (ctree));
4186 gtk_clist_set_selection_mode (GTK_CLIST (ctree), GTK_SELECTION_EXTENDED);
4187 gtk_clist_set_policy (GTK_CLIST (ctree), GTK_POLICY_ALWAYS,
4188 GTK_POLICY_AUTOMATIC);
4189 gtk_clist_set_column_width (GTK_CLIST (ctree), 0, 200);
4190 gtk_clist_set_column_width (GTK_CLIST (ctree), 1, 200);
4192 gtk_signal_connect (GTK_OBJECT (button), "clicked",
4193 GTK_SIGNAL_FUNC (rebuild_tree), ctree);
4195 hbox = gtk_hbox_new (FALSE, 5);
4196 gtk_container_border_width (GTK_CONTAINER (hbox), 5);
4197 gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0);
4199 button = gtk_button_new_with_label ("Expand all");
4200 gtk_signal_connect (GTK_OBJECT (button), "clicked",
4201 GTK_SIGNAL_FUNC (expand_all), ctree);
4202 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
4204 button = gtk_button_new_with_label ("Collapse all");
4205 gtk_signal_connect (GTK_OBJECT (button), "clicked",
4206 GTK_SIGNAL_FUNC (collapse_all), ctree);
4207 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
4209 button = gtk_button_new_with_label ("Sort tree");
4210 gtk_signal_connect (GTK_OBJECT (button), "clicked",
4211 GTK_SIGNAL_FUNC (sort_all), ctree);
4212 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
4214 hbox = gtk_hbox_new (FALSE, 5);
4215 gtk_container_border_width (GTK_CONTAINER (hbox), 5);
4216 gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0);
4218 label = gtk_label_new ("Row height :");
4219 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
4221 adj = (GtkAdjustment *) gtk_adjustment_new (20, 12, 100, 1, 10, 0);
4222 spinner = gtk_spin_button_new (adj, 0, 0);
4223 gtk_tooltips_set_tip (tooltips, spinner,
4224 "Row height of list items", NULL);
4225 gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
4226 GTK_SIGNAL_FUNC (change_row_height), ctree);
4227 gtk_box_pack_start (GTK_BOX (hbox), spinner, FALSE, TRUE, 5);
4228 gtk_clist_set_row_height ( GTK_CLIST (ctree), adj->value);
4230 button = gtk_button_new_with_label ("Select all");
4231 gtk_signal_connect (GTK_OBJECT (button), "clicked",
4232 GTK_SIGNAL_FUNC (select_all), ctree);
4233 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
4235 button = gtk_button_new_with_label ("Unselect all");
4236 gtk_signal_connect (GTK_OBJECT (button), "clicked",
4237 GTK_SIGNAL_FUNC (unselect_all), ctree);
4238 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
4240 button = gtk_button_new_with_label ("Remove selection");
4241 gtk_signal_connect (GTK_OBJECT (button), "clicked",
4242 GTK_SIGNAL_FUNC (remove_selection), ctree);
4243 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
4245 hbox = gtk_hbox_new (TRUE, 5);
4246 gtk_container_border_width (GTK_CONTAINER (hbox), 5);
4247 gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0);
4249 hbox2 = gtk_hbox_new (FALSE, 0);
4250 gtk_box_pack_start (GTK_BOX (hbox), hbox2, FALSE, TRUE, 0);
4252 label = gtk_label_new ("Indent :");
4253 gtk_box_pack_start (GTK_BOX (hbox2), label, FALSE, TRUE, 0);
4255 adj = (GtkAdjustment *) gtk_adjustment_new (20, 0, 60, 1, 10, 0);
4256 spinner = gtk_spin_button_new (adj, 0, 0);
4257 gtk_tooltips_set_tip (tooltips, spinner, "Tree indentation.", NULL);
4258 gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
4259 GTK_SIGNAL_FUNC (change_indent), ctree);
4260 gtk_box_pack_start (GTK_BOX (hbox2), spinner, FALSE, TRUE, 5);
4262 check = gtk_check_button_new_with_label ("Reorderable");
4263 gtk_tooltips_set_tip (tooltips, check,
4264 "Tree items can be reordered by dragging.", NULL);
4265 gtk_signal_connect (GTK_OBJECT (check), "clicked",
4266 GTK_SIGNAL_FUNC (toggle_reorderable), ctree);
4267 gtk_box_pack_start (GTK_BOX (hbox), check, FALSE, TRUE, 0);
4268 gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON (check), TRUE);
4270 omenu2 = gtk_option_menu_new ();
4271 gtk_tooltips_set_tip (tooltips, omenu2, "The tree's line style.", NULL);
4273 menu = gtk_menu_new ();
4277 menu_item = gtk_radio_menu_item_new_with_label (group, "Solid");
4278 gtk_signal_connect (GTK_OBJECT (menu_item), "activate",
4279 GTK_SIGNAL_FUNC (toggle_line_style), ctree);
4280 group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menu_item));
4281 gtk_menu_append (GTK_MENU (menu), menu_item);
4282 gtk_widget_show (menu_item);
4284 menu_item = gtk_radio_menu_item_new_with_label (group, "Dotted");
4285 gtk_signal_connect (GTK_OBJECT (menu_item), "activate",
4286 GTK_SIGNAL_FUNC (toggle_line_style), ctree);
4287 group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menu_item));
4288 gtk_check_menu_item_set_state (GTK_CHECK_MENU_ITEM (menu_item), TRUE);
4289 gtk_menu_append (GTK_MENU (menu), menu_item);
4290 gtk_widget_show (menu_item);
4292 menu_item = gtk_radio_menu_item_new_with_label (group, "Tabbed");
4293 gtk_signal_connect (GTK_OBJECT (menu_item), "activate",
4294 GTK_SIGNAL_FUNC (toggle_line_style), ctree);
4295 group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menu_item));
4296 gtk_menu_append (GTK_MENU (menu), menu_item);
4297 gtk_widget_show (menu_item);
4299 menu_item = gtk_radio_menu_item_new_with_label (group, "No lines");
4300 gtk_signal_connect (GTK_OBJECT (menu_item), "activate",
4301 GTK_SIGNAL_FUNC (toggle_line_style), ctree);
4302 group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menu_item));
4303 gtk_menu_append (GTK_MENU (menu), menu_item);
4304 gtk_widget_show (menu_item);
4306 gtk_option_menu_set_menu (GTK_OPTION_MENU (omenu2), menu);
4307 gtk_box_pack_start (GTK_BOX (hbox), omenu2, FALSE, TRUE, 0);
4309 gtk_option_menu_set_history (GTK_OPTION_MENU (omenu2), 1);
4311 omenu3 = gtk_option_menu_new ();
4312 gtk_tooltips_set_tip (tooltips, omenu3, "The tree's justification.",
4315 menu = gtk_menu_new ();
4319 menu_item = gtk_radio_menu_item_new_with_label (group, "Left");
4320 gtk_signal_connect (GTK_OBJECT (menu_item), "activate",
4321 GTK_SIGNAL_FUNC (toggle_justify), ctree);
4322 group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menu_item));
4323 gtk_menu_append (GTK_MENU (menu), menu_item);
4324 gtk_check_menu_item_set_state (GTK_CHECK_MENU_ITEM (menu_item), TRUE);
4325 gtk_widget_show (menu_item);
4327 menu_item = gtk_radio_menu_item_new_with_label (group, "Right");
4328 gtk_signal_connect (GTK_OBJECT (menu_item), "activate",
4329 GTK_SIGNAL_FUNC (toggle_justify), ctree);
4330 group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menu_item));
4331 gtk_menu_append (GTK_MENU (menu), menu_item);
4332 gtk_widget_show (menu_item);
4334 gtk_option_menu_set_menu (GTK_OPTION_MENU (omenu3), menu);
4335 gtk_box_pack_start (GTK_BOX (hbox), omenu3, FALSE, TRUE, 0);
4337 gtk_option_menu_set_history (GTK_OPTION_MENU (omenu3), 0);
4339 omenu = gtk_option_menu_new ();
4340 gtk_tooltips_set_tip (tooltips, omenu, "The list's selection mode.",
4343 menu = gtk_menu_new ();
4347 menu_item = gtk_radio_menu_item_new_with_label (group, "Single");
4348 gtk_signal_connect (GTK_OBJECT (menu_item), "activate",
4349 GTK_SIGNAL_FUNC (toggle_sel_mode), ctree);
4350 group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menu_item));
4351 gtk_menu_append (GTK_MENU (menu), menu_item);
4352 gtk_widget_show (menu_item);
4354 menu_item = gtk_radio_menu_item_new_with_label (group, "Browse");
4355 gtk_signal_connect (GTK_OBJECT (menu_item), "activate",
4356 GTK_SIGNAL_FUNC (toggle_sel_mode), ctree);
4357 group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menu_item));
4358 gtk_menu_append (GTK_MENU (menu), menu_item);
4359 gtk_widget_show (menu_item);
4361 menu_item = gtk_radio_menu_item_new_with_label (group, "Multiple");
4362 gtk_signal_connect (GTK_OBJECT (menu_item), "activate",
4363 GTK_SIGNAL_FUNC (toggle_sel_mode), ctree);
4364 group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menu_item));
4365 gtk_menu_append (GTK_MENU (menu), menu_item);
4366 gtk_widget_show (menu_item);
4368 menu_item = gtk_radio_menu_item_new_with_label (group, "Extended");
4369 gtk_signal_connect (GTK_OBJECT (menu_item), "activate",
4370 GTK_SIGNAL_FUNC (toggle_sel_mode), ctree);
4371 group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menu_item));
4372 gtk_menu_append (GTK_MENU (menu), menu_item);
4373 gtk_check_menu_item_set_state (GTK_CHECK_MENU_ITEM (menu_item), TRUE);
4374 gtk_widget_show (menu_item);
4376 gtk_option_menu_set_menu (GTK_OPTION_MENU (omenu), menu);
4377 gtk_box_pack_start (GTK_BOX (hbox), omenu, FALSE, TRUE, 0);
4379 gtk_option_menu_set_history (GTK_OPTION_MENU (omenu), 3);
4381 gtk_widget_realize (window);
4383 pixmap1 = gdk_pixmap_create_from_xpm_d (window->window, &mask1,
4384 &transparent, book_closed_xpm);
4385 pixmap2 = gdk_pixmap_create_from_xpm_d (window->window, &mask2,
4386 &transparent, book_open_xpm);
4387 pixmap3 = gdk_pixmap_create_from_xpm_d (window->window, &mask3,
4388 &transparent, mini_page_xpm);
4390 gtk_widget_set_usize (GTK_WIDGET (ctree), 0, 300);
4392 frame = gtk_frame_new (NULL);
4393 gtk_container_border_width (GTK_CONTAINER (frame), 0);
4394 gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_OUT);
4395 gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, TRUE, 0);
4397 hbox = gtk_hbox_new (TRUE, 2);
4398 gtk_container_border_width (GTK_CONTAINER (hbox), 2);
4399 gtk_container_add (GTK_CONTAINER (frame), hbox);
4401 frame = gtk_frame_new (NULL);
4402 gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
4403 gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, TRUE, 0);
4405 hbox2 = gtk_hbox_new (FALSE, 0);
4406 gtk_container_border_width (GTK_CONTAINER (hbox2), 2);
4407 gtk_container_add (GTK_CONTAINER (frame), hbox2);
4409 label = gtk_label_new ("Books :");
4410 gtk_box_pack_start (GTK_BOX (hbox2), label, FALSE, TRUE, 0);
4412 sprintf (buf, "%d", books);
4413 book_label = gtk_label_new (buf);
4414 gtk_box_pack_end (GTK_BOX (hbox2), book_label, FALSE, TRUE, 5);
4416 frame = gtk_frame_new (NULL);
4417 gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
4418 gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, TRUE, 0);
4420 hbox2 = gtk_hbox_new (FALSE, 0);
4421 gtk_container_border_width (GTK_CONTAINER (hbox2), 2);
4422 gtk_container_add (GTK_CONTAINER (frame), hbox2);
4424 label = gtk_label_new ("Pages :");
4425 gtk_box_pack_start (GTK_BOX (hbox2), label, FALSE, TRUE, 0);
4427 sprintf (buf, "%d", pages);
4428 page_label = gtk_label_new (buf);
4429 gtk_box_pack_end (GTK_BOX (hbox2), page_label, FALSE, TRUE, 5);
4431 frame = gtk_frame_new (NULL);
4432 gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
4433 gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, TRUE, 0);
4435 hbox2 = gtk_hbox_new (FALSE, 0);
4436 gtk_container_border_width (GTK_CONTAINER (hbox2), 2);
4437 gtk_container_add (GTK_CONTAINER (frame), hbox2);
4439 label = gtk_label_new ("Selected :");
4440 gtk_box_pack_start (GTK_BOX (hbox2), label, FALSE, TRUE, 0);
4442 sprintf (buf, "%d", g_list_length (GTK_CLIST (ctree)->selection));
4443 sel_label = gtk_label_new (buf);
4444 gtk_box_pack_end (GTK_BOX (hbox2), sel_label, FALSE, TRUE, 5);
4446 frame = gtk_frame_new (NULL);
4447 gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
4448 gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, TRUE, 0);
4450 hbox2 = gtk_hbox_new (FALSE, 0);
4451 gtk_container_border_width (GTK_CONTAINER (hbox2), 2);
4452 gtk_container_add (GTK_CONTAINER (frame), hbox2);
4454 label = gtk_label_new ("Visible :");
4455 gtk_box_pack_start (GTK_BOX (hbox2), label, FALSE, TRUE, 0);
4457 sprintf (buf, "%d", g_list_length (GTK_CLIST (ctree)->row_list));
4458 vis_label = gtk_label_new (buf);
4459 gtk_box_pack_end (GTK_BOX (hbox2), vis_label, FALSE, TRUE, 5);
4461 rebuild_tree (NULL, ctree);
4464 if (!GTK_WIDGET_VISIBLE (window))
4465 gtk_widget_show_all (window);
4467 gtk_widget_destroy (window);
4474 color_selection_ok (GtkWidget *w,
4475 GtkColorSelectionDialog *cs)
4477 GtkColorSelection *colorsel;
4480 colorsel=GTK_COLOR_SELECTION(cs->colorsel);
4482 gtk_color_selection_get_color(colorsel,color);
4483 gtk_color_selection_set_color(colorsel,color);
4487 color_selection_changed (GtkWidget *w,
4488 GtkColorSelectionDialog *cs)
4490 GtkColorSelection *colorsel;
4493 colorsel=GTK_COLOR_SELECTION(cs->colorsel);
4494 gtk_color_selection_get_color(colorsel,color);
4498 create_color_selection (void)
4500 static GtkWidget *window = NULL;
4504 window = gtk_color_selection_dialog_new ("color selection dialog");
4506 gtk_color_selection_set_opacity (
4507 GTK_COLOR_SELECTION (GTK_COLOR_SELECTION_DIALOG (window)->colorsel),
4510 gtk_color_selection_set_update_policy(
4511 GTK_COLOR_SELECTION (GTK_COLOR_SELECTION_DIALOG (window)->colorsel),
4512 GTK_UPDATE_CONTINUOUS);
4514 gtk_window_position (GTK_WINDOW (window), GTK_WIN_POS_MOUSE);
4516 gtk_signal_connect (GTK_OBJECT (window), "destroy",
4517 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
4520 gtk_signal_connect (
4521 GTK_OBJECT (GTK_COLOR_SELECTION_DIALOG (window)->colorsel),
4523 GTK_SIGNAL_FUNC(color_selection_changed),
4526 gtk_signal_connect (
4527 GTK_OBJECT (GTK_COLOR_SELECTION_DIALOG (window)->ok_button),
4529 GTK_SIGNAL_FUNC(color_selection_ok),
4532 gtk_signal_connect_object (
4533 GTK_OBJECT (GTK_COLOR_SELECTION_DIALOG (window)->cancel_button),
4535 GTK_SIGNAL_FUNC(gtk_widget_destroy),
4536 GTK_OBJECT (window));
4539 if (!GTK_WIDGET_VISIBLE (window))
4540 gtk_widget_show (window);
4542 gtk_widget_destroy (window);
4546 file_selection_hide_fileops (GtkWidget *widget,
4547 GtkFileSelection *fs)
4549 gtk_file_selection_hide_fileop_buttons (fs);
4553 file_selection_ok (GtkWidget *w,
4554 GtkFileSelection *fs)
4556 g_print ("%s\n", gtk_file_selection_get_filename (fs));
4557 gtk_widget_destroy (GTK_WIDGET (fs));
4561 create_file_selection (void)
4563 static GtkWidget *window = NULL;
4568 window = gtk_file_selection_new ("file selection dialog");
4570 gtk_file_selection_hide_fileop_buttons (GTK_FILE_SELECTION (window));
4572 gtk_window_position (GTK_WINDOW (window), GTK_WIN_POS_MOUSE);
4574 gtk_signal_connect (GTK_OBJECT (window), "destroy",
4575 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
4578 gtk_signal_connect (GTK_OBJECT (GTK_FILE_SELECTION (window)->ok_button),
4579 "clicked", GTK_SIGNAL_FUNC(file_selection_ok),
4581 gtk_signal_connect_object (GTK_OBJECT (GTK_FILE_SELECTION (window)->cancel_button),
4582 "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy),
4583 GTK_OBJECT (window));
4585 button = gtk_button_new_with_label ("Hide Fileops");
4586 gtk_signal_connect (GTK_OBJECT (button), "clicked",
4587 (GtkSignalFunc) file_selection_hide_fileops,
4589 gtk_box_pack_start (GTK_BOX (GTK_FILE_SELECTION (window)->action_area),
4590 button, FALSE, FALSE, 0);
4591 gtk_widget_show (button);
4593 button = gtk_button_new_with_label ("Show Fileops");
4594 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
4595 (GtkSignalFunc) gtk_file_selection_show_fileop_buttons,
4597 gtk_box_pack_start (GTK_BOX (GTK_FILE_SELECTION (window)->action_area),
4598 button, FALSE, FALSE, 0);
4599 gtk_widget_show (button);
4605 if (!GTK_WIDGET_VISIBLE (window))
4606 gtk_widget_show (window);
4608 gtk_widget_destroy (window);
4612 font_selection_ok (GtkWidget *w,
4613 GtkFontSelectionDialog *fs)
4615 g_print ("%s\n", gtk_font_selection_dialog_get_font_name (fs));
4616 gtk_widget_destroy (GTK_WIDGET (fs));
4620 create_font_selection (void)
4622 static GtkWidget *window = NULL;
4626 window = gtk_font_selection_dialog_new ("Font Selection Dialog");
4628 gtk_window_position (GTK_WINDOW (window), GTK_WIN_POS_MOUSE);
4630 gtk_signal_connect (GTK_OBJECT (window), "destroy",
4631 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
4634 gtk_signal_connect (GTK_OBJECT (GTK_FONT_SELECTION_DIALOG (window)->ok_button),
4635 "clicked", GTK_SIGNAL_FUNC(font_selection_ok),
4636 GTK_FONT_SELECTION_DIALOG (window));
4637 gtk_signal_connect_object (GTK_OBJECT (GTK_FONT_SELECTION_DIALOG (window)->cancel_button),
4638 "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy),
4639 GTK_OBJECT (window));
4642 if (!GTK_WIDGET_VISIBLE (window))
4643 gtk_widget_show (window);
4645 gtk_widget_destroy (window);
4652 static GtkWidget *dialog_window = NULL;
4655 label_toggle (GtkWidget *widget,
4660 *label = gtk_label_new ("Dialog Test");
4661 gtk_signal_connect (GTK_OBJECT (*label),
4663 GTK_SIGNAL_FUNC (gtk_widget_destroyed),
4665 gtk_misc_set_padding (GTK_MISC (*label), 10, 10);
4666 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog_window)->vbox),
4667 *label, TRUE, TRUE, 0);
4668 gtk_widget_show (*label);
4671 gtk_widget_destroy (*label);
4675 create_dialog (void)
4677 static GtkWidget *label;
4682 dialog_window = gtk_dialog_new ();
4684 gtk_signal_connect (GTK_OBJECT (dialog_window), "destroy",
4685 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
4688 gtk_window_set_title (GTK_WINDOW (dialog_window), "dialog");
4689 gtk_container_border_width (GTK_CONTAINER (dialog_window), 0);
4691 button = gtk_button_new_with_label ("OK");
4692 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
4693 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog_window)->action_area),
4694 button, TRUE, TRUE, 0);
4695 gtk_widget_grab_default (button);
4696 gtk_widget_show (button);
4698 button = gtk_button_new_with_label ("Toggle");
4699 gtk_signal_connect (GTK_OBJECT (button), "clicked",
4700 GTK_SIGNAL_FUNC (label_toggle),
4702 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
4703 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog_window)->action_area),
4704 button, TRUE, TRUE, 0);
4705 gtk_widget_show (button);
4710 if (!GTK_WIDGET_VISIBLE (dialog_window))
4711 gtk_widget_show (dialog_window);
4713 gtk_widget_destroy (dialog_window);
4721 create_range_controls (void)
4723 static GtkWidget *window = NULL;
4727 GtkWidget *scrollbar;
4729 GtkWidget *separator;
4730 GtkObject *adjustment;
4734 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
4736 gtk_signal_connect (GTK_OBJECT (window), "destroy",
4737 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
4740 gtk_window_set_title (GTK_WINDOW (window), "range controls");
4741 gtk_container_border_width (GTK_CONTAINER (window), 0);
4744 box1 = gtk_vbox_new (FALSE, 0);
4745 gtk_container_add (GTK_CONTAINER (window), box1);
4746 gtk_widget_show (box1);
4749 box2 = gtk_vbox_new (FALSE, 10);
4750 gtk_container_border_width (GTK_CONTAINER (box2), 10);
4751 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
4752 gtk_widget_show (box2);
4755 adjustment = gtk_adjustment_new (0.0, 0.0, 101.0, 0.1, 1.0, 1.0);
4757 scale = gtk_hscale_new (GTK_ADJUSTMENT (adjustment));
4758 gtk_widget_set_usize (GTK_WIDGET (scale), 150, 30);
4759 gtk_range_set_update_policy (GTK_RANGE (scale), GTK_UPDATE_DELAYED);
4760 gtk_scale_set_digits (GTK_SCALE (scale), 1);
4761 gtk_scale_set_draw_value (GTK_SCALE (scale), TRUE);
4762 gtk_box_pack_start (GTK_BOX (box2), scale, TRUE, TRUE, 0);
4763 gtk_widget_show (scale);
4765 scrollbar = gtk_hscrollbar_new (GTK_ADJUSTMENT (adjustment));
4766 gtk_range_set_update_policy (GTK_RANGE (scrollbar),
4767 GTK_UPDATE_CONTINUOUS);
4768 gtk_box_pack_start (GTK_BOX (box2), scrollbar, TRUE, TRUE, 0);
4769 gtk_widget_show (scrollbar);
4772 separator = gtk_hseparator_new ();
4773 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
4774 gtk_widget_show (separator);
4777 box2 = gtk_vbox_new (FALSE, 10);
4778 gtk_container_border_width (GTK_CONTAINER (box2), 10);
4779 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
4780 gtk_widget_show (box2);
4783 button = gtk_button_new_with_label ("close");
4784 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
4785 GTK_SIGNAL_FUNC(gtk_widget_destroy),
4786 GTK_OBJECT (window));
4787 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
4788 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
4789 gtk_widget_grab_default (button);
4790 gtk_widget_show (button);
4793 if (!GTK_WIDGET_VISIBLE (window))
4794 gtk_widget_show (window);
4796 gtk_widget_destroy (window);
4804 create_rulers (void)
4806 static GtkWidget *window = NULL;
4812 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
4813 gtk_window_set_policy (GTK_WINDOW (window), TRUE, TRUE, FALSE);
4815 gtk_signal_connect (GTK_OBJECT (window), "destroy",
4816 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
4819 gtk_window_set_title (GTK_WINDOW (window), "rulers");
4820 gtk_widget_set_usize (window, 300, 300);
4821 gtk_widget_set_events (window,
4822 GDK_POINTER_MOTION_MASK
4823 | GDK_POINTER_MOTION_HINT_MASK);
4824 gtk_container_border_width (GTK_CONTAINER (window), 0);
4826 table = gtk_table_new (2, 2, FALSE);
4827 gtk_container_add (GTK_CONTAINER (window), table);
4828 gtk_widget_show (table);
4830 ruler = gtk_hruler_new ();
4831 gtk_ruler_set_metric (GTK_RULER (ruler), GTK_CENTIMETERS);
4832 gtk_ruler_set_range (GTK_RULER (ruler), 100, 0, 0, 20);
4834 gtk_signal_connect_object (
4835 GTK_OBJECT (window),
4836 "motion_notify_event",
4838 GTK_WIDGET_CLASS (GTK_OBJECT (ruler)->klass)->motion_notify_event),
4839 GTK_OBJECT (ruler));
4841 gtk_table_attach (GTK_TABLE (table), ruler, 1, 2, 0, 1,
4842 GTK_EXPAND | GTK_FILL, GTK_FILL, 0, 0);
4843 gtk_widget_show (ruler);
4846 ruler = gtk_vruler_new ();
4847 gtk_ruler_set_range (GTK_RULER (ruler), 5, 15, 0, 20);
4849 gtk_signal_connect_object (
4850 GTK_OBJECT (window),
4851 "motion_notify_event",
4852 GTK_SIGNAL_FUNC (GTK_WIDGET_CLASS (GTK_OBJECT (ruler)->klass)->motion_notify_event),
4853 GTK_OBJECT (ruler));
4855 gtk_table_attach (GTK_TABLE (table), ruler, 0, 1, 1, 2,
4856 GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
4857 gtk_widget_show (ruler);
4860 if (!GTK_WIDGET_VISIBLE (window))
4861 gtk_widget_show (window);
4863 gtk_widget_destroy (window);
4868 text_toggle_editable (GtkWidget *checkbutton,
4871 gtk_text_set_editable(GTK_TEXT(text),
4872 GTK_TOGGLE_BUTTON(checkbutton)->active);
4876 text_toggle_word_wrap (GtkWidget *checkbutton,
4879 gtk_text_set_word_wrap(GTK_TEXT(text),
4880 GTK_TOGGLE_BUTTON(checkbutton)->active);
4889 static GtkWidget *window = NULL;
4895 GtkWidget *separator;
4897 GtkWidget *hscrollbar;
4898 GtkWidget *vscrollbar;
4905 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
4906 gtk_widget_set_name (window, "text window");
4907 gtk_widget_set_usize (window, 500, 500);
4908 gtk_window_set_policy (GTK_WINDOW(window), TRUE, TRUE, FALSE);
4910 gtk_signal_connect (GTK_OBJECT (window), "destroy",
4911 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
4914 gtk_window_set_title (GTK_WINDOW (window), "test");
4915 gtk_container_border_width (GTK_CONTAINER (window), 0);
4918 box1 = gtk_vbox_new (FALSE, 0);
4919 gtk_container_add (GTK_CONTAINER (window), box1);
4920 gtk_widget_show (box1);
4923 box2 = gtk_vbox_new (FALSE, 10);
4924 gtk_container_border_width (GTK_CONTAINER (box2), 10);
4925 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
4926 gtk_widget_show (box2);
4929 table = gtk_table_new (2, 2, FALSE);
4930 gtk_table_set_row_spacing (GTK_TABLE (table), 0, 2);
4931 gtk_table_set_col_spacing (GTK_TABLE (table), 0, 2);
4932 gtk_box_pack_start (GTK_BOX (box2), table, TRUE, TRUE, 0);
4933 gtk_widget_show (table);
4935 text = gtk_text_new (NULL, NULL);
4936 gtk_text_set_editable (GTK_TEXT (text), TRUE);
4937 gtk_table_attach (GTK_TABLE (table), text, 0, 1, 0, 1,
4938 GTK_EXPAND | GTK_SHRINK | GTK_FILL,
4939 GTK_EXPAND | GTK_SHRINK | GTK_FILL, 0, 0);
4940 gtk_widget_show (text);
4942 hscrollbar = gtk_hscrollbar_new (GTK_TEXT (text)->hadj);
4943 gtk_table_attach (GTK_TABLE (table), hscrollbar, 0, 1, 1, 2,
4944 GTK_EXPAND | GTK_FILL | GTK_SHRINK, GTK_FILL, 0, 0);
4945 gtk_widget_show (hscrollbar);
4947 vscrollbar = gtk_vscrollbar_new (GTK_TEXT (text)->vadj);
4948 gtk_table_attach (GTK_TABLE (table), vscrollbar, 1, 2, 0, 1,
4949 GTK_FILL, GTK_EXPAND | GTK_SHRINK | GTK_FILL, 0, 0);
4950 gtk_widget_show (vscrollbar);
4952 gtk_text_freeze (GTK_TEXT (text));
4954 gtk_widget_realize (text);
4956 infile = fopen("testgtk.c", "r");
4965 nchars = fread(buffer, 1, 1024, infile);
4966 gtk_text_insert (GTK_TEXT (text), NULL, NULL,
4967 NULL, buffer, nchars);
4976 gtk_text_insert (GTK_TEXT (text), NULL, &text->style->black, NULL,
4978 gtk_text_insert (GTK_TEXT (text), NULL, &text->style->bg[GTK_STATE_NORMAL], NULL,
4980 gtk_text_insert (GTK_TEXT (text), NULL, &text->style->black, NULL,
4983 gtk_text_thaw (GTK_TEXT (text));
4985 hbox = gtk_hbutton_box_new ();
4986 gtk_box_pack_start (GTK_BOX (box2), hbox, FALSE, FALSE, 0);
4987 gtk_widget_show (hbox);
4989 check = gtk_check_button_new_with_label("Editable");
4990 gtk_box_pack_start (GTK_BOX (hbox), check, FALSE, FALSE, 0);
4991 gtk_signal_connect (GTK_OBJECT(check), "toggled",
4992 GTK_SIGNAL_FUNC(text_toggle_editable), text);
4993 gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(check), TRUE);
4994 gtk_widget_show (check);
4996 check = gtk_check_button_new_with_label("Wrap Words");
4997 gtk_box_pack_start (GTK_BOX (hbox), check, FALSE, TRUE, 0);
4998 gtk_signal_connect (GTK_OBJECT(check), "toggled",
4999 GTK_SIGNAL_FUNC(text_toggle_word_wrap), text);
5000 gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(check), FALSE);
5001 gtk_widget_show (check);
5003 separator = gtk_hseparator_new ();
5004 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
5005 gtk_widget_show (separator);
5008 box2 = gtk_vbox_new (FALSE, 10);
5009 gtk_container_border_width (GTK_CONTAINER (box2), 10);
5010 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
5011 gtk_widget_show (box2);
5014 button = gtk_button_new_with_label ("close");
5015 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
5016 GTK_SIGNAL_FUNC(gtk_widget_destroy),
5017 GTK_OBJECT (window));
5018 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
5019 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
5020 gtk_widget_grab_default (button);
5021 gtk_widget_show (button);
5024 if (!GTK_WIDGET_VISIBLE (window))
5025 gtk_widget_show (window);
5027 gtk_widget_destroy (window);
5035 GdkPixmap *book_open;
5036 GdkPixmap *book_closed;
5037 GdkBitmap *book_open_mask;
5038 GdkBitmap *book_closed_mask;
5042 notebook_reparent (GtkWidget *widget, GtkWidget *scrollwin)
5044 static GtkWidget *parent = NULL;
5045 static GtkWidget *float_parent;
5049 gtk_widget_reparent (scrollwin, parent);
5050 gtk_widget_destroy (float_parent);
5051 float_parent = NULL;
5056 parent = widget->parent;
5057 float_parent = gtk_window_new (GTK_WINDOW_TOPLEVEL);
5058 gtk_widget_show (float_parent);
5059 gtk_widget_reparent (scrollwin, float_parent);
5064 page_switch (GtkWidget *widget, GtkNotebookPage *page, gint page_num)
5066 GtkNotebookPage *oldpage;
5069 oldpage = GTK_NOTEBOOK (widget)->cur_page;
5071 if (page == oldpage)
5074 pixwid = ((GtkBoxChild*)(GTK_BOX (page->tab_label)->children->data))->widget;
5075 gtk_pixmap_set (GTK_PIXMAP (pixwid), book_open, book_open_mask);
5076 pixwid = ((GtkBoxChild*) (GTK_BOX (page->menu_label)->children->data))->widget;
5077 gtk_pixmap_set (GTK_PIXMAP (pixwid), book_open, book_open_mask);
5081 pixwid = ((GtkBoxChild*) (GTK_BOX
5082 (oldpage->tab_label)->children->data))->widget;
5083 gtk_pixmap_set (GTK_PIXMAP (pixwid), book_closed, book_closed_mask);
5084 pixwid = ((GtkBoxChild*) (GTK_BOX (oldpage->menu_label)->children->data))->widget;
5085 gtk_pixmap_set (GTK_PIXMAP (pixwid), book_closed, book_closed_mask);
5090 create_pages (GtkNotebook *notebook, gint start, gint end)
5092 GtkWidget *child = NULL;
5097 GtkWidget *label_box;
5098 GtkWidget *menu_box;
5104 for (i = start; i <= end; i++)
5106 sprintf (buffer, "Page %d", i);
5111 child = gtk_button_new_with_label (buffer);
5112 gtk_container_border_width (GTK_CONTAINER(child), 10);
5115 child = gtk_label_new (buffer);
5118 child = gtk_frame_new (buffer);
5119 gtk_container_border_width (GTK_CONTAINER (child), 10);
5121 box = gtk_vbox_new (TRUE,0);
5122 gtk_container_border_width (GTK_CONTAINER (box), 10);
5123 gtk_container_add (GTK_CONTAINER (child), box);
5125 label = gtk_label_new (buffer);
5126 gtk_box_pack_start (GTK_BOX(box), label, TRUE, TRUE, 5);
5128 entry = gtk_entry_new ();
5129 gtk_box_pack_start (GTK_BOX(box), entry, TRUE, TRUE, 5);
5131 hbox = gtk_hbox_new (TRUE,0);
5132 gtk_box_pack_start (GTK_BOX(box), hbox, TRUE, TRUE, 5);
5134 button = gtk_button_new_with_label ("Ok");
5135 gtk_box_pack_start (GTK_BOX(hbox), button, TRUE, TRUE, 5);
5137 button = gtk_button_new_with_label ("Cancel");
5138 gtk_box_pack_start (GTK_BOX(hbox), button, TRUE, TRUE, 5);
5141 child = gtk_frame_new (buffer);
5142 gtk_container_border_width (GTK_CONTAINER (child), 10);
5144 label = gtk_label_new (buffer);
5145 gtk_container_add (GTK_CONTAINER (child), label);
5149 gtk_widget_show_all (child);
5151 label_box = gtk_hbox_new (FALSE, 0);
5152 pixwid = gtk_pixmap_new (book_closed, book_closed_mask);
5153 gtk_box_pack_start (GTK_BOX (label_box), pixwid, FALSE, TRUE, 0);
5154 gtk_misc_set_padding (GTK_MISC (pixwid), 3, 1);
5155 label = gtk_label_new (buffer);
5156 gtk_box_pack_start (GTK_BOX (label_box), label, FALSE, TRUE, 0);
5157 gtk_widget_show_all (label_box);
5159 menu_box = gtk_hbox_new (FALSE, 0);
5160 pixwid = gtk_pixmap_new (book_closed, book_closed_mask);
5161 gtk_box_pack_start (GTK_BOX (menu_box), pixwid, FALSE, TRUE, 0);
5162 gtk_misc_set_padding (GTK_MISC (pixwid), 3, 1);
5163 label = gtk_label_new (buffer);
5164 gtk_box_pack_start (GTK_BOX (menu_box), label, FALSE, TRUE, 0);
5165 gtk_widget_show_all (menu_box);
5167 gtk_notebook_append_page_menu (notebook, child, label_box, menu_box);
5172 rotate_notebook (GtkButton *button,
5173 GtkNotebook *notebook)
5175 gtk_notebook_set_tab_pos (notebook, (notebook->tab_pos + 1) % 4);
5179 standard_notebook (GtkButton *button,
5180 GtkNotebook *notebook)
5184 gtk_notebook_set_show_tabs (notebook, TRUE);
5185 gtk_notebook_set_scrollable (notebook, FALSE);
5186 if (g_list_length (notebook->children) == 15)
5187 for (i = 0; i < 10; i++)
5188 gtk_notebook_remove_page (notebook, 5);
5192 notabs_notebook (GtkButton *button,
5193 GtkNotebook *notebook)
5197 gtk_notebook_set_show_tabs (notebook, FALSE);
5198 if (g_list_length (notebook->children) == 15)
5199 for (i = 0; i < 10; i++)
5200 gtk_notebook_remove_page (notebook, 5);
5204 scrollable_notebook (GtkButton *button,
5205 GtkNotebook *notebook)
5207 gtk_notebook_set_show_tabs (notebook, TRUE);
5208 gtk_notebook_set_scrollable (notebook, TRUE);
5209 if (g_list_length (notebook->children) == 5)
5210 create_pages (notebook, 6, 15);
5214 notebook_popup (GtkToggleButton *button,
5215 GtkNotebook *notebook)
5218 gtk_notebook_popup_enable (notebook);
5220 gtk_notebook_popup_disable (notebook);
5224 create_notebook (void)
5226 static GtkWidget *window = NULL;
5230 GtkWidget *separator;
5231 GtkWidget *notebook;
5235 GtkWidget *menuitem;
5237 GdkColor *transparent = NULL;
5241 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
5243 gtk_signal_connect (GTK_OBJECT (window), "destroy",
5244 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
5247 gtk_window_set_title (GTK_WINDOW (window), "notebook");
5248 gtk_container_border_width (GTK_CONTAINER (window), 0);
5250 box1 = gtk_vbox_new (FALSE, 0);
5251 gtk_container_add (GTK_CONTAINER (window), box1);
5253 notebook = gtk_notebook_new ();
5254 gtk_signal_connect (GTK_OBJECT (notebook), "switch_page",
5255 GTK_SIGNAL_FUNC (page_switch), NULL);
5256 gtk_notebook_set_tab_pos (GTK_NOTEBOOK (notebook), GTK_POS_TOP);
5257 gtk_box_pack_start (GTK_BOX (box1), notebook, TRUE, TRUE, 0);
5258 gtk_container_border_width (GTK_CONTAINER (notebook), 10);
5260 gtk_widget_realize (notebook);
5261 book_open = gdk_pixmap_create_from_xpm_d (notebook->window,
5265 book_closed = gdk_pixmap_create_from_xpm_d (notebook->window,
5270 create_pages (GTK_NOTEBOOK (notebook), 1, 5);
5272 separator = gtk_hseparator_new ();
5273 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 10);
5275 box2 = gtk_hbox_new (TRUE, 5);
5276 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
5278 omenu = gtk_option_menu_new ();
5279 menu = gtk_menu_new ();
5283 menuitem = gtk_radio_menu_item_new_with_label (group, "Standard");
5284 gtk_signal_connect_object (GTK_OBJECT (menuitem), "activate",
5285 GTK_SIGNAL_FUNC (standard_notebook),
5286 GTK_OBJECT (notebook));
5287 group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menuitem));
5288 gtk_menu_append (GTK_MENU (menu), menuitem);
5289 gtk_widget_show (menuitem);
5290 menuitem = gtk_radio_menu_item_new_with_label (group, "w/o Tabs");
5291 gtk_signal_connect_object (GTK_OBJECT (menuitem), "activate",
5292 GTK_SIGNAL_FUNC (notabs_notebook),
5293 GTK_OBJECT (notebook));
5294 group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menuitem));
5295 gtk_menu_append (GTK_MENU (menu), menuitem);
5296 gtk_widget_show (menuitem);
5297 menuitem = gtk_radio_menu_item_new_with_label (group, "Scrollable");
5298 gtk_signal_connect_object (GTK_OBJECT (menuitem), "activate",
5299 GTK_SIGNAL_FUNC (scrollable_notebook),
5300 GTK_OBJECT (notebook));
5301 group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menuitem));
5302 gtk_menu_append (GTK_MENU (menu), menuitem);
5303 gtk_widget_show (menuitem);
5305 gtk_option_menu_set_menu (GTK_OPTION_MENU (omenu), menu);
5306 gtk_box_pack_start (GTK_BOX (box2), omenu, FALSE, FALSE, 0);
5307 button = gtk_check_button_new_with_label ("enable popup menu");
5308 gtk_box_pack_start (GTK_BOX (box2), button, FALSE, FALSE, 0);
5309 gtk_signal_connect (GTK_OBJECT(button), "clicked",
5310 GTK_SIGNAL_FUNC (notebook_popup),
5311 GTK_OBJECT (notebook));
5313 box2 = gtk_hbox_new (FALSE, 10);
5314 gtk_container_border_width (GTK_CONTAINER (box2), 10);
5315 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
5317 button = gtk_button_new_with_label ("close");
5318 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
5319 GTK_SIGNAL_FUNC (gtk_widget_destroy),
5320 GTK_OBJECT (window));
5321 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
5322 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
5323 gtk_widget_grab_default (button);
5325 button = gtk_button_new_with_label ("next");
5326 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
5327 GTK_SIGNAL_FUNC (gtk_notebook_next_page),
5328 GTK_OBJECT (notebook));
5329 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
5330 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
5332 button = gtk_button_new_with_label ("prev");
5333 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
5334 GTK_SIGNAL_FUNC (gtk_notebook_prev_page),
5335 GTK_OBJECT (notebook));
5336 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
5337 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
5339 button = gtk_button_new_with_label ("rotate");
5340 gtk_signal_connect (GTK_OBJECT (button), "clicked",
5341 GTK_SIGNAL_FUNC (rotate_notebook),
5343 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
5344 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
5346 button = gtk_button_new_with_label ("reparent");
5347 gtk_signal_connect (GTK_OBJECT (button), "clicked",
5348 GTK_SIGNAL_FUNC (notebook_reparent),
5350 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
5351 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
5354 if (!GTK_WIDGET_VISIBLE (window))
5355 gtk_widget_show_all (window);
5357 gtk_widget_destroy (window);
5367 static GtkWidget *window = NULL;
5375 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
5377 gtk_signal_connect (GTK_OBJECT (window), "destroy",
5378 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
5381 gtk_window_set_title (GTK_WINDOW (window), "Panes");
5382 gtk_container_border_width (GTK_CONTAINER (window), 0);
5384 vpaned = gtk_vpaned_new ();
5385 gtk_container_add (GTK_CONTAINER (window), vpaned);
5386 gtk_container_border_width (GTK_CONTAINER(vpaned), 5);
5387 gtk_widget_show (vpaned);
5389 hpaned = gtk_hpaned_new ();
5390 gtk_paned_add1 (GTK_PANED (vpaned), hpaned);
5392 frame = gtk_frame_new (NULL);
5393 gtk_frame_set_shadow_type (GTK_FRAME(frame), GTK_SHADOW_IN);
5394 gtk_widget_set_usize (frame, 60, 60);
5395 gtk_paned_add1 (GTK_PANED (hpaned), frame);
5396 gtk_widget_show (frame);
5398 button = gtk_button_new_with_label ("Hi there");
5399 gtk_container_add (GTK_CONTAINER(frame), button);
5400 gtk_widget_show (button);
5402 frame = gtk_frame_new (NULL);
5403 gtk_frame_set_shadow_type (GTK_FRAME(frame), GTK_SHADOW_IN);
5404 gtk_widget_set_usize (frame, 80, 60);
5405 gtk_paned_add2 (GTK_PANED (hpaned), frame);
5406 gtk_widget_show (frame);
5408 gtk_widget_show (hpaned);
5410 frame = gtk_frame_new (NULL);
5411 gtk_frame_set_shadow_type (GTK_FRAME(frame), GTK_SHADOW_IN);
5412 gtk_widget_set_usize (frame, 60, 80);
5413 gtk_paned_add2 (GTK_PANED (vpaned), frame);
5414 gtk_widget_show (frame);
5417 if (!GTK_WIDGET_VISIBLE (window))
5418 gtk_widget_show (window);
5420 gtk_widget_destroy (window);
5429 dnd_drop_destroy_popup (GtkWidget *widget, GtkWindow **window)
5431 if(GTK_IS_BUTTON(widget)) /* I.e. they clicked the close button */
5432 gtk_widget_destroy(GTK_WIDGET(*window));
5434 gtk_grab_remove(GTK_WIDGET(*window));
5442 dnd_drop (GtkWidget *button, GdkEvent *event)
5444 static GtkWidget *window = NULL;
5445 GtkWidget *vbox, *lbl, *btn;
5448 /* DND doesn't obey gtk_grab's, so check if we're already displaying
5449 * drop modal dialog first
5454 window = gtk_window_new(GTK_WINDOW_DIALOG);
5455 gtk_container_border_width (GTK_CONTAINER(window), 10);
5457 gtk_signal_connect (GTK_OBJECT (window), "destroy",
5458 GTK_SIGNAL_FUNC(dnd_drop_destroy_popup),
5460 gtk_signal_connect (GTK_OBJECT (window), "delete-event",
5461 GTK_SIGNAL_FUNC(gtk_false),
5464 vbox = gtk_vbox_new(FALSE, 5);
5466 /* Display message that we got from drop source */
5467 msg = g_malloc(strlen(event->dropdataavailable.data)
5468 + strlen(event->dropdataavailable.data_type) + 100);
5469 sprintf(msg, "Drop data of type %s was:\n\n%s",
5470 event->dropdataavailable.data_type,
5471 (char *)event->dropdataavailable.data);
5472 lbl = gtk_label_new(msg);
5473 gtk_label_set_justify(GTK_LABEL(lbl), GTK_JUSTIFY_FILL);
5475 gtk_widget_show(lbl);
5476 gtk_box_pack_start_defaults(GTK_BOX(vbox), lbl);
5478 /* Provide an obvious way out of this heinousness */
5479 btn = gtk_button_new_with_label("Continue with life in\nspite of this oppression");
5480 gtk_signal_connect_object (GTK_OBJECT (btn), "clicked",
5481 GTK_SIGNAL_FUNC(gtk_widget_destroy),
5482 GTK_OBJECT (window));
5483 gtk_widget_show(btn);
5484 gtk_box_pack_start_defaults(GTK_BOX(vbox), btn);
5486 gtk_container_add(GTK_CONTAINER(window), vbox);
5488 gtk_widget_show(vbox);
5489 gtk_grab_add(window);
5490 gtk_widget_show(window);
5494 dnd_drag_request (GtkWidget *button, GdkEvent *event)
5496 #define DND_STRING "Bill Gates demands royalties for\nyour use of his innovation."
5497 gtk_widget_dnd_data_set (button, event, DND_STRING, strlen(DND_STRING) + 1);
5503 static GtkWidget *window = NULL;
5509 GtkWidget *separator;
5511 /* For clarity... */
5512 char *possible_drag_types[] = {"text/plain"};
5513 char *accepted_drop_types[] = {"text/plain"};
5515 static GtkWidget *drag_icon = NULL;
5516 static GtkWidget *drop_icon = NULL;
5520 GdkPoint hotspot = {5,5};
5524 drag_icon = shape_create_icon ("Modeller.xpm",
5525 440, 140, 0,0, GTK_WINDOW_POPUP);
5527 gtk_signal_connect (GTK_OBJECT (drag_icon), "destroy",
5528 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
5531 gtk_widget_hide (drag_icon);
5536 drop_icon = shape_create_icon ("3DRings.xpm",
5537 440, 140, 0,0, GTK_WINDOW_POPUP);
5539 gtk_signal_connect (GTK_OBJECT (drop_icon), "destroy",
5540 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
5543 gtk_widget_hide (drop_icon);
5546 gdk_dnd_set_drag_shape(drag_icon->window,
5551 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
5553 gtk_signal_connect (GTK_OBJECT (window), "destroy",
5554 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
5557 gtk_window_set_title (GTK_WINDOW (window), "Drag -N- Drop");
5558 gtk_container_border_width (GTK_CONTAINER (window), 0);
5560 box1 = gtk_vbox_new (FALSE, 0);
5561 gtk_container_add (GTK_CONTAINER (window), box1);
5562 gtk_widget_show (box1);
5564 box2 = gtk_hbox_new (FALSE, 5);
5565 gtk_container_border_width (GTK_CONTAINER (box2), 10);
5566 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
5567 gtk_widget_show (box2);
5569 frame = gtk_frame_new ("Drag");
5570 gtk_box_pack_start (GTK_BOX (box2), frame, TRUE, TRUE, 0);
5571 gtk_widget_show (frame);
5573 box3 = gtk_vbox_new (FALSE, 5);
5574 gtk_container_border_width (GTK_CONTAINER (box3), 5);
5575 gtk_container_add (GTK_CONTAINER (frame), box3);
5576 gtk_widget_show (box3);
5581 button = gtk_button_new_with_label ("Drag me!");
5582 gtk_box_pack_start (GTK_BOX (box3), button, FALSE, TRUE, 0);
5583 gtk_widget_show (button);
5586 * currently, the widget has to be realized to
5587 * set dnd on it, this needs to change
5589 gtk_widget_realize (button);
5590 gtk_signal_connect (GTK_OBJECT (button),
5591 "drag_request_event",
5592 GTK_SIGNAL_FUNC(dnd_drag_request),
5595 gtk_widget_dnd_drag_set (button, TRUE, possible_drag_types, 1);
5598 frame = gtk_frame_new ("Drop");
5599 gtk_box_pack_start (GTK_BOX (box2), frame, TRUE, TRUE, 0);
5600 gtk_widget_show (frame);
5602 box3 = gtk_vbox_new (FALSE, 5);
5603 gtk_container_border_width (GTK_CONTAINER (box3), 5);
5604 gtk_container_add (GTK_CONTAINER (frame), box3);
5605 gtk_widget_show (box3);
5611 button = gtk_button_new_with_label ("To");
5612 gtk_box_pack_start (GTK_BOX (box3), button, FALSE, TRUE, 0);
5613 gtk_widget_show (button);
5615 gtk_widget_realize (button);
5616 gtk_signal_connect (GTK_OBJECT (button),
5617 "drop_data_available_event",
5618 GTK_SIGNAL_FUNC(dnd_drop),
5621 gtk_widget_dnd_drop_set (button, TRUE, accepted_drop_types, 1, FALSE);
5624 separator = gtk_hseparator_new ();
5625 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
5626 gtk_widget_show (separator);
5629 box2 = gtk_vbox_new (FALSE, 10);
5630 gtk_container_border_width (GTK_CONTAINER (box2), 10);
5631 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
5632 gtk_widget_show (box2);
5635 button = gtk_button_new_with_label ("close");
5637 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
5638 GTK_SIGNAL_FUNC(gtk_widget_destroy),
5639 GTK_OBJECT (window));
5641 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
5642 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
5643 gtk_widget_grab_default (button);
5644 gtk_widget_show (button);
5647 if (!GTK_WIDGET_VISIBLE (window))
5648 gtk_widget_show (window);
5650 gtk_widget_destroy (window);
5656 static GdkWindow *root_win = NULL;
5658 typedef struct _cursoroffset {gint x,y;} CursorOffset;
5661 shape_pressed (GtkWidget *widget, GdkEventButton *event)
5665 /* ignore double and triple click */
5666 if (event->type != GDK_BUTTON_PRESS)
5669 p = gtk_object_get_user_data (GTK_OBJECT(widget));
5670 p->x = (int) event->x;
5671 p->y = (int) event->y;
5673 gtk_grab_add (widget);
5674 gdk_pointer_grab (widget->window, TRUE,
5675 GDK_BUTTON_RELEASE_MASK |
5676 GDK_BUTTON_MOTION_MASK |
5677 GDK_POINTER_MOTION_HINT_MASK,
5683 shape_released (GtkWidget *widget)
5685 gtk_grab_remove (widget);
5686 gdk_pointer_ungrab (0);
5690 shape_motion (GtkWidget *widget,
5691 GdkEventMotion *event)
5695 GdkModifierType mask;
5697 p = gtk_object_get_user_data (GTK_OBJECT (widget));
5700 * Can't use event->x / event->y here
5701 * because I need absolute coordinates.
5703 gdk_window_get_pointer (root_win, &xp, &yp, &mask);
5704 gtk_widget_set_uposition (widget, xp - p->x, yp - p->y);
5708 shape_create_icon (char *xpm_file,
5718 CursorOffset* icon_pos;
5720 GdkBitmap *gdk_pixmap_mask;
5721 GdkPixmap *gdk_pixmap;
5724 style = gtk_widget_get_default_style ();
5725 gc = style->black_gc;
5728 * GDK_WINDOW_TOPLEVEL works also, giving you a title border
5730 window = gtk_window_new (window_type);
5732 fixed = gtk_fixed_new ();
5733 gtk_widget_set_usize (fixed, 100,100);
5734 gtk_container_add (GTK_CONTAINER (window), fixed);
5735 gtk_widget_show (fixed);
5737 gtk_widget_set_events (window,
5738 gtk_widget_get_events (window) |
5739 GDK_BUTTON_MOTION_MASK |
5740 GDK_POINTER_MOTION_HINT_MASK |
5741 GDK_BUTTON_PRESS_MASK);
5743 gtk_widget_realize (window);
5744 gdk_pixmap = gdk_pixmap_create_from_xpm (window->window, &gdk_pixmap_mask,
5745 &style->bg[GTK_STATE_NORMAL],
5748 pixmap = gtk_pixmap_new (gdk_pixmap, gdk_pixmap_mask);
5749 gtk_fixed_put (GTK_FIXED (fixed), pixmap, px,py);
5750 gtk_widget_show (pixmap);
5752 gtk_widget_shape_combine_mask (window, gdk_pixmap_mask, px,py);
5755 gtk_signal_connect (GTK_OBJECT (window), "button_press_event",
5756 GTK_SIGNAL_FUNC (shape_pressed),NULL);
5757 gtk_signal_connect (GTK_OBJECT (window), "button_release_event",
5758 GTK_SIGNAL_FUNC (shape_released),NULL);
5759 gtk_signal_connect (GTK_OBJECT (window), "motion_notify_event",
5760 GTK_SIGNAL_FUNC (shape_motion),NULL);
5762 icon_pos = g_new (CursorOffset, 1);
5763 gtk_object_set_user_data(GTK_OBJECT(window), icon_pos);
5765 gtk_widget_set_uposition (window, x, y);
5766 gtk_widget_show (window);
5772 create_shapes (void)
5774 /* Variables used by the Drag/Drop and Shape Window demos */
5775 static GtkWidget *modeller = NULL;
5776 static GtkWidget *sheets = NULL;
5777 static GtkWidget *rings = NULL;
5779 root_win = gdk_window_foreign_new (GDK_ROOT_WINDOW ());
5783 modeller = shape_create_icon ("Modeller.xpm",
5784 440, 140, 0,0, GTK_WINDOW_POPUP);
5786 gtk_signal_connect (GTK_OBJECT (modeller), "destroy",
5787 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
5791 gtk_widget_destroy (modeller);
5795 sheets = shape_create_icon ("FilesQueue.xpm",
5796 580, 170, 0,0, GTK_WINDOW_POPUP);
5798 gtk_signal_connect (GTK_OBJECT (sheets), "destroy",
5799 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
5804 gtk_widget_destroy (sheets);
5808 rings = shape_create_icon ("3DRings.xpm",
5809 460, 270, 25,25, GTK_WINDOW_TOPLEVEL);
5811 gtk_signal_connect (GTK_OBJECT (rings), "destroy",
5812 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
5816 gtk_widget_destroy (rings);
5820 create_wmhints (void)
5822 static GtkWidget *window = NULL;
5824 GtkWidget *separator;
5833 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
5835 gtk_signal_connect (GTK_OBJECT (window), "destroy",
5836 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
5839 gtk_window_set_title (GTK_WINDOW (window), "WM Hints");
5840 gtk_container_border_width (GTK_CONTAINER (window), 0);
5842 gtk_widget_realize (window);
5844 circles = gdk_bitmap_create_from_data (window->window,
5848 gdk_window_set_icon (window->window, NULL,
5851 gdk_window_set_icon_name (window->window, "WMHints Test Icon");
5853 gdk_window_set_decorations (window->window, GDK_DECOR_ALL | GDK_DECOR_MENU);
5854 gdk_window_set_functions (window->window, GDK_FUNC_ALL | GDK_FUNC_RESIZE);
5856 box1 = gtk_vbox_new (FALSE, 0);
5857 gtk_container_add (GTK_CONTAINER (window), box1);
5858 gtk_widget_show (box1);
5860 label = gtk_label_new ("Try iconizing me!");
5861 gtk_widget_set_usize (label, 150, 50);
5862 gtk_box_pack_start (GTK_BOX (box1), label, TRUE, TRUE, 0);
5863 gtk_widget_show (label);
5866 separator = gtk_hseparator_new ();
5867 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
5868 gtk_widget_show (separator);
5871 box2 = gtk_vbox_new (FALSE, 10);
5872 gtk_container_border_width (GTK_CONTAINER (box2), 10);
5873 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
5874 gtk_widget_show (box2);
5877 button = gtk_button_new_with_label ("close");
5879 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
5880 GTK_SIGNAL_FUNC(gtk_widget_destroy),
5881 GTK_OBJECT (window));
5883 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
5884 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
5885 gtk_widget_grab_default (button);
5886 gtk_widget_show (button);
5889 if (!GTK_WIDGET_VISIBLE (window))
5890 gtk_widget_show (window);
5892 gtk_widget_destroy (window);
5898 static int progress_timer = 0;
5901 progress_timeout (gpointer data)
5905 new_val = GTK_PROGRESS_BAR (data)->percentage;
5910 gtk_progress_bar_update (GTK_PROGRESS_BAR (data), new_val);
5916 destroy_progress (GtkWidget *widget,
5919 gtk_timeout_remove (progress_timer);
5925 create_progress_bar (void)
5927 static GtkWidget *window = NULL;
5932 GtkTooltips *tooltips;
5936 window = gtk_dialog_new ();
5938 gtk_signal_connect (GTK_OBJECT (window), "destroy",
5939 GTK_SIGNAL_FUNC(destroy_progress),
5942 gtk_window_set_title (GTK_WINDOW (window), "dialog");
5943 gtk_container_border_width (GTK_CONTAINER (window), 0);
5945 tooltips = gtk_tooltips_new();
5947 vbox = gtk_vbox_new (FALSE, 5);
5948 gtk_container_border_width (GTK_CONTAINER (vbox), 10);
5949 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox),
5950 vbox, TRUE, TRUE, 0);
5951 gtk_widget_show (vbox);
5953 label = gtk_label_new ("progress...");
5954 gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
5955 gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, TRUE, 0);
5956 gtk_widget_show (label);
5958 pbar = gtk_progress_bar_new ();
5959 gtk_widget_set_events (pbar, GDK_ENTER_NOTIFY_MASK | GDK_LEAVE_NOTIFY_MASK);
5960 gtk_widget_set_usize (pbar, 200, 20);
5961 gtk_box_pack_start (GTK_BOX (vbox), pbar, TRUE, TRUE, 0);
5962 gtk_widget_show (pbar);
5963 gtk_tooltips_set_tip (tooltips, pbar, "Countdown is progressing yet!", "Secret!");
5964 gtk_tooltips_set_delay (tooltips, 0);
5966 progress_timer = gtk_timeout_add (100, progress_timeout, pbar);
5968 button = gtk_button_new_with_label ("close");
5969 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
5970 GTK_SIGNAL_FUNC(gtk_widget_destroy),
5971 GTK_OBJECT (window));
5972 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
5973 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
5974 button, TRUE, TRUE, 0);
5975 gtk_widget_grab_default (button);
5976 gtk_widget_show (button);
5979 if (!GTK_WIDGET_VISIBLE (window))
5980 gtk_widget_show (window);
5982 gtk_widget_destroy (window);
5989 static int color_idle = 0;
5992 color_idle_func (GtkWidget *preview)
5994 static int count = 1;
5998 for (i = 0; i < 256; i++)
6000 for (j = 0, k = 0; j < 256; j++)
6002 buf[k+0] = i + count;
6004 buf[k+2] = j + count;
6008 gtk_preview_draw_row (GTK_PREVIEW (preview), buf, 0, i, 256);
6013 gtk_widget_draw (preview, NULL);
6019 color_preview_destroy (GtkWidget *widget,
6022 gtk_idle_remove (color_idle);
6029 create_color_preview (void)
6031 static GtkWidget *window = NULL;
6038 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
6040 gtk_signal_connect (GTK_OBJECT (window), "destroy",
6041 GTK_SIGNAL_FUNC(color_preview_destroy),
6044 gtk_window_set_title (GTK_WINDOW (window), "test");
6045 gtk_container_border_width (GTK_CONTAINER (window), 10);
6047 preview = gtk_preview_new (GTK_PREVIEW_COLOR);
6048 gtk_preview_size (GTK_PREVIEW (preview), 256, 256);
6049 gtk_container_add (GTK_CONTAINER (window), preview);
6050 gtk_widget_show (preview);
6052 for (i = 0; i < 256; i++)
6054 for (j = 0, k = 0; j < 256; j++)
6062 gtk_preview_draw_row (GTK_PREVIEW (preview), buf, 0, i, 256);
6065 color_idle = gtk_idle_add ((GtkFunction) color_idle_func, preview);
6068 if (!GTK_WIDGET_VISIBLE (window))
6069 gtk_widget_show (window);
6071 gtk_widget_destroy (window);
6078 static int gray_idle = 0;
6081 gray_idle_func (GtkWidget *preview)
6083 static int count = 1;
6087 for (i = 0; i < 256; i++)
6089 for (j = 0; j < 256; j++)
6090 buf[j] = i + j + count;
6092 gtk_preview_draw_row (GTK_PREVIEW (preview), buf, 0, i, 256);
6097 gtk_widget_draw (preview, NULL);
6103 gray_preview_destroy (GtkWidget *widget,
6106 gtk_idle_remove (gray_idle);
6113 create_gray_preview (void)
6115 static GtkWidget *window = NULL;
6122 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
6124 gtk_signal_connect (GTK_OBJECT (window), "destroy",
6125 GTK_SIGNAL_FUNC(gray_preview_destroy),
6128 gtk_window_set_title (GTK_WINDOW (window), "test");
6129 gtk_container_border_width (GTK_CONTAINER (window), 10);
6131 preview = gtk_preview_new (GTK_PREVIEW_GRAYSCALE);
6132 gtk_preview_size (GTK_PREVIEW (preview), 256, 256);
6133 gtk_container_add (GTK_CONTAINER (window), preview);
6134 gtk_widget_show (preview);
6136 for (i = 0; i < 256; i++)
6138 for (j = 0; j < 256; j++)
6141 gtk_preview_draw_row (GTK_PREVIEW (preview), buf, 0, i, 256);
6144 gray_idle = gtk_idle_add ((GtkFunction) gray_idle_func, preview);
6147 if (!GTK_WIDGET_VISIBLE (window))
6148 gtk_widget_show (window);
6150 gtk_widget_destroy (window);
6158 selection_test_received (GtkWidget *list, GtkSelectionData *data)
6161 GtkWidget *list_item;
6165 if (data->length < 0)
6167 g_print ("Selection retrieval failed\n");
6170 if (data->type != GDK_SELECTION_TYPE_ATOM)
6172 g_print ("Selection \"TARGETS\" was not returned as atoms!\n");
6176 /* Clear out any current list items */
6178 gtk_list_clear_items (GTK_LIST(list), 0, -1);
6180 /* Add new items to list */
6182 atoms = (GdkAtom *)data->data;
6185 l = data->length / sizeof (GdkAtom);
6186 for (i = 0; i < l; i++)
6189 name = gdk_atom_name (atoms[i]);
6192 list_item = gtk_list_item_new_with_label (name);
6196 list_item = gtk_list_item_new_with_label ("(bad atom)");
6198 gtk_widget_show (list_item);
6199 item_list = g_list_append (item_list, list_item);
6202 gtk_list_append_items (GTK_LIST (list), item_list);
6208 selection_test_get_targets (GtkWidget *widget, GtkWidget *list)
6210 static GdkAtom targets_atom = GDK_NONE;
6212 if (targets_atom == GDK_NONE)
6213 targets_atom = gdk_atom_intern ("TARGETS", FALSE);
6215 gtk_selection_convert (list, GDK_SELECTION_PRIMARY, targets_atom,
6220 create_selection_test (void)
6222 static GtkWidget *window = NULL;
6225 GtkWidget *scrolled_win;
6231 window = gtk_dialog_new ();
6233 gtk_signal_connect (GTK_OBJECT (window), "destroy",
6234 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
6237 gtk_window_set_title (GTK_WINDOW (window), "Selection Test");
6238 gtk_container_border_width (GTK_CONTAINER (window), 0);
6240 /* Create the list */
6242 vbox = gtk_vbox_new (FALSE, 5);
6243 gtk_container_border_width (GTK_CONTAINER (vbox), 10);
6244 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), vbox,
6246 gtk_widget_show (vbox);
6248 label = gtk_label_new ("Gets available targets for current selection");
6249 gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
6250 gtk_widget_show (label);
6252 scrolled_win = gtk_scrolled_window_new (NULL, NULL);
6253 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
6254 GTK_POLICY_AUTOMATIC,
6255 GTK_POLICY_AUTOMATIC);
6256 gtk_box_pack_start (GTK_BOX (vbox), scrolled_win, TRUE, TRUE, 0);
6257 gtk_widget_set_usize (scrolled_win, 100, 200);
6258 gtk_widget_show (scrolled_win);
6260 list = gtk_list_new ();
6261 gtk_container_add (GTK_CONTAINER (scrolled_win), list);
6263 gtk_signal_connect (GTK_OBJECT(list), "selection_received",
6264 GTK_SIGNAL_FUNC (selection_test_received), NULL);
6265 gtk_widget_show (list);
6267 /* .. And create some buttons */
6268 button = gtk_button_new_with_label ("Get Targets");
6269 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
6270 button, TRUE, TRUE, 0);
6272 gtk_signal_connect (GTK_OBJECT (button), "clicked",
6273 GTK_SIGNAL_FUNC (selection_test_get_targets), list);
6274 gtk_widget_show (button);
6276 button = gtk_button_new_with_label ("Quit");
6277 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
6278 button, TRUE, TRUE, 0);
6280 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
6281 GTK_SIGNAL_FUNC (gtk_widget_destroy),
6282 GTK_OBJECT (window));
6283 gtk_widget_show (button);
6286 if (!GTK_WIDGET_VISIBLE (window))
6287 gtk_widget_show (window);
6289 gtk_widget_destroy (window);
6297 create_gamma_curve (void)
6299 static GtkWidget *window = NULL, *curve;
6300 static int count = 0;
6307 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
6308 gtk_window_set_title (GTK_WINDOW (window), "test");
6309 gtk_container_border_width (GTK_CONTAINER (window), 10);
6311 gtk_signal_connect (GTK_OBJECT (window), "destroy",
6312 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
6315 curve = gtk_gamma_curve_new ();
6316 gtk_container_add (GTK_CONTAINER (window), curve);
6317 gtk_widget_show (curve);
6320 max = 127 + (count % 2)*128;
6321 gtk_curve_set_range (GTK_CURVE (GTK_GAMMA_CURVE (curve)->curve),
6323 for (i = 0; i < max; ++i)
6324 vec[i] = (127 / sqrt (max)) * sqrt (i);
6325 gtk_curve_set_vector (GTK_CURVE (GTK_GAMMA_CURVE (curve)->curve),
6328 if (!GTK_WIDGET_VISIBLE (window))
6329 gtk_widget_show (window);
6330 else if (count % 4 == 3)
6332 gtk_widget_destroy (window);
6339 static int scroll_test_pos = 0.0;
6340 static GdkGC *scroll_test_gc = NULL;
6343 scroll_test_expose (GtkWidget *widget, GdkEventExpose *event,
6347 gint imin, imax, jmin, jmax;
6349 imin = (event->area.x) / 10;
6350 imax = (event->area.x + event->area.width + 9) / 10;
6352 jmin = ((int)adj->value + event->area.y) / 10;
6353 jmax = ((int)adj->value + event->area.y + event->area.height + 9) / 10;
6355 gdk_window_clear_area (widget->window,
6356 event->area.x, event->area.y,
6357 event->area.width, event->area.height);
6359 for (i=imin; i<imax; i++)
6360 for (j=jmin; j<jmax; j++)
6362 gdk_draw_rectangle (widget->window,
6363 widget->style->black_gc,
6365 10*i, 10*j - (int)adj->value, 1+i%10, 1+j%10);
6371 scroll_test_configure (GtkWidget *widget, GdkEventConfigure *event,
6374 adj->page_increment = 0.9 * widget->allocation.height;
6375 adj->page_size = widget->allocation.height;
6377 gtk_signal_emit_by_name (GTK_OBJECT (adj), "changed");
6381 scroll_test_adjustment_changed (GtkAdjustment *adj, GtkWidget *widget)
6383 gint source_min = (int)adj->value - scroll_test_pos;
6384 gint source_max = source_min + widget->allocation.height;
6386 gint dest_max = widget->allocation.height;
6390 scroll_test_pos = adj->value;
6392 if (!GTK_WIDGET_DRAWABLE (widget))
6399 rect.width = widget->allocation.width;
6400 rect.height = -source_min;
6401 if (rect.height > widget->allocation.height)
6402 rect.height = widget->allocation.height;
6405 dest_min = rect.height;
6410 rect.y = 2*widget->allocation.height - source_max;
6413 rect.width = widget->allocation.width;
6414 rect.height = widget->allocation.height - rect.y;
6416 source_max = widget->allocation.height;
6420 if (source_min != source_max)
6422 if (scroll_test_gc == NULL)
6424 scroll_test_gc = gdk_gc_new (widget->window);
6425 gdk_gc_set_exposures (scroll_test_gc, TRUE);
6428 gdk_draw_pixmap (widget->window,
6433 widget->allocation.width,
6434 source_max - source_min);
6436 /* Make sure graphics expose events are processed before scrolling
6439 while ((event = gdk_event_get_graphics_expose (widget->window)) != NULL)
6441 gtk_widget_event (widget, event);
6442 if (event->expose.count == 0)
6444 gdk_event_free (event);
6447 gdk_event_free (event);
6452 if (rect.height != 0)
6453 gtk_widget_draw (widget, &rect);
6458 create_scroll_test (void)
6460 static GtkWidget *window = NULL;
6462 GtkWidget *drawing_area;
6463 GtkWidget *scrollbar;
6469 window = gtk_dialog_new ();
6471 gtk_signal_connect (GTK_OBJECT (window), "destroy",
6472 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
6475 gtk_window_set_title (GTK_WINDOW (window), "Scroll Test");
6476 gtk_container_border_width (GTK_CONTAINER (window), 0);
6478 hbox = gtk_hbox_new (FALSE, 0);
6479 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), hbox,
6481 gtk_widget_show (hbox);
6483 drawing_area = gtk_drawing_area_new ();
6484 gtk_drawing_area_size (GTK_DRAWING_AREA (drawing_area), 200, 200);
6485 gtk_box_pack_start (GTK_BOX (hbox), drawing_area, TRUE, TRUE, 0);
6486 gtk_widget_show (drawing_area);
6488 gtk_widget_set_events (drawing_area, GDK_EXPOSURE_MASK);
6490 adj = GTK_ADJUSTMENT (gtk_adjustment_new (0.0, 0.0, 1000.0, 1.0, 180.0, 200.0));
6491 scroll_test_pos = 0.0;
6493 scrollbar = gtk_vscrollbar_new (adj);
6494 gtk_box_pack_start (GTK_BOX (hbox), scrollbar, FALSE, FALSE, 0);
6495 gtk_widget_show (scrollbar);
6497 gtk_signal_connect (GTK_OBJECT (drawing_area), "expose_event",
6498 GTK_SIGNAL_FUNC (scroll_test_expose), adj);
6499 gtk_signal_connect (GTK_OBJECT (drawing_area), "configure_event",
6500 GTK_SIGNAL_FUNC (scroll_test_configure), adj);
6503 gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
6504 GTK_SIGNAL_FUNC (scroll_test_adjustment_changed),
6507 /* .. And create some buttons */
6509 button = gtk_button_new_with_label ("Quit");
6510 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
6511 button, TRUE, TRUE, 0);
6513 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
6514 GTK_SIGNAL_FUNC (gtk_widget_destroy),
6515 GTK_OBJECT (window));
6516 gtk_widget_show (button);
6519 if (!GTK_WIDGET_VISIBLE (window))
6520 gtk_widget_show (window);
6522 gtk_widget_destroy (window);
6528 static int timer = 0;
6531 timeout_test (GtkWidget *label)
6533 static int count = 0;
6534 static char buffer[32];
6536 sprintf (buffer, "count: %d", ++count);
6537 gtk_label_set (GTK_LABEL (label), buffer);
6543 start_timeout_test (GtkWidget *widget,
6548 timer = gtk_timeout_add (100, (GtkFunction) timeout_test, label);
6553 stop_timeout_test (GtkWidget *widget,
6558 gtk_timeout_remove (timer);
6564 destroy_timeout_test (GtkWidget *widget,
6567 stop_timeout_test (NULL, NULL);
6573 create_timeout_test (void)
6575 static GtkWidget *window = NULL;
6581 window = gtk_dialog_new ();
6583 gtk_signal_connect (GTK_OBJECT (window), "destroy",
6584 GTK_SIGNAL_FUNC(destroy_timeout_test),
6587 gtk_window_set_title (GTK_WINDOW (window), "Timeout Test");
6588 gtk_container_border_width (GTK_CONTAINER (window), 0);
6590 label = gtk_label_new ("count: 0");
6591 gtk_misc_set_padding (GTK_MISC (label), 10, 10);
6592 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox),
6593 label, TRUE, TRUE, 0);
6594 gtk_widget_show (label);
6596 button = gtk_button_new_with_label ("close");
6597 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
6598 GTK_SIGNAL_FUNC(gtk_widget_destroy),
6599 GTK_OBJECT (window));
6600 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
6601 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
6602 button, TRUE, TRUE, 0);
6603 gtk_widget_grab_default (button);
6604 gtk_widget_show (button);
6606 button = gtk_button_new_with_label ("start");
6607 gtk_signal_connect (GTK_OBJECT (button), "clicked",
6608 GTK_SIGNAL_FUNC(start_timeout_test),
6610 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
6611 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
6612 button, TRUE, TRUE, 0);
6613 gtk_widget_show (button);
6615 button = gtk_button_new_with_label ("stop");
6616 gtk_signal_connect (GTK_OBJECT (button), "clicked",
6617 GTK_SIGNAL_FUNC(stop_timeout_test),
6619 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
6620 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
6621 button, TRUE, TRUE, 0);
6622 gtk_widget_show (button);
6625 if (!GTK_WIDGET_VISIBLE (window))
6626 gtk_widget_show (window);
6628 gtk_widget_destroy (window);
6635 static int idle = 0;
6638 idle_test (GtkWidget *label)
6640 static int count = 0;
6641 static char buffer[32];
6643 sprintf (buffer, "count: %d", ++count);
6644 gtk_label_set (GTK_LABEL (label), buffer);
6650 start_idle_test (GtkWidget *widget,
6655 idle = gtk_idle_add ((GtkFunction) idle_test, label);
6660 stop_idle_test (GtkWidget *widget,
6665 gtk_idle_remove (idle);
6671 destroy_idle_test (GtkWidget *widget,
6674 stop_idle_test (NULL, NULL);
6680 toggle_idle_container (GtkObject *button,
6681 GtkContainer *container)
6683 gtk_container_set_resize_mode (container, (guint) gtk_object_get_user_data (button));
6687 create_idle_test (void)
6689 static GtkWidget *window = NULL;
6692 GtkWidget *container;
6699 window = gtk_dialog_new ();
6701 gtk_signal_connect (GTK_OBJECT (window), "destroy",
6702 GTK_SIGNAL_FUNC(destroy_idle_test),
6705 gtk_window_set_title (GTK_WINDOW (window), "Idle Test");
6706 gtk_container_border_width (GTK_CONTAINER (window), 0);
6708 label = gtk_label_new ("count: 0");
6709 gtk_misc_set_padding (GTK_MISC (label), 10, 10);
6710 gtk_widget_show (label);
6713 gtk_widget_new (GTK_TYPE_HBOX,
6714 "GtkWidget::visible", TRUE,
6715 /* "GtkContainer::child", gtk_widget_new (GTK_TYPE_HBOX,
6716 * "GtkWidget::visible", TRUE,
6718 "GtkContainer::child", label,
6721 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox),
6722 container, TRUE, TRUE, 0);
6725 gtk_widget_new (GTK_TYPE_FRAME,
6726 "GtkContainer::border_width", 5,
6727 "GtkFrame::label", "Label Container",
6728 "GtkWidget::visible", TRUE,
6729 "GtkWidget::parent", GTK_DIALOG (window)->vbox,
6732 gtk_widget_new (GTK_TYPE_VBOX,
6733 "GtkWidget::visible", TRUE,
6734 "GtkWidget::parent", frame,
6737 gtk_widget_new (GTK_TYPE_RADIO_BUTTON,
6738 "GtkButton::label", "Resize-Parent",
6739 "GtkObject::user_data", (void*)GTK_RESIZE_PARENT,
6740 "GtkObject::signal::clicked", toggle_idle_container, container,
6741 "GtkWidget::visible", TRUE,
6742 "GtkWidget::parent", box,
6745 gtk_widget_new (GTK_TYPE_RADIO_BUTTON,
6746 "GtkButton::label", "Resize-Queue",
6747 "GtkObject::user_data", (void*)GTK_RESIZE_QUEUE,
6748 "GtkObject::signal::clicked", toggle_idle_container, container,
6749 "GtkRadioButton::group", button,
6750 "GtkWidget::visible", TRUE,
6751 "GtkWidget::parent", box,
6754 gtk_widget_new (GTK_TYPE_RADIO_BUTTON,
6755 "GtkButton::label", "Resize-Immediate",
6756 "GtkObject::user_data", (void*)GTK_RESIZE_IMMEDIATE,
6757 "GtkObject::signal::clicked", toggle_idle_container, container,
6758 "GtkRadioButton::group", button,
6759 "GtkWidget::visible", TRUE,
6760 "GtkWidget::parent", box,
6764 button = gtk_button_new_with_label ("close");
6765 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
6766 GTK_SIGNAL_FUNC(gtk_widget_destroy),
6767 GTK_OBJECT (window));
6768 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
6769 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
6770 button, TRUE, TRUE, 0);
6771 gtk_widget_grab_default (button);
6772 gtk_widget_show (button);
6774 button = gtk_button_new_with_label ("start");
6775 gtk_signal_connect (GTK_OBJECT (button), "clicked",
6776 GTK_SIGNAL_FUNC(start_idle_test),
6778 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
6779 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
6780 button, TRUE, TRUE, 0);
6781 gtk_widget_show (button);
6783 button = gtk_button_new_with_label ("stop");
6784 gtk_signal_connect (GTK_OBJECT (button), "clicked",
6785 GTK_SIGNAL_FUNC(stop_idle_test),
6787 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
6788 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
6789 button, TRUE, TRUE, 0);
6790 gtk_widget_show (button);
6793 if (!GTK_WIDGET_VISIBLE (window))
6794 gtk_widget_show (window);
6796 gtk_widget_destroy (window);
6800 reload_rc_file (void)
6804 if (gtk_rc_reparse_all ())
6806 toplevels = gdk_window_get_toplevels();
6810 gdk_window_get_user_data (toplevels->data, (gpointer *)&widget);
6813 gtk_widget_reset_rc_styles (widget);
6815 toplevels = toplevels->next;
6817 g_list_free (toplevels);
6822 reload_all_rc_files (void)
6824 static GdkAtom atom_rcfiles = GDK_NONE;
6830 atom_rcfiles = gdk_atom_intern("_GTK_READ_RCFILES", FALSE);
6832 for(i = 0; i < 5; i++)
6834 sev.data_format = 32;
6835 sev.message_type = atom_rcfiles;
6836 gdk_event_send_clientmessage_toall ((GdkEvent *) &sev);
6840 create_rc_file (void)
6842 static GtkWidget *window = NULL;
6847 window = gtk_dialog_new ();
6849 gtk_signal_connect (GTK_OBJECT (window), "destroy",
6850 GTK_SIGNAL_FUNC(destroy_idle_test),
6853 gtk_window_set_title (GTK_WINDOW (window), "Reload Rc file");
6854 gtk_container_border_width (GTK_CONTAINER (window), 0);
6856 button = gtk_button_new_with_label ("Reload");
6857 gtk_signal_connect (GTK_OBJECT (button), "clicked",
6858 GTK_SIGNAL_FUNC(reload_rc_file), NULL);
6859 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
6860 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
6861 button, TRUE, TRUE, 0);
6862 gtk_widget_grab_default (button);
6863 gtk_widget_show (button);
6865 button = gtk_button_new_with_label ("Reload All");
6866 gtk_signal_connect (GTK_OBJECT (button), "clicked",
6867 GTK_SIGNAL_FUNC(reload_all_rc_files), NULL);
6868 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
6869 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
6870 button, TRUE, TRUE, 0);
6871 gtk_widget_show (button);
6873 button = gtk_button_new_with_label ("Close");
6874 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
6875 GTK_SIGNAL_FUNC(gtk_widget_destroy),
6876 GTK_OBJECT (window));
6877 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
6878 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
6879 button, TRUE, TRUE, 0);
6880 gtk_widget_show (button);
6884 if (!GTK_WIDGET_VISIBLE (window))
6885 gtk_widget_show (window);
6887 gtk_widget_destroy (window);
6891 * Test of recursive mainloop
6895 mainloop_destroyed (GtkWidget *w, GtkWidget **window)
6902 create_mainloop (void)
6904 static GtkWidget *window = NULL;
6910 window = gtk_dialog_new ();
6912 gtk_window_set_title (GTK_WINDOW (window), "Test Main Loop");
6914 gtk_signal_connect (GTK_OBJECT (window), "destroy",
6915 GTK_SIGNAL_FUNC(mainloop_destroyed),
6918 label = gtk_label_new ("In recursive main loop...");
6919 gtk_misc_set_padding (GTK_MISC(label), 20, 20);
6921 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), label,
6923 gtk_widget_show (label);
6925 button = gtk_button_new_with_label ("Leave");
6926 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area), button,
6929 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
6930 GTK_SIGNAL_FUNC (gtk_widget_destroy),
6931 GTK_OBJECT (window));
6933 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
6934 gtk_widget_grab_default (button);
6936 gtk_widget_show (button);
6939 if (!GTK_WIDGET_VISIBLE (window))
6941 gtk_widget_show (window);
6943 g_print ("create_mainloop: start\n");
6945 g_print ("create_mainloop: done\n");
6948 gtk_widget_destroy (window);
6953 * Main Window and Exit
6956 do_exit (GtkWidget *widget, GtkWidget *window)
6958 gtk_widget_destroy (window);
6963 create_main_window (void)
6970 { "button box", create_button_box },
6971 { "buttons", create_buttons },
6972 { "check buttons", create_check_buttons },
6973 { "clist", create_clist},
6974 { "color selection", create_color_selection },
6975 { "ctree", create_ctree },
6976 { "cursors", create_cursors },
6977 { "dialog", create_dialog },
6978 { "dnd", create_dnd },
6979 { "entry", create_entry },
6980 { "file selection", create_file_selection },
6981 { "font selection", create_font_selection },
6982 { "gamma curve", create_gamma_curve },
6983 { "handle box", create_handle_box },
6984 { "list", create_list },
6985 { "menus", create_menus },
6986 { "miscellaneous", NULL },
6987 { "notebook", create_notebook },
6988 { "panes", create_panes },
6989 { "pixmap", create_pixmap },
6990 { "preview color", create_color_preview },
6991 { "preview gray", create_gray_preview },
6992 { "progress bar", create_progress_bar },
6993 { "radio buttons", create_radio_buttons },
6994 { "range controls", create_range_controls },
6995 { "rc file", create_rc_file },
6996 { "reparent", create_reparent },
6997 { "rulers", create_rulers },
6998 { "scrolled windows", create_scrolled_windows },
6999 { "shapes", create_shapes },
7000 { "spinbutton", create_spins },
7001 { "statusbar", create_statusbar },
7002 { "test idle", create_idle_test },
7003 { "test mainloop", create_mainloop },
7004 { "test scrolling", create_scroll_test },
7005 { "test selection", create_selection_test },
7006 { "test timeout", create_timeout_test },
7007 { "text", create_text },
7008 { "toggle buttons", create_toggle_buttons },
7009 { "toolbar", create_toolbar },
7010 { "tooltips", create_tooltips },
7011 { "tree", create_tree_mode_window},
7012 { "WM hints", create_wmhints },
7014 int nbuttons = sizeof (buttons) / sizeof (buttons[0]);
7018 GtkWidget *scrolled_window;
7022 GtkWidget *separator;
7025 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
7026 gtk_window_set_policy (GTK_WINDOW (window), FALSE, FALSE, FALSE);
7027 gtk_widget_set_name (window, "main window");
7028 gtk_widget_set_usize (window, 200, 400);
7029 gtk_widget_set_uposition (window, 20, 20);
7031 gtk_signal_connect (GTK_OBJECT (window), "destroy",
7032 GTK_SIGNAL_FUNC(gtk_main_quit),
7034 gtk_signal_connect (GTK_OBJECT (window), "delete-event",
7035 GTK_SIGNAL_FUNC (gtk_false),
7038 box1 = gtk_vbox_new (FALSE, 0);
7039 gtk_container_add (GTK_CONTAINER (window), box1);
7040 gtk_widget_show (box1);
7042 if (gtk_micro_version > 0)
7054 label = gtk_label_new (buffer);
7055 gtk_widget_show (label);
7056 gtk_box_pack_start (GTK_BOX (box1), label, FALSE, FALSE, 0);
7058 scrolled_window = gtk_scrolled_window_new (NULL, NULL);
7059 gtk_container_border_width (GTK_CONTAINER (scrolled_window), 10);
7060 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
7061 GTK_POLICY_AUTOMATIC,
7062 GTK_POLICY_AUTOMATIC);
7063 GTK_WIDGET_UNSET_FLAGS (GTK_SCROLLED_WINDOW (scrolled_window)->vscrollbar, GTK_CAN_FOCUS);
7064 gtk_box_pack_start (GTK_BOX (box1), scrolled_window, TRUE, TRUE, 0);
7065 gtk_widget_show (scrolled_window);
7067 box2 = gtk_vbox_new (FALSE, 0);
7068 gtk_container_border_width (GTK_CONTAINER (box2), 10);
7069 gtk_container_add (GTK_CONTAINER (scrolled_window), box2);
7070 gtk_container_set_focus_vadjustment (GTK_CONTAINER (box2),
7071 gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (scrolled_window)));
7072 gtk_widget_show (box2);
7074 for (i = 0; i < nbuttons; i++)
7076 button = gtk_button_new_with_label (buttons[i].label);
7077 if (buttons[i].func)
7078 gtk_signal_connect (GTK_OBJECT (button),
7080 GTK_SIGNAL_FUNC(buttons[i].func),
7083 gtk_widget_set_sensitive (button, FALSE);
7084 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
7085 gtk_widget_show (button);
7088 separator = gtk_hseparator_new ();
7089 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
7090 gtk_widget_show (separator);
7092 box2 = gtk_vbox_new (FALSE, 10);
7093 gtk_container_border_width (GTK_CONTAINER (box2), 10);
7094 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
7095 gtk_widget_show (box2);
7097 button = gtk_button_new_with_label ("close");
7098 gtk_signal_connect (GTK_OBJECT (button), "clicked",
7099 GTK_SIGNAL_FUNC (do_exit),
7101 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
7102 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
7103 gtk_widget_grab_default (button);
7104 gtk_widget_show (button);
7106 gtk_widget_show (window);
7110 main (int argc, char *argv[])
7112 srand (time (NULL));
7116 gtk_init (&argc, &argv);
7119 gle_init (&argc, &argv);
7120 #endif /* !HAVE_LIBGLE */
7122 gtk_rc_parse ("testgtkrc");
7124 create_main_window ();