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 Free
16 * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21 #include "../gdk/gdk.h"
22 #include "../gdk/gdkx.h"
24 #include "circles.xbm"
26 /* Variables used by the Drag/Drop and Shape Window demos */
27 static GtkWidget *modeller = NULL;
28 static GtkWidget *sheets = NULL;
29 static GtkWidget *rings = NULL;
30 void create_shapes(void);
33 /* macro, structure and variables used by tree window demos */
34 #define DEFAULT_NUMBER_OF_ITEM 3
35 #define DEFAULT_RECURSION_LEVEL 3
38 GSList* selection_mode_group;
39 GtkWidget* single_button;
40 GtkWidget* browse_button;
41 GtkWidget* multiple_button;
42 GtkWidget* draw_line_button;
43 GtkWidget* view_line_button;
44 GtkWidget* no_root_item_button;
45 GtkWidget* nb_item_spinner;
46 GtkWidget* recursion_spinner;
47 } sTreeSampleSelection;
49 typedef struct sTreeButtons {
51 GtkWidget* add_button;
52 GtkWidget* remove_button;
54 /* end of tree section */
57 destroy_tooltips (GtkWidget *widget, GtkWindow **window)
59 GtkTooltips *tt = gtk_object_get_data (GTK_OBJECT (*window), "tooltips");
60 gtk_object_unref (GTK_OBJECT (tt));
66 button_window (GtkWidget *widget,
69 if (!GTK_WIDGET_VISIBLE (button))
70 gtk_widget_show (button);
72 gtk_widget_hide (button);
78 static GtkWidget *window = NULL;
82 GtkWidget *button[10];
87 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
89 gtk_signal_connect (GTK_OBJECT (window), "destroy",
90 GTK_SIGNAL_FUNC (gtk_widget_destroyed),
93 gtk_window_set_title (GTK_WINDOW (window), "buttons");
94 gtk_container_border_width (GTK_CONTAINER (window), 0);
96 box1 = gtk_vbox_new (FALSE, 0);
97 gtk_container_add (GTK_CONTAINER (window), box1);
98 gtk_widget_show (box1);
101 table = gtk_table_new (3, 3, FALSE);
102 gtk_table_set_row_spacings (GTK_TABLE (table), 5);
103 gtk_table_set_col_spacings (GTK_TABLE (table), 5);
104 gtk_container_border_width (GTK_CONTAINER (table), 10);
105 gtk_box_pack_start (GTK_BOX (box1), table, TRUE, TRUE, 0);
106 gtk_widget_show (table);
109 button[0] = gtk_button_new_with_label ("button1");
110 button[1] = gtk_button_new_with_label ("button2");
111 button[2] = gtk_button_new_with_label ("button3");
112 button[3] = gtk_button_new_with_label ("button4");
113 button[4] = gtk_button_new_with_label ("button5");
114 button[5] = gtk_button_new_with_label ("button6");
115 button[6] = gtk_button_new_with_label ("button7");
116 button[7] = gtk_button_new_with_label ("button8");
117 button[8] = gtk_button_new_with_label ("button9");
119 gtk_signal_connect (GTK_OBJECT (button[0]), "clicked",
120 GTK_SIGNAL_FUNC(button_window),
123 gtk_table_attach (GTK_TABLE (table), button[0], 0, 1, 0, 1,
124 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
125 gtk_widget_show (button[0]);
127 gtk_signal_connect (GTK_OBJECT (button[1]), "clicked",
128 GTK_SIGNAL_FUNC(button_window),
131 gtk_table_attach (GTK_TABLE (table), button[1], 1, 2, 1, 2,
132 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
133 gtk_widget_show (button[1]);
135 gtk_signal_connect (GTK_OBJECT (button[2]), "clicked",
136 GTK_SIGNAL_FUNC(button_window),
138 gtk_table_attach (GTK_TABLE (table), button[2], 2, 3, 2, 3,
139 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
140 gtk_widget_show (button[2]);
142 gtk_signal_connect (GTK_OBJECT (button[3]), "clicked",
143 GTK_SIGNAL_FUNC(button_window),
145 gtk_table_attach (GTK_TABLE (table), button[3], 0, 1, 2, 3,
146 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
147 gtk_widget_show (button[3]);
149 gtk_signal_connect (GTK_OBJECT (button[4]), "clicked",
150 GTK_SIGNAL_FUNC(button_window),
152 gtk_table_attach (GTK_TABLE (table), button[4], 2, 3, 0, 1,
153 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
154 gtk_widget_show (button[4]);
156 gtk_signal_connect (GTK_OBJECT (button[5]), "clicked",
157 GTK_SIGNAL_FUNC(button_window),
159 gtk_table_attach (GTK_TABLE (table), button[5], 1, 2, 2, 3,
160 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
161 gtk_widget_show (button[5]);
163 gtk_signal_connect (GTK_OBJECT (button[6]), "clicked",
164 GTK_SIGNAL_FUNC(button_window),
166 gtk_table_attach (GTK_TABLE (table), button[6], 1, 2, 0, 1,
167 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
168 gtk_widget_show (button[6]);
170 gtk_signal_connect (GTK_OBJECT (button[7]), "clicked",
171 GTK_SIGNAL_FUNC(button_window),
173 gtk_table_attach (GTK_TABLE (table), button[7], 2, 3, 1, 2,
174 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
175 gtk_widget_show (button[7]);
177 gtk_signal_connect (GTK_OBJECT (button[8]), "clicked",
178 GTK_SIGNAL_FUNC(button_window),
180 gtk_table_attach (GTK_TABLE (table), button[8], 0, 1, 1, 2,
181 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
182 gtk_widget_show (button[8]);
185 separator = gtk_hseparator_new ();
186 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
187 gtk_widget_show (separator);
190 box2 = gtk_vbox_new (FALSE, 10);
191 gtk_container_border_width (GTK_CONTAINER (box2), 10);
192 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
193 gtk_widget_show (box2);
196 button[9] = gtk_button_new_with_label ("close");
197 gtk_signal_connect_object (GTK_OBJECT (button[9]), "clicked",
198 GTK_SIGNAL_FUNC(gtk_widget_destroy),
199 GTK_OBJECT (window));
200 gtk_box_pack_start (GTK_BOX (box2), button[9], TRUE, TRUE, 0);
201 GTK_WIDGET_SET_FLAGS (button[9], GTK_CAN_DEFAULT);
202 gtk_widget_grab_default (button[9]);
203 gtk_widget_show (button[9]);
206 if (!GTK_WIDGET_VISIBLE (window))
207 gtk_widget_show (window);
209 gtk_widget_destroy (window);
213 create_toggle_buttons ()
215 static GtkWidget *window = NULL;
219 GtkWidget *separator;
223 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
225 gtk_signal_connect (GTK_OBJECT (window), "destroy",
226 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
229 gtk_window_set_title (GTK_WINDOW (window), "toggle buttons");
230 gtk_container_border_width (GTK_CONTAINER (window), 0);
233 box1 = gtk_vbox_new (FALSE, 0);
234 gtk_container_add (GTK_CONTAINER (window), box1);
235 gtk_widget_show (box1);
238 box2 = gtk_vbox_new (FALSE, 10);
239 gtk_container_border_width (GTK_CONTAINER (box2), 10);
240 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
241 gtk_widget_show (box2);
244 button = gtk_toggle_button_new_with_label ("button1");
245 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
246 gtk_widget_show (button);
248 button = gtk_toggle_button_new_with_label ("button2");
249 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
250 gtk_widget_show (button);
252 button = gtk_toggle_button_new_with_label ("button3");
253 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
254 gtk_widget_show (button);
257 separator = gtk_hseparator_new ();
258 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
259 gtk_widget_show (separator);
262 box2 = gtk_vbox_new (FALSE, 10);
263 gtk_container_border_width (GTK_CONTAINER (box2), 10);
264 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
265 gtk_widget_show (box2);
268 button = gtk_button_new_with_label ("close");
269 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
270 GTK_SIGNAL_FUNC(gtk_widget_destroy),
271 GTK_OBJECT (window));
272 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
273 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
274 gtk_widget_grab_default (button);
275 gtk_widget_show (button);
278 if (!GTK_WIDGET_VISIBLE (window))
279 gtk_widget_show (window);
281 gtk_widget_destroy (window);
285 create_check_buttons ()
287 static GtkWidget *window = NULL;
291 GtkWidget *separator;
295 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
297 gtk_signal_connect (GTK_OBJECT (window), "destroy",
298 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
301 gtk_window_set_title (GTK_WINDOW (window), "check buttons");
302 gtk_container_border_width (GTK_CONTAINER (window), 0);
305 box1 = gtk_vbox_new (FALSE, 0);
306 gtk_container_add (GTK_CONTAINER (window), box1);
307 gtk_widget_show (box1);
310 box2 = gtk_vbox_new (FALSE, 10);
311 gtk_container_border_width (GTK_CONTAINER (box2), 10);
312 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
313 gtk_widget_show (box2);
316 button = gtk_check_button_new_with_label ("button1");
317 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
318 gtk_widget_show (button);
320 button = gtk_check_button_new_with_label ("button2");
321 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
322 gtk_widget_show (button);
324 button = gtk_check_button_new_with_label ("button3");
325 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
326 gtk_widget_show (button);
329 separator = gtk_hseparator_new ();
330 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
331 gtk_widget_show (separator);
334 box2 = gtk_vbox_new (FALSE, 10);
335 gtk_container_border_width (GTK_CONTAINER (box2), 10);
336 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
337 gtk_widget_show (box2);
340 button = gtk_button_new_with_label ("close");
341 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
342 GTK_SIGNAL_FUNC(gtk_widget_destroy),
343 GTK_OBJECT (window));
344 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
345 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
346 gtk_widget_grab_default (button);
347 gtk_widget_show (button);
350 if (!GTK_WIDGET_VISIBLE (window))
351 gtk_widget_show (window);
353 gtk_widget_destroy (window);
357 create_radio_buttons ()
359 static GtkWidget *window = NULL;
363 GtkWidget *separator;
367 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
369 gtk_signal_connect (GTK_OBJECT (window), "destroy",
370 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
373 gtk_window_set_title (GTK_WINDOW (window), "radio buttons");
374 gtk_container_border_width (GTK_CONTAINER (window), 0);
377 box1 = gtk_vbox_new (FALSE, 0);
378 gtk_container_add (GTK_CONTAINER (window), box1);
379 gtk_widget_show (box1);
382 box2 = gtk_vbox_new (FALSE, 10);
383 gtk_container_border_width (GTK_CONTAINER (box2), 10);
384 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
385 gtk_widget_show (box2);
388 button = gtk_radio_button_new_with_label (NULL, "button1");
389 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
390 gtk_widget_show (button);
392 button = gtk_radio_button_new_with_label (
393 gtk_radio_button_group (GTK_RADIO_BUTTON (button)),
395 gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON (button), TRUE);
396 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
397 gtk_widget_show (button);
399 button = gtk_radio_button_new_with_label (
400 gtk_radio_button_group (GTK_RADIO_BUTTON (button)),
402 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
403 gtk_widget_show (button);
406 separator = gtk_hseparator_new ();
407 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
408 gtk_widget_show (separator);
411 box2 = gtk_vbox_new (FALSE, 10);
412 gtk_container_border_width (GTK_CONTAINER (box2), 10);
413 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
414 gtk_widget_show (box2);
417 button = gtk_button_new_with_label ("close");
418 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
419 GTK_SIGNAL_FUNC(gtk_widget_destroy),
420 GTK_OBJECT (window));
421 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
422 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
423 gtk_widget_grab_default (button);
424 gtk_widget_show (button);
427 if (!GTK_WIDGET_VISIBLE (window))
428 gtk_widget_show (window);
430 gtk_widget_destroy (window);
434 bbox_widget_destroy (GtkWidget* widget, GtkWidget* todestroy)
439 create_bbox_window (gint horizontal,
452 /* create a new window */
453 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
454 gtk_window_set_title (GTK_WINDOW (window), title);
456 gtk_signal_connect (GTK_OBJECT (window), "destroy",
457 GTK_SIGNAL_FUNC(bbox_widget_destroy), window);
461 gtk_widget_set_usize (window, 550, 60);
462 gtk_widget_set_uposition (window, 150, pos);
463 box1 = gtk_vbox_new (FALSE, 0);
467 gtk_widget_set_usize (window, 150, 400);
468 gtk_widget_set_uposition (window, pos, 200);
469 box1 = gtk_vbox_new (FALSE, 0);
472 gtk_container_add (GTK_CONTAINER (window), box1);
473 gtk_widget_show (box1);
476 bbox = gtk_hbutton_box_new();
478 bbox = gtk_vbutton_box_new();
479 gtk_button_box_set_layout (GTK_BUTTON_BOX (bbox), layout);
480 gtk_button_box_set_spacing (GTK_BUTTON_BOX (bbox), spacing);
481 gtk_button_box_set_child_size (GTK_BUTTON_BOX (bbox), child_w, child_h);
482 gtk_widget_show (bbox);
484 gtk_container_border_width (GTK_CONTAINER(box1), 25);
485 gtk_box_pack_start (GTK_BOX (box1), bbox, TRUE, TRUE, 0);
487 button = gtk_button_new_with_label ("OK");
488 gtk_container_add (GTK_CONTAINER(bbox), button);
490 gtk_signal_connect (GTK_OBJECT (button), "clicked",
491 GTK_SIGNAL_FUNC(bbox_widget_destroy), window);
493 gtk_widget_show (button);
495 button = gtk_button_new_with_label ("Cancel");
496 gtk_container_add (GTK_CONTAINER(bbox), button);
497 gtk_widget_show (button);
499 button = gtk_button_new_with_label ("Help");
500 gtk_container_add (GTK_CONTAINER(bbox), button);
501 gtk_widget_show (button);
503 gtk_widget_show (window);
509 create_bbox_window (TRUE, "Spread", 50, 40, 85, 28, GTK_BUTTONBOX_SPREAD);
510 create_bbox_window (TRUE, "Edge", 200, 40, 85, 25, GTK_BUTTONBOX_EDGE);
511 create_bbox_window (TRUE, "Start", 350, 40, 85, 25, GTK_BUTTONBOX_START);
512 create_bbox_window (TRUE, "End", 500, 15, 30, 25, GTK_BUTTONBOX_END);
518 create_bbox_window (FALSE, "Spread", 50, 40, 85, 25, GTK_BUTTONBOX_SPREAD);
519 create_bbox_window (FALSE, "Edge", 250, 40, 85, 28, GTK_BUTTONBOX_EDGE);
520 create_bbox_window (FALSE, "Start", 450, 40, 85, 25, GTK_BUTTONBOX_START);
521 create_bbox_window (FALSE, "End", 650, 15, 30, 25, GTK_BUTTONBOX_END);
527 static GtkWidget* window = NULL;
533 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
534 gtk_window_set_title (GTK_WINDOW (window),
537 gtk_signal_connect (GTK_OBJECT (window), "destroy",
538 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
541 gtk_container_border_width (GTK_CONTAINER (window), 20);
544 *these 15 lines are a nice and easy example for GtkHButtonBox
546 bbox = gtk_hbutton_box_new ();
547 gtk_container_add (GTK_CONTAINER (window), bbox);
548 gtk_widget_show (bbox);
550 button = gtk_button_new_with_label ("Horizontal");
551 gtk_signal_connect (GTK_OBJECT (button), "clicked",
552 GTK_SIGNAL_FUNC(test_hbbox), 0);
553 gtk_container_add (GTK_CONTAINER (bbox), button);
554 gtk_widget_show (button);
556 button = gtk_button_new_with_label ("Vertical");
557 gtk_signal_connect (GTK_OBJECT (button), "clicked",
558 GTK_SIGNAL_FUNC(test_vbbox), 0);
559 gtk_container_add (GTK_CONTAINER (bbox), button);
560 gtk_widget_show (button);
563 if (!GTK_WIDGET_VISIBLE (window))
564 gtk_widget_show (window);
566 gtk_widget_destroy (window);
570 new_pixmap (char *filename,
572 GdkColor *background)
578 pixmap = gdk_pixmap_create_from_xpm (window, &mask,
581 wpixmap = gtk_pixmap_new (pixmap, mask);
587 set_toolbar_horizontal (GtkWidget *widget,
590 gtk_toolbar_set_orientation (GTK_TOOLBAR (data), GTK_ORIENTATION_HORIZONTAL);
594 set_toolbar_vertical (GtkWidget *widget,
597 gtk_toolbar_set_orientation (GTK_TOOLBAR (data), GTK_ORIENTATION_VERTICAL);
601 set_toolbar_icons (GtkWidget *widget,
604 gtk_toolbar_set_style (GTK_TOOLBAR (data), GTK_TOOLBAR_ICONS);
608 set_toolbar_text (GtkWidget *widget,
611 gtk_toolbar_set_style (GTK_TOOLBAR (data), GTK_TOOLBAR_TEXT);
615 set_toolbar_both (GtkWidget *widget,
618 gtk_toolbar_set_style (GTK_TOOLBAR (data), GTK_TOOLBAR_BOTH);
622 set_toolbar_small_space (GtkWidget *widget,
625 gtk_toolbar_set_space_size (GTK_TOOLBAR (data), 5);
629 set_toolbar_big_space (GtkWidget *widget,
632 gtk_toolbar_set_space_size (GTK_TOOLBAR (data), 10);
636 set_toolbar_enable (GtkWidget *widget,
639 gtk_toolbar_set_tooltips (GTK_TOOLBAR (data), TRUE);
643 set_toolbar_disable (GtkWidget *widget,
646 gtk_toolbar_set_tooltips (GTK_TOOLBAR (data), FALSE);
650 create_toolbar (void)
652 static GtkWidget *window = NULL;
658 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
659 gtk_window_set_title (GTK_WINDOW (window), "Toolbar test");
660 gtk_window_set_policy (GTK_WINDOW (window), FALSE, TRUE, TRUE);
662 gtk_signal_connect (GTK_OBJECT (window), "destroy",
663 GTK_SIGNAL_FUNC (gtk_widget_destroyed),
666 gtk_container_border_width (GTK_CONTAINER (window), 0);
667 gtk_widget_realize (window);
669 toolbar = gtk_toolbar_new (GTK_ORIENTATION_HORIZONTAL, GTK_TOOLBAR_BOTH);
671 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
672 "Horizontal", "Horizontal toolbar layout", "Toolbar/Horizontal",
673 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
674 (GtkSignalFunc) set_toolbar_horizontal, toolbar);
675 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
676 "Vertical", "Vertical toolbar layout", "Toolbar/Vertical",
677 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
678 (GtkSignalFunc) set_toolbar_vertical, toolbar);
680 gtk_toolbar_append_space (GTK_TOOLBAR(toolbar));
682 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
683 "Icons", "Only show toolbar icons", "Toolbar/IconsOnly",
684 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
685 (GtkSignalFunc) set_toolbar_icons, toolbar);
686 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
687 "Text", "Only show toolbar text", "Toolbar/TextOnly",
688 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
689 (GtkSignalFunc) set_toolbar_text, toolbar);
690 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
691 "Both", "Show toolbar icons and text", "Toolbar/Both",
692 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
693 (GtkSignalFunc) set_toolbar_both, toolbar);
695 gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
697 entry = gtk_entry_new ();
698 gtk_widget_show(entry);
699 gtk_toolbar_append_widget (GTK_TOOLBAR (toolbar), entry, "This is an unusable GtkEntry ;)", "Hey don't click me!!!");
701 gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
703 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
704 "Small", "Use small spaces", "Toolbar/Small",
705 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
706 (GtkSignalFunc) set_toolbar_small_space, toolbar);
707 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
708 "Big", "Use big spaces", "Toolbar/Big",
709 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
710 (GtkSignalFunc) set_toolbar_big_space, toolbar);
712 gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
714 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
715 "Enable", "Enable tooltips", NULL,
716 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
717 (GtkSignalFunc) set_toolbar_enable, toolbar);
718 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
719 "Disable", "Disable tooltips", NULL,
720 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
721 (GtkSignalFunc) set_toolbar_disable, toolbar);
723 gtk_container_add (GTK_CONTAINER (window), toolbar);
724 gtk_widget_show (toolbar);
727 if (!GTK_WIDGET_VISIBLE (window))
728 gtk_widget_show (window);
730 gtk_widget_destroy (window);
734 make_toolbar (GtkWidget *window)
738 if (!GTK_WIDGET_REALIZED (window))
739 gtk_widget_realize (window);
741 toolbar = gtk_toolbar_new (GTK_ORIENTATION_HORIZONTAL, GTK_TOOLBAR_BOTH);
743 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
744 "Horizontal", "Horizontal toolbar layout", NULL,
745 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
746 (GtkSignalFunc) set_toolbar_horizontal, toolbar);
747 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
748 "Vertical", "Vertical toolbar layout", NULL,
749 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
750 (GtkSignalFunc) set_toolbar_vertical, toolbar);
752 gtk_toolbar_append_space (GTK_TOOLBAR(toolbar));
754 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
755 "Icons", "Only show toolbar icons", NULL,
756 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
757 (GtkSignalFunc) set_toolbar_icons, toolbar);
758 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
759 "Text", "Only show toolbar text", NULL,
760 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
761 (GtkSignalFunc) set_toolbar_text, toolbar);
762 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
763 "Both", "Show toolbar icons and text", NULL,
764 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
765 (GtkSignalFunc) set_toolbar_both, toolbar);
767 gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
769 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
770 "Small", "Use small spaces", NULL,
771 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
772 (GtkSignalFunc) set_toolbar_small_space, toolbar);
773 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
774 "Big", "Use big spaces", "Toolbar/Big",
775 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
776 (GtkSignalFunc) set_toolbar_big_space, toolbar);
778 gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
780 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
781 "Enable", "Enable tooltips", NULL,
782 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
783 (GtkSignalFunc) set_toolbar_enable, toolbar);
784 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
785 "Disable", "Disable tooltips", NULL,
786 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
787 (GtkSignalFunc) set_toolbar_disable, toolbar);
792 static guint statusbar_counter = 1;
795 statusbar_push (GtkWidget *button,
796 GtkStatusbar *statusbar)
800 sprintf (text, "something %d", statusbar_counter++);
802 gtk_statusbar_push (statusbar, 1, text);
806 statusbar_pop (GtkWidget *button,
807 GtkStatusbar *statusbar)
809 gtk_statusbar_pop (statusbar, 1);
813 statusbar_steal (GtkWidget *button,
814 GtkStatusbar *statusbar)
816 gtk_statusbar_remove (statusbar, 1, 4);
820 statusbar_popped (GtkStatusbar *statusbar,
824 if (!statusbar->messages)
825 statusbar_counter = 1;
829 statusbar_contexts (GtkWidget *button,
830 GtkStatusbar *statusbar)
834 string = "any context";
835 g_print ("GtkStatusBar: context=\"%s\", context_id=%d\n",
837 gtk_statusbar_get_context_id (statusbar, string));
839 string = "idle messages";
840 g_print ("GtkStatusBar: context=\"%s\", context_id=%d\n",
842 gtk_statusbar_get_context_id (statusbar, string));
844 string = "some text";
845 g_print ("GtkStatusBar: context=\"%s\", context_id=%d\n",
847 gtk_statusbar_get_context_id (statusbar, string));
849 string = "hit the mouse";
850 g_print ("GtkStatusBar: context=\"%s\", context_id=%d\n",
852 gtk_statusbar_get_context_id (statusbar, string));
854 string = "hit the mouse2";
855 g_print ("GtkStatusBar: context=\"%s\", context_id=%d\n",
857 gtk_statusbar_get_context_id (statusbar, string));
861 statusbar_dump_stack (GtkWidget *button,
862 GtkStatusbar *statusbar)
866 for (list = statusbar->messages; list; list = list->next)
868 GtkStatusbarMsg *msg;
871 g_print ("context_id: %d, message_id: %d, status_text: \"%s\"\n",
881 static GtkWidget *window = NULL;
885 GtkWidget *separator;
886 GtkWidget *statusbar;
890 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
892 gtk_signal_connect (GTK_OBJECT (window), "destroy",
893 GTK_SIGNAL_FUNC (gtk_widget_destroyed),
896 gtk_window_set_title (GTK_WINDOW (window), "statusbar");
897 gtk_container_border_width (GTK_CONTAINER (window), 0);
900 box1 = gtk_vbox_new (FALSE, 0);
901 gtk_container_add (GTK_CONTAINER (window), box1);
902 gtk_widget_show (box1);
905 box2 = gtk_vbox_new (FALSE, 10);
906 gtk_container_border_width (GTK_CONTAINER (box2), 10);
907 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
908 gtk_widget_show (box2);
910 statusbar = gtk_statusbar_new ();
911 gtk_box_pack_end (GTK_BOX (box1), statusbar, TRUE, TRUE, 0);
912 gtk_widget_show (statusbar);
913 gtk_signal_connect (GTK_OBJECT (statusbar),
915 GTK_SIGNAL_FUNC (statusbar_popped),
918 button = gtk_widget_new (gtk_button_get_type (),
919 "GtkButton::label", "push something",
920 "GtkWidget::visible", TRUE,
921 "GtkWidget::parent", box2,
922 "GtkObject::signal::clicked", statusbar_push, statusbar,
925 button = gtk_widget_new (gtk_button_get_type (),
926 "GtkButton::label", "pop",
927 "GtkWidget::visible", TRUE,
928 "GtkWidget::parent", box2,
929 "GtkObject::signal::clicked", statusbar_pop, statusbar,
932 button = gtk_widget_new (gtk_button_get_type (),
933 "GtkButton::label", "steal #4",
934 "GtkWidget::visible", TRUE,
935 "GtkWidget::parent", box2,
936 "GtkObject::signal::clicked", statusbar_steal, statusbar,
939 button = gtk_widget_new (gtk_button_get_type (),
940 "GtkButton::label", "dump stack",
941 "GtkWidget::visible", TRUE,
942 "GtkWidget::parent", box2,
943 "GtkObject::signal::clicked", statusbar_dump_stack, statusbar,
946 button = gtk_widget_new (gtk_button_get_type (),
947 "GtkButton::label", "test contexts",
948 "GtkWidget::visible", TRUE,
949 "GtkWidget::parent", box2,
950 "GtkObject::signal::clicked", statusbar_contexts, statusbar,
953 separator = gtk_hseparator_new ();
954 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
955 gtk_widget_show (separator);
958 box2 = gtk_vbox_new (FALSE, 10);
959 gtk_container_border_width (GTK_CONTAINER (box2), 10);
960 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
961 gtk_widget_show (box2);
964 button = gtk_button_new_with_label ("close");
965 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
966 GTK_SIGNAL_FUNC(gtk_widget_destroy),
967 GTK_OBJECT (window));
968 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
969 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
970 gtk_widget_grab_default (button);
971 gtk_widget_show (button);
974 if (!GTK_WIDGET_VISIBLE (window))
975 gtk_widget_show (window);
977 gtk_widget_destroy (window);
981 handle_box_child_signal (GtkHandleBox *hb,
985 printf ("%s: child <%s> %sed\n",
986 gtk_type_name (GTK_OBJECT_TYPE (hb)),
987 gtk_type_name (GTK_OBJECT_TYPE (child)),
992 cb_tree_destroy_event(GtkWidget* w)
994 sTreeButtons* tree_buttons;
996 /* free buttons structure associate at this tree */
997 tree_buttons = gtk_object_get_user_data(GTK_OBJECT(w));
1001 cb_add_new_item(GtkWidget* w, GtkTree* tree)
1003 sTreeButtons* tree_buttons;
1004 GList* selected_list;
1005 GtkWidget* selected_item;
1007 GtkWidget* item_new;
1010 tree_buttons = gtk_object_get_user_data(GTK_OBJECT(tree));
1012 selected_list = GTK_TREE_SELECTION(tree);
1014 if(selected_list == NULL)
1016 /* there is no item in tree */
1017 subtree = GTK_WIDGET(tree);
1021 /* list can have only one element */
1022 selected_item = GTK_WIDGET(selected_list->data);
1024 subtree = GTK_TREE_ITEM_SUBTREE(selected_item);
1028 /* current selected item have not subtree ... create it */
1029 subtree = gtk_tree_new();
1030 gtk_tree_item_set_subtree(GTK_TREE_ITEM(selected_item),
1035 /* at this point, we know which subtree will be used to add new item */
1036 /* create a new item */
1037 sprintf(buffer, "item add %d", tree_buttons->nb_item_add);
1038 item_new = gtk_tree_item_new_with_label(buffer);
1039 gtk_tree_append(GTK_TREE(subtree), item_new);
1040 gtk_widget_show(item_new);
1042 tree_buttons->nb_item_add++;
1046 cb_remove_item(GtkWidget*w, GtkTree* tree)
1048 GList* selected_list;
1051 selected_list = GTK_TREE_SELECTION(tree);
1055 while (selected_list)
1057 clear_list = g_list_prepend (clear_list, selected_list->data);
1058 selected_list = selected_list->next;
1061 clear_list = g_list_reverse (clear_list);
1062 gtk_tree_remove_items(tree, clear_list);
1064 g_list_free (clear_list);
1068 cb_tree_changed(GtkTree* tree)
1070 sTreeButtons* tree_buttons;
1071 GList* selected_list;
1074 tree_buttons = gtk_object_get_user_data(GTK_OBJECT(tree));
1076 selected_list = GTK_TREE_SELECTION(tree);
1077 nb_selected = g_list_length(selected_list);
1079 if(nb_selected == 0)
1081 if(tree->children == NULL)
1082 gtk_widget_set_sensitive(tree_buttons->add_button, TRUE);
1084 gtk_widget_set_sensitive(tree_buttons->add_button, FALSE);
1085 gtk_widget_set_sensitive(tree_buttons->remove_button, FALSE);
1089 gtk_widget_set_sensitive(tree_buttons->remove_button, TRUE);
1090 gtk_widget_set_sensitive(tree_buttons->add_button, (nb_selected == 1));
1095 create_subtree(GtkWidget* item, guint level, guint nb_item_max, guint recursion_level_max)
1097 GtkWidget* item_subtree;
1098 GtkWidget* item_new;
1103 if(level == recursion_level_max) return;
1107 /* query with no root item */
1109 item_subtree = item;
1114 /* query with no root item */
1115 /* create subtree and associate it with current item */
1116 item_subtree = gtk_tree_new();
1120 for(nb_item = 0; nb_item < nb_item_max; nb_item++)
1122 sprintf(buffer, "item %d-%d", level, nb_item);
1123 item_new = gtk_tree_item_new_with_label(buffer);
1124 gtk_tree_append(GTK_TREE(item_subtree), item_new);
1125 create_subtree(item_new, level+1, nb_item_max, recursion_level_max);
1126 gtk_widget_show(item_new);
1130 gtk_tree_item_set_subtree(GTK_TREE_ITEM(item), item_subtree);
1134 create_tree_sample(guint selection_mode,
1135 guint draw_line, guint view_line, guint no_root_item,
1136 guint nb_item_max, guint recursion_level_max)
1141 GtkWidget* separator;
1143 GtkWidget* scrolled_win;
1144 GtkWidget* root_tree;
1145 GtkWidget* root_item;
1146 sTreeButtons* tree_buttons;
1148 /* create tree buttons struct */
1149 if((tree_buttons = g_malloc(sizeof(sTreeButtons))) == NULL)
1151 g_error("can't allocate memory for tree structure !\n");
1154 tree_buttons->nb_item_add = 0;
1156 /* create top level window */
1157 window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
1158 gtk_window_set_title(GTK_WINDOW(window), "Tree Sample");
1159 gtk_signal_connect(GTK_OBJECT(window), "destroy",
1160 (GtkSignalFunc) cb_tree_destroy_event, NULL);
1161 gtk_object_set_user_data(GTK_OBJECT(window), tree_buttons);
1163 box1 = gtk_vbox_new(FALSE, 0);
1164 gtk_container_add(GTK_CONTAINER(window), box1);
1165 gtk_widget_show(box1);
1167 /* create tree box */
1168 box2 = gtk_vbox_new(FALSE, 0);
1169 gtk_box_pack_start(GTK_BOX(box1), box2, TRUE, TRUE, 0);
1170 gtk_container_border_width(GTK_CONTAINER(box2), 5);
1171 gtk_widget_show(box2);
1173 /* create scrolled window */
1174 scrolled_win = gtk_scrolled_window_new (NULL, NULL);
1175 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
1176 GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
1177 gtk_box_pack_start (GTK_BOX (box2), scrolled_win, TRUE, TRUE, 0);
1178 gtk_widget_set_usize (scrolled_win, 200, 200);
1179 gtk_widget_show (scrolled_win);
1181 /* create root tree widget */
1182 root_tree = gtk_tree_new();
1183 gtk_signal_connect(GTK_OBJECT(root_tree), "selection_changed",
1184 (GtkSignalFunc)cb_tree_changed,
1186 gtk_object_set_user_data(GTK_OBJECT(root_tree), tree_buttons);
1187 gtk_container_add(GTK_CONTAINER(scrolled_win), root_tree);
1188 gtk_tree_set_selection_mode(GTK_TREE(root_tree), selection_mode);
1189 gtk_tree_set_view_lines(GTK_TREE(root_tree), draw_line);
1190 gtk_tree_set_view_mode(GTK_TREE(root_tree), !view_line);
1191 gtk_widget_show(root_tree);
1195 /* set root tree to subtree function with root item variable */
1196 root_item = GTK_WIDGET(root_tree);
1200 /* create root tree item widget */
1201 root_item = gtk_tree_item_new_with_label("root item");
1202 gtk_tree_append(GTK_TREE(root_tree), root_item);
1203 gtk_widget_show(root_item);
1205 create_subtree(root_item, -no_root_item, nb_item_max, recursion_level_max);
1207 box2 = gtk_vbox_new(FALSE, 0);
1208 gtk_box_pack_start(GTK_BOX(box1), box2, FALSE, FALSE, 0);
1209 gtk_container_border_width(GTK_CONTAINER(box2), 5);
1210 gtk_widget_show(box2);
1212 button = gtk_button_new_with_label("Add Item");
1213 gtk_widget_set_sensitive(button, FALSE);
1214 gtk_signal_connect(GTK_OBJECT (button), "clicked",
1215 (GtkSignalFunc) cb_add_new_item,
1216 (gpointer)root_tree);
1217 gtk_box_pack_start(GTK_BOX(box2), button, TRUE, TRUE, 0);
1218 gtk_widget_show(button);
1219 tree_buttons->add_button = button;
1221 button = gtk_button_new_with_label("Remove Item(s)");
1222 gtk_widget_set_sensitive(button, FALSE);
1223 gtk_signal_connect(GTK_OBJECT (button), "clicked",
1224 (GtkSignalFunc) cb_remove_item,
1225 (gpointer)root_tree);
1226 gtk_box_pack_start(GTK_BOX(box2), button, TRUE, TRUE, 0);
1227 gtk_widget_show(button);
1228 tree_buttons->remove_button = button;
1230 /* create separator */
1231 separator = gtk_hseparator_new();
1232 gtk_box_pack_start(GTK_BOX(box1), separator, FALSE, FALSE, 0);
1233 gtk_widget_show(separator);
1235 /* create button box */
1236 box2 = gtk_vbox_new(FALSE, 0);
1237 gtk_box_pack_start(GTK_BOX(box1), box2, FALSE, FALSE, 0);
1238 gtk_container_border_width(GTK_CONTAINER(box2), 5);
1239 gtk_widget_show(box2);
1241 button = gtk_button_new_with_label("Close");
1242 gtk_box_pack_start(GTK_BOX(box2), button, TRUE, TRUE, 0);
1243 gtk_signal_connect_object(GTK_OBJECT (button), "clicked",
1244 (GtkSignalFunc) gtk_widget_destroy,
1245 GTK_OBJECT(window));
1246 gtk_widget_show(button);
1248 gtk_widget_show(window);
1252 cb_create_tree(GtkWidget* w)
1254 guint selection_mode = GTK_SELECTION_SINGLE;
1259 guint recursion_level;
1261 /* get selection mode choice */
1262 if(GTK_TOGGLE_BUTTON(sTreeSampleSelection.single_button)->active)
1263 selection_mode = GTK_SELECTION_SINGLE;
1265 if(GTK_TOGGLE_BUTTON(sTreeSampleSelection.browse_button)->active)
1266 selection_mode = GTK_SELECTION_BROWSE;
1268 selection_mode = GTK_SELECTION_MULTIPLE;
1270 /* get options choice */
1271 draw_line = GTK_TOGGLE_BUTTON(sTreeSampleSelection.draw_line_button)->active;
1272 view_line = GTK_TOGGLE_BUTTON(sTreeSampleSelection.view_line_button)->active;
1273 no_root_item = GTK_TOGGLE_BUTTON(sTreeSampleSelection.no_root_item_button)->active;
1276 nb_item = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(sTreeSampleSelection.nb_item_spinner));
1277 recursion_level = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(sTreeSampleSelection.recursion_spinner));
1279 create_tree_sample(selection_mode, draw_line, view_line, no_root_item, nb_item, recursion_level);
1283 create_tree_mode_window(void)
1285 static GtkWidget* window;
1293 GtkWidget* separator;
1300 /* create toplevel window */
1301 window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
1302 gtk_window_set_title(GTK_WINDOW(window), "Tree Mode Selection Window");
1303 gtk_signal_connect (GTK_OBJECT (window), "destroy",
1304 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
1306 box1 = gtk_vbox_new(FALSE, 0);
1307 gtk_container_add(GTK_CONTAINER(window), box1);
1308 gtk_widget_show(box1);
1310 /* create upper box - selection box */
1311 box2 = gtk_vbox_new(FALSE, 5);
1312 gtk_box_pack_start(GTK_BOX(box1), box2, TRUE, TRUE, 0);
1313 gtk_container_border_width(GTK_CONTAINER(box2), 5);
1314 gtk_widget_show(box2);
1316 box3 = gtk_hbox_new(FALSE, 5);
1317 gtk_box_pack_start(GTK_BOX(box2), box3, TRUE, TRUE, 0);
1318 gtk_widget_show(box3);
1320 /* create selection mode frame */
1321 frame = gtk_frame_new("Selection Mode");
1322 gtk_box_pack_start(GTK_BOX(box3), frame, TRUE, TRUE, 0);
1323 gtk_widget_show(frame);
1325 box4 = gtk_vbox_new(FALSE, 0);
1326 gtk_container_add(GTK_CONTAINER(frame), box4);
1327 gtk_container_border_width(GTK_CONTAINER(box4), 5);
1328 gtk_widget_show(box4);
1330 /* create radio button */
1331 button = gtk_radio_button_new_with_label(NULL, "SINGLE");
1332 gtk_box_pack_start(GTK_BOX(box4), button, TRUE, TRUE, 0);
1333 gtk_widget_show(button);
1334 sTreeSampleSelection.single_button = button;
1336 button = gtk_radio_button_new_with_label(gtk_radio_button_group (GTK_RADIO_BUTTON (button)),
1338 gtk_box_pack_start(GTK_BOX(box4), button, TRUE, TRUE, 0);
1339 gtk_widget_show(button);
1340 sTreeSampleSelection.browse_button = button;
1342 button = gtk_radio_button_new_with_label(gtk_radio_button_group (GTK_RADIO_BUTTON (button)),
1344 gtk_box_pack_start(GTK_BOX(box4), button, TRUE, TRUE, 0);
1345 gtk_widget_show(button);
1346 sTreeSampleSelection.multiple_button = button;
1348 sTreeSampleSelection.selection_mode_group = gtk_radio_button_group (GTK_RADIO_BUTTON (button));
1350 /* create option mode frame */
1351 frame = gtk_frame_new("Options");
1352 gtk_box_pack_start(GTK_BOX(box3), frame, TRUE, TRUE, 0);
1353 gtk_widget_show(frame);
1355 box4 = gtk_vbox_new(FALSE, 0);
1356 gtk_container_add(GTK_CONTAINER(frame), box4);
1357 gtk_container_border_width(GTK_CONTAINER(box4), 5);
1358 gtk_widget_show(box4);
1360 /* create check button */
1361 button = gtk_check_button_new_with_label("Draw line");
1362 gtk_box_pack_start(GTK_BOX(box4), button, TRUE, TRUE, 0);
1363 gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(button), TRUE);
1364 gtk_widget_show(button);
1365 sTreeSampleSelection.draw_line_button = button;
1367 button = gtk_check_button_new_with_label("View Line mode");
1368 gtk_box_pack_start(GTK_BOX(box4), button, TRUE, TRUE, 0);
1369 gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(button), TRUE);
1370 gtk_widget_show(button);
1371 sTreeSampleSelection.view_line_button = button;
1373 button = gtk_check_button_new_with_label("Without Root item");
1374 gtk_box_pack_start(GTK_BOX(box4), button, TRUE, TRUE, 0);
1375 gtk_widget_show(button);
1376 sTreeSampleSelection.no_root_item_button = button;
1378 /* create recursion parameter */
1379 frame = gtk_frame_new("Size Parameters");
1380 gtk_box_pack_start(GTK_BOX(box2), frame, TRUE, TRUE, 0);
1381 gtk_widget_show(frame);
1383 box4 = gtk_hbox_new(FALSE, 5);
1384 gtk_container_add(GTK_CONTAINER(frame), box4);
1385 gtk_container_border_width(GTK_CONTAINER(box4), 5);
1386 gtk_widget_show(box4);
1388 /* create number of item spin button */
1389 box5 = gtk_hbox_new(FALSE, 5);
1390 gtk_box_pack_start(GTK_BOX(box4), box5, FALSE, FALSE, 0);
1391 gtk_widget_show(box5);
1393 label = gtk_label_new("Number of Item");
1394 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
1395 gtk_box_pack_start (GTK_BOX (box5), label, FALSE, TRUE, 0);
1396 gtk_widget_show(label);
1398 adj = (GtkAdjustment *) gtk_adjustment_new ((gfloat)DEFAULT_NUMBER_OF_ITEM, 1.0, 255.0, 1.0,
1400 spinner = gtk_spin_button_new (adj, 0, 0);
1401 gtk_box_pack_start (GTK_BOX (box5), spinner, FALSE, TRUE, 0);
1402 gtk_widget_show(spinner);
1403 sTreeSampleSelection.nb_item_spinner = spinner;
1405 /* create recursion level spin button */
1406 box5 = gtk_hbox_new(FALSE, 5);
1407 gtk_box_pack_start(GTK_BOX(box4), box5, FALSE, FALSE, 0);
1408 gtk_widget_show(box5);
1410 label = gtk_label_new("Depth Level");
1411 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
1412 gtk_box_pack_start (GTK_BOX (box5), label, FALSE, TRUE, 0);
1413 gtk_widget_show(label);
1415 adj = (GtkAdjustment *) gtk_adjustment_new ((gfloat)DEFAULT_RECURSION_LEVEL, 0.0, 255.0, 1.0,
1417 spinner = gtk_spin_button_new (adj, 0, 0);
1418 gtk_box_pack_start (GTK_BOX (box5), spinner, FALSE, TRUE, 0);
1419 gtk_widget_show(spinner);
1420 sTreeSampleSelection.recursion_spinner = spinner;
1422 /* create horizontal separator */
1423 separator = gtk_hseparator_new();
1424 gtk_box_pack_start(GTK_BOX(box1), separator, FALSE, FALSE, 0);
1425 gtk_widget_show(separator);
1427 /* create bottom button box */
1428 box2 = gtk_hbox_new(FALSE, 0);
1429 gtk_box_pack_start(GTK_BOX(box1), box2, FALSE, FALSE, 0);
1430 gtk_container_border_width(GTK_CONTAINER(box2), 5);
1431 gtk_widget_show(box2);
1433 button = gtk_button_new_with_label("Create Tree Sample");
1434 gtk_box_pack_start(GTK_BOX(box2), button, TRUE, TRUE, 0);
1435 gtk_signal_connect(GTK_OBJECT (button), "clicked",
1436 (GtkSignalFunc) cb_create_tree, NULL);
1437 gtk_widget_show(button);
1439 button = gtk_button_new_with_label("Close");
1440 gtk_box_pack_start(GTK_BOX(box2), button, TRUE, TRUE, 0);
1441 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
1442 GTK_SIGNAL_FUNC(gtk_widget_destroy),
1443 GTK_OBJECT (window));
1444 gtk_widget_show(button);
1447 if (!GTK_WIDGET_VISIBLE (window))
1448 gtk_widget_show (window);
1450 gtk_widget_destroy (window);
1453 /* end of function used by tree demos */
1456 create_handle_box ()
1458 static GtkWidget* window = NULL;
1459 GtkWidget *handle_box;
1466 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
1467 gtk_window_set_title (GTK_WINDOW (window),
1470 gtk_signal_connect (GTK_OBJECT (window), "destroy",
1471 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
1474 gtk_container_border_width (GTK_CONTAINER (window), 20);
1476 hbox = gtk_hbox_new (FALSE, 10);
1477 gtk_container_add (GTK_CONTAINER (window), hbox);
1478 gtk_widget_show (hbox);
1480 handle_box = gtk_handle_box_new ();
1481 gtk_container_add (GTK_CONTAINER (hbox), handle_box);
1482 gtk_signal_connect (GTK_OBJECT (handle_box),
1484 GTK_SIGNAL_FUNC (handle_box_child_signal),
1486 gtk_signal_connect (GTK_OBJECT (handle_box),
1488 GTK_SIGNAL_FUNC (handle_box_child_signal),
1490 gtk_widget_show (handle_box);
1492 toolbar = make_toolbar (window);
1493 gtk_container_add (GTK_CONTAINER (handle_box), toolbar);
1494 gtk_widget_show (toolbar);
1496 handle_box = gtk_handle_box_new ();
1497 gtk_container_add (GTK_CONTAINER (hbox), handle_box);
1498 gtk_signal_connect (GTK_OBJECT (handle_box),
1500 GTK_SIGNAL_FUNC (handle_box_child_signal),
1502 gtk_signal_connect (GTK_OBJECT (handle_box),
1504 GTK_SIGNAL_FUNC (handle_box_child_signal),
1506 gtk_widget_show (handle_box);
1508 label = gtk_label_new ("Fooo!");
1509 gtk_container_add (GTK_CONTAINER (handle_box), label);
1510 gtk_widget_show (label);
1513 if (!GTK_WIDGET_VISIBLE (window))
1514 gtk_widget_show (window);
1516 gtk_widget_destroy (window);
1521 reparent_label (GtkWidget *widget,
1522 GtkWidget *new_parent)
1526 label = gtk_object_get_user_data (GTK_OBJECT (widget));
1528 gtk_widget_reparent (label, new_parent);
1532 set_parent_signal (GtkWidget *child,
1533 GtkWidget *old_parent,
1536 g_print ("set_parent for \"%s\": new parent: \"%s\", old parent: \"%s\", data: %d\n",
1537 gtk_type_name (GTK_OBJECT_TYPE (child)),
1538 child->parent ? gtk_type_name (GTK_OBJECT_TYPE (child->parent)) : "NULL",
1539 old_parent ? gtk_type_name (GTK_OBJECT_TYPE (old_parent)) : "NULL",
1546 static GtkWidget *window = NULL;
1553 GtkWidget *separator;
1557 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
1559 gtk_signal_connect (GTK_OBJECT (window), "destroy",
1560 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
1563 gtk_window_set_title (GTK_WINDOW (window), "buttons");
1564 gtk_container_border_width (GTK_CONTAINER (window), 0);
1567 box1 = gtk_vbox_new (FALSE, 0);
1568 gtk_container_add (GTK_CONTAINER (window), box1);
1569 gtk_widget_show (box1);
1572 box2 = gtk_hbox_new (FALSE, 5);
1573 gtk_container_border_width (GTK_CONTAINER (box2), 10);
1574 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
1575 gtk_widget_show (box2);
1578 label = gtk_label_new ("Hello World");
1580 frame = gtk_frame_new ("Frame 1");
1581 gtk_box_pack_start (GTK_BOX (box2), frame, TRUE, TRUE, 0);
1582 gtk_widget_show (frame);
1584 box3 = gtk_vbox_new (FALSE, 5);
1585 gtk_container_border_width (GTK_CONTAINER (box3), 5);
1586 gtk_container_add (GTK_CONTAINER (frame), box3);
1587 gtk_widget_show (box3);
1589 button = gtk_button_new_with_label ("switch");
1590 gtk_signal_connect (GTK_OBJECT (button), "clicked",
1591 GTK_SIGNAL_FUNC(reparent_label),
1593 gtk_object_set_user_data (GTK_OBJECT (button), label);
1594 gtk_box_pack_start (GTK_BOX (box3), button, FALSE, TRUE, 0);
1595 gtk_widget_show (button);
1597 gtk_box_pack_start (GTK_BOX (box3), label, FALSE, TRUE, 0);
1598 gtk_signal_connect (GTK_OBJECT (label),
1600 GTK_SIGNAL_FUNC (set_parent_signal),
1602 gtk_widget_show (label);
1605 frame = gtk_frame_new ("Frame 2");
1606 gtk_box_pack_start (GTK_BOX (box2), frame, TRUE, TRUE, 0);
1607 gtk_widget_show (frame);
1609 box3 = gtk_vbox_new (FALSE, 5);
1610 gtk_container_border_width (GTK_CONTAINER (box3), 5);
1611 gtk_container_add (GTK_CONTAINER (frame), box3);
1612 gtk_widget_show (box3);
1614 button = gtk_button_new_with_label ("switch");
1615 gtk_signal_connect (GTK_OBJECT (button), "clicked",
1616 GTK_SIGNAL_FUNC(reparent_label),
1618 gtk_object_set_user_data (GTK_OBJECT (button), label);
1619 gtk_box_pack_start (GTK_BOX (box3), button, FALSE, TRUE, 0);
1620 gtk_widget_show (button);
1623 separator = gtk_hseparator_new ();
1624 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
1625 gtk_widget_show (separator);
1628 box2 = gtk_vbox_new (FALSE, 10);
1629 gtk_container_border_width (GTK_CONTAINER (box2), 10);
1630 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
1631 gtk_widget_show (box2);
1634 button = gtk_button_new_with_label ("close");
1635 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
1636 GTK_SIGNAL_FUNC(gtk_widget_destroy),
1637 GTK_OBJECT (window));
1638 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
1639 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
1640 gtk_widget_grab_default (button);
1641 gtk_widget_show (button);
1644 if (!GTK_WIDGET_VISIBLE (window))
1645 gtk_widget_show (window);
1647 gtk_widget_destroy (window);
1653 static GtkWidget *window = NULL;
1659 GtkWidget *separator;
1660 GtkWidget *pixmapwid;
1667 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
1669 gtk_signal_connect (GTK_OBJECT (window), "destroy",
1670 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
1673 gtk_window_set_title (GTK_WINDOW (window), "pixmap");
1674 gtk_container_border_width (GTK_CONTAINER (window), 0);
1675 gtk_widget_realize(window);
1677 box1 = gtk_vbox_new (FALSE, 0);
1678 gtk_container_add (GTK_CONTAINER (window), box1);
1679 gtk_widget_show (box1);
1681 box2 = gtk_vbox_new (FALSE, 10);
1682 gtk_container_border_width (GTK_CONTAINER (box2), 10);
1683 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
1684 gtk_widget_show (box2);
1686 button = gtk_button_new ();
1687 gtk_box_pack_start (GTK_BOX (box2), button, FALSE, FALSE, 0);
1688 gtk_widget_show (button);
1690 style=gtk_widget_get_style(button);
1692 pixmap = gdk_pixmap_create_from_xpm (window->window, &mask,
1693 &style->bg[GTK_STATE_NORMAL],
1695 pixmapwid = gtk_pixmap_new (pixmap, mask);
1697 label = gtk_label_new ("Pixmap\ntest");
1698 box3 = gtk_hbox_new (FALSE, 0);
1699 gtk_container_border_width (GTK_CONTAINER (box3), 2);
1700 gtk_container_add (GTK_CONTAINER (box3), pixmapwid);
1701 gtk_container_add (GTK_CONTAINER (box3), label);
1702 gtk_container_add (GTK_CONTAINER (button), box3);
1703 gtk_widget_show (pixmapwid);
1704 gtk_widget_show (label);
1705 gtk_widget_show (box3);
1707 separator = gtk_hseparator_new ();
1708 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
1709 gtk_widget_show (separator);
1712 box2 = gtk_vbox_new (FALSE, 10);
1713 gtk_container_border_width (GTK_CONTAINER (box2), 10);
1714 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
1715 gtk_widget_show (box2);
1718 button = gtk_button_new_with_label ("close");
1719 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
1720 GTK_SIGNAL_FUNC(gtk_widget_destroy),
1721 GTK_OBJECT (window));
1722 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
1723 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
1724 gtk_widget_grab_default (button);
1725 gtk_widget_show (button);
1728 if (!GTK_WIDGET_VISIBLE (window))
1729 gtk_widget_show (window);
1731 gtk_widget_destroy (window);
1735 tips_query_widget_entered (GtkTipsQuery *tips_query,
1737 const gchar *tip_text,
1738 const gchar *tip_private,
1741 if (GTK_TOGGLE_BUTTON (toggle)->active)
1743 gtk_label_set (GTK_LABEL (tips_query), tip_text ? "There is a Tip!" : "There is no Tip!");
1744 /* don't let GtkTipsQuery reset it's label */
1745 gtk_signal_emit_stop_by_name (GTK_OBJECT (tips_query), "widget_entered");
1750 tips_query_widget_selected (GtkWidget *tips_query,
1752 const gchar *tip_text,
1753 const gchar *tip_private,
1754 GdkEventButton *event,
1758 g_print ("Help \"%s\" requested for <%s>\n",
1759 tip_private ? tip_private : "None",
1760 gtk_type_name (GTK_OBJECT_TYPE (widget)));
1768 static GtkWidget *window = NULL;
1775 GtkWidget *tips_query;
1776 GtkWidget *separator;
1777 GtkTooltips *tooltips;
1782 gtk_widget_new (gtk_window_get_type (),
1783 "GtkWindow::type", GTK_WINDOW_TOPLEVEL,
1784 "GtkContainer::border_width", 0,
1785 "GtkWindow::title", "Tooltips",
1786 "GtkWindow::allow_shrink", TRUE,
1787 "GtkWindow::allow_grow", FALSE,
1788 "GtkWindow::auto_shrink", TRUE,
1789 "GtkWidget::width", 200,
1792 gtk_signal_connect (GTK_OBJECT (window), "destroy",
1793 GTK_SIGNAL_FUNC (destroy_tooltips),
1796 tooltips=gtk_tooltips_new();
1797 gtk_object_set_data (GTK_OBJECT (window), "tooltips", tooltips);
1799 box1 = gtk_vbox_new (FALSE, 0);
1800 gtk_container_add (GTK_CONTAINER (window), box1);
1801 gtk_widget_show (box1);
1804 box2 = gtk_vbox_new (FALSE, 10);
1805 gtk_container_border_width (GTK_CONTAINER (box2), 10);
1806 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
1807 gtk_widget_show (box2);
1810 button = gtk_toggle_button_new_with_label ("button1");
1811 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
1812 gtk_widget_show (button);
1814 gtk_tooltips_set_tip (tooltips,button,"This is button 1", "ContextHelp/buttons/1");
1816 button = gtk_toggle_button_new_with_label ("button2");
1817 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
1818 gtk_widget_show (button);
1820 gtk_tooltips_set_tip (tooltips,
1822 "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.",
1823 "ContextHelp/buttons/2_long");
1825 toggle = gtk_toggle_button_new_with_label ("Override TipsQuery Label");
1826 gtk_box_pack_start (GTK_BOX (box2), toggle, TRUE, TRUE, 0);
1827 gtk_widget_show (toggle);
1829 gtk_tooltips_set_tip (tooltips, toggle, "Toggle TipsQuery view.", "Hi msw! ;)");
1832 gtk_widget_new (gtk_vbox_get_type (),
1833 "GtkBox::homogeneous", FALSE,
1834 "GtkBox::spacing", 5,
1835 "GtkContainer::border_width", 5,
1836 "GtkWidget::visible", TRUE,
1839 tips_query = gtk_tips_query_new ();
1842 gtk_widget_new (gtk_button_get_type (),
1843 "GtkButton::label", "[?]",
1844 "GtkWidget::visible", TRUE,
1845 "GtkWidget::parent", box3,
1846 "GtkObject::object_signal::clicked", gtk_tips_query_start_query, tips_query,
1848 gtk_box_set_child_packing (GTK_BOX (box3), button, FALSE, FALSE, 0, GTK_PACK_START);
1849 gtk_tooltips_set_tip (tooltips,
1851 "Start the Tooltips Inspector",
1852 "ContextHelp/buttons/?");
1855 gtk_widget_set (tips_query,
1856 "GtkWidget::visible", TRUE,
1857 "GtkWidget::parent", box3,
1858 "GtkTipsQuery::caller", button,
1859 "GtkObject::signal::widget_entered", tips_query_widget_entered, toggle,
1860 "GtkObject::signal::widget_selected", tips_query_widget_selected, NULL,
1864 gtk_widget_new (gtk_frame_get_type (),
1865 "GtkFrame::label", "ToolTips Inspector",
1866 "GtkFrame::label_xalign", (double) 0.5,
1867 "GtkContainer::border_width", 0,
1868 "GtkWidget::visible", TRUE,
1869 "GtkWidget::parent", box2,
1870 "GtkContainer::child", box3,
1872 gtk_box_set_child_packing (GTK_BOX (box2), frame, TRUE, TRUE, 10, GTK_PACK_START);
1874 separator = gtk_hseparator_new ();
1875 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
1876 gtk_widget_show (separator);
1879 box2 = gtk_vbox_new (FALSE, 10);
1880 gtk_container_border_width (GTK_CONTAINER (box2), 10);
1881 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
1882 gtk_widget_show (box2);
1885 button = gtk_button_new_with_label ("close");
1886 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
1887 GTK_SIGNAL_FUNC(gtk_widget_destroy),
1888 GTK_OBJECT (window));
1889 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
1890 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
1891 gtk_widget_grab_default (button);
1892 gtk_widget_show (button);
1894 gtk_tooltips_set_tip (tooltips, button, "Push this button to close window", "ContextHelp/buttons/Close");
1897 if (!GTK_WIDGET_VISIBLE (window))
1898 gtk_widget_show (window);
1900 gtk_widget_destroy (window);
1904 create_menu (int depth)
1907 GtkWidget *menuitem;
1915 menu = gtk_menu_new ();
1918 for (i = 0, j = 1; i < 5; i++, j++)
1920 sprintf (buf, "item %2d - %d", depth, j);
1921 menuitem = gtk_radio_menu_item_new_with_label (group, buf);
1922 group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menuitem));
1924 gtk_check_menu_item_set_show_toggle (GTK_CHECK_MENU_ITEM (menuitem), TRUE);
1925 gtk_menu_append (GTK_MENU (menu), menuitem);
1926 gtk_widget_show (menuitem);
1928 gtk_widget_set_sensitive (menuitem, FALSE);
1930 gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), create_menu (depth - 1));
1939 static GtkWidget *window = NULL;
1945 GtkWidget *menuitem;
1946 GtkWidget *optionmenu;
1947 GtkWidget *separator;
1951 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
1953 gtk_signal_connect (GTK_OBJECT (window), "destroy",
1954 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
1956 gtk_signal_connect (GTK_OBJECT (window), "delete_event",
1957 GTK_SIGNAL_FUNC (gtk_true),
1960 gtk_window_set_title (GTK_WINDOW (window), "menus");
1961 gtk_container_border_width (GTK_CONTAINER (window), 0);
1964 box1 = gtk_vbox_new (FALSE, 0);
1965 gtk_container_add (GTK_CONTAINER (window), box1);
1966 gtk_widget_show (box1);
1969 menubar = gtk_menu_bar_new ();
1970 gtk_box_pack_start (GTK_BOX (box1), menubar, FALSE, TRUE, 0);
1971 gtk_widget_show (menubar);
1973 menu = create_menu (2);
1975 menuitem = gtk_menu_item_new_with_label ("test\nline2");
1976 gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), menu);
1977 gtk_menu_bar_append (GTK_MENU_BAR (menubar), menuitem);
1978 gtk_widget_show (menuitem);
1980 menuitem = gtk_menu_item_new_with_label ("foo");
1981 gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), create_menu (3));
1982 gtk_menu_bar_append (GTK_MENU_BAR (menubar), menuitem);
1983 gtk_widget_show (menuitem);
1985 menuitem = gtk_menu_item_new_with_label ("bar");
1986 gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), create_menu (4));
1987 gtk_menu_item_right_justify (GTK_MENU_ITEM (menuitem));
1988 gtk_menu_bar_append (GTK_MENU_BAR (menubar), menuitem);
1989 gtk_widget_show (menuitem);
1992 box2 = gtk_vbox_new (FALSE, 10);
1993 gtk_container_border_width (GTK_CONTAINER (box2), 10);
1994 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
1995 gtk_widget_show (box2);
1998 optionmenu = gtk_option_menu_new ();
1999 gtk_option_menu_set_menu (GTK_OPTION_MENU (optionmenu), create_menu (1));
2000 gtk_option_menu_set_history (GTK_OPTION_MENU (optionmenu), 4);
2001 gtk_box_pack_start (GTK_BOX (box2), optionmenu, TRUE, TRUE, 0);
2002 gtk_widget_show (optionmenu);
2005 separator = gtk_hseparator_new ();
2006 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
2007 gtk_widget_show (separator);
2010 box2 = gtk_vbox_new (FALSE, 10);
2011 gtk_container_border_width (GTK_CONTAINER (box2), 10);
2012 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
2013 gtk_widget_show (box2);
2016 button = gtk_button_new_with_label ("close");
2017 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
2018 GTK_SIGNAL_FUNC(gtk_widget_destroy),
2019 GTK_OBJECT (window));
2020 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
2021 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
2022 gtk_widget_grab_default (button);
2023 gtk_widget_show (button);
2026 if (!GTK_WIDGET_VISIBLE (window))
2027 gtk_widget_show (window);
2029 gtk_widget_destroy (window);
2036 create_scrolled_windows ()
2038 static GtkWidget *window;
2039 GtkWidget *scrolled_window;
2047 window = gtk_dialog_new ();
2049 gtk_signal_connect (GTK_OBJECT (window), "destroy",
2050 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
2053 gtk_window_set_title (GTK_WINDOW (window), "dialog");
2054 gtk_container_border_width (GTK_CONTAINER (window), 0);
2057 scrolled_window = gtk_scrolled_window_new (NULL, NULL);
2058 gtk_container_border_width (GTK_CONTAINER (scrolled_window), 10);
2059 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
2060 GTK_POLICY_AUTOMATIC,
2061 GTK_POLICY_AUTOMATIC);
2062 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox),
2063 scrolled_window, TRUE, TRUE, 0);
2064 gtk_widget_show (scrolled_window);
2066 table = gtk_table_new (20, 20, FALSE);
2067 gtk_table_set_row_spacings (GTK_TABLE (table), 10);
2068 gtk_table_set_col_spacings (GTK_TABLE (table), 10);
2069 gtk_container_add (GTK_CONTAINER (scrolled_window), table);
2070 gtk_widget_show (table);
2072 for (i = 0; i < 20; i++)
2073 for (j = 0; j < 20; j++)
2075 sprintf (buffer, "button (%d,%d)\n", i, j);
2076 button = gtk_toggle_button_new_with_label (buffer);
2077 gtk_table_attach_defaults (GTK_TABLE (table), button,
2079 gtk_widget_show (button);
2083 button = gtk_button_new_with_label ("close");
2084 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
2085 GTK_SIGNAL_FUNC(gtk_widget_destroy),
2086 GTK_OBJECT (window));
2087 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
2088 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
2089 button, TRUE, TRUE, 0);
2090 gtk_widget_grab_default (button);
2091 gtk_widget_show (button);
2094 if (!GTK_WIDGET_VISIBLE (window))
2095 gtk_widget_show (window);
2097 gtk_widget_destroy (window);
2105 entry_toggle_editable (GtkWidget *checkbutton,
2108 gtk_entry_set_editable(GTK_ENTRY(entry),
2109 GTK_TOGGLE_BUTTON(checkbutton)->active);
2115 static GtkWidget *window = NULL;
2118 GtkWidget *editable_check;
2119 GtkWidget *entry, *cb;
2121 GtkWidget *separator;
2122 GList *cbitems = NULL;
2126 cbitems = g_list_append(cbitems, "item0");
2127 cbitems = g_list_append(cbitems, "item1 item1");
2128 cbitems = g_list_append(cbitems, "item2 item2 item2");
2129 cbitems = g_list_append(cbitems, "item3 item3 item3 item3");
2130 cbitems = g_list_append(cbitems, "item4 item4 item4 item4 item4");
2131 cbitems = g_list_append(cbitems, "item5 item5 item5 item5 item5 item5");
2132 cbitems = g_list_append(cbitems, "item6 item6 item6 item6 item6");
2133 cbitems = g_list_append(cbitems, "item7 item7 item7 item7");
2134 cbitems = g_list_append(cbitems, "item8 item8 item8");
2135 cbitems = g_list_append(cbitems, "item9 item9");
2137 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
2139 gtk_signal_connect (GTK_OBJECT (window), "destroy",
2140 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
2143 gtk_window_set_title (GTK_WINDOW (window), "entry");
2144 gtk_container_border_width (GTK_CONTAINER (window), 0);
2147 box1 = gtk_vbox_new (FALSE, 0);
2148 gtk_container_add (GTK_CONTAINER (window), box1);
2149 gtk_widget_show (box1);
2152 box2 = gtk_vbox_new (FALSE, 10);
2153 gtk_container_border_width (GTK_CONTAINER (box2), 10);
2154 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
2155 gtk_widget_show (box2);
2157 entry = gtk_entry_new ();
2158 gtk_entry_set_text (GTK_ENTRY (entry), "hello world");
2159 gtk_editable_select_region (GTK_EDITABLE (entry), 0, -1);
2160 gtk_box_pack_start (GTK_BOX (box2), entry, TRUE, TRUE, 0);
2161 gtk_widget_show (entry);
2163 cb = gtk_combo_new ();
2164 gtk_combo_set_popdown_strings (GTK_COMBO (cb), cbitems);
2165 gtk_entry_set_text (GTK_ENTRY (GTK_COMBO(cb)->entry), "hello world");
2166 gtk_editable_select_region (GTK_EDITABLE (GTK_COMBO(cb)->entry),
2168 gtk_box_pack_start (GTK_BOX (box2), cb, TRUE, TRUE, 0);
2169 gtk_widget_show (cb);
2171 editable_check = gtk_check_button_new_with_label("Editable");
2172 gtk_box_pack_start (GTK_BOX (box2), editable_check, FALSE, TRUE, 0);
2173 gtk_signal_connect (GTK_OBJECT(editable_check), "toggled",
2174 GTK_SIGNAL_FUNC(entry_toggle_editable), entry);
2175 gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(editable_check), TRUE);
2176 gtk_widget_show (editable_check);
2178 separator = gtk_hseparator_new ();
2179 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
2180 gtk_widget_show (separator);
2183 box2 = gtk_vbox_new (FALSE, 10);
2184 gtk_container_border_width (GTK_CONTAINER (box2), 10);
2185 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
2186 gtk_widget_show (box2);
2189 button = gtk_button_new_with_label ("close");
2190 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
2191 GTK_SIGNAL_FUNC(gtk_widget_destroy),
2192 GTK_OBJECT (window));
2193 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
2194 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
2195 gtk_widget_grab_default (button);
2196 gtk_widget_show (button);
2199 if (!GTK_WIDGET_VISIBLE (window))
2200 gtk_widget_show (window);
2202 gtk_widget_destroy (window);
2209 static GtkWidget *spinner1;
2212 toggle_snap (GtkWidget *widget, GtkSpinButton *spin)
2214 if (GTK_TOGGLE_BUTTON (widget)->active)
2215 gtk_spin_button_set_update_policy (spin, GTK_UPDATE_ALWAYS
2216 | GTK_UPDATE_SNAP_TO_TICKS);
2218 gtk_spin_button_set_update_policy (spin, GTK_UPDATE_ALWAYS);
2222 toggle_numeric (GtkWidget *widget, GtkSpinButton *spin)
2224 gtk_spin_button_set_numeric (spin, GTK_TOGGLE_BUTTON (widget)->active);
2228 change_digits (GtkWidget *widget, GtkSpinButton *spin)
2230 gtk_spin_button_set_digits (GTK_SPIN_BUTTON (spinner1),
2231 gtk_spin_button_get_value_as_int (spin));
2235 get_value (GtkWidget *widget, gint data)
2239 GtkSpinButton *spin;
2241 spin = GTK_SPIN_BUTTON (spinner1);
2242 label = GTK_LABEL (gtk_object_get_user_data (GTK_OBJECT (widget)));
2244 sprintf (buf, "%d", gtk_spin_button_get_value_as_int (spin));
2246 sprintf (buf, "%0.*f", spin->digits,
2247 gtk_spin_button_get_value_as_float (spin));
2248 gtk_label_set (label, buf);
2254 static GtkWidget *window = NULL;
2257 GtkWidget *main_vbox;
2260 GtkWidget *spinner2;
2264 GtkWidget *val_label;
2269 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
2271 gtk_signal_connect (GTK_OBJECT (window), "destroy",
2272 GTK_SIGNAL_FUNC (gtk_widget_destroyed),
2275 gtk_window_set_title (GTK_WINDOW (window), "GtkSpinButton");
2277 main_vbox = gtk_vbox_new (FALSE, 5);
2278 gtk_container_border_width (GTK_CONTAINER (main_vbox), 10);
2279 gtk_container_add (GTK_CONTAINER (window), main_vbox);
2281 frame = gtk_frame_new ("Not accelerated");
2282 gtk_box_pack_start (GTK_BOX (main_vbox), frame, TRUE, TRUE, 0);
2284 vbox = gtk_vbox_new (FALSE, 0);
2285 gtk_container_border_width (GTK_CONTAINER (vbox), 5);
2286 gtk_container_add (GTK_CONTAINER (frame), vbox);
2288 /* Day, month, year spinners */
2290 hbox = gtk_hbox_new (FALSE, 0);
2291 gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 5);
2293 vbox2 = gtk_vbox_new (FALSE, 0);
2294 gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 5);
2296 label = gtk_label_new ("Day :");
2297 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
2298 gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, TRUE, 0);
2300 adj = (GtkAdjustment *) gtk_adjustment_new (1.0, 1.0, 31.0, 1.0,
2302 spinner = gtk_spin_button_new (adj, 0, 0);
2303 gtk_box_pack_start (GTK_BOX (vbox2), spinner, FALSE, TRUE, 0);
2305 vbox2 = gtk_vbox_new (FALSE, 0);
2306 gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 5);
2308 label = gtk_label_new ("Month :");
2309 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
2310 gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, TRUE, 0);
2312 adj = (GtkAdjustment *) gtk_adjustment_new (1.0, 1.0, 12.0, 1.0,
2314 spinner = gtk_spin_button_new (adj, 0, 0);
2315 gtk_box_pack_start (GTK_BOX (vbox2), spinner, FALSE, TRUE, 0);
2317 vbox2 = gtk_vbox_new (FALSE, 0);
2318 gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 5);
2320 label = gtk_label_new ("Year :");
2321 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
2322 gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, TRUE, 0);
2324 adj = (GtkAdjustment *) gtk_adjustment_new (1998.0, 0.0, 2100.0,
2326 spinner = gtk_spin_button_new (adj, 0, 0);
2327 gtk_widget_set_usize (spinner, 55, 0);
2328 gtk_box_pack_start (GTK_BOX (vbox2), spinner, FALSE, TRUE, 0);
2330 frame = gtk_frame_new ("Accelerated");
2331 gtk_box_pack_start (GTK_BOX (main_vbox), frame, TRUE, TRUE, 0);
2333 vbox = gtk_vbox_new (FALSE, 0);
2334 gtk_container_border_width (GTK_CONTAINER (vbox), 5);
2335 gtk_container_add (GTK_CONTAINER (frame), vbox);
2337 hbox = gtk_hbox_new (FALSE, 0);
2338 gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 5);
2340 vbox2 = gtk_vbox_new (FALSE, 0);
2341 gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 5);
2343 label = gtk_label_new ("Value :");
2344 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
2345 gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, TRUE, 0);
2347 adj = (GtkAdjustment *) gtk_adjustment_new (0.0, -10000.0, 10000.0,
2349 spinner1 = gtk_spin_button_new (adj, 1.0, 2);
2350 gtk_widget_set_usize (spinner1, 100, 0);
2351 gtk_spin_button_set_update_policy (GTK_SPIN_BUTTON (spinner1),
2353 gtk_box_pack_start (GTK_BOX (vbox2), spinner1, FALSE, TRUE, 0);
2355 vbox2 = gtk_vbox_new (FALSE, 0);
2356 gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 5);
2358 label = gtk_label_new ("Digits :");
2359 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
2360 gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, TRUE, 0);
2362 adj = (GtkAdjustment *) gtk_adjustment_new (2, 1, 5, 1, 1, 0);
2363 spinner2 = gtk_spin_button_new (adj, 0.0, 0);
2364 gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
2365 GTK_SIGNAL_FUNC (change_digits),
2366 (gpointer) spinner2);
2367 gtk_box_pack_start (GTK_BOX (vbox2), spinner2, FALSE, TRUE, 0);
2369 hbox = gtk_hbox_new (FALSE, 0);
2370 gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 5);
2372 button = gtk_check_button_new_with_label ("Snap to 0.5-ticks");
2373 gtk_signal_connect (GTK_OBJECT (button), "clicked",
2374 GTK_SIGNAL_FUNC (toggle_snap),
2376 gtk_box_pack_start (GTK_BOX (vbox), button, TRUE, TRUE, 0);
2377 gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON (button), TRUE);
2379 button = gtk_check_button_new_with_label ("Numeric only input mode");
2380 gtk_signal_connect (GTK_OBJECT (button), "clicked",
2381 GTK_SIGNAL_FUNC (toggle_numeric),
2383 gtk_box_pack_start (GTK_BOX (vbox), button, TRUE, TRUE, 0);
2384 gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON (button), TRUE);
2386 val_label = gtk_label_new ("");
2388 hbox = gtk_hbox_new (FALSE, 0);
2389 gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 5);
2391 button = gtk_button_new_with_label ("Value as Int");
2392 gtk_object_set_user_data (GTK_OBJECT (button), val_label);
2393 gtk_signal_connect (GTK_OBJECT (button), "clicked",
2394 GTK_SIGNAL_FUNC (get_value),
2396 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
2398 button = gtk_button_new_with_label ("Value as Float");
2399 gtk_object_set_user_data (GTK_OBJECT (button), val_label);
2400 gtk_signal_connect (GTK_OBJECT (button), "clicked",
2401 GTK_SIGNAL_FUNC (get_value),
2403 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
2405 gtk_box_pack_start (GTK_BOX (vbox), val_label, TRUE, TRUE, 0);
2406 gtk_label_set (GTK_LABEL (val_label), "0");
2408 hbox = gtk_hbox_new (FALSE, 0);
2409 gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, TRUE, 0);
2411 button = gtk_button_new_with_label ("Close");
2412 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
2413 GTK_SIGNAL_FUNC (gtk_widget_destroy),
2414 GTK_OBJECT (window));
2415 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
2418 if (!GTK_WIDGET_VISIBLE (window))
2419 gtk_widget_show_all (window);
2421 gtk_widget_destroy (window);
2430 cursor_expose_event (GtkWidget *widget,
2434 GtkDrawingArea *darea;
2435 GdkDrawable *drawable;
2442 g_return_val_if_fail (widget != NULL, TRUE);
2443 g_return_val_if_fail (GTK_IS_DRAWING_AREA (widget), TRUE);
2445 darea = GTK_DRAWING_AREA (widget);
2446 drawable = widget->window;
2447 white_gc = widget->style->white_gc;
2448 gray_gc = widget->style->bg_gc[GTK_STATE_NORMAL];
2449 black_gc = widget->style->black_gc;
2450 max_width = widget->allocation.width;
2451 max_height = widget->allocation.height;
2453 gdk_draw_rectangle (drawable, white_gc,
2460 gdk_draw_rectangle (drawable, black_gc,
2467 gdk_draw_rectangle (drawable, gray_gc,
2478 set_cursor (GtkWidget *spinner,
2484 c = CLAMP (gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (spinner)), 0, 152);
2487 cursor = gdk_cursor_new (c);
2488 gdk_window_set_cursor (widget->window, cursor);
2489 gdk_cursor_destroy (cursor);
2493 cursor_event (GtkWidget *widget,
2495 GtkSpinButton *spinner)
2497 if ((event->type == GDK_BUTTON_PRESS) &&
2498 ((event->button.button == 1) ||
2499 (event->button.button == 3)))
2501 gtk_spin_button_spin (spinner,
2502 event->button.button == 1 ? GTK_ARROW_UP : GTK_ARROW_DOWN,
2503 spinner->adjustment->step_increment);
2513 static GtkWidget *window = NULL;
2516 GtkWidget *main_vbox;
2527 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
2529 gtk_signal_connect (GTK_OBJECT (window), "destroy",
2530 GTK_SIGNAL_FUNC (gtk_widget_destroyed),
2533 gtk_window_set_title (GTK_WINDOW (window), "Cursors");
2535 main_vbox = gtk_vbox_new (FALSE, 5);
2536 gtk_container_border_width (GTK_CONTAINER (main_vbox), 0);
2537 gtk_container_add (GTK_CONTAINER (window), main_vbox);
2540 gtk_widget_new (gtk_vbox_get_type (),
2541 "GtkBox::homogeneous", FALSE,
2542 "GtkBox::spacing", 5,
2543 "GtkContainer::border_width", 10,
2544 "GtkWidget::parent", main_vbox,
2545 "GtkWidget::visible", TRUE,
2548 hbox = gtk_hbox_new (FALSE, 0);
2549 gtk_container_border_width (GTK_CONTAINER (hbox), 5);
2550 gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0);
2552 label = gtk_label_new ("Cursor Value:");
2553 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
2554 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
2556 adj = (GtkAdjustment *) gtk_adjustment_new (0,
2560 spinner = gtk_spin_button_new (adj, 0, 0);
2561 gtk_box_pack_start (GTK_BOX (hbox), spinner, TRUE, TRUE, 0);
2564 gtk_widget_new (gtk_frame_get_type (),
2565 "GtkFrame::shadow", GTK_SHADOW_ETCHED_IN,
2566 "GtkFrame::label_xalign", 0.5,
2567 "GtkFrame::label", "Cursor Area",
2568 "GtkContainer::border_width", 10,
2569 "GtkWidget::parent", vbox,
2570 "GtkWidget::visible", TRUE,
2573 darea = gtk_drawing_area_new ();
2574 gtk_widget_set_usize (darea, 80, 80);
2575 gtk_container_add (GTK_CONTAINER (frame), darea);
2576 gtk_signal_connect (GTK_OBJECT (darea),
2578 GTK_SIGNAL_FUNC (cursor_expose_event),
2580 gtk_widget_set_events (darea, GDK_EXPOSURE_MASK | GDK_BUTTON_PRESS_MASK);
2581 gtk_signal_connect (GTK_OBJECT (darea),
2582 "button_press_event",
2583 GTK_SIGNAL_FUNC (cursor_event),
2585 gtk_widget_show (darea);
2587 gtk_signal_connect (GTK_OBJECT (spinner), "changed",
2588 GTK_SIGNAL_FUNC (set_cursor),
2592 gtk_widget_new (gtk_hseparator_get_type (),
2593 "GtkWidget::visible", TRUE,
2595 gtk_box_pack_start (GTK_BOX (main_vbox), any, FALSE, TRUE, 0);
2597 hbox = gtk_hbox_new (FALSE, 0);
2598 gtk_container_border_width (GTK_CONTAINER (hbox), 10);
2599 gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, TRUE, 0);
2601 button = gtk_button_new_with_label ("Close");
2602 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
2603 GTK_SIGNAL_FUNC (gtk_widget_destroy),
2604 GTK_OBJECT (window));
2605 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
2608 if (!GTK_WIDGET_VISIBLE (window))
2609 gtk_widget_show_all (window);
2611 gtk_widget_destroy (window);
2618 list_add (GtkWidget *widget,
2623 GtkWidget *list_item;
2625 sprintf (buffer, "added item %d", i++);
2626 list_item = gtk_list_item_new_with_label (buffer);
2627 gtk_widget_show (list_item);
2628 gtk_container_add (GTK_CONTAINER (list), list_item);
2632 list_remove (GtkWidget *widget,
2638 tmp_list = GTK_LIST (list)->selection;
2643 clear_list = g_list_prepend (clear_list, tmp_list->data);
2644 tmp_list = tmp_list->next;
2647 clear_list = g_list_reverse (clear_list);
2649 gtk_list_remove_items (GTK_LIST (list), clear_list);
2651 g_list_free (clear_list);
2655 list_clear (GtkWidget *widget,
2658 gtk_list_clear_items (GTK_LIST (list), 3 - 1, 5 - 1);
2664 static GtkWidget *window = NULL;
2665 static char *list_items[] =
2678 static int nlist_items = sizeof (list_items) / sizeof (list_items[0]);
2682 GtkWidget *scrolled_win;
2684 GtkWidget *list_item;
2686 GtkWidget *separator;
2691 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
2693 gtk_signal_connect (GTK_OBJECT (window), "destroy",
2694 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
2697 gtk_window_set_title (GTK_WINDOW (window), "list");
2698 gtk_container_border_width (GTK_CONTAINER (window), 0);
2701 box1 = gtk_vbox_new (FALSE, 0);
2702 gtk_container_add (GTK_CONTAINER (window), box1);
2703 gtk_widget_show (box1);
2706 box2 = gtk_vbox_new (FALSE, 10);
2707 gtk_container_border_width (GTK_CONTAINER (box2), 10);
2708 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
2709 gtk_widget_show (box2);
2712 scrolled_win = gtk_scrolled_window_new (NULL, NULL);
2713 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
2714 GTK_POLICY_AUTOMATIC,
2715 GTK_POLICY_AUTOMATIC);
2716 gtk_box_pack_start (GTK_BOX (box2), scrolled_win, TRUE, TRUE, 0);
2717 gtk_widget_show (scrolled_win);
2719 list = gtk_list_new ();
2720 gtk_list_set_selection_mode (GTK_LIST (list), GTK_SELECTION_MULTIPLE);
2721 gtk_list_set_selection_mode (GTK_LIST (list), GTK_SELECTION_BROWSE);
2722 gtk_container_add (GTK_CONTAINER (scrolled_win), list);
2723 gtk_widget_show (list);
2725 for (i = 0; i < nlist_items; i++)
2727 list_item = gtk_list_item_new_with_label (list_items[i]);
2728 gtk_container_add (GTK_CONTAINER (list), list_item);
2729 gtk_widget_show (list_item);
2732 button = gtk_button_new_with_label ("add");
2733 GTK_WIDGET_UNSET_FLAGS (button, GTK_CAN_FOCUS);
2734 gtk_signal_connect (GTK_OBJECT (button), "clicked",
2735 GTK_SIGNAL_FUNC(list_add),
2737 gtk_box_pack_start (GTK_BOX (box2), button, FALSE, TRUE, 0);
2738 gtk_widget_show (button);
2740 button = gtk_button_new_with_label ("clear items 3 - 5");
2741 GTK_WIDGET_UNSET_FLAGS (button, GTK_CAN_FOCUS);
2742 gtk_signal_connect (GTK_OBJECT (button), "clicked",
2743 GTK_SIGNAL_FUNC(list_clear),
2745 gtk_box_pack_start (GTK_BOX (box2), button, FALSE, TRUE, 0);
2746 gtk_widget_show (button);
2748 button = gtk_button_new_with_label ("remove");
2749 GTK_WIDGET_UNSET_FLAGS (button, GTK_CAN_FOCUS);
2750 gtk_signal_connect (GTK_OBJECT (button), "clicked",
2751 GTK_SIGNAL_FUNC(list_remove),
2753 gtk_box_pack_start (GTK_BOX (box2), button, FALSE, TRUE, 0);
2754 gtk_widget_show (button);
2757 separator = gtk_hseparator_new ();
2758 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
2759 gtk_widget_show (separator);
2762 box2 = gtk_vbox_new (FALSE, 10);
2763 gtk_container_border_width (GTK_CONTAINER (box2), 10);
2764 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
2765 gtk_widget_show (box2);
2768 button = gtk_button_new_with_label ("close");
2769 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
2770 GTK_SIGNAL_FUNC(gtk_widget_destroy),
2771 GTK_OBJECT (window));
2772 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
2773 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
2774 gtk_widget_grab_default (button);
2775 gtk_widget_show (button);
2778 if (!GTK_WIDGET_VISIBLE (window))
2779 gtk_widget_show (window);
2781 gtk_widget_destroy (window);
2787 #define TESTGTK_CLIST_COLUMNS 7
2788 static gint clist_rows = 0;
2789 static gint clist_selected_row = 0;
2792 add1000_clist (GtkWidget *widget, gpointer data)
2795 char text[TESTGTK_CLIST_COLUMNS][50];
2796 char *texts[TESTGTK_CLIST_COLUMNS];
2800 pixmap = gdk_pixmap_create_from_xpm (GTK_CLIST (data)->clist_window,
2802 >K_WIDGET (data)->style->white,
2805 for (i = 0; i < TESTGTK_CLIST_COLUMNS; i++)
2808 sprintf (text[i], "Column %d", i);
2812 sprintf (text[1], "Right");
2813 sprintf (text[2], "Center");
2815 gtk_clist_freeze (GTK_CLIST (data));
2816 for (i = 0; i < 1000; i++)
2818 sprintf (text[0], "Row %d", clist_rows++);
2819 row = gtk_clist_append (GTK_CLIST (data), texts);
2820 gtk_clist_set_pixtext (GTK_CLIST (data), row, 3, "Testing", 5, pixmap, mask);
2822 gtk_clist_thaw (GTK_CLIST (data));
2824 gdk_pixmap_unref (pixmap);
2825 gdk_bitmap_unref (mask);
2829 add10000_clist (GtkWidget *widget, gpointer data)
2832 char text[TESTGTK_CLIST_COLUMNS][50];
2833 char *texts[TESTGTK_CLIST_COLUMNS];
2835 for (i = 0; i < TESTGTK_CLIST_COLUMNS; i++)
2838 sprintf (text[i], "Column %d", i);
2841 sprintf (text[1], "Right");
2842 sprintf (text[2], "Center");
2844 gtk_clist_freeze (GTK_CLIST (data));
2845 for (i = 0; i < 10000; i++)
2847 sprintf (text[0], "Row %d", clist_rows++);
2848 gtk_clist_append (GTK_CLIST (data), texts);
2850 gtk_clist_thaw (GTK_CLIST (data));
2855 clear_clist (GtkWidget *widget, gpointer data)
2857 gtk_clist_clear (GTK_CLIST (data));
2862 remove_row_clist (GtkWidget *widget, gpointer data)
2864 gtk_clist_remove (GTK_CLIST (data), clist_selected_row);
2869 show_titles_clist (GtkWidget *widget, gpointer data)
2871 gtk_clist_column_titles_show (GTK_CLIST (data));
2875 hide_titles_clist (GtkWidget *widget, gpointer data)
2877 gtk_clist_column_titles_hide (GTK_CLIST (data));
2881 select_clist (GtkWidget *widget,
2884 GdkEventButton * bevent)
2893 g_print ("GtkCList Selection: row %d column %d button %d\n",
2894 row, column, bevent ? bevent->button : 0);
2896 for (i = 0; i < TESTGTK_CLIST_COLUMNS; i++)
2898 switch (gtk_clist_get_cell_type (GTK_CLIST (widget), row, i))
2901 g_print ("CELL %d GTK_CELL_TEXT\n", i);
2902 gtk_clist_get_text (GTK_CLIST (widget), row, i, &text);
2903 g_print ("TEXT: %s\n", text);
2906 case GTK_CELL_PIXMAP:
2907 g_print ("CELL %d GTK_CELL_PIXMAP\n", i);
2908 gtk_clist_get_pixmap (GTK_CLIST (widget), row, i, &pixmap, &mask);
2909 g_print ("PIXMAP: %d\n", (int) pixmap);
2910 g_print ("MASK: %d\n", (int) mask);
2913 case GTK_CELL_PIXTEXT:
2914 g_print ("CELL %d GTK_CELL_PIXTEXT\n", i);
2915 gtk_clist_get_pixtext (GTK_CLIST (widget), row, i, &text, &spacing, &pixmap, &mask);
2916 g_print ("TEXT: %s\n", text);
2917 g_print ("SPACING: %d\n", spacing);
2918 g_print ("PIXMAP: %d\n", (int) pixmap);
2919 g_print ("MASK: %d\n", (int) mask);
2927 /* print selections list */
2928 g_print ("\nSelected Rows:");
2929 list = GTK_CLIST (widget)->selection;
2932 g_print (" %d ", (gint) list->data);
2938 clist_selected_row = row;
2942 unselect_clist (GtkWidget *widget,
2945 GdkEventButton * bevent)
2954 g_print ("GtkCList Unselection: row %d column %d button %d\n",
2955 row, column, bevent ? bevent->button : 0);
2957 for (i = 0; i < TESTGTK_CLIST_COLUMNS; i++)
2959 switch (gtk_clist_get_cell_type (GTK_CLIST (widget), row, i))
2962 g_print ("CELL %d GTK_CELL_TEXT\n", i);
2963 gtk_clist_get_text (GTK_CLIST (widget), row, i, &text);
2964 g_print ("TEXT: %s\n", text);
2967 case GTK_CELL_PIXMAP:
2968 g_print ("CELL %d GTK_CELL_PIXMAP\n", i);
2969 gtk_clist_get_pixmap (GTK_CLIST (widget), row, i, &pixmap, &mask);
2970 g_print ("PIXMAP: %d\n", (int) pixmap);
2971 g_print ("MASK: %d\n", (int) mask);
2974 case GTK_CELL_PIXTEXT:
2975 g_print ("CELL %d GTK_CELL_PIXTEXT\n", i);
2976 gtk_clist_get_pixtext (GTK_CLIST (widget), row, i, &text, &spacing, &pixmap, &mask);
2977 g_print ("TEXT: %s\n", text);
2978 g_print ("SPACING: %d\n", spacing);
2979 g_print ("PIXMAP: %d\n", (int) pixmap);
2980 g_print ("MASK: %d\n", (int) mask);
2988 /* print selections list */
2989 g_print ("\nSelected Rows:");
2990 list = GTK_CLIST (widget)->selection;
2993 g_print (" %d ", (gint) list->data);
2999 clist_selected_row = row;
3003 insert_row_clist (GtkWidget *widget, gpointer data)
3005 static char *text[] =
3016 gtk_clist_insert (GTK_CLIST (data), clist_selected_row, text);
3024 static GtkWidget *window = NULL;
3026 static char *titles[] =
3037 char text[TESTGTK_CLIST_COLUMNS][50];
3038 char *texts[TESTGTK_CLIST_COLUMNS];
3044 GtkWidget *separator;
3049 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
3051 gtk_signal_connect (GTK_OBJECT (window), "destroy",
3052 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
3055 gtk_window_set_title (GTK_WINDOW (window), "clist");
3056 gtk_container_border_width (GTK_CONTAINER (window), 0);
3059 box1 = gtk_vbox_new (FALSE, 0);
3060 gtk_container_add (GTK_CONTAINER (window), box1);
3061 gtk_widget_show (box1);
3064 box2 = gtk_hbox_new (FALSE, 10);
3065 gtk_container_border_width (GTK_CONTAINER (box2), 10);
3066 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0);
3067 gtk_widget_show (box2);
3069 /* create GtkCList here so we have a pointer to throw at the
3070 * button callbacks -- more is done with it later */
3071 clist = gtk_clist_new_with_titles (TESTGTK_CLIST_COLUMNS, titles);
3072 /*clist = gtk_clist_new (TESTGTK_CLIST_COLUMNS);*/
3074 /* control buttons */
3075 button = gtk_button_new_with_label ("Add 1,000 Rows With Pixmaps");
3076 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
3078 gtk_signal_connect (GTK_OBJECT (button),
3080 (GtkSignalFunc) add1000_clist,
3083 gtk_widget_show (button);
3086 button = gtk_button_new_with_label ("Add 10,000 Rows");
3087 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
3089 gtk_signal_connect (GTK_OBJECT (button),
3091 (GtkSignalFunc) add10000_clist,
3094 gtk_widget_show (button);
3096 button = gtk_button_new_with_label ("Clear List");
3097 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
3099 gtk_signal_connect (GTK_OBJECT (button),
3101 (GtkSignalFunc) clear_clist,
3104 gtk_widget_show (button);
3106 button = gtk_button_new_with_label ("Remove Row");
3107 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
3109 gtk_signal_connect (GTK_OBJECT (button),
3111 (GtkSignalFunc) remove_row_clist,
3114 gtk_widget_show (button);
3116 /* second layer of buttons */
3117 box2 = gtk_hbox_new (FALSE, 10);
3118 gtk_container_border_width (GTK_CONTAINER (box2), 10);
3119 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0);
3120 gtk_widget_show (box2);
3122 button = gtk_button_new_with_label ("Insert Row");
3123 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
3125 gtk_signal_connect (GTK_OBJECT (button),
3127 (GtkSignalFunc) insert_row_clist,
3130 gtk_widget_show (button);
3132 button = gtk_button_new_with_label ("Show Title Buttons");
3133 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
3135 gtk_signal_connect (GTK_OBJECT (button),
3137 (GtkSignalFunc) show_titles_clist,
3140 gtk_widget_show (button);
3142 button = gtk_button_new_with_label ("Hide Title Buttons");
3143 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
3145 gtk_signal_connect (GTK_OBJECT (button),
3147 (GtkSignalFunc) hide_titles_clist,
3150 gtk_widget_show (button);
3152 /* vbox for the list itself */
3153 box2 = gtk_vbox_new (FALSE, 10);
3154 gtk_container_border_width (GTK_CONTAINER (box2), 10);
3155 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
3156 gtk_widget_show (box2);
3159 * the rest of the clist configuration
3161 gtk_clist_set_row_height (GTK_CLIST (clist), 20);
3163 gtk_signal_connect (GTK_OBJECT (clist),
3165 (GtkSignalFunc) select_clist,
3168 gtk_signal_connect (GTK_OBJECT (clist),
3170 (GtkSignalFunc) unselect_clist,
3173 gtk_clist_set_column_width (GTK_CLIST (clist), 0, 100);
3175 for (i = 1; i < TESTGTK_CLIST_COLUMNS; i++)
3176 gtk_clist_set_column_width (GTK_CLIST (clist), i, 80);
3178 gtk_clist_set_selection_mode (GTK_CLIST (clist), GTK_SELECTION_BROWSE);
3179 gtk_clist_set_policy (GTK_CLIST (clist),
3180 GTK_POLICY_AUTOMATIC,
3181 GTK_POLICY_AUTOMATIC);
3183 gtk_clist_set_policy (GTK_CLIST (clist), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
3185 gtk_clist_set_column_justification (GTK_CLIST (clist), 1, GTK_JUSTIFY_RIGHT);
3186 gtk_clist_set_column_justification (GTK_CLIST (clist), 2, GTK_JUSTIFY_CENTER);
3188 for (i = 0; i < TESTGTK_CLIST_COLUMNS; i++)
3191 sprintf (text[i], "Column %d", i);
3194 sprintf (text[1], "Right");
3195 sprintf (text[2], "Center");
3197 for (i = 0; i < 100; i++)
3199 sprintf (text[0], "Row %d", clist_rows++);
3200 gtk_clist_append (GTK_CLIST (clist), texts);
3203 gtk_container_border_width (GTK_CONTAINER (clist), 5);
3204 gtk_box_pack_start (GTK_BOX (box2), clist, TRUE, TRUE, 0);
3205 gtk_widget_show (clist);
3208 separator = gtk_hseparator_new ();
3209 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
3210 gtk_widget_show (separator);
3212 box2 = gtk_vbox_new (FALSE, 10);
3213 gtk_container_border_width (GTK_CONTAINER (box2), 10);
3214 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
3215 gtk_widget_show (box2);
3217 button = gtk_button_new_with_label ("close");
3218 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
3219 GTK_SIGNAL_FUNC(gtk_widget_destroy),
3220 GTK_OBJECT (window));
3222 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
3223 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
3224 gtk_widget_grab_default (button);
3226 gtk_widget_show (button);
3229 if (!GTK_WIDGET_VISIBLE (window))
3230 gtk_widget_show (window);
3234 gtk_widget_destroy (window);
3243 color_selection_ok (GtkWidget *w,
3244 GtkColorSelectionDialog *cs)
3246 GtkColorSelection *colorsel;
3249 colorsel=GTK_COLOR_SELECTION(cs->colorsel);
3251 gtk_color_selection_get_color(colorsel,color);
3252 gtk_color_selection_set_color(colorsel,color);
3256 color_selection_changed (GtkWidget *w,
3257 GtkColorSelectionDialog *cs)
3259 GtkColorSelection *colorsel;
3262 colorsel=GTK_COLOR_SELECTION(cs->colorsel);
3263 gtk_color_selection_get_color(colorsel,color);
3267 create_color_selection ()
3269 static GtkWidget *window = NULL;
3273 gtk_preview_set_install_cmap (TRUE);
3274 gtk_widget_push_visual (gtk_preview_get_visual ());
3275 gtk_widget_push_colormap (gtk_preview_get_cmap ());
3277 window = gtk_color_selection_dialog_new ("color selection dialog");
3279 gtk_color_selection_set_opacity (
3280 GTK_COLOR_SELECTION (GTK_COLOR_SELECTION_DIALOG (window)->colorsel),
3283 gtk_color_selection_set_update_policy(
3284 GTK_COLOR_SELECTION (GTK_COLOR_SELECTION_DIALOG (window)->colorsel),
3285 GTK_UPDATE_CONTINUOUS);
3287 gtk_window_position (GTK_WINDOW (window), GTK_WIN_POS_MOUSE);
3289 gtk_signal_connect (GTK_OBJECT (window), "destroy",
3290 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
3293 gtk_signal_connect (
3294 GTK_OBJECT (GTK_COLOR_SELECTION_DIALOG (window)->colorsel),
3296 GTK_SIGNAL_FUNC(color_selection_changed),
3299 gtk_signal_connect (
3300 GTK_OBJECT (GTK_COLOR_SELECTION_DIALOG (window)->ok_button),
3302 GTK_SIGNAL_FUNC(color_selection_ok),
3305 gtk_signal_connect_object (
3306 GTK_OBJECT (GTK_COLOR_SELECTION_DIALOG (window)->cancel_button),
3308 GTK_SIGNAL_FUNC(gtk_widget_destroy),
3309 GTK_OBJECT (window));
3311 gtk_widget_pop_colormap ();
3312 gtk_widget_pop_visual ();
3315 if (!GTK_WIDGET_VISIBLE (window))
3316 gtk_widget_show (window);
3318 gtk_widget_destroy (window);
3322 file_selection_hide_fileops (GtkWidget *widget,
3323 GtkFileSelection *fs)
3325 gtk_file_selection_hide_fileop_buttons (fs);
3329 file_selection_ok (GtkWidget *w,
3330 GtkFileSelection *fs)
3332 g_print ("%s\n", gtk_file_selection_get_filename (GTK_FILE_SELECTION (fs)));
3333 gtk_widget_destroy (GTK_WIDGET (fs));
3337 create_file_selection ()
3339 static GtkWidget *window = NULL;
3344 window = gtk_file_selection_new ("file selection dialog");
3346 gtk_file_selection_hide_fileop_buttons (GTK_FILE_SELECTION (window));
3348 gtk_window_position (GTK_WINDOW (window), GTK_WIN_POS_MOUSE);
3350 gtk_signal_connect (GTK_OBJECT (window), "destroy",
3351 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
3354 gtk_signal_connect (GTK_OBJECT (GTK_FILE_SELECTION (window)->ok_button),
3355 "clicked", GTK_SIGNAL_FUNC(file_selection_ok),
3357 gtk_signal_connect_object (GTK_OBJECT (GTK_FILE_SELECTION (window)->cancel_button),
3358 "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy),
3359 GTK_OBJECT (window));
3361 button = gtk_button_new_with_label ("Hide Fileops");
3362 gtk_signal_connect (GTK_OBJECT (button), "clicked",
3363 (GtkSignalFunc) file_selection_hide_fileops,
3365 gtk_box_pack_start (GTK_BOX (GTK_FILE_SELECTION (window)->action_area),
3366 button, FALSE, FALSE, 0);
3367 gtk_widget_show (button);
3369 button = gtk_button_new_with_label ("Show Fileops");
3370 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
3371 (GtkSignalFunc) gtk_file_selection_show_fileop_buttons,
3373 gtk_box_pack_start (GTK_BOX (GTK_FILE_SELECTION (window)->action_area),
3374 button, FALSE, FALSE, 0);
3375 gtk_widget_show (button);
3381 if (!GTK_WIDGET_VISIBLE (window))
3382 gtk_widget_show (window);
3384 gtk_widget_destroy (window);
3391 static GtkWidget *dialog_window = NULL;
3394 label_toggle (GtkWidget *widget,
3399 *label = gtk_label_new ("Dialog Test");
3400 gtk_signal_connect (GTK_OBJECT (*label),
3402 GTK_SIGNAL_FUNC (gtk_widget_destroyed),
3404 gtk_misc_set_padding (GTK_MISC (*label), 10, 10);
3405 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog_window)->vbox),
3406 *label, TRUE, TRUE, 0);
3407 gtk_widget_show (*label);
3410 gtk_widget_destroy (*label);
3416 static GtkWidget *label;
3421 dialog_window = gtk_dialog_new ();
3423 gtk_signal_connect (GTK_OBJECT (dialog_window), "destroy",
3424 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
3427 gtk_window_set_title (GTK_WINDOW (dialog_window), "dialog");
3428 gtk_container_border_width (GTK_CONTAINER (dialog_window), 0);
3430 button = gtk_button_new_with_label ("OK");
3431 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
3432 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog_window)->action_area),
3433 button, TRUE, TRUE, 0);
3434 gtk_widget_grab_default (button);
3435 gtk_widget_show (button);
3437 button = gtk_button_new_with_label ("Toggle");
3438 gtk_signal_connect (GTK_OBJECT (button), "clicked",
3439 GTK_SIGNAL_FUNC (label_toggle),
3441 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
3442 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog_window)->action_area),
3443 button, TRUE, TRUE, 0);
3444 gtk_widget_show (button);
3449 if (!GTK_WIDGET_VISIBLE (dialog_window))
3450 gtk_widget_show (dialog_window);
3452 gtk_widget_destroy (dialog_window);
3460 create_range_controls ()
3462 static GtkWidget *window = NULL;
3466 GtkWidget *scrollbar;
3468 GtkWidget *separator;
3469 GtkObject *adjustment;
3473 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
3475 gtk_signal_connect (GTK_OBJECT (window), "destroy",
3476 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
3479 gtk_window_set_title (GTK_WINDOW (window), "range controls");
3480 gtk_container_border_width (GTK_CONTAINER (window), 0);
3483 box1 = gtk_vbox_new (FALSE, 0);
3484 gtk_container_add (GTK_CONTAINER (window), box1);
3485 gtk_widget_show (box1);
3488 box2 = gtk_vbox_new (FALSE, 10);
3489 gtk_container_border_width (GTK_CONTAINER (box2), 10);
3490 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
3491 gtk_widget_show (box2);
3494 adjustment = gtk_adjustment_new (0.0, 0.0, 101.0, 0.1, 1.0, 1.0);
3496 scale = gtk_hscale_new (GTK_ADJUSTMENT (adjustment));
3497 gtk_widget_set_usize (GTK_WIDGET (scale), 150, 30);
3498 gtk_range_set_update_policy (GTK_RANGE (scale), GTK_UPDATE_DELAYED);
3499 gtk_scale_set_digits (GTK_SCALE (scale), 1);
3500 gtk_scale_set_draw_value (GTK_SCALE (scale), TRUE);
3501 gtk_box_pack_start (GTK_BOX (box2), scale, TRUE, TRUE, 0);
3502 gtk_widget_show (scale);
3504 scrollbar = gtk_hscrollbar_new (GTK_ADJUSTMENT (adjustment));
3505 gtk_range_set_update_policy (GTK_RANGE (scrollbar),
3506 GTK_UPDATE_CONTINUOUS);
3507 gtk_box_pack_start (GTK_BOX (box2), scrollbar, TRUE, TRUE, 0);
3508 gtk_widget_show (scrollbar);
3511 separator = gtk_hseparator_new ();
3512 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
3513 gtk_widget_show (separator);
3516 box2 = gtk_vbox_new (FALSE, 10);
3517 gtk_container_border_width (GTK_CONTAINER (box2), 10);
3518 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
3519 gtk_widget_show (box2);
3522 button = gtk_button_new_with_label ("close");
3523 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
3524 GTK_SIGNAL_FUNC(gtk_widget_destroy),
3525 GTK_OBJECT (window));
3526 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
3527 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
3528 gtk_widget_grab_default (button);
3529 gtk_widget_show (button);
3532 if (!GTK_WIDGET_VISIBLE (window))
3533 gtk_widget_show (window);
3535 gtk_widget_destroy (window);
3545 static GtkWidget *window = NULL;
3551 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
3553 gtk_signal_connect (GTK_OBJECT (window), "destroy",
3554 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
3557 gtk_window_set_title (GTK_WINDOW (window), "rulers");
3558 gtk_widget_set_usize (window, 300, 300);
3559 gtk_widget_set_events (window,
3560 GDK_POINTER_MOTION_MASK
3561 | GDK_POINTER_MOTION_HINT_MASK);
3562 gtk_container_border_width (GTK_CONTAINER (window), 0);
3564 table = gtk_table_new (2, 2, FALSE);
3565 gtk_container_add (GTK_CONTAINER (window), table);
3566 gtk_widget_show (table);
3568 ruler = gtk_hruler_new ();
3569 gtk_ruler_set_range (GTK_RULER (ruler), 5, 15, 0, 20);
3571 gtk_signal_connect_object (
3572 GTK_OBJECT (window),
3573 "motion_notify_event",
3575 GTK_WIDGET_CLASS (GTK_OBJECT (ruler)->klass)->motion_notify_event),
3576 GTK_OBJECT (ruler));
3578 gtk_table_attach (GTK_TABLE (table), ruler, 1, 2, 0, 1,
3579 GTK_EXPAND | GTK_FILL, GTK_FILL, 0, 0);
3580 gtk_widget_show (ruler);
3583 ruler = gtk_vruler_new ();
3584 gtk_ruler_set_range (GTK_RULER (ruler), 5, 15, 0, 20);
3586 gtk_signal_connect_object (
3587 GTK_OBJECT (window),
3588 "motion_notify_event",
3589 GTK_SIGNAL_FUNC (GTK_WIDGET_CLASS (GTK_OBJECT (ruler)->klass)->motion_notify_event),
3590 GTK_OBJECT (ruler));
3592 gtk_table_attach (GTK_TABLE (table), ruler, 0, 1, 1, 2,
3593 GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
3594 gtk_widget_show (ruler);
3597 if (!GTK_WIDGET_VISIBLE (window))
3598 gtk_widget_show (window);
3600 gtk_widget_destroy (window);
3605 text_toggle_editable (GtkWidget *checkbutton,
3608 gtk_text_set_editable(GTK_TEXT(text),
3609 GTK_TOGGLE_BUTTON(checkbutton)->active);
3618 static GtkWidget *window = NULL;
3622 GtkWidget *editable_check;
3623 GtkWidget *separator;
3625 GtkWidget *hscrollbar;
3626 GtkWidget *vscrollbar;
3633 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
3634 gtk_widget_set_name (window, "text window");
3635 gtk_widget_set_usize (window, 500, 500);
3636 gtk_window_set_policy (GTK_WINDOW(window), TRUE, TRUE, FALSE);
3638 gtk_signal_connect (GTK_OBJECT (window), "destroy",
3639 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
3642 gtk_window_set_title (GTK_WINDOW (window), "test");
3643 gtk_container_border_width (GTK_CONTAINER (window), 0);
3646 box1 = gtk_vbox_new (FALSE, 0);
3647 gtk_container_add (GTK_CONTAINER (window), box1);
3648 gtk_widget_show (box1);
3651 box2 = gtk_vbox_new (FALSE, 10);
3652 gtk_container_border_width (GTK_CONTAINER (box2), 10);
3653 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
3654 gtk_widget_show (box2);
3657 table = gtk_table_new (2, 2, FALSE);
3658 gtk_table_set_row_spacing (GTK_TABLE (table), 0, 2);
3659 gtk_table_set_col_spacing (GTK_TABLE (table), 0, 2);
3660 gtk_box_pack_start (GTK_BOX (box2), table, TRUE, TRUE, 0);
3661 gtk_widget_show (table);
3663 text = gtk_text_new (NULL, NULL);
3664 gtk_text_set_editable (GTK_TEXT (text), TRUE);
3665 gtk_table_attach (GTK_TABLE (table), text, 0, 1, 0, 1,
3666 GTK_EXPAND | GTK_SHRINK | GTK_FILL,
3667 GTK_EXPAND | GTK_SHRINK | GTK_FILL, 0, 0);
3668 gtk_widget_show (text);
3670 hscrollbar = gtk_hscrollbar_new (GTK_TEXT (text)->hadj);
3671 gtk_table_attach (GTK_TABLE (table), hscrollbar, 0, 1, 1, 2,
3672 GTK_EXPAND | GTK_FILL | GTK_SHRINK, GTK_FILL, 0, 0);
3673 gtk_widget_show (hscrollbar);
3675 vscrollbar = gtk_vscrollbar_new (GTK_TEXT (text)->vadj);
3676 gtk_table_attach (GTK_TABLE (table), vscrollbar, 1, 2, 0, 1,
3677 GTK_FILL, GTK_EXPAND | GTK_SHRINK | GTK_FILL, 0, 0);
3678 gtk_widget_show (vscrollbar);
3680 gtk_text_freeze (GTK_TEXT (text));
3682 gtk_widget_realize (text);
3684 infile = fopen("testgtk.c", "r");
3693 nchars = fread(buffer, 1, 1024, infile);
3694 gtk_text_insert (GTK_TEXT (text), NULL, NULL,
3695 NULL, buffer, nchars);
3704 gtk_text_insert (GTK_TEXT (text), NULL, &text->style->black, NULL,
3706 gtk_text_insert (GTK_TEXT (text), NULL, &text->style->bg[GTK_STATE_NORMAL], NULL,
3708 gtk_text_insert (GTK_TEXT (text), NULL, &text->style->black, NULL,
3711 gtk_text_thaw (GTK_TEXT (text));
3713 editable_check = gtk_check_button_new_with_label("Editable");
3714 gtk_box_pack_start (GTK_BOX (box2), editable_check, FALSE, TRUE, 0);
3715 gtk_signal_connect (GTK_OBJECT(editable_check), "toggled",
3716 GTK_SIGNAL_FUNC(text_toggle_editable), text);
3717 gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(editable_check), TRUE);
3718 gtk_widget_show (editable_check);
3720 separator = gtk_hseparator_new ();
3721 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
3722 gtk_widget_show (separator);
3725 box2 = gtk_vbox_new (FALSE, 10);
3726 gtk_container_border_width (GTK_CONTAINER (box2), 10);
3727 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
3728 gtk_widget_show (box2);
3731 button = gtk_button_new_with_label ("close");
3732 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
3733 GTK_SIGNAL_FUNC(gtk_widget_destroy),
3734 GTK_OBJECT (window));
3735 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
3736 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
3737 gtk_widget_grab_default (button);
3738 gtk_widget_show (button);
3741 if (!GTK_WIDGET_VISIBLE (window))
3742 gtk_widget_show (window);
3744 gtk_widget_destroy (window);
3752 GdkPixmap *book_open;
3753 GdkPixmap *book_closed;
3754 GdkBitmap *book_open_mask;
3755 GdkBitmap *book_closed_mask;
3757 static char * book_open_xpm[] = {
3780 static char * book_closed_xpm[] = {
3806 page_switch (GtkWidget *widget, GtkNotebookPage *page, gint page_num)
3808 GtkNotebookPage *oldpage;
3811 oldpage = GTK_NOTEBOOK (widget)->cur_page;
3813 if (page == oldpage)
3816 pixwid = ((GtkBoxChild*)(GTK_BOX (page->tab_label)->children->data))->widget;
3817 gtk_pixmap_set (GTK_PIXMAP (pixwid), book_open, book_open_mask);
3818 pixwid = ((GtkBoxChild*) (GTK_BOX (page->menu_label)->children->data))->widget;
3819 gtk_pixmap_set (GTK_PIXMAP (pixwid), book_open, book_open_mask);
3823 pixwid = ((GtkBoxChild*) (GTK_BOX
3824 (oldpage->tab_label)->children->data))->widget;
3825 gtk_pixmap_set (GTK_PIXMAP (pixwid), book_closed, book_closed_mask);
3826 pixwid = ((GtkBoxChild*) (GTK_BOX (oldpage->menu_label)->children->data))->widget;
3827 gtk_pixmap_set (GTK_PIXMAP (pixwid), book_closed, book_closed_mask);
3832 create_pages (GtkNotebook *notebook, gint start, gint end)
3834 GtkWidget *child = NULL;
3839 GtkWidget *label_box;
3840 GtkWidget *menu_box;
3846 for (i = start; i <= end; i++)
3848 sprintf (buffer, "Page %d", i);
3853 child = gtk_button_new_with_label (buffer);
3854 gtk_container_border_width (GTK_CONTAINER(child), 10);
3857 child = gtk_label_new (buffer);
3860 child = gtk_frame_new (buffer);
3861 gtk_container_border_width (GTK_CONTAINER (child), 10);
3863 box = gtk_vbox_new (TRUE,0);
3864 gtk_container_border_width (GTK_CONTAINER (box), 10);
3865 gtk_container_add (GTK_CONTAINER (child), box);
3867 label = gtk_label_new (buffer);
3868 gtk_box_pack_start (GTK_BOX(box), label, TRUE, TRUE, 5);
3870 entry = gtk_entry_new ();
3871 gtk_box_pack_start (GTK_BOX(box), entry, TRUE, TRUE, 5);
3873 hbox = gtk_hbox_new (TRUE,0);
3874 gtk_box_pack_start (GTK_BOX(box), hbox, TRUE, TRUE, 5);
3876 button = gtk_button_new_with_label ("Ok");
3877 gtk_box_pack_start (GTK_BOX(hbox), button, TRUE, TRUE, 5);
3879 button = gtk_button_new_with_label ("Cancel");
3880 gtk_box_pack_start (GTK_BOX(hbox), button, TRUE, TRUE, 5);
3883 child = gtk_frame_new (buffer);
3884 gtk_container_border_width (GTK_CONTAINER (child), 10);
3886 label = gtk_label_new (buffer);
3887 gtk_container_add (GTK_CONTAINER (child), label);
3891 gtk_widget_show_all (child);
3893 label_box = gtk_hbox_new (FALSE, 0);
3894 pixwid = gtk_pixmap_new (book_closed, book_closed_mask);
3895 gtk_box_pack_start (GTK_BOX (label_box), pixwid, FALSE, TRUE, 0);
3896 gtk_misc_set_padding (GTK_MISC (pixwid), 3, 1);
3897 label = gtk_label_new (buffer);
3898 gtk_box_pack_start (GTK_BOX (label_box), label, FALSE, TRUE, 0);
3899 gtk_widget_show_all (label_box);
3901 menu_box = gtk_hbox_new (FALSE, 0);
3902 pixwid = gtk_pixmap_new (book_closed, book_closed_mask);
3903 gtk_box_pack_start (GTK_BOX (menu_box), pixwid, FALSE, TRUE, 0);
3904 gtk_misc_set_padding (GTK_MISC (pixwid), 3, 1);
3905 label = gtk_label_new (buffer);
3906 gtk_box_pack_start (GTK_BOX (menu_box), label, FALSE, TRUE, 0);
3907 gtk_widget_show_all (menu_box);
3909 gtk_notebook_append_page_menu (notebook, child, label_box, menu_box);
3914 rotate_notebook (GtkButton *button,
3915 GtkNotebook *notebook)
3917 gtk_notebook_set_tab_pos (notebook, (notebook->tab_pos + 1) % 4);
3921 standard_notebook (GtkButton *button,
3922 GtkNotebook *notebook)
3926 gtk_notebook_set_show_tabs (notebook, TRUE);
3927 gtk_notebook_set_scrollable (notebook, FALSE);
3928 if (g_list_length (notebook->children) == 15)
3929 for (i = 0; i < 10; i++)
3930 gtk_notebook_remove_page (notebook, 5);
3934 notabs_notebook (GtkButton *button,
3935 GtkNotebook *notebook)
3939 gtk_notebook_set_show_tabs (notebook, FALSE);
3940 if (g_list_length (notebook->children) == 15)
3941 for (i = 0; i < 10; i++)
3942 gtk_notebook_remove_page (notebook, 5);
3946 scrollable_notebook (GtkButton *button,
3947 GtkNotebook *notebook)
3949 gtk_notebook_set_show_tabs (notebook, TRUE);
3950 gtk_notebook_set_scrollable (notebook, TRUE);
3951 if (g_list_length (notebook->children) == 5)
3952 create_pages (notebook, 6, 15);
3956 notebook_popup (GtkToggleButton *button,
3957 GtkNotebook *notebook)
3960 gtk_notebook_popup_enable (notebook);
3962 gtk_notebook_popup_disable (notebook);
3968 static GtkWidget *window = NULL;
3972 GtkWidget *separator;
3973 GtkWidget *notebook;
3977 GtkWidget *menuitem;
3979 GdkColor transparent;
3983 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
3985 gtk_signal_connect (GTK_OBJECT (window), "destroy",
3986 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
3989 gtk_window_set_title (GTK_WINDOW (window), "notebook");
3990 gtk_container_border_width (GTK_CONTAINER (window), 0);
3992 box1 = gtk_vbox_new (FALSE, 0);
3993 gtk_container_add (GTK_CONTAINER (window), box1);
3995 notebook = gtk_notebook_new ();
3996 gtk_signal_connect (GTK_OBJECT (notebook), "switch_page",
3997 GTK_SIGNAL_FUNC (page_switch), NULL);
3998 gtk_notebook_set_tab_pos (GTK_NOTEBOOK (notebook), GTK_POS_TOP);
3999 gtk_box_pack_start (GTK_BOX (box1), notebook, TRUE, TRUE, 0);
4000 gtk_container_border_width (GTK_CONTAINER (notebook), 10);
4002 gtk_widget_realize (notebook);
4003 book_open = gdk_pixmap_create_from_xpm_d (notebook->window,
4007 book_closed = gdk_pixmap_create_from_xpm_d (notebook->window,
4012 create_pages (GTK_NOTEBOOK (notebook), 1, 5);
4014 separator = gtk_hseparator_new ();
4015 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 10);
4017 box2 = gtk_hbox_new (TRUE, 5);
4018 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
4020 omenu = gtk_option_menu_new ();
4021 menu = gtk_menu_new ();
4025 menuitem = gtk_radio_menu_item_new_with_label (group, "Standard");
4026 gtk_signal_connect_object (GTK_OBJECT (menuitem), "activate",
4027 GTK_SIGNAL_FUNC (standard_notebook),
4028 GTK_OBJECT (notebook));
4029 group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menuitem));
4030 gtk_menu_append (GTK_MENU (menu), menuitem);
4031 gtk_widget_show (menuitem);
4032 menuitem = gtk_radio_menu_item_new_with_label (group, "w/o Tabs");
4033 gtk_signal_connect_object (GTK_OBJECT (menuitem), "activate",
4034 GTK_SIGNAL_FUNC (notabs_notebook),
4035 GTK_OBJECT (notebook));
4036 group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menuitem));
4037 gtk_menu_append (GTK_MENU (menu), menuitem);
4038 gtk_widget_show (menuitem);
4039 menuitem = gtk_radio_menu_item_new_with_label (group, "Scrollable");
4040 gtk_signal_connect_object (GTK_OBJECT (menuitem), "activate",
4041 GTK_SIGNAL_FUNC (scrollable_notebook),
4042 GTK_OBJECT (notebook));
4043 group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menuitem));
4044 gtk_menu_append (GTK_MENU (menu), menuitem);
4045 gtk_widget_show (menuitem);
4047 gtk_option_menu_set_menu (GTK_OPTION_MENU (omenu), menu);
4048 gtk_box_pack_start (GTK_BOX (box2), omenu, FALSE, FALSE, 0);
4049 button = gtk_check_button_new_with_label ("enable popup menu");
4050 gtk_box_pack_start (GTK_BOX (box2), button, FALSE, FALSE, 0);
4051 gtk_signal_connect (GTK_OBJECT(button), "clicked",
4052 GTK_SIGNAL_FUNC (notebook_popup),
4053 GTK_OBJECT (notebook));
4055 box2 = gtk_hbox_new (FALSE, 10);
4056 gtk_container_border_width (GTK_CONTAINER (box2), 10);
4057 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
4059 button = gtk_button_new_with_label ("close");
4060 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
4061 GTK_SIGNAL_FUNC (gtk_widget_destroy),
4062 GTK_OBJECT (window));
4063 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
4064 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
4065 gtk_widget_grab_default (button);
4067 button = gtk_button_new_with_label ("next");
4068 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
4069 GTK_SIGNAL_FUNC (gtk_notebook_next_page),
4070 GTK_OBJECT (notebook));
4071 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
4073 button = gtk_button_new_with_label ("prev");
4074 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
4075 GTK_SIGNAL_FUNC (gtk_notebook_prev_page),
4076 GTK_OBJECT (notebook));
4077 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
4079 button = gtk_button_new_with_label ("rotate");
4080 gtk_signal_connect (GTK_OBJECT (button), "clicked",
4081 GTK_SIGNAL_FUNC (rotate_notebook),
4083 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
4086 if (!GTK_WIDGET_VISIBLE (window))
4087 gtk_widget_show_all (window);
4089 gtk_widget_destroy (window);
4099 static GtkWidget *window = NULL;
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), "Panes");
4113 gtk_container_border_width (GTK_CONTAINER (window), 0);
4115 vpaned = gtk_vpaned_new ();
4116 gtk_container_add (GTK_CONTAINER (window), vpaned);
4117 gtk_container_border_width (GTK_CONTAINER(vpaned), 5);
4118 gtk_widget_show (vpaned);
4120 hpaned = gtk_hpaned_new ();
4121 gtk_paned_add1 (GTK_PANED (vpaned), hpaned);
4123 frame = gtk_frame_new (NULL);
4124 gtk_frame_set_shadow_type (GTK_FRAME(frame), GTK_SHADOW_IN);
4125 gtk_widget_set_usize (frame, 60, 60);
4126 gtk_paned_add1 (GTK_PANED (hpaned), frame);
4127 gtk_widget_show (frame);
4129 frame = gtk_frame_new (NULL);
4130 gtk_frame_set_shadow_type (GTK_FRAME(frame), GTK_SHADOW_IN);
4131 gtk_widget_set_usize (frame, 80, 60);
4132 gtk_paned_add2 (GTK_PANED (hpaned), frame);
4133 gtk_widget_show (frame);
4135 gtk_widget_show (hpaned);
4137 frame = gtk_frame_new (NULL);
4138 gtk_frame_set_shadow_type (GTK_FRAME(frame), GTK_SHADOW_IN);
4139 gtk_widget_set_usize (frame, 60, 80);
4140 gtk_paned_add2 (GTK_PANED (vpaned), frame);
4141 gtk_widget_show (frame);
4144 if (!GTK_WIDGET_VISIBLE (window))
4145 gtk_widget_show (window);
4147 gtk_widget_destroy (window);
4156 dnd_drop_destroy_popup (GtkWidget *widget, GtkWindow **window)
4158 if(GTK_IS_BUTTON(widget)) /* I.e. they clicked the close button */
4159 gtk_widget_destroy(GTK_WIDGET(*window));
4161 gtk_grab_remove(GTK_WIDGET(*window));
4169 dnd_drop (GtkWidget *button, GdkEvent *event)
4171 static GtkWidget *window = NULL;
4172 GtkWidget *vbox, *lbl, *btn;
4175 window = gtk_window_new(GTK_WINDOW_DIALOG);
4176 gtk_container_border_width (GTK_CONTAINER(window), 10);
4178 gtk_signal_connect (GTK_OBJECT (window), "destroy",
4179 GTK_SIGNAL_FUNC(dnd_drop_destroy_popup),
4181 gtk_signal_connect (GTK_OBJECT (window), "delete_event",
4182 GTK_SIGNAL_FUNC(dnd_drop_destroy_popup),
4185 vbox = gtk_vbox_new(FALSE, 5);
4187 /* Display message that we got from drop source */
4188 msg = g_malloc(strlen(event->dropdataavailable.data)
4189 + strlen(event->dropdataavailable.data_type) + 100);
4190 sprintf(msg, "Drop data of type %s was:\n\n%s",
4191 event->dropdataavailable.data_type,
4192 (char *)event->dropdataavailable.data);
4193 lbl = gtk_label_new(msg);
4194 gtk_label_set_justify(GTK_LABEL(lbl), GTK_JUSTIFY_FILL);
4196 gtk_widget_show(lbl);
4197 gtk_box_pack_start_defaults(GTK_BOX(vbox), lbl);
4199 /* Provide an obvious way out of this heinousness */
4200 btn = gtk_button_new_with_label("Continue with life in\nspite of this oppression");
4201 gtk_signal_connect (GTK_OBJECT (btn), "clicked",
4202 GTK_SIGNAL_FUNC(dnd_drop_destroy_popup),
4204 gtk_widget_show(btn);
4205 gtk_box_pack_start_defaults(GTK_BOX(vbox), btn);
4207 gtk_container_add(GTK_CONTAINER(window), vbox);
4209 gtk_widget_show(vbox);
4210 gtk_grab_add(window);
4211 gtk_widget_show(window);
4215 dnd_drag_request (GtkWidget *button, GdkEvent *event)
4217 #define DND_STRING "Bill Gates demands royalties for\nyour use of his innovation."
4218 gtk_widget_dnd_data_set (button, event, DND_STRING, strlen(DND_STRING) + 1);
4224 static GtkWidget *window = NULL;
4230 GtkWidget *separator;
4232 /* For clarity... */
4233 char *possible_drag_types[] = {"text/plain"};
4234 char *accepted_drop_types[] = {"text/plain"};
4241 GdkPoint hotspot = {5,5};
4243 gdk_dnd_set_drag_shape(modeller->window,
4248 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
4250 gtk_signal_connect (GTK_OBJECT (window), "destroy",
4251 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
4254 gtk_window_set_title (GTK_WINDOW (window), "Drag -N- Drop");
4255 gtk_container_border_width (GTK_CONTAINER (window), 0);
4257 box1 = gtk_vbox_new (FALSE, 0);
4258 gtk_container_add (GTK_CONTAINER (window), box1);
4259 gtk_widget_show (box1);
4261 box2 = gtk_hbox_new (FALSE, 5);
4262 gtk_container_border_width (GTK_CONTAINER (box2), 10);
4263 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
4264 gtk_widget_show (box2);
4266 frame = gtk_frame_new ("Drag");
4267 gtk_box_pack_start (GTK_BOX (box2), frame, TRUE, TRUE, 0);
4268 gtk_widget_show (frame);
4270 box3 = gtk_vbox_new (FALSE, 5);
4271 gtk_container_border_width (GTK_CONTAINER (box3), 5);
4272 gtk_container_add (GTK_CONTAINER (frame), box3);
4273 gtk_widget_show (box3);
4278 button = gtk_button_new_with_label ("Drag me!");
4279 gtk_box_pack_start (GTK_BOX (box3), button, FALSE, TRUE, 0);
4280 gtk_widget_show (button);
4283 * currently, the widget has to be realized to
4284 * set dnd on it, this needs to change
4286 gtk_widget_realize (button);
4287 gtk_signal_connect (GTK_OBJECT (button),
4288 "drag_request_event",
4289 GTK_SIGNAL_FUNC(dnd_drag_request),
4292 gtk_widget_dnd_drag_set (button, TRUE, possible_drag_types, 1);
4295 frame = gtk_frame_new ("Drop");
4296 gtk_box_pack_start (GTK_BOX (box2), frame, TRUE, TRUE, 0);
4297 gtk_widget_show (frame);
4299 box3 = gtk_vbox_new (FALSE, 5);
4300 gtk_container_border_width (GTK_CONTAINER (box3), 5);
4301 gtk_container_add (GTK_CONTAINER (frame), box3);
4302 gtk_widget_show (box3);
4308 button = gtk_button_new_with_label ("To");
4309 gtk_box_pack_start (GTK_BOX (box3), button, FALSE, TRUE, 0);
4310 gtk_widget_show (button);
4312 gtk_widget_realize (button);
4313 gtk_signal_connect (GTK_OBJECT (button),
4314 "drop_data_available_event",
4315 GTK_SIGNAL_FUNC(dnd_drop),
4318 gtk_widget_dnd_drop_set (button, TRUE, accepted_drop_types, 1, FALSE);
4321 separator = gtk_hseparator_new ();
4322 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
4323 gtk_widget_show (separator);
4326 box2 = gtk_vbox_new (FALSE, 10);
4327 gtk_container_border_width (GTK_CONTAINER (box2), 10);
4328 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
4329 gtk_widget_show (box2);
4332 button = gtk_button_new_with_label ("close");
4334 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
4335 GTK_SIGNAL_FUNC(gtk_widget_destroy),
4336 GTK_OBJECT (window));
4338 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
4339 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
4340 gtk_widget_grab_default (button);
4341 gtk_widget_show (button);
4344 gtk_widget_hide(modeller); gtk_widget_hide(rings);
4346 if (!GTK_WIDGET_VISIBLE (window))
4347 gtk_widget_show (window);
4349 gtk_widget_destroy (window);
4355 static GdkWindow *root_win = NULL;
4357 typedef struct _cursoroffset {gint x,y;} CursorOffset;
4360 shape_pressed (GtkWidget *widget, GdkEventButton *event)
4364 /* ignore double and triple click */
4365 if (event->type != GDK_BUTTON_PRESS)
4368 p = gtk_object_get_user_data (GTK_OBJECT(widget));
4369 p->x = (int) event->x;
4370 p->y = (int) event->y;
4372 gtk_grab_add (widget);
4373 gdk_pointer_grab (widget->window, TRUE,
4374 GDK_BUTTON_RELEASE_MASK |
4375 GDK_BUTTON_MOTION_MASK |
4376 GDK_POINTER_MOTION_HINT_MASK,
4382 shape_released (GtkWidget *widget)
4384 gtk_grab_remove (widget);
4385 gdk_pointer_ungrab (0);
4389 shape_motion (GtkWidget *widget,
4390 GdkEventMotion *event)
4394 GdkModifierType mask;
4396 p = gtk_object_get_user_data (GTK_OBJECT (widget));
4399 * Can't use event->x / event->y here
4400 * because I need absolute coordinates.
4402 gdk_window_get_pointer (root_win, &xp, &yp, &mask);
4403 gtk_widget_set_uposition (widget, xp - p->x, yp - p->y);
4407 shape_create_icon (char *xpm_file,
4417 CursorOffset* icon_pos;
4419 GdkBitmap *gdk_pixmap_mask;
4420 GdkPixmap *gdk_pixmap;
4423 style = gtk_widget_get_default_style ();
4424 gc = style->black_gc;
4427 * GDK_WINDOW_TOPLEVEL works also, giving you a title border
4429 window = gtk_window_new (window_type);
4431 fixed = gtk_fixed_new ();
4432 gtk_widget_set_usize (fixed, 100,100);
4433 gtk_container_add (GTK_CONTAINER (window), fixed);
4434 gtk_widget_show (fixed);
4436 gtk_widget_set_events (window,
4437 gtk_widget_get_events (window) |
4438 GDK_BUTTON_MOTION_MASK |
4439 GDK_POINTER_MOTION_HINT_MASK |
4440 GDK_BUTTON_PRESS_MASK);
4442 gtk_widget_realize (window);
4443 gdk_pixmap = gdk_pixmap_create_from_xpm (window->window, &gdk_pixmap_mask,
4444 &style->bg[GTK_STATE_NORMAL],
4447 pixmap = gtk_pixmap_new (gdk_pixmap, gdk_pixmap_mask);
4448 gtk_fixed_put (GTK_FIXED (fixed), pixmap, px,py);
4449 gtk_widget_show (pixmap);
4451 gtk_widget_shape_combine_mask (window, gdk_pixmap_mask, px,py);
4454 gtk_signal_connect (GTK_OBJECT (window), "button_press_event",
4455 GTK_SIGNAL_FUNC (shape_pressed),NULL);
4456 gtk_signal_connect (GTK_OBJECT (window), "button_release_event",
4457 GTK_SIGNAL_FUNC (shape_released),NULL);
4458 gtk_signal_connect (GTK_OBJECT (window), "motion_notify_event",
4459 GTK_SIGNAL_FUNC (shape_motion),NULL);
4461 icon_pos = g_new (CursorOffset, 1);
4462 gtk_object_set_user_data(GTK_OBJECT(window), icon_pos);
4464 gtk_widget_set_uposition (window, x, y);
4465 gtk_widget_show (window);
4473 root_win = gdk_window_foreign_new (GDK_ROOT_WINDOW ());
4477 modeller = shape_create_icon ("Modeller.xpm",
4478 440, 140, 0,0, GTK_WINDOW_POPUP);
4480 gtk_signal_connect (GTK_OBJECT (modeller), "destroy",
4481 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
4485 gtk_widget_destroy (modeller);
4489 sheets = shape_create_icon ("FilesQueue.xpm",
4490 580, 170, 0,0, GTK_WINDOW_POPUP);
4492 gtk_signal_connect (GTK_OBJECT (sheets), "destroy",
4493 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
4498 gtk_widget_destroy (sheets);
4502 rings = shape_create_icon ("3DRings.xpm",
4503 460, 270, 25,25, GTK_WINDOW_TOPLEVEL);
4505 gtk_signal_connect (GTK_OBJECT (rings), "destroy",
4506 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
4510 gtk_widget_destroy (rings);
4516 static GtkWidget *window = NULL;
4518 GtkWidget *separator;
4527 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
4529 gtk_signal_connect (GTK_OBJECT (window), "destroy",
4530 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
4533 gtk_window_set_title (GTK_WINDOW (window), "WM Hints");
4534 gtk_container_border_width (GTK_CONTAINER (window), 0);
4536 gtk_widget_realize (window);
4538 circles = gdk_bitmap_create_from_data (window->window,
4542 gdk_window_set_icon (window->window, NULL,
4545 gdk_window_set_icon_name (window->window, "WMHints Test Icon");
4547 gdk_window_set_decorations (window->window, GDK_DECOR_ALL | GDK_DECOR_MENU);
4548 gdk_window_set_functions (window->window, GDK_FUNC_ALL | GDK_FUNC_RESIZE);
4550 box1 = gtk_vbox_new (FALSE, 0);
4551 gtk_container_add (GTK_CONTAINER (window), box1);
4552 gtk_widget_show (box1);
4554 label = gtk_label_new ("Try iconizing me!");
4555 gtk_widget_set_usize (label, 150, 50);
4556 gtk_box_pack_start (GTK_BOX (box1), label, TRUE, TRUE, 0);
4557 gtk_widget_show (label);
4560 separator = gtk_hseparator_new ();
4561 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
4562 gtk_widget_show (separator);
4565 box2 = gtk_vbox_new (FALSE, 10);
4566 gtk_container_border_width (GTK_CONTAINER (box2), 10);
4567 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
4568 gtk_widget_show (box2);
4571 button = gtk_button_new_with_label ("close");
4573 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
4574 GTK_SIGNAL_FUNC(gtk_widget_destroy),
4575 GTK_OBJECT (window));
4577 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
4578 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
4579 gtk_widget_grab_default (button);
4580 gtk_widget_show (button);
4583 if (!GTK_WIDGET_VISIBLE (window))
4584 gtk_widget_show (window);
4586 gtk_widget_destroy (window);
4592 static int progress_timer = 0;
4595 progress_timeout (gpointer data)
4599 new_val = GTK_PROGRESS_BAR (data)->percentage;
4604 gtk_progress_bar_update (GTK_PROGRESS_BAR (data), new_val);
4610 destroy_progress (GtkWidget *widget,
4613 gtk_timeout_remove (progress_timer);
4619 create_progress_bar ()
4621 static GtkWidget *window = NULL;
4629 window = gtk_dialog_new ();
4631 gtk_signal_connect (GTK_OBJECT (window), "destroy",
4632 GTK_SIGNAL_FUNC(destroy_progress),
4635 gtk_window_set_title (GTK_WINDOW (window), "dialog");
4636 gtk_container_border_width (GTK_CONTAINER (window), 0);
4639 vbox = gtk_vbox_new (FALSE, 5);
4640 gtk_container_border_width (GTK_CONTAINER (vbox), 10);
4641 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox),
4642 vbox, TRUE, TRUE, 0);
4643 gtk_widget_show (vbox);
4645 label = gtk_label_new ("progress...");
4646 gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
4647 gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, TRUE, 0);
4648 gtk_widget_show (label);
4650 pbar = gtk_progress_bar_new ();
4651 gtk_widget_set_usize (pbar, 200, 20);
4652 gtk_box_pack_start (GTK_BOX (vbox), pbar, TRUE, TRUE, 0);
4653 gtk_widget_show (pbar);
4655 progress_timer = gtk_timeout_add (100, progress_timeout, pbar);
4657 button = gtk_button_new_with_label ("close");
4658 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
4659 GTK_SIGNAL_FUNC(gtk_widget_destroy),
4660 GTK_OBJECT (window));
4661 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
4662 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
4663 button, TRUE, TRUE, 0);
4664 gtk_widget_grab_default (button);
4665 gtk_widget_show (button);
4668 if (!GTK_WIDGET_VISIBLE (window))
4669 gtk_widget_show (window);
4671 gtk_widget_destroy (window);
4678 static int color_idle = 0;
4681 color_idle_func (GtkWidget *preview)
4683 static int count = 1;
4687 for (i = 0; i < 256; i++)
4689 for (j = 0, k = 0; j < 256; j++)
4691 buf[k+0] = i + count;
4693 buf[k+2] = j + count;
4697 gtk_preview_draw_row (GTK_PREVIEW (preview), buf, 0, i, 256);
4702 gtk_widget_draw (preview, NULL);
4708 color_preview_destroy (GtkWidget *widget,
4711 gtk_idle_remove (color_idle);
4718 create_color_preview ()
4720 static GtkWidget *window = NULL;
4727 gtk_widget_push_visual (gtk_preview_get_visual ());
4728 gtk_widget_push_colormap (gtk_preview_get_cmap ());
4730 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
4732 gtk_signal_connect (GTK_OBJECT (window), "destroy",
4733 GTK_SIGNAL_FUNC(color_preview_destroy),
4736 gtk_window_set_title (GTK_WINDOW (window), "test");
4737 gtk_container_border_width (GTK_CONTAINER (window), 10);
4739 preview = gtk_preview_new (GTK_PREVIEW_COLOR);
4740 gtk_preview_size (GTK_PREVIEW (preview), 256, 256);
4741 gtk_container_add (GTK_CONTAINER (window), preview);
4742 gtk_widget_show (preview);
4744 for (i = 0; i < 256; i++)
4746 for (j = 0, k = 0; j < 256; j++)
4754 gtk_preview_draw_row (GTK_PREVIEW (preview), buf, 0, i, 256);
4757 color_idle = gtk_idle_add ((GtkFunction) color_idle_func, preview);
4759 gtk_widget_pop_colormap ();
4760 gtk_widget_pop_visual ();
4763 if (!GTK_WIDGET_VISIBLE (window))
4764 gtk_widget_show (window);
4766 gtk_widget_destroy (window);
4773 static int gray_idle = 0;
4776 gray_idle_func (GtkWidget *preview)
4778 static int count = 1;
4782 for (i = 0; i < 256; i++)
4784 for (j = 0; j < 256; j++)
4785 buf[j] = i + j + count;
4787 gtk_preview_draw_row (GTK_PREVIEW (preview), buf, 0, i, 256);
4792 gtk_widget_draw (preview, NULL);
4798 gray_preview_destroy (GtkWidget *widget,
4801 gtk_idle_remove (gray_idle);
4808 create_gray_preview ()
4810 static GtkWidget *window = NULL;
4817 gtk_widget_push_visual (gtk_preview_get_visual ());
4818 gtk_widget_push_colormap (gtk_preview_get_cmap ());
4820 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
4822 gtk_signal_connect (GTK_OBJECT (window), "destroy",
4823 GTK_SIGNAL_FUNC(gray_preview_destroy),
4826 gtk_window_set_title (GTK_WINDOW (window), "test");
4827 gtk_container_border_width (GTK_CONTAINER (window), 10);
4829 preview = gtk_preview_new (GTK_PREVIEW_GRAYSCALE);
4830 gtk_preview_size (GTK_PREVIEW (preview), 256, 256);
4831 gtk_container_add (GTK_CONTAINER (window), preview);
4832 gtk_widget_show (preview);
4834 for (i = 0; i < 256; i++)
4836 for (j = 0; j < 256; j++)
4839 gtk_preview_draw_row (GTK_PREVIEW (preview), buf, 0, i, 256);
4842 gray_idle = gtk_idle_add ((GtkFunction) gray_idle_func, preview);
4844 gtk_widget_pop_colormap ();
4845 gtk_widget_pop_visual ();
4848 if (!GTK_WIDGET_VISIBLE (window))
4849 gtk_widget_show (window);
4851 gtk_widget_destroy (window);
4859 selection_test_received (GtkWidget *list, GtkSelectionData *data)
4862 GtkWidget *list_item;
4866 if (data->length < 0)
4868 g_print ("Selection retrieval failed\n");
4871 if (data->type != GDK_SELECTION_TYPE_ATOM)
4873 g_print ("Selection \"TARGETS\" was not returned as atoms!\n");
4877 /* Clear out any current list items */
4879 gtk_list_clear_items (GTK_LIST(list), 0, -1);
4881 /* Add new items to list */
4883 atoms = (GdkAtom *)data->data;
4886 l = data->length / sizeof (GdkAtom);
4887 for (i = 0; i < l; i++)
4890 name = gdk_atom_name (atoms[i]);
4893 list_item = gtk_list_item_new_with_label (name);
4897 list_item = gtk_list_item_new_with_label ("(bad atom)");
4899 gtk_widget_show (list_item);
4900 item_list = g_list_append (item_list, list_item);
4903 gtk_list_append_items (GTK_LIST (list), item_list);
4909 selection_test_get_targets (GtkWidget *widget, GtkWidget *list)
4911 static GdkAtom targets_atom = GDK_NONE;
4913 if (targets_atom == GDK_NONE)
4914 targets_atom = gdk_atom_intern ("TARGETS", FALSE);
4916 gtk_selection_convert (list, GDK_SELECTION_PRIMARY, targets_atom,
4921 create_selection_test ()
4923 static GtkWidget *window = NULL;
4926 GtkWidget *scrolled_win;
4932 window = gtk_dialog_new ();
4934 gtk_signal_connect (GTK_OBJECT (window), "destroy",
4935 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
4938 gtk_window_set_title (GTK_WINDOW (window), "Selection Test");
4939 gtk_container_border_width (GTK_CONTAINER (window), 0);
4941 /* Create the list */
4943 vbox = gtk_vbox_new (FALSE, 5);
4944 gtk_container_border_width (GTK_CONTAINER (vbox), 10);
4945 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), vbox,
4947 gtk_widget_show (vbox);
4949 label = gtk_label_new ("Gets available targets for current selection");
4950 gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
4951 gtk_widget_show (label);
4953 scrolled_win = gtk_scrolled_window_new (NULL, NULL);
4954 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
4955 GTK_POLICY_AUTOMATIC,
4956 GTK_POLICY_AUTOMATIC);
4957 gtk_box_pack_start (GTK_BOX (vbox), scrolled_win, TRUE, TRUE, 0);
4958 gtk_widget_set_usize (scrolled_win, 100, 200);
4959 gtk_widget_show (scrolled_win);
4961 list = gtk_list_new ();
4962 gtk_container_add (GTK_CONTAINER (scrolled_win), list);
4964 gtk_signal_connect (GTK_OBJECT(list), "selection_received",
4965 GTK_SIGNAL_FUNC (selection_test_received), NULL);
4966 gtk_widget_show (list);
4968 /* .. And create some buttons */
4969 button = gtk_button_new_with_label ("Get Targets");
4970 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
4971 button, TRUE, TRUE, 0);
4973 gtk_signal_connect (GTK_OBJECT (button), "clicked",
4974 GTK_SIGNAL_FUNC (selection_test_get_targets), list);
4975 gtk_widget_show (button);
4977 button = gtk_button_new_with_label ("Quit");
4978 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
4979 button, TRUE, TRUE, 0);
4981 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
4982 GTK_SIGNAL_FUNC (gtk_widget_destroy),
4983 GTK_OBJECT (window));
4984 gtk_widget_show (button);
4987 if (!GTK_WIDGET_VISIBLE (window))
4988 gtk_widget_show (window);
4990 gtk_widget_destroy (window);
4998 create_gamma_curve ()
5000 static GtkWidget *window = NULL, *curve;
5001 static int count = 0;
5008 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
5009 gtk_window_set_title (GTK_WINDOW (window), "test");
5010 gtk_container_border_width (GTK_CONTAINER (window), 10);
5012 gtk_signal_connect (GTK_OBJECT (window), "destroy",
5013 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
5016 curve = gtk_gamma_curve_new ();
5017 gtk_container_add (GTK_CONTAINER (window), curve);
5018 gtk_widget_show (curve);
5021 max = 127 + (count % 2)*128;
5022 gtk_curve_set_range (GTK_CURVE (GTK_GAMMA_CURVE (curve)->curve),
5024 for (i = 0; i < max; ++i)
5025 vec[i] = (127 / sqrt (max)) * sqrt (i);
5026 gtk_curve_set_vector (GTK_CURVE (GTK_GAMMA_CURVE (curve)->curve),
5029 if (!GTK_WIDGET_VISIBLE (window))
5030 gtk_widget_show (window);
5031 else if (count % 4 == 3)
5033 gtk_widget_destroy (window);
5040 static int scroll_test_pos = 0.0;
5041 static GdkGC *scroll_test_gc = NULL;
5044 scroll_test_expose (GtkWidget *widget, GdkEventExpose *event,
5048 gint imin, imax, jmin, jmax;
5050 imin = (event->area.x) / 10;
5051 imax = (event->area.x + event->area.width + 9) / 10;
5053 jmin = ((int)adj->value + event->area.y) / 10;
5054 jmax = ((int)adj->value + event->area.y + event->area.height + 9) / 10;
5056 gdk_window_clear_area (widget->window,
5057 event->area.x, event->area.y,
5058 event->area.width, event->area.height);
5060 for (i=imin; i<imax; i++)
5061 for (j=jmin; j<jmax; j++)
5063 gdk_draw_rectangle (widget->window,
5064 widget->style->black_gc,
5066 10*i, 10*j - (int)adj->value, 1+i%10, 1+j%10);
5072 scroll_test_configure (GtkWidget *widget, GdkEventConfigure *event,
5075 adj->page_increment = 0.9 * widget->allocation.height;
5076 adj->page_size = widget->allocation.height;
5078 gtk_signal_emit_by_name (GTK_OBJECT (adj), "changed");
5082 scroll_test_adjustment_changed (GtkAdjustment *adj, GtkWidget *widget)
5084 gint source_min = (int)adj->value - scroll_test_pos;
5085 gint source_max = source_min + widget->allocation.height;
5087 gint dest_max = widget->allocation.height;
5091 scroll_test_pos = adj->value;
5093 if (!GTK_WIDGET_DRAWABLE (widget))
5100 rect.width = widget->allocation.width;
5101 rect.height = -source_min;
5102 if (rect.height > widget->allocation.height)
5103 rect.height = widget->allocation.height;
5106 dest_min = rect.height;
5111 rect.y = 2*widget->allocation.height - source_max;
5114 rect.width = widget->allocation.width;
5115 rect.height = widget->allocation.height - rect.y;
5117 source_max = widget->allocation.height;
5121 if (source_min != source_max)
5123 if (scroll_test_gc == NULL)
5125 scroll_test_gc = gdk_gc_new (widget->window);
5126 gdk_gc_set_exposures (scroll_test_gc, TRUE);
5129 gdk_draw_pixmap (widget->window,
5134 widget->allocation.width,
5135 source_max - source_min);
5137 /* Make sure graphics expose events are processed before scrolling
5140 while ((event = gdk_event_get_graphics_expose (widget->window)) != NULL)
5142 gtk_widget_event (widget, event);
5143 if (event->expose.count == 0)
5145 gdk_event_free (event);
5148 gdk_event_free (event);
5153 if (rect.height != 0)
5154 gtk_widget_draw (widget, &rect);
5159 create_scroll_test ()
5161 static GtkWidget *window = NULL;
5163 GtkWidget *drawing_area;
5164 GtkWidget *scrollbar;
5170 window = gtk_dialog_new ();
5172 gtk_signal_connect (GTK_OBJECT (window), "destroy",
5173 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
5176 gtk_window_set_title (GTK_WINDOW (window), "Scroll Test");
5177 gtk_container_border_width (GTK_CONTAINER (window), 0);
5179 hbox = gtk_hbox_new (FALSE, 0);
5180 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), hbox,
5182 gtk_widget_show (hbox);
5184 drawing_area = gtk_drawing_area_new ();
5185 gtk_drawing_area_size (GTK_DRAWING_AREA (drawing_area), 200, 200);
5186 gtk_box_pack_start (GTK_BOX (hbox), drawing_area, TRUE, TRUE, 0);
5187 gtk_widget_show (drawing_area);
5189 gtk_widget_set_events (drawing_area, GDK_EXPOSURE_MASK);
5191 adj = GTK_ADJUSTMENT (gtk_adjustment_new (0.0, 0.0, 1000.0, 1.0, 180.0, 200.0));
5192 scroll_test_pos = 0.0;
5194 scrollbar = gtk_vscrollbar_new (adj);
5195 gtk_box_pack_start (GTK_BOX (hbox), scrollbar, FALSE, FALSE, 0);
5196 gtk_widget_show (scrollbar);
5198 gtk_signal_connect (GTK_OBJECT (drawing_area), "expose_event",
5199 GTK_SIGNAL_FUNC (scroll_test_expose), adj);
5200 gtk_signal_connect (GTK_OBJECT (drawing_area), "configure_event",
5201 GTK_SIGNAL_FUNC (scroll_test_configure), adj);
5204 gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
5205 GTK_SIGNAL_FUNC (scroll_test_adjustment_changed),
5208 /* .. And create some buttons */
5210 button = gtk_button_new_with_label ("Quit");
5211 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
5212 button, TRUE, TRUE, 0);
5214 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
5215 GTK_SIGNAL_FUNC (gtk_widget_destroy),
5216 GTK_OBJECT (window));
5217 gtk_widget_show (button);
5220 if (!GTK_WIDGET_VISIBLE (window))
5221 gtk_widget_show (window);
5223 gtk_widget_destroy (window);
5229 static int timer = 0;
5232 timeout_test (GtkWidget *label)
5234 static int count = 0;
5235 static char buffer[32];
5237 sprintf (buffer, "count: %d", ++count);
5238 gtk_label_set (GTK_LABEL (label), buffer);
5242 start_timeout_test (GtkWidget *widget,
5247 timer = gtk_timeout_add (100, (GtkFunction) timeout_test, label);
5252 stop_timeout_test (GtkWidget *widget,
5257 gtk_timeout_remove (timer);
5263 destroy_timeout_test (GtkWidget *widget,
5266 stop_timeout_test (NULL, NULL);
5272 create_timeout_test ()
5274 static GtkWidget *window = NULL;
5280 window = gtk_dialog_new ();
5282 gtk_signal_connect (GTK_OBJECT (window), "destroy",
5283 GTK_SIGNAL_FUNC(destroy_timeout_test),
5286 gtk_window_set_title (GTK_WINDOW (window), "Timeout Test");
5287 gtk_container_border_width (GTK_CONTAINER (window), 0);
5289 label = gtk_label_new ("count: 0");
5290 gtk_misc_set_padding (GTK_MISC (label), 10, 10);
5291 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox),
5292 label, TRUE, TRUE, 0);
5293 gtk_widget_show (label);
5295 button = gtk_button_new_with_label ("close");
5296 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
5297 GTK_SIGNAL_FUNC(gtk_widget_destroy),
5298 GTK_OBJECT (window));
5299 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
5300 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
5301 button, TRUE, TRUE, 0);
5302 gtk_widget_grab_default (button);
5303 gtk_widget_show (button);
5305 button = gtk_button_new_with_label ("start");
5306 gtk_signal_connect (GTK_OBJECT (button), "clicked",
5307 GTK_SIGNAL_FUNC(start_timeout_test),
5309 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
5310 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
5311 button, TRUE, TRUE, 0);
5312 gtk_widget_show (button);
5314 button = gtk_button_new_with_label ("stop");
5315 gtk_signal_connect (GTK_OBJECT (button), "clicked",
5316 GTK_SIGNAL_FUNC(stop_timeout_test),
5318 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
5319 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
5320 button, TRUE, TRUE, 0);
5321 gtk_widget_show (button);
5324 if (!GTK_WIDGET_VISIBLE (window))
5325 gtk_widget_show (window);
5327 gtk_widget_destroy (window);
5334 static int idle = 0;
5337 idle_test (GtkWidget *label)
5339 static int count = 0;
5340 static char buffer[32];
5342 sprintf (buffer, "count: %d", ++count);
5343 gtk_label_set (GTK_LABEL (label), buffer);
5349 start_idle_test (GtkWidget *widget,
5354 idle = gtk_idle_add ((GtkFunction) idle_test, label);
5359 stop_idle_test (GtkWidget *widget,
5364 gtk_idle_remove (idle);
5370 destroy_idle_test (GtkWidget *widget,
5373 stop_idle_test (NULL, NULL);
5381 static GtkWidget *window = NULL;
5387 window = gtk_dialog_new ();
5389 gtk_signal_connect (GTK_OBJECT (window), "destroy",
5390 GTK_SIGNAL_FUNC(destroy_idle_test),
5393 gtk_window_set_title (GTK_WINDOW (window), "Idle Test");
5394 gtk_container_border_width (GTK_CONTAINER (window), 0);
5396 label = gtk_label_new ("count: 0");
5397 gtk_misc_set_padding (GTK_MISC (label), 10, 10);
5398 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox),
5399 label, TRUE, TRUE, 0);
5400 gtk_widget_show (label);
5402 button = gtk_button_new_with_label ("close");
5403 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
5404 GTK_SIGNAL_FUNC(gtk_widget_destroy),
5405 GTK_OBJECT (window));
5406 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
5407 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
5408 button, TRUE, TRUE, 0);
5409 gtk_widget_grab_default (button);
5410 gtk_widget_show (button);
5412 button = gtk_button_new_with_label ("start");
5413 gtk_signal_connect (GTK_OBJECT (button), "clicked",
5414 GTK_SIGNAL_FUNC(start_idle_test),
5416 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
5417 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
5418 button, TRUE, TRUE, 0);
5419 gtk_widget_show (button);
5421 button = gtk_button_new_with_label ("stop");
5422 gtk_signal_connect (GTK_OBJECT (button), "clicked",
5423 GTK_SIGNAL_FUNC(stop_idle_test),
5425 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
5426 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
5427 button, TRUE, TRUE, 0);
5428 gtk_widget_show (button);
5431 if (!GTK_WIDGET_VISIBLE (window))
5432 gtk_widget_show (window);
5434 gtk_widget_destroy (window);
5443 static GtkWidget *window = NULL;
5447 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
5449 gtk_signal_connect (GTK_OBJECT (window), "destroy",
5450 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
5454 gtk_window_set_title (GTK_WINDOW (window), "test");
5455 gtk_container_border_width (GTK_CONTAINER (window), 0);
5458 if (!GTK_WIDGET_VISIBLE (window))
5460 gtk_widget_show (window);
5462 g_print ("create_test: start\n");
5464 g_print ("create_test: done\n");
5467 gtk_widget_destroy (window);
5472 * Main Window and Exit
5475 do_exit (GtkWidget *widget, GtkWidget *window)
5477 gtk_widget_destroy (window);
5482 create_main_window ()
5489 { "buttons", create_buttons },
5490 { "toggle buttons", create_toggle_buttons },
5491 { "check buttons", create_check_buttons },
5492 { "radio buttons", create_radio_buttons },
5493 { "button box", create_button_box },
5494 { "toolbar", create_toolbar },
5495 { "handle box", create_handle_box },
5496 { "statusbar", create_statusbar },
5497 { "reparent", create_reparent },
5498 { "pixmap", create_pixmap },
5499 { "tooltips", create_tooltips },
5500 { "menus", create_menus },
5501 { "scrolled windows", create_scrolled_windows },
5502 { "cursors", create_cursors },
5503 { "entry", create_entry },
5504 { "spinbutton", create_spins },
5505 { "list", create_list },
5506 { "clist", create_clist},
5507 { "tree", create_tree_mode_window},
5508 { "color selection", create_color_selection },
5509 { "file selection", create_file_selection },
5510 { "dialog", create_dialog },
5511 { "miscellaneous", NULL },
5512 { "range controls", create_range_controls },
5513 { "rulers", create_rulers },
5514 { "text", create_text },
5515 { "notebook", create_notebook },
5516 { "panes", create_panes },
5517 { "shapes", create_shapes },
5518 { "dnd", create_dnd },
5519 { "WM hints", create_wmhints },
5520 { "progress bar", create_progress_bar },
5521 { "preview color", create_color_preview },
5522 { "preview gray", create_gray_preview },
5523 { "gamma curve", create_gamma_curve },
5524 { "test scrolling", create_scroll_test },
5525 { "test selection", create_selection_test },
5526 { "test timeout", create_timeout_test },
5527 { "test idle", create_idle_test },
5528 { "test", create_test },
5530 int nbuttons = sizeof (buttons) / sizeof (buttons[0]);
5534 GtkWidget *scrolled_window;
5538 GtkWidget *separator;
5541 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
5542 gtk_widget_set_name (window, "main window");
5543 gtk_widget_set_usize (window, 200, 400);
5544 gtk_widget_set_uposition (window, 20, 20);
5546 gtk_signal_connect (GTK_OBJECT (window), "destroy",
5547 GTK_SIGNAL_FUNC(gtk_main_quit),
5549 gtk_signal_connect (GTK_OBJECT (window), "delete_event",
5550 GTK_SIGNAL_FUNC (gtk_false),
5553 box1 = gtk_vbox_new (FALSE, 0);
5554 gtk_container_add (GTK_CONTAINER (window), box1);
5555 gtk_widget_show (box1);
5557 if (gtk_micro_version > 0)
5569 label = gtk_label_new (buffer);
5570 gtk_widget_show (label);
5571 gtk_box_pack_start (GTK_BOX (box1), label, FALSE, FALSE, 0);
5573 scrolled_window = gtk_scrolled_window_new (NULL, NULL);
5574 gtk_container_border_width (GTK_CONTAINER (scrolled_window), 10);
5575 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
5576 GTK_POLICY_AUTOMATIC,
5577 GTK_POLICY_AUTOMATIC);
5578 gtk_box_pack_start (GTK_BOX (box1), scrolled_window, TRUE, TRUE, 0);
5579 gtk_widget_show (scrolled_window);
5581 box2 = gtk_vbox_new (FALSE, 0);
5582 gtk_container_border_width (GTK_CONTAINER (box2), 10);
5583 gtk_container_add (GTK_CONTAINER (scrolled_window), box2);
5584 gtk_widget_show (box2);
5586 for (i = 0; i < nbuttons; i++)
5588 button = gtk_button_new_with_label (buttons[i].label);
5589 if (buttons[i].func)
5590 gtk_signal_connect (GTK_OBJECT (button),
5592 GTK_SIGNAL_FUNC(buttons[i].func),
5595 gtk_widget_set_sensitive (button, FALSE);
5596 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
5597 gtk_widget_show (button);
5600 separator = gtk_hseparator_new ();
5601 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
5602 gtk_widget_show (separator);
5604 box2 = gtk_vbox_new (FALSE, 10);
5605 gtk_container_border_width (GTK_CONTAINER (box2), 10);
5606 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
5607 gtk_widget_show (box2);
5609 button = gtk_button_new_with_label ("close");
5610 gtk_signal_connect (GTK_OBJECT (button), "clicked",
5611 GTK_SIGNAL_FUNC (do_exit),
5613 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
5614 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
5615 gtk_widget_grab_default (button);
5616 gtk_widget_show (button);
5618 gtk_widget_show (window);
5622 main (int argc, char *argv[])
5626 gtk_init (&argc, &argv);
5629 gle_init (&argc, &argv);
5630 #endif /* !HAVE_LIBGLE */
5632 gtk_rc_parse ("testgtkrc");
5634 create_main_window ();