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 Lesser 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 * Lesser General Public License for more details.
14 * You should have received a copy of the GNU Lesser General Public
15 * License along with this library; if not, write to the
16 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
17 * Boston, MA 02111-1307, USA.
21 * Modified by the GTK+ Team and others 1997-2000. See the AUTHORS
22 * file for a list of people on the GTK+ Team. See the ChangeLog
23 * files for a list of changes. These files are distributed with
24 * GTK+ at ftp://ftp.gtk.org/pub/gtk/.
41 #define GTK_ENABLE_BROKEN
44 #include "gdk/gdkkeysyms.h"
47 #define sleep(n) _sleep(n)
50 #include "circles.xbm"
53 typedef struct _OptionMenuItem
60 file_exists (const char *filename)
64 return stat (filename, &statbuf) == 0;
68 shape_create_icon (char *xpm_file,
76 build_option_menu (OptionMenuItem items[],
81 /* macro, structure and variables used by tree window demos */
82 #define DEFAULT_NUMBER_OF_ITEM 3
83 #define DEFAULT_RECURSION_LEVEL 3
86 GSList* selection_mode_group;
87 GtkWidget* single_button;
88 GtkWidget* browse_button;
89 GtkWidget* multiple_button;
90 GtkWidget* draw_line_button;
91 GtkWidget* view_line_button;
92 GtkWidget* no_root_item_button;
93 GtkWidget* nb_item_spinner;
94 GtkWidget* recursion_spinner;
95 } sTreeSampleSelection;
97 typedef struct sTreeButtons {
99 GtkWidget* add_button;
100 GtkWidget* remove_button;
101 GtkWidget* subtree_button;
103 /* end of tree section */
106 build_option_menu (OptionMenuItem items[],
113 GtkWidget *menu_item;
116 omenu = gtk_option_menu_new ();
118 menu = gtk_menu_new ();
120 for (i = 0; i < num_items; i++)
122 menu_item = gtk_menu_item_new_with_label (items[i].name);
123 gtk_signal_connect (GTK_OBJECT (menu_item), "activate",
124 (GtkSignalFunc) items[i].func, data);
125 gtk_menu_shell_append (GTK_MENU_SHELL (menu), menu_item);
126 gtk_widget_show (menu_item);
129 gtk_option_menu_set_menu (GTK_OPTION_MENU (omenu), menu);
130 gtk_option_menu_set_history (GTK_OPTION_MENU (omenu), history);
136 destroy_tooltips (GtkWidget *widget, GtkWindow **window)
138 GtkTooltips *tt = gtk_object_get_data (GTK_OBJECT (*window), "tooltips");
139 gtk_object_unref (GTK_OBJECT (tt));
148 button_window (GtkWidget *widget,
151 if (!GTK_WIDGET_VISIBLE (button))
152 gtk_widget_show (button);
154 gtk_widget_hide (button);
158 create_buttons (void)
160 static GtkWidget *window = NULL;
164 GtkWidget *button[10];
165 GtkWidget *separator;
169 GtkAccelGroup *accel_group;
171 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
173 accel_group = gtk_window_get_default_accel_group (GTK_WINDOW (window));
175 gtk_signal_connect (GTK_OBJECT (window), "destroy",
176 GTK_SIGNAL_FUNC (gtk_widget_destroyed),
179 gtk_window_set_title (GTK_WINDOW (window), "GtkButton");
180 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
182 box1 = gtk_vbox_new (FALSE, 0);
183 gtk_container_add (GTK_CONTAINER (window), box1);
185 table = gtk_table_new (3, 3, FALSE);
186 gtk_table_set_row_spacings (GTK_TABLE (table), 5);
187 gtk_table_set_col_spacings (GTK_TABLE (table), 5);
188 gtk_container_set_border_width (GTK_CONTAINER (table), 10);
189 gtk_box_pack_start (GTK_BOX (box1), table, TRUE, TRUE, 0);
191 button[0] = gtk_button_new_with_label ("button1");
192 button[1] = gtk_button_new_accel ("_button2", accel_group);
193 button[2] = gtk_button_new_with_label ("button3");
194 button[3] = gtk_button_new_stock (GTK_STOCK_BUTTON_OK, NULL);
195 button[4] = gtk_button_new_with_label ("button5");
196 button[5] = gtk_button_new_with_label ("button6");
197 button[6] = gtk_button_new_with_label ("button7");
198 button[7] = gtk_button_new_stock (GTK_STOCK_BUTTON_CLOSE, accel_group);
199 button[8] = gtk_button_new_with_label ("button9");
201 gtk_signal_connect (GTK_OBJECT (button[0]), "clicked",
202 GTK_SIGNAL_FUNC(button_window),
205 gtk_table_attach (GTK_TABLE (table), button[0], 0, 1, 0, 1,
206 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
208 gtk_signal_connect (GTK_OBJECT (button[1]), "clicked",
209 GTK_SIGNAL_FUNC(button_window),
212 gtk_table_attach (GTK_TABLE (table), button[1], 1, 2, 1, 2,
213 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
215 gtk_signal_connect (GTK_OBJECT (button[2]), "clicked",
216 GTK_SIGNAL_FUNC(button_window),
218 gtk_table_attach (GTK_TABLE (table), button[2], 2, 3, 2, 3,
219 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
221 gtk_signal_connect (GTK_OBJECT (button[3]), "clicked",
222 GTK_SIGNAL_FUNC(button_window),
224 gtk_table_attach (GTK_TABLE (table), button[3], 0, 1, 2, 3,
225 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
227 gtk_signal_connect (GTK_OBJECT (button[4]), "clicked",
228 GTK_SIGNAL_FUNC(button_window),
230 gtk_table_attach (GTK_TABLE (table), button[4], 2, 3, 0, 1,
231 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
233 gtk_signal_connect (GTK_OBJECT (button[5]), "clicked",
234 GTK_SIGNAL_FUNC(button_window),
236 gtk_table_attach (GTK_TABLE (table), button[5], 1, 2, 2, 3,
237 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
239 gtk_signal_connect (GTK_OBJECT (button[6]), "clicked",
240 GTK_SIGNAL_FUNC(button_window),
242 gtk_table_attach (GTK_TABLE (table), button[6], 1, 2, 0, 1,
243 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
245 gtk_signal_connect (GTK_OBJECT (button[7]), "clicked",
246 GTK_SIGNAL_FUNC(button_window),
248 gtk_table_attach (GTK_TABLE (table), button[7], 2, 3, 1, 2,
249 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
251 gtk_signal_connect (GTK_OBJECT (button[8]), "clicked",
252 GTK_SIGNAL_FUNC(button_window),
254 gtk_table_attach (GTK_TABLE (table), button[8], 0, 1, 1, 2,
255 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
257 separator = gtk_hseparator_new ();
258 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
260 box2 = gtk_vbox_new (FALSE, 10);
261 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
262 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
264 button[9] = gtk_button_new_with_label ("close");
265 gtk_signal_connect_object (GTK_OBJECT (button[9]), "clicked",
266 GTK_SIGNAL_FUNC(gtk_widget_destroy),
267 GTK_OBJECT (window));
268 gtk_box_pack_start (GTK_BOX (box2), button[9], TRUE, TRUE, 0);
269 GTK_WIDGET_SET_FLAGS (button[9], GTK_CAN_DEFAULT);
270 gtk_widget_grab_default (button[9]);
273 if (!GTK_WIDGET_VISIBLE (window))
274 gtk_widget_show_all (window);
276 gtk_widget_hide (window);
284 create_toggle_buttons (void)
286 static GtkWidget *window = NULL;
290 GtkWidget *separator;
294 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
296 gtk_signal_connect (GTK_OBJECT (window), "destroy",
297 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
300 gtk_window_set_title (GTK_WINDOW (window), "GtkToggleButton");
301 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
303 box1 = gtk_vbox_new (FALSE, 0);
304 gtk_container_add (GTK_CONTAINER (window), box1);
306 box2 = gtk_vbox_new (FALSE, 10);
307 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
308 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
310 button = gtk_toggle_button_new_with_label ("button1");
311 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
313 button = gtk_toggle_button_new_with_label ("button2");
314 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
316 button = gtk_toggle_button_new_with_label ("button3");
317 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
319 button = gtk_toggle_button_new_with_label ("inconsistent");
320 gtk_toggle_button_set_inconsistent (GTK_TOGGLE_BUTTON (button), TRUE);
321 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
323 separator = gtk_hseparator_new ();
324 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
326 box2 = gtk_vbox_new (FALSE, 10);
327 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
328 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
330 button = gtk_button_new_with_label ("close");
331 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
332 GTK_SIGNAL_FUNC(gtk_widget_destroy),
333 GTK_OBJECT (window));
334 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
335 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
336 gtk_widget_grab_default (button);
339 if (!GTK_WIDGET_VISIBLE (window))
340 gtk_widget_show_all (window);
342 gtk_widget_destroy (window);
350 create_check_buttons (void)
352 static GtkWidget *window = NULL;
356 GtkWidget *separator;
360 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
362 gtk_signal_connect (GTK_OBJECT (window), "destroy",
363 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
366 gtk_window_set_title (GTK_WINDOW (window), "GtkCheckButton");
367 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
369 box1 = gtk_vbox_new (FALSE, 0);
370 gtk_container_add (GTK_CONTAINER (window), box1);
372 box2 = gtk_vbox_new (FALSE, 10);
373 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
374 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
376 button = gtk_check_button_new_with_label ("button1");
377 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
379 button = gtk_check_button_new_with_label ("button2");
380 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
382 button = gtk_check_button_new_with_label ("button3");
383 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
385 button = gtk_check_button_new_with_label ("inconsistent");
386 gtk_toggle_button_set_inconsistent (GTK_TOGGLE_BUTTON (button), TRUE);
387 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
389 separator = gtk_hseparator_new ();
390 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
392 box2 = gtk_vbox_new (FALSE, 10);
393 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
394 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
396 button = gtk_button_new_with_label ("close");
397 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
398 GTK_SIGNAL_FUNC(gtk_widget_destroy),
399 GTK_OBJECT (window));
400 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
401 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
402 gtk_widget_grab_default (button);
405 if (!GTK_WIDGET_VISIBLE (window))
406 gtk_widget_show_all (window);
408 gtk_widget_destroy (window);
416 create_radio_buttons (void)
418 static GtkWidget *window = NULL;
422 GtkWidget *separator;
426 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
428 gtk_signal_connect (GTK_OBJECT (window), "destroy",
429 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
432 gtk_window_set_title (GTK_WINDOW (window), "radio buttons");
433 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
435 box1 = gtk_vbox_new (FALSE, 0);
436 gtk_container_add (GTK_CONTAINER (window), box1);
438 box2 = gtk_vbox_new (FALSE, 10);
439 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
440 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
442 button = gtk_radio_button_new_with_label (NULL, "button1");
443 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
445 button = gtk_radio_button_new_with_label (
446 gtk_radio_button_group (GTK_RADIO_BUTTON (button)),
448 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
449 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
451 button = gtk_radio_button_new_with_label (
452 gtk_radio_button_group (GTK_RADIO_BUTTON (button)),
454 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
456 button = gtk_radio_button_new_with_label (
457 gtk_radio_button_group (GTK_RADIO_BUTTON (button)),
459 gtk_toggle_button_set_inconsistent (GTK_TOGGLE_BUTTON (button), TRUE);
460 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
462 separator = gtk_hseparator_new ();
463 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
465 box2 = gtk_vbox_new (FALSE, 10);
466 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
467 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
469 button = gtk_button_new_with_label ("close");
470 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
471 GTK_SIGNAL_FUNC(gtk_widget_destroy),
472 GTK_OBJECT (window));
473 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
474 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
475 gtk_widget_grab_default (button);
478 if (!GTK_WIDGET_VISIBLE (window))
479 gtk_widget_show_all (window);
481 gtk_widget_destroy (window);
489 create_bbox (gint horizontal,
500 frame = gtk_frame_new (title);
503 bbox = gtk_hbutton_box_new ();
505 bbox = gtk_vbutton_box_new ();
507 gtk_container_set_border_width (GTK_CONTAINER (bbox), 5);
508 gtk_container_add (GTK_CONTAINER (frame), bbox);
510 gtk_button_box_set_layout (GTK_BUTTON_BOX (bbox), layout);
511 gtk_button_box_set_spacing (GTK_BUTTON_BOX (bbox), spacing);
512 gtk_button_box_set_child_size (GTK_BUTTON_BOX (bbox), child_w, child_h);
514 button = gtk_button_new_with_label ("OK");
515 gtk_container_add (GTK_CONTAINER (bbox), button);
517 button = gtk_button_new_with_label ("Cancel");
518 gtk_container_add (GTK_CONTAINER (bbox), button);
520 button = gtk_button_new_with_label ("Help");
521 gtk_container_add (GTK_CONTAINER (bbox), button);
527 create_button_box (void)
529 static GtkWidget* window = NULL;
530 GtkWidget *main_vbox;
533 GtkWidget *frame_horz;
534 GtkWidget *frame_vert;
538 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
539 gtk_window_set_title (GTK_WINDOW (window), "Button Boxes");
541 gtk_signal_connect (GTK_OBJECT (window), "destroy",
542 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
545 gtk_container_set_border_width (GTK_CONTAINER (window), 10);
547 main_vbox = gtk_vbox_new (FALSE, 0);
548 gtk_container_add (GTK_CONTAINER (window), main_vbox);
550 frame_horz = gtk_frame_new ("Horizontal Button Boxes");
551 gtk_box_pack_start (GTK_BOX (main_vbox), frame_horz, TRUE, TRUE, 10);
553 vbox = gtk_vbox_new (FALSE, 0);
554 gtk_container_set_border_width (GTK_CONTAINER (vbox), 10);
555 gtk_container_add (GTK_CONTAINER (frame_horz), vbox);
557 gtk_box_pack_start (GTK_BOX (vbox),
558 create_bbox (TRUE, "Spread", 40, 85, 20, GTK_BUTTONBOX_SPREAD),
561 gtk_box_pack_start (GTK_BOX (vbox),
562 create_bbox (TRUE, "Edge", 40, 85, 20, GTK_BUTTONBOX_EDGE),
565 gtk_box_pack_start (GTK_BOX (vbox),
566 create_bbox (TRUE, "Start", 40, 85, 20, GTK_BUTTONBOX_START),
569 gtk_box_pack_start (GTK_BOX (vbox),
570 create_bbox (TRUE, "End", 40, 85, 20, GTK_BUTTONBOX_END),
573 frame_vert = gtk_frame_new ("Vertical Button Boxes");
574 gtk_box_pack_start (GTK_BOX (main_vbox), frame_vert, TRUE, TRUE, 10);
576 hbox = gtk_hbox_new (FALSE, 0);
577 gtk_container_set_border_width (GTK_CONTAINER (hbox), 10);
578 gtk_container_add (GTK_CONTAINER (frame_vert), hbox);
580 gtk_box_pack_start (GTK_BOX (hbox),
581 create_bbox (FALSE, "Spread", 30, 85, 20, GTK_BUTTONBOX_SPREAD),
584 gtk_box_pack_start (GTK_BOX (hbox),
585 create_bbox (FALSE, "Edge", 30, 85, 20, GTK_BUTTONBOX_EDGE),
588 gtk_box_pack_start (GTK_BOX (hbox),
589 create_bbox (FALSE, "Start", 30, 85, 20, GTK_BUTTONBOX_START),
592 gtk_box_pack_start (GTK_BOX (hbox),
593 create_bbox (FALSE, "End", 30, 85, 20, GTK_BUTTONBOX_END),
597 if (!GTK_WIDGET_VISIBLE (window))
598 gtk_widget_show_all (window);
600 gtk_widget_destroy (window);
608 new_pixmap (char *filename,
610 GdkColor *background)
616 if (strcmp (filename, "test.xpm") == 0 ||
617 !file_exists (filename))
619 pixmap = gdk_pixmap_create_from_xpm_d (window, &mask,
624 pixmap = gdk_pixmap_create_from_xpm (window, &mask,
628 wpixmap = gtk_pixmap_new (pixmap, mask);
634 set_toolbar_horizontal (GtkWidget *widget,
637 gtk_toolbar_set_orientation (GTK_TOOLBAR (data), GTK_ORIENTATION_HORIZONTAL);
641 set_toolbar_vertical (GtkWidget *widget,
644 gtk_toolbar_set_orientation (GTK_TOOLBAR (data), GTK_ORIENTATION_VERTICAL);
648 set_toolbar_icons (GtkWidget *widget,
651 gtk_toolbar_set_style (GTK_TOOLBAR (data), GTK_TOOLBAR_ICONS);
655 set_toolbar_text (GtkWidget *widget,
658 gtk_toolbar_set_style (GTK_TOOLBAR (data), GTK_TOOLBAR_TEXT);
662 set_toolbar_both (GtkWidget *widget,
665 gtk_toolbar_set_style (GTK_TOOLBAR (data), GTK_TOOLBAR_BOTH);
669 set_toolbar_both_horiz (GtkWidget *widget,
672 gtk_toolbar_set_style (GTK_TOOLBAR (data), GTK_TOOLBAR_BOTH_HORIZ);
676 set_toolbar_small_space (GtkWidget *widget,
679 gtk_toolbar_set_space_size (GTK_TOOLBAR (data), 5);
683 set_toolbar_big_space (GtkWidget *widget,
686 gtk_toolbar_set_space_size (GTK_TOOLBAR (data), 10);
690 set_toolbar_enable (GtkWidget *widget,
693 gtk_toolbar_set_tooltips (GTK_TOOLBAR (data), TRUE);
697 set_toolbar_disable (GtkWidget *widget,
700 gtk_toolbar_set_tooltips (GTK_TOOLBAR (data), FALSE);
704 set_toolbar_borders (GtkWidget *widget,
707 gtk_toolbar_set_button_relief (GTK_TOOLBAR (data), GTK_RELIEF_NORMAL);
711 set_toolbar_borderless (GtkWidget *widget,
714 gtk_toolbar_set_button_relief (GTK_TOOLBAR (data), GTK_RELIEF_NONE);
718 set_toolbar_space_style_empty (GtkWidget *widget,
721 gtk_toolbar_set_space_style (GTK_TOOLBAR (data), GTK_TOOLBAR_SPACE_EMPTY);
725 set_toolbar_space_style_line (GtkWidget *widget,
728 gtk_toolbar_set_space_style (GTK_TOOLBAR (data), GTK_TOOLBAR_SPACE_LINE);
732 create_toolbar (void)
734 static GtkWidget *window = NULL;
740 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
741 gtk_window_set_title (GTK_WINDOW (window), "Toolbar test");
742 gtk_window_set_policy (GTK_WINDOW (window), FALSE, TRUE, TRUE);
744 gtk_signal_connect (GTK_OBJECT (window), "destroy",
745 GTK_SIGNAL_FUNC (gtk_widget_destroyed),
748 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
749 gtk_widget_realize (window);
751 toolbar = gtk_toolbar_new (GTK_ORIENTATION_HORIZONTAL, GTK_TOOLBAR_BOTH);
752 gtk_toolbar_set_button_relief (GTK_TOOLBAR (toolbar), GTK_RELIEF_NONE);
754 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
755 "Horizontal", "Horizontal toolbar layout", "Toolbar/Horizontal",
756 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
757 (GtkSignalFunc) set_toolbar_horizontal, toolbar);
758 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
759 "Vertical", "Vertical toolbar layout", "Toolbar/Vertical",
760 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
761 (GtkSignalFunc) set_toolbar_vertical, toolbar);
763 gtk_toolbar_append_space (GTK_TOOLBAR(toolbar));
765 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
766 "Icons", "Only show toolbar icons", "Toolbar/IconsOnly",
767 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
768 (GtkSignalFunc) set_toolbar_icons, toolbar);
769 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
770 "Text", "Only show toolbar text", "Toolbar/TextOnly",
771 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
772 (GtkSignalFunc) set_toolbar_text, toolbar);
773 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
774 "Both", "Show toolbar icons and text", "Toolbar/Both",
775 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
776 (GtkSignalFunc) set_toolbar_both, toolbar);
777 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
779 "Show toolbar icons and text in a horizontal fashion",
781 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
782 (GtkSignalFunc) set_toolbar_both_horiz, toolbar);
784 gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
786 entry = gtk_entry_new ();
788 gtk_toolbar_append_widget (GTK_TOOLBAR (toolbar), entry, "This is an unusable GtkEntry ;)", "Hey don't click me!!!");
790 gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
792 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
793 "Small", "Use small spaces", "Toolbar/Small",
794 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
795 (GtkSignalFunc) set_toolbar_small_space, toolbar);
796 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
797 "Big", "Use big spaces", "Toolbar/Big",
798 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
799 (GtkSignalFunc) set_toolbar_big_space, toolbar);
801 gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
803 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
804 "Enable", "Enable tooltips", NULL,
805 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
806 (GtkSignalFunc) set_toolbar_enable, toolbar);
807 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
808 "Disable", "Disable tooltips", NULL,
809 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
810 (GtkSignalFunc) set_toolbar_disable, toolbar);
812 gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
814 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
815 "Borders", "Show Borders", NULL,
816 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
817 (GtkSignalFunc) set_toolbar_borders, toolbar);
818 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
819 "Borderless", "Hide Borders", NULL,
820 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
821 (GtkSignalFunc) set_toolbar_borderless, toolbar);
823 gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
825 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
826 "Empty", "Empty spaces", NULL,
827 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
828 (GtkSignalFunc) set_toolbar_space_style_empty, toolbar);
829 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
830 "Lines", "Lines in spaces", NULL,
831 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
832 (GtkSignalFunc) set_toolbar_space_style_line, toolbar);
834 gtk_container_add (GTK_CONTAINER (window), toolbar);
837 if (!GTK_WIDGET_VISIBLE (window))
838 gtk_widget_show_all (window);
840 gtk_widget_destroy (window);
844 make_toolbar (GtkWidget *window)
848 if (!GTK_WIDGET_REALIZED (window))
849 gtk_widget_realize (window);
851 toolbar = gtk_toolbar_new (GTK_ORIENTATION_HORIZONTAL, GTK_TOOLBAR_BOTH);
852 gtk_toolbar_set_button_relief (GTK_TOOLBAR (toolbar), GTK_RELIEF_NONE);
854 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
855 "Horizontal", "Horizontal toolbar layout", NULL,
856 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
857 (GtkSignalFunc) set_toolbar_horizontal, toolbar);
858 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
859 "Vertical", "Vertical toolbar layout", NULL,
860 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
861 (GtkSignalFunc) set_toolbar_vertical, toolbar);
863 gtk_toolbar_append_space (GTK_TOOLBAR(toolbar));
865 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
866 "Icons", "Only show toolbar icons", NULL,
867 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
868 (GtkSignalFunc) set_toolbar_icons, toolbar);
869 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
870 "Text", "Only show toolbar text", NULL,
871 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
872 (GtkSignalFunc) set_toolbar_text, toolbar);
873 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
874 "Both", "Show toolbar icons and text", NULL,
875 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
876 (GtkSignalFunc) set_toolbar_both, toolbar);
878 gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
880 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
881 "Small", "Use small spaces", NULL,
882 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
883 (GtkSignalFunc) set_toolbar_small_space, toolbar);
884 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
885 "Big", "Use big spaces", "Toolbar/Big",
886 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
887 (GtkSignalFunc) set_toolbar_big_space, toolbar);
889 gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
891 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
892 "Enable", "Enable tooltips", NULL,
893 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
894 (GtkSignalFunc) set_toolbar_enable, toolbar);
895 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
896 "Disable", "Disable tooltips", NULL,
897 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
898 (GtkSignalFunc) set_toolbar_disable, toolbar);
900 gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
902 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
903 "Borders", "Show Borders", NULL,
904 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
905 (GtkSignalFunc) set_toolbar_borders, toolbar);
906 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
907 "Borderless", "Hide Borders", NULL,
908 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
909 (GtkSignalFunc) set_toolbar_borderless, toolbar);
918 static guint statusbar_counter = 1;
921 statusbar_push (GtkWidget *button,
922 GtkStatusbar *statusbar)
926 sprintf (text, "something %d", statusbar_counter++);
928 gtk_statusbar_push (statusbar, 1, text);
932 statusbar_pop (GtkWidget *button,
933 GtkStatusbar *statusbar)
935 gtk_statusbar_pop (statusbar, 1);
939 statusbar_steal (GtkWidget *button,
940 GtkStatusbar *statusbar)
942 gtk_statusbar_remove (statusbar, 1, 4);
946 statusbar_popped (GtkStatusbar *statusbar,
950 if (!statusbar->messages)
951 statusbar_counter = 1;
955 statusbar_contexts (GtkStatusbar *statusbar)
959 string = "any context";
960 g_print ("GtkStatusBar: context=\"%s\", context_id=%d\n",
962 gtk_statusbar_get_context_id (statusbar, string));
964 string = "idle messages";
965 g_print ("GtkStatusBar: context=\"%s\", context_id=%d\n",
967 gtk_statusbar_get_context_id (statusbar, string));
969 string = "some text";
970 g_print ("GtkStatusBar: context=\"%s\", context_id=%d\n",
972 gtk_statusbar_get_context_id (statusbar, string));
974 string = "hit the mouse";
975 g_print ("GtkStatusBar: context=\"%s\", context_id=%d\n",
977 gtk_statusbar_get_context_id (statusbar, string));
979 string = "hit the mouse2";
980 g_print ("GtkStatusBar: context=\"%s\", context_id=%d\n",
982 gtk_statusbar_get_context_id (statusbar, string));
986 create_statusbar (void)
988 static GtkWidget *window = NULL;
992 GtkWidget *separator;
993 GtkWidget *statusbar;
997 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
999 gtk_signal_connect (GTK_OBJECT (window), "destroy",
1000 GTK_SIGNAL_FUNC (gtk_widget_destroyed),
1003 gtk_window_set_title (GTK_WINDOW (window), "statusbar");
1004 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
1006 box1 = gtk_vbox_new (FALSE, 0);
1007 gtk_container_add (GTK_CONTAINER (window), box1);
1009 box2 = gtk_vbox_new (FALSE, 10);
1010 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
1011 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
1013 statusbar = gtk_statusbar_new ();
1014 gtk_box_pack_end (GTK_BOX (box1), statusbar, TRUE, TRUE, 0);
1015 gtk_signal_connect (GTK_OBJECT (statusbar),
1017 GTK_SIGNAL_FUNC (statusbar_popped),
1020 button = gtk_widget_new (gtk_button_get_type (),
1021 "label", "push something",
1025 g_object_set (G_OBJECT (button),
1026 "signal::clicked", statusbar_push, statusbar,
1029 button = gtk_widget_new (gtk_button_get_type (),
1034 g_object_set (G_OBJECT (button),
1035 "signal_after::clicked", statusbar_pop, statusbar,
1038 button = gtk_widget_new (gtk_button_get_type (),
1039 "label", "steal #4",
1043 g_object_set (G_OBJECT (button),
1044 "signal_after::clicked", statusbar_steal, statusbar,
1047 button = gtk_widget_new (gtk_button_get_type (),
1048 "label", "test contexts",
1052 g_object_set (G_OBJECT (button),
1053 "swapped_signal_after::clicked", statusbar_contexts, statusbar,
1056 separator = gtk_hseparator_new ();
1057 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
1059 box2 = gtk_vbox_new (FALSE, 10);
1060 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
1061 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
1063 button = gtk_button_new_with_label ("close");
1064 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
1065 GTK_SIGNAL_FUNC(gtk_widget_destroy),
1066 GTK_OBJECT (window));
1067 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
1068 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
1069 gtk_widget_grab_default (button);
1072 if (!GTK_WIDGET_VISIBLE (window))
1073 gtk_widget_show_all (window);
1075 gtk_widget_destroy (window);
1083 cb_tree_destroy_event(GtkWidget* w)
1085 sTreeButtons* tree_buttons;
1087 /* free buttons structure associate at this tree */
1088 tree_buttons = gtk_object_get_user_data (GTK_OBJECT (w));
1089 g_free (tree_buttons);
1093 cb_add_new_item(GtkWidget* w, GtkTree* tree)
1095 sTreeButtons* tree_buttons;
1096 GList* selected_list;
1097 GtkWidget* selected_item;
1099 GtkWidget* item_new;
1102 tree_buttons = gtk_object_get_user_data(GTK_OBJECT(tree));
1104 selected_list = GTK_TREE_SELECTION_OLD(tree);
1106 if(selected_list == NULL)
1108 /* there is no item in tree */
1109 subtree = GTK_WIDGET(tree);
1113 /* list can have only one element */
1114 selected_item = GTK_WIDGET(selected_list->data);
1116 subtree = GTK_TREE_ITEM_SUBTREE(selected_item);
1120 /* current selected item have not subtree ... create it */
1121 subtree = gtk_tree_new();
1122 gtk_tree_item_set_subtree(GTK_TREE_ITEM(selected_item),
1127 /* at this point, we know which subtree will be used to add new item */
1128 /* create a new item */
1129 sprintf(buffer, "item add %d", tree_buttons->nb_item_add);
1130 item_new = gtk_tree_item_new_with_label(buffer);
1131 gtk_tree_append(GTK_TREE(subtree), item_new);
1132 gtk_widget_show(item_new);
1134 tree_buttons->nb_item_add++;
1138 cb_remove_item(GtkWidget*w, GtkTree* tree)
1140 GList* selected_list;
1143 selected_list = GTK_TREE_SELECTION_OLD(tree);
1147 while (selected_list)
1149 clear_list = g_list_prepend (clear_list, selected_list->data);
1150 selected_list = selected_list->next;
1153 clear_list = g_list_reverse (clear_list);
1154 gtk_tree_remove_items(tree, clear_list);
1156 g_list_free (clear_list);
1160 cb_remove_subtree(GtkWidget*w, GtkTree* tree)
1162 GList* selected_list;
1165 selected_list = GTK_TREE_SELECTION_OLD(tree);
1169 item = GTK_TREE_ITEM (selected_list->data);
1171 gtk_tree_item_remove_subtree (item);
1176 cb_tree_changed(GtkTree* tree)
1178 sTreeButtons* tree_buttons;
1179 GList* selected_list;
1182 tree_buttons = gtk_object_get_user_data(GTK_OBJECT(tree));
1184 selected_list = GTK_TREE_SELECTION_OLD(tree);
1185 nb_selected = g_list_length(selected_list);
1187 if(nb_selected == 0)
1189 if(tree->children == NULL)
1190 gtk_widget_set_sensitive(tree_buttons->add_button, TRUE);
1192 gtk_widget_set_sensitive(tree_buttons->add_button, FALSE);
1193 gtk_widget_set_sensitive(tree_buttons->remove_button, FALSE);
1194 gtk_widget_set_sensitive(tree_buttons->subtree_button, FALSE);
1198 gtk_widget_set_sensitive(tree_buttons->remove_button, TRUE);
1199 gtk_widget_set_sensitive(tree_buttons->add_button, (nb_selected == 1));
1200 gtk_widget_set_sensitive(tree_buttons->subtree_button, (nb_selected == 1));
1205 create_subtree(GtkWidget* item, guint level, guint nb_item_max, guint recursion_level_max)
1207 GtkWidget* item_subtree;
1208 GtkWidget* item_new;
1213 if(level == recursion_level_max) return;
1217 /* query with no root item */
1219 item_subtree = item;
1224 /* query with no root item */
1225 /* create subtree and associate it with current item */
1226 item_subtree = gtk_tree_new();
1230 for(nb_item = 0; nb_item < nb_item_max; nb_item++)
1232 sprintf(buffer, "item %d-%d", level, nb_item);
1233 item_new = gtk_tree_item_new_with_label(buffer);
1234 gtk_tree_append(GTK_TREE(item_subtree), item_new);
1235 create_subtree(item_new, level+1, nb_item_max, recursion_level_max);
1236 gtk_widget_show(item_new);
1240 gtk_tree_item_set_subtree(GTK_TREE_ITEM(item), item_subtree);
1244 create_tree_sample(guint selection_mode,
1245 guint draw_line, guint view_line, guint no_root_item,
1246 guint nb_item_max, guint recursion_level_max)
1251 GtkWidget* separator;
1253 GtkWidget* scrolled_win;
1254 GtkWidget* root_tree;
1255 GtkWidget* root_item;
1256 sTreeButtons* tree_buttons;
1258 /* create tree buttons struct */
1259 if ((tree_buttons = g_malloc (sizeof (sTreeButtons))) == NULL)
1261 g_error("can't allocate memory for tree structure !\n");
1264 tree_buttons->nb_item_add = 0;
1266 /* create top level window */
1267 window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
1268 gtk_window_set_title(GTK_WINDOW(window), "Tree Sample");
1269 gtk_signal_connect(GTK_OBJECT(window), "destroy",
1270 (GtkSignalFunc) cb_tree_destroy_event, NULL);
1271 gtk_object_set_user_data(GTK_OBJECT(window), tree_buttons);
1273 box1 = gtk_vbox_new(FALSE, 0);
1274 gtk_container_add(GTK_CONTAINER(window), box1);
1275 gtk_widget_show(box1);
1277 /* create tree box */
1278 box2 = gtk_vbox_new(FALSE, 0);
1279 gtk_box_pack_start(GTK_BOX(box1), box2, TRUE, TRUE, 0);
1280 gtk_container_set_border_width(GTK_CONTAINER(box2), 5);
1281 gtk_widget_show(box2);
1283 /* create scrolled window */
1284 scrolled_win = gtk_scrolled_window_new (NULL, NULL);
1285 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
1286 GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
1287 gtk_box_pack_start (GTK_BOX (box2), scrolled_win, TRUE, TRUE, 0);
1288 gtk_widget_set_usize (scrolled_win, 200, 200);
1289 gtk_widget_show (scrolled_win);
1291 /* create root tree widget */
1292 root_tree = gtk_tree_new();
1293 gtk_signal_connect(GTK_OBJECT(root_tree), "selection_changed",
1294 (GtkSignalFunc)cb_tree_changed,
1296 gtk_object_set_user_data(GTK_OBJECT(root_tree), tree_buttons);
1297 gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (scrolled_win), root_tree);
1298 gtk_tree_set_selection_mode(GTK_TREE(root_tree), selection_mode);
1299 gtk_tree_set_view_lines(GTK_TREE(root_tree), draw_line);
1300 gtk_tree_set_view_mode(GTK_TREE(root_tree), !view_line);
1301 gtk_widget_show(root_tree);
1305 /* set root tree to subtree function with root item variable */
1306 root_item = GTK_WIDGET(root_tree);
1310 /* create root tree item widget */
1311 root_item = gtk_tree_item_new_with_label("root item");
1312 gtk_tree_append(GTK_TREE(root_tree), root_item);
1313 gtk_widget_show(root_item);
1315 create_subtree(root_item, -no_root_item, nb_item_max, recursion_level_max);
1317 box2 = gtk_vbox_new(FALSE, 0);
1318 gtk_box_pack_start(GTK_BOX(box1), box2, FALSE, FALSE, 0);
1319 gtk_container_set_border_width(GTK_CONTAINER(box2), 5);
1320 gtk_widget_show(box2);
1322 button = gtk_button_new_with_label("Add Item");
1323 gtk_widget_set_sensitive(button, FALSE);
1324 gtk_signal_connect(GTK_OBJECT (button), "clicked",
1325 (GtkSignalFunc) cb_add_new_item,
1326 (gpointer)root_tree);
1327 gtk_box_pack_start(GTK_BOX(box2), button, TRUE, TRUE, 0);
1328 gtk_widget_show(button);
1329 tree_buttons->add_button = button;
1331 button = gtk_button_new_with_label("Remove Item(s)");
1332 gtk_widget_set_sensitive(button, FALSE);
1333 gtk_signal_connect(GTK_OBJECT (button), "clicked",
1334 (GtkSignalFunc) cb_remove_item,
1335 (gpointer)root_tree);
1336 gtk_box_pack_start(GTK_BOX(box2), button, TRUE, TRUE, 0);
1337 gtk_widget_show(button);
1338 tree_buttons->remove_button = button;
1340 button = gtk_button_new_with_label("Remove Subtree");
1341 gtk_widget_set_sensitive(button, FALSE);
1342 gtk_signal_connect(GTK_OBJECT (button), "clicked",
1343 (GtkSignalFunc) cb_remove_subtree,
1344 (gpointer)root_tree);
1345 gtk_box_pack_start(GTK_BOX(box2), button, TRUE, TRUE, 0);
1346 gtk_widget_show(button);
1347 tree_buttons->subtree_button = button;
1349 /* create separator */
1350 separator = gtk_hseparator_new();
1351 gtk_box_pack_start(GTK_BOX(box1), separator, FALSE, FALSE, 0);
1352 gtk_widget_show(separator);
1354 /* create button box */
1355 box2 = gtk_vbox_new(FALSE, 0);
1356 gtk_box_pack_start(GTK_BOX(box1), box2, FALSE, FALSE, 0);
1357 gtk_container_set_border_width(GTK_CONTAINER(box2), 5);
1358 gtk_widget_show(box2);
1360 button = gtk_button_new_with_label("Close");
1361 gtk_box_pack_start(GTK_BOX(box2), button, TRUE, TRUE, 0);
1362 gtk_signal_connect_object(GTK_OBJECT (button), "clicked",
1363 (GtkSignalFunc) gtk_widget_destroy,
1364 GTK_OBJECT(window));
1365 gtk_widget_show(button);
1367 gtk_widget_show(window);
1371 cb_create_tree(GtkWidget* w)
1373 guint selection_mode = GTK_SELECTION_SINGLE;
1378 guint recursion_level;
1380 /* get selection mode choice */
1381 if(GTK_TOGGLE_BUTTON(sTreeSampleSelection.single_button)->active)
1382 selection_mode = GTK_SELECTION_SINGLE;
1384 if(GTK_TOGGLE_BUTTON(sTreeSampleSelection.browse_button)->active)
1385 selection_mode = GTK_SELECTION_BROWSE;
1387 selection_mode = GTK_SELECTION_MULTIPLE;
1389 /* get options choice */
1390 draw_line = GTK_TOGGLE_BUTTON(sTreeSampleSelection.draw_line_button)->active;
1391 view_line = GTK_TOGGLE_BUTTON(sTreeSampleSelection.view_line_button)->active;
1392 no_root_item = GTK_TOGGLE_BUTTON(sTreeSampleSelection.no_root_item_button)->active;
1395 nb_item = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(sTreeSampleSelection.nb_item_spinner));
1396 recursion_level = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(sTreeSampleSelection.recursion_spinner));
1398 if (pow (nb_item, recursion_level) > 10000)
1400 g_print ("%g total items? That will take a very long time. Try less\n",
1401 pow (nb_item, recursion_level));
1405 create_tree_sample(selection_mode, draw_line, view_line, no_root_item, nb_item, recursion_level);
1409 create_tree_mode_window(void)
1411 static GtkWidget* window;
1419 GtkWidget* separator;
1426 /* create toplevel window */
1427 window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
1428 gtk_window_set_title(GTK_WINDOW(window), "Set Tree Parameters");
1429 gtk_signal_connect (GTK_OBJECT (window), "destroy",
1430 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
1432 box1 = gtk_vbox_new(FALSE, 0);
1433 gtk_container_add(GTK_CONTAINER(window), box1);
1435 /* create upper box - selection box */
1436 box2 = gtk_vbox_new(FALSE, 5);
1437 gtk_box_pack_start(GTK_BOX(box1), box2, TRUE, TRUE, 0);
1438 gtk_container_set_border_width(GTK_CONTAINER(box2), 5);
1440 box3 = gtk_hbox_new(FALSE, 5);
1441 gtk_box_pack_start(GTK_BOX(box2), box3, TRUE, TRUE, 0);
1443 /* create selection mode frame */
1444 frame = gtk_frame_new("Selection Mode");
1445 gtk_box_pack_start(GTK_BOX(box3), frame, TRUE, TRUE, 0);
1447 box4 = gtk_vbox_new(FALSE, 0);
1448 gtk_container_add(GTK_CONTAINER(frame), box4);
1449 gtk_container_set_border_width(GTK_CONTAINER(box4), 5);
1451 /* create radio button */
1452 button = gtk_radio_button_new_with_label(NULL, "SINGLE");
1453 gtk_box_pack_start(GTK_BOX(box4), button, TRUE, TRUE, 0);
1454 sTreeSampleSelection.single_button = button;
1456 button = gtk_radio_button_new_with_label(gtk_radio_button_group (GTK_RADIO_BUTTON (button)),
1458 gtk_box_pack_start(GTK_BOX(box4), button, TRUE, TRUE, 0);
1459 sTreeSampleSelection.browse_button = button;
1461 button = gtk_radio_button_new_with_label(gtk_radio_button_group (GTK_RADIO_BUTTON (button)),
1463 gtk_box_pack_start(GTK_BOX(box4), button, TRUE, TRUE, 0);
1464 sTreeSampleSelection.multiple_button = button;
1466 sTreeSampleSelection.selection_mode_group = gtk_radio_button_group (GTK_RADIO_BUTTON (button));
1468 /* create option mode frame */
1469 frame = gtk_frame_new("Options");
1470 gtk_box_pack_start(GTK_BOX(box3), frame, TRUE, TRUE, 0);
1472 box4 = gtk_vbox_new(FALSE, 0);
1473 gtk_container_add(GTK_CONTAINER(frame), box4);
1474 gtk_container_set_border_width(GTK_CONTAINER(box4), 5);
1476 /* create check button */
1477 button = gtk_check_button_new_with_label("Draw line");
1478 gtk_box_pack_start(GTK_BOX(box4), button, TRUE, TRUE, 0);
1479 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), TRUE);
1480 sTreeSampleSelection.draw_line_button = button;
1482 button = gtk_check_button_new_with_label("View Line mode");
1483 gtk_box_pack_start(GTK_BOX(box4), button, TRUE, TRUE, 0);
1484 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), TRUE);
1485 sTreeSampleSelection.view_line_button = button;
1487 button = gtk_check_button_new_with_label("Without Root item");
1488 gtk_box_pack_start(GTK_BOX(box4), button, TRUE, TRUE, 0);
1489 sTreeSampleSelection.no_root_item_button = button;
1491 /* create recursion parameter */
1492 frame = gtk_frame_new("Size Parameters");
1493 gtk_box_pack_start(GTK_BOX(box2), frame, TRUE, TRUE, 0);
1495 box4 = gtk_hbox_new(FALSE, 5);
1496 gtk_container_add(GTK_CONTAINER(frame), box4);
1497 gtk_container_set_border_width(GTK_CONTAINER(box4), 5);
1499 /* create number of item spin button */
1500 box5 = gtk_hbox_new(FALSE, 5);
1501 gtk_box_pack_start(GTK_BOX(box4), box5, FALSE, FALSE, 0);
1503 label = gtk_label_new("Number of items : ");
1504 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
1505 gtk_box_pack_start (GTK_BOX (box5), label, FALSE, TRUE, 0);
1507 adj = (GtkAdjustment *) gtk_adjustment_new ((gfloat)DEFAULT_NUMBER_OF_ITEM, 1.0, 255.0, 1.0,
1509 spinner = gtk_spin_button_new (adj, 0, 0);
1510 gtk_box_pack_start (GTK_BOX (box5), spinner, FALSE, TRUE, 0);
1511 sTreeSampleSelection.nb_item_spinner = spinner;
1513 /* create recursion level spin button */
1514 box5 = gtk_hbox_new(FALSE, 5);
1515 gtk_box_pack_start(GTK_BOX(box4), box5, FALSE, FALSE, 0);
1517 label = gtk_label_new("Depth : ");
1518 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
1519 gtk_box_pack_start (GTK_BOX (box5), label, FALSE, TRUE, 0);
1521 adj = (GtkAdjustment *) gtk_adjustment_new ((gfloat)DEFAULT_RECURSION_LEVEL, 0.0, 255.0, 1.0,
1523 spinner = gtk_spin_button_new (adj, 0, 0);
1524 gtk_box_pack_start (GTK_BOX (box5), spinner, FALSE, TRUE, 0);
1525 sTreeSampleSelection.recursion_spinner = spinner;
1527 /* create horizontal separator */
1528 separator = gtk_hseparator_new();
1529 gtk_box_pack_start(GTK_BOX(box1), separator, FALSE, FALSE, 0);
1531 /* create bottom button box */
1532 box2 = gtk_hbox_new(TRUE, 10);
1533 gtk_box_pack_start(GTK_BOX(box1), box2, FALSE, FALSE, 0);
1534 gtk_container_set_border_width(GTK_CONTAINER(box2), 5);
1536 button = gtk_button_new_with_label("Create Tree");
1537 gtk_box_pack_start(GTK_BOX(box2), button, TRUE, TRUE, 0);
1538 gtk_signal_connect(GTK_OBJECT (button), "clicked",
1539 (GtkSignalFunc) cb_create_tree, NULL);
1541 button = gtk_button_new_with_label("Close");
1542 gtk_box_pack_start(GTK_BOX(box2), button, TRUE, TRUE, 0);
1543 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
1544 GTK_SIGNAL_FUNC(gtk_widget_destroy),
1545 GTK_OBJECT (window));
1547 if (!GTK_WIDGET_VISIBLE (window))
1548 gtk_widget_show_all (window);
1550 gtk_widget_destroy (window);
1558 handle_box_child_signal (GtkHandleBox *hb,
1560 const gchar *action)
1562 printf ("%s: child <%s> %sed\n",
1563 gtk_type_name (GTK_OBJECT_TYPE (hb)),
1564 gtk_type_name (GTK_OBJECT_TYPE (child)),
1569 create_handle_box (void)
1571 static GtkWidget* window = NULL;
1572 GtkWidget *handle_box;
1573 GtkWidget *handle_box2;
1578 GtkWidget *separator;
1582 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
1583 gtk_window_set_title (GTK_WINDOW (window),
1585 gtk_window_set_policy (GTK_WINDOW (window),
1590 gtk_signal_connect (GTK_OBJECT (window), "destroy",
1591 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
1594 gtk_container_set_border_width (GTK_CONTAINER (window), 20);
1596 vbox = gtk_vbox_new (FALSE, 0);
1597 gtk_container_add (GTK_CONTAINER (window), vbox);
1598 gtk_widget_show (vbox);
1600 label = gtk_label_new ("Above");
1601 gtk_container_add (GTK_CONTAINER (vbox), label);
1602 gtk_widget_show (label);
1604 separator = gtk_hseparator_new ();
1605 gtk_container_add (GTK_CONTAINER (vbox), separator);
1606 gtk_widget_show (separator);
1608 hbox = gtk_hbox_new (FALSE, 10);
1609 gtk_container_add (GTK_CONTAINER (vbox), hbox);
1610 gtk_widget_show (hbox);
1612 separator = gtk_hseparator_new ();
1613 gtk_container_add (GTK_CONTAINER (vbox), separator);
1614 gtk_widget_show (separator);
1616 label = gtk_label_new ("Below");
1617 gtk_container_add (GTK_CONTAINER (vbox), label);
1618 gtk_widget_show (label);
1620 handle_box = gtk_handle_box_new ();
1621 gtk_box_pack_start (GTK_BOX (hbox), handle_box, FALSE, FALSE, 0);
1622 gtk_signal_connect (GTK_OBJECT (handle_box),
1624 GTK_SIGNAL_FUNC (handle_box_child_signal),
1626 gtk_signal_connect (GTK_OBJECT (handle_box),
1628 GTK_SIGNAL_FUNC (handle_box_child_signal),
1630 gtk_widget_show (handle_box);
1632 toolbar = make_toolbar (window);
1633 gtk_toolbar_set_button_relief (GTK_TOOLBAR (toolbar), GTK_RELIEF_NORMAL);
1634 gtk_container_add (GTK_CONTAINER (handle_box), toolbar);
1635 gtk_widget_show (toolbar);
1637 handle_box = gtk_handle_box_new ();
1638 gtk_box_pack_start (GTK_BOX (hbox), handle_box, FALSE, FALSE, 0);
1639 gtk_signal_connect (GTK_OBJECT (handle_box),
1641 GTK_SIGNAL_FUNC (handle_box_child_signal),
1643 gtk_signal_connect (GTK_OBJECT (handle_box),
1645 GTK_SIGNAL_FUNC (handle_box_child_signal),
1647 gtk_widget_show (handle_box);
1649 handle_box2 = gtk_handle_box_new ();
1650 gtk_container_add (GTK_CONTAINER (handle_box), handle_box2);
1651 gtk_signal_connect (GTK_OBJECT (handle_box2),
1653 GTK_SIGNAL_FUNC (handle_box_child_signal),
1655 gtk_signal_connect (GTK_OBJECT (handle_box2),
1657 GTK_SIGNAL_FUNC (handle_box_child_signal),
1659 gtk_widget_show (handle_box2);
1661 label = gtk_label_new ("Fooo!");
1662 gtk_container_add (GTK_CONTAINER (handle_box2), label);
1663 gtk_widget_show (label);
1666 if (!GTK_WIDGET_VISIBLE (window))
1667 gtk_widget_show (window);
1669 gtk_widget_destroy (window);
1673 * Test for getting an image from a drawable
1684 take_snapshot (GtkWidget *button,
1687 struct GetImageData *gid = data;
1688 GdkRectangle visible;
1690 int height_fraction;
1693 GdkColor color = { 0, 30000, 0, 0 };
1694 GdkRectangle target;
1697 /* Do some begin_paint_rect on some random rects, draw some
1698 * distinctive stuff into those rects, then take the snapshot.
1699 * figure out whether any rects were overlapped and report to
1703 visible = gid->sw->allocation;
1705 visible.x = gtk_scrolled_window_get_hadjustment (GTK_SCROLLED_WINDOW (gid->sw))->value;
1706 visible.y = gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (gid->sw))->value;
1708 width_fraction = visible.width / 4;
1709 height_fraction = visible.height / 4;
1711 gc = gdk_gc_new (gid->src->window);
1712 black_gc = gid->src->style->black_gc;
1714 gdk_gc_set_rgb_fg_color (gc, &color);
1717 target.x = visible.x + width_fraction;
1718 target.y = visible.y + height_fraction * 3;
1719 target.width = width_fraction;
1720 target.height = height_fraction / 2;
1722 gdk_window_begin_paint_rect (gid->src->window,
1725 gdk_draw_rectangle (gid->src->window,
1729 target.width, target.height);
1731 gdk_draw_rectangle (gid->src->window,
1734 target.x + 10, target.y + 10,
1735 target.width - 20, target.height - 20);
1737 target.x = visible.x + width_fraction;
1738 target.y = visible.y + height_fraction;
1739 target.width = width_fraction;
1740 target.height = height_fraction;
1742 gdk_window_begin_paint_rect (gid->src->window,
1745 gdk_draw_rectangle (gid->src->window,
1749 target.width, target.height);
1751 gdk_draw_rectangle (gid->src->window,
1754 target.x + 10, target.y + 10,
1755 target.width - 20, target.height - 20);
1757 target.x = visible.x + width_fraction * 3;
1758 target.y = visible.y + height_fraction;
1759 target.width = width_fraction / 2;
1760 target.height = height_fraction;
1762 gdk_window_begin_paint_rect (gid->src->window,
1765 gdk_draw_rectangle (gid->src->window,
1769 target.width, target.height);
1771 gdk_draw_rectangle (gid->src->window,
1774 target.x + 10, target.y + 10,
1775 target.width - 20, target.height - 20);
1777 target.x = visible.x + width_fraction * 2;
1778 target.y = visible.y + height_fraction * 2;
1779 target.width = width_fraction / 4;
1780 target.height = height_fraction / 4;
1782 gdk_window_begin_paint_rect (gid->src->window,
1785 gdk_draw_rectangle (gid->src->window,
1789 target.width, target.height);
1791 gdk_draw_rectangle (gid->src->window,
1794 target.x + 10, target.y + 10,
1795 target.width - 20, target.height - 20);
1797 target.x += target.width / 2;
1798 target.y += target.width / 2;
1800 gdk_window_begin_paint_rect (gid->src->window,
1803 gdk_draw_rectangle (gid->src->window,
1807 target.width, target.height);
1809 gdk_draw_rectangle (gid->src->window,
1812 target.x + 10, target.y + 10,
1813 target.width - 20, target.height - 20);
1815 /* Screen shot area */
1817 target.x = visible.x + width_fraction * 1.5;
1818 target.y = visible.y + height_fraction * 1.5;
1819 target.width = width_fraction * 2;
1820 target.height = height_fraction * 2;
1822 shot = gdk_drawable_get_image (gid->src->window,
1824 target.width, target.height);
1826 gtk_image_set_from_image (GTK_IMAGE (gid->snap),
1829 g_object_unref (G_OBJECT (shot));
1831 gdk_window_end_paint (gid->src->window);
1832 gdk_window_end_paint (gid->src->window);
1833 gdk_window_end_paint (gid->src->window);
1834 gdk_window_end_paint (gid->src->window);
1835 gdk_window_end_paint (gid->src->window);
1837 gdk_draw_rectangle (gid->src->window,
1838 gid->src->style->black_gc,
1841 target.width, target.height);
1843 g_object_unref (G_OBJECT (gc));
1847 image_source_expose (GtkWidget *da,
1848 GdkEventExpose *event,
1851 int x = event->area.x;
1852 GdkColor red = { 0, 65535, 0, 0 };
1853 GdkColor green = { 0, 0, 65535, 0 };
1854 GdkColor blue = { 0, 0, 0, 65535 };
1857 gc = gdk_gc_new (event->window);
1859 while (x < (event->area.x + event->area.width))
1866 gdk_gc_set_rgb_fg_color (gc, &red);
1872 gdk_gc_set_rgb_fg_color (gc, &green);
1878 gdk_gc_set_rgb_fg_color (gc, &blue);
1882 g_assert_not_reached ();
1886 gdk_draw_line (event->window,
1889 x, event->area.y + event->area.height);
1894 g_object_unref (G_OBJECT (gc));
1900 create_get_image (void)
1902 static GtkWidget *window = NULL;
1905 gtk_widget_destroy (window);
1914 struct GetImageData *gid;
1916 gid = g_new (struct GetImageData, 1);
1918 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
1920 gtk_signal_connect (GTK_OBJECT (window),
1922 GTK_SIGNAL_FUNC (gtk_widget_destroyed),
1925 gtk_object_set_data_full (GTK_OBJECT (window),
1926 "testgtk-get-image-data",
1930 vbox = gtk_vbox_new (FALSE, 0);
1932 gtk_container_add (GTK_CONTAINER (window), vbox);
1934 sw = gtk_scrolled_window_new (NULL, NULL);
1935 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
1936 GTK_POLICY_AUTOMATIC,
1937 GTK_POLICY_AUTOMATIC);
1941 gtk_widget_set_usize (sw, 400, 400);
1943 src = gtk_drawing_area_new ();
1944 gtk_widget_set_usize (src, 10000, 10000);
1946 gtk_signal_connect (GTK_OBJECT (src),
1948 GTK_SIGNAL_FUNC (image_source_expose),
1953 gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (sw),
1956 gtk_box_pack_start (GTK_BOX (vbox),
1960 hbox = gtk_hbox_new (FALSE, 3);
1962 snap = gtk_widget_new (GTK_TYPE_IMAGE, NULL);
1966 sw = gtk_scrolled_window_new (NULL, NULL);
1967 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
1968 GTK_POLICY_AUTOMATIC,
1969 GTK_POLICY_AUTOMATIC);
1970 gtk_widget_set_usize (sw, 300, 300);
1972 gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (sw), snap);
1974 gtk_box_pack_end (GTK_BOX (hbox), sw, FALSE, FALSE, 5);
1976 button = gtk_button_new_with_label ("Get image from drawable");
1978 gtk_signal_connect (GTK_OBJECT (button),
1980 GTK_SIGNAL_FUNC (take_snapshot),
1983 gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0);
1985 gtk_box_pack_end (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
1987 gtk_widget_show_all (window);
1995 sensitivity_toggled (GtkWidget *toggle,
1998 gtk_widget_set_sensitive (widget, GTK_TOGGLE_BUTTON (toggle)->active);
2002 create_sensitivity_control (GtkWidget *widget)
2006 button = gtk_toggle_button_new_with_label ("Sensitive");
2008 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button),
2009 GTK_WIDGET_IS_SENSITIVE (widget));
2011 gtk_signal_connect (GTK_OBJECT (button),
2013 GTK_SIGNAL_FUNC (sensitivity_toggled),
2016 gtk_widget_show_all (button);
2022 set_selectable_recursive (GtkWidget *widget,
2025 if (GTK_IS_CONTAINER (widget))
2030 children = gtk_container_children (GTK_CONTAINER (widget));
2034 set_selectable_recursive (tmp->data, setting);
2038 g_list_free (children);
2040 else if (GTK_IS_LABEL (widget))
2042 gtk_label_set_selectable (GTK_LABEL (widget), setting);
2047 selectable_toggled (GtkWidget *toggle,
2050 set_selectable_recursive (widget,
2051 GTK_TOGGLE_BUTTON (toggle)->active);
2055 create_selectable_control (GtkWidget *widget)
2059 button = gtk_toggle_button_new_with_label ("Selectable");
2061 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button),
2064 gtk_signal_connect (GTK_OBJECT (button),
2066 GTK_SIGNAL_FUNC (selectable_toggled),
2069 gtk_widget_show_all (button);
2074 void create_labels (void)
2076 static GtkWidget *window = NULL;
2087 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
2088 gtk_signal_connect (GTK_OBJECT (window), "destroy",
2089 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
2092 gtk_window_set_title (GTK_WINDOW (window), "Label");
2094 vbox = gtk_vbox_new (FALSE, 5);
2096 hbox = gtk_hbox_new (FALSE, 5);
2097 gtk_container_add (GTK_CONTAINER (window), vbox);
2099 gtk_box_pack_end (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
2101 button = create_sensitivity_control (hbox);
2103 gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
2105 button = create_selectable_control (hbox);
2107 gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
2109 vbox = gtk_vbox_new (FALSE, 5);
2111 gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 0);
2112 gtk_container_set_border_width (GTK_CONTAINER (window), 5);
2114 frame = gtk_frame_new ("Normal Label");
2115 label = gtk_label_new ("This is a Normal label");
2116 gtk_container_add (GTK_CONTAINER (frame), label);
2117 gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
2119 frame = gtk_frame_new ("Multi-line Label");
2120 label = gtk_label_new ("This is a Multi-line label.\nSecond line\nThird line");
2121 gtk_container_add (GTK_CONTAINER (frame), label);
2122 gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
2124 frame = gtk_frame_new ("Left Justified Label");
2125 label = gtk_label_new ("This is a Left-Justified\nMulti-line label.\nThird line");
2126 gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
2127 gtk_container_add (GTK_CONTAINER (frame), label);
2128 gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
2130 frame = gtk_frame_new ("Right Justified Label");
2131 label = gtk_label_new ("This is a Right-Justified\nMulti-line label.\nFourth line, (j/k)");
2132 gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_RIGHT);
2133 gtk_container_add (GTK_CONTAINER (frame), label);
2134 gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
2136 frame = gtk_frame_new ("Internationalized Label");
2137 label = gtk_label_new ("French (Français) Bonjour, Salut\n"
2138 "Korean (한글) 안녕하세요, 안녕하십니까\n"
2139 "Russian (Русский) Здравствуйте!");
2140 gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
2141 gtk_container_add (GTK_CONTAINER (frame), label);
2142 gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
2144 frame = gtk_frame_new ("Bidirection Label");
2145 label = gtk_label_new ("Arabic السلام عليكم\n"
2147 gtk_widget_set_direction (label, GTK_TEXT_DIR_RTL);
2148 gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_RIGHT);
2149 gtk_container_add (GTK_CONTAINER (frame), label);
2150 gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
2152 vbox = gtk_vbox_new (FALSE, 5);
2153 gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 0);
2154 frame = gtk_frame_new ("Line wrapped label");
2155 label = gtk_label_new ("This is an example of a line-wrapped label. It should not be taking "\
2156 "up the entire "/* big space to test spacing */\
2157 "width allocated to it, but automatically wraps the words to fit. "\
2158 "The time has come, for all good men, to come to the aid of their party. "\
2159 "The sixth sheik's six sheep's sick.\n"\
2160 " It supports multiple paragraphs correctly, and correctly adds "\
2161 "many extra spaces. ");
2163 gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
2164 gtk_container_add (GTK_CONTAINER (frame), label);
2165 gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
2167 frame = gtk_frame_new ("Filled, wrapped label");
2168 label = gtk_label_new ("This is an example of a line-wrapped, filled label. It should be taking "\
2169 "up the entire width allocated to it. Here is a seneance to prove "\
2170 "my point. Here is another sentence. "\
2171 "Here comes the sun, do de do de do.\n"\
2172 " This is a new paragraph.\n"\
2173 " This is another newer, longer, better paragraph. It is coming to an end, "\
2175 gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_FILL);
2176 gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
2177 gtk_container_add (GTK_CONTAINER (frame), label);
2178 gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
2180 frame = gtk_frame_new ("Underlined label");
2181 label = gtk_label_new ("This label is underlined!\n"
2182 "This one is underlined (こんにちは) in quite a funky fashion");
2183 gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
2184 gtk_label_set_pattern (GTK_LABEL (label), "_________________________ _ _________ _ _____ _ __ __ ___ ____ _____");
2185 gtk_container_add (GTK_CONTAINER (frame), label);
2186 gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
2188 frame = gtk_frame_new ("Markup label");
2189 label = gtk_label_new (NULL);
2191 /* There's also a gtk_label_set_markup() without accel if you
2192 * don't have an accelerator key
2195 gtk_label_set_markup_with_accel (GTK_LABEL (label),
2196 "This <span foreground=\"blue\" background=\"orange\">label</span> has "
2197 "<b>markup</b> _such as "
2198 "<big><i>Big Italics</i></big>\n"
2199 "<tt>Monospace font</tt>\n"
2200 "<u>Underline!</u>\n"
2202 "<span foreground=\"green\" background=\"red\">Ugly colors</span>\n"
2203 "and nothing on this line,\n"
2206 "or even on this one\n"
2207 "la <big>la <big>la <big>la <big>la</big></big></big></big>\n"
2208 "but this _word is <span foreground=\"purple\"><big>purple</big></span>\n"
2209 "<span underline=\"double\">We like <sup>superscript</sup> and <sub>subscript</sub> too</span>");
2211 g_return_if_fail (keyval == GDK_s);
2213 gtk_container_add (GTK_CONTAINER (frame), label);
2214 gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
2217 if (!GTK_WIDGET_VISIBLE (window))
2218 gtk_widget_show_all (window);
2220 gtk_widget_destroy (window);
2228 reparent_label (GtkWidget *widget,
2229 GtkWidget *new_parent)
2233 label = gtk_object_get_user_data (GTK_OBJECT (widget));
2235 gtk_widget_reparent (label, new_parent);
2239 set_parent_signal (GtkWidget *child,
2240 GtkWidget *old_parent,
2243 g_print ("set_parent for \"%s\": new parent: \"%s\", old parent: \"%s\", data: %d\n",
2244 gtk_type_name (GTK_OBJECT_TYPE (child)),
2245 child->parent ? gtk_type_name (GTK_OBJECT_TYPE (child->parent)) : "NULL",
2246 old_parent ? gtk_type_name (GTK_OBJECT_TYPE (old_parent)) : "NULL",
2247 GPOINTER_TO_INT (func_data));
2251 create_reparent (void)
2253 static GtkWidget *window = NULL;
2260 GtkWidget *separator;
2264 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
2266 gtk_signal_connect (GTK_OBJECT (window), "destroy",
2267 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
2270 gtk_window_set_title (GTK_WINDOW (window), "reparent");
2271 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
2273 box1 = gtk_vbox_new (FALSE, 0);
2274 gtk_container_add (GTK_CONTAINER (window), box1);
2276 box2 = gtk_hbox_new (FALSE, 5);
2277 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
2278 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
2280 label = gtk_label_new ("Hello World");
2282 frame = gtk_frame_new ("Frame 1");
2283 gtk_box_pack_start (GTK_BOX (box2), frame, TRUE, TRUE, 0);
2285 box3 = gtk_vbox_new (FALSE, 5);
2286 gtk_container_set_border_width (GTK_CONTAINER (box3), 5);
2287 gtk_container_add (GTK_CONTAINER (frame), box3);
2289 button = gtk_button_new_with_label ("switch");
2290 gtk_signal_connect (GTK_OBJECT (button), "clicked",
2291 GTK_SIGNAL_FUNC(reparent_label),
2293 gtk_object_set_user_data (GTK_OBJECT (button), label);
2294 gtk_box_pack_start (GTK_BOX (box3), button, FALSE, TRUE, 0);
2296 gtk_box_pack_start (GTK_BOX (box3), label, FALSE, TRUE, 0);
2297 gtk_signal_connect (GTK_OBJECT (label),
2299 GTK_SIGNAL_FUNC (set_parent_signal),
2300 GINT_TO_POINTER (42));
2302 frame = gtk_frame_new ("Frame 2");
2303 gtk_box_pack_start (GTK_BOX (box2), frame, TRUE, TRUE, 0);
2305 box3 = gtk_vbox_new (FALSE, 5);
2306 gtk_container_set_border_width (GTK_CONTAINER (box3), 5);
2307 gtk_container_add (GTK_CONTAINER (frame), box3);
2309 button = gtk_button_new_with_label ("switch");
2310 gtk_signal_connect (GTK_OBJECT (button), "clicked",
2311 GTK_SIGNAL_FUNC(reparent_label),
2313 gtk_object_set_user_data (GTK_OBJECT (button), label);
2314 gtk_box_pack_start (GTK_BOX (box3), button, FALSE, TRUE, 0);
2316 separator = gtk_hseparator_new ();
2317 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
2319 box2 = gtk_vbox_new (FALSE, 10);
2320 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
2321 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
2323 button = gtk_button_new_with_label ("close");
2324 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
2325 GTK_SIGNAL_FUNC(gtk_widget_destroy),
2326 GTK_OBJECT (window));
2327 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
2328 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
2329 gtk_widget_grab_default (button);
2332 if (!GTK_WIDGET_VISIBLE (window))
2333 gtk_widget_show_all (window);
2335 gtk_widget_destroy (window);
2341 gint upositionx = 0;
2342 gint upositiony = 0;
2345 uposition_configure (GtkWidget *window)
2351 lx = gtk_object_get_data (GTK_OBJECT (window), "x");
2352 ly = gtk_object_get_data (GTK_OBJECT (window), "y");
2354 gdk_window_get_root_origin (window->window, &upositionx, &upositiony);
2355 sprintf (buffer, "%d", upositionx);
2356 gtk_label_set_text (lx, buffer);
2357 sprintf (buffer, "%d", upositiony);
2358 gtk_label_set_text (ly, buffer);
2364 uposition_stop_configure (GtkToggleButton *toggle,
2368 gtk_signal_handler_block_by_func (window, uposition_configure, NULL);
2370 gtk_signal_handler_unblock_by_func (window, uposition_configure, NULL);
2374 create_saved_position (void)
2376 static GtkWidget *window = NULL;
2381 GtkWidget *main_vbox;
2389 window = gtk_widget_new (GTK_TYPE_WINDOW,
2390 "type", GTK_WINDOW_TOPLEVEL,
2391 "signal::configure_event", uposition_configure, NULL,
2394 "title", "Saved Position",
2397 gtk_signal_connect (GTK_OBJECT (window), "destroy",
2398 GTK_SIGNAL_FUNC (gtk_widget_destroyed),
2401 main_vbox = gtk_vbox_new (FALSE, 5);
2402 gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 0);
2403 gtk_container_add (GTK_CONTAINER (window), main_vbox);
2406 gtk_widget_new (gtk_vbox_get_type (),
2407 "GtkBox::homogeneous", FALSE,
2408 "GtkBox::spacing", 5,
2409 "GtkContainer::border_width", 10,
2410 "GtkWidget::parent", main_vbox,
2411 "GtkWidget::visible", TRUE,
2412 "child", gtk_widget_new (GTK_TYPE_TOGGLE_BUTTON,
2413 "label", "Stop Events",
2415 "signal::clicked", uposition_stop_configure, window,
2420 hbox = gtk_hbox_new (FALSE, 0);
2421 gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
2422 gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0);
2424 label = gtk_label_new ("X Origin : ");
2425 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
2426 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
2428 x_label = gtk_label_new ("");
2429 gtk_box_pack_start (GTK_BOX (hbox), x_label, TRUE, TRUE, 0);
2430 gtk_object_set_data (GTK_OBJECT (window), "x", x_label);
2432 hbox = gtk_hbox_new (FALSE, 0);
2433 gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
2434 gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0);
2436 label = gtk_label_new ("Y Origin : ");
2437 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
2438 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
2440 y_label = gtk_label_new ("");
2441 gtk_box_pack_start (GTK_BOX (hbox), y_label, TRUE, TRUE, 0);
2442 gtk_object_set_data (GTK_OBJECT (window), "y", y_label);
2445 gtk_widget_new (gtk_hseparator_get_type (),
2446 "GtkWidget::visible", TRUE,
2448 gtk_box_pack_start (GTK_BOX (main_vbox), any, FALSE, TRUE, 0);
2450 hbox = gtk_hbox_new (FALSE, 0);
2451 gtk_container_set_border_width (GTK_CONTAINER (hbox), 10);
2452 gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, TRUE, 0);
2454 button = gtk_button_new_with_label ("Close");
2455 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
2456 GTK_SIGNAL_FUNC (gtk_widget_destroy),
2457 GTK_OBJECT (window));
2458 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
2459 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
2460 gtk_widget_grab_default (button);
2462 gtk_widget_show_all (window);
2465 gtk_widget_destroy (window);
2473 create_pixmap (void)
2475 static GtkWidget *window = NULL;
2481 GtkWidget *separator;
2482 GtkWidget *pixmapwid;
2486 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
2488 gtk_signal_connect (GTK_OBJECT (window), "destroy",
2489 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
2492 gtk_window_set_title (GTK_WINDOW (window), "GtkPixmap");
2493 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
2494 gtk_widget_realize(window);
2496 box1 = gtk_vbox_new (FALSE, 0);
2497 gtk_container_add (GTK_CONTAINER (window), box1);
2499 box2 = gtk_vbox_new (FALSE, 10);
2500 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
2501 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
2503 button = gtk_button_new ();
2504 gtk_box_pack_start (GTK_BOX (box2), button, FALSE, FALSE, 0);
2506 pixmapwid = new_pixmap ("test.xpm", window->window, NULL);
2508 label = gtk_label_new ("Pixmap\ntest");
2509 box3 = gtk_hbox_new (FALSE, 0);
2510 gtk_container_set_border_width (GTK_CONTAINER (box3), 2);
2511 gtk_container_add (GTK_CONTAINER (box3), pixmapwid);
2512 gtk_container_add (GTK_CONTAINER (box3), label);
2513 gtk_container_add (GTK_CONTAINER (button), box3);
2515 button = gtk_button_new ();
2516 gtk_box_pack_start (GTK_BOX (box2), button, FALSE, FALSE, 0);
2518 pixmapwid = new_pixmap ("test.xpm", window->window, NULL);
2520 label = gtk_label_new ("Pixmap\ntest");
2521 box3 = gtk_hbox_new (FALSE, 0);
2522 gtk_container_set_border_width (GTK_CONTAINER (box3), 2);
2523 gtk_container_add (GTK_CONTAINER (box3), pixmapwid);
2524 gtk_container_add (GTK_CONTAINER (box3), label);
2525 gtk_container_add (GTK_CONTAINER (button), box3);
2527 gtk_widget_set_sensitive (button, FALSE);
2529 separator = gtk_hseparator_new ();
2530 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
2532 box2 = gtk_vbox_new (FALSE, 10);
2533 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
2534 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
2536 button = gtk_button_new_with_label ("close");
2537 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
2538 GTK_SIGNAL_FUNC(gtk_widget_destroy),
2539 GTK_OBJECT (window));
2540 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
2541 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
2542 gtk_widget_grab_default (button);
2545 if (!GTK_WIDGET_VISIBLE (window))
2546 gtk_widget_show_all (window);
2548 gtk_widget_destroy (window);
2552 tips_query_widget_entered (GtkTipsQuery *tips_query,
2554 const gchar *tip_text,
2555 const gchar *tip_private,
2558 if (GTK_TOGGLE_BUTTON (toggle)->active)
2560 gtk_label_set_text (GTK_LABEL (tips_query), tip_text ? "There is a Tip!" : "There is no Tip!");
2561 /* don't let GtkTipsQuery reset its label */
2562 gtk_signal_emit_stop_by_name (GTK_OBJECT (tips_query), "widget_entered");
2567 tips_query_widget_selected (GtkWidget *tips_query,
2569 const gchar *tip_text,
2570 const gchar *tip_private,
2571 GdkEventButton *event,
2575 g_print ("Help \"%s\" requested for <%s>\n",
2576 tip_private ? tip_private : "None",
2577 gtk_type_name (GTK_OBJECT_TYPE (widget)));
2582 create_tooltips (void)
2584 static GtkWidget *window = NULL;
2591 GtkWidget *tips_query;
2592 GtkWidget *separator;
2593 GtkTooltips *tooltips;
2598 gtk_widget_new (gtk_window_get_type (),
2599 "GtkWindow::type", GTK_WINDOW_TOPLEVEL,
2600 "GtkContainer::border_width", 0,
2601 "GtkWindow::title", "Tooltips",
2602 "GtkWindow::allow_shrink", TRUE,
2603 "GtkWindow::allow_grow", FALSE,
2604 "GtkWindow::auto_shrink", TRUE,
2605 "GtkWidget::width", 200,
2608 gtk_signal_connect (GTK_OBJECT (window), "destroy",
2609 GTK_SIGNAL_FUNC (destroy_tooltips),
2612 tooltips=gtk_tooltips_new();
2613 gtk_object_set_data (GTK_OBJECT (window), "tooltips", tooltips);
2615 box1 = gtk_vbox_new (FALSE, 0);
2616 gtk_container_add (GTK_CONTAINER (window), box1);
2618 box2 = gtk_vbox_new (FALSE, 10);
2619 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
2620 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
2622 button = gtk_toggle_button_new_with_label ("button1");
2623 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
2625 gtk_tooltips_set_tip (tooltips,button,"This is button 1", "ContextHelp/buttons/1");
2627 button = gtk_toggle_button_new_with_label ("button2");
2628 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
2630 gtk_tooltips_set_tip (tooltips,
2632 "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.",
2633 "ContextHelp/buttons/2_long");
2635 toggle = gtk_toggle_button_new_with_label ("Override TipsQuery Label");
2636 gtk_box_pack_start (GTK_BOX (box2), toggle, TRUE, TRUE, 0);
2638 gtk_tooltips_set_tip (tooltips, toggle, "Toggle TipsQuery view.", "Hi msw! ;)");
2641 gtk_widget_new (gtk_vbox_get_type (),
2642 "GtkBox::homogeneous", FALSE,
2643 "GtkBox::spacing", 5,
2644 "GtkContainer::border_width", 5,
2645 "GtkWidget::visible", TRUE,
2648 tips_query = gtk_tips_query_new ();
2651 gtk_widget_new (gtk_button_get_type (),
2652 "GtkButton::label", "[?]",
2653 "GtkWidget::visible", TRUE,
2654 "GtkWidget::parent", box3,
2656 g_object_set (G_OBJECT (button),
2657 "swapped_signal::clicked", gtk_tips_query_start_query, tips_query,
2659 gtk_box_set_child_packing (GTK_BOX (box3), button, FALSE, FALSE, 0, GTK_PACK_START);
2660 gtk_tooltips_set_tip (tooltips,
2662 "Start the Tooltips Inspector",
2663 "ContextHelp/buttons/?");
2666 gtk_widget_set (tips_query,
2667 "GtkWidget::visible", TRUE,
2668 "GtkWidget::parent", box3,
2669 "GtkTipsQuery::caller", button,
2670 "GtkObject::signal::widget_entered", tips_query_widget_entered, toggle,
2671 "GtkObject::signal::widget_selected", tips_query_widget_selected, NULL,
2675 gtk_widget_new (gtk_frame_get_type (),
2676 "GtkFrame::label", "ToolTips Inspector",
2677 "GtkFrame::label_xalign", (double) 0.5,
2678 "GtkContainer::border_width", 0,
2679 "GtkWidget::visible", TRUE,
2680 "GtkWidget::parent", box2,
2681 "GtkContainer::child", box3,
2683 gtk_box_set_child_packing (GTK_BOX (box2), frame, TRUE, TRUE, 10, GTK_PACK_START);
2685 separator = gtk_hseparator_new ();
2686 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
2688 box2 = gtk_vbox_new (FALSE, 10);
2689 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
2690 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
2692 button = gtk_button_new_with_label ("close");
2693 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
2694 GTK_SIGNAL_FUNC(gtk_widget_destroy),
2695 GTK_OBJECT (window));
2696 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
2697 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
2698 gtk_widget_grab_default (button);
2700 gtk_tooltips_set_tip (tooltips, button, "Push this button to close window", "ContextHelp/buttons/Close");
2703 if (!GTK_WIDGET_VISIBLE (window))
2704 gtk_widget_show_all (window);
2706 gtk_widget_destroy (window);
2714 pack_image (GtkWidget *box,
2718 gtk_box_pack_start (GTK_BOX (box),
2719 gtk_label_new (text),
2722 gtk_box_pack_start (GTK_BOX (box),
2730 static GtkWidget *window = NULL;
2738 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
2740 gtk_signal_connect (GTK_OBJECT (window), "destroy",
2741 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
2744 vbox = gtk_vbox_new (FALSE, 5);
2746 gtk_container_add (GTK_CONTAINER (window), vbox);
2748 pack_image (vbox, "Stock Warning Dialog",
2749 gtk_image_new_from_stock (GTK_STOCK_DIALOG_WARNING,
2750 GTK_ICON_SIZE_DIALOG));
2752 pixmap = gdk_pixmap_colormap_create_from_xpm_d (NULL,
2753 gtk_widget_get_colormap (window),
2758 pack_image (vbox, "Pixmap",
2759 gtk_image_new_from_pixmap (pixmap, mask));
2762 if (!GTK_WIDGET_VISIBLE (window))
2763 gtk_widget_show_all (window);
2765 gtk_widget_destroy (window);
2773 create_menu (gint depth, gint length, gboolean tearoff)
2776 GtkWidget *menuitem;
2785 menu = gtk_menu_new ();
2790 menuitem = gtk_tearoff_menu_item_new ();
2791 gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
2792 gtk_widget_show (menuitem);
2795 image = gtk_image_new_from_stock (GTK_STOCK_OPEN,
2796 GTK_ICON_SIZE_MENU);
2797 gtk_widget_show (image);
2798 menuitem = gtk_image_menu_item_new (image, "Image item");
2799 gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
2800 gtk_widget_show (menuitem);
2802 for (i = 0, j = 1; i < length; i++, j++)
2804 sprintf (buf, "item %2d - %d", depth, j);
2806 menuitem = gtk_radio_menu_item_new_with_label (group, buf);
2807 group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menuitem));
2810 gtk_check_menu_item_set_show_toggle (GTK_CHECK_MENU_ITEM (menuitem), TRUE);
2812 gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
2813 gtk_widget_show (menuitem);
2815 gtk_widget_set_sensitive (menuitem, FALSE);
2818 gtk_check_menu_item_set_inconsistent (GTK_CHECK_MENU_ITEM (menuitem),
2822 gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), create_menu (depth - 1, 5, TRUE));
2831 static GtkWidget *window = NULL;
2835 GtkWidget *optionmenu;
2836 GtkWidget *separator;
2842 GtkWidget *menuitem;
2843 GtkAccelGroup *accel_group;
2846 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
2848 gtk_signal_connect (GTK_OBJECT (window), "destroy",
2849 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
2851 gtk_signal_connect (GTK_OBJECT (window), "delete-event",
2852 GTK_SIGNAL_FUNC (gtk_true),
2855 accel_group = gtk_accel_group_new ();
2856 gtk_accel_group_attach (accel_group, GTK_OBJECT (window));
2858 gtk_window_set_title (GTK_WINDOW (window), "menus");
2859 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
2862 box1 = gtk_vbox_new (FALSE, 0);
2863 gtk_container_add (GTK_CONTAINER (window), box1);
2864 gtk_widget_show (box1);
2866 menubar = gtk_menu_bar_new ();
2867 gtk_box_pack_start (GTK_BOX (box1), menubar, FALSE, TRUE, 0);
2868 gtk_widget_show (menubar);
2870 menu = create_menu (2, 50, TRUE);
2872 menuitem = gtk_menu_item_new_with_label ("test\nline2");
2873 gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), menu);
2874 gtk_menu_bar_append (GTK_MENU_BAR (menubar), menuitem);
2875 gtk_widget_show (menuitem);
2877 menuitem = gtk_menu_item_new_with_label ("foo");
2878 gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), create_menu (3, 5, TRUE));
2879 gtk_menu_bar_append (GTK_MENU_BAR (menubar), menuitem);
2880 gtk_widget_show (menuitem);
2882 image = gtk_image_new_from_stock (GTK_STOCK_HELP,
2883 GTK_ICON_SIZE_MENU);
2884 gtk_widget_show (image);
2885 menuitem = gtk_image_menu_item_new (image, "Help");
2886 gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), create_menu (4, 5, TRUE));
2887 gtk_menu_item_right_justify (GTK_MENU_ITEM (menuitem));
2888 gtk_menu_bar_append (GTK_MENU_BAR (menubar), menuitem);
2889 gtk_widget_show (menuitem);
2891 box2 = gtk_vbox_new (FALSE, 10);
2892 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
2893 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
2894 gtk_widget_show (box2);
2896 menu = create_menu (1, 5, FALSE);
2897 gtk_menu_set_accel_group (GTK_MENU (menu), accel_group);
2899 menuitem = gtk_check_menu_item_new_with_label ("Accelerate Me");
2900 gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
2901 gtk_widget_show (menuitem);
2902 gtk_widget_add_accelerator (menuitem,
2907 GTK_ACCEL_VISIBLE | GTK_ACCEL_SIGNAL_VISIBLE);
2908 menuitem = gtk_check_menu_item_new_with_label ("Accelerator Locked");
2909 gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
2910 gtk_widget_show (menuitem);
2911 gtk_widget_add_accelerator (menuitem,
2916 GTK_ACCEL_VISIBLE | GTK_ACCEL_LOCKED);
2917 menuitem = gtk_check_menu_item_new_with_label ("Accelerators Frozen");
2918 gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
2919 gtk_widget_show (menuitem);
2920 gtk_widget_add_accelerator (menuitem,
2926 gtk_widget_add_accelerator (menuitem,
2932 gtk_widget_lock_accelerators (menuitem);
2934 optionmenu = gtk_option_menu_new ();
2935 gtk_option_menu_set_menu (GTK_OPTION_MENU (optionmenu), menu);
2936 gtk_option_menu_set_history (GTK_OPTION_MENU (optionmenu), 3);
2937 gtk_box_pack_start (GTK_BOX (box2), optionmenu, TRUE, TRUE, 0);
2938 gtk_widget_show (optionmenu);
2940 separator = gtk_hseparator_new ();
2941 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
2942 gtk_widget_show (separator);
2944 box2 = gtk_vbox_new (FALSE, 10);
2945 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
2946 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
2947 gtk_widget_show (box2);
2949 button = gtk_button_new_with_label ("close");
2950 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
2951 GTK_SIGNAL_FUNC(gtk_widget_destroy),
2952 GTK_OBJECT (window));
2953 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
2954 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
2955 gtk_widget_grab_default (button);
2956 gtk_widget_show (button);
2959 if (!GTK_WIDGET_VISIBLE (window))
2960 gtk_widget_show (window);
2962 gtk_widget_destroy (window);
2966 gtk_ifactory_cb (gpointer callback_data,
2967 guint callback_action,
2970 g_message ("ItemFactory: activated \"%s\"", gtk_item_factory_path_from_widget (widget));
2973 static GtkItemFactoryEntry menu_items[] =
2975 { "/_File", NULL, 0, 0, "<Branch>" },
2976 { "/File/tearoff1", NULL, gtk_ifactory_cb, 0, "<Tearoff>" },
2977 { "/File/_New", "<control>N", gtk_ifactory_cb, 0 },
2978 { "/File/_Open", "<control>O", gtk_ifactory_cb, 0 },
2979 { "/File/_Save", "<control>S", gtk_ifactory_cb, 0 },
2980 { "/File/Save _As...", NULL, gtk_ifactory_cb, 0 },
2981 { "/File/sep1", NULL, gtk_ifactory_cb, 0, "<Separator>" },
2982 { "/File/_Quit", "<control>Q", gtk_ifactory_cb, 0 },
2984 { "/_Preferences", NULL, 0, 0, "<Branch>" },
2985 { "/_Preferences/_Color", NULL, 0, 0, "<Branch>" },
2986 { "/_Preferences/Color/_Red", NULL, gtk_ifactory_cb, 0, "<RadioItem>" },
2987 { "/_Preferences/Color/_Green", NULL, gtk_ifactory_cb, 0, "/Preferences/Color/Red" },
2988 { "/_Preferences/Color/_Blue", NULL, gtk_ifactory_cb, 0, "/Preferences/Color/Red" },
2989 { "/_Preferences/_Shape", NULL, 0, 0, "<Branch>" },
2990 { "/_Preferences/Shape/_Square", NULL, gtk_ifactory_cb, 0, "<RadioItem>" },
2991 { "/_Preferences/Shape/_Rectangle", NULL, gtk_ifactory_cb, 0, "/Preferences/Shape/Square" },
2992 { "/_Preferences/Shape/_Oval", NULL, gtk_ifactory_cb, 0, "/Preferences/Shape/Rectangle" },
2993 { "/_Preferences/Shape/_Rectangle", NULL, gtk_ifactory_cb, 0, "/Preferences/Shape/Square" },
2994 { "/_Preferences/Shape/_Oval", NULL, gtk_ifactory_cb, 0, "/Preferences/Shape/Rectangle" },
2996 /* For testing deletion of menus */
2997 { "/_Preferences/Should_NotAppear", NULL, 0, 0, "<Branch>" },
2998 { "/Preferences/ShouldNotAppear/SubItem1", NULL, gtk_ifactory_cb, 0 },
2999 { "/Preferences/ShouldNotAppear/SubItem2", NULL, gtk_ifactory_cb, 0 },
3001 { "/_Help", NULL, 0, 0, "<LastBranch>" },
3002 { "/Help/_About", NULL, gtk_ifactory_cb, 0 },
3006 static int nmenu_items = sizeof (menu_items) / sizeof (menu_items[0]);
3009 create_item_factory (void)
3011 static GtkWidget *window = NULL;
3017 GtkWidget *separator;
3020 GtkAccelGroup *accel_group;
3021 GtkItemFactory *item_factory;
3023 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
3025 gtk_signal_connect (GTK_OBJECT (window), "destroy",
3026 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
3028 gtk_signal_connect (GTK_OBJECT (window), "delete-event",
3029 GTK_SIGNAL_FUNC (gtk_true),
3032 accel_group = gtk_accel_group_new ();
3033 item_factory = gtk_item_factory_new (GTK_TYPE_MENU_BAR, "<main>", accel_group);
3034 gtk_object_set_data_full (GTK_OBJECT (window),
3037 (GtkDestroyNotify) gtk_object_unref);
3038 gtk_accel_group_attach (accel_group, GTK_OBJECT (window));
3039 gtk_window_set_title (GTK_WINDOW (window), "Item Factory");
3040 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
3041 gtk_item_factory_create_items (item_factory, nmenu_items, menu_items, NULL);
3043 /* preselect /Preferences/Shape/Oval over the other radios
3045 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (gtk_item_factory_get_item (item_factory,
3046 "/Preferences/Shape/Oval")),
3049 box1 = gtk_vbox_new (FALSE, 0);
3050 gtk_container_add (GTK_CONTAINER (window), box1);
3052 gtk_box_pack_start (GTK_BOX (box1),
3053 gtk_item_factory_get_widget (item_factory, "<main>"),
3056 label = gtk_label_new ("Type\n<alt>\nto start");
3057 gtk_widget_set_usize (label, 200, 200);
3058 gtk_misc_set_alignment (GTK_MISC (label), 0.5, 0.5);
3059 gtk_box_pack_start (GTK_BOX (box1), label, TRUE, TRUE, 0);
3062 separator = gtk_hseparator_new ();
3063 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
3066 box2 = gtk_vbox_new (FALSE, 10);
3067 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
3068 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
3070 button = gtk_button_new_with_label ("close");
3071 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
3072 GTK_SIGNAL_FUNC(gtk_widget_destroy),
3073 GTK_OBJECT (window));
3074 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
3075 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
3076 gtk_widget_grab_default (button);
3078 gtk_item_factory_delete_item (item_factory, "/Preferences/ShouldNotAppear");
3080 gtk_widget_show_all (window);
3083 gtk_widget_destroy (window);
3091 cmw_destroy_cb(GtkWidget *widget)
3093 /* This is needed to get out of gtk_main */
3100 cmw_color (GtkWidget *widget, GtkWidget *parent)
3104 csd=gtk_color_selection_dialog_new ("This is a modal color selection dialog");
3107 gtk_window_set_modal (GTK_WINDOW(csd),TRUE);
3109 /* And mark it as a transient dialog */
3110 gtk_window_set_transient_for (GTK_WINDOW (csd), GTK_WINDOW (parent));
3112 gtk_signal_connect (GTK_OBJECT(csd), "destroy",
3113 GTK_SIGNAL_FUNC(cmw_destroy_cb),NULL);
3115 gtk_signal_connect_object (GTK_OBJECT(GTK_COLOR_SELECTION_DIALOG(csd)->ok_button),
3116 "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy),
3118 gtk_signal_connect_object (GTK_OBJECT(GTK_COLOR_SELECTION_DIALOG(csd)->cancel_button),
3119 "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy),
3122 /* wait until destroy calls gtk_main_quit */
3123 gtk_widget_show (csd);
3128 cmw_file (GtkWidget *widget, GtkWidget *parent)
3132 fs = gtk_file_selection_new("This is a modal file selection dialog");
3135 gtk_window_set_modal (GTK_WINDOW(fs),TRUE);
3137 /* And mark it as a transient dialog */
3138 gtk_window_set_transient_for (GTK_WINDOW (fs), GTK_WINDOW (parent));
3140 gtk_signal_connect (GTK_OBJECT(fs), "destroy",
3141 GTK_SIGNAL_FUNC(cmw_destroy_cb),NULL);
3143 gtk_signal_connect_object (GTK_OBJECT(GTK_FILE_SELECTION(fs)->ok_button),
3144 "clicked",GTK_SIGNAL_FUNC(gtk_widget_destroy),
3146 gtk_signal_connect_object (GTK_OBJECT(GTK_FILE_SELECTION(fs)->cancel_button),
3147 "clicked",GTK_SIGNAL_FUNC(gtk_widget_destroy),
3150 /* wait until destroy calls gtk_main_quit */
3151 gtk_widget_show (fs);
3158 create_modal_window (void)
3160 GtkWidget *window = NULL;
3161 GtkWidget *box1,*box2;
3163 GtkWidget *btnColor,*btnFile,*btnClose;
3165 /* Create modal window (Here you can use any window descendent )*/
3166 window=gtk_window_new (GTK_WINDOW_TOPLEVEL);
3167 gtk_window_set_title (GTK_WINDOW(window),"This window is modal");
3169 /* Set window as modal */
3170 gtk_window_set_modal (GTK_WINDOW(window),TRUE);
3172 /* Create widgets */
3173 box1 = gtk_vbox_new (FALSE,5);
3174 frame1 = gtk_frame_new ("Standard dialogs in modal form");
3175 box2 = gtk_vbox_new (TRUE,5);
3176 btnColor = gtk_button_new_with_label ("Color");
3177 btnFile = gtk_button_new_with_label ("File Selection");
3178 btnClose = gtk_button_new_with_label ("Close");
3181 gtk_container_set_border_width (GTK_CONTAINER(box1),3);
3182 gtk_container_set_border_width (GTK_CONTAINER(box2),3);
3185 gtk_container_add (GTK_CONTAINER (window), box1);
3186 gtk_box_pack_start (GTK_BOX (box1), frame1, TRUE, TRUE, 4);
3187 gtk_container_add (GTK_CONTAINER (frame1), box2);
3188 gtk_box_pack_start (GTK_BOX (box2), btnColor, FALSE, FALSE, 4);
3189 gtk_box_pack_start (GTK_BOX (box2), btnFile, FALSE, FALSE, 4);
3190 gtk_box_pack_start (GTK_BOX (box1), gtk_hseparator_new (), FALSE, FALSE, 4);
3191 gtk_box_pack_start (GTK_BOX (box1), btnClose, FALSE, FALSE, 4);
3193 /* connect signals */
3194 gtk_signal_connect_object (GTK_OBJECT (btnClose), "clicked",
3195 GTK_SIGNAL_FUNC (gtk_widget_destroy),
3196 GTK_OBJECT (window));
3198 gtk_signal_connect (GTK_OBJECT (window), "destroy",
3199 GTK_SIGNAL_FUNC (cmw_destroy_cb),NULL);
3201 gtk_signal_connect (GTK_OBJECT (btnColor), "clicked",
3202 GTK_SIGNAL_FUNC (cmw_color),window);
3203 gtk_signal_connect (GTK_OBJECT (btnFile), "clicked",
3204 GTK_SIGNAL_FUNC (cmw_file),window);
3207 gtk_widget_show_all (window);
3209 /* wait until dialog get destroyed */
3218 make_message_dialog (GtkWidget **dialog,
3219 GtkMessageType type,
3220 GtkButtonsType buttons)
3224 gtk_widget_destroy (*dialog);
3229 *dialog = gtk_message_dialog_new (NULL, 0, type, buttons,
3230 "This is a message dialog; it can wrap long lines. This is a long line. La la la. Look this line is wrapped. Blah blah blah blah blah blah. (Note: testgtk has a nonstandard gtkrc that changes some of the message dialog icons.)");
3232 gtk_signal_connect_object (GTK_OBJECT (*dialog),
3234 GTK_SIGNAL_FUNC (gtk_widget_destroy),
3235 GTK_OBJECT (*dialog));
3237 gtk_signal_connect (GTK_OBJECT (*dialog),
3239 GTK_SIGNAL_FUNC (gtk_widget_destroyed),
3242 gtk_widget_show (*dialog);
3246 create_message_dialog (void)
3248 static GtkWidget *info = NULL;
3249 static GtkWidget *warning = NULL;
3250 static GtkWidget *error = NULL;
3251 static GtkWidget *question = NULL;
3253 make_message_dialog (&info, GTK_MESSAGE_INFO, GTK_BUTTONS_OK);
3254 make_message_dialog (&warning, GTK_MESSAGE_WARNING, GTK_BUTTONS_CLOSE);
3255 make_message_dialog (&error, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK_CANCEL);
3256 make_message_dialog (&question, GTK_MESSAGE_QUESTION, GTK_BUTTONS_YES_NO);
3263 static GtkWidget *sw_parent = NULL;
3264 static GtkWidget *sw_float_parent;
3265 static guint sw_destroyed_handler = 0;
3268 scrolled_windows_delete_cb (GtkWidget *widget, GdkEventAny *event, GtkWidget *scrollwin)
3270 gtk_widget_reparent (scrollwin, sw_parent);
3272 gtk_signal_disconnect (GTK_OBJECT (sw_parent), sw_destroyed_handler);
3273 sw_float_parent = NULL;
3275 sw_destroyed_handler = 0;
3281 scrolled_windows_destroy_cb (GtkWidget *widget, GtkWidget *scrollwin)
3283 gtk_widget_destroy (sw_float_parent);
3285 sw_float_parent = NULL;
3287 sw_destroyed_handler = 0;
3291 scrolled_windows_remove (GtkWidget *widget, GtkWidget *scrollwin)
3295 gtk_widget_reparent (scrollwin, sw_parent);
3296 gtk_widget_destroy (sw_float_parent);
3298 gtk_signal_disconnect (GTK_OBJECT (sw_parent), sw_destroyed_handler);
3299 sw_float_parent = NULL;
3301 sw_destroyed_handler = 0;
3305 sw_parent = scrollwin->parent;
3306 sw_float_parent = gtk_window_new (GTK_WINDOW_TOPLEVEL);
3307 gtk_window_set_default_size (GTK_WINDOW (sw_float_parent), 200, 200);
3309 gtk_widget_reparent (scrollwin, sw_float_parent);
3310 gtk_widget_show (sw_float_parent);
3312 sw_destroyed_handler =
3313 gtk_signal_connect (GTK_OBJECT (sw_parent), "destroy",
3314 GTK_SIGNAL_FUNC (scrolled_windows_destroy_cb), scrollwin);
3315 gtk_signal_connect (GTK_OBJECT (sw_float_parent), "delete_event",
3316 GTK_SIGNAL_FUNC (scrolled_windows_delete_cb), scrollwin);
3321 create_scrolled_windows (void)
3323 static GtkWidget *window;
3324 GtkWidget *scrolled_window;
3332 window = gtk_dialog_new ();
3334 gtk_signal_connect (GTK_OBJECT (window), "destroy",
3335 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
3338 gtk_window_set_title (GTK_WINDOW (window), "dialog");
3339 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
3342 scrolled_window = gtk_scrolled_window_new (NULL, NULL);
3343 gtk_container_set_border_width (GTK_CONTAINER (scrolled_window), 10);
3344 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
3345 GTK_POLICY_AUTOMATIC,
3346 GTK_POLICY_AUTOMATIC);
3347 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox),
3348 scrolled_window, TRUE, TRUE, 0);
3349 gtk_widget_show (scrolled_window);
3351 table = gtk_table_new (20, 20, FALSE);
3352 gtk_table_set_row_spacings (GTK_TABLE (table), 10);
3353 gtk_table_set_col_spacings (GTK_TABLE (table), 10);
3354 gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (scrolled_window), table);
3355 gtk_container_set_focus_hadjustment (GTK_CONTAINER (table),
3356 gtk_scrolled_window_get_hadjustment (GTK_SCROLLED_WINDOW (scrolled_window)));
3357 gtk_container_set_focus_vadjustment (GTK_CONTAINER (table),
3358 gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (scrolled_window)));
3359 gtk_widget_show (table);
3361 for (i = 0; i < 20; i++)
3362 for (j = 0; j < 20; j++)
3364 sprintf (buffer, "button (%d,%d)\n", i, j);
3365 button = gtk_toggle_button_new_with_label (buffer);
3366 gtk_table_attach_defaults (GTK_TABLE (table), button,
3368 gtk_widget_show (button);
3372 button = gtk_button_new_with_label ("Close");
3373 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
3374 GTK_SIGNAL_FUNC(gtk_widget_destroy),
3375 GTK_OBJECT (window));
3376 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
3377 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
3378 button, TRUE, TRUE, 0);
3379 gtk_widget_grab_default (button);
3380 gtk_widget_show (button);
3382 button = gtk_button_new_with_label ("Reparent Out");
3383 gtk_signal_connect (GTK_OBJECT (button), "clicked",
3384 GTK_SIGNAL_FUNC(scrolled_windows_remove),
3386 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
3387 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
3388 button, TRUE, TRUE, 0);
3389 gtk_widget_grab_default (button);
3390 gtk_widget_show (button);
3392 gtk_window_set_default_size (GTK_WINDOW (window), 300, 300);
3395 if (!GTK_WIDGET_VISIBLE (window))
3396 gtk_widget_show (window);
3398 gtk_widget_destroy (window);
3406 entry_toggle_frame (GtkWidget *checkbutton,
3409 gtk_entry_set_has_frame (GTK_ENTRY(entry),
3410 GTK_TOGGLE_BUTTON(checkbutton)->active);
3414 entry_toggle_editable (GtkWidget *checkbutton,
3417 gtk_entry_set_editable(GTK_ENTRY(entry),
3418 GTK_TOGGLE_BUTTON(checkbutton)->active);
3422 entry_toggle_sensitive (GtkWidget *checkbutton,
3425 gtk_widget_set_sensitive (entry, GTK_TOGGLE_BUTTON(checkbutton)->active);
3429 entry_toggle_visibility (GtkWidget *checkbutton,
3432 gtk_entry_set_visibility(GTK_ENTRY(entry),
3433 GTK_TOGGLE_BUTTON(checkbutton)->active);
3437 entry_toggle_invisible_char (GtkWidget *checkbutton,
3440 if (GTK_TOGGLE_BUTTON (checkbutton)->active)
3441 gtk_entry_set_invisible_char (GTK_ENTRY (entry), 0);
3443 gtk_entry_set_invisible_char (GTK_ENTRY (entry), '*');
3449 static GtkWidget *window = NULL;
3452 GtkWidget *editable_check;
3453 GtkWidget *sensitive_check;
3454 GtkWidget *invisible_char_check;
3455 GtkWidget *entry, *cb;
3457 GtkWidget *separator;
3458 GList *cbitems = NULL;
3462 cbitems = g_list_append(cbitems, "item0");
3463 cbitems = g_list_append(cbitems, "item1 item1");
3464 cbitems = g_list_append(cbitems, "item2 item2 item2");
3465 cbitems = g_list_append(cbitems, "item3 item3 item3 item3");
3466 cbitems = g_list_append(cbitems, "item4 item4 item4 item4 item4");
3467 cbitems = g_list_append(cbitems, "item5 item5 item5 item5 item5 item5");
3468 cbitems = g_list_append(cbitems, "item6 item6 item6 item6 item6");
3469 cbitems = g_list_append(cbitems, "item7 item7 item7 item7");
3470 cbitems = g_list_append(cbitems, "item8 item8 item8");
3471 cbitems = g_list_append(cbitems, "item9 item9");
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), "entry");
3480 gtk_container_set_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_set_border_width (GTK_CONTAINER (box2), 10);
3490 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
3491 gtk_widget_show (box2);
3493 entry = gtk_entry_new ();
3494 gtk_entry_set_text (GTK_ENTRY (entry), "hello world السلام عليكم");
3495 gtk_editable_select_region (GTK_EDITABLE (entry), 0, 5);
3496 gtk_box_pack_start (GTK_BOX (box2), entry, TRUE, TRUE, 0);
3497 gtk_widget_show (entry);
3499 cb = gtk_combo_new ();
3500 gtk_combo_set_popdown_strings (GTK_COMBO (cb), cbitems);
3501 gtk_entry_set_text (GTK_ENTRY (GTK_COMBO(cb)->entry), "hello world");
3502 gtk_editable_select_region (GTK_EDITABLE (GTK_COMBO(cb)->entry),
3504 gtk_box_pack_start (GTK_BOX (box2), cb, TRUE, TRUE, 0);
3505 gtk_widget_show (cb);
3507 editable_check = gtk_check_button_new_with_label("Editable");
3508 gtk_box_pack_start (GTK_BOX (box2), editable_check, FALSE, TRUE, 0);
3509 gtk_signal_connect (GTK_OBJECT(editable_check), "toggled",
3510 GTK_SIGNAL_FUNC(entry_toggle_editable), entry);
3511 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(editable_check), TRUE);
3512 gtk_widget_show (editable_check);
3514 editable_check = gtk_check_button_new_with_label("Visible");
3515 gtk_box_pack_start (GTK_BOX (box2), editable_check, FALSE, TRUE, 0);
3516 gtk_signal_connect (GTK_OBJECT(editable_check), "toggled",
3517 GTK_SIGNAL_FUNC(entry_toggle_visibility), entry);
3518 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(editable_check), TRUE);
3519 gtk_widget_show (editable_check);
3521 sensitive_check = gtk_check_button_new_with_label("Sensitive");
3522 gtk_box_pack_start (GTK_BOX (box2), sensitive_check, FALSE, TRUE, 0);
3523 gtk_signal_connect (GTK_OBJECT(sensitive_check), "toggled",
3524 GTK_SIGNAL_FUNC(entry_toggle_sensitive), entry);
3525 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(sensitive_check), TRUE);
3526 gtk_widget_show (sensitive_check);
3528 invisible_char_check = gtk_check_button_new_with_label("invisible_char = 0");
3529 gtk_box_pack_start (GTK_BOX (box2), invisible_char_check, FALSE, TRUE, 0);
3530 gtk_signal_connect (GTK_OBJECT(invisible_char_check), "toggled",
3531 GTK_SIGNAL_FUNC(entry_toggle_invisible_char), entry);
3532 gtk_widget_show (invisible_char_check);
3534 editable_check = gtk_check_button_new_with_label("Has Frame");
3535 gtk_box_pack_start (GTK_BOX (box2), editable_check, FALSE, TRUE, 0);
3536 gtk_signal_connect (GTK_OBJECT(editable_check), "toggled",
3537 GTK_SIGNAL_FUNC(entry_toggle_frame), entry);
3538 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(editable_check), TRUE);
3539 gtk_widget_show (editable_check);
3541 separator = gtk_hseparator_new ();
3542 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
3543 gtk_widget_show (separator);
3546 box2 = gtk_vbox_new (FALSE, 10);
3547 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
3548 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
3549 gtk_widget_show (box2);
3552 button = gtk_button_new_with_label ("close");
3553 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
3554 GTK_SIGNAL_FUNC(gtk_widget_destroy),
3555 GTK_OBJECT (window));
3556 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
3557 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
3558 gtk_widget_grab_default (button);
3559 gtk_widget_show (button);
3562 if (!GTK_WIDGET_VISIBLE (window))
3563 gtk_widget_show (window);
3565 gtk_widget_destroy (window);
3572 static GtkWidget *spinner1;
3575 toggle_snap (GtkWidget *widget, GtkSpinButton *spin)
3577 gtk_spin_button_set_snap_to_ticks (spin, GTK_TOGGLE_BUTTON (widget)->active);
3581 toggle_numeric (GtkWidget *widget, GtkSpinButton *spin)
3583 gtk_spin_button_set_numeric (spin, GTK_TOGGLE_BUTTON (widget)->active);
3587 change_digits (GtkWidget *widget, GtkSpinButton *spin)
3589 gtk_spin_button_set_digits (GTK_SPIN_BUTTON (spinner1),
3590 gtk_spin_button_get_value_as_int (spin));
3594 get_value (GtkWidget *widget, gpointer data)
3598 GtkSpinButton *spin;
3600 spin = GTK_SPIN_BUTTON (spinner1);
3601 label = GTK_LABEL (gtk_object_get_user_data (GTK_OBJECT (widget)));
3602 if (GPOINTER_TO_INT (data) == 1)
3603 sprintf (buf, "%d", gtk_spin_button_get_value_as_int (spin));
3605 sprintf (buf, "%0.*f", spin->digits,
3606 gtk_spin_button_get_value_as_float (spin));
3607 gtk_label_set_text (label, buf);
3611 spin_button_time_output_func (GtkSpinButton *spin_button)
3613 static gchar buf[6];
3617 hours = spin_button->adjustment->value / 60.0;
3618 minutes = (fabs(floor (hours) - hours) < 1e-5) ? 0.0 : 30;
3619 sprintf (buf, "%02.0f:%02.0f", floor (hours), minutes);
3620 if (strcmp (buf, gtk_entry_get_text (GTK_ENTRY (spin_button))))
3621 gtk_entry_set_text (GTK_ENTRY (spin_button), buf);
3626 spin_button_month_input_func (GtkSpinButton *spin_button,
3630 static gchar *month[12] = { "January", "February", "March", "April",
3631 "May", "June", "July", "August",
3632 "September", "October", "November", "December" };
3634 gboolean found = FALSE;
3636 for (i = 1; i <= 12; i++)
3638 tmp1 = g_strdup (month[i-1]);
3640 tmp2 = g_strdup (gtk_entry_get_text (GTK_ENTRY (spin_button)));
3642 if (strstr (tmp1, tmp2) == tmp1)
3652 return GTK_INPUT_ERROR;
3654 *new_val = (gfloat) i;
3659 spin_button_month_output_func (GtkSpinButton *spin_button)
3662 static gchar *month[12] = { "January", "February", "March", "April",
3663 "May", "June", "July", "August", "September",
3664 "October", "November", "December" };
3666 for (i = 1; i <= 12; i++)
3667 if (fabs (spin_button->adjustment->value - (double)i) < 1e-5)
3669 if (strcmp (month[i-1], gtk_entry_get_text (GTK_ENTRY (spin_button))))
3670 gtk_entry_set_text (GTK_ENTRY (spin_button), month[i-1]);
3676 spin_button_hex_input_func (GtkSpinButton *spin_button,
3683 buf = gtk_entry_get_text (GTK_ENTRY (spin_button));
3684 res = (gfloat)(strtol(buf, &err, 16));
3687 return GTK_INPUT_ERROR;
3693 spin_button_hex_output_func (GtkSpinButton *spin_button)
3695 static gchar buf[7];
3698 val = (gint) spin_button->adjustment->value;
3699 if (fabs (val) < 1e-5)
3700 sprintf (buf, "0x00");
3702 sprintf (buf, "0x%.2X", val);
3703 if (strcmp (buf, gtk_entry_get_text (GTK_ENTRY (spin_button))))
3704 gtk_entry_set_text (GTK_ENTRY (spin_button), buf);
3711 static GtkWidget *window = NULL;
3714 GtkWidget *main_vbox;
3717 GtkWidget *spinner2;
3721 GtkWidget *val_label;
3726 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
3728 gtk_signal_connect (GTK_OBJECT (window), "destroy",
3729 GTK_SIGNAL_FUNC (gtk_widget_destroyed),
3732 gtk_window_set_title (GTK_WINDOW (window), "GtkSpinButton");
3734 main_vbox = gtk_vbox_new (FALSE, 5);
3735 gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 10);
3736 gtk_container_add (GTK_CONTAINER (window), main_vbox);
3738 frame = gtk_frame_new ("Not accelerated");
3739 gtk_box_pack_start (GTK_BOX (main_vbox), frame, TRUE, TRUE, 0);
3741 vbox = gtk_vbox_new (FALSE, 0);
3742 gtk_container_set_border_width (GTK_CONTAINER (vbox), 5);
3743 gtk_container_add (GTK_CONTAINER (frame), vbox);
3745 /* Time, month, hex spinners */
3747 hbox = gtk_hbox_new (FALSE, 0);
3748 gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 5);
3750 vbox2 = gtk_vbox_new (FALSE, 0);
3751 gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 5);
3753 label = gtk_label_new ("Time :");
3754 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
3755 gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, TRUE, 0);
3757 adj = (GtkAdjustment *) gtk_adjustment_new (0, 0, 1410, 30, 60, 0);
3758 spinner = gtk_spin_button_new (adj, 0, 0);
3759 gtk_editable_set_editable (GTK_EDITABLE (spinner), FALSE);
3760 gtk_signal_connect (GTK_OBJECT (spinner),
3762 GTK_SIGNAL_FUNC (spin_button_time_output_func),
3764 gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spinner), TRUE);
3765 gtk_widget_set_usize (spinner, 55, -1);
3766 gtk_box_pack_start (GTK_BOX (vbox2), spinner, FALSE, TRUE, 0);
3768 vbox2 = gtk_vbox_new (FALSE, 0);
3769 gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 5);
3771 label = gtk_label_new ("Month :");
3772 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
3773 gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, TRUE, 0);
3775 adj = (GtkAdjustment *) gtk_adjustment_new (1.0, 1.0, 12.0, 1.0,
3777 spinner = gtk_spin_button_new (adj, 0, 0);
3778 gtk_spin_button_set_update_policy (GTK_SPIN_BUTTON (spinner),
3779 GTK_UPDATE_IF_VALID);
3780 gtk_signal_connect (GTK_OBJECT (spinner),
3782 GTK_SIGNAL_FUNC (spin_button_month_input_func),
3784 gtk_signal_connect (GTK_OBJECT (spinner),
3786 GTK_SIGNAL_FUNC (spin_button_month_output_func),
3788 gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spinner), TRUE);
3789 gtk_widget_set_usize (spinner, 85, -1);
3790 gtk_box_pack_start (GTK_BOX (vbox2), spinner, FALSE, TRUE, 0);
3792 vbox2 = gtk_vbox_new (FALSE, 0);
3793 gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 5);
3795 label = gtk_label_new ("Hex :");
3796 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
3797 gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, TRUE, 0);
3799 adj = (GtkAdjustment *) gtk_adjustment_new (0, 0, 255, 1, 16, 0);
3800 spinner = gtk_spin_button_new (adj, 0, 0);
3801 gtk_editable_set_editable (GTK_EDITABLE (spinner), TRUE);
3802 gtk_signal_connect (GTK_OBJECT (spinner),
3804 GTK_SIGNAL_FUNC (spin_button_hex_input_func),
3806 gtk_signal_connect (GTK_OBJECT (spinner),
3808 GTK_SIGNAL_FUNC (spin_button_hex_output_func),
3810 gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spinner), TRUE);
3811 gtk_widget_set_usize (spinner, 55, 0);
3812 gtk_box_pack_start (GTK_BOX (vbox2), spinner, FALSE, TRUE, 0);
3814 frame = gtk_frame_new ("Accelerated");
3815 gtk_box_pack_start (GTK_BOX (main_vbox), frame, TRUE, TRUE, 0);
3817 vbox = gtk_vbox_new (FALSE, 0);
3818 gtk_container_set_border_width (GTK_CONTAINER (vbox), 5);
3819 gtk_container_add (GTK_CONTAINER (frame), vbox);
3821 hbox = gtk_hbox_new (FALSE, 0);
3822 gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 5);
3824 vbox2 = gtk_vbox_new (FALSE, 0);
3825 gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 5);
3827 label = gtk_label_new ("Value :");
3828 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
3829 gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, TRUE, 0);
3831 adj = (GtkAdjustment *) gtk_adjustment_new (0.0, -10000.0, 10000.0,
3833 spinner1 = gtk_spin_button_new (adj, 1.0, 2);
3834 gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spinner1), TRUE);
3835 gtk_widget_set_usize (spinner1, 100, 0);
3836 gtk_box_pack_start (GTK_BOX (vbox2), spinner1, FALSE, TRUE, 0);
3838 vbox2 = gtk_vbox_new (FALSE, 0);
3839 gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 5);
3841 label = gtk_label_new ("Digits :");
3842 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
3843 gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, TRUE, 0);
3845 adj = (GtkAdjustment *) gtk_adjustment_new (2, 1, 5, 1, 1, 0);
3846 spinner2 = gtk_spin_button_new (adj, 0.0, 0);
3847 gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
3848 GTK_SIGNAL_FUNC (change_digits),
3849 (gpointer) spinner2);
3850 gtk_box_pack_start (GTK_BOX (vbox2), spinner2, FALSE, TRUE, 0);
3852 hbox = gtk_hbox_new (FALSE, 0);
3853 gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 5);
3855 button = gtk_check_button_new_with_label ("Snap to 0.5-ticks");
3856 gtk_signal_connect (GTK_OBJECT (button), "clicked",
3857 GTK_SIGNAL_FUNC (toggle_snap),
3859 gtk_box_pack_start (GTK_BOX (vbox), button, TRUE, TRUE, 0);
3860 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
3862 button = gtk_check_button_new_with_label ("Numeric only input mode");
3863 gtk_signal_connect (GTK_OBJECT (button), "clicked",
3864 GTK_SIGNAL_FUNC (toggle_numeric),
3866 gtk_box_pack_start (GTK_BOX (vbox), button, TRUE, TRUE, 0);
3867 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
3869 val_label = gtk_label_new ("");
3871 hbox = gtk_hbox_new (FALSE, 0);
3872 gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 5);
3874 button = gtk_button_new_with_label ("Value as Int");
3875 gtk_object_set_user_data (GTK_OBJECT (button), val_label);
3876 gtk_signal_connect (GTK_OBJECT (button), "clicked",
3877 GTK_SIGNAL_FUNC (get_value),
3878 GINT_TO_POINTER (1));
3879 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
3881 button = gtk_button_new_with_label ("Value as Float");
3882 gtk_object_set_user_data (GTK_OBJECT (button), val_label);
3883 gtk_signal_connect (GTK_OBJECT (button), "clicked",
3884 GTK_SIGNAL_FUNC (get_value),
3885 GINT_TO_POINTER (2));
3886 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
3888 gtk_box_pack_start (GTK_BOX (vbox), val_label, TRUE, TRUE, 0);
3889 gtk_label_set_text (GTK_LABEL (val_label), "0");
3891 hbox = gtk_hbox_new (FALSE, 0);
3892 gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, TRUE, 0);
3894 button = gtk_button_new_with_label ("Close");
3895 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
3896 GTK_SIGNAL_FUNC (gtk_widget_destroy),
3897 GTK_OBJECT (window));
3898 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
3901 if (!GTK_WIDGET_VISIBLE (window))
3902 gtk_widget_show_all (window);
3904 gtk_widget_destroy (window);
3913 cursor_expose_event (GtkWidget *widget,
3917 GtkDrawingArea *darea;
3918 GdkDrawable *drawable;
3925 g_return_val_if_fail (widget != NULL, TRUE);
3926 g_return_val_if_fail (GTK_IS_DRAWING_AREA (widget), TRUE);
3928 darea = GTK_DRAWING_AREA (widget);
3929 drawable = widget->window;
3930 white_gc = widget->style->white_gc;
3931 gray_gc = widget->style->bg_gc[GTK_STATE_NORMAL];
3932 black_gc = widget->style->black_gc;
3933 max_width = widget->allocation.width;
3934 max_height = widget->allocation.height;
3936 gdk_draw_rectangle (drawable, white_gc,
3943 gdk_draw_rectangle (drawable, black_gc,
3950 gdk_draw_rectangle (drawable, gray_gc,
3961 set_cursor (GtkWidget *spinner,
3969 c = CLAMP (gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (spinner)), 0, 152);
3972 label = gtk_object_get_user_data (GTK_OBJECT (spinner));
3973 vals = gtk_type_enum_get_values (GTK_TYPE_GDK_CURSOR_TYPE);
3974 while (vals && vals->value != c)
3977 gtk_label_set_text (GTK_LABEL (label), vals->value_nick);
3979 gtk_label_set_text (GTK_LABEL (label), "<unknown>");
3981 cursor = gdk_cursor_new (c);
3982 gdk_window_set_cursor (widget->window, cursor);
3983 gdk_cursor_unref (cursor);
3987 cursor_event (GtkWidget *widget,
3989 GtkSpinButton *spinner)
3991 if ((event->type == GDK_BUTTON_PRESS) &&
3992 ((event->button.button == 1) ||
3993 (event->button.button == 3)))
3995 gtk_spin_button_spin (spinner, event->button.button == 1 ?
3996 GTK_SPIN_STEP_FORWARD : GTK_SPIN_STEP_BACKWARD, 0);
4004 create_cursors (void)
4006 static GtkWidget *window = NULL;
4009 GtkWidget *main_vbox;
4020 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
4022 gtk_signal_connect (GTK_OBJECT (window), "destroy",
4023 GTK_SIGNAL_FUNC (gtk_widget_destroyed),
4026 gtk_window_set_title (GTK_WINDOW (window), "Cursors");
4028 main_vbox = gtk_vbox_new (FALSE, 5);
4029 gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 0);
4030 gtk_container_add (GTK_CONTAINER (window), main_vbox);
4033 gtk_widget_new (gtk_vbox_get_type (),
4034 "GtkBox::homogeneous", FALSE,
4035 "GtkBox::spacing", 5,
4036 "GtkContainer::border_width", 10,
4037 "GtkWidget::parent", main_vbox,
4038 "GtkWidget::visible", TRUE,
4041 hbox = gtk_hbox_new (FALSE, 0);
4042 gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
4043 gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0);
4045 label = gtk_label_new ("Cursor Value : ");
4046 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
4047 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
4049 adj = (GtkAdjustment *) gtk_adjustment_new (0,
4053 spinner = gtk_spin_button_new (adj, 0, 0);
4054 gtk_box_pack_start (GTK_BOX (hbox), spinner, TRUE, TRUE, 0);
4057 gtk_widget_new (gtk_frame_get_type (),
4058 "GtkFrame::shadow", GTK_SHADOW_ETCHED_IN,
4059 "GtkFrame::label_xalign", 0.5,
4060 "GtkFrame::label", "Cursor Area",
4061 "GtkContainer::border_width", 10,
4062 "GtkWidget::parent", vbox,
4063 "GtkWidget::visible", TRUE,
4066 darea = gtk_drawing_area_new ();
4067 gtk_widget_set_usize (darea, 80, 80);
4068 gtk_container_add (GTK_CONTAINER (frame), darea);
4069 gtk_signal_connect (GTK_OBJECT (darea),
4071 GTK_SIGNAL_FUNC (cursor_expose_event),
4073 gtk_widget_set_events (darea, GDK_EXPOSURE_MASK | GDK_BUTTON_PRESS_MASK);
4074 gtk_signal_connect (GTK_OBJECT (darea),
4075 "button_press_event",
4076 GTK_SIGNAL_FUNC (cursor_event),
4078 gtk_widget_show (darea);
4080 gtk_signal_connect (GTK_OBJECT (spinner), "changed",
4081 GTK_SIGNAL_FUNC (set_cursor),
4084 label = gtk_widget_new (GTK_TYPE_LABEL,
4089 gtk_container_child_set (GTK_CONTAINER (vbox), label,
4092 gtk_object_set_user_data (GTK_OBJECT (spinner), label);
4095 gtk_widget_new (gtk_hseparator_get_type (),
4096 "GtkWidget::visible", TRUE,
4098 gtk_box_pack_start (GTK_BOX (main_vbox), any, FALSE, TRUE, 0);
4100 hbox = gtk_hbox_new (FALSE, 0);
4101 gtk_container_set_border_width (GTK_CONTAINER (hbox), 10);
4102 gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, TRUE, 0);
4104 button = gtk_button_new_with_label ("Close");
4105 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
4106 GTK_SIGNAL_FUNC (gtk_widget_destroy),
4107 GTK_OBJECT (window));
4108 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
4110 gtk_widget_show_all (window);
4112 set_cursor (spinner, darea);
4115 gtk_widget_destroy (window);
4123 list_add (GtkWidget *widget,
4128 GtkWidget *list_item;
4129 GtkContainer *container;
4131 container = GTK_CONTAINER (list);
4133 sprintf (buffer, "added item %d", i++);
4134 list_item = gtk_list_item_new_with_label (buffer);
4135 gtk_widget_show (list_item);
4137 gtk_container_add (container, list_item);
4141 list_remove (GtkWidget *widget,
4144 GList *clear_list = NULL;
4145 GList *sel_row = NULL;
4148 if (list->selection_mode == GTK_SELECTION_EXTENDED)
4152 item = GTK_CONTAINER (list)->focus_child;
4153 if (!item && list->selection)
4154 item = list->selection->data;
4158 work = g_list_find (list->children, item);
4159 for (sel_row = work; sel_row; sel_row = sel_row->next)
4160 if (GTK_WIDGET (sel_row->data)->state != GTK_STATE_SELECTED)
4165 for (sel_row = work; sel_row; sel_row = sel_row->prev)
4166 if (GTK_WIDGET (sel_row->data)->state != GTK_STATE_SELECTED)
4172 for (work = list->selection; work; work = work->next)
4173 clear_list = g_list_prepend (clear_list, work->data);
4175 clear_list = g_list_reverse (clear_list);
4176 gtk_list_remove_items (GTK_LIST (list), clear_list);
4177 g_list_free (clear_list);
4179 if (list->selection_mode == GTK_SELECTION_EXTENDED && sel_row)
4180 gtk_list_select_child (list, GTK_WIDGET(sel_row->data));
4184 list_clear (GtkWidget *widget,
4187 gtk_list_clear_items (GTK_LIST (list), 0, -1);
4190 #define RADIOMENUTOGGLED(_rmi_, __i) { \
4193 __g = gtk_radio_menu_item_group(_rmi_); \
4194 while( __g && !((GtkCheckMenuItem *)(__g->data))->active) { \
4200 static GtkWidget *list_omenu;
4203 list_toggle_sel_mode (GtkWidget *widget, GtkList *list)
4207 if (!GTK_WIDGET_MAPPED (widget))
4210 RADIOMENUTOGGLED ((GtkRadioMenuItem *)
4211 (((GtkOptionMenu *)list_omenu)->menu_item), i);
4213 gtk_list_set_selection_mode (list, (GtkSelectionMode) (3-i));
4219 static GtkWidget *window = NULL;
4221 static OptionMenuItem items[] =
4223 { "Single", list_toggle_sel_mode },
4224 { "Browse", list_toggle_sel_mode },
4225 { "Multiple", list_toggle_sel_mode },
4226 { "Extended", list_toggle_sel_mode }
4235 GtkWidget *scrolled_win;
4238 GtkWidget *separator;
4241 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
4243 gtk_signal_connect (GTK_OBJECT (window), "destroy",
4244 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
4247 gtk_window_set_title (GTK_WINDOW (window), "list");
4248 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
4250 vbox = gtk_vbox_new (FALSE, 0);
4251 gtk_container_add (GTK_CONTAINER (window), vbox);
4253 scrolled_win = gtk_scrolled_window_new (NULL, NULL);
4254 gtk_container_set_border_width (GTK_CONTAINER (scrolled_win), 5);
4255 gtk_widget_set_usize (scrolled_win, -1, 300);
4256 gtk_box_pack_start (GTK_BOX (vbox), scrolled_win, TRUE, TRUE, 0);
4257 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
4258 GTK_POLICY_AUTOMATIC,
4259 GTK_POLICY_AUTOMATIC);
4261 list = gtk_list_new ();
4262 gtk_list_set_selection_mode (GTK_LIST (list), GTK_SELECTION_EXTENDED);
4263 gtk_scrolled_window_add_with_viewport
4264 (GTK_SCROLLED_WINDOW (scrolled_win), list);
4265 gtk_container_set_focus_vadjustment
4266 (GTK_CONTAINER (list),
4267 gtk_scrolled_window_get_vadjustment
4268 (GTK_SCROLLED_WINDOW (scrolled_win)));
4269 gtk_container_set_focus_hadjustment
4270 (GTK_CONTAINER (list),
4271 gtk_scrolled_window_get_hadjustment
4272 (GTK_SCROLLED_WINDOW (scrolled_win)));
4274 if ((infile = fopen("gtkenums.h", "r")))
4280 while (fgets (buffer, 256, infile))
4282 if ((pos = strchr (buffer, '\n')))
4284 item = gtk_list_item_new_with_label (buffer);
4285 gtk_container_add (GTK_CONTAINER (list), item);
4292 hbox = gtk_hbox_new (TRUE, 5);
4293 gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
4294 gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0);
4296 button = gtk_button_new_with_label ("Insert Row");
4297 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
4298 gtk_signal_connect (GTK_OBJECT (button), "clicked",
4299 GTK_SIGNAL_FUNC (list_add),
4302 button = gtk_button_new_with_label ("Clear List");
4303 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
4304 gtk_signal_connect (GTK_OBJECT (button), "clicked",
4305 GTK_SIGNAL_FUNC (list_clear),
4308 button = gtk_button_new_with_label ("Remove Selection");
4309 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
4310 gtk_signal_connect (GTK_OBJECT (button), "clicked",
4311 GTK_SIGNAL_FUNC (list_remove),
4314 cbox = gtk_hbox_new (FALSE, 0);
4315 gtk_box_pack_start (GTK_BOX (vbox), cbox, FALSE, TRUE, 0);
4317 hbox = gtk_hbox_new (FALSE, 5);
4318 gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
4319 gtk_box_pack_start (GTK_BOX (cbox), hbox, TRUE, FALSE, 0);
4321 label = gtk_label_new ("Selection Mode :");
4322 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
4324 list_omenu = build_option_menu (items, 4, 3, list);
4325 gtk_box_pack_start (GTK_BOX (hbox), list_omenu, FALSE, TRUE, 0);
4327 separator = gtk_hseparator_new ();
4328 gtk_box_pack_start (GTK_BOX (vbox), separator, FALSE, TRUE, 0);
4330 cbox = gtk_hbox_new (FALSE, 0);
4331 gtk_box_pack_start (GTK_BOX (vbox), cbox, FALSE, TRUE, 0);
4333 button = gtk_button_new_with_label ("close");
4334 gtk_container_set_border_width (GTK_CONTAINER (button), 10);
4335 gtk_box_pack_start (GTK_BOX (cbox), button, TRUE, TRUE, 0);
4336 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
4337 GTK_SIGNAL_FUNC(gtk_widget_destroy),
4338 GTK_OBJECT (window));
4340 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
4341 gtk_widget_grab_default (button);
4344 if (!GTK_WIDGET_VISIBLE (window))
4345 gtk_widget_show_all (window);
4347 gtk_widget_destroy (window);
4354 static char * book_open_xpm[] = {
4377 static char * book_closed_xpm[] = {
4402 static char * mini_page_xpm[] = {
4425 static char * gtk_mini_xpm[] = {
4465 #define TESTGTK_CLIST_COLUMNS 12
4466 static gint clist_rows = 0;
4467 static GtkWidget *clist_omenu;
4470 add1000_clist (GtkWidget *widget, gpointer data)
4473 char text[TESTGTK_CLIST_COLUMNS][50];
4474 char *texts[TESTGTK_CLIST_COLUMNS];
4479 clist = GTK_CLIST (data);
4481 pixmap = gdk_pixmap_create_from_xpm_d (clist->clist_window,
4483 >K_WIDGET (data)->style->white,
4486 for (i = 0; i < TESTGTK_CLIST_COLUMNS; i++)
4489 sprintf (text[i], "Column %d", i);
4493 sprintf (text[1], "Right");
4494 sprintf (text[2], "Center");
4496 gtk_clist_freeze (GTK_CLIST (data));
4497 for (i = 0; i < 1000; i++)
4499 sprintf (text[0], "CListRow %d", rand() % 10000);
4500 row = gtk_clist_append (clist, texts);
4501 gtk_clist_set_pixtext (clist, row, 3, "gtk+", 5, pixmap, mask);
4504 gtk_clist_thaw (GTK_CLIST (data));
4506 gdk_pixmap_unref (pixmap);
4507 gdk_bitmap_unref (mask);
4511 add10000_clist (GtkWidget *widget, gpointer data)
4514 char text[TESTGTK_CLIST_COLUMNS][50];
4515 char *texts[TESTGTK_CLIST_COLUMNS];
4517 for (i = 0; i < TESTGTK_CLIST_COLUMNS; i++)
4520 sprintf (text[i], "Column %d", i);
4523 sprintf (text[1], "Right");
4524 sprintf (text[2], "Center");
4526 gtk_clist_freeze (GTK_CLIST (data));
4527 for (i = 0; i < 10000; i++)
4529 sprintf (text[0], "CListRow %d", rand() % 10000);
4530 gtk_clist_append (GTK_CLIST (data), texts);
4532 gtk_clist_thaw (GTK_CLIST (data));
4536 clear_clist (GtkWidget *widget, gpointer data)
4538 gtk_clist_clear (GTK_CLIST (data));
4542 void clist_remove_selection (GtkWidget *widget, GtkCList *clist)
4544 gtk_clist_freeze (clist);
4546 while (clist->selection)
4551 row = GPOINTER_TO_INT (clist->selection->data);
4553 gtk_clist_remove (clist, row);
4555 if (clist->selection_mode == GTK_SELECTION_BROWSE)
4559 if (clist->selection_mode == GTK_SELECTION_EXTENDED && !clist->selection &&
4560 clist->focus_row >= 0)
4561 gtk_clist_select_row (clist, clist->focus_row, -1);
4563 gtk_clist_thaw (clist);
4566 void toggle_title_buttons (GtkWidget *widget, GtkCList *clist)
4568 if (GTK_TOGGLE_BUTTON (widget)->active)
4569 gtk_clist_column_titles_show (clist);
4571 gtk_clist_column_titles_hide (clist);
4574 void toggle_reorderable (GtkWidget *widget, GtkCList *clist)
4576 gtk_clist_set_reorderable (clist, GTK_TOGGLE_BUTTON (widget)->active);
4580 insert_row_clist (GtkWidget *widget, gpointer data)
4582 static char *text[] =
4584 "This", "is an", "inserted", "row.",
4585 "This", "is an", "inserted", "row.",
4586 "This", "is an", "inserted", "row."
4589 static GtkStyle *style1 = NULL;
4590 static GtkStyle *style2 = NULL;
4591 static GtkStyle *style3 = NULL;
4594 if (GTK_CLIST (data)->focus_row >= 0)
4595 row = gtk_clist_insert (GTK_CLIST (data), GTK_CLIST (data)->focus_row,
4598 row = gtk_clist_prepend (GTK_CLIST (data), text);
4612 style1 = gtk_style_copy (GTK_WIDGET (data)->style);
4613 style1->base[GTK_STATE_NORMAL] = col1;
4614 style1->base[GTK_STATE_SELECTED] = col2;
4616 style2 = gtk_style_copy (GTK_WIDGET (data)->style);
4617 style2->fg[GTK_STATE_NORMAL] = col1;
4618 style2->fg[GTK_STATE_SELECTED] = col2;
4620 style3 = gtk_style_copy (GTK_WIDGET (data)->style);
4621 style3->fg[GTK_STATE_NORMAL] = col1;
4622 style3->base[GTK_STATE_NORMAL] = col2;
4623 pango_font_description_free (style3->font_desc);
4624 style3->font_desc = pango_font_description_from_string ("courier 12");
4627 gtk_clist_set_cell_style (GTK_CLIST (data), row, 3, style1);
4628 gtk_clist_set_cell_style (GTK_CLIST (data), row, 4, style2);
4629 gtk_clist_set_cell_style (GTK_CLIST (data), row, 0, style3);
4635 clist_warning_test (GtkWidget *button,
4639 static gboolean add_remove = FALSE;
4641 add_remove = !add_remove;
4643 child = gtk_label_new ("Test");
4644 gtk_widget_ref (child);
4645 gtk_object_sink (GTK_OBJECT (child));
4648 gtk_container_add (GTK_CONTAINER (clist), child);
4651 child->parent = clist;
4652 gtk_container_remove (GTK_CONTAINER (clist), child);
4653 child->parent = NULL;
4656 gtk_widget_destroy (child);
4657 gtk_widget_unref (child);
4661 undo_selection (GtkWidget *button, GtkCList *clist)
4663 gtk_clist_undo_selection (clist);
4667 clist_toggle_sel_mode (GtkWidget *widget, GtkCList *clist)
4671 if (!GTK_WIDGET_MAPPED (widget))
4674 RADIOMENUTOGGLED ((GtkRadioMenuItem *)
4675 (((GtkOptionMenu *)clist_omenu)->menu_item), i);
4677 gtk_clist_set_selection_mode (clist, (GtkSelectionMode) (3-i));
4681 clist_click_column (GtkCList *clist, gint column, gpointer data)
4684 gtk_clist_set_column_visibility (clist, column, FALSE);
4685 else if (column == clist->sort_column)
4687 if (clist->sort_type == GTK_SORT_ASCENDING)
4688 clist->sort_type = GTK_SORT_DESCENDING;
4690 clist->sort_type = GTK_SORT_ASCENDING;
4693 gtk_clist_set_sort_column (clist, column);
4695 gtk_clist_sort (clist);
4702 static GtkWidget *window = NULL;
4704 static char *titles[] =
4706 "auto resize", "not resizeable", "max width 100", "min width 50",
4707 "hide column", "Title 5", "Title 6", "Title 7",
4708 "Title 8", "Title 9", "Title 10", "Title 11"
4711 static OptionMenuItem items[] =
4713 { "Single", clist_toggle_sel_mode },
4714 { "Browse", clist_toggle_sel_mode },
4715 { "Multiple", clist_toggle_sel_mode },
4716 { "Extended", clist_toggle_sel_mode }
4719 char text[TESTGTK_CLIST_COLUMNS][50];
4720 char *texts[TESTGTK_CLIST_COLUMNS];
4726 GtkWidget *separator;
4727 GtkWidget *scrolled_win;
4730 GtkWidget *undo_button;
4740 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
4742 gtk_signal_connect (GTK_OBJECT (window), "destroy",
4743 GTK_SIGNAL_FUNC (gtk_widget_destroyed), &window);
4745 gtk_window_set_title (GTK_WINDOW (window), "clist");
4746 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
4748 vbox = gtk_vbox_new (FALSE, 0);
4749 gtk_container_add (GTK_CONTAINER (window), vbox);
4751 scrolled_win = gtk_scrolled_window_new (NULL, NULL);
4752 gtk_container_set_border_width (GTK_CONTAINER (scrolled_win), 5);
4753 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
4754 GTK_POLICY_AUTOMATIC,
4755 GTK_POLICY_AUTOMATIC);
4757 /* create GtkCList here so we have a pointer to throw at the
4758 * button callbacks -- more is done with it later */
4759 clist = gtk_clist_new_with_titles (TESTGTK_CLIST_COLUMNS, titles);
4760 gtk_container_add (GTK_CONTAINER (scrolled_win), clist);
4761 gtk_signal_connect (GTK_OBJECT (clist), "click_column",
4762 (GtkSignalFunc) clist_click_column, NULL);
4764 /* control buttons */
4765 hbox = gtk_hbox_new (FALSE, 5);
4766 gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
4767 gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
4769 button = gtk_button_new_with_label ("Insert Row");
4770 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
4771 gtk_signal_connect (GTK_OBJECT (button), "clicked",
4772 (GtkSignalFunc) insert_row_clist, (gpointer) clist);
4774 button = gtk_button_new_with_label ("Add 1,000 Rows With Pixmaps");
4775 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
4776 gtk_signal_connect (GTK_OBJECT (button), "clicked",
4777 (GtkSignalFunc) add1000_clist, (gpointer) clist);
4779 button = gtk_button_new_with_label ("Add 10,000 Rows");
4780 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
4781 gtk_signal_connect (GTK_OBJECT (button), "clicked",
4782 (GtkSignalFunc) add10000_clist, (gpointer) clist);
4784 /* second layer of buttons */
4785 hbox = gtk_hbox_new (FALSE, 5);
4786 gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
4787 gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
4789 button = gtk_button_new_with_label ("Clear List");
4790 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
4791 gtk_signal_connect (GTK_OBJECT (button), "clicked",
4792 (GtkSignalFunc) clear_clist, (gpointer) clist);
4794 button = gtk_button_new_with_label ("Remove Selection");
4795 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
4796 gtk_signal_connect (GTK_OBJECT (button), "clicked",
4797 (GtkSignalFunc) clist_remove_selection,
4800 undo_button = gtk_button_new_with_label ("Undo Selection");
4801 gtk_box_pack_start (GTK_BOX (hbox), undo_button, TRUE, TRUE, 0);
4802 gtk_signal_connect (GTK_OBJECT (undo_button), "clicked",
4803 (GtkSignalFunc) undo_selection, (gpointer) clist);
4805 button = gtk_button_new_with_label ("Warning Test");
4806 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
4807 gtk_signal_connect (GTK_OBJECT (button), "clicked",
4808 (GtkSignalFunc) clist_warning_test,(gpointer) clist);
4810 /* third layer of buttons */
4811 hbox = gtk_hbox_new (FALSE, 5);
4812 gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
4813 gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
4815 check = gtk_check_button_new_with_label ("Show Title Buttons");
4816 gtk_box_pack_start (GTK_BOX (hbox), check, FALSE, TRUE, 0);
4817 gtk_signal_connect (GTK_OBJECT (check), "clicked",
4818 GTK_SIGNAL_FUNC (toggle_title_buttons), clist);
4819 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check), TRUE);
4821 check = gtk_check_button_new_with_label ("Reorderable");
4822 gtk_box_pack_start (GTK_BOX (hbox), check, FALSE, TRUE, 0);
4823 gtk_signal_connect (GTK_OBJECT (check), "clicked",
4824 GTK_SIGNAL_FUNC (toggle_reorderable), clist);
4825 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check), TRUE);
4827 label = gtk_label_new ("Selection Mode :");
4828 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
4830 clist_omenu = build_option_menu (items, 4, 3, clist);
4831 gtk_box_pack_start (GTK_BOX (hbox), clist_omenu, FALSE, TRUE, 0);
4834 * the rest of the clist configuration
4837 gtk_box_pack_start (GTK_BOX (vbox), scrolled_win, TRUE, TRUE, 0);
4838 gtk_clist_set_row_height (GTK_CLIST (clist), 18);
4839 gtk_widget_set_usize (clist, -1, 300);
4841 for (i = 1; i < TESTGTK_CLIST_COLUMNS; i++)
4842 gtk_clist_set_column_width (GTK_CLIST (clist), i, 80);
4844 gtk_clist_set_column_auto_resize (GTK_CLIST (clist), 0, TRUE);
4845 gtk_clist_set_column_resizeable (GTK_CLIST (clist), 1, FALSE);
4846 gtk_clist_set_column_max_width (GTK_CLIST (clist), 2, 100);
4847 gtk_clist_set_column_min_width (GTK_CLIST (clist), 3, 50);
4848 gtk_clist_set_selection_mode (GTK_CLIST (clist), GTK_SELECTION_EXTENDED);
4849 gtk_clist_set_column_justification (GTK_CLIST (clist), 1,
4851 gtk_clist_set_column_justification (GTK_CLIST (clist), 2,
4852 GTK_JUSTIFY_CENTER);
4854 for (i = 0; i < TESTGTK_CLIST_COLUMNS; i++)
4857 sprintf (text[i], "Column %d", i);
4860 sprintf (text[1], "Right");
4861 sprintf (text[2], "Center");
4870 style = gtk_style_new ();
4871 style->fg[GTK_STATE_NORMAL] = col1;
4872 style->base[GTK_STATE_NORMAL] = col2;
4874 style->font_desc->size = 14 * PANGO_SCALE;
4875 style->font_desc->weight = PANGO_WEIGHT_BOLD;
4877 for (i = 0; i < 10; i++)
4879 sprintf (text[0], "CListRow %d", clist_rows++);
4880 gtk_clist_append (GTK_CLIST (clist), texts);
4885 gtk_clist_set_row_style (GTK_CLIST (clist), i, style);
4888 gtk_clist_set_cell_style (GTK_CLIST (clist), i, i % 4, style);
4893 gtk_style_unref (style);
4895 separator = gtk_hseparator_new ();
4896 gtk_box_pack_start (GTK_BOX (vbox), separator, FALSE, TRUE, 0);
4898 hbox = gtk_hbox_new (FALSE, 0);
4899 gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0);
4901 button = gtk_button_new_with_label ("close");
4902 gtk_container_set_border_width (GTK_CONTAINER (button), 10);
4903 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
4904 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
4905 GTK_SIGNAL_FUNC(gtk_widget_destroy),
4906 GTK_OBJECT (window));
4908 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
4909 gtk_widget_grab_default (button);
4912 if (!GTK_WIDGET_VISIBLE (window))
4913 gtk_widget_show_all (window);
4917 gtk_widget_destroy (window);
4932 static gint books = 0;
4933 static gint pages = 0;
4935 static GtkWidget *book_label;
4936 static GtkWidget *page_label;
4937 static GtkWidget *sel_label;
4938 static GtkWidget *vis_label;
4939 static GtkWidget *omenu1;
4940 static GtkWidget *omenu2;
4941 static GtkWidget *omenu3;
4942 static GtkWidget *omenu4;
4943 static GtkWidget *spin1;
4944 static GtkWidget *spin2;
4945 static GtkWidget *spin3;
4946 static gint line_style;
4948 void after_press (GtkCTree *ctree, gpointer data)
4952 sprintf (buf, "%d", g_list_length (GTK_CLIST (ctree)->selection));
4953 gtk_label_set_text (GTK_LABEL (sel_label), buf);
4955 sprintf (buf, "%d", g_list_length (GTK_CLIST (ctree)->row_list));
4956 gtk_label_set_text (GTK_LABEL (vis_label), buf);
4958 sprintf (buf, "%d", books);
4959 gtk_label_set_text (GTK_LABEL (book_label), buf);
4961 sprintf (buf, "%d", pages);
4962 gtk_label_set_text (GTK_LABEL (page_label), buf);
4965 void after_move (GtkCTree *ctree, GtkCTreeNode *child, GtkCTreeNode *parent,
4966 GtkCTreeNode *sibling, gpointer data)
4972 gtk_ctree_get_node_info (ctree, child, &source,
4973 NULL, NULL, NULL, NULL, NULL, NULL, NULL);
4975 gtk_ctree_get_node_info (ctree, parent, &target1,
4976 NULL, NULL, NULL, NULL, NULL, NULL, NULL);
4978 gtk_ctree_get_node_info (ctree, sibling, &target2,
4979 NULL, NULL, NULL, NULL, NULL, NULL, NULL);
4981 g_print ("Moving \"%s\" to \"%s\" with sibling \"%s\".\n", source,
4982 (parent) ? target1 : "nil", (sibling) ? target2 : "nil");
4985 void count_items (GtkCTree *ctree, GtkCTreeNode *list)
4987 if (GTK_CTREE_ROW (list)->is_leaf)
4993 void expand_all (GtkWidget *widget, GtkCTree *ctree)
4995 gtk_ctree_expand_recursive (ctree, NULL);
4996 after_press (ctree, NULL);
4999 void collapse_all (GtkWidget *widget, GtkCTree *ctree)
5001 gtk_ctree_collapse_recursive (ctree, NULL);
5002 after_press (ctree, NULL);
5005 void select_all (GtkWidget *widget, GtkCTree *ctree)
5007 gtk_ctree_select_recursive (ctree, NULL);
5008 after_press (ctree, NULL);
5011 void change_style (GtkWidget *widget, GtkCTree *ctree)
5013 static GtkStyle *style1 = NULL;
5014 static GtkStyle *style2 = NULL;
5020 if (GTK_CLIST (ctree)->focus_row >= 0)
5021 node = GTK_CTREE_NODE
5022 (g_list_nth (GTK_CLIST (ctree)->row_list,GTK_CLIST (ctree)->focus_row));
5024 node = GTK_CTREE_NODE (GTK_CLIST (ctree)->row_list);
5038 style1 = gtk_style_new ();
5039 style1->base[GTK_STATE_NORMAL] = col1;
5040 style1->fg[GTK_STATE_SELECTED] = col2;
5042 style2 = gtk_style_new ();
5043 style2->base[GTK_STATE_SELECTED] = col2;
5044 style2->fg[GTK_STATE_NORMAL] = col1;
5045 style2->base[GTK_STATE_NORMAL] = col2;
5046 pango_font_description_free (style2->font_desc);
5047 style2->font_desc = pango_font_description_from_string ("courier 30");
5050 gtk_ctree_node_set_cell_style (ctree, node, 1, style1);
5051 gtk_ctree_node_set_cell_style (ctree, node, 0, style2);
5053 if (GTK_CTREE_ROW (node)->children)
5054 gtk_ctree_node_set_row_style (ctree, GTK_CTREE_ROW (node)->children,
5058 void unselect_all (GtkWidget *widget, GtkCTree *ctree)
5060 gtk_ctree_unselect_recursive (ctree, NULL);
5061 after_press (ctree, NULL);
5064 void remove_selection (GtkWidget *widget, GtkCTree *ctree)
5069 clist = GTK_CLIST (ctree);
5071 gtk_clist_freeze (clist);
5073 while (clist->selection)
5075 node = clist->selection->data;
5077 if (GTK_CTREE_ROW (node)->is_leaf)
5080 gtk_ctree_post_recursive (ctree, node,
5081 (GtkCTreeFunc) count_items, NULL);
5083 gtk_ctree_remove_node (ctree, node);
5085 if (clist->selection_mode == GTK_SELECTION_BROWSE)
5089 if (clist->selection_mode == GTK_SELECTION_EXTENDED && !clist->selection &&
5090 clist->focus_row >= 0)
5092 node = gtk_ctree_node_nth (ctree, clist->focus_row);
5095 gtk_ctree_select (ctree, node);
5098 gtk_clist_thaw (clist);
5099 after_press (ctree, NULL);
5102 struct _ExportStruct {
5108 typedef struct _ExportStruct ExportStruct;
5111 gnode2ctree (GtkCTree *ctree,
5114 GtkCTreeNode *cnode,
5118 GdkPixmap *pixmap_closed;
5119 GdkBitmap *mask_closed;
5120 GdkPixmap *pixmap_opened;
5121 GdkBitmap *mask_opened;
5123 if (!cnode || !gnode || (!(es = gnode->data)))
5128 pixmap_closed = pixmap3;
5129 mask_closed = mask3;
5130 pixmap_opened = NULL;
5135 pixmap_closed = pixmap1;
5136 mask_closed = mask1;
5137 pixmap_opened = pixmap2;
5138 mask_opened = mask2;
5141 gtk_ctree_set_node_info (ctree, cnode, es->tree, 2, pixmap_closed,
5142 mask_closed, pixmap_opened, mask_opened,
5143 es->is_leaf, (depth < 3));
5144 gtk_ctree_node_set_text (ctree, cnode, 1, es->info);
5152 ctree2gnode (GtkCTree *ctree,
5155 GtkCTreeNode *cnode,
5160 if (!cnode || !gnode)
5163 es = g_new (ExportStruct, 1);
5165 es->is_leaf = GTK_CTREE_ROW (cnode)->is_leaf;
5166 es->tree = GTK_CELL_PIXTEXT (GTK_CTREE_ROW (cnode)->row.cell[0])->text;
5167 es->info = GTK_CELL_PIXTEXT (GTK_CTREE_ROW (cnode)->row.cell[1])->text;
5171 void export_ctree (GtkWidget *widget, GtkCTree *ctree)
5173 char *title[] = { "Tree" , "Info" };
5174 static GtkWidget *export_window = NULL;
5175 static GtkCTree *export_ctree;
5177 GtkWidget *scrolled_win;
5185 export_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
5187 gtk_signal_connect (GTK_OBJECT (export_window), "destroy",
5188 GTK_SIGNAL_FUNC (gtk_widget_destroyed),
5191 gtk_window_set_title (GTK_WINDOW (export_window), "exported ctree");
5192 gtk_container_set_border_width (GTK_CONTAINER (export_window), 5);
5194 vbox = gtk_vbox_new (FALSE, 0);
5195 gtk_container_add (GTK_CONTAINER (export_window), vbox);
5197 button = gtk_button_new_with_label ("Close");
5198 gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, TRUE, 0);
5200 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
5201 (GtkSignalFunc) gtk_widget_destroy,
5202 GTK_OBJECT(export_window));
5204 sep = gtk_hseparator_new ();
5205 gtk_box_pack_end (GTK_BOX (vbox), sep, FALSE, TRUE, 10);
5207 export_ctree = GTK_CTREE (gtk_ctree_new_with_titles (2, 0, title));
5208 gtk_ctree_set_line_style (export_ctree, GTK_CTREE_LINES_DOTTED);
5210 scrolled_win = gtk_scrolled_window_new (NULL, NULL);
5211 gtk_container_add (GTK_CONTAINER (scrolled_win),
5212 GTK_WIDGET (export_ctree));
5213 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
5214 GTK_POLICY_AUTOMATIC,
5215 GTK_POLICY_AUTOMATIC);
5216 gtk_box_pack_start (GTK_BOX (vbox), scrolled_win, TRUE, TRUE, 0);
5217 gtk_clist_set_selection_mode (GTK_CLIST (export_ctree),
5218 GTK_SELECTION_EXTENDED);
5219 gtk_clist_set_column_width (GTK_CLIST (export_ctree), 0, 200);
5220 gtk_clist_set_column_width (GTK_CLIST (export_ctree), 1, 200);
5221 gtk_widget_set_usize (GTK_WIDGET (export_ctree), 300, 200);
5224 if (!GTK_WIDGET_VISIBLE (export_window))
5225 gtk_widget_show_all (export_window);
5227 gtk_clist_clear (GTK_CLIST (export_ctree));
5229 node = GTK_CTREE_NODE (g_list_nth (GTK_CLIST (ctree)->row_list,
5230 GTK_CLIST (ctree)->focus_row));
5234 gnode = gtk_ctree_export_to_gnode (ctree, NULL, NULL, node,
5238 gtk_ctree_insert_gnode (export_ctree, NULL, NULL, gnode,
5240 g_node_destroy (gnode);
5244 void change_indent (GtkWidget *widget, GtkCTree *ctree)
5246 gtk_ctree_set_indent (ctree, GTK_ADJUSTMENT (widget)->value);
5249 void change_spacing (GtkWidget *widget, GtkCTree *ctree)
5251 gtk_ctree_set_spacing (ctree, GTK_ADJUSTMENT (widget)->value);
5254 void change_row_height (GtkWidget *widget, GtkCList *clist)
5256 gtk_clist_set_row_height (clist, GTK_ADJUSTMENT (widget)->value);
5259 void set_background (GtkCTree *ctree, GtkCTreeNode *node, gpointer data)
5261 GtkStyle *style = NULL;
5266 if (ctree->line_style != GTK_CTREE_LINES_TABBED)
5268 if (!GTK_CTREE_ROW (node)->is_leaf)
5269 style = GTK_CTREE_ROW (node)->row.data;
5270 else if (GTK_CTREE_ROW (node)->parent)
5271 style = GTK_CTREE_ROW (GTK_CTREE_ROW (node)->parent)->row.data;
5274 gtk_ctree_node_set_row_style (ctree, node, style);
5277 void ctree_toggle_line_style (GtkWidget *widget, GtkCTree *ctree)
5281 if (!GTK_WIDGET_MAPPED (widget))
5284 RADIOMENUTOGGLED ((GtkRadioMenuItem *)
5285 (((GtkOptionMenu *)omenu1)->menu_item), i);
5287 if ((ctree->line_style == GTK_CTREE_LINES_TABBED &&
5288 ((GtkCTreeLineStyle) (3 - i)) != GTK_CTREE_LINES_TABBED) ||
5289 (ctree->line_style != GTK_CTREE_LINES_TABBED &&
5290 ((GtkCTreeLineStyle) (3 - i)) == GTK_CTREE_LINES_TABBED))
5291 gtk_ctree_pre_recursive (ctree, NULL, set_background, NULL);
5292 gtk_ctree_set_line_style (ctree, 3 - i);
5296 void ctree_toggle_expander_style (GtkWidget *widget, GtkCTree *ctree)
5300 if (!GTK_WIDGET_MAPPED (widget))
5303 RADIOMENUTOGGLED ((GtkRadioMenuItem *)
5304 (((GtkOptionMenu *)omenu2)->menu_item), i);
5306 gtk_ctree_set_expander_style (ctree, (GtkCTreeExpanderStyle) (3 - i));
5309 void ctree_toggle_justify (GtkWidget *widget, GtkCTree *ctree)
5313 if (!GTK_WIDGET_MAPPED (widget))
5316 RADIOMENUTOGGLED ((GtkRadioMenuItem *)
5317 (((GtkOptionMenu *)omenu3)->menu_item), i);
5319 gtk_clist_set_column_justification (GTK_CLIST (ctree), ctree->tree_column,
5320 (GtkJustification) (1 - i));
5323 void ctree_toggle_sel_mode (GtkWidget *widget, GtkCTree *ctree)
5327 if (!GTK_WIDGET_MAPPED (widget))
5330 RADIOMENUTOGGLED ((GtkRadioMenuItem *)
5331 (((GtkOptionMenu *)omenu4)->menu_item), i);
5333 gtk_clist_set_selection_mode (GTK_CLIST (ctree), (GtkSelectionMode) (3 - i));
5334 after_press (ctree, NULL);
5337 void build_recursive (GtkCTree *ctree, gint cur_depth, gint depth,
5338 gint num_books, gint num_pages, GtkCTreeNode *parent)
5343 GtkCTreeNode *sibling;
5350 for (i = num_pages + num_books; i > num_books; i--)
5353 sprintf (buf1, "Page %02d", (gint) rand() % 100);
5354 sprintf (buf2, "Item %d-%d", cur_depth, i);
5355 sibling = gtk_ctree_insert_node (ctree, parent, sibling, text, 5,
5356 pixmap3, mask3, NULL, NULL,
5359 if (parent && ctree->line_style == GTK_CTREE_LINES_TABBED)
5360 gtk_ctree_node_set_row_style (ctree, sibling,
5361 GTK_CTREE_ROW (parent)->row.style);
5364 if (cur_depth == depth)
5367 for (i = num_books; i > 0; i--)
5372 sprintf (buf1, "Book %02d", (gint) rand() % 100);
5373 sprintf (buf2, "Item %d-%d", cur_depth, i);
5374 sibling = gtk_ctree_insert_node (ctree, parent, sibling, text, 5,
5375 pixmap1, mask1, pixmap2, mask2,
5378 style = gtk_style_new ();
5379 switch (cur_depth % 3)
5382 style->base[GTK_STATE_NORMAL].red = 10000 * (cur_depth % 6);
5383 style->base[GTK_STATE_NORMAL].green = 0;
5384 style->base[GTK_STATE_NORMAL].blue = 65535 - ((i * 10000) % 65535);
5387 style->base[GTK_STATE_NORMAL].red = 10000 * (cur_depth % 6);
5388 style->base[GTK_STATE_NORMAL].green = 65535 - ((i * 10000) % 65535);
5389 style->base[GTK_STATE_NORMAL].blue = 0;
5392 style->base[GTK_STATE_NORMAL].red = 65535 - ((i * 10000) % 65535);
5393 style->base[GTK_STATE_NORMAL].green = 0;
5394 style->base[GTK_STATE_NORMAL].blue = 10000 * (cur_depth % 6);
5397 gtk_ctree_node_set_row_data_full (ctree, sibling, style,
5398 (GtkDestroyNotify) gtk_style_unref);
5400 if (ctree->line_style == GTK_CTREE_LINES_TABBED)
5401 gtk_ctree_node_set_row_style (ctree, sibling, style);
5403 build_recursive (ctree, cur_depth + 1, depth, num_books, num_pages,
5408 void rebuild_tree (GtkWidget *widget, GtkCTree *ctree)
5411 gchar label1[] = "Root";
5412 gchar label2[] = "";
5413 GtkCTreeNode *parent;
5420 d = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (spin1));
5421 b = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (spin2));
5422 p = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (spin3));
5424 n = ((pow (b, d) - 1) / (b - 1)) * (p + 1);
5428 g_print ("%d total items? Try less\n",n);
5432 gtk_clist_freeze (GTK_CLIST (ctree));
5433 gtk_clist_clear (GTK_CLIST (ctree));
5438 parent = gtk_ctree_insert_node (ctree, NULL, NULL, text, 5, pixmap1,
5439 mask1, pixmap2, mask2, FALSE, TRUE);
5441 style = gtk_style_new ();
5442 style->base[GTK_STATE_NORMAL].red = 0;
5443 style->base[GTK_STATE_NORMAL].green = 45000;
5444 style->base[GTK_STATE_NORMAL].blue = 55000;
5445 gtk_ctree_node_set_row_data_full (ctree, parent, style,
5446 (GtkDestroyNotify) gtk_style_unref);
5448 if (ctree->line_style == GTK_CTREE_LINES_TABBED)
5449 gtk_ctree_node_set_row_style (ctree, parent, style);
5451 build_recursive (ctree, 1, d, b, p, parent);
5452 gtk_clist_thaw (GTK_CLIST (ctree));
5453 after_press (ctree, NULL);
5457 ctree_click_column (GtkCTree *ctree, gint column, gpointer data)
5461 clist = GTK_CLIST (ctree);
5463 if (column == clist->sort_column)
5465 if (clist->sort_type == GTK_SORT_ASCENDING)
5466 clist->sort_type = GTK_SORT_DESCENDING;
5468 clist->sort_type = GTK_SORT_ASCENDING;
5471 gtk_clist_set_sort_column (clist, column);
5473 gtk_ctree_sort_recursive (ctree, NULL);
5476 void create_ctree (void)
5478 static GtkWidget *window = NULL;
5479 GtkTooltips *tooltips;
5481 GtkWidget *scrolled_win;
5493 GdkColor transparent = { 0 };
5495 char *title[] = { "Tree" , "Info" };
5498 static OptionMenuItem items1[] =
5500 { "No lines", ctree_toggle_line_style },
5501 { "Solid", ctree_toggle_line_style },
5502 { "Dotted", ctree_toggle_line_style },
5503 { "Tabbed", ctree_toggle_line_style }
5506 static OptionMenuItem items2[] =
5508 { "None", ctree_toggle_expander_style },
5509 { "Square", ctree_toggle_expander_style },
5510 { "Triangle", ctree_toggle_expander_style },
5511 { "Circular", ctree_toggle_expander_style }
5514 static OptionMenuItem items3[] =
5516 { "Left", ctree_toggle_justify },
5517 { "Right", ctree_toggle_justify }
5520 static OptionMenuItem items4[] =
5522 { "Single", ctree_toggle_sel_mode },
5523 { "Browse", ctree_toggle_sel_mode },
5524 { "Multiple", ctree_toggle_sel_mode },
5525 { "Extended", ctree_toggle_sel_mode }
5530 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
5532 gtk_signal_connect (GTK_OBJECT (window), "destroy",
5533 GTK_SIGNAL_FUNC (gtk_widget_destroyed),
5536 gtk_window_set_title (GTK_WINDOW (window), "GtkCTree");
5537 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
5539 tooltips = gtk_tooltips_new ();
5540 gtk_object_ref (GTK_OBJECT (tooltips));
5541 gtk_object_sink (GTK_OBJECT (tooltips));
5543 gtk_object_set_data_full (GTK_OBJECT (window), "tooltips", tooltips,
5544 (GtkDestroyNotify) gtk_object_unref);
5546 vbox = gtk_vbox_new (FALSE, 0);
5547 gtk_container_add (GTK_CONTAINER (window), vbox);
5549 hbox = gtk_hbox_new (FALSE, 5);
5550 gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
5551 gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0);
5553 label = gtk_label_new ("Depth :");
5554 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
5556 adj = (GtkAdjustment *) gtk_adjustment_new (4, 1, 10, 1, 5, 0);
5557 spin1 = gtk_spin_button_new (adj, 0, 0);
5558 gtk_box_pack_start (GTK_BOX (hbox), spin1, FALSE, TRUE, 5);
5560 label = gtk_label_new ("Books :");
5561 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
5563 adj = (GtkAdjustment *) gtk_adjustment_new (3, 1, 20, 1, 5, 0);
5564 spin2 = gtk_spin_button_new (adj, 0, 0);
5565 gtk_box_pack_start (GTK_BOX (hbox), spin2, FALSE, TRUE, 5);
5567 label = gtk_label_new ("Pages :");
5568 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
5570 adj = (GtkAdjustment *) gtk_adjustment_new (5, 1, 20, 1, 5, 0);
5571 spin3 = gtk_spin_button_new (adj, 0, 0);
5572 gtk_box_pack_start (GTK_BOX (hbox), spin3, FALSE, TRUE, 5);
5574 button = gtk_button_new_with_label ("Close");
5575 gtk_box_pack_end (GTK_BOX (hbox), button, TRUE, TRUE, 0);
5577 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
5578 (GtkSignalFunc) gtk_widget_destroy,
5579 GTK_OBJECT(window));
5581 button = gtk_button_new_with_label ("Rebuild Tree");
5582 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
5584 scrolled_win = gtk_scrolled_window_new (NULL, NULL);
5585 gtk_container_set_border_width (GTK_CONTAINER (scrolled_win), 5);
5586 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
5587 GTK_POLICY_AUTOMATIC,
5589 gtk_box_pack_start (GTK_BOX (vbox), scrolled_win, TRUE, TRUE, 0);
5591 ctree = GTK_CTREE (gtk_ctree_new_with_titles (2, 0, title));
5592 gtk_container_add (GTK_CONTAINER (scrolled_win), GTK_WIDGET (ctree));
5594 gtk_clist_set_column_auto_resize (GTK_CLIST (ctree), 0, TRUE);
5595 gtk_clist_set_column_width (GTK_CLIST (ctree), 1, 200);
5596 gtk_clist_set_selection_mode (GTK_CLIST (ctree), GTK_SELECTION_EXTENDED);
5597 gtk_ctree_set_line_style (ctree, GTK_CTREE_LINES_DOTTED);
5598 line_style = GTK_CTREE_LINES_DOTTED;
5600 gtk_signal_connect (GTK_OBJECT (button), "clicked",
5601 GTK_SIGNAL_FUNC (rebuild_tree), ctree);
5602 gtk_signal_connect (GTK_OBJECT (ctree), "click_column",
5603 (GtkSignalFunc) ctree_click_column, NULL);
5605 gtk_signal_connect_after (GTK_OBJECT (ctree), "button_press_event",
5606 GTK_SIGNAL_FUNC (after_press), NULL);
5607 gtk_signal_connect_after (GTK_OBJECT (ctree), "button_release_event",
5608 GTK_SIGNAL_FUNC (after_press), NULL);
5609 gtk_signal_connect_after (GTK_OBJECT (ctree), "tree_move",
5610 GTK_SIGNAL_FUNC (after_move), NULL);
5611 gtk_signal_connect_after (GTK_OBJECT (ctree), "end_selection",
5612 GTK_SIGNAL_FUNC (after_press), NULL);
5613 gtk_signal_connect_after (GTK_OBJECT (ctree), "toggle_focus_row",
5614 GTK_SIGNAL_FUNC (after_press), NULL);
5615 gtk_signal_connect_after (GTK_OBJECT (ctree), "select_all",
5616 GTK_SIGNAL_FUNC (after_press), NULL);
5617 gtk_signal_connect_after (GTK_OBJECT (ctree), "unselect_all",
5618 GTK_SIGNAL_FUNC (after_press), NULL);
5619 gtk_signal_connect_after (GTK_OBJECT (ctree), "scroll_vertical",
5620 GTK_SIGNAL_FUNC (after_press), NULL);
5622 bbox = gtk_hbox_new (FALSE, 5);
5623 gtk_container_set_border_width (GTK_CONTAINER (bbox), 5);
5624 gtk_box_pack_start (GTK_BOX (vbox), bbox, FALSE, TRUE, 0);
5626 mbox = gtk_vbox_new (TRUE, 5);
5627 gtk_box_pack_start (GTK_BOX (bbox), mbox, FALSE, TRUE, 0);
5629 label = gtk_label_new ("Row Height :");
5630 gtk_box_pack_start (GTK_BOX (mbox), label, FALSE, FALSE, 0);
5632 label = gtk_label_new ("Indent :");
5633 gtk_box_pack_start (GTK_BOX (mbox), label, FALSE, FALSE, 0);
5635 label = gtk_label_new ("Spacing :");
5636 gtk_box_pack_start (GTK_BOX (mbox), label, FALSE, FALSE, 0);
5638 mbox = gtk_vbox_new (TRUE, 5);
5639 gtk_box_pack_start (GTK_BOX (bbox), mbox, FALSE, TRUE, 0);
5641 adj = (GtkAdjustment *) gtk_adjustment_new (20, 12, 100, 1, 10, 0);
5642 spinner = gtk_spin_button_new (adj, 0, 0);
5643 gtk_box_pack_start (GTK_BOX (mbox), spinner, FALSE, FALSE, 5);
5644 gtk_tooltips_set_tip (tooltips, spinner,
5645 "Row height of list items", NULL);
5646 gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
5647 GTK_SIGNAL_FUNC (change_row_height), ctree);
5648 gtk_clist_set_row_height ( GTK_CLIST (ctree), adj->value);
5650 adj = (GtkAdjustment *) gtk_adjustment_new (20, 0, 60, 1, 10, 0);
5651 spinner = gtk_spin_button_new (adj, 0, 0);
5652 gtk_box_pack_start (GTK_BOX (mbox), spinner, FALSE, FALSE, 5);
5653 gtk_tooltips_set_tip (tooltips, spinner, "Tree Indentation.", NULL);
5654 gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
5655 GTK_SIGNAL_FUNC (change_indent), ctree);
5657 adj = (GtkAdjustment *) gtk_adjustment_new (5, 0, 60, 1, 10, 0);
5658 spinner = gtk_spin_button_new (adj, 0, 0);
5659 gtk_box_pack_start (GTK_BOX (mbox), spinner, FALSE, FALSE, 5);
5660 gtk_tooltips_set_tip (tooltips, spinner, "Tree Spacing.", NULL);
5661 gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
5662 GTK_SIGNAL_FUNC (change_spacing), ctree);
5664 mbox = gtk_vbox_new (TRUE, 5);
5665 gtk_box_pack_start (GTK_BOX (bbox), mbox, FALSE, TRUE, 0);
5667 hbox = gtk_hbox_new (FALSE, 5);
5668 gtk_box_pack_start (GTK_BOX (mbox), hbox, FALSE, FALSE, 0);
5670 button = gtk_button_new_with_label ("Expand All");
5671 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
5672 gtk_signal_connect (GTK_OBJECT (button), "clicked",
5673 GTK_SIGNAL_FUNC (expand_all), ctree);
5675 button = gtk_button_new_with_label ("Collapse All");
5676 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
5677 gtk_signal_connect (GTK_OBJECT (button), "clicked",
5678 GTK_SIGNAL_FUNC (collapse_all), ctree);
5680 button = gtk_button_new_with_label ("Change Style");
5681 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
5682 gtk_signal_connect (GTK_OBJECT (button), "clicked",
5683 GTK_SIGNAL_FUNC (change_style), ctree);
5685 button = gtk_button_new_with_label ("Export Tree");
5686 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
5687 gtk_signal_connect (GTK_OBJECT (button), "clicked",
5688 GTK_SIGNAL_FUNC (export_ctree), ctree);
5690 hbox = gtk_hbox_new (FALSE, 5);
5691 gtk_box_pack_start (GTK_BOX (mbox), hbox, FALSE, FALSE, 0);
5693 button = gtk_button_new_with_label ("Select All");
5694 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
5695 gtk_signal_connect (GTK_OBJECT (button), "clicked",
5696 GTK_SIGNAL_FUNC (select_all), ctree);
5698 button = gtk_button_new_with_label ("Unselect All");
5699 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
5700 gtk_signal_connect (GTK_OBJECT (button), "clicked",
5701 GTK_SIGNAL_FUNC (unselect_all), ctree);
5703 button = gtk_button_new_with_label ("Remove Selection");
5704 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
5705 gtk_signal_connect (GTK_OBJECT (button), "clicked",
5706 GTK_SIGNAL_FUNC (remove_selection), ctree);
5708 check = gtk_check_button_new_with_label ("Reorderable");
5709 gtk_box_pack_start (GTK_BOX (hbox), check, FALSE, TRUE, 0);
5710 gtk_tooltips_set_tip (tooltips, check,
5711 "Tree items can be reordered by dragging.", NULL);
5712 gtk_signal_connect (GTK_OBJECT (check), "clicked",
5713 GTK_SIGNAL_FUNC (toggle_reorderable), ctree);
5714 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check), TRUE);
5716 hbox = gtk_hbox_new (TRUE, 5);
5717 gtk_box_pack_start (GTK_BOX (mbox), hbox, FALSE, FALSE, 0);
5719 omenu1 = build_option_menu (items1, 4, 2, ctree);
5720 gtk_box_pack_start (GTK_BOX (hbox), omenu1, FALSE, TRUE, 0);
5721 gtk_tooltips_set_tip (tooltips, omenu1, "The tree's line style.", NULL);
5723 omenu2 = build_option_menu (items2, 4, 1, ctree);
5724 gtk_box_pack_start (GTK_BOX (hbox), omenu2, FALSE, TRUE, 0);
5725 gtk_tooltips_set_tip (tooltips, omenu2, "The tree's expander style.",
5728 omenu3 = build_option_menu (items3, 2, 0, ctree);
5729 gtk_box_pack_start (GTK_BOX (hbox), omenu3, FALSE, TRUE, 0);
5730 gtk_tooltips_set_tip (tooltips, omenu3, "The tree's justification.",
5733 omenu4 = build_option_menu (items4, 4, 3, ctree);
5734 gtk_box_pack_start (GTK_BOX (hbox), omenu4, FALSE, TRUE, 0);
5735 gtk_tooltips_set_tip (tooltips, omenu4, "The list's selection mode.",
5738 gtk_widget_realize (window);
5741 pixmap1 = gdk_pixmap_create_from_xpm_d (window->window, &mask1,
5742 &transparent, book_closed_xpm);
5744 pixmap2 = gdk_pixmap_create_from_xpm_d (window->window, &mask2,
5745 &transparent, book_open_xpm);
5747 pixmap3 = gdk_pixmap_create_from_xpm_d (window->window, &mask3,
5748 &transparent, mini_page_xpm);
5750 gtk_widget_set_usize (GTK_WIDGET (ctree), 0, 300);
5752 frame = gtk_frame_new (NULL);
5753 gtk_container_set_border_width (GTK_CONTAINER (frame), 0);
5754 gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_OUT);
5755 gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, TRUE, 0);
5757 hbox = gtk_hbox_new (TRUE, 2);
5758 gtk_container_set_border_width (GTK_CONTAINER (hbox), 2);
5759 gtk_container_add (GTK_CONTAINER (frame), hbox);
5761 frame = gtk_frame_new (NULL);
5762 gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
5763 gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, TRUE, 0);
5765 hbox2 = gtk_hbox_new (FALSE, 0);
5766 gtk_container_set_border_width (GTK_CONTAINER (hbox2), 2);
5767 gtk_container_add (GTK_CONTAINER (frame), hbox2);
5769 label = gtk_label_new ("Books :");
5770 gtk_box_pack_start (GTK_BOX (hbox2), label, FALSE, TRUE, 0);
5772 sprintf (buf, "%d", books);
5773 book_label = gtk_label_new (buf);
5774 gtk_box_pack_end (GTK_BOX (hbox2), book_label, FALSE, TRUE, 5);
5776 frame = gtk_frame_new (NULL);
5777 gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
5778 gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, TRUE, 0);
5780 hbox2 = gtk_hbox_new (FALSE, 0);
5781 gtk_container_set_border_width (GTK_CONTAINER (hbox2), 2);
5782 gtk_container_add (GTK_CONTAINER (frame), hbox2);
5784 label = gtk_label_new ("Pages :");
5785 gtk_box_pack_start (GTK_BOX (hbox2), label, FALSE, TRUE, 0);
5787 sprintf (buf, "%d", pages);
5788 page_label = gtk_label_new (buf);
5789 gtk_box_pack_end (GTK_BOX (hbox2), page_label, FALSE, TRUE, 5);
5791 frame = gtk_frame_new (NULL);
5792 gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
5793 gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, TRUE, 0);
5795 hbox2 = gtk_hbox_new (FALSE, 0);
5796 gtk_container_set_border_width (GTK_CONTAINER (hbox2), 2);
5797 gtk_container_add (GTK_CONTAINER (frame), hbox2);
5799 label = gtk_label_new ("Selected :");
5800 gtk_box_pack_start (GTK_BOX (hbox2), label, FALSE, TRUE, 0);
5802 sprintf (buf, "%d", g_list_length (GTK_CLIST (ctree)->selection));
5803 sel_label = gtk_label_new (buf);
5804 gtk_box_pack_end (GTK_BOX (hbox2), sel_label, FALSE, TRUE, 5);
5806 frame = gtk_frame_new (NULL);
5807 gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
5808 gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, TRUE, 0);
5810 hbox2 = gtk_hbox_new (FALSE, 0);
5811 gtk_container_set_border_width (GTK_CONTAINER (hbox2), 2);
5812 gtk_container_add (GTK_CONTAINER (frame), hbox2);
5814 label = gtk_label_new ("Visible :");
5815 gtk_box_pack_start (GTK_BOX (hbox2), label, FALSE, TRUE, 0);
5817 sprintf (buf, "%d", g_list_length (GTK_CLIST (ctree)->row_list));
5818 vis_label = gtk_label_new (buf);
5819 gtk_box_pack_end (GTK_BOX (hbox2), vis_label, FALSE, TRUE, 5);
5821 rebuild_tree (NULL, ctree);
5824 if (!GTK_WIDGET_VISIBLE (window))
5825 gtk_widget_show_all (window);
5827 gtk_widget_destroy (window);
5835 color_selection_ok (GtkWidget *w,
5836 GtkColorSelectionDialog *cs)
5838 GtkColorSelection *colorsel;
5841 colorsel=GTK_COLOR_SELECTION(cs->colorsel);
5843 gtk_color_selection_get_color(colorsel,color);
5844 gtk_color_selection_set_color(colorsel,color);
5848 color_selection_changed (GtkWidget *w,
5849 GtkColorSelectionDialog *cs)
5851 GtkColorSelection *colorsel;
5854 colorsel=GTK_COLOR_SELECTION(cs->colorsel);
5855 gtk_color_selection_get_color(colorsel,color);
5859 opacity_toggled_cb (GtkWidget *w,
5860 GtkColorSelectionDialog *cs)
5862 GtkColorSelection *colorsel;
5864 colorsel = GTK_COLOR_SELECTION (cs->colorsel);
5865 gtk_color_selection_set_use_opacity (colorsel,
5866 gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (w)));
5870 palette_toggled_cb (GtkWidget *w,
5871 GtkColorSelectionDialog *cs)
5873 GtkColorSelection *colorsel;
5875 colorsel = GTK_COLOR_SELECTION (cs->colorsel);
5876 gtk_color_selection_set_use_palette (colorsel,
5877 gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (w)));
5881 create_color_selection (void)
5883 static GtkWidget *window = NULL;
5887 GtkWidget *options_hbox;
5888 GtkWidget *check_button;
5890 window = gtk_color_selection_dialog_new ("color selection dialog");
5892 gtk_window_set_position (GTK_WINDOW (window), GTK_WIN_POS_MOUSE);
5894 gtk_signal_connect (GTK_OBJECT (window), "destroy",
5895 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
5898 options_hbox = gtk_hbox_new (FALSE, 0);
5899 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), options_hbox, FALSE, FALSE, 0);
5900 gtk_container_set_border_width (GTK_CONTAINER (options_hbox), 10);
5902 check_button = gtk_check_button_new_with_label ("Show Opacity");
5903 gtk_box_pack_start (GTK_BOX (options_hbox), check_button, FALSE, FALSE, 0);
5904 gtk_signal_connect (GTK_OBJECT (check_button), "toggled",
5905 GTK_SIGNAL_FUNC (opacity_toggled_cb), window);
5907 check_button = gtk_check_button_new_with_label ("Show Palette");
5908 gtk_box_pack_end (GTK_BOX (options_hbox), check_button, FALSE, FALSE, 0);
5909 gtk_signal_connect (GTK_OBJECT (check_button), "toggled",
5910 GTK_SIGNAL_FUNC (palette_toggled_cb), window);
5912 gtk_widget_show_all (options_hbox);
5914 gtk_signal_connect (
5915 GTK_OBJECT (GTK_COLOR_SELECTION_DIALOG (window)->colorsel),
5917 GTK_SIGNAL_FUNC(color_selection_changed),
5920 gtk_signal_connect (
5921 GTK_OBJECT (GTK_COLOR_SELECTION_DIALOG (window)->ok_button),
5923 GTK_SIGNAL_FUNC(color_selection_ok),
5926 gtk_signal_connect_object (
5927 GTK_OBJECT (GTK_COLOR_SELECTION_DIALOG (window)->cancel_button),
5929 GTK_SIGNAL_FUNC(gtk_widget_destroy),
5930 GTK_OBJECT (window));
5933 if (!GTK_WIDGET_VISIBLE (window))
5934 gtk_widget_show (window);
5936 gtk_widget_destroy (window);
5944 file_selection_hide_fileops (GtkWidget *widget,
5945 GtkFileSelection *fs)
5947 gtk_file_selection_hide_fileop_buttons (fs);
5951 file_selection_ok (GtkWidget *w,
5952 GtkFileSelection *fs)
5954 g_print ("%s\n", gtk_file_selection_get_filename (fs));
5955 gtk_widget_destroy (GTK_WIDGET (fs));
5959 create_file_selection (void)
5961 static GtkWidget *window = NULL;
5966 window = gtk_file_selection_new ("file selection dialog");
5968 gtk_file_selection_hide_fileop_buttons (GTK_FILE_SELECTION (window));
5970 gtk_window_set_position (GTK_WINDOW (window), GTK_WIN_POS_MOUSE);
5972 gtk_signal_connect (GTK_OBJECT (window), "destroy",
5973 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
5976 gtk_signal_connect (GTK_OBJECT (GTK_FILE_SELECTION (window)->ok_button),
5977 "clicked", GTK_SIGNAL_FUNC(file_selection_ok),
5979 gtk_signal_connect_object (GTK_OBJECT (GTK_FILE_SELECTION (window)->cancel_button),
5980 "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy),
5981 GTK_OBJECT (window));
5983 button = gtk_button_new_with_label ("Hide Fileops");
5984 gtk_signal_connect (GTK_OBJECT (button), "clicked",
5985 (GtkSignalFunc) file_selection_hide_fileops,
5987 gtk_box_pack_start (GTK_BOX (GTK_FILE_SELECTION (window)->action_area),
5988 button, FALSE, FALSE, 0);
5989 gtk_widget_show (button);
5991 button = gtk_button_new_with_label ("Show Fileops");
5992 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
5993 (GtkSignalFunc) gtk_file_selection_show_fileop_buttons,
5995 gtk_box_pack_start (GTK_BOX (GTK_FILE_SELECTION (window)->action_area),
5996 button, FALSE, FALSE, 0);
5997 gtk_widget_show (button);
6000 if (!GTK_WIDGET_VISIBLE (window))
6001 gtk_widget_show (window);
6003 gtk_widget_destroy (window);
6007 flipping_toggled_cb (GtkWidget *widget, gpointer data)
6009 int state = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget));
6010 int new_direction = state ? GTK_TEXT_DIR_RTL : GTK_TEXT_DIR_LTR;
6012 gtk_widget_set_default_direction (new_direction);
6016 create_flipping (void)
6018 static GtkWidget *window = NULL;
6019 GtkWidget *check_button, *button;
6023 window = gtk_dialog_new ();
6025 gtk_signal_connect (GTK_OBJECT (window), "destroy",
6026 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
6029 gtk_window_set_title (GTK_WINDOW (window), "Bidirectional Flipping");
6031 check_button = gtk_check_button_new_with_label ("Right-to-left global direction");
6032 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox),
6033 check_button, TRUE, TRUE, 0);
6035 if (gtk_widget_get_default_direction () == GTK_TEXT_DIR_RTL)
6036 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check_button), TRUE);
6038 gtk_signal_connect (GTK_OBJECT (check_button), "toggled",
6039 flipping_toggled_cb, FALSE);
6041 gtk_container_set_border_width (GTK_CONTAINER (check_button), 10);
6043 button = gtk_button_new_with_label ("Close");
6044 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
6045 GTK_SIGNAL_FUNC (gtk_widget_destroy), GTK_OBJECT (window));
6046 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
6047 button, TRUE, TRUE, 0);
6050 if (!GTK_WIDGET_VISIBLE (window))
6051 gtk_widget_show_all (window);
6053 gtk_widget_destroy (window);
6061 font_selection_ok (GtkWidget *w,
6062 GtkFontSelectionDialog *fs)
6064 gchar *s = gtk_font_selection_dialog_get_font_name (fs);
6066 g_print ("%s\n", s);
6068 gtk_widget_destroy (GTK_WIDGET (fs));
6072 create_font_selection (void)
6074 static GtkWidget *window = NULL;
6078 window = gtk_font_selection_dialog_new ("Font Selection Dialog");
6080 gtk_window_set_position (GTK_WINDOW (window), GTK_WIN_POS_MOUSE);
6082 gtk_signal_connect (GTK_OBJECT (window), "destroy",
6083 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
6086 gtk_signal_connect (GTK_OBJECT (GTK_FONT_SELECTION_DIALOG (window)->ok_button),
6087 "clicked", GTK_SIGNAL_FUNC(font_selection_ok),
6088 GTK_FONT_SELECTION_DIALOG (window));
6089 gtk_signal_connect_object (GTK_OBJECT (GTK_FONT_SELECTION_DIALOG (window)->cancel_button),
6090 "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy),
6091 GTK_OBJECT (window));
6094 if (!GTK_WIDGET_VISIBLE (window))
6095 gtk_widget_show (window);
6097 gtk_widget_destroy (window);
6104 static GtkWidget *dialog_window = NULL;
6107 label_toggle (GtkWidget *widget,
6112 *label = gtk_label_new ("Dialog Test");
6113 gtk_signal_connect (GTK_OBJECT (*label),
6115 GTK_SIGNAL_FUNC (gtk_widget_destroyed),
6117 gtk_misc_set_padding (GTK_MISC (*label), 10, 10);
6118 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog_window)->vbox),
6119 *label, TRUE, TRUE, 0);
6120 gtk_widget_show (*label);
6123 gtk_widget_destroy (*label);
6127 create_dialog (void)
6129 static GtkWidget *label;
6134 dialog_window = gtk_dialog_new ();
6136 gtk_signal_connect (GTK_OBJECT (dialog_window), "destroy",
6137 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
6140 gtk_window_set_title (GTK_WINDOW (dialog_window), "GtkDialog");
6141 gtk_container_set_border_width (GTK_CONTAINER (dialog_window), 0);
6142 gtk_widget_set_usize (dialog_window, 200, 110);
6144 button = gtk_button_new_with_label ("OK");
6145 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
6146 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog_window)->action_area),
6147 button, TRUE, TRUE, 0);
6148 gtk_widget_grab_default (button);
6149 gtk_widget_show (button);
6151 button = gtk_button_new_with_label ("Toggle");
6152 gtk_signal_connect (GTK_OBJECT (button), "clicked",
6153 GTK_SIGNAL_FUNC (label_toggle),
6155 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
6156 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog_window)->action_area),
6157 button, TRUE, TRUE, 0);
6158 gtk_widget_show (button);
6163 if (!GTK_WIDGET_VISIBLE (dialog_window))
6164 gtk_widget_show (dialog_window);
6166 gtk_widget_destroy (dialog_window);
6171 static gboolean event_watcher_enter_id = 0;
6172 static gboolean event_watcher_leave_id = 0;
6175 event_watcher (GtkObject *object,
6181 g_print ("Watch: \"%s\" emitted for %s\n",
6182 gtk_signal_name (signal_id),
6183 gtk_type_name (GTK_OBJECT_TYPE (object)));
6189 event_watcher_down (void)
6191 if (event_watcher_enter_id)
6195 signal_id = gtk_signal_lookup ("enter_notify_event", GTK_TYPE_WIDGET);
6196 gtk_signal_remove_emission_hook (signal_id, event_watcher_enter_id);
6197 event_watcher_enter_id = 0;
6198 signal_id = gtk_signal_lookup ("leave_notify_event", GTK_TYPE_WIDGET);
6199 gtk_signal_remove_emission_hook (signal_id, event_watcher_leave_id);
6200 event_watcher_leave_id = 0;
6205 event_watcher_toggle (void)
6207 if (event_watcher_enter_id)
6208 event_watcher_down ();
6213 signal_id = gtk_signal_lookup ("enter_notify_event", GTK_TYPE_WIDGET);
6214 event_watcher_enter_id = gtk_signal_add_emission_hook (signal_id, event_watcher, NULL);
6215 signal_id = gtk_signal_lookup ("leave_notify_event", GTK_TYPE_WIDGET);
6216 event_watcher_leave_id = gtk_signal_add_emission_hook (signal_id, event_watcher, NULL);
6221 create_event_watcher (void)
6227 dialog_window = gtk_dialog_new ();
6229 gtk_signal_connect (GTK_OBJECT (dialog_window), "destroy",
6230 GTK_SIGNAL_FUNC (gtk_widget_destroyed),
6232 gtk_signal_connect (GTK_OBJECT (dialog_window),
6234 GTK_SIGNAL_FUNC (event_watcher_down),
6237 gtk_window_set_title (GTK_WINDOW (dialog_window), "Event Watcher");
6238 gtk_container_set_border_width (GTK_CONTAINER (dialog_window), 0);
6239 gtk_widget_set_usize (dialog_window, 200, 110);
6241 button = gtk_toggle_button_new_with_label ("Activate Watch");
6242 gtk_signal_connect (GTK_OBJECT (button), "clicked",
6243 GTK_SIGNAL_FUNC (event_watcher_toggle),
6245 gtk_container_set_border_width (GTK_CONTAINER (button), 10);
6246 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog_window)->vbox),
6247 button, TRUE, TRUE, 0);
6248 gtk_widget_show (button);
6250 button = gtk_button_new_with_label ("Close");
6251 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
6252 GTK_SIGNAL_FUNC (gtk_widget_destroy),
6253 (GtkObject*) dialog_window);
6254 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
6255 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog_window)->action_area),
6256 button, TRUE, TRUE, 0);
6257 gtk_widget_grab_default (button);
6258 gtk_widget_show (button);
6261 if (!GTK_WIDGET_VISIBLE (dialog_window))
6262 gtk_widget_show (dialog_window);
6264 gtk_widget_destroy (dialog_window);
6272 create_range_controls (void)
6274 static GtkWidget *window = NULL;
6278 GtkWidget *scrollbar;
6280 GtkWidget *separator;
6281 GtkObject *adjustment;
6286 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
6288 gtk_signal_connect (GTK_OBJECT (window), "destroy",
6289 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
6292 gtk_window_set_title (GTK_WINDOW (window), "range controls");
6293 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
6296 box1 = gtk_vbox_new (FALSE, 0);
6297 gtk_container_add (GTK_CONTAINER (window), box1);
6298 gtk_widget_show (box1);
6301 box2 = gtk_vbox_new (FALSE, 10);
6302 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
6303 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
6304 gtk_widget_show (box2);
6307 adjustment = gtk_adjustment_new (0.0, 0.0, 101.0, 0.1, 1.0, 1.0);
6309 scale = gtk_hscale_new (GTK_ADJUSTMENT (adjustment));
6310 gtk_widget_set_usize (GTK_WIDGET (scale), 150, 30);
6311 gtk_range_set_update_policy (GTK_RANGE (scale), GTK_UPDATE_DELAYED);
6312 gtk_scale_set_digits (GTK_SCALE (scale), 1);
6313 gtk_scale_set_draw_value (GTK_SCALE (scale), TRUE);
6314 gtk_box_pack_start (GTK_BOX (box2), scale, TRUE, TRUE, 0);
6315 gtk_widget_show (scale);
6317 scrollbar = gtk_hscrollbar_new (GTK_ADJUSTMENT (adjustment));
6318 gtk_range_set_update_policy (GTK_RANGE (scrollbar),
6319 GTK_UPDATE_CONTINUOUS);
6320 gtk_box_pack_start (GTK_BOX (box2), scrollbar, TRUE, TRUE, 0);
6321 gtk_widget_show (scrollbar);
6323 hbox = gtk_hbox_new (FALSE, 0);
6325 scale = gtk_vscale_new (GTK_ADJUSTMENT (adjustment));
6326 gtk_widget_set_usize (scale, -1, 200);
6327 gtk_scale_set_digits (GTK_SCALE (scale), 2);
6328 gtk_scale_set_draw_value (GTK_SCALE (scale), TRUE);
6329 gtk_box_pack_start (GTK_BOX (hbox), scale, TRUE, TRUE, 0);
6330 gtk_widget_show (scale);
6332 scale = gtk_vscale_new (GTK_ADJUSTMENT (adjustment));
6333 gtk_widget_set_usize (scale, -1, 200);
6334 gtk_scale_set_digits (GTK_SCALE (scale), 2);
6335 gtk_scale_set_draw_value (GTK_SCALE (scale), TRUE);
6336 gtk_range_set_inverted (GTK_RANGE (scale), TRUE);
6337 gtk_box_pack_start (GTK_BOX (hbox), scale, TRUE, TRUE, 0);
6338 gtk_widget_show (scale);
6340 gtk_box_pack_start (GTK_BOX (box2), hbox, TRUE, TRUE, 0);
6341 gtk_widget_show (hbox);
6343 separator = gtk_hseparator_new ();
6344 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
6345 gtk_widget_show (separator);
6348 box2 = gtk_vbox_new (FALSE, 10);
6349 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
6350 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
6351 gtk_widget_show (box2);
6354 button = gtk_button_new_with_label ("close");
6355 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
6356 GTK_SIGNAL_FUNC(gtk_widget_destroy),
6357 GTK_OBJECT (window));
6358 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
6359 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
6360 gtk_widget_grab_default (button);
6361 gtk_widget_show (button);
6364 if (!GTK_WIDGET_VISIBLE (window))
6365 gtk_widget_show (window);
6367 gtk_widget_destroy (window);
6375 create_rulers (void)
6377 static GtkWidget *window = NULL;
6383 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
6384 gtk_window_set_policy (GTK_WINDOW (window), TRUE, TRUE, FALSE);
6386 gtk_signal_connect (GTK_OBJECT (window), "destroy",
6387 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
6390 gtk_window_set_title (GTK_WINDOW (window), "rulers");
6391 gtk_widget_set_usize (window, 300, 300);
6392 gtk_widget_set_events (window,
6393 GDK_POINTER_MOTION_MASK
6394 | GDK_POINTER_MOTION_HINT_MASK);
6395 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
6397 table = gtk_table_new (2, 2, FALSE);
6398 gtk_container_add (GTK_CONTAINER (window), table);
6399 gtk_widget_show (table);
6401 ruler = gtk_hruler_new ();
6402 gtk_ruler_set_metric (GTK_RULER (ruler), GTK_CENTIMETERS);
6403 gtk_ruler_set_range (GTK_RULER (ruler), 100, 0, 0, 20);
6405 gtk_signal_connect_object (GTK_OBJECT (window),
6406 "motion_notify_event",
6407 GTK_SIGNAL_FUNC (GTK_WIDGET_GET_CLASS (ruler)->motion_notify_event),
6408 GTK_OBJECT (ruler));
6410 gtk_table_attach (GTK_TABLE (table), ruler, 1, 2, 0, 1,
6411 GTK_EXPAND | GTK_FILL, GTK_FILL, 0, 0);
6412 gtk_widget_show (ruler);
6415 ruler = gtk_vruler_new ();
6416 gtk_ruler_set_range (GTK_RULER (ruler), 5, 15, 0, 20);
6418 gtk_signal_connect_object (GTK_OBJECT (window),
6419 "motion_notify_event",
6420 GTK_SIGNAL_FUNC (GTK_WIDGET_GET_CLASS (ruler)->motion_notify_event),
6421 GTK_OBJECT (ruler));
6423 gtk_table_attach (GTK_TABLE (table), ruler, 0, 1, 1, 2,
6424 GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
6425 gtk_widget_show (ruler);
6428 if (!GTK_WIDGET_VISIBLE (window))
6429 gtk_widget_show (window);
6431 gtk_widget_destroy (window);
6435 text_toggle_editable (GtkWidget *checkbutton,
6438 gtk_text_set_editable(GTK_TEXT(text),
6439 GTK_TOGGLE_BUTTON(checkbutton)->active);
6443 text_toggle_word_wrap (GtkWidget *checkbutton,
6446 gtk_text_set_word_wrap(GTK_TEXT(text),
6447 GTK_TOGGLE_BUTTON(checkbutton)->active);
6454 { { 0, 0x0000, 0x0000, 0x0000 }, "black" },
6455 { { 0, 0xFFFF, 0xFFFF, 0xFFFF }, "white" },
6456 { { 0, 0xFFFF, 0x0000, 0x0000 }, "red" },
6457 { { 0, 0x0000, 0xFFFF, 0x0000 }, "green" },
6458 { { 0, 0x0000, 0x0000, 0xFFFF }, "blue" },
6459 { { 0, 0x0000, 0xFFFF, 0xFFFF }, "cyan" },
6460 { { 0, 0xFFFF, 0x0000, 0xFFFF }, "magenta" },
6461 { { 0, 0xFFFF, 0xFFFF, 0x0000 }, "yellow" }
6464 int ntext_colors = sizeof(text_colors) / sizeof(text_colors[0]);
6470 text_insert_random (GtkWidget *w, GtkText *text)
6474 for (i=0; i<10; i++)
6476 c = 'A' + rand() % ('Z' - 'A');
6477 gtk_text_set_point (text, rand() % gtk_text_get_length (text));
6478 gtk_text_insert (text, NULL, NULL, NULL, &c, 1);
6487 static GtkWidget *window = NULL;
6493 GtkWidget *separator;
6494 GtkWidget *scrolled_window;
6501 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
6502 gtk_widget_set_name (window, "text window");
6503 gtk_widget_set_usize (window, 500, 500);
6504 gtk_window_set_policy (GTK_WINDOW(window), TRUE, TRUE, FALSE);
6506 gtk_signal_connect (GTK_OBJECT (window), "destroy",
6507 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
6510 gtk_window_set_title (GTK_WINDOW (window), "test");
6511 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
6514 box1 = gtk_vbox_new (FALSE, 0);
6515 gtk_container_add (GTK_CONTAINER (window), box1);
6516 gtk_widget_show (box1);
6519 box2 = gtk_vbox_new (FALSE, 10);
6520 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
6521 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
6522 gtk_widget_show (box2);
6525 scrolled_window = gtk_scrolled_window_new (NULL, NULL);
6526 gtk_box_pack_start (GTK_BOX (box2), scrolled_window, TRUE, TRUE, 0);
6527 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
6530 gtk_widget_show (scrolled_window);
6532 text = gtk_text_new (NULL, NULL);
6533 gtk_text_set_editable (GTK_TEXT (text), TRUE);
6534 gtk_container_add (GTK_CONTAINER (scrolled_window), text);
6535 gtk_widget_grab_focus (text);
6536 gtk_widget_show (text);
6539 gtk_text_freeze (GTK_TEXT (text));
6541 for (i=0; i<ntext_colors; i++)
6543 gtk_text_insert (GTK_TEXT (text), NULL, NULL, NULL,
6544 text_colors[i].name, -1);
6545 gtk_text_insert (GTK_TEXT (text), NULL, NULL, NULL, "\t", -1);
6547 for (j=0; j<ntext_colors; j++)
6549 gtk_text_insert (GTK_TEXT (text), NULL,
6550 &text_colors[j].color, &text_colors[i].color,
6553 gtk_text_insert (GTK_TEXT (text), NULL, NULL, NULL, "\n", -1);
6556 infile = fopen("testgtk.c", "r");
6561 int nbytes_read, nbytes_alloc;
6564 nbytes_alloc = 1024;
6565 buffer = g_new (char, nbytes_alloc);
6569 if (nbytes_alloc < nbytes_read + 1024)
6572 buffer = g_realloc (buffer, nbytes_alloc);
6574 len = fread (buffer + nbytes_read, 1, 1024, infile);
6580 gtk_text_insert (GTK_TEXT (text), NULL, NULL,
6581 NULL, buffer, nbytes_read);
6586 gtk_text_thaw (GTK_TEXT (text));
6588 hbox = gtk_hbutton_box_new ();
6589 gtk_box_pack_start (GTK_BOX (box2), hbox, FALSE, FALSE, 0);
6590 gtk_widget_show (hbox);
6592 check = gtk_check_button_new_with_label("Editable");
6593 gtk_box_pack_start (GTK_BOX (hbox), check, FALSE, FALSE, 0);
6594 gtk_signal_connect (GTK_OBJECT(check), "toggled",
6595 GTK_SIGNAL_FUNC(text_toggle_editable), text);
6596 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check), TRUE);
6597 gtk_widget_show (check);
6599 check = gtk_check_button_new_with_label("Wrap Words");
6600 gtk_box_pack_start (GTK_BOX (hbox), check, FALSE, TRUE, 0);
6601 gtk_signal_connect (GTK_OBJECT(check), "toggled",
6602 GTK_SIGNAL_FUNC(text_toggle_word_wrap), text);
6603 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check), FALSE);
6604 gtk_widget_show (check);
6606 separator = gtk_hseparator_new ();
6607 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
6608 gtk_widget_show (separator);
6611 box2 = gtk_vbox_new (FALSE, 10);
6612 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
6613 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
6614 gtk_widget_show (box2);
6617 button = gtk_button_new_with_label ("insert random");
6618 gtk_signal_connect (GTK_OBJECT (button), "clicked",
6619 GTK_SIGNAL_FUNC(text_insert_random),
6621 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
6622 gtk_widget_show (button);
6624 button = gtk_button_new_with_label ("close");
6625 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
6626 GTK_SIGNAL_FUNC(gtk_widget_destroy),
6627 GTK_OBJECT (window));
6628 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
6629 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
6630 gtk_widget_grab_default (button);
6631 gtk_widget_show (button);
6634 if (!GTK_WIDGET_VISIBLE (window))
6635 gtk_widget_show (window);
6637 gtk_widget_destroy (window);
6644 GdkPixmap *book_open;
6645 GdkPixmap *book_closed;
6646 GdkBitmap *book_open_mask;
6647 GdkBitmap *book_closed_mask;
6648 GtkWidget *sample_notebook;
6651 set_page_pixmaps (GtkNotebook *notebook, gint page_num,
6652 GdkPixmap *pixmap, GdkPixmap *mask)
6654 GtkWidget *page_widget;
6657 page_widget = gtk_notebook_get_nth_page (notebook, page_num);
6659 pixwid = gtk_object_get_data (GTK_OBJECT (page_widget), "tab_pixmap");
6660 gtk_pixmap_set (GTK_PIXMAP (pixwid), pixmap, mask);
6662 pixwid = gtk_object_get_data (GTK_OBJECT (page_widget), "menu_pixmap");
6663 gtk_pixmap_set (GTK_PIXMAP (pixwid), pixmap, mask);
6667 page_switch (GtkWidget *widget, GtkNotebookPage *page, gint page_num)
6669 GtkNotebook *notebook = GTK_NOTEBOOK (widget);
6670 gint old_page_num = gtk_notebook_get_current_page (notebook);
6672 if (page_num == old_page_num)
6675 set_page_pixmaps (notebook, page_num, book_open, book_open_mask);
6677 if (old_page_num != -1)
6678 set_page_pixmaps (notebook, old_page_num, book_closed, book_closed_mask);
6682 tab_fill (GtkToggleButton *button, GtkWidget *child)
6685 GtkPackType pack_type;
6687 gtk_notebook_query_tab_label_packing (GTK_NOTEBOOK (sample_notebook), child,
6688 &expand, NULL, &pack_type);
6689 gtk_notebook_set_tab_label_packing (GTK_NOTEBOOK (sample_notebook), child,
6690 expand, button->active, pack_type);
6694 tab_expand (GtkToggleButton *button, GtkWidget *child)
6697 GtkPackType pack_type;
6699 gtk_notebook_query_tab_label_packing (GTK_NOTEBOOK (sample_notebook), child,
6700 NULL, &fill, &pack_type);
6701 gtk_notebook_set_tab_label_packing (GTK_NOTEBOOK (sample_notebook), child,
6702 button->active, fill, pack_type);
6706 tab_pack (GtkToggleButton *button, GtkWidget *child)
6712 gtk_notebook_query_tab_label_packing (GTK_NOTEBOOK (sample_notebook), child,
6713 &expand, &fill, NULL);
6714 gtk_notebook_set_tab_label_packing (GTK_NOTEBOOK (sample_notebook), child,
6715 expand, fill, button->active);
6719 create_pages (GtkNotebook *notebook, gint start, gint end)
6721 GtkWidget *child = NULL;
6726 GtkWidget *label_box;
6727 GtkWidget *menu_box;
6732 for (i = start; i <= end; i++)
6734 sprintf (buffer, "Page %d", i);
6736 child = gtk_frame_new (buffer);
6737 gtk_container_set_border_width (GTK_CONTAINER (child), 10);
6739 vbox = gtk_vbox_new (TRUE,0);
6740 gtk_container_set_border_width (GTK_CONTAINER (vbox), 10);
6741 gtk_container_add (GTK_CONTAINER (child), vbox);
6743 hbox = gtk_hbox_new (TRUE,0);
6744 gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 5);
6746 button = gtk_check_button_new_with_label ("Fill Tab");
6747 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
6748 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
6749 gtk_signal_connect (GTK_OBJECT (button), "toggled",
6750 GTK_SIGNAL_FUNC (tab_fill), child);
6752 button = gtk_check_button_new_with_label ("Expand Tab");
6753 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
6754 gtk_signal_connect (GTK_OBJECT (button), "toggled",
6755 GTK_SIGNAL_FUNC (tab_expand), child);
6757 button = gtk_check_button_new_with_label ("Pack end");
6758 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
6759 gtk_signal_connect (GTK_OBJECT (button), "toggled",
6760 GTK_SIGNAL_FUNC (tab_pack), child);
6762 button = gtk_button_new_with_label ("Hide Page");
6763 gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 5);
6764 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
6765 GTK_SIGNAL_FUNC (gtk_widget_hide),
6766 GTK_OBJECT (child));
6768 gtk_widget_show_all (child);
6770 label_box = gtk_hbox_new (FALSE, 0);
6771 pixwid = gtk_pixmap_new (book_closed, book_closed_mask);
6772 gtk_object_set_data (GTK_OBJECT (child), "tab_pixmap", pixwid);
6774 gtk_box_pack_start (GTK_BOX (label_box), pixwid, FALSE, TRUE, 0);
6775 gtk_misc_set_padding (GTK_MISC (pixwid), 3, 1);
6776 label = gtk_label_new (buffer);
6777 gtk_box_pack_start (GTK_BOX (label_box), label, FALSE, TRUE, 0);
6778 gtk_widget_show_all (label_box);
6781 menu_box = gtk_hbox_new (FALSE, 0);
6782 pixwid = gtk_pixmap_new (book_closed, book_closed_mask);
6783 gtk_object_set_data (GTK_OBJECT (child), "menu_pixmap", pixwid);
6785 gtk_box_pack_start (GTK_BOX (menu_box), pixwid, FALSE, TRUE, 0);
6786 gtk_misc_set_padding (GTK_MISC (pixwid), 3, 1);
6787 label = gtk_label_new (buffer);
6788 gtk_box_pack_start (GTK_BOX (menu_box), label, FALSE, TRUE, 0);
6789 gtk_widget_show_all (menu_box);
6791 gtk_notebook_append_page_menu (notebook, child, label_box, menu_box);
6796 rotate_notebook (GtkButton *button,
6797 GtkNotebook *notebook)
6799 gtk_notebook_set_tab_pos (notebook, (notebook->tab_pos + 1) % 4);
6803 show_all_pages (GtkButton *button,
6804 GtkNotebook *notebook)
6806 gtk_container_foreach (GTK_CONTAINER (notebook),
6807 (GtkCallback) gtk_widget_show, NULL);
6811 standard_notebook (GtkButton *button,
6812 GtkNotebook *notebook)
6816 gtk_notebook_set_show_tabs (notebook, TRUE);
6817 gtk_notebook_set_show_border (notebook, TRUE);
6818 gtk_notebook_set_scrollable (notebook, FALSE);
6819 if (g_list_length (notebook->children) == 15)
6820 for (i = 0; i < 10; i++)
6821 gtk_notebook_remove_page (notebook, 5);
6825 notabs_notebook (GtkButton *button,
6826 GtkNotebook *notebook)
6830 gtk_notebook_set_show_tabs (notebook, FALSE);
6831 gtk_notebook_set_show_border (notebook, TRUE);
6832 if (g_list_length (notebook->children) == 15)
6833 for (i = 0; i < 10; i++)
6834 gtk_notebook_remove_page (notebook, 5);
6838 borderless_notebook (GtkButton *button,
6839 GtkNotebook *notebook)
6843 gtk_notebook_set_show_tabs (notebook, FALSE);
6844 gtk_notebook_set_show_border (notebook, FALSE);
6845 if (g_list_length (notebook->children) == 15)
6846 for (i = 0; i < 10; i++)
6847 gtk_notebook_remove_page (notebook, 5);
6851 scrollable_notebook (GtkButton *button,
6852 GtkNotebook *notebook)
6854 gtk_notebook_set_show_tabs (notebook, TRUE);
6855 gtk_notebook_set_show_border (notebook, TRUE);
6856 gtk_notebook_set_scrollable (notebook, TRUE);
6857 if (g_list_length (notebook->children) == 5)
6858 create_pages (notebook, 6, 15);
6862 notebook_popup (GtkToggleButton *button,
6863 GtkNotebook *notebook)
6866 gtk_notebook_popup_enable (notebook);
6868 gtk_notebook_popup_disable (notebook);
6872 notebook_homogeneous (GtkToggleButton *button,
6873 GtkNotebook *notebook)
6875 gtk_notebook_set_homogeneous_tabs (notebook, button->active);
6879 create_notebook (void)
6881 static GtkWidget *window = NULL;
6885 GtkWidget *separator;
6887 GdkColor *transparent = NULL;
6890 static OptionMenuItem items[] =
6892 { "Standard", standard_notebook },
6893 { "No tabs", notabs_notebook },
6894 { "Borderless", borderless_notebook },
6895 { "Scrollable", scrollable_notebook },
6900 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
6902 gtk_signal_connect (GTK_OBJECT (window), "destroy",
6903 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
6906 gtk_window_set_title (GTK_WINDOW (window), "notebook");
6907 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
6909 box1 = gtk_vbox_new (FALSE, 0);
6910 gtk_container_add (GTK_CONTAINER (window), box1);
6912 sample_notebook = gtk_notebook_new ();
6913 gtk_signal_connect (GTK_OBJECT (sample_notebook), "switch_page",
6914 GTK_SIGNAL_FUNC (page_switch), NULL);
6915 gtk_notebook_set_tab_pos (GTK_NOTEBOOK (sample_notebook), GTK_POS_TOP);
6916 gtk_box_pack_start (GTK_BOX (box1), sample_notebook, TRUE, TRUE, 0);
6917 gtk_container_set_border_width (GTK_CONTAINER (sample_notebook), 10);
6919 gtk_widget_realize (sample_notebook);
6921 book_open = gdk_pixmap_create_from_xpm_d (sample_notebook->window,
6926 book_closed = gdk_pixmap_create_from_xpm_d (sample_notebook->window,
6931 create_pages (GTK_NOTEBOOK (sample_notebook), 1, 5);
6933 separator = gtk_hseparator_new ();
6934 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 10);
6936 box2 = gtk_hbox_new (FALSE, 5);
6937 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
6938 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
6940 button = gtk_check_button_new_with_label ("popup menu");
6941 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, FALSE, 0);
6942 gtk_signal_connect (GTK_OBJECT(button), "clicked",
6943 GTK_SIGNAL_FUNC (notebook_popup),
6944 GTK_OBJECT (sample_notebook));
6946 button = gtk_check_button_new_with_label ("homogeneous tabs");
6947 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, FALSE, 0);
6948 gtk_signal_connect (GTK_OBJECT(button), "clicked",
6949 GTK_SIGNAL_FUNC (notebook_homogeneous),
6950 GTK_OBJECT (sample_notebook));
6952 box2 = gtk_hbox_new (FALSE, 5);
6953 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
6954 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
6956 label = gtk_label_new ("Notebook Style :");
6957 gtk_box_pack_start (GTK_BOX (box2), label, FALSE, TRUE, 0);
6959 omenu = build_option_menu (items, G_N_ELEMENTS (items), 0, sample_notebook);
6960 gtk_box_pack_start (GTK_BOX (box2), omenu, FALSE, TRUE, 0);
6962 button = gtk_button_new_with_label ("Show all Pages");
6963 gtk_box_pack_start (GTK_BOX (box2), button, FALSE, TRUE, 0);
6964 gtk_signal_connect (GTK_OBJECT (button), "clicked",
6965 GTK_SIGNAL_FUNC (show_all_pages), sample_notebook);
6967 box2 = gtk_hbox_new (TRUE, 10);
6968 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
6969 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
6971 button = gtk_button_new_with_label ("prev");
6972 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
6973 GTK_SIGNAL_FUNC (gtk_notebook_prev_page),
6974 GTK_OBJECT (sample_notebook));
6975 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
6977 button = gtk_button_new_with_label ("next");
6978 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
6979 GTK_SIGNAL_FUNC (gtk_notebook_next_page),
6980 GTK_OBJECT (sample_notebook));
6981 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
6983 button = gtk_button_new_with_label ("rotate");
6984 gtk_signal_connect (GTK_OBJECT (button), "clicked",
6985 GTK_SIGNAL_FUNC (rotate_notebook), sample_notebook);
6986 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
6988 separator = gtk_hseparator_new ();
6989 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 5);
6991 button = gtk_button_new_with_label ("close");
6992 gtk_container_set_border_width (GTK_CONTAINER (button), 5);
6993 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
6994 GTK_SIGNAL_FUNC (gtk_widget_destroy),
6995 GTK_OBJECT (window));
6996 gtk_box_pack_start (GTK_BOX (box1), button, FALSE, FALSE, 0);
6997 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
6998 gtk_widget_grab_default (button);
7001 if (!GTK_WIDGET_VISIBLE (window))
7002 gtk_widget_show_all (window);
7004 gtk_widget_destroy (window);
7012 toggle_resize (GtkWidget *widget, GtkWidget *child)
7014 GtkPaned *paned = GTK_PANED (child->parent);
7015 gboolean is_child1 = (child == paned->child1);
7016 gboolean resize, shrink;
7018 resize = is_child1 ? paned->child1_resize : paned->child2_resize;
7019 shrink = is_child1 ? paned->child1_shrink : paned->child2_shrink;
7021 gtk_widget_ref (child);
7022 gtk_container_remove (GTK_CONTAINER (child->parent), child);
7024 gtk_paned_pack1 (paned, child, !resize, shrink);
7026 gtk_paned_pack2 (paned, child, !resize, shrink);
7027 gtk_widget_unref (child);
7031 toggle_shrink (GtkWidget *widget, GtkWidget *child)
7033 GtkPaned *paned = GTK_PANED (child->parent);
7034 gboolean is_child1 = (child == paned->child1);
7035 gboolean resize, shrink;
7037 resize = is_child1 ? paned->child1_resize : paned->child2_resize;
7038 shrink = is_child1 ? paned->child1_shrink : paned->child2_shrink;
7040 gtk_widget_ref (child);
7041 gtk_container_remove (GTK_CONTAINER (child->parent), child);
7043 gtk_paned_pack1 (paned, child, resize, !shrink);
7045 gtk_paned_pack2 (paned, child, resize, !shrink);
7046 gtk_widget_unref (child);
7050 create_pane_options (GtkPaned *paned,
7051 const gchar *frame_label,
7052 const gchar *label1,
7053 const gchar *label2)
7058 GtkWidget *check_button;
7060 frame = gtk_frame_new (frame_label);
7061 gtk_container_set_border_width (GTK_CONTAINER (frame), 4);
7063 table = gtk_table_new (3, 2, 4);
7064 gtk_container_add (GTK_CONTAINER (frame), table);
7066 label = gtk_label_new (label1);
7067 gtk_table_attach_defaults (GTK_TABLE (table), label,
7070 check_button = gtk_check_button_new_with_label ("Resize");
7071 gtk_table_attach_defaults (GTK_TABLE (table), check_button,
7073 gtk_signal_connect (GTK_OBJECT (check_button), "toggled",
7074 GTK_SIGNAL_FUNC (toggle_resize),
7077 check_button = gtk_check_button_new_with_label ("Shrink");
7078 gtk_table_attach_defaults (GTK_TABLE (table), check_button,
7080 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check_button),
7082 gtk_signal_connect (GTK_OBJECT (check_button), "toggled",
7083 GTK_SIGNAL_FUNC (toggle_shrink),
7086 label = gtk_label_new (label2);
7087 gtk_table_attach_defaults (GTK_TABLE (table), label,
7090 check_button = gtk_check_button_new_with_label ("Resize");
7091 gtk_table_attach_defaults (GTK_TABLE (table), check_button,
7093 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check_button),
7095 gtk_signal_connect (GTK_OBJECT (check_button), "toggled",
7096 GTK_SIGNAL_FUNC (toggle_resize),
7099 check_button = gtk_check_button_new_with_label ("Shrink");
7100 gtk_table_attach_defaults (GTK_TABLE (table), check_button,
7102 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check_button),
7104 gtk_signal_connect (GTK_OBJECT (check_button), "toggled",
7105 GTK_SIGNAL_FUNC (toggle_shrink),
7114 static GtkWidget *window = NULL;
7123 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
7125 gtk_signal_connect (GTK_OBJECT (window), "destroy",
7126 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
7129 gtk_window_set_title (GTK_WINDOW (window), "Panes");
7130 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
7132 vbox = gtk_vbox_new (FALSE, 0);
7133 gtk_container_add (GTK_CONTAINER (window), vbox);
7135 vpaned = gtk_vpaned_new ();
7136 gtk_box_pack_start (GTK_BOX (vbox), vpaned, TRUE, TRUE, 0);
7137 gtk_container_set_border_width (GTK_CONTAINER(vpaned), 5);
7139 hpaned = gtk_hpaned_new ();
7140 gtk_paned_add1 (GTK_PANED (vpaned), hpaned);
7142 frame = gtk_frame_new (NULL);
7143 gtk_frame_set_shadow_type (GTK_FRAME(frame), GTK_SHADOW_IN);
7144 gtk_widget_set_usize (frame, 60, 60);
7145 gtk_paned_add1 (GTK_PANED (hpaned), frame);
7147 button = gtk_button_new_with_label ("Hi there");
7148 gtk_container_add (GTK_CONTAINER(frame), button);
7150 frame = gtk_frame_new (NULL);
7151 gtk_frame_set_shadow_type (GTK_FRAME(frame), GTK_SHADOW_IN);
7152 gtk_widget_set_usize (frame, 80, 60);
7153 gtk_paned_add2 (GTK_PANED (hpaned), frame);
7155 frame = gtk_frame_new (NULL);
7156 gtk_frame_set_shadow_type (GTK_FRAME(frame), GTK_SHADOW_IN);
7157 gtk_widget_set_usize (frame, 60, 80);
7158 gtk_paned_add2 (GTK_PANED (vpaned), frame);
7160 /* Now create toggle buttons to control sizing */
7162 gtk_box_pack_start (GTK_BOX (vbox),
7163 create_pane_options (GTK_PANED (hpaned),
7169 gtk_box_pack_start (GTK_BOX (vbox),
7170 create_pane_options (GTK_PANED (vpaned),
7176 gtk_widget_show_all (vbox);
7179 if (!GTK_WIDGET_VISIBLE (window))
7180 gtk_widget_show (window);
7182 gtk_widget_destroy (window);
7191 dnd_drop_destroy_popup (GtkWidget *widget, GtkWindow **window)
7193 if(GTK_IS_BUTTON(widget)) /* I.e. they clicked the close button */
7194 gtk_widget_destroy(GTK_WIDGET(*window));
7196 gtk_grab_remove(GTK_WIDGET(*window));
7204 dnd_drop (GtkWidget *button, GdkEvent *event)
7206 static GtkWidget *window = NULL;
7207 GtkWidget *vbox, *lbl, *btn;
7210 /* DND doesn't obey gtk_grab's, so check if we're already displaying
7211 * drop modal dialog first
7216 window = gtk_window_new(GTK_WINDOW_DIALOG);
7217 gtk_container_set_border_width (GTK_CONTAINER(window), 10);
7219 gtk_signal_connect (GTK_OBJECT (window), "destroy",
7220 GTK_SIGNAL_FUNC(dnd_drop_destroy_popup),
7222 gtk_signal_connect (GTK_OBJECT (window), "delete-event",
7223 GTK_SIGNAL_FUNC(gtk_false),
7226 vbox = gtk_vbox_new(FALSE, 5);
7228 /* Display message that we got from drop source */
7229 msg = g_malloc(strlen(event->dropdataavailable.data)
7230 + strlen(event->dropdataavailable.data_type) + 100);
7231 sprintf(msg, "Drop data of type %s was:\n\n%s",
7232 event->dropdataavailable.data_type,
7233 (char *)event->dropdataavailable.data);
7234 lbl = gtk_label_new(msg);
7235 gtk_label_set_justify(GTK_LABEL(lbl), GTK_JUSTIFY_FILL);
7237 gtk_widget_show(lbl);
7238 gtk_box_pack_start_defaults(GTK_BOX(vbox), lbl);
7240 /* Provide an obvious way out of this heinousness */
7241 btn = gtk_button_new_with_label("Continue with life in\nspite of this oppression");
7242 gtk_signal_connect_object (GTK_OBJECT (btn), "clicked",
7243 GTK_SIGNAL_FUNC(gtk_widget_destroy),
7244 GTK_OBJECT (window));
7245 gtk_widget_show(btn);
7246 gtk_box_pack_start_defaults(GTK_BOX(vbox), btn);
7248 gtk_container_add(GTK_CONTAINER(window), vbox);
7250 gtk_widget_show(vbox);
7251 gtk_grab_add(window);
7252 gtk_widget_show(window);
7256 dnd_drag_request (GtkWidget *button, GdkEvent *event)
7258 #define DND_STRING "Bill Gates demands royalties for\nyour use of his innovation."
7259 gtk_widget_dnd_data_set (button, event, DND_STRING, strlen(DND_STRING) + 1);
7265 static GtkWidget *window = NULL;
7271 GtkWidget *separator;
7273 /* For clarity... */
7274 char *possible_drag_types[] = {"text/plain"};
7275 char *accepted_drop_types[] = {"text/plain"};
7277 static GtkWidget *drag_icon = NULL;
7278 static GtkWidget *drop_icon = NULL;
7282 GdkPoint hotspot = {5,5};
7286 drag_icon = shape_create_icon ("Modeller.xpm",
7287 440, 140, 0,0, GTK_WINDOW_POPUP);
7289 gtk_signal_connect (GTK_OBJECT (drag_icon), "destroy",
7290 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
7293 gtk_widget_hide (drag_icon);
7298 drop_icon = shape_create_icon ("3DRings.xpm",
7299 440, 140, 0,0, GTK_WINDOW_POPUP);
7301 gtk_signal_connect (GTK_OBJECT (drop_icon), "destroy",
7302 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
7305 gtk_widget_hide (drop_icon);
7308 gdk_dnd_set_drag_shape(drag_icon->window,
7313 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
7315 gtk_signal_connect (GTK_OBJECT (window), "destroy",
7316 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
7319 gtk_window_set_title (GTK_WINDOW (window), "Drag -N- Drop");
7320 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
7322 box1 = gtk_vbox_new (FALSE, 0);
7323 gtk_container_add (GTK_CONTAINER (window), box1);
7324 gtk_widget_show (box1);
7326 box2 = gtk_hbox_new (FALSE, 5);
7327 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
7328 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
7329 gtk_widget_show (box2);
7331 frame = gtk_frame_new ("Drag");
7332 gtk_box_pack_start (GTK_BOX (box2), frame, TRUE, TRUE, 0);
7333 gtk_widget_show (frame);
7335 box3 = gtk_vbox_new (FALSE, 5);
7336 gtk_container_set_border_width (GTK_CONTAINER (box3), 5);
7337 gtk_container_add (GTK_CONTAINER (frame), box3);
7338 gtk_widget_show (box3);
7343 button = gtk_button_new_with_label ("Drag me!");
7344 gtk_box_pack_start (GTK_BOX (box3), button, FALSE, TRUE, 0);
7345 gtk_widget_show (button);
7348 * currently, the widget has to be realized to
7349 * set dnd on it, this needs to change
7351 gtk_widget_realize (button);
7352 gtk_signal_connect (GTK_OBJECT (button),
7353 "drag_request_event",
7354 GTK_SIGNAL_FUNC(dnd_drag_request),
7357 gtk_widget_dnd_drag_set (button, TRUE, possible_drag_types, 1);
7360 frame = gtk_frame_new ("Drop");
7361 gtk_box_pack_start (GTK_BOX (box2), frame, TRUE, TRUE, 0);
7362 gtk_widget_show (frame);
7364 box3 = gtk_vbox_new (FALSE, 5);
7365 gtk_container_set_border_width (GTK_CONTAINER (box3), 5);
7366 gtk_container_add (GTK_CONTAINER (frame), box3);
7367 gtk_widget_show (box3);
7373 button = gtk_button_new_with_label ("To");
7374 gtk_box_pack_start (GTK_BOX (box3), button, FALSE, TRUE, 0);
7375 gtk_widget_show (button);
7377 gtk_widget_realize (button);
7378 gtk_signal_connect (GTK_OBJECT (button),
7379 "drop_data_available_event",
7380 GTK_SIGNAL_FUNC(dnd_drop),
7383 gtk_widget_dnd_drop_set (button, TRUE, accepted_drop_types, 1, FALSE);
7386 separator = gtk_hseparator_new ();
7387 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
7388 gtk_widget_show (separator);
7391 box2 = gtk_vbox_new (FALSE, 10);
7392 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
7393 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
7394 gtk_widget_show (box2);
7397 button = gtk_button_new_with_label ("close");
7399 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
7400 GTK_SIGNAL_FUNC(gtk_widget_destroy),
7401 GTK_OBJECT (window));
7403 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
7404 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
7405 gtk_widget_grab_default (button);
7406 gtk_widget_show (button);
7409 if (!GTK_WIDGET_VISIBLE (window))
7410 gtk_widget_show (window);
7412 gtk_widget_destroy (window);
7420 typedef struct _cursoroffset {gint x,y;} CursorOffset;
7423 shape_pressed (GtkWidget *widget, GdkEventButton *event)
7427 /* ignore double and triple click */
7428 if (event->type != GDK_BUTTON_PRESS)
7431 p = gtk_object_get_user_data (GTK_OBJECT(widget));
7432 p->x = (int) event->x;
7433 p->y = (int) event->y;
7435 gtk_grab_add (widget);
7436 gdk_pointer_grab (widget->window, TRUE,
7437 GDK_BUTTON_RELEASE_MASK |
7438 GDK_BUTTON_MOTION_MASK |
7439 GDK_POINTER_MOTION_HINT_MASK,
7444 shape_released (GtkWidget *widget)
7446 gtk_grab_remove (widget);
7447 gdk_pointer_ungrab (0);
7451 shape_motion (GtkWidget *widget,
7452 GdkEventMotion *event)
7456 GdkModifierType mask;
7458 p = gtk_object_get_user_data (GTK_OBJECT (widget));
7461 * Can't use event->x / event->y here
7462 * because I need absolute coordinates.
7464 gdk_window_get_pointer (NULL, &xp, &yp, &mask);
7465 gtk_widget_set_uposition (widget, xp - p->x, yp - p->y);
7469 shape_create_icon (char *xpm_file,
7479 CursorOffset* icon_pos;
7481 GdkBitmap *gdk_pixmap_mask;
7482 GdkPixmap *gdk_pixmap;
7485 style = gtk_widget_get_default_style ();
7486 gc = style->black_gc;
7489 * GDK_WINDOW_TOPLEVEL works also, giving you a title border
7491 window = gtk_window_new (window_type);
7493 fixed = gtk_fixed_new ();
7494 gtk_widget_set_usize (fixed, 100,100);
7495 gtk_container_add (GTK_CONTAINER (window), fixed);
7496 gtk_widget_show (fixed);
7498 gtk_widget_set_events (window,
7499 gtk_widget_get_events (window) |
7500 GDK_BUTTON_MOTION_MASK |
7501 GDK_POINTER_MOTION_HINT_MASK |
7502 GDK_BUTTON_PRESS_MASK);
7504 gtk_widget_realize (window);
7505 gdk_pixmap = gdk_pixmap_create_from_xpm (window->window, &gdk_pixmap_mask,
7506 &style->bg[GTK_STATE_NORMAL],
7509 pixmap = gtk_pixmap_new (gdk_pixmap, gdk_pixmap_mask);
7510 gtk_fixed_put (GTK_FIXED (fixed), pixmap, px,py);
7511 gtk_widget_show (pixmap);
7513 gtk_widget_shape_combine_mask (window, gdk_pixmap_mask, px, py);
7515 gdk_drawable_unref (gdk_pixmap_mask);
7516 gdk_drawable_unref (gdk_pixmap);
7518 gtk_signal_connect (GTK_OBJECT (window), "button_press_event",
7519 GTK_SIGNAL_FUNC (shape_pressed),NULL);
7520 gtk_signal_connect (GTK_OBJECT (window), "button_release_event",
7521 GTK_SIGNAL_FUNC (shape_released),NULL);
7522 gtk_signal_connect (GTK_OBJECT (window), "motion_notify_event",
7523 GTK_SIGNAL_FUNC (shape_motion),NULL);
7525 icon_pos = g_new (CursorOffset, 1);
7526 gtk_object_set_user_data(GTK_OBJECT(window), icon_pos);
7528 gtk_widget_set_uposition (window, x, y);
7529 gtk_widget_show (window);
7535 create_shapes (void)
7537 /* Variables used by the Drag/Drop and Shape Window demos */
7538 static GtkWidget *modeller = NULL;
7539 static GtkWidget *sheets = NULL;
7540 static GtkWidget *rings = NULL;
7542 if (!(file_exists ("Modeller.xpm") &&
7543 file_exists ("FilesQueue.xpm") &&
7544 file_exists ("3DRings.xpm")))
7550 modeller = shape_create_icon ("Modeller.xpm",
7551 440, 140, 0,0, GTK_WINDOW_POPUP);
7553 gtk_signal_connect (GTK_OBJECT (modeller), "destroy",
7554 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
7558 gtk_widget_destroy (modeller);
7562 sheets = shape_create_icon ("FilesQueue.xpm",
7563 580, 170, 0,0, GTK_WINDOW_POPUP);
7565 gtk_signal_connect (GTK_OBJECT (sheets), "destroy",
7566 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
7571 gtk_widget_destroy (sheets);
7575 rings = shape_create_icon ("3DRings.xpm",
7576 460, 270, 25,25, GTK_WINDOW_TOPLEVEL);
7578 gtk_signal_connect (GTK_OBJECT (rings), "destroy",
7579 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
7583 gtk_widget_destroy (rings);
7591 create_wmhints (void)
7593 static GtkWidget *window = NULL;
7595 GtkWidget *separator;
7604 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
7606 gtk_signal_connect (GTK_OBJECT (window), "destroy",
7607 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
7610 gtk_window_set_title (GTK_WINDOW (window), "WM Hints");
7611 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
7613 gtk_widget_realize (window);
7615 circles = gdk_bitmap_create_from_data (window->window,
7619 gdk_window_set_icon (window->window, NULL,
7622 gdk_window_set_icon_name (window->window, "WMHints Test Icon");
7624 gdk_window_set_decorations (window->window, GDK_DECOR_ALL | GDK_DECOR_MENU);
7625 gdk_window_set_functions (window->window, GDK_FUNC_ALL | GDK_FUNC_RESIZE);
7627 box1 = gtk_vbox_new (FALSE, 0);
7628 gtk_container_add (GTK_CONTAINER (window), box1);
7629 gtk_widget_show (box1);
7631 label = gtk_label_new ("Try iconizing me!");
7632 gtk_widget_set_usize (label, 150, 50);
7633 gtk_box_pack_start (GTK_BOX (box1), label, TRUE, TRUE, 0);
7634 gtk_widget_show (label);
7637 separator = gtk_hseparator_new ();
7638 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
7639 gtk_widget_show (separator);
7642 box2 = gtk_vbox_new (FALSE, 10);
7643 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
7644 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
7645 gtk_widget_show (box2);
7648 button = gtk_button_new_with_label ("close");
7650 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
7651 GTK_SIGNAL_FUNC(gtk_widget_destroy),
7652 GTK_OBJECT (window));
7654 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
7655 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
7656 gtk_widget_grab_default (button);
7657 gtk_widget_show (button);
7660 if (!GTK_WIDGET_VISIBLE (window))
7661 gtk_widget_show (window);
7663 gtk_widget_destroy (window);
7670 typedef struct _ProgressData {
7673 GtkWidget *block_spin;
7674 GtkWidget *x_align_spin;
7675 GtkWidget *y_align_spin;
7676 GtkWidget *step_spin;
7677 GtkWidget *act_blocks_spin;
7686 progress_timeout (gpointer data)
7691 adj = GTK_PROGRESS (data)->adjustment;
7693 new_val = adj->value + 1;
7694 if (new_val > adj->upper)
7695 new_val = adj->lower;
7697 gtk_progress_set_value (GTK_PROGRESS (data), new_val);
7703 destroy_progress (GtkWidget *widget,
7704 ProgressData **pdata)
7706 gtk_timeout_remove ((*pdata)->timer);
7707 (*pdata)->timer = 0;
7708 (*pdata)->window = NULL;
7714 progressbar_toggle_orientation (GtkWidget *widget, ProgressData *pdata)
7718 if (!GTK_WIDGET_MAPPED (widget))
7721 RADIOMENUTOGGLED ((GtkRadioMenuItem *)
7722 (((GtkOptionMenu *)(pdata->omenu1))->menu_item), i);
7724 gtk_progress_bar_set_orientation (GTK_PROGRESS_BAR (pdata->pbar),
7725 (GtkProgressBarOrientation) (3-i));
7729 toggle_show_text (GtkWidget *widget, ProgressData *pdata)
7731 gtk_progress_set_show_text (GTK_PROGRESS (pdata->pbar),
7732 GTK_TOGGLE_BUTTON (widget)->active);
7733 gtk_widget_set_sensitive (pdata->entry, GTK_TOGGLE_BUTTON (widget)->active);
7734 gtk_widget_set_sensitive (pdata->x_align_spin,
7735 GTK_TOGGLE_BUTTON (widget)->active);
7736 gtk_widget_set_sensitive (pdata->y_align_spin,
7737 GTK_TOGGLE_BUTTON (widget)->active);
7741 progressbar_toggle_bar_style (GtkWidget *widget, ProgressData *pdata)
7745 if (!GTK_WIDGET_MAPPED (widget))
7748 RADIOMENUTOGGLED ((GtkRadioMenuItem *)
7749 (((GtkOptionMenu *)(pdata->omenu2))->menu_item), i);
7754 gtk_widget_set_sensitive (pdata->block_spin, TRUE);
7756 gtk_widget_set_sensitive (pdata->block_spin, FALSE);
7758 gtk_progress_bar_set_bar_style (GTK_PROGRESS_BAR (pdata->pbar),
7759 (GtkProgressBarStyle) i);
7763 progress_value_changed (GtkAdjustment *adj, ProgressData *pdata)
7767 if (GTK_PROGRESS (pdata->pbar)->activity_mode)
7768 sprintf (buf, "???");
7770 sprintf (buf, "%.0f%%", 100 *
7771 gtk_progress_get_current_percentage (GTK_PROGRESS (pdata->pbar)));
7772 gtk_label_set_text (GTK_LABEL (pdata->label), buf);
7776 adjust_blocks (GtkAdjustment *adj, ProgressData *pdata)
7778 gtk_progress_set_percentage (GTK_PROGRESS (pdata->pbar), 0);
7779 gtk_progress_bar_set_discrete_blocks (GTK_PROGRESS_BAR (pdata->pbar),
7780 gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (pdata->block_spin)));
7784 adjust_step (GtkAdjustment *adj, ProgressData *pdata)
7786 gtk_progress_bar_set_activity_step (GTK_PROGRESS_BAR (pdata->pbar),
7787 gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (pdata->step_spin)));
7791 adjust_act_blocks (GtkAdjustment *adj, ProgressData *pdata)
7793 gtk_progress_bar_set_activity_blocks (GTK_PROGRESS_BAR (pdata->pbar),
7794 gtk_spin_button_get_value_as_int
7795 (GTK_SPIN_BUTTON (pdata->act_blocks_spin)));
7799 adjust_align (GtkAdjustment *adj, ProgressData *pdata)
7801 gtk_progress_set_text_alignment (GTK_PROGRESS (pdata->pbar),
7802 gtk_spin_button_get_value_as_float
7803 (GTK_SPIN_BUTTON (pdata->x_align_spin)),
7804 gtk_spin_button_get_value_as_float
7805 (GTK_SPIN_BUTTON (pdata->y_align_spin)));
7809 toggle_activity_mode (GtkWidget *widget, ProgressData *pdata)
7811 gtk_progress_set_activity_mode (GTK_PROGRESS (pdata->pbar),
7812 GTK_TOGGLE_BUTTON (widget)->active);
7813 gtk_widget_set_sensitive (pdata->step_spin,
7814 GTK_TOGGLE_BUTTON (widget)->active);
7815 gtk_widget_set_sensitive (pdata->act_blocks_spin,
7816 GTK_TOGGLE_BUTTON (widget)->active);
7820 entry_changed (GtkWidget *widget, ProgressData *pdata)
7822 gtk_progress_set_format_string (GTK_PROGRESS (pdata->pbar),
7823 gtk_entry_get_text (GTK_ENTRY (pdata->entry)));
7827 create_progress_bar (void)
7839 static ProgressData *pdata = NULL;
7841 static OptionMenuItem items1[] =
7843 { "Left-Right", progressbar_toggle_orientation },
7844 { "Right-Left", progressbar_toggle_orientation },
7845 { "Bottom-Top", progressbar_toggle_orientation },
7846 { "Top-Bottom", progressbar_toggle_orientation }
7849 static OptionMenuItem items2[] =
7851 { "Continuous", progressbar_toggle_bar_style },
7852 { "Discrete", progressbar_toggle_bar_style }
7856 pdata = g_new0 (ProgressData, 1);
7860 pdata->window = gtk_dialog_new ();
7862 gtk_window_set_policy (GTK_WINDOW (pdata->window), FALSE, FALSE, TRUE);
7864 gtk_signal_connect (GTK_OBJECT (pdata->window), "destroy",
7865 GTK_SIGNAL_FUNC (destroy_progress),
7870 gtk_window_set_title (GTK_WINDOW (pdata->window), "GtkProgressBar");
7871 gtk_container_set_border_width (GTK_CONTAINER (pdata->window), 0);
7873 vbox = gtk_vbox_new (FALSE, 5);
7874 gtk_container_set_border_width (GTK_CONTAINER (vbox), 10);
7875 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (pdata->window)->vbox),
7876 vbox, FALSE, TRUE, 0);
7878 frame = gtk_frame_new ("Progress");
7879 gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, TRUE, 0);
7881 vbox2 = gtk_vbox_new (FALSE, 5);
7882 gtk_container_add (GTK_CONTAINER (frame), vbox2);
7884 align = gtk_alignment_new (0.5, 0.5, 0, 0);
7885 gtk_box_pack_start (GTK_BOX (vbox2), align, FALSE, FALSE, 5);
7887 adj = (GtkAdjustment *) gtk_adjustment_new (0, 1, 300, 0, 0, 0);
7888 gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
7889 GTK_SIGNAL_FUNC (progress_value_changed), pdata);
7891 pdata->pbar = gtk_progress_bar_new_with_adjustment (adj);
7892 gtk_progress_set_format_string (GTK_PROGRESS (pdata->pbar),
7893 "%v from [%l,%u] (=%p%%)");
7894 gtk_container_add (GTK_CONTAINER (align), pdata->pbar);
7895 pdata->timer = gtk_timeout_add (100, progress_timeout, pdata->pbar);
7897 align = gtk_alignment_new (0.5, 0.5, 0, 0);
7898 gtk_box_pack_start (GTK_BOX (vbox2), align, FALSE, FALSE, 5);
7900 hbox = gtk_hbox_new (FALSE, 5);
7901 gtk_container_add (GTK_CONTAINER (align), hbox);
7902 label = gtk_label_new ("Label updated by user :");
7903 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
7904 pdata->label = gtk_label_new ("");
7905 gtk_box_pack_start (GTK_BOX (hbox), pdata->label, FALSE, TRUE, 0);
7907 frame = gtk_frame_new ("Options");
7908 gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, TRUE, 0);
7910 vbox2 = gtk_vbox_new (FALSE, 5);
7911 gtk_container_add (GTK_CONTAINER (frame), vbox2);
7913 tab = gtk_table_new (7, 2, FALSE);
7914 gtk_box_pack_start (GTK_BOX (vbox2), tab, FALSE, TRUE, 0);
7916 label = gtk_label_new ("Orientation :");
7917 gtk_table_attach (GTK_TABLE (tab), label, 0, 1, 0, 1,
7918 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
7920 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
7922 pdata->omenu1 = build_option_menu (items1, 4, 0, pdata);
7923 hbox = gtk_hbox_new (FALSE, 0);
7924 gtk_table_attach (GTK_TABLE (tab), hbox, 1, 2, 0, 1,
7925 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
7927 gtk_box_pack_start (GTK_BOX (hbox), pdata->omenu1, TRUE, TRUE, 0);
7929 check = gtk_check_button_new_with_label ("Show text");
7930 gtk_signal_connect (GTK_OBJECT (check), "clicked",
7931 GTK_SIGNAL_FUNC (toggle_show_text),
7933 gtk_table_attach (GTK_TABLE (tab), check, 0, 1, 1, 2,
7934 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
7937 hbox = gtk_hbox_new (FALSE, 0);
7938 gtk_table_attach (GTK_TABLE (tab), hbox, 1, 2, 1, 2,
7939 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
7942 label = gtk_label_new ("Format : ");
7943 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
7945 pdata->entry = gtk_entry_new ();
7946 gtk_signal_connect (GTK_OBJECT (pdata->entry), "changed",
7947 GTK_SIGNAL_FUNC (entry_changed),
7949 gtk_box_pack_start (GTK_BOX (hbox), pdata->entry, TRUE, TRUE, 0);
7950 gtk_entry_set_text (GTK_ENTRY (pdata->entry), "%v from [%l,%u] (=%p%%)");
7951 gtk_widget_set_usize (pdata->entry, 100, -1);
7952 gtk_widget_set_sensitive (pdata->entry, FALSE);
7954 label = gtk_label_new ("Text align :");
7955 gtk_table_attach (GTK_TABLE (tab), label, 0, 1, 2, 3,
7956 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
7958 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
7960 hbox = gtk_hbox_new (FALSE, 0);
7961 gtk_table_attach (GTK_TABLE (tab), hbox, 1, 2, 2, 3,
7962 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
7965 label = gtk_label_new ("x :");
7966 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 5);
7968 adj = (GtkAdjustment *) gtk_adjustment_new (0.5, 0, 1, 0.1, 0.1, 0);
7969 pdata->x_align_spin = gtk_spin_button_new (adj, 0, 1);
7970 gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
7971 GTK_SIGNAL_FUNC (adjust_align), pdata);
7972 gtk_box_pack_start (GTK_BOX (hbox), pdata->x_align_spin, FALSE, TRUE, 0);
7973 gtk_widget_set_sensitive (pdata->x_align_spin, FALSE);
7975 label = gtk_label_new ("y :");
7976 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 5);
7978 adj = (GtkAdjustment *) gtk_adjustment_new (0.5, 0, 1, 0.1, 0.1, 0);
7979 pdata->y_align_spin = gtk_spin_button_new (adj, 0, 1);
7980 gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
7981 GTK_SIGNAL_FUNC (adjust_align), pdata);
7982 gtk_box_pack_start (GTK_BOX (hbox), pdata->y_align_spin, FALSE, TRUE, 0);
7983 gtk_widget_set_sensitive (pdata->y_align_spin, FALSE);
7985 label = gtk_label_new ("Bar Style :");
7986 gtk_table_attach (GTK_TABLE (tab), label, 0, 1, 3, 4,
7987 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
7989 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
7991 pdata->omenu2 = build_option_menu (items2, 2, 0, pdata);
7992 hbox = gtk_hbox_new (FALSE, 0);
7993 gtk_table_attach (GTK_TABLE (tab), hbox, 1, 2, 3, 4,
7994 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
7996 gtk_box_pack_start (GTK_BOX (hbox), pdata->omenu2, TRUE, TRUE, 0);
7998 label = gtk_label_new ("Block count :");
7999 gtk_table_attach (GTK_TABLE (tab), label, 0, 1, 4, 5,
8000 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
8002 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
8004 hbox = gtk_hbox_new (FALSE, 0);
8005 gtk_table_attach (GTK_TABLE (tab), hbox, 1, 2, 4, 5,
8006 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
8008 adj = (GtkAdjustment *) gtk_adjustment_new (10, 2, 20, 1, 5, 0);
8009 pdata->block_spin = gtk_spin_button_new (adj, 0, 0);
8010 gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
8011 GTK_SIGNAL_FUNC (adjust_blocks), pdata);
8012 gtk_box_pack_start (GTK_BOX (hbox), pdata->block_spin, FALSE, TRUE, 0);
8013 gtk_widget_set_sensitive (pdata->block_spin, FALSE);
8015 check = gtk_check_button_new_with_label ("Activity mode");
8016 gtk_signal_connect (GTK_OBJECT (check), "clicked",
8017 GTK_SIGNAL_FUNC (toggle_activity_mode),
8019 gtk_table_attach (GTK_TABLE (tab), check, 0, 1, 5, 6,
8020 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
8023 hbox = gtk_hbox_new (FALSE, 0);
8024 gtk_table_attach (GTK_TABLE (tab), hbox, 1, 2, 5, 6,
8025 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
8027 label = gtk_label_new ("Step size : ");
8028 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
8029 adj = (GtkAdjustment *) gtk_adjustment_new (3, 1, 20, 1, 5, 0);
8030 pdata->step_spin = gtk_spin_button_new (adj, 0, 0);
8031 gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
8032 GTK_SIGNAL_FUNC (adjust_step), pdata);
8033 gtk_box_pack_start (GTK_BOX (hbox), pdata->step_spin, FALSE, TRUE, 0);
8034 gtk_widget_set_sensitive (pdata->step_spin, FALSE);
8036 hbox = gtk_hbox_new (FALSE, 0);
8037 gtk_table_attach (GTK_TABLE (tab), hbox, 1, 2, 6, 7,
8038 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
8040 label = gtk_label_new ("Blocks : ");
8041 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
8042 adj = (GtkAdjustment *) gtk_adjustment_new (5, 2, 10, 1, 5, 0);
8043 pdata->act_blocks_spin = gtk_spin_button_new (adj, 0, 0);
8044 gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
8045 GTK_SIGNAL_FUNC (adjust_act_blocks), pdata);
8046 gtk_box_pack_start (GTK_BOX (hbox), pdata->act_blocks_spin, FALSE, TRUE,
8048 gtk_widget_set_sensitive (pdata->act_blocks_spin, FALSE);
8050 button = gtk_button_new_with_label ("close");
8051 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
8052 GTK_SIGNAL_FUNC (gtk_widget_destroy),
8053 GTK_OBJECT (pdata->window));
8054 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
8055 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (pdata->window)->action_area),
8056 button, TRUE, TRUE, 0);
8057 gtk_widget_grab_default (button);
8060 if (!GTK_WIDGET_VISIBLE (pdata->window))
8061 gtk_widget_show_all (pdata->window);
8063 gtk_widget_destroy (pdata->window);
8070 static int color_idle = 0;
8073 color_idle_func (GtkWidget *preview)
8075 static int count = 1;
8079 for (i = 0; i < 256; i++)
8081 for (j = 0, k = 0; j < 256; j++)
8083 buf[k+0] = i + count;
8085 buf[k+2] = j + count;
8089 gtk_preview_draw_row (GTK_PREVIEW (preview), buf, 0, i, 256);
8094 gtk_widget_draw (preview, NULL);
8100 color_preview_destroy (GtkWidget *widget,
8103 gtk_idle_remove (color_idle);
8110 create_color_preview (void)
8112 static GtkWidget *window = NULL;
8119 gtk_widget_push_colormap (gdk_rgb_get_cmap ());
8120 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
8121 gtk_widget_pop_colormap ();
8123 gtk_signal_connect (GTK_OBJECT (window), "destroy",
8124 GTK_SIGNAL_FUNC(color_preview_destroy),
8127 gtk_window_set_title (GTK_WINDOW (window), "test");
8128 gtk_container_set_border_width (GTK_CONTAINER (window), 10);
8130 preview = gtk_preview_new (GTK_PREVIEW_COLOR);
8131 gtk_preview_size (GTK_PREVIEW (preview), 256, 256);
8132 gtk_container_add (GTK_CONTAINER (window), preview);
8134 for (i = 0; i < 256; i++)
8136 for (j = 0, k = 0; j < 256; j++)
8144 gtk_preview_draw_row (GTK_PREVIEW (preview), buf, 0, i, 256);
8147 color_idle = gtk_idle_add ((GtkFunction) color_idle_func, preview);
8150 if (!GTK_WIDGET_VISIBLE (window))
8151 gtk_widget_show_all (window);
8153 gtk_widget_destroy (window);
8160 static int gray_idle = 0;
8163 gray_idle_func (GtkWidget *preview)
8165 static int count = 1;
8169 for (i = 0; i < 256; i++)
8171 for (j = 0; j < 256; j++)
8172 buf[j] = i + j + count;
8174 gtk_preview_draw_row (GTK_PREVIEW (preview), buf, 0, i, 256);
8179 gtk_widget_draw (preview, NULL);
8185 gray_preview_destroy (GtkWidget *widget,
8188 gtk_idle_remove (gray_idle);
8195 create_gray_preview (void)
8197 static GtkWidget *window = NULL;
8204 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
8206 gtk_signal_connect (GTK_OBJECT (window), "destroy",
8207 GTK_SIGNAL_FUNC(gray_preview_destroy),
8210 gtk_window_set_title (GTK_WINDOW (window), "test");
8211 gtk_container_set_border_width (GTK_CONTAINER (window), 10);
8213 preview = gtk_preview_new (GTK_PREVIEW_GRAYSCALE);
8214 gtk_preview_size (GTK_PREVIEW (preview), 256, 256);
8215 gtk_container_add (GTK_CONTAINER (window), preview);
8217 for (i = 0; i < 256; i++)
8219 for (j = 0; j < 256; j++)
8222 gtk_preview_draw_row (GTK_PREVIEW (preview), buf, 0, i, 256);
8225 gray_idle = gtk_idle_add ((GtkFunction) gray_idle_func, preview);
8228 if (!GTK_WIDGET_VISIBLE (window))
8229 gtk_widget_show_all (window);
8231 gtk_widget_destroy (window);
8240 selection_test_received (GtkWidget *list, GtkSelectionData *data)
8243 GtkWidget *list_item;
8247 if (data->length < 0)
8249 g_print ("Selection retrieval failed\n");
8252 if (data->type != GDK_SELECTION_TYPE_ATOM)
8254 g_print ("Selection \"TARGETS\" was not returned as atoms!\n");
8258 /* Clear out any current list items */
8260 gtk_list_clear_items (GTK_LIST(list), 0, -1);
8262 /* Add new items to list */
8264 atoms = (GdkAtom *)data->data;
8267 l = data->length / sizeof (GdkAtom);
8268 for (i = 0; i < l; i++)
8271 name = gdk_atom_name (atoms[i]);
8274 list_item = gtk_list_item_new_with_label (name);
8278 list_item = gtk_list_item_new_with_label ("(bad atom)");
8280 gtk_widget_show (list_item);
8281 item_list = g_list_append (item_list, list_item);
8284 gtk_list_append_items (GTK_LIST (list), item_list);
8290 selection_test_get_targets (GtkWidget *widget, GtkWidget *list)
8292 static GdkAtom targets_atom = GDK_NONE;
8294 if (targets_atom == GDK_NONE)
8295 targets_atom = gdk_atom_intern ("TARGETS", FALSE);
8297 gtk_selection_convert (list, GDK_SELECTION_PRIMARY, targets_atom,
8302 create_selection_test (void)
8304 static GtkWidget *window = NULL;
8307 GtkWidget *scrolled_win;
8313 window = gtk_dialog_new ();
8315 gtk_signal_connect (GTK_OBJECT (window), "destroy",
8316 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
8319 gtk_window_set_title (GTK_WINDOW (window), "Selection Test");
8320 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
8322 /* Create the list */
8324 vbox = gtk_vbox_new (FALSE, 5);
8325 gtk_container_set_border_width (GTK_CONTAINER (vbox), 10);
8326 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), vbox,
8329 label = gtk_label_new ("Gets available targets for current selection");
8330 gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
8332 scrolled_win = gtk_scrolled_window_new (NULL, NULL);
8333 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
8334 GTK_POLICY_AUTOMATIC,
8335 GTK_POLICY_AUTOMATIC);
8336 gtk_box_pack_start (GTK_BOX (vbox), scrolled_win, TRUE, TRUE, 0);
8337 gtk_widget_set_usize (scrolled_win, 100, 200);
8339 list = gtk_list_new ();
8340 gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (scrolled_win), list);
8342 gtk_signal_connect (GTK_OBJECT(list), "selection_received",
8343 GTK_SIGNAL_FUNC (selection_test_received), NULL);
8345 /* .. And create some buttons */
8346 button = gtk_button_new_with_label ("Get Targets");
8347 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
8348 button, TRUE, TRUE, 0);
8350 gtk_signal_connect (GTK_OBJECT (button), "clicked",
8351 GTK_SIGNAL_FUNC (selection_test_get_targets), list);
8353 button = gtk_button_new_with_label ("Quit");
8354 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
8355 button, TRUE, TRUE, 0);
8357 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
8358 GTK_SIGNAL_FUNC (gtk_widget_destroy),
8359 GTK_OBJECT (window));
8362 if (!GTK_WIDGET_VISIBLE (window))
8363 gtk_widget_show_all (window);
8365 gtk_widget_destroy (window);
8373 create_gamma_curve (void)
8375 static GtkWidget *window = NULL, *curve;
8376 static int count = 0;
8383 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
8384 gtk_window_set_title (GTK_WINDOW (window), "test");
8385 gtk_container_set_border_width (GTK_CONTAINER (window), 10);
8387 gtk_signal_connect (GTK_OBJECT (window), "destroy",
8388 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
8391 curve = gtk_gamma_curve_new ();
8392 gtk_container_add (GTK_CONTAINER (window), curve);
8393 gtk_widget_show (curve);
8396 max = 127 + (count % 2)*128;
8397 gtk_curve_set_range (GTK_CURVE (GTK_GAMMA_CURVE (curve)->curve),
8399 for (i = 0; i < max; ++i)
8400 vec[i] = (127 / sqrt (max)) * sqrt (i);
8401 gtk_curve_set_vector (GTK_CURVE (GTK_GAMMA_CURVE (curve)->curve),
8404 if (!GTK_WIDGET_VISIBLE (window))
8405 gtk_widget_show (window);
8406 else if (count % 4 == 3)
8408 gtk_widget_destroy (window);
8419 static int scroll_test_pos = 0.0;
8420 static GdkGC *scroll_test_gc = NULL;
8423 scroll_test_expose (GtkWidget *widget, GdkEventExpose *event,
8427 gint imin, imax, jmin, jmax;
8429 imin = (event->area.x) / 10;
8430 imax = (event->area.x + event->area.width + 9) / 10;
8432 jmin = ((int)adj->value + event->area.y) / 10;
8433 jmax = ((int)adj->value + event->area.y + event->area.height + 9) / 10;
8435 gdk_window_clear_area (widget->window,
8436 event->area.x, event->area.y,
8437 event->area.width, event->area.height);
8439 for (i=imin; i<imax; i++)
8440 for (j=jmin; j<jmax; j++)
8442 gdk_draw_rectangle (widget->window,
8443 widget->style->black_gc,
8445 10*i, 10*j - (int)adj->value, 1+i%10, 1+j%10);
8451 scroll_test_scroll (GtkWidget *widget, GdkEventScroll *event,
8454 gfloat new_value = adj->value + ((event->direction == GDK_SCROLL_UP) ?
8455 -adj->page_increment / 2:
8456 adj->page_increment / 2);
8457 new_value = CLAMP (new_value, adj->lower, adj->upper - adj->page_size);
8458 gtk_adjustment_set_value (adj, new_value);
8464 scroll_test_configure (GtkWidget *widget, GdkEventConfigure *event,
8467 adj->page_increment = 0.9 * widget->allocation.height;
8468 adj->page_size = widget->allocation.height;
8470 gtk_signal_emit_by_name (GTK_OBJECT (adj), "changed");
8474 scroll_test_adjustment_changed (GtkAdjustment *adj, GtkWidget *widget)
8476 gint source_min = (int)adj->value - scroll_test_pos;
8477 gint source_max = source_min + widget->allocation.height;
8479 gint dest_max = widget->allocation.height;
8483 scroll_test_pos = adj->value;
8485 if (!GTK_WIDGET_DRAWABLE (widget))
8492 rect.width = widget->allocation.width;
8493 rect.height = -source_min;
8494 if (rect.height > widget->allocation.height)
8495 rect.height = widget->allocation.height;
8498 dest_min = rect.height;
8503 rect.y = 2*widget->allocation.height - source_max;
8506 rect.width = widget->allocation.width;
8507 rect.height = widget->allocation.height - rect.y;
8509 source_max = widget->allocation.height;
8513 if (source_min != source_max)
8515 if (scroll_test_gc == NULL)
8517 scroll_test_gc = gdk_gc_new (widget->window);
8518 gdk_gc_set_exposures (scroll_test_gc, TRUE);
8521 gdk_draw_pixmap (widget->window,
8526 widget->allocation.width,
8527 source_max - source_min);
8529 /* Make sure graphics expose events are processed before scrolling
8532 while ((event = gdk_event_get_graphics_expose (widget->window)) != NULL)
8534 gtk_widget_event (widget, event);
8535 if (event->expose.count == 0)
8537 gdk_event_free (event);
8540 gdk_event_free (event);
8544 if (rect.height != 0)
8545 gtk_widget_draw (widget, &rect);
8550 create_scroll_test (void)
8552 static GtkWidget *window = NULL;
8554 GtkWidget *drawing_area;
8555 GtkWidget *scrollbar;
8558 GdkGeometry geometry;
8559 GdkWindowHints geometry_mask;
8563 window = gtk_dialog_new ();
8565 gtk_signal_connect (GTK_OBJECT (window), "destroy",
8566 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
8569 gtk_window_set_title (GTK_WINDOW (window), "Scroll Test");
8570 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
8572 hbox = gtk_hbox_new (FALSE, 0);
8573 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), hbox,
8575 gtk_widget_show (hbox);
8577 drawing_area = gtk_drawing_area_new ();
8578 gtk_drawing_area_size (GTK_DRAWING_AREA (drawing_area), 200, 200);
8579 gtk_box_pack_start (GTK_BOX (hbox), drawing_area, TRUE, TRUE, 0);
8580 gtk_widget_show (drawing_area);
8582 gtk_widget_set_events (drawing_area, GDK_EXPOSURE_MASK | GDK_SCROLL_MASK);
8584 adj = GTK_ADJUSTMENT (gtk_adjustment_new (0.0, 0.0, 1000.0, 1.0, 180.0, 200.0));
8585 scroll_test_pos = 0.0;
8587 scrollbar = gtk_vscrollbar_new (adj);
8588 gtk_box_pack_start (GTK_BOX (hbox), scrollbar, FALSE, FALSE, 0);
8589 gtk_widget_show (scrollbar);
8591 gtk_signal_connect (GTK_OBJECT (drawing_area), "expose_event",
8592 GTK_SIGNAL_FUNC (scroll_test_expose), adj);
8593 gtk_signal_connect (GTK_OBJECT (drawing_area), "configure_event",
8594 GTK_SIGNAL_FUNC (scroll_test_configure), adj);
8595 gtk_signal_connect (GTK_OBJECT (drawing_area), "scroll_event",
8596 GTK_SIGNAL_FUNC (scroll_test_scroll), adj);
8598 gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
8599 GTK_SIGNAL_FUNC (scroll_test_adjustment_changed),
8602 /* .. And create some buttons */
8604 button = gtk_button_new_with_label ("Quit");
8605 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
8606 button, TRUE, TRUE, 0);
8608 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
8609 GTK_SIGNAL_FUNC (gtk_widget_destroy),
8610 GTK_OBJECT (window));
8611 gtk_widget_show (button);
8613 /* Set up gridded geometry */
8615 geometry_mask = GDK_HINT_MIN_SIZE |
8616 GDK_HINT_BASE_SIZE |
8617 GDK_HINT_RESIZE_INC;
8619 geometry.min_width = 20;
8620 geometry.min_height = 20;
8621 geometry.base_width = 0;
8622 geometry.base_height = 0;
8623 geometry.width_inc = 10;
8624 geometry.height_inc = 10;
8626 gtk_window_set_geometry_hints (GTK_WINDOW (window),
8627 drawing_area, &geometry, geometry_mask);
8630 if (!GTK_WIDGET_VISIBLE (window))
8631 gtk_widget_show (window);
8633 gtk_widget_destroy (window);
8640 static int timer = 0;
8643 timeout_test (GtkWidget *label)
8645 static int count = 0;
8646 static char buffer[32];
8648 sprintf (buffer, "count: %d", ++count);
8649 gtk_label_set_text (GTK_LABEL (label), buffer);
8655 start_timeout_test (GtkWidget *widget,
8660 timer = gtk_timeout_add (100, (GtkFunction) timeout_test, label);
8665 stop_timeout_test (GtkWidget *widget,
8670 gtk_timeout_remove (timer);
8676 destroy_timeout_test (GtkWidget *widget,
8679 stop_timeout_test (NULL, NULL);
8685 create_timeout_test (void)
8687 static GtkWidget *window = NULL;
8693 window = gtk_dialog_new ();
8695 gtk_signal_connect (GTK_OBJECT (window), "destroy",
8696 GTK_SIGNAL_FUNC(destroy_timeout_test),
8699 gtk_window_set_title (GTK_WINDOW (window), "Timeout Test");
8700 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
8702 label = gtk_label_new ("count: 0");
8703 gtk_misc_set_padding (GTK_MISC (label), 10, 10);
8704 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox),
8705 label, TRUE, TRUE, 0);
8706 gtk_widget_show (label);
8708 button = gtk_button_new_with_label ("close");
8709 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
8710 GTK_SIGNAL_FUNC(gtk_widget_destroy),
8711 GTK_OBJECT (window));
8712 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
8713 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
8714 button, TRUE, TRUE, 0);
8715 gtk_widget_grab_default (button);
8716 gtk_widget_show (button);
8718 button = gtk_button_new_with_label ("start");
8719 gtk_signal_connect (GTK_OBJECT (button), "clicked",
8720 GTK_SIGNAL_FUNC(start_timeout_test),
8722 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
8723 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
8724 button, TRUE, TRUE, 0);
8725 gtk_widget_show (button);
8727 button = gtk_button_new_with_label ("stop");
8728 gtk_signal_connect (GTK_OBJECT (button), "clicked",
8729 GTK_SIGNAL_FUNC(stop_timeout_test),
8731 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
8732 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
8733 button, TRUE, TRUE, 0);
8734 gtk_widget_show (button);
8737 if (!GTK_WIDGET_VISIBLE (window))
8738 gtk_widget_show (window);
8740 gtk_widget_destroy (window);
8747 static int idle_id = 0;
8750 idle_test (GtkWidget *label)
8752 static int count = 0;
8753 static char buffer[32];
8755 sprintf (buffer, "count: %d", ++count);
8756 gtk_label_set_text (GTK_LABEL (label), buffer);
8762 start_idle_test (GtkWidget *widget,
8767 idle_id = gtk_idle_add ((GtkFunction) idle_test, label);
8772 stop_idle_test (GtkWidget *widget,
8777 gtk_idle_remove (idle_id);
8783 destroy_idle_test (GtkWidget *widget,
8786 stop_idle_test (NULL, NULL);
8792 toggle_idle_container (GtkObject *button,
8793 GtkContainer *container)
8795 gtk_container_set_resize_mode (container, GPOINTER_TO_INT (gtk_object_get_user_data (button)));
8799 create_idle_test (void)
8801 static GtkWidget *window = NULL;
8804 GtkWidget *container;
8811 window = gtk_dialog_new ();
8813 gtk_signal_connect (GTK_OBJECT (window), "destroy",
8814 GTK_SIGNAL_FUNC(destroy_idle_test),
8817 gtk_window_set_title (GTK_WINDOW (window), "Idle Test");
8818 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
8820 label = gtk_label_new ("count: 0");
8821 gtk_misc_set_padding (GTK_MISC (label), 10, 10);
8822 gtk_widget_show (label);
8825 gtk_widget_new (GTK_TYPE_HBOX,
8826 "GtkWidget::visible", TRUE,
8827 /* "GtkContainer::child", gtk_widget_new (GTK_TYPE_HBOX,
8828 * "GtkWidget::visible", TRUE,
8830 "GtkContainer::child", label,
8833 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox),
8834 container, TRUE, TRUE, 0);
8837 gtk_widget_new (GTK_TYPE_FRAME,
8838 "GtkContainer::border_width", 5,
8839 "GtkFrame::label", "Label Container",
8840 "GtkWidget::visible", TRUE,
8841 "GtkWidget::parent", GTK_DIALOG (window)->vbox,
8844 gtk_widget_new (GTK_TYPE_VBOX,
8845 "GtkWidget::visible", TRUE,
8846 "GtkWidget::parent", frame,
8849 gtk_widget_new (GTK_TYPE_RADIO_BUTTON,
8850 "GtkButton::label", "Resize-Parent",
8851 "GtkObject::user_data", (void*)GTK_RESIZE_PARENT,
8852 "GtkObject::signal::clicked", toggle_idle_container, container,
8853 "GtkWidget::visible", TRUE,
8854 "GtkWidget::parent", box,
8857 gtk_widget_new (GTK_TYPE_RADIO_BUTTON,
8858 "GtkButton::label", "Resize-Queue",
8859 "GtkObject::user_data", (void*)GTK_RESIZE_QUEUE,
8860 "GtkObject::signal::clicked", toggle_idle_container, container,
8861 "GtkRadioButton::group", button,
8862 "GtkWidget::visible", TRUE,
8863 "GtkWidget::parent", box,
8866 gtk_widget_new (GTK_TYPE_RADIO_BUTTON,
8867 "GtkButton::label", "Resize-Immediate",
8868 "GtkObject::user_data", (void*)GTK_RESIZE_IMMEDIATE,
8869 "GtkObject::signal::clicked", toggle_idle_container, container,
8870 "GtkRadioButton::group", button,
8871 "GtkWidget::visible", TRUE,
8872 "GtkWidget::parent", box,
8876 button = gtk_button_new_with_label ("close");
8877 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
8878 GTK_SIGNAL_FUNC(gtk_widget_destroy),
8879 GTK_OBJECT (window));
8880 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
8881 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
8882 button, TRUE, TRUE, 0);
8883 gtk_widget_grab_default (button);
8884 gtk_widget_show (button);
8886 button = gtk_button_new_with_label ("start");
8887 gtk_signal_connect (GTK_OBJECT (button), "clicked",
8888 GTK_SIGNAL_FUNC(start_idle_test),
8890 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
8891 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
8892 button, TRUE, TRUE, 0);
8893 gtk_widget_show (button);
8895 button = gtk_button_new_with_label ("stop");
8896 gtk_signal_connect (GTK_OBJECT (button), "clicked",
8897 GTK_SIGNAL_FUNC(stop_idle_test),
8899 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
8900 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
8901 button, TRUE, TRUE, 0);
8902 gtk_widget_show (button);
8905 if (!GTK_WIDGET_VISIBLE (window))
8906 gtk_widget_show (window);
8908 gtk_widget_destroy (window);
8916 reload_rc_file (void)
8920 if (gtk_rc_reparse_all ())
8922 toplevels = gdk_window_get_toplevels();
8926 gdk_window_get_user_data (toplevels->data, (gpointer *)&widget);
8929 gtk_widget_reset_rc_styles (widget);
8931 toplevels = toplevels->next;
8933 g_list_free (toplevels);
8938 reload_all_rc_files (void)
8940 static GdkAtom atom_rcfiles = GDK_NONE;
8946 atom_rcfiles = gdk_atom_intern("_GTK_READ_RCFILES", FALSE);
8948 for(i = 0; i < 5; i++)
8950 sev.data_format = 32;
8951 sev.message_type = atom_rcfiles;
8952 gdk_event_send_clientmessage_toall ((GdkEvent *) &sev);
8956 create_rc_file (void)
8958 static GtkWidget *window = NULL;
8963 window = gtk_dialog_new ();
8965 gtk_signal_connect (GTK_OBJECT (window), "destroy",
8966 GTK_SIGNAL_FUNC(destroy_idle_test),
8969 gtk_window_set_title (GTK_WINDOW (window), "Reload Rc file");
8970 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
8972 button = gtk_button_new_with_label ("Reload");
8973 gtk_signal_connect (GTK_OBJECT (button), "clicked",
8974 GTK_SIGNAL_FUNC(reload_rc_file), NULL);
8975 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
8976 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
8977 button, TRUE, TRUE, 0);
8978 gtk_widget_grab_default (button);
8979 gtk_widget_show (button);
8981 button = gtk_button_new_with_label ("Reload All");
8982 gtk_signal_connect (GTK_OBJECT (button), "clicked",
8983 GTK_SIGNAL_FUNC(reload_all_rc_files), NULL);
8984 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
8985 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
8986 button, TRUE, TRUE, 0);
8987 gtk_widget_show (button);
8989 button = gtk_button_new_with_label ("Close");
8990 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
8991 GTK_SIGNAL_FUNC(gtk_widget_destroy),
8992 GTK_OBJECT (window));
8993 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
8994 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
8995 button, TRUE, TRUE, 0);
8996 gtk_widget_show (button);
9000 if (!GTK_WIDGET_VISIBLE (window))
9001 gtk_widget_show (window);
9003 gtk_widget_destroy (window);
9007 * Test of recursive mainloop
9011 mainloop_destroyed (GtkWidget *w, GtkWidget **window)
9018 create_mainloop (void)
9020 static GtkWidget *window = NULL;
9026 window = gtk_dialog_new ();
9028 gtk_window_set_title (GTK_WINDOW (window), "Test Main Loop");
9030 gtk_signal_connect (GTK_OBJECT (window), "destroy",
9031 GTK_SIGNAL_FUNC(mainloop_destroyed),
9034 label = gtk_label_new ("In recursive main loop...");
9035 gtk_misc_set_padding (GTK_MISC(label), 20, 20);
9037 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), label,
9039 gtk_widget_show (label);
9041 button = gtk_button_new_with_label ("Leave");
9042 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area), button,
9045 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
9046 GTK_SIGNAL_FUNC (gtk_widget_destroy),
9047 GTK_OBJECT (window));
9049 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
9050 gtk_widget_grab_default (button);
9052 gtk_widget_show (button);
9055 if (!GTK_WIDGET_VISIBLE (window))
9057 gtk_widget_show (window);
9059 g_print ("create_mainloop: start\n");
9061 g_print ("create_mainloop: done\n");
9064 gtk_widget_destroy (window);
9068 layout_expose_handler (GtkWidget *widget, GdkEventExpose *event)
9073 gint imin, imax, jmin, jmax;
9075 layout = GTK_LAYOUT (widget);
9077 imin = (layout->xoffset + event->area.x) / 10;
9078 imax = (layout->xoffset + event->area.x + event->area.width + 9) / 10;
9080 jmin = (layout->yoffset + event->area.y) / 10;
9081 jmax = (layout->yoffset + event->area.y + event->area.height + 9) / 10;
9083 gdk_window_clear_area (widget->window,
9084 event->area.x, event->area.y,
9085 event->area.width, event->area.height);
9087 for (i=imin; i<imax; i++)
9088 for (j=jmin; j<jmax; j++)
9090 gdk_draw_rectangle (layout->bin_window,
9091 widget->style->black_gc,
9093 10*i - layout->xoffset, 10*j - layout->yoffset,
9099 void create_layout (void)
9101 static GtkWidget *window = NULL;
9103 GtkWidget *scrolledwindow;
9112 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
9113 gtk_signal_connect (GTK_OBJECT (window), "destroy",
9114 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
9117 gtk_window_set_title (GTK_WINDOW (window), "Layout");
9118 gtk_widget_set_usize (window, 200, 200);
9120 scrolledwindow = gtk_scrolled_window_new (NULL, NULL);
9121 gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolledwindow),
9123 gtk_scrolled_window_set_placement (GTK_SCROLLED_WINDOW (scrolledwindow),
9124 GTK_CORNER_TOP_RIGHT);
9126 gtk_container_add (GTK_CONTAINER (window), scrolledwindow);
9128 layout = gtk_layout_new (NULL, NULL);
9129 gtk_container_add (GTK_CONTAINER (scrolledwindow), layout);
9131 /* We set step sizes here since GtkLayout does not set
9134 GTK_LAYOUT (layout)->hadjustment->step_increment = 10.0;
9135 GTK_LAYOUT (layout)->vadjustment->step_increment = 10.0;
9137 gtk_widget_set_events (layout, GDK_EXPOSURE_MASK);
9138 gtk_signal_connect (GTK_OBJECT (layout), "expose_event",
9139 GTK_SIGNAL_FUNC (layout_expose_handler), NULL);
9141 gtk_layout_set_size (GTK_LAYOUT (layout), 1600, 128000);
9143 for (i=0 ; i < 16 ; i++)
9144 for (j=0 ; j < 16 ; j++)
9146 sprintf(buf, "Button %d, %d", i, j);
9148 button = gtk_button_new_with_label (buf);
9150 button = gtk_label_new (buf);
9152 gtk_layout_put (GTK_LAYOUT (layout), button,
9156 for (i=16; i < 1280; i++)
9158 sprintf(buf, "Button %d, %d", i, 0);
9160 button = gtk_button_new_with_label (buf);
9162 button = gtk_label_new (buf);
9164 gtk_layout_put (GTK_LAYOUT (layout), button,
9169 if (!GTK_WIDGET_VISIBLE (window))
9170 gtk_widget_show_all (window);
9172 gtk_widget_destroy (window);
9176 create_styles (void)
9178 static GtkWidget *window = NULL;
9183 static GdkColor red = { 0, 0xffff, 0, 0 };
9184 static GdkColor green = { 0, 0, 0xffff, 0 };
9185 static GdkColor blue = { 0, 0, 0, 0xffff };
9186 static GdkColor yellow = { 0, 0xffff, 0xffff, 0 };
9187 static GdkColor cyan = { 0, 0 , 0xffff, 0xffff };
9188 PangoFontDescription *font_desc;
9190 GtkRcStyle *rc_style;
9194 window = gtk_dialog_new ();
9195 gtk_signal_connect (GTK_OBJECT (window), "destroy",
9196 GTK_SIGNAL_FUNC(gtk_widget_destroyed),
9200 button = gtk_button_new_with_label ("Close");
9201 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
9202 GTK_SIGNAL_FUNC(gtk_widget_destroy),
9203 GTK_OBJECT (window));
9204 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
9205 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
9206 button, TRUE, TRUE, 0);
9207 gtk_widget_show (button);
9209 vbox = gtk_vbox_new (FALSE, 5);
9210 gtk_container_set_border_width (GTK_CONTAINER (vbox), 10);
9211 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), vbox, FALSE, FALSE, 0);
9213 label = gtk_label_new ("Font:");
9214 gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
9215 gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
9217 font_desc = pango_font_description_from_string ("Helvetica,Sans Oblique 18");
9219 button = gtk_button_new_with_label ("Some Text");
9220 gtk_widget_modify_font (GTK_BIN (button)->child, font_desc);
9221 gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
9223 label = gtk_label_new ("Foreground:");
9224 gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
9225 gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
9227 button = gtk_button_new_with_label ("Some Text");
9228 gtk_widget_modify_fg (GTK_BIN (button)->child, GTK_STATE_NORMAL, &red);
9229 gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
9231 label = gtk_label_new ("Background:");
9232 gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
9233 gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
9235 button = gtk_button_new_with_label ("Some Text");
9236 gtk_widget_modify_bg (button, GTK_STATE_NORMAL, &green);
9237 gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
9239 label = gtk_label_new ("Text:");
9240 gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
9241 gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
9243 entry = gtk_entry_new ();
9244 gtk_entry_set_text (GTK_ENTRY (entry), "Some Text");
9245 gtk_widget_modify_text (entry, GTK_STATE_NORMAL, &blue);
9246 gtk_box_pack_start (GTK_BOX (vbox), entry, FALSE, FALSE, 0);
9248 label = gtk_label_new ("Base:");
9249 gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
9250 gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
9252 entry = gtk_entry_new ();
9253 gtk_entry_set_text (GTK_ENTRY (entry), "Some Text");
9254 gtk_widget_modify_base (entry, GTK_STATE_NORMAL, &yellow);
9255 gtk_box_pack_start (GTK_BOX (vbox), entry, FALSE, FALSE, 0);
9257 label = gtk_label_new ("Multiple:");
9258 gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
9259 gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
9261 button = gtk_button_new_with_label ("Some Text");
9263 rc_style = gtk_rc_style_new ();
9265 rc_style->font_desc = font_desc;
9266 rc_style->color_flags[GTK_STATE_NORMAL] = GTK_RC_FG | GTK_RC_BG;
9267 rc_style->color_flags[GTK_STATE_PRELIGHT] = GTK_RC_FG | GTK_RC_BG;
9268 rc_style->color_flags[GTK_STATE_ACTIVE] = GTK_RC_FG | GTK_RC_BG;
9269 rc_style->fg[GTK_STATE_NORMAL] = yellow;
9270 rc_style->bg[GTK_STATE_NORMAL] = blue;
9271 rc_style->fg[GTK_STATE_PRELIGHT] = blue;
9272 rc_style->bg[GTK_STATE_PRELIGHT] = yellow;
9273 rc_style->fg[GTK_STATE_ACTIVE] = red;
9274 rc_style->bg[GTK_STATE_ACTIVE] = cyan;
9275 rc_style->xthickness = 5;
9276 rc_style->ythickness = 5;
9278 gtk_widget_modify_style (button, rc_style);
9279 gtk_widget_modify_style (GTK_BIN (button)->child, rc_style);
9281 g_object_unref (G_OBJECT (rc_style));
9283 gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
9286 if (!GTK_WIDGET_VISIBLE (window))
9287 gtk_widget_show_all (window);
9289 gtk_widget_destroy (window);
9293 * Main Window and Exit
9297 do_exit (GtkWidget *widget, GtkWidget *window)
9299 gtk_widget_destroy (window);
9304 create_main_window (void)
9311 { "button box", create_button_box },
9312 { "buttons", create_buttons },
9313 { "check buttons", create_check_buttons },
9314 { "clist", create_clist},
9315 { "color selection", create_color_selection },
9316 { "ctree", create_ctree },
9317 { "cursors", create_cursors },
9318 { "dialog", create_dialog },
9319 /* { "dnd", create_dnd }, */
9320 { "entry", create_entry },
9321 { "event watcher", create_event_watcher },
9322 { "file selection", create_file_selection },
9323 { "flipping", create_flipping },
9324 { "font selection", create_font_selection },
9325 { "gamma curve", create_gamma_curve },
9326 { "handle box", create_handle_box },
9327 { "image from drawable", create_get_image },
9328 { "image", create_image },
9329 { "item factory", create_item_factory },
9330 { "labels", create_labels },
9331 { "layout", create_layout },
9332 { "list", create_list },
9333 { "menus", create_menus },
9334 { "message dialog", create_message_dialog },
9335 { "modal window", create_modal_window },
9336 { "notebook", create_notebook },
9337 { "panes", create_panes },
9338 { "pixmap", create_pixmap },
9339 { "preview color", create_color_preview },
9340 { "preview gray", create_gray_preview },
9341 { "progress bar", create_progress_bar },
9342 { "radio buttons", create_radio_buttons },
9343 { "range controls", create_range_controls },
9344 { "rc file", create_rc_file },
9345 { "reparent", create_reparent },
9346 { "rulers", create_rulers },
9347 { "saved position", create_saved_position },
9348 { "scrolled windows", create_scrolled_windows },
9349 { "shapes", create_shapes },
9350 { "spinbutton", create_spins },
9351 { "statusbar", create_statusbar },
9352 { "styles", create_styles },
9353 { "test idle", create_idle_test },
9354 { "test mainloop", create_mainloop },
9355 { "test scrolling", create_scroll_test },
9356 { "test selection", create_selection_test },
9357 { "test timeout", create_timeout_test },
9358 { "text", create_text },
9359 { "toggle buttons", create_toggle_buttons },
9360 { "toolbar", create_toolbar },
9361 { "tooltips", create_tooltips },
9362 { "tree", create_tree_mode_window},
9363 { "WM hints", create_wmhints },
9365 int nbuttons = sizeof (buttons) / sizeof (buttons[0]);
9369 GtkWidget *scrolled_window;
9373 GtkWidget *separator;
9374 GdkGeometry geometry;
9377 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
9378 gtk_widget_set_name (window, "main window");
9379 gtk_widget_set_uposition (window, 20, 20);
9380 gtk_window_set_default_size (GTK_WINDOW (window), -1, 400);
9382 geometry.min_width = -1;
9383 geometry.min_height = -1;
9384 geometry.max_width = -1;
9385 geometry.max_height = G_MAXSHORT;
9386 gtk_window_set_geometry_hints (GTK_WINDOW (window), NULL,
9388 GDK_HINT_MIN_SIZE | GDK_HINT_MAX_SIZE);
9390 gtk_signal_connect (GTK_OBJECT (window), "destroy",
9391 GTK_SIGNAL_FUNC(gtk_main_quit),
9393 gtk_signal_connect (GTK_OBJECT (window), "delete-event",
9394 GTK_SIGNAL_FUNC (gtk_false),
9397 box1 = gtk_vbox_new (FALSE, 0);
9398 gtk_container_add (GTK_CONTAINER (window), box1);
9400 if (gtk_micro_version > 0)
9412 label = gtk_label_new (buffer);
9413 gtk_box_pack_start (GTK_BOX (box1), label, FALSE, FALSE, 0);
9415 scrolled_window = gtk_scrolled_window_new (NULL, NULL);
9416 gtk_container_set_border_width (GTK_CONTAINER (scrolled_window), 10);
9417 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
9419 GTK_POLICY_AUTOMATIC);
9420 gtk_box_pack_start (GTK_BOX (box1), scrolled_window, TRUE, TRUE, 0);
9422 box2 = gtk_vbox_new (FALSE, 0);
9423 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
9424 gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (scrolled_window), box2);
9425 gtk_container_set_focus_vadjustment (GTK_CONTAINER (box2),
9426 gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (scrolled_window)));
9427 gtk_widget_show (box2);
9429 for (i = 0; i < nbuttons; i++)
9431 button = gtk_button_new_with_label (buttons[i].label);
9432 if (buttons[i].func)
9433 gtk_signal_connect (GTK_OBJECT (button),
9435 GTK_SIGNAL_FUNC(buttons[i].func),
9438 gtk_widget_set_sensitive (button, FALSE);
9439 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
9442 separator = gtk_hseparator_new ();
9443 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
9445 box2 = gtk_vbox_new (FALSE, 10);
9446 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
9447 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
9449 button = gtk_button_new_with_label ("close");
9450 gtk_signal_connect (GTK_OBJECT (button), "clicked",
9451 GTK_SIGNAL_FUNC (do_exit),
9453 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
9454 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
9455 gtk_widget_grab_default (button);
9457 gtk_widget_show_all (window);
9463 if (file_exists ("../gdk-pixbuf/.libs/libpixbufloader-pnm.so"))
9465 putenv ("GDK_PIXBUF_MODULEDIR=../gdk-pixbuf/.libs");
9466 putenv ("GTK_IM_MODULE_FILE=./gtk.immodules");
9471 main (int argc, char *argv[])
9473 GtkBindingSet *binding_set;
9475 g_mem_set_vtable (glib_mem_profiler_table);
9477 srand (time (NULL));
9482 /* Check to see if we are being run from the correct
9485 if (file_exists ("testgtkrc"))
9486 gtk_rc_add_default_file ("testgtkrc");
9488 gtk_init (&argc, &argv);
9492 binding_set = gtk_binding_set_by_class (gtk_type_class (GTK_TYPE_WIDGET));
9493 gtk_binding_entry_add_signal (binding_set,
9494 '9', GDK_CONTROL_MASK | GDK_RELEASE_MASK,
9497 GTK_TYPE_STRING, "GtkWidgetClass <ctrl><release>9 test");
9499 create_main_window ();
9505 while (g_main_pending ())
9506 g_main_iteration (FALSE);
9508 while (g_main_pending ())
9509 g_main_iteration (FALSE);