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/.
44 #include "gdk/gdkkeysyms.h"
47 #define sleep(n) _sleep(n)
50 #include "prop-editor.h"
55 file_exists (const char *filename)
59 return stat (filename, &statbuf) == 0;
63 shape_create_icon (GdkScreen *screen,
72 build_option_menu (gchar *items[],
75 void (*func) (GtkWidget *widget, gpointer data),
78 /* macro, structure and variables used by tree window demos */
79 #define DEFAULT_NUMBER_OF_ITEM 3
80 #define DEFAULT_RECURSION_LEVEL 3
83 GSList* selection_mode_group;
84 GtkWidget* single_button;
85 GtkWidget* browse_button;
86 GtkWidget* multiple_button;
87 GtkWidget* draw_line_button;
88 GtkWidget* view_line_button;
89 GtkWidget* no_root_item_button;
90 GtkWidget* nb_item_spinner;
91 GtkWidget* recursion_spinner;
92 } sTreeSampleSelection;
94 typedef struct sTreeButtons {
96 GtkWidget* add_button;
97 GtkWidget* remove_button;
98 GtkWidget* subtree_button;
100 /* end of tree section */
103 build_option_menu (gchar *items[],
106 void (*func)(GtkWidget *widget, gpointer data),
112 omenu = gtk_combo_box_new_text ();
113 g_signal_connect (omenu, "changed",
114 G_CALLBACK (func), data);
116 for (i = 0; i < num_items; i++)
117 gtk_combo_box_append_text (GTK_COMBO_BOX (omenu), items[i]);
119 gtk_combo_box_set_active (GTK_COMBO_BOX (omenu), history);
125 * Windows with an alpha channel
130 on_alpha_window_draw (GtkWidget *widget,
133 cairo_pattern_t *pattern;
134 int radius, width, height;
136 width = gtk_widget_get_allocated_width (widget);
137 height = gtk_widget_get_allocated_height (widget);
138 radius = MIN (width, height) / 2;
139 pattern = cairo_pattern_create_radial (width / 2,
146 if (gdk_screen_get_rgba_visual (gtk_widget_get_screen (widget)) &&
147 gtk_widget_is_composited (widget))
148 cairo_set_source_rgba (cr, 1.0, 1.0, 1.0, 0.0); /* transparent */
150 cairo_set_source_rgb (cr, 1.0, 1.0, 1.0); /* opaque white */
152 cairo_set_operator (cr, CAIRO_OPERATOR_SOURCE);
155 cairo_pattern_add_color_stop_rgba (pattern, 0.0,
156 1.0, 0.75, 0.0, 1.0); /* solid orange */
157 cairo_pattern_add_color_stop_rgba (pattern, 1.0,
158 1.0, 0.75, 0.0, 0.0); /* transparent orange */
160 cairo_set_source (cr, pattern);
161 cairo_pattern_destroy (pattern);
163 cairo_set_operator (cr, CAIRO_OPERATOR_OVER);
170 build_alpha_widgets (void)
173 GtkWidget *radio_button;
178 table = gtk_table_new (1, 1, FALSE);
180 radio_button = gtk_radio_button_new_with_label (NULL, "Red");
181 gtk_table_attach (GTK_TABLE (table),
184 GTK_EXPAND | GTK_FILL, 0,
187 radio_button = gtk_radio_button_new_with_label_from_widget (GTK_RADIO_BUTTON (radio_button), "Green");
188 gtk_table_attach (GTK_TABLE (table),
191 GTK_EXPAND | GTK_FILL, 0,
194 radio_button = gtk_radio_button_new_with_label_from_widget (GTK_RADIO_BUTTON (radio_button), "Blue"),
195 gtk_table_attach (GTK_TABLE (table),
198 GTK_EXPAND | GTK_FILL, 0,
201 gtk_table_attach (GTK_TABLE (table),
202 gtk_check_button_new_with_label ("Sedentary"),
204 GTK_EXPAND | GTK_FILL, 0,
206 gtk_table_attach (GTK_TABLE (table),
207 gtk_check_button_new_with_label ("Nocturnal"),
209 GTK_EXPAND | GTK_FILL, 0,
211 gtk_table_attach (GTK_TABLE (table),
212 gtk_check_button_new_with_label ("Compulsive"),
214 GTK_EXPAND | GTK_FILL, 0,
217 radio_button = gtk_radio_button_new_with_label_from_widget (GTK_RADIO_BUTTON (radio_button), "Green");
218 gtk_table_attach (GTK_TABLE (table),
221 GTK_EXPAND | GTK_FILL, 0,
224 radio_button = gtk_radio_button_new_with_label_from_widget (GTK_RADIO_BUTTON (radio_button), "Blue"),
225 gtk_table_attach (GTK_TABLE (table),
228 GTK_EXPAND | GTK_FILL, 0,
231 hbox = gtk_hbox_new (FALSE, 0);
232 label = gtk_label_new (NULL);
233 gtk_label_set_markup (GTK_LABEL (label), "<i>Entry: </i>");
234 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
235 entry = gtk_entry_new ();
236 gtk_box_pack_start (GTK_BOX (hbox), entry, TRUE, TRUE, 0);
237 gtk_table_attach (GTK_TABLE (table),
240 GTK_EXPAND | GTK_FILL, 0,
247 on_alpha_screen_changed (GtkWindow *window,
248 GdkScreen *old_screen,
251 GdkScreen *screen = gtk_widget_get_screen (GTK_WIDGET (window));
252 GdkVisual *visual = gdk_screen_get_rgba_visual (screen);
256 visual = gdk_screen_get_system_visual (screen);
257 gtk_label_set_markup (GTK_LABEL (label), "<b>Screen doesn't support alpha</b>");
261 gtk_label_set_markup (GTK_LABEL (label), "<b>Screen supports alpha</b>");
264 gtk_widget_set_visual (GTK_WIDGET (window), visual);
268 on_composited_changed (GtkWidget *window,
271 gboolean is_composited = gtk_widget_is_composited (window);
274 gtk_label_set_text (label, "Composited");
276 gtk_label_set_text (label, "Not composited");
280 create_alpha_window (GtkWidget *widget)
282 static GtkWidget *window;
286 GtkWidget *content_area;
290 window = gtk_dialog_new_with_buttons ("Alpha Window",
291 GTK_WINDOW (gtk_widget_get_toplevel (widget)), 0,
295 gtk_widget_set_app_paintable (window, TRUE);
296 g_signal_connect (window, "draw",
297 G_CALLBACK (on_alpha_window_draw), NULL);
299 content_area = gtk_dialog_get_content_area (GTK_DIALOG (window));
301 vbox = gtk_vbox_new (FALSE, 8);
302 gtk_container_set_border_width (GTK_CONTAINER (vbox), 12);
303 gtk_box_pack_start (GTK_BOX (content_area), vbox,
306 label = gtk_label_new (NULL);
307 gtk_box_pack_start (GTK_BOX (vbox), label, TRUE, TRUE, 0);
308 on_alpha_screen_changed (GTK_WINDOW (window), NULL, label);
309 g_signal_connect (window, "screen-changed",
310 G_CALLBACK (on_alpha_screen_changed), label);
312 label = gtk_label_new (NULL);
313 gtk_box_pack_start (GTK_BOX (vbox), label, TRUE, TRUE, 0);
314 on_composited_changed (window, GTK_LABEL (label));
315 g_signal_connect (window, "composited_changed", G_CALLBACK (on_composited_changed), label);
317 gtk_box_pack_start (GTK_BOX (vbox), build_alpha_widgets (), TRUE, TRUE, 0);
319 g_signal_connect (window, "destroy",
320 G_CALLBACK (gtk_widget_destroyed),
323 g_signal_connect (window, "response",
324 G_CALLBACK (gtk_widget_destroy),
328 if (!gtk_widget_get_visible (window))
329 gtk_widget_show_all (window);
331 gtk_widget_destroy (window);
335 * Composited non-toplevel window
338 /* The draw event handler for the event box.
340 * This function simply draws a transparency onto a widget on the area
341 * for which it receives expose events. This is intended to give the
342 * event box a "transparent" background.
344 * In order for this to work properly, the widget must have an RGBA
345 * colourmap. The widget should also be set as app-paintable since it
346 * doesn't make sense for GTK to draw a background if we are drawing it
347 * (and because GTK might actually replace our transparency with its
348 * default background colour).
351 transparent_draw (GtkWidget *widget,
354 cairo_set_operator (cr, CAIRO_OPERATOR_CLEAR);
360 /* The expose event handler for the window.
362 * This function performs the actual compositing of the event box onto
363 * the already-existing background of the window at 50% normal opacity.
365 * In this case we do not want app-paintable to be set on the widget
366 * since we want it to draw its own (red) background. Because of this,
367 * however, we must ensure that we use g_signal_register_after so that
368 * this handler is called after the red has been drawn. If it was
369 * called before then GTK would just blindly paint over our work.
372 window_draw (GtkWidget *widget,
375 GtkAllocation allocation;
378 /* get our child (in this case, the event box) */
379 child = gtk_bin_get_child (GTK_BIN (widget));
381 gtk_widget_get_allocation (child, &allocation);
383 /* the source data is the (composited) event box */
384 gdk_cairo_set_source_window (cr, gtk_widget_get_window (child),
388 /* composite, with a 50% opacity */
389 cairo_paint_with_alpha (cr, 0.5);
395 create_composited_window (GtkWidget *widget)
397 static GtkWidget *window;
401 GtkWidget *event, *button;
404 /* make the widgets */
405 button = gtk_button_new_with_label ("A Button");
406 event = gtk_event_box_new ();
407 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
409 g_signal_connect (window, "destroy",
410 G_CALLBACK (gtk_widget_destroyed),
413 /* put a red background on the window */
414 gdk_color_parse ("red", &red);
415 gtk_widget_modify_bg (window, GTK_STATE_NORMAL, &red);
417 /* set our event box to have a fully-transparent background
418 * drawn on it. currently there is no way to simply tell gtk
419 * that "transparency" is the background colour for a widget.
421 gtk_widget_set_app_paintable (GTK_WIDGET (event), TRUE);
422 g_signal_connect (event, "draw",
423 G_CALLBACK (transparent_draw), NULL);
425 /* put them inside one another */
426 gtk_container_set_border_width (GTK_CONTAINER (window), 10);
427 gtk_container_add (GTK_CONTAINER (window), event);
428 gtk_container_add (GTK_CONTAINER (event), button);
430 /* realise and show everything */
431 gtk_widget_realize (button);
433 /* set the event box GdkWindow to be composited.
434 * obviously must be performed after event box is realised.
436 gdk_window_set_composited (gtk_widget_get_window (event),
439 /* set up the compositing handler.
440 * note that we do _after so that the normal (red) background is drawn
441 * by gtk before our compositing occurs.
443 g_signal_connect_after (window, "draw",
444 G_CALLBACK (window_draw), NULL);
447 if (!gtk_widget_get_visible (window))
448 gtk_widget_show_all (window);
450 gtk_widget_destroy (window);
454 * Big windows and guffaw scrolling
458 pattern_set_bg (GtkWidget *widget,
462 static const GdkColor colors[] = {
463 { 0, 0x4444, 0x4444, 0xffff },
464 { 0, 0x8888, 0x8888, 0xffff },
465 { 0, 0xaaaa, 0xaaaa, 0xffff }
468 gdk_window_set_user_data (child, widget);
469 gdk_window_set_background (child, &colors[level]);
473 create_pattern (GtkWidget *widget,
484 while (2 * h <= height)
489 while (2 * w <= width)
491 if ((i + j) % 2 == 0)
496 GdkWindowAttr attributes;
498 attributes.window_type = GDK_WINDOW_CHILD;
501 attributes.width = w;
502 attributes.height = h;
503 attributes.wclass = GDK_INPUT_OUTPUT;
504 attributes.event_mask = GDK_EXPOSURE_MASK;
505 attributes.visual = gtk_widget_get_visual (widget);
507 child = gdk_window_new (parent, &attributes,
508 GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL);
510 pattern_set_bg (widget, child, level);
513 create_pattern (widget, child, level + 1, w, h);
515 gdk_window_show (child);
525 #define PATTERN_SIZE (1 << 18)
528 pattern_hadj_changed (GtkAdjustment *adj,
531 gint *old_value = g_object_get_data (G_OBJECT (adj), "old-value");
532 gint new_value = adj->value;
534 if (gtk_widget_get_realized (darea))
536 gdk_window_scroll (gtk_widget_get_window (darea),
537 *old_value - new_value, 0);
538 *old_value = new_value;
543 pattern_vadj_changed (GtkAdjustment *adj,
546 gint *old_value = g_object_get_data (G_OBJECT (adj), "old-value");
547 gint new_value = adj->value;
549 if (gtk_widget_get_realized (darea))
551 gdk_window_scroll (gtk_widget_get_window (darea),
552 0, *old_value - new_value);
553 *old_value = new_value;
558 pattern_realize (GtkWidget *widget,
563 window = gtk_widget_get_window (widget);
564 pattern_set_bg (widget, window, 0);
565 create_pattern (widget, window, 1, PATTERN_SIZE, PATTERN_SIZE);
569 create_big_windows (GtkWidget *widget)
571 static GtkWidget *window = NULL;
572 GtkWidget *content_area;
573 GtkWidget *darea, *table, *scrollbar;
577 static gint current_x;
578 static gint current_y;
585 window = gtk_dialog_new_with_buttons ("Big Windows",
591 gtk_window_set_screen (GTK_WINDOW (window),
592 gtk_widget_get_screen (widget));
594 gtk_window_set_default_size (GTK_WINDOW (window), 200, 300);
596 g_signal_connect (window, "destroy",
597 G_CALLBACK (gtk_widget_destroyed),
600 g_signal_connect (window, "response",
601 G_CALLBACK (gtk_widget_destroy),
604 content_area = gtk_dialog_get_content_area (GTK_DIALOG (window));
606 table = gtk_table_new (2, 2, FALSE);
607 gtk_box_pack_start (GTK_BOX (content_area), table, TRUE, TRUE, 0);
609 darea = gtk_drawing_area_new ();
611 hadj = gtk_adjustment_new (0, 0, PATTERN_SIZE, 10, 100, 100);
612 g_signal_connect (hadj, "value_changed",
613 G_CALLBACK (pattern_hadj_changed), darea);
614 g_object_set_data (G_OBJECT (hadj), "old-value", ¤t_x);
616 vadj = gtk_adjustment_new (0, 0, PATTERN_SIZE, 10, 100, 100);
617 g_signal_connect (vadj, "value_changed",
618 G_CALLBACK (pattern_vadj_changed), darea);
619 g_object_set_data (G_OBJECT (vadj), "old-value", ¤t_y);
621 g_signal_connect (darea, "realize",
622 G_CALLBACK (pattern_realize),
625 eventbox = gtk_event_box_new ();
626 gtk_table_attach (GTK_TABLE (table), eventbox,
628 GTK_FILL | GTK_EXPAND, GTK_FILL | GTK_EXPAND,
631 gtk_container_add (GTK_CONTAINER (eventbox), darea);
633 scrollbar = gtk_hscrollbar_new (hadj);
634 gtk_table_attach (GTK_TABLE (table), scrollbar,
636 GTK_FILL | GTK_EXPAND, GTK_FILL,
639 scrollbar = gtk_vscrollbar_new (vadj);
640 gtk_table_attach (GTK_TABLE (table), scrollbar,
642 GTK_FILL, GTK_EXPAND | GTK_FILL,
647 if (!gtk_widget_get_visible (window))
648 gtk_widget_show_all (window);
650 gtk_widget_hide (window);
658 button_window (GtkWidget *widget,
661 if (!gtk_widget_get_visible (button))
662 gtk_widget_show (button);
664 gtk_widget_hide (button);
668 create_buttons (GtkWidget *widget)
670 static GtkWidget *window = NULL;
674 GtkWidget *button[10];
675 GtkWidget *separator;
679 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
680 gtk_window_set_screen (GTK_WINDOW (window),
681 gtk_widget_get_screen (widget));
683 g_signal_connect (window, "destroy",
684 G_CALLBACK (gtk_widget_destroyed),
687 gtk_window_set_title (GTK_WINDOW (window), "GtkButton");
688 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
690 box1 = gtk_vbox_new (FALSE, 0);
691 gtk_container_add (GTK_CONTAINER (window), box1);
693 table = gtk_table_new (3, 3, FALSE);
694 gtk_table_set_row_spacings (GTK_TABLE (table), 5);
695 gtk_table_set_col_spacings (GTK_TABLE (table), 5);
696 gtk_container_set_border_width (GTK_CONTAINER (table), 10);
697 gtk_box_pack_start (GTK_BOX (box1), table, TRUE, TRUE, 0);
699 button[0] = gtk_button_new_with_label ("button1");
700 button[1] = gtk_button_new_with_mnemonic ("_button2");
701 button[2] = gtk_button_new_with_mnemonic ("_button3");
702 button[3] = gtk_button_new_from_stock (GTK_STOCK_OK);
703 button[4] = gtk_button_new_with_label ("button5");
704 button[5] = gtk_button_new_with_label ("button6");
705 button[6] = gtk_button_new_with_label ("button7");
706 button[7] = gtk_button_new_from_stock (GTK_STOCK_CLOSE);
707 button[8] = gtk_button_new_with_label ("button9");
709 g_signal_connect (button[0], "clicked",
710 G_CALLBACK (button_window),
713 gtk_table_attach (GTK_TABLE (table), button[0], 0, 1, 0, 1,
714 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
716 g_signal_connect (button[1], "clicked",
717 G_CALLBACK (button_window),
720 gtk_table_attach (GTK_TABLE (table), button[1], 1, 2, 1, 2,
721 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
723 g_signal_connect (button[2], "clicked",
724 G_CALLBACK (button_window),
726 gtk_table_attach (GTK_TABLE (table), button[2], 2, 3, 2, 3,
727 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
729 g_signal_connect (button[3], "clicked",
730 G_CALLBACK (button_window),
732 gtk_table_attach (GTK_TABLE (table), button[3], 0, 1, 2, 3,
733 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
735 g_signal_connect (button[4], "clicked",
736 G_CALLBACK (button_window),
738 gtk_table_attach (GTK_TABLE (table), button[4], 2, 3, 0, 1,
739 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
741 g_signal_connect (button[5], "clicked",
742 G_CALLBACK (button_window),
744 gtk_table_attach (GTK_TABLE (table), button[5], 1, 2, 2, 3,
745 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
747 g_signal_connect (button[6], "clicked",
748 G_CALLBACK (button_window),
750 gtk_table_attach (GTK_TABLE (table), button[6], 1, 2, 0, 1,
751 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
753 g_signal_connect (button[7], "clicked",
754 G_CALLBACK (button_window),
756 gtk_table_attach (GTK_TABLE (table), button[7], 2, 3, 1, 2,
757 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
759 g_signal_connect (button[8], "clicked",
760 G_CALLBACK (button_window),
762 gtk_table_attach (GTK_TABLE (table), button[8], 0, 1, 1, 2,
763 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
765 separator = gtk_hseparator_new ();
766 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
768 box2 = gtk_vbox_new (FALSE, 10);
769 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
770 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
772 button[9] = gtk_button_new_with_label ("close");
773 g_signal_connect_swapped (button[9], "clicked",
774 G_CALLBACK (gtk_widget_destroy),
776 gtk_box_pack_start (GTK_BOX (box2), button[9], TRUE, TRUE, 0);
777 gtk_widget_set_can_default (button[9], TRUE);
778 gtk_widget_grab_default (button[9]);
781 if (!gtk_widget_get_visible (window))
782 gtk_widget_show_all (window);
784 gtk_widget_destroy (window);
792 create_toggle_buttons (GtkWidget *widget)
794 static GtkWidget *window = NULL;
798 GtkWidget *separator;
802 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
803 gtk_window_set_screen (GTK_WINDOW (window),
804 gtk_widget_get_screen (widget));
806 g_signal_connect (window, "destroy",
807 G_CALLBACK (gtk_widget_destroyed),
810 gtk_window_set_title (GTK_WINDOW (window), "GtkToggleButton");
811 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
813 box1 = gtk_vbox_new (FALSE, 0);
814 gtk_container_add (GTK_CONTAINER (window), box1);
816 box2 = gtk_vbox_new (FALSE, 10);
817 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
818 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
820 button = gtk_toggle_button_new_with_label ("button1");
821 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
823 button = gtk_toggle_button_new_with_label ("button2");
824 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
826 button = gtk_toggle_button_new_with_label ("button3");
827 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
829 button = gtk_toggle_button_new_with_label ("inconsistent");
830 gtk_toggle_button_set_inconsistent (GTK_TOGGLE_BUTTON (button), TRUE);
831 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
833 separator = gtk_hseparator_new ();
834 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
836 box2 = gtk_vbox_new (FALSE, 10);
837 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
838 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
840 button = gtk_button_new_with_label ("close");
841 g_signal_connect_swapped (button, "clicked",
842 G_CALLBACK (gtk_widget_destroy),
844 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
845 gtk_widget_set_can_default (button, TRUE);
846 gtk_widget_grab_default (button);
849 if (!gtk_widget_get_visible (window))
850 gtk_widget_show_all (window);
852 gtk_widget_destroy (window);
856 create_widget_grid (GType widget_type)
859 GtkWidget *group_widget = NULL;
862 table = gtk_table_new (FALSE, 3, 3);
864 for (i = 0; i < 5; i++)
866 for (j = 0; j < 5; j++)
871 if (i == 0 && j == 0)
877 tmp = g_strdup_printf ("%d", j);
878 widget = gtk_label_new (tmp);
883 tmp = g_strdup_printf ("%c", 'A' + i - 1);
884 widget = gtk_label_new (tmp);
889 widget = g_object_new (widget_type, NULL);
891 if (g_type_is_a (widget_type, GTK_TYPE_RADIO_BUTTON))
894 group_widget = widget;
896 g_object_set (widget, "group", group_widget, NULL);
901 gtk_table_attach (GTK_TABLE (table), widget,
916 create_check_buttons (GtkWidget *widget)
918 static GtkWidget *window = NULL;
922 GtkWidget *separator;
927 window = gtk_dialog_new_with_buttons ("Check Buttons",
933 gtk_window_set_screen (GTK_WINDOW (window),
934 gtk_widget_get_screen (widget));
936 g_signal_connect (window, "destroy",
937 G_CALLBACK (gtk_widget_destroyed),
939 g_signal_connect (window, "response",
940 G_CALLBACK (gtk_widget_destroy),
943 box1 = gtk_dialog_get_content_area (GTK_DIALOG (window));
945 box2 = gtk_vbox_new (FALSE, 10);
946 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
947 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
949 button = gtk_check_button_new_with_mnemonic ("_button1");
950 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
952 button = gtk_check_button_new_with_label ("button2");
953 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
955 button = gtk_check_button_new_with_label ("button3");
956 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
958 button = gtk_check_button_new_with_label ("inconsistent");
959 gtk_toggle_button_set_inconsistent (GTK_TOGGLE_BUTTON (button), TRUE);
960 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
962 separator = gtk_hseparator_new ();
963 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
965 table = create_widget_grid (GTK_TYPE_CHECK_BUTTON);
966 gtk_container_set_border_width (GTK_CONTAINER (table), 10);
967 gtk_box_pack_start (GTK_BOX (box1), table, TRUE, TRUE, 0);
970 if (!gtk_widget_get_visible (window))
971 gtk_widget_show_all (window);
973 gtk_widget_destroy (window);
981 create_radio_buttons (GtkWidget *widget)
983 static GtkWidget *window = NULL;
987 GtkWidget *separator;
992 window = gtk_dialog_new_with_buttons ("Radio Buttons",
998 gtk_window_set_screen (GTK_WINDOW (window),
999 gtk_widget_get_screen (widget));
1001 g_signal_connect (window, "destroy",
1002 G_CALLBACK (gtk_widget_destroyed),
1004 g_signal_connect (window, "response",
1005 G_CALLBACK (gtk_widget_destroy),
1008 box1 = gtk_dialog_get_content_area (GTK_DIALOG (window));
1010 box2 = gtk_vbox_new (FALSE, 10);
1011 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
1012 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
1014 button = gtk_radio_button_new_with_label (NULL, "button1");
1015 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
1017 button = gtk_radio_button_new_with_label (
1018 gtk_radio_button_get_group (GTK_RADIO_BUTTON (button)),
1020 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
1021 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
1023 button = gtk_radio_button_new_with_label (
1024 gtk_radio_button_get_group (GTK_RADIO_BUTTON (button)),
1026 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
1028 button = gtk_radio_button_new_with_label (
1029 gtk_radio_button_get_group (GTK_RADIO_BUTTON (button)),
1031 gtk_toggle_button_set_inconsistent (GTK_TOGGLE_BUTTON (button), TRUE);
1032 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
1034 separator = gtk_hseparator_new ();
1035 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
1037 box2 = gtk_vbox_new (FALSE, 10);
1038 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
1039 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
1041 button = gtk_radio_button_new_with_label (NULL, "button4");
1042 gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (button), FALSE);
1043 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
1045 button = gtk_radio_button_new_with_label (
1046 gtk_radio_button_get_group (GTK_RADIO_BUTTON (button)),
1048 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
1049 gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (button), FALSE);
1050 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
1052 button = gtk_radio_button_new_with_label (
1053 gtk_radio_button_get_group (GTK_RADIO_BUTTON (button)),
1055 gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (button), FALSE);
1056 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
1058 separator = gtk_hseparator_new ();
1059 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
1061 table = create_widget_grid (GTK_TYPE_RADIO_BUTTON);
1062 gtk_container_set_border_width (GTK_CONTAINER (table), 10);
1063 gtk_box_pack_start (GTK_BOX (box1), table, TRUE, TRUE, 0);
1066 if (!gtk_widget_get_visible (window))
1067 gtk_widget_show_all (window);
1069 gtk_widget_destroy (window);
1077 create_bbox (gint horizontal,
1088 frame = gtk_frame_new (title);
1091 bbox = gtk_hbutton_box_new ();
1093 bbox = gtk_vbutton_box_new ();
1095 gtk_container_set_border_width (GTK_CONTAINER (bbox), 5);
1096 gtk_container_add (GTK_CONTAINER (frame), bbox);
1098 gtk_button_box_set_layout (GTK_BUTTON_BOX (bbox), layout);
1099 gtk_box_set_spacing (GTK_BOX (bbox), spacing);
1101 button = gtk_button_new_with_label ("OK");
1102 gtk_container_add (GTK_CONTAINER (bbox), button);
1104 button = gtk_button_new_with_label ("Cancel");
1105 gtk_container_add (GTK_CONTAINER (bbox), button);
1107 button = gtk_button_new_with_label ("Help");
1108 gtk_container_add (GTK_CONTAINER (bbox), button);
1114 create_button_box (GtkWidget *widget)
1116 static GtkWidget* window = NULL;
1117 GtkWidget *main_vbox;
1120 GtkWidget *frame_horz;
1121 GtkWidget *frame_vert;
1125 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
1126 gtk_window_set_screen (GTK_WINDOW (window), gtk_widget_get_screen (widget));
1127 gtk_window_set_title (GTK_WINDOW (window), "Button Boxes");
1129 g_signal_connect (window, "destroy",
1130 G_CALLBACK (gtk_widget_destroyed),
1133 gtk_container_set_border_width (GTK_CONTAINER (window), 10);
1135 main_vbox = gtk_vbox_new (FALSE, 0);
1136 gtk_container_add (GTK_CONTAINER (window), main_vbox);
1138 frame_horz = gtk_frame_new ("Horizontal Button Boxes");
1139 gtk_box_pack_start (GTK_BOX (main_vbox), frame_horz, TRUE, TRUE, 10);
1141 vbox = gtk_vbox_new (FALSE, 0);
1142 gtk_container_set_border_width (GTK_CONTAINER (vbox), 10);
1143 gtk_container_add (GTK_CONTAINER (frame_horz), vbox);
1145 gtk_box_pack_start (GTK_BOX (vbox),
1146 create_bbox (TRUE, "Spread", 40, 85, 20, GTK_BUTTONBOX_SPREAD),
1149 gtk_box_pack_start (GTK_BOX (vbox),
1150 create_bbox (TRUE, "Edge", 40, 85, 20, GTK_BUTTONBOX_EDGE),
1153 gtk_box_pack_start (GTK_BOX (vbox),
1154 create_bbox (TRUE, "Start", 40, 85, 20, GTK_BUTTONBOX_START),
1157 gtk_box_pack_start (GTK_BOX (vbox),
1158 create_bbox (TRUE, "End", 40, 85, 20, GTK_BUTTONBOX_END),
1161 gtk_box_pack_start (GTK_BOX (vbox),
1162 create_bbox (TRUE, "Center", 40, 85, 20, GTK_BUTTONBOX_CENTER),
1165 frame_vert = gtk_frame_new ("Vertical Button Boxes");
1166 gtk_box_pack_start (GTK_BOX (main_vbox), frame_vert, TRUE, TRUE, 10);
1168 hbox = gtk_hbox_new (FALSE, 0);
1169 gtk_container_set_border_width (GTK_CONTAINER (hbox), 10);
1170 gtk_container_add (GTK_CONTAINER (frame_vert), hbox);
1172 gtk_box_pack_start (GTK_BOX (hbox),
1173 create_bbox (FALSE, "Spread", 30, 85, 20, GTK_BUTTONBOX_SPREAD),
1176 gtk_box_pack_start (GTK_BOX (hbox),
1177 create_bbox (FALSE, "Edge", 30, 85, 20, GTK_BUTTONBOX_EDGE),
1180 gtk_box_pack_start (GTK_BOX (hbox),
1181 create_bbox (FALSE, "Start", 30, 85, 20, GTK_BUTTONBOX_START),
1184 gtk_box_pack_start (GTK_BOX (hbox),
1185 create_bbox (FALSE, "End", 30, 85, 20, GTK_BUTTONBOX_END),
1188 gtk_box_pack_start (GTK_BOX (hbox),
1189 create_bbox (FALSE, "Center", 30, 85, 20, GTK_BUTTONBOX_CENTER),
1193 if (!gtk_widget_get_visible (window))
1194 gtk_widget_show_all (window);
1196 gtk_widget_destroy (window);
1204 new_pixbuf (char *filename,
1206 GdkColor *background)
1211 if (strcmp (filename, "test.xpm") == 0)
1214 pixbuf = gdk_pixbuf_new_from_file (filename, NULL);
1217 pixbuf = gdk_pixbuf_new_from_xpm_data ((const char **) openfile);
1219 widget = gtk_image_new_from_pixbuf (pixbuf);
1221 g_object_unref (pixbuf);
1228 set_toolbar_small_stock (GtkWidget *widget,
1231 gtk_toolbar_set_icon_size (GTK_TOOLBAR (data), GTK_ICON_SIZE_SMALL_TOOLBAR);
1235 set_toolbar_large_stock (GtkWidget *widget,
1238 gtk_toolbar_set_icon_size (GTK_TOOLBAR (data), GTK_ICON_SIZE_LARGE_TOOLBAR);
1242 set_toolbar_horizontal (GtkWidget *widget,
1245 gtk_orientable_set_orientation (GTK_ORIENTABLE (data), GTK_ORIENTATION_HORIZONTAL);
1249 set_toolbar_vertical (GtkWidget *widget,
1252 gtk_orientable_set_orientation (GTK_ORIENTABLE (data), GTK_ORIENTATION_VERTICAL);
1256 set_toolbar_icons (GtkWidget *widget,
1259 gtk_toolbar_set_style (GTK_TOOLBAR (data), GTK_TOOLBAR_ICONS);
1263 set_toolbar_text (GtkWidget *widget,
1266 gtk_toolbar_set_style (GTK_TOOLBAR (data), GTK_TOOLBAR_TEXT);
1270 set_toolbar_both (GtkWidget *widget,
1273 gtk_toolbar_set_style (GTK_TOOLBAR (data), GTK_TOOLBAR_BOTH);
1277 set_toolbar_both_horiz (GtkWidget *widget,
1280 gtk_toolbar_set_style (GTK_TOOLBAR (data), GTK_TOOLBAR_BOTH_HORIZ);
1284 set_toolbar_enable (GtkWidget *widget,
1287 GtkSettings *settings = gtk_widget_get_settings (widget);
1288 g_object_set (settings, "gtk-enable-tooltips", TRUE, NULL);
1292 set_toolbar_disable (GtkWidget *widget,
1295 GtkSettings *settings = gtk_widget_get_settings (widget);
1296 g_object_set (settings, "gtk-enable-tooltips", FALSE, NULL);
1299 static GtkActionEntry create_toolbar_items[] = {
1300 { NULL, GTK_STOCK_NEW, NULL, NULL, "Stock icon: New",
1301 G_CALLBACK (set_toolbar_small_stock) },
1302 { NULL, GTK_STOCK_OPEN, NULL, NULL, "Stock icon: Open",
1303 G_CALLBACK (set_toolbar_large_stock) },
1304 { NULL, NULL, "Horizontal", NULL, "Horizontal toolbar layout",
1305 G_CALLBACK (set_toolbar_horizontal) },
1306 { NULL, NULL, "Vertical", NULL, "Vertical toolbar layout",
1307 G_CALLBACK (set_toolbar_vertical) },
1309 { NULL, NULL, "Icons", NULL, "Only show toolbar icons",
1310 G_CALLBACK (set_toolbar_icons) },
1311 { NULL, NULL, "Text", NULL, "Only show toolbar text",
1312 G_CALLBACK (set_toolbar_text) },
1313 { NULL, NULL, "Both", NULL, "Show toolbar icons and text",
1314 G_CALLBACK (set_toolbar_both) },
1315 { NULL, NULL, "Both (horizontal)", NULL, "Show toolbar icons and text in a horizontal fashion",
1316 G_CALLBACK (set_toolbar_both_horiz) },
1318 { "entry", NULL, NULL, "This is an unusable GtkEntry ;)",
1322 { NULL, NULL, "Enable", NULL, "Enable tooltips",
1323 G_CALLBACK (set_toolbar_enable) },
1324 { NULL, NULL, "Disable", NULL, "Disable tooltips",
1325 G_CALLBACK (set_toolbar_disable) },
1327 { NULL, NULL, "Frobate", NULL, "Frobate tooltip",
1329 { NULL, NULL, "Baz", NULL, "Baz tooltip",
1332 { NULL, NULL, "Blah", NULL, "Blash tooltip",
1334 { NULL, NULL, "Bar", NULL, "Bar tooltip",
1339 create_toolbar (GtkWidget *widget)
1341 static GtkWidget *window = NULL;
1348 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
1349 gtk_window_set_screen (GTK_WINDOW (window),
1350 gtk_widget_get_screen (widget));
1352 gtk_window_set_title (GTK_WINDOW (window), "Toolbar test");
1354 g_signal_connect (window, "destroy",
1355 G_CALLBACK (gtk_widget_destroyed),
1358 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
1359 gtk_widget_realize (window);
1361 toolbar = gtk_toolbar_new ();
1362 for (i = 0; i < G_N_ELEMENTS (create_toolbar_items); i++)
1364 GtkToolItem *toolitem;
1366 if (create_toolbar_items[i].tooltip == NULL)
1367 toolitem = gtk_separator_tool_item_new ();
1368 else if (g_strcmp0 (create_toolbar_items[i].name, "entry") == 0)
1372 toolitem = gtk_tool_item_new ();
1373 entry = gtk_entry_new ();
1374 gtk_container_add (GTK_CONTAINER (toolitem), entry);
1376 else if (create_toolbar_items[i].stock_id)
1377 toolitem = gtk_tool_button_new_from_stock (create_toolbar_items[i].stock_id);
1382 icon = new_pixbuf ("test.xpm", gtk_widget_get_window (window),
1383 >k_widget_get_style (window)->bg[GTK_STATE_NORMAL]);
1384 toolitem = gtk_tool_button_new (icon, create_toolbar_items[i].label);
1386 if (create_toolbar_items[i].callback)
1387 g_signal_connect (toolitem, "clicked",
1388 create_toolbar_items[i].callback, toolbar);
1389 gtk_tool_item_set_tooltip_text (toolitem, create_toolbar_items[i].tooltip);
1390 gtk_toolbar_insert (GTK_TOOLBAR (toolbar), toolitem, -1);
1393 gtk_container_add (GTK_CONTAINER (window), toolbar);
1395 gtk_widget_set_size_request (toolbar, 200, -1);
1398 if (!gtk_widget_get_visible (window))
1399 gtk_widget_show_all (window);
1401 gtk_widget_destroy (window);
1404 static GtkActionEntry make_toolbar_items[] = {
1405 { NULL, NULL, "Horizontal", NULL, "Horizontal toolbar layout",
1406 G_CALLBACK (set_toolbar_horizontal) },
1407 { NULL, NULL, "Vertical", NULL, "Vertical toolbar layout",
1408 G_CALLBACK (set_toolbar_vertical) },
1410 { NULL, NULL, "Icons", NULL, "Only show toolbar icons",
1411 G_CALLBACK (set_toolbar_icons) },
1412 { NULL, NULL, "Text", NULL, "Only show toolbar text",
1413 G_CALLBACK (set_toolbar_text) },
1414 { NULL, NULL, "Both", NULL, "Show toolbar icons and text",
1415 G_CALLBACK (set_toolbar_both) },
1417 { NULL, NULL, "Woot", NULL, "Woot woot woot",
1419 { NULL, NULL, "Blah", NULL, "Blah blah blah",
1422 { NULL, NULL, "Enable", NULL, "Enable tooltips",
1423 G_CALLBACK (set_toolbar_enable) },
1424 { NULL, NULL, "Disable", NULL, "Disable tooltips",
1425 G_CALLBACK (set_toolbar_disable) },
1427 { NULL, NULL, "Hoo", NULL, "Hoo tooltip",
1429 { NULL, NULL, "Woo", NULL, "Woo tooltip",
1434 make_toolbar (GtkWidget *window)
1439 if (!gtk_widget_get_realized (window))
1440 gtk_widget_realize (window);
1442 toolbar = gtk_toolbar_new ();
1443 for (i = 0; i < G_N_ELEMENTS (make_toolbar_items); i++)
1446 GtkToolItem *toolitem;
1448 if (make_toolbar_items[i].label == NULL)
1450 toolitem = gtk_separator_tool_item_new ();
1453 icon = new_pixbuf ("test.xpm", gtk_widget_get_window (window),
1454 >k_widget_get_style (window)->bg[GTK_STATE_NORMAL]);
1455 toolitem = gtk_tool_button_new (icon, make_toolbar_items[i].label);
1456 gtk_tool_item_set_tooltip_text (toolitem, make_toolbar_items[i].tooltip);
1457 if (make_toolbar_items[i].callback != NULL)
1458 g_signal_connect (toolitem, "clicked", make_toolbar_items[i].callback, toolbar);
1459 gtk_toolbar_insert (GTK_TOOLBAR (toolbar), toolitem, -1);
1469 static guint statusbar_counter = 1;
1472 statusbar_push (GtkWidget *button,
1473 GtkStatusbar *statusbar)
1477 sprintf (text, "something %d", statusbar_counter++);
1479 gtk_statusbar_push (statusbar, 1, text);
1483 statusbar_push_long (GtkWidget *button,
1484 GtkStatusbar *statusbar)
1488 sprintf (text, "Just because a system has menu choices written with English words, phrases or sentences, that is no guarantee, that it is comprehensible. Individual words may not be familiar to some users (for example, \"repaginate\"), and two menu items may appear to satisfy the users's needs, whereas only one does (for example, \"put away\" or \"eject\").");
1490 gtk_statusbar_push (statusbar, 1, text);
1494 statusbar_pop (GtkWidget *button,
1495 GtkStatusbar *statusbar)
1497 gtk_statusbar_pop (statusbar, 1);
1501 statusbar_steal (GtkWidget *button,
1502 GtkStatusbar *statusbar)
1504 gtk_statusbar_remove (statusbar, 1, 4);
1508 statusbar_popped (GtkStatusbar *statusbar,
1513 statusbar_counter = 1;
1517 statusbar_contexts (GtkStatusbar *statusbar)
1521 string = "any context";
1522 g_print ("GtkStatusBar: context=\"%s\", context_id=%d\n",
1524 gtk_statusbar_get_context_id (statusbar, string));
1526 string = "idle messages";
1527 g_print ("GtkStatusBar: context=\"%s\", context_id=%d\n",
1529 gtk_statusbar_get_context_id (statusbar, string));
1531 string = "some text";
1532 g_print ("GtkStatusBar: context=\"%s\", context_id=%d\n",
1534 gtk_statusbar_get_context_id (statusbar, string));
1536 string = "hit the mouse";
1537 g_print ("GtkStatusBar: context=\"%s\", context_id=%d\n",
1539 gtk_statusbar_get_context_id (statusbar, string));
1541 string = "hit the mouse2";
1542 g_print ("GtkStatusBar: context=\"%s\", context_id=%d\n",
1544 gtk_statusbar_get_context_id (statusbar, string));
1548 create_statusbar (GtkWidget *widget)
1550 static GtkWidget *window = NULL;
1554 GtkWidget *separator;
1555 GtkWidget *statusbar;
1559 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
1560 gtk_window_set_screen (GTK_WINDOW (window),
1561 gtk_widget_get_screen (widget));
1563 g_signal_connect (window, "destroy",
1564 G_CALLBACK (gtk_widget_destroyed),
1567 gtk_window_set_title (GTK_WINDOW (window), "statusbar");
1568 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
1570 box1 = gtk_vbox_new (FALSE, 0);
1571 gtk_container_add (GTK_CONTAINER (window), box1);
1573 box2 = gtk_vbox_new (FALSE, 10);
1574 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
1575 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
1577 statusbar = gtk_statusbar_new ();
1578 gtk_box_pack_end (GTK_BOX (box1), statusbar, TRUE, TRUE, 0);
1579 g_signal_connect (statusbar,
1581 G_CALLBACK (statusbar_popped),
1584 button = g_object_new (gtk_button_get_type (),
1585 "label", "push something",
1589 g_object_connect (button,
1590 "signal::clicked", statusbar_push, statusbar,
1593 button = g_object_connect (g_object_new (gtk_button_get_type (),
1598 "signal_after::clicked", statusbar_pop, statusbar,
1601 button = g_object_connect (g_object_new (gtk_button_get_type (),
1602 "label", "steal #4",
1606 "signal_after::clicked", statusbar_steal, statusbar,
1609 button = g_object_connect (g_object_new (gtk_button_get_type (),
1610 "label", "test contexts",
1614 "swapped_signal_after::clicked", statusbar_contexts, statusbar,
1617 button = g_object_connect (g_object_new (gtk_button_get_type (),
1618 "label", "push something long",
1622 "signal_after::clicked", statusbar_push_long, statusbar,
1625 separator = gtk_hseparator_new ();
1626 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
1628 box2 = gtk_vbox_new (FALSE, 10);
1629 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
1630 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
1632 button = gtk_button_new_with_label ("close");
1633 g_signal_connect_swapped (button, "clicked",
1634 G_CALLBACK (gtk_widget_destroy),
1636 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
1637 gtk_widget_set_can_default (button, TRUE);
1638 gtk_widget_grab_default (button);
1641 if (!gtk_widget_get_visible (window))
1642 gtk_widget_show_all (window);
1644 gtk_widget_destroy (window);
1652 handle_box_child_signal (GtkHandleBox *hb,
1654 const gchar *action)
1656 printf ("%s: child <%s> %sed\n",
1657 g_type_name (G_OBJECT_TYPE (hb)),
1658 g_type_name (G_OBJECT_TYPE (child)),
1663 create_handle_box (GtkWidget *widget)
1665 static GtkWidget* window = NULL;
1666 GtkWidget *handle_box;
1667 GtkWidget *handle_box2;
1672 GtkWidget *separator;
1676 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
1678 gtk_window_set_screen (GTK_WINDOW (window),
1679 gtk_widget_get_screen (widget));
1680 gtk_window_set_modal (GTK_WINDOW (window), FALSE);
1681 gtk_window_set_title (GTK_WINDOW (window),
1683 gtk_window_set_resizable (GTK_WINDOW (window), TRUE);
1685 g_signal_connect (window, "destroy",
1686 G_CALLBACK (gtk_widget_destroyed),
1689 gtk_container_set_border_width (GTK_CONTAINER (window), 20);
1691 vbox = gtk_vbox_new (FALSE, 0);
1692 gtk_container_add (GTK_CONTAINER (window), vbox);
1693 gtk_widget_show (vbox);
1695 label = gtk_label_new ("Above");
1696 gtk_container_add (GTK_CONTAINER (vbox), label);
1697 gtk_widget_show (label);
1699 separator = gtk_hseparator_new ();
1700 gtk_container_add (GTK_CONTAINER (vbox), separator);
1701 gtk_widget_show (separator);
1703 hbox = gtk_hbox_new (FALSE, 10);
1704 gtk_container_add (GTK_CONTAINER (vbox), hbox);
1705 gtk_widget_show (hbox);
1707 separator = gtk_hseparator_new ();
1708 gtk_container_add (GTK_CONTAINER (vbox), separator);
1709 gtk_widget_show (separator);
1711 label = gtk_label_new ("Below");
1712 gtk_container_add (GTK_CONTAINER (vbox), label);
1713 gtk_widget_show (label);
1715 handle_box = gtk_handle_box_new ();
1716 gtk_box_pack_start (GTK_BOX (hbox), handle_box, FALSE, FALSE, 0);
1717 g_signal_connect (handle_box,
1719 G_CALLBACK (handle_box_child_signal),
1721 g_signal_connect (handle_box,
1723 G_CALLBACK (handle_box_child_signal),
1725 gtk_widget_show (handle_box);
1727 toolbar = make_toolbar (window);
1729 gtk_container_add (GTK_CONTAINER (handle_box), toolbar);
1730 gtk_widget_show (toolbar);
1732 handle_box = gtk_handle_box_new ();
1733 gtk_box_pack_start (GTK_BOX (hbox), handle_box, FALSE, FALSE, 0);
1734 g_signal_connect (handle_box,
1736 G_CALLBACK (handle_box_child_signal),
1738 g_signal_connect (handle_box,
1740 G_CALLBACK (handle_box_child_signal),
1742 gtk_widget_show (handle_box);
1744 handle_box2 = gtk_handle_box_new ();
1745 gtk_container_add (GTK_CONTAINER (handle_box), handle_box2);
1746 g_signal_connect (handle_box2,
1748 G_CALLBACK (handle_box_child_signal),
1750 g_signal_connect (handle_box2,
1752 G_CALLBACK (handle_box_child_signal),
1754 gtk_widget_show (handle_box2);
1756 hbox = g_object_new (GTK_TYPE_HBOX, "visible", 1, "parent", handle_box2, NULL);
1757 label = gtk_label_new ("Fooo!");
1758 gtk_container_add (GTK_CONTAINER (hbox), label);
1759 gtk_widget_show (label);
1760 g_object_new (GTK_TYPE_ARROW, "visible", 1, "parent", hbox, NULL);
1763 if (!gtk_widget_get_visible (window))
1764 gtk_widget_show (window);
1766 gtk_widget_destroy (window);
1773 sensitivity_toggled (GtkWidget *toggle,
1776 gtk_widget_set_sensitive (widget, GTK_TOGGLE_BUTTON (toggle)->active);
1780 create_sensitivity_control (GtkWidget *widget)
1784 button = gtk_toggle_button_new_with_label ("Sensitive");
1786 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button),
1787 gtk_widget_is_sensitive (widget));
1789 g_signal_connect (button,
1791 G_CALLBACK (sensitivity_toggled),
1794 gtk_widget_show_all (button);
1800 set_selectable_recursive (GtkWidget *widget,
1803 if (GTK_IS_CONTAINER (widget))
1808 children = gtk_container_get_children (GTK_CONTAINER (widget));
1812 set_selectable_recursive (tmp->data, setting);
1816 g_list_free (children);
1818 else if (GTK_IS_LABEL (widget))
1820 gtk_label_set_selectable (GTK_LABEL (widget), setting);
1825 selectable_toggled (GtkWidget *toggle,
1828 set_selectable_recursive (widget,
1829 GTK_TOGGLE_BUTTON (toggle)->active);
1833 create_selectable_control (GtkWidget *widget)
1837 button = gtk_toggle_button_new_with_label ("Selectable");
1839 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button),
1842 g_signal_connect (button,
1844 G_CALLBACK (selectable_toggled),
1847 gtk_widget_show_all (button);
1853 dialog_response (GtkWidget *dialog, gint response_id, GtkLabel *label)
1857 gtk_widget_destroy (dialog);
1859 text = "Some <a href=\"http://en.wikipedia.org/wiki/Text\" title=\"plain text\">text</a> may be marked up\n"
1860 "as hyperlinks, which can be clicked\n"
1861 "or activated via <a href=\"keynav\">keynav</a>.\n"
1862 "The links remain the same.";
1863 gtk_label_set_markup (label, text);
1867 activate_link (GtkWidget *label, const gchar *uri, gpointer data)
1869 if (g_strcmp0 (uri, "keynav") == 0)
1873 dialog = gtk_message_dialog_new_with_markup (GTK_WINDOW (gtk_widget_get_toplevel (label)),
1874 GTK_DIALOG_DESTROY_WITH_PARENT,
1877 "The term <i>keynav</i> is a shorthand for "
1878 "keyboard navigation and refers to the process of using a program "
1879 "(exclusively) via keyboard input.");
1881 gtk_window_present (GTK_WINDOW (dialog));
1883 g_signal_connect (dialog, "response", G_CALLBACK (dialog_response), label);
1891 void create_labels (GtkWidget *widget)
1893 static GtkWidget *window = NULL;
1902 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
1904 gtk_window_set_screen (GTK_WINDOW (window),
1905 gtk_widget_get_screen (widget));
1907 g_signal_connect (window, "destroy",
1908 G_CALLBACK (gtk_widget_destroyed),
1911 gtk_window_set_title (GTK_WINDOW (window), "Label");
1913 vbox = gtk_vbox_new (FALSE, 5);
1915 hbox = gtk_hbox_new (FALSE, 5);
1916 gtk_container_add (GTK_CONTAINER (window), vbox);
1918 gtk_box_pack_end (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
1920 button = create_sensitivity_control (hbox);
1922 gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
1924 button = create_selectable_control (hbox);
1926 gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
1928 vbox = gtk_vbox_new (FALSE, 5);
1930 gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 0);
1931 gtk_container_set_border_width (GTK_CONTAINER (window), 5);
1933 frame = gtk_frame_new ("Normal Label");
1934 label = gtk_label_new ("This is a Normal label");
1935 gtk_label_set_ellipsize (GTK_LABEL (label), PANGO_ELLIPSIZE_START);
1936 gtk_container_add (GTK_CONTAINER (frame), label);
1937 gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
1939 frame = gtk_frame_new ("Multi-line Label");
1940 label = gtk_label_new ("This is a Multi-line label.\nSecond line\nThird line");
1941 gtk_label_set_ellipsize (GTK_LABEL (label), PANGO_ELLIPSIZE_END);
1942 gtk_container_add (GTK_CONTAINER (frame), label);
1943 gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
1945 frame = gtk_frame_new ("Left Justified Label");
1946 label = gtk_label_new ("This is a Left-Justified\nMulti-line label.\nThird line");
1947 gtk_label_set_ellipsize (GTK_LABEL (label), PANGO_ELLIPSIZE_MIDDLE);
1948 gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
1949 gtk_container_add (GTK_CONTAINER (frame), label);
1950 gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
1952 frame = gtk_frame_new ("Right Justified Label");
1953 gtk_label_set_ellipsize (GTK_LABEL (label), PANGO_ELLIPSIZE_START);
1954 label = gtk_label_new ("This is a Right-Justified\nMulti-line label.\nFourth line, (j/k)");
1955 gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_RIGHT);
1956 gtk_container_add (GTK_CONTAINER (frame), label);
1957 gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
1959 frame = gtk_frame_new ("Internationalized Label");
1960 label = gtk_label_new (NULL);
1961 gtk_label_set_markup (GTK_LABEL (label),
1962 "French (Fran\303\247ais) Bonjour, Salut\n"
1963 "Korean (\355\225\234\352\270\200) \354\225\210\353\205\225\355\225\230\354\204\270\354\232\224, \354\225\210\353\205\225\355\225\230\354\213\255\353\213\210\352\271\214\n"
1964 "Russian (\320\240\321\203\321\201\321\201\320\272\320\270\320\271) \320\227\320\264\321\200\320\260\320\262\321\201\321\202\320\262\321\203\320\271\321\202\320\265!\n"
1965 "Chinese (Simplified) <span lang=\"zh-cn\">\345\205\203\346\260\224 \345\274\200\345\217\221</span>\n"
1966 "Chinese (Traditional) <span lang=\"zh-tw\">\345\205\203\346\260\243 \351\226\213\347\231\274</span>\n"
1967 "Japanese <span lang=\"ja\">\345\205\203\346\260\227 \351\226\213\347\231\272</span>");
1968 gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
1969 gtk_container_add (GTK_CONTAINER (frame), label);
1970 gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
1972 frame = gtk_frame_new ("Bidirection Label");
1973 label = gtk_label_new ("\342\200\217Arabic \330\247\331\204\330\263\331\204\330\247\331\205 \330\271\331\204\331\212\331\203\331\205\n"
1974 "\342\200\217Hebrew \327\251\327\234\327\225\327\235");
1975 gtk_container_add (GTK_CONTAINER (frame), label);
1976 gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
1978 frame = gtk_frame_new ("Links in a label");
1979 label = gtk_label_new ("Some <a href=\"http://en.wikipedia.org/wiki/Text\" title=\"plain text\">text</a> may be marked up\n"
1980 "as hyperlinks, which can be clicked\n"
1981 "or activated via <a href=\"keynav\">keynav</a>");
1982 gtk_label_set_use_markup (GTK_LABEL (label), TRUE);
1983 gtk_container_add (GTK_CONTAINER (frame), label);
1984 gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
1985 g_signal_connect (label, "activate-link", G_CALLBACK (activate_link), NULL);
1987 vbox = gtk_vbox_new (FALSE, 5);
1988 gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 0);
1989 frame = gtk_frame_new ("Line wrapped label");
1990 label = gtk_label_new ("This is an example of a line-wrapped label. It should not be taking "\
1991 "up the entire "/* big space to test spacing */\
1992 "width allocated to it, but automatically wraps the words to fit. "\
1993 "The time has come, for all good men, to come to the aid of their party. "\
1994 "The sixth sheik's six sheep's sick.\n"\
1995 " It supports multiple paragraphs correctly, and correctly adds "\
1996 "many extra spaces. ");
1998 gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
1999 gtk_container_add (GTK_CONTAINER (frame), label);
2000 gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
2002 frame = gtk_frame_new ("Filled, wrapped label");
2003 label = gtk_label_new ("This is an example of a line-wrapped, filled label. It should be taking "\
2004 "up the entire width allocated to it. Here is a seneance to prove "\
2005 "my point. Here is another sentence. "\
2006 "Here comes the sun, do de do de do.\n"\
2007 " This is a new paragraph.\n"\
2008 " This is another newer, longer, better paragraph. It is coming to an end, "\
2010 gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_FILL);
2011 gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
2012 gtk_container_add (GTK_CONTAINER (frame), label);
2013 gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
2015 frame = gtk_frame_new ("Underlined label");
2016 label = gtk_label_new ("This label is underlined!\n"
2017 "This one is underlined (\343\201\223\343\202\223\343\201\253\343\201\241\343\201\257) in quite a funky fashion");
2018 gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
2019 gtk_label_set_pattern (GTK_LABEL (label), "_________________________ _ _________ _ _____ _ __ __ ___ ____ _____");
2020 gtk_container_add (GTK_CONTAINER (frame), label);
2021 gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
2023 frame = gtk_frame_new ("Markup label");
2024 label = gtk_label_new (NULL);
2026 /* There's also a gtk_label_set_markup() without accel if you
2027 * don't have an accelerator key
2029 gtk_label_set_markup_with_mnemonic (GTK_LABEL (label),
2030 "This <span foreground=\"blue\" background=\"orange\">label</span> has "
2031 "<b>markup</b> _such as "
2032 "<big><i>Big Italics</i></big>\n"
2033 "<tt>Monospace font</tt>\n"
2034 "<u>Underline!</u>\n"
2036 "<span foreground=\"green\" background=\"red\">Ugly colors</span>\n"
2037 "and nothing on this line,\n"
2040 "or even on this one\n"
2041 "la <big>la <big>la <big>la <big>la</big></big></big></big>\n"
2042 "but this _word is <span foreground=\"purple\"><big>purple</big></span>\n"
2043 "<span underline=\"double\">We like <sup>superscript</sup> and <sub>subscript</sub> too</span>");
2045 g_assert (gtk_label_get_mnemonic_keyval (GTK_LABEL (label)) == GDK_KEY_s);
2047 gtk_container_add (GTK_CONTAINER (frame), label);
2048 gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
2051 if (!gtk_widget_get_visible (window))
2052 gtk_widget_show_all (window);
2054 gtk_widget_destroy (window);
2058 on_angle_scale_changed (GtkRange *range,
2061 gtk_label_set_angle (GTK_LABEL (label), gtk_range_get_value (range));
2065 create_rotated_label (GtkWidget *widget)
2067 static GtkWidget *window = NULL;
2068 GtkWidget *content_area;
2072 GtkWidget *scale_label;
2073 GtkWidget *scale_hbox;
2077 window = gtk_dialog_new_with_buttons ("Rotated Label",
2078 GTK_WINDOW (gtk_widget_get_toplevel (widget)), 0,
2079 GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE,
2082 gtk_window_set_resizable (GTK_WINDOW (window), TRUE);
2084 gtk_window_set_screen (GTK_WINDOW (window),
2085 gtk_widget_get_screen (widget));
2087 g_signal_connect (window, "response",
2088 G_CALLBACK (gtk_widget_destroy), NULL);
2089 g_signal_connect (window, "destroy",
2090 G_CALLBACK (gtk_widget_destroyed), &window);
2092 content_area = gtk_dialog_get_content_area (GTK_DIALOG (window));
2094 vbox = gtk_vbox_new (FALSE, 5);
2095 gtk_box_pack_start (GTK_BOX (content_area), vbox, TRUE, TRUE, 0);
2096 gtk_container_set_border_width (GTK_CONTAINER (vbox), 10);
2098 label = gtk_label_new (NULL);
2099 gtk_label_set_markup (GTK_LABEL (label), "Hello World\n<i>Rotate</i> <span underline='single' foreground='blue'>me</span>");
2100 gtk_box_pack_start (GTK_BOX (vbox), label, TRUE, TRUE, 0);
2102 scale_hbox = gtk_hbox_new (FALSE, 0);
2103 gtk_box_pack_start (GTK_BOX (vbox), scale_hbox, FALSE, FALSE, 0);
2105 scale_label = gtk_label_new (NULL);
2106 gtk_label_set_markup (GTK_LABEL (scale_label), "<i>Angle: </i>");
2107 gtk_box_pack_start (GTK_BOX (scale_hbox), scale_label, FALSE, FALSE, 0);
2109 hscale = gtk_hscale_new_with_range (0, 360, 5);
2110 g_signal_connect (hscale, "value-changed",
2111 G_CALLBACK (on_angle_scale_changed), label);
2113 gtk_range_set_value (GTK_RANGE (hscale), 45);
2114 gtk_widget_set_size_request (hscale, 200, -1);
2115 gtk_box_pack_start (GTK_BOX (scale_hbox), hscale, TRUE, TRUE, 0);
2118 if (!gtk_widget_get_visible (window))
2119 gtk_widget_show_all (window);
2121 gtk_widget_destroy (window);
2124 #define DEFAULT_TEXT_RADIUS 200
2127 on_rotated_text_unrealize (GtkWidget *widget)
2129 g_object_set_data (G_OBJECT (widget), "text-gc", NULL);
2133 on_rotated_text_draw (GtkWidget *widget,
2135 GdkPixbuf *tile_pixbuf)
2137 static const gchar *words[] = { "The", "grand", "old", "Duke", "of", "York",
2138 "had", "10,000", "men" };
2143 PangoLayout *layout;
2144 PangoContext *context;
2145 PangoFontDescription *desc;
2149 gdk_cairo_set_source_pixbuf (cr, tile_pixbuf, 0, 0);
2150 cairo_pattern_set_extend (cairo_get_source (cr), CAIRO_EXTEND_REPEAT);
2153 cairo_set_source_rgb (cr, 0, 0, 0);
2155 width = gtk_widget_get_allocated_width (widget);
2156 height = gtk_widget_get_allocated_height (widget);
2157 radius = MIN (width, height) / 2.;
2159 cairo_translate (cr,
2160 radius + (width - 2 * radius) / 2,
2161 radius + (height - 2 * radius) / 2);
2162 cairo_scale (cr, radius / DEFAULT_TEXT_RADIUS, radius / DEFAULT_TEXT_RADIUS);
2164 context = gtk_widget_get_pango_context (widget);
2165 layout = pango_layout_new (context);
2166 desc = pango_font_description_from_string ("Sans Bold 30");
2167 pango_layout_set_font_description (layout, desc);
2168 pango_font_description_free (desc);
2170 n_words = G_N_ELEMENTS (words);
2171 for (i = 0; i < n_words; i++)
2177 cairo_rotate (cr, 2 * G_PI * i / n_words);
2178 pango_cairo_update_layout (cr, layout);
2180 pango_layout_set_text (layout, words[i], -1);
2181 pango_layout_get_size (layout, &width, &height);
2183 cairo_move_to (cr, - width / 2 / PANGO_SCALE, - DEFAULT_TEXT_RADIUS);
2184 pango_cairo_show_layout (cr, layout);
2189 g_object_unref (layout);
2195 create_rotated_text (GtkWidget *widget)
2197 static GtkWidget *window = NULL;
2201 const GdkColor white = { 0, 0xffff, 0xffff, 0xffff };
2202 GtkRequisition requisition;
2203 GtkWidget *content_area;
2204 GtkWidget *drawing_area;
2205 GdkPixbuf *tile_pixbuf;
2207 window = gtk_dialog_new_with_buttons ("Rotated Text",
2208 GTK_WINDOW (gtk_widget_get_toplevel (widget)), 0,
2209 GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE,
2212 gtk_window_set_resizable (GTK_WINDOW (window), TRUE);
2214 gtk_window_set_screen (GTK_WINDOW (window),
2215 gtk_widget_get_screen (widget));
2217 g_signal_connect (window, "response",
2218 G_CALLBACK (gtk_widget_destroy), NULL);
2219 g_signal_connect (window, "destroy",
2220 G_CALLBACK (gtk_widget_destroyed), &window);
2222 content_area = gtk_dialog_get_content_area (GTK_DIALOG (window));
2224 drawing_area = gtk_drawing_area_new ();
2225 gtk_box_pack_start (GTK_BOX (content_area), drawing_area, TRUE, TRUE, 0);
2226 gtk_widget_modify_bg (drawing_area, GTK_STATE_NORMAL, &white);
2228 tile_pixbuf = gdk_pixbuf_new_from_file ("marble.xpm", NULL);
2230 g_signal_connect (drawing_area, "draw",
2231 G_CALLBACK (on_rotated_text_draw), tile_pixbuf);
2232 g_signal_connect (drawing_area, "unrealize",
2233 G_CALLBACK (on_rotated_text_unrealize), NULL);
2235 gtk_widget_show_all (gtk_bin_get_child (GTK_BIN (window)));
2237 gtk_widget_set_size_request (drawing_area, DEFAULT_TEXT_RADIUS * 2, DEFAULT_TEXT_RADIUS * 2);
2238 gtk_widget_get_preferred_size ( (window),
2239 &requisition, NULL);
2240 gtk_widget_set_size_request (drawing_area, -1, -1);
2241 gtk_window_resize (GTK_WINDOW (window), requisition.width, requisition.height);
2244 if (!gtk_widget_get_visible (window))
2245 gtk_widget_show (window);
2247 gtk_widget_destroy (window);
2255 reparent_label (GtkWidget *widget,
2256 GtkWidget *new_parent)
2260 label = g_object_get_data (G_OBJECT (widget), "user_data");
2262 gtk_widget_reparent (label, new_parent);
2266 set_parent_signal (GtkWidget *child,
2267 GtkWidget *old_parent,
2272 parent = gtk_widget_get_parent (child);
2273 g_message ("set_parent for \"%s\": new parent: \"%s\", old parent: \"%s\", data: %d\n",
2274 g_type_name (G_OBJECT_TYPE (child)),
2275 parent ? g_type_name (G_OBJECT_TYPE (parent)) : "NULL",
2276 old_parent ? g_type_name (G_OBJECT_TYPE (old_parent)) : "NULL",
2277 GPOINTER_TO_INT (func_data));
2281 create_reparent (GtkWidget *widget)
2283 static GtkWidget *window = NULL;
2290 GtkWidget *separator;
2291 GtkWidget *event_box;
2295 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
2297 gtk_window_set_screen (GTK_WINDOW (window),
2298 gtk_widget_get_screen (widget));
2300 g_signal_connect (window, "destroy",
2301 G_CALLBACK (gtk_widget_destroyed),
2304 gtk_window_set_title (GTK_WINDOW (window), "reparent");
2305 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
2307 box1 = gtk_vbox_new (FALSE, 0);
2308 gtk_container_add (GTK_CONTAINER (window), box1);
2310 box2 = gtk_hbox_new (FALSE, 5);
2311 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
2312 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
2314 label = gtk_label_new ("Hello World");
2316 frame = gtk_frame_new ("Frame 1");
2317 gtk_box_pack_start (GTK_BOX (box2), frame, TRUE, TRUE, 0);
2319 box3 = gtk_vbox_new (FALSE, 5);
2320 gtk_container_set_border_width (GTK_CONTAINER (box3), 5);
2321 gtk_container_add (GTK_CONTAINER (frame), box3);
2323 button = gtk_button_new_with_label ("switch");
2324 g_object_set_data (G_OBJECT (button), "user_data", label);
2325 gtk_box_pack_start (GTK_BOX (box3), button, FALSE, TRUE, 0);
2327 event_box = gtk_event_box_new ();
2328 gtk_box_pack_start (GTK_BOX (box3), event_box, FALSE, TRUE, 0);
2329 gtk_container_add (GTK_CONTAINER (event_box), label);
2331 g_signal_connect (button, "clicked",
2332 G_CALLBACK (reparent_label),
2335 g_signal_connect (label, "parent_set",
2336 G_CALLBACK (set_parent_signal),
2337 GINT_TO_POINTER (42));
2339 frame = gtk_frame_new ("Frame 2");
2340 gtk_box_pack_start (GTK_BOX (box2), frame, TRUE, TRUE, 0);
2342 box3 = gtk_vbox_new (FALSE, 5);
2343 gtk_container_set_border_width (GTK_CONTAINER (box3), 5);
2344 gtk_container_add (GTK_CONTAINER (frame), box3);
2346 button = gtk_button_new_with_label ("switch");
2347 g_object_set_data (G_OBJECT (button), "user_data", label);
2348 gtk_box_pack_start (GTK_BOX (box3), button, FALSE, TRUE, 0);
2350 event_box = gtk_event_box_new ();
2351 gtk_box_pack_start (GTK_BOX (box3), event_box, FALSE, TRUE, 0);
2353 g_signal_connect (button, "clicked",
2354 G_CALLBACK (reparent_label),
2357 separator = gtk_hseparator_new ();
2358 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
2360 box2 = gtk_vbox_new (FALSE, 10);
2361 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
2362 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
2364 button = gtk_button_new_with_label ("close");
2365 g_signal_connect_swapped (button, "clicked",
2366 G_CALLBACK (gtk_widget_destroy), window);
2367 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
2368 gtk_widget_set_can_default (button, TRUE);
2369 gtk_widget_grab_default (button);
2372 if (!gtk_widget_get_visible (window))
2373 gtk_widget_show_all (window);
2375 gtk_widget_destroy (window);
2382 grippy_button_press (GtkWidget *area, GdkEventButton *event, GdkWindowEdge edge)
2384 if (event->type == GDK_BUTTON_PRESS)
2386 if (event->button == 1)
2387 gtk_window_begin_resize_drag (GTK_WINDOW (gtk_widget_get_toplevel (area)), edge,
2388 event->button, event->x_root, event->y_root,
2390 else if (event->button == 2)
2391 gtk_window_begin_move_drag (GTK_WINDOW (gtk_widget_get_toplevel (area)),
2392 event->button, event->x_root, event->y_root,
2399 grippy_draw (GtkWidget *area, cairo_t *cr, GdkWindowEdge edge)
2401 gtk_paint_resize_grip (gtk_widget_get_style (area),
2403 gtk_widget_get_state (area),
2408 gtk_widget_get_allocated_width (area),
2409 gtk_widget_get_allocated_height (area));
2415 create_resize_grips (GtkWidget *widget)
2417 static GtkWidget *window = NULL;
2419 GtkWidget *hbox, *vbox;
2422 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
2424 gtk_window_set_screen (GTK_WINDOW (window),
2425 gtk_widget_get_screen (widget));
2427 gtk_window_set_title (GTK_WINDOW (window), "resize grips");
2429 g_signal_connect (window, "destroy",
2430 G_CALLBACK (gtk_widget_destroyed),
2433 vbox = gtk_vbox_new (FALSE, 0);
2434 gtk_container_add (GTK_CONTAINER (window), vbox);
2436 hbox = gtk_hbox_new (FALSE, 0);
2437 gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 0);
2440 area = gtk_drawing_area_new ();
2441 gtk_widget_add_events (area, GDK_BUTTON_PRESS_MASK);
2442 gtk_box_pack_start (GTK_BOX (hbox), area, TRUE, TRUE, 0);
2443 g_signal_connect (area, "draw", G_CALLBACK (grippy_draw),
2444 GINT_TO_POINTER (GDK_WINDOW_EDGE_NORTH_WEST));
2445 g_signal_connect (area, "button_press_event", G_CALLBACK (grippy_button_press),
2446 GINT_TO_POINTER (GDK_WINDOW_EDGE_NORTH_WEST));
2449 area = gtk_drawing_area_new ();
2450 gtk_widget_add_events (area, GDK_BUTTON_PRESS_MASK);
2451 gtk_box_pack_start (GTK_BOX (hbox), area, TRUE, TRUE, 0);
2452 g_signal_connect (area, "draw", G_CALLBACK (grippy_draw),
2453 GINT_TO_POINTER (GDK_WINDOW_EDGE_NORTH));
2454 g_signal_connect (area, "button_press_event", G_CALLBACK (grippy_button_press),
2455 GINT_TO_POINTER (GDK_WINDOW_EDGE_NORTH));
2458 area = gtk_drawing_area_new ();
2459 gtk_widget_add_events (area, GDK_BUTTON_PRESS_MASK);
2460 gtk_box_pack_start (GTK_BOX (hbox), area, TRUE, TRUE, 0);
2461 g_signal_connect (area, "draw", G_CALLBACK (grippy_draw),
2462 GINT_TO_POINTER (GDK_WINDOW_EDGE_NORTH_EAST));
2463 g_signal_connect (area, "button_press_event", G_CALLBACK (grippy_button_press),
2464 GINT_TO_POINTER (GDK_WINDOW_EDGE_NORTH_EAST));
2466 hbox = gtk_hbox_new (FALSE, 0);
2467 gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 0);
2470 area = gtk_drawing_area_new ();
2471 gtk_widget_add_events (area, GDK_BUTTON_PRESS_MASK);
2472 gtk_box_pack_start (GTK_BOX (hbox), area, TRUE, TRUE, 0);
2473 g_signal_connect (area, "draw", G_CALLBACK (grippy_draw),
2474 GINT_TO_POINTER (GDK_WINDOW_EDGE_WEST));
2475 g_signal_connect (area, "button_press_event", G_CALLBACK (grippy_button_press),
2476 GINT_TO_POINTER (GDK_WINDOW_EDGE_WEST));
2479 area = gtk_drawing_area_new ();
2480 gtk_box_pack_start (GTK_BOX (hbox), area, TRUE, TRUE, 0);
2483 area = gtk_drawing_area_new ();
2484 gtk_widget_add_events (area, GDK_BUTTON_PRESS_MASK);
2485 gtk_box_pack_start (GTK_BOX (hbox), area, TRUE, TRUE, 0);
2486 g_signal_connect (area, "draw", G_CALLBACK (grippy_draw),
2487 GINT_TO_POINTER (GDK_WINDOW_EDGE_EAST));
2488 g_signal_connect (area, "button_press_event", G_CALLBACK (grippy_button_press),
2489 GINT_TO_POINTER (GDK_WINDOW_EDGE_EAST));
2492 hbox = gtk_hbox_new (FALSE, 0);
2493 gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 0);
2496 area = gtk_drawing_area_new ();
2497 gtk_widget_add_events (area, GDK_BUTTON_PRESS_MASK);
2498 gtk_box_pack_start (GTK_BOX (hbox), area, TRUE, TRUE, 0);
2499 g_signal_connect (area, "draw", G_CALLBACK (grippy_draw),
2500 GINT_TO_POINTER (GDK_WINDOW_EDGE_SOUTH_WEST));
2501 g_signal_connect (area, "button_press_event", G_CALLBACK (grippy_button_press),
2502 GINT_TO_POINTER (GDK_WINDOW_EDGE_SOUTH_WEST));
2504 area = gtk_drawing_area_new ();
2505 gtk_widget_add_events (area, GDK_BUTTON_PRESS_MASK);
2506 gtk_box_pack_start (GTK_BOX (hbox), area, TRUE, TRUE, 0);
2507 g_signal_connect (area, "draw", G_CALLBACK (grippy_draw),
2508 GINT_TO_POINTER (GDK_WINDOW_EDGE_SOUTH));
2509 g_signal_connect (area, "button_press_event", G_CALLBACK (grippy_button_press),
2510 GINT_TO_POINTER (GDK_WINDOW_EDGE_SOUTH));
2513 area = gtk_drawing_area_new ();
2514 gtk_widget_add_events (area, GDK_BUTTON_PRESS_MASK);
2515 gtk_box_pack_start (GTK_BOX (hbox), area, TRUE, TRUE, 0);
2516 g_signal_connect (area, "draw", G_CALLBACK (grippy_draw),
2517 GINT_TO_POINTER (GDK_WINDOW_EDGE_SOUTH_EAST));
2518 g_signal_connect (area, "button_press_event", G_CALLBACK (grippy_button_press),
2519 GINT_TO_POINTER (GDK_WINDOW_EDGE_SOUTH_EAST));
2522 if (!gtk_widget_get_visible (window))
2523 gtk_widget_show_all (window);
2525 gtk_widget_destroy (window);
2531 gint upositionx = 0;
2532 gint upositiony = 0;
2535 uposition_configure (GtkWidget *window)
2541 lx = g_object_get_data (G_OBJECT (window), "x");
2542 ly = g_object_get_data (G_OBJECT (window), "y");
2544 gdk_window_get_root_origin (gtk_widget_get_window (window),
2545 &upositionx, &upositiony);
2546 sprintf (buffer, "%d", upositionx);
2547 gtk_label_set_text (lx, buffer);
2548 sprintf (buffer, "%d", upositiony);
2549 gtk_label_set_text (ly, buffer);
2555 uposition_stop_configure (GtkToggleButton *toggle,
2559 g_signal_handlers_block_by_func (window, G_CALLBACK (uposition_configure), NULL);
2561 g_signal_handlers_unblock_by_func (window, G_CALLBACK (uposition_configure), NULL);
2565 create_saved_position (GtkWidget *widget)
2567 static GtkWidget *window = NULL;
2572 GtkWidget *main_vbox;
2580 window = g_object_connect (g_object_new (GTK_TYPE_WINDOW,
2581 "type", GTK_WINDOW_TOPLEVEL,
2582 "title", "Saved Position",
2584 "signal::configure_event", uposition_configure, NULL,
2587 gtk_window_move (GTK_WINDOW (window), upositionx, upositiony);
2589 gtk_window_set_screen (GTK_WINDOW (window),
2590 gtk_widget_get_screen (widget));
2593 g_signal_connect (window, "destroy",
2594 G_CALLBACK (gtk_widget_destroyed),
2597 main_vbox = gtk_vbox_new (FALSE, 5);
2598 gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 0);
2599 gtk_container_add (GTK_CONTAINER (window), main_vbox);
2602 g_object_new (gtk_vbox_get_type (),
2603 "GtkBox::homogeneous", FALSE,
2604 "GtkBox::spacing", 5,
2605 "GtkContainer::border_width", 10,
2606 "GtkWidget::parent", main_vbox,
2607 "GtkWidget::visible", TRUE,
2608 "child", g_object_connect (g_object_new (GTK_TYPE_TOGGLE_BUTTON,
2609 "label", "Stop Events",
2613 "signal::clicked", uposition_stop_configure, window,
2617 hbox = gtk_hbox_new (FALSE, 0);
2618 gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
2619 gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0);
2621 label = gtk_label_new ("X Origin : ");
2622 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
2623 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
2625 x_label = gtk_label_new ("");
2626 gtk_box_pack_start (GTK_BOX (hbox), x_label, TRUE, TRUE, 0);
2627 g_object_set_data (G_OBJECT (window), "x", x_label);
2629 hbox = gtk_hbox_new (FALSE, 0);
2630 gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
2631 gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0);
2633 label = gtk_label_new ("Y Origin : ");
2634 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
2635 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
2637 y_label = gtk_label_new ("");
2638 gtk_box_pack_start (GTK_BOX (hbox), y_label, TRUE, TRUE, 0);
2639 g_object_set_data (G_OBJECT (window), "y", y_label);
2642 g_object_new (gtk_hseparator_get_type (),
2643 "GtkWidget::visible", TRUE,
2645 gtk_box_pack_start (GTK_BOX (main_vbox), any, FALSE, TRUE, 0);
2647 hbox = gtk_hbox_new (FALSE, 0);
2648 gtk_container_set_border_width (GTK_CONTAINER (hbox), 10);
2649 gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, TRUE, 0);
2651 button = gtk_button_new_with_label ("Close");
2652 g_signal_connect_swapped (button, "clicked",
2653 G_CALLBACK (gtk_widget_destroy),
2655 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
2656 gtk_widget_set_can_default (button, TRUE);
2657 gtk_widget_grab_default (button);
2659 gtk_widget_show_all (window);
2662 gtk_widget_destroy (window);
2670 create_pixbuf (GtkWidget *widget)
2672 static GtkWidget *window = NULL;
2678 GtkWidget *separator;
2679 GtkWidget *pixbufwid;
2680 GdkWindow *gdk_window;
2684 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
2686 gtk_window_set_screen (GTK_WINDOW (window),
2687 gtk_widget_get_screen (widget));
2689 g_signal_connect (window, "destroy",
2690 G_CALLBACK (gtk_widget_destroyed),
2693 gtk_window_set_title (GTK_WINDOW (window), "GtkPixmap");
2694 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
2695 gtk_widget_realize(window);
2697 box1 = gtk_vbox_new (FALSE, 0);
2698 gtk_container_add (GTK_CONTAINER (window), box1);
2700 box2 = gtk_vbox_new (FALSE, 10);
2701 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
2702 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
2704 button = gtk_button_new ();
2705 gtk_box_pack_start (GTK_BOX (box2), button, FALSE, FALSE, 0);
2707 gdk_window = gtk_widget_get_window (window);
2709 pixbufwid = new_pixbuf ("test.xpm", gdk_window, NULL);
2711 label = gtk_label_new ("Pixbuf\ntest");
2712 box3 = gtk_hbox_new (FALSE, 0);
2713 gtk_container_set_border_width (GTK_CONTAINER (box3), 2);
2714 gtk_container_add (GTK_CONTAINER (box3), pixbufwid);
2715 gtk_container_add (GTK_CONTAINER (box3), label);
2716 gtk_container_add (GTK_CONTAINER (button), box3);
2718 button = gtk_button_new ();
2719 gtk_box_pack_start (GTK_BOX (box2), button, FALSE, FALSE, 0);
2721 pixbufwid = new_pixbuf ("test.xpm", gdk_window, NULL);
2723 label = gtk_label_new ("Pixbuf\ntest");
2724 box3 = gtk_hbox_new (FALSE, 0);
2725 gtk_container_set_border_width (GTK_CONTAINER (box3), 2);
2726 gtk_container_add (GTK_CONTAINER (box3), pixbufwid);
2727 gtk_container_add (GTK_CONTAINER (box3), label);
2728 gtk_container_add (GTK_CONTAINER (button), box3);
2730 gtk_widget_set_sensitive (button, FALSE);
2732 separator = gtk_hseparator_new ();
2733 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
2735 box2 = gtk_vbox_new (FALSE, 10);
2736 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
2737 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
2739 button = gtk_button_new_with_label ("close");
2740 g_signal_connect_swapped (button, "clicked",
2741 G_CALLBACK (gtk_widget_destroy),
2743 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
2744 gtk_widget_set_can_default (button, TRUE);
2745 gtk_widget_grab_default (button);
2748 if (!gtk_widget_get_visible (window))
2749 gtk_widget_show_all (window);
2751 gtk_widget_destroy (window);
2755 create_tooltips (GtkWidget *widget)
2757 static GtkWidget *window = NULL;
2764 GtkWidget *separator;
2769 g_object_new (gtk_window_get_type (),
2770 "GtkWindow::type", GTK_WINDOW_TOPLEVEL,
2771 "GtkContainer::border_width", 0,
2772 "GtkWindow::title", "Tooltips",
2773 "GtkWindow::resizable", FALSE,
2776 gtk_window_set_screen (GTK_WINDOW (window),
2777 gtk_widget_get_screen (widget));
2779 box1 = gtk_vbox_new (FALSE, 0);
2780 gtk_container_add (GTK_CONTAINER (window), box1);
2782 box2 = gtk_vbox_new (FALSE, 10);
2783 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
2784 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
2786 button = gtk_toggle_button_new_with_label ("button1");
2787 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
2789 gtk_widget_set_tooltip_text (button, "This is button 1");
2791 button = gtk_toggle_button_new_with_label ("button2");
2792 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
2794 gtk_widget_set_tooltip_text (button,
2795 "This is button 2. This is also a really long tooltip which probably "
2796 "won't fit on a single line and will therefore need to be wrapped. "
2797 "Hopefully the wrapping will work correctly.");
2799 toggle = gtk_toggle_button_new_with_label ("Override TipsQuery Label");
2800 gtk_box_pack_start (GTK_BOX (box2), toggle, TRUE, TRUE, 0);
2802 gtk_widget_set_tooltip_text (toggle, "Toggle TipsQuery view.");
2805 g_object_new (gtk_vbox_get_type (),
2806 "homogeneous", FALSE,
2813 g_object_new (gtk_button_get_type (),
2818 gtk_box_set_child_packing (GTK_BOX (box3), button, FALSE, FALSE, 0, GTK_PACK_START);
2819 gtk_widget_set_tooltip_text (button, "Start the Tooltips Inspector");
2821 frame = g_object_new (gtk_frame_get_type (),
2822 "label", "ToolTips Inspector",
2823 "label_xalign", (double) 0.5,
2829 gtk_box_set_child_packing (GTK_BOX (box2), frame, TRUE, TRUE, 10, GTK_PACK_START);
2831 separator = gtk_hseparator_new ();
2832 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
2834 box2 = gtk_vbox_new (FALSE, 10);
2835 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
2836 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
2838 button = gtk_button_new_with_label ("close");
2839 g_signal_connect_swapped (button, "clicked",
2840 G_CALLBACK (gtk_widget_destroy),
2842 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
2843 gtk_widget_set_can_default (button, TRUE);
2844 gtk_widget_grab_default (button);
2846 gtk_widget_set_tooltip_text (button, "Push this button to close window");
2849 if (!gtk_widget_get_visible (window))
2850 gtk_widget_show_all (window);
2852 gtk_widget_destroy (window);
2860 pack_image (GtkWidget *box,
2864 gtk_box_pack_start (GTK_BOX (box),
2865 gtk_label_new (text),
2868 gtk_box_pack_start (GTK_BOX (box),
2874 create_image (GtkWidget *widget)
2876 static GtkWidget *window = NULL;
2883 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
2885 gtk_window_set_screen (GTK_WINDOW (window),
2886 gtk_widget_get_screen (widget));
2888 /* this is bogus for testing drawing when allocation < request,
2889 * don't copy into real code
2891 gtk_window_set_resizable (GTK_WINDOW (window), TRUE);
2893 g_signal_connect (window, "destroy",
2894 G_CALLBACK (gtk_widget_destroyed),
2897 vbox = gtk_vbox_new (FALSE, 5);
2899 gtk_container_add (GTK_CONTAINER (window), vbox);
2901 pack_image (vbox, "Stock Warning Dialog",
2902 gtk_image_new_from_stock (GTK_STOCK_DIALOG_WARNING,
2903 GTK_ICON_SIZE_DIALOG));
2905 pixbuf = gdk_pixbuf_new_from_xpm_data ((const char **) openfile);
2907 pack_image (vbox, "Pixbuf",
2908 gtk_image_new_from_pixbuf (pixbuf));
2910 g_object_unref (pixbuf);
2913 if (!gtk_widget_get_visible (window))
2914 gtk_widget_show_all (window);
2916 gtk_widget_destroy (window);
2924 create_menu (GdkScreen *screen, gint depth, gint length, gboolean tearoff)
2927 GtkWidget *menuitem;
2936 menu = gtk_menu_new ();
2937 gtk_menu_set_screen (GTK_MENU (menu), screen);
2943 menuitem = gtk_tearoff_menu_item_new ();
2944 gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
2945 gtk_widget_show (menuitem);
2948 image = gtk_image_new_from_stock (GTK_STOCK_OPEN,
2949 GTK_ICON_SIZE_MENU);
2950 gtk_widget_show (image);
2951 menuitem = gtk_image_menu_item_new_with_label ("Image item");
2952 gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menuitem), image);
2953 gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
2954 gtk_widget_show (menuitem);
2956 for (i = 0, j = 1; i < length; i++, j++)
2958 sprintf (buf, "item %2d - %d", depth, j);
2960 menuitem = gtk_radio_menu_item_new_with_label (group, buf);
2961 group = gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (menuitem));
2963 gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
2964 gtk_widget_show (menuitem);
2966 gtk_widget_set_sensitive (menuitem, FALSE);
2969 gtk_check_menu_item_set_inconsistent (GTK_CHECK_MENU_ITEM (menuitem),
2973 gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem),
2974 create_menu (screen, depth - 1, 5, TRUE));
2981 create_table_menu (GdkScreen *screen, gint cols, gint rows, gboolean tearoff)
2984 GtkWidget *menuitem;
2990 menu = gtk_menu_new ();
2991 gtk_menu_set_screen (GTK_MENU (menu), screen);
2996 menuitem = gtk_tearoff_menu_item_new ();
2997 gtk_menu_attach (GTK_MENU (menu), menuitem, 0, cols, j, j + 1);
2998 gtk_widget_show (menuitem);
3002 menuitem = gtk_menu_item_new_with_label ("items");
3003 gtk_menu_attach (GTK_MENU (menu), menuitem, 0, cols, j, j + 1);
3005 submenu = gtk_menu_new ();
3006 gtk_menu_set_screen (GTK_MENU (submenu), screen);
3007 gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), submenu);
3008 gtk_widget_show (menuitem);
3011 /* now fill the items submenu */
3012 image = gtk_image_new_from_stock (GTK_STOCK_HELP,
3013 GTK_ICON_SIZE_MENU);
3014 gtk_widget_show (image);
3015 menuitem = gtk_image_menu_item_new_with_label ("Image");
3016 gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menuitem), image);
3017 gtk_menu_attach (GTK_MENU (submenu), menuitem, 0, 1, 0, 1);
3018 gtk_widget_show (menuitem);
3020 menuitem = gtk_menu_item_new_with_label ("x");
3021 gtk_menu_attach (GTK_MENU (submenu), menuitem, 1, 2, 0, 1);
3022 gtk_widget_show (menuitem);
3024 menuitem = gtk_menu_item_new_with_label ("x");
3025 gtk_menu_attach (GTK_MENU (submenu), menuitem, 0, 1, 1, 2);
3026 gtk_widget_show (menuitem);
3028 image = gtk_image_new_from_stock (GTK_STOCK_HELP,
3029 GTK_ICON_SIZE_MENU);
3030 gtk_widget_show (image);
3031 menuitem = gtk_image_menu_item_new_with_label ("Image");
3032 gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menuitem), image);
3033 gtk_menu_attach (GTK_MENU (submenu), menuitem, 1, 2, 1, 2);
3034 gtk_widget_show (menuitem);
3036 menuitem = gtk_radio_menu_item_new_with_label (NULL, "Radio");
3037 gtk_menu_attach (GTK_MENU (submenu), menuitem, 0, 1, 2, 3);
3038 gtk_widget_show (menuitem);
3040 menuitem = gtk_menu_item_new_with_label ("x");
3041 gtk_menu_attach (GTK_MENU (submenu), menuitem, 1, 2, 2, 3);
3042 gtk_widget_show (menuitem);
3044 menuitem = gtk_menu_item_new_with_label ("x");
3045 gtk_menu_attach (GTK_MENU (submenu), menuitem, 0, 1, 3, 4);
3046 gtk_widget_show (menuitem);
3048 menuitem = gtk_radio_menu_item_new_with_label (NULL, "Radio");
3049 gtk_menu_attach (GTK_MENU (submenu), menuitem, 1, 2, 3, 4);
3050 gtk_widget_show (menuitem);
3052 menuitem = gtk_check_menu_item_new_with_label ("Check");
3053 gtk_menu_attach (GTK_MENU (submenu), menuitem, 0, 1, 4, 5);
3054 gtk_widget_show (menuitem);
3056 menuitem = gtk_menu_item_new_with_label ("x");
3057 gtk_menu_attach (GTK_MENU (submenu), menuitem, 1, 2, 4, 5);
3058 gtk_widget_show (menuitem);
3060 menuitem = gtk_menu_item_new_with_label ("x");
3061 gtk_menu_attach (GTK_MENU (submenu), menuitem, 0, 1, 5, 6);
3062 gtk_widget_show (menuitem);
3064 menuitem = gtk_check_menu_item_new_with_label ("Check");
3065 gtk_menu_attach (GTK_MENU (submenu), menuitem, 1, 2, 5, 6);
3066 gtk_widget_show (menuitem);
3068 menuitem = gtk_menu_item_new_with_label ("1. Inserted normally (8)");
3069 gtk_widget_show (menuitem);
3070 gtk_menu_shell_insert (GTK_MENU_SHELL (submenu), menuitem, 8);
3072 menuitem = gtk_menu_item_new_with_label ("2. Inserted normally (2)");
3073 gtk_widget_show (menuitem);
3074 gtk_menu_shell_insert (GTK_MENU_SHELL (submenu), menuitem, 2);
3076 menuitem = gtk_menu_item_new_with_label ("3. Inserted normally (0)");
3077 gtk_widget_show (menuitem);
3078 gtk_menu_shell_insert (GTK_MENU_SHELL (submenu), menuitem, 0);
3080 menuitem = gtk_menu_item_new_with_label ("4. Inserted normally (-1)");
3081 gtk_widget_show (menuitem);
3082 gtk_menu_shell_insert (GTK_MENU_SHELL (submenu), menuitem, -1);
3084 /* end of items submenu */
3086 menuitem = gtk_menu_item_new_with_label ("spanning");
3087 gtk_menu_attach (GTK_MENU (menu), menuitem, 0, cols, j, j + 1);
3089 submenu = gtk_menu_new ();
3090 gtk_menu_set_screen (GTK_MENU (submenu), screen);
3091 gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), submenu);
3092 gtk_widget_show (menuitem);
3095 /* now fill the spanning submenu */
3096 menuitem = gtk_menu_item_new_with_label ("a");
3097 gtk_menu_attach (GTK_MENU (submenu), menuitem, 0, 2, 0, 1);
3098 gtk_widget_show (menuitem);
3100 menuitem = gtk_menu_item_new_with_label ("b");
3101 gtk_menu_attach (GTK_MENU (submenu), menuitem, 2, 3, 0, 2);
3102 gtk_widget_show (menuitem);
3104 menuitem = gtk_menu_item_new_with_label ("c");
3105 gtk_menu_attach (GTK_MENU (submenu), menuitem, 0, 1, 1, 3);
3106 gtk_widget_show (menuitem);
3108 menuitem = gtk_menu_item_new_with_label ("d");
3109 gtk_menu_attach (GTK_MENU (submenu), menuitem, 1, 2, 1, 2);
3110 gtk_widget_show (menuitem);
3112 menuitem = gtk_menu_item_new_with_label ("e");
3113 gtk_menu_attach (GTK_MENU (submenu), menuitem, 1, 3, 2, 3);
3114 gtk_widget_show (menuitem);
3115 /* end of spanning submenu */
3117 menuitem = gtk_menu_item_new_with_label ("left");
3118 gtk_menu_attach (GTK_MENU (menu), menuitem, 0, 1, j, j + 1);
3119 submenu = gtk_menu_new ();
3120 gtk_menu_set_screen (GTK_MENU (submenu), screen);
3121 gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), submenu);
3122 gtk_widget_show (menuitem);
3124 menuitem = gtk_menu_item_new_with_label ("Empty");
3125 gtk_menu_attach (GTK_MENU (submenu), menuitem, 0, 1, 0, 1);
3126 submenu = gtk_menu_new ();
3127 gtk_menu_set_screen (GTK_MENU (submenu), screen);
3128 gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), submenu);
3129 gtk_widget_show (menuitem);
3131 menuitem = gtk_menu_item_new_with_label ("right");
3132 gtk_menu_attach (GTK_MENU (menu), menuitem, 1, 2, j, j + 1);
3133 submenu = gtk_menu_new ();
3134 gtk_menu_set_screen (GTK_MENU (submenu), screen);
3135 gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), submenu);
3136 gtk_widget_show (menuitem);
3138 menuitem = gtk_menu_item_new_with_label ("Empty");
3139 gtk_menu_attach (GTK_MENU (submenu), menuitem, 0, 1, 0, 1);
3140 gtk_widget_show (menuitem);
3144 for (; j < rows; j++)
3145 for (i = 0; i < cols; i++)
3147 sprintf (buf, "(%d %d)", i, j);
3148 menuitem = gtk_menu_item_new_with_label (buf);
3149 gtk_menu_attach (GTK_MENU (menu), menuitem, i, i + 1, j, j + 1);
3150 gtk_widget_show (menuitem);
3153 menuitem = gtk_menu_item_new_with_label ("1. Inserted normally (8)");
3154 gtk_menu_shell_insert (GTK_MENU_SHELL (menu), menuitem, 8);
3155 gtk_widget_show (menuitem);
3156 menuitem = gtk_menu_item_new_with_label ("2. Inserted normally (2)");
3157 gtk_menu_shell_insert (GTK_MENU_SHELL (menu), menuitem, 2);
3158 gtk_widget_show (menuitem);
3159 menuitem = gtk_menu_item_new_with_label ("3. Inserted normally (0)");
3160 gtk_menu_shell_insert (GTK_MENU_SHELL (menu), menuitem, 0);
3161 gtk_widget_show (menuitem);
3162 menuitem = gtk_menu_item_new_with_label ("4. Inserted normally (-1)");
3163 gtk_menu_shell_insert (GTK_MENU_SHELL (menu), menuitem, -1);
3164 gtk_widget_show (menuitem);
3170 create_menus (GtkWidget *widget)
3172 static GtkWidget *window = NULL;
3176 GtkWidget *optionmenu;
3177 GtkWidget *separator;
3183 GtkWidget *menuitem;
3184 GtkAccelGroup *accel_group;
3186 GdkScreen *screen = gtk_widget_get_screen (widget);
3188 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
3190 gtk_window_set_screen (GTK_WINDOW (window), screen);
3192 g_signal_connect (window, "destroy",
3193 G_CALLBACK (gtk_widget_destroyed),
3195 g_signal_connect (window, "delete-event",
3196 G_CALLBACK (gtk_true),
3199 accel_group = gtk_accel_group_new ();
3200 gtk_window_add_accel_group (GTK_WINDOW (window), accel_group);
3202 gtk_window_set_title (GTK_WINDOW (window), "menus");
3203 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
3206 box1 = gtk_vbox_new (FALSE, 0);
3207 gtk_container_add (GTK_CONTAINER (window), box1);
3208 gtk_widget_show (box1);
3210 menubar = gtk_menu_bar_new ();
3211 gtk_box_pack_start (GTK_BOX (box1), menubar, FALSE, TRUE, 0);
3212 gtk_widget_show (menubar);
3214 menu = create_menu (screen, 2, 50, TRUE);
3216 menuitem = gtk_menu_item_new_with_label ("test\nline2");
3217 gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), menu);
3218 gtk_menu_shell_append (GTK_MENU_SHELL (menubar), menuitem);
3219 gtk_widget_show (menuitem);
3221 menu = create_table_menu (screen, 2, 50, TRUE);
3223 menuitem = gtk_menu_item_new_with_label ("table");
3224 gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), menu);
3225 gtk_menu_shell_append (GTK_MENU_SHELL (menubar), menuitem);
3226 gtk_widget_show (menuitem);
3228 menuitem = gtk_menu_item_new_with_label ("foo");
3229 gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), create_menu (screen, 3, 5, TRUE));
3230 gtk_menu_shell_append (GTK_MENU_SHELL (menubar), menuitem);
3231 gtk_widget_show (menuitem);
3233 image = gtk_image_new_from_stock (GTK_STOCK_HELP,
3234 GTK_ICON_SIZE_MENU);
3235 gtk_widget_show (image);
3236 menuitem = gtk_image_menu_item_new_with_label ("Help");
3237 gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menuitem), image);
3238 gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), create_menu (screen, 4, 5, TRUE));
3239 gtk_menu_item_set_right_justified (GTK_MENU_ITEM (menuitem), TRUE);
3240 gtk_menu_shell_append (GTK_MENU_SHELL (menubar), menuitem);
3241 gtk_widget_show (menuitem);
3243 menubar = gtk_menu_bar_new ();
3244 gtk_box_pack_start (GTK_BOX (box1), menubar, FALSE, TRUE, 0);
3245 gtk_widget_show (menubar);
3247 menu = create_menu (screen, 2, 10, TRUE);
3249 menuitem = gtk_menu_item_new_with_label ("Second menu bar");
3250 gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), menu);
3251 gtk_menu_shell_append (GTK_MENU_SHELL (menubar), menuitem);
3252 gtk_widget_show (menuitem);
3254 box2 = gtk_vbox_new (FALSE, 10);
3255 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
3256 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
3257 gtk_widget_show (box2);
3259 menu = create_menu (screen, 1, 5, FALSE);
3260 gtk_menu_set_accel_group (GTK_MENU (menu), accel_group);
3262 menuitem = gtk_image_menu_item_new_from_stock (GTK_STOCK_NEW, accel_group);
3263 gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
3264 gtk_widget_show (menuitem);
3266 menuitem = gtk_check_menu_item_new_with_label ("Accelerate Me");
3267 gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
3268 gtk_widget_show (menuitem);
3269 gtk_widget_add_accelerator (menuitem,
3275 menuitem = gtk_check_menu_item_new_with_label ("Accelerator Locked");
3276 gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
3277 gtk_widget_show (menuitem);
3278 gtk_widget_add_accelerator (menuitem,
3283 GTK_ACCEL_VISIBLE | GTK_ACCEL_LOCKED);
3284 menuitem = gtk_check_menu_item_new_with_label ("Accelerators Frozen");
3285 gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
3286 gtk_widget_show (menuitem);
3287 gtk_widget_add_accelerator (menuitem,
3293 gtk_widget_add_accelerator (menuitem,
3300 optionmenu = gtk_combo_box_new_text ();
3301 gtk_combo_box_set_active (GTK_COMBO_BOX (optionmenu), 3);
3302 gtk_box_pack_start (GTK_BOX (box2), optionmenu, TRUE, TRUE, 0);
3303 gtk_widget_show (optionmenu);
3305 separator = gtk_hseparator_new ();
3306 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
3307 gtk_widget_show (separator);
3309 box2 = gtk_vbox_new (FALSE, 10);
3310 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
3311 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
3312 gtk_widget_show (box2);
3314 button = gtk_button_new_with_label ("close");
3315 g_signal_connect_swapped (button, "clicked",
3316 G_CALLBACK (gtk_widget_destroy),
3318 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
3319 gtk_widget_set_can_default (button, TRUE);
3320 gtk_widget_grab_default (button);
3321 gtk_widget_show (button);
3324 if (!gtk_widget_get_visible (window))
3325 gtk_widget_show (window);
3327 gtk_widget_destroy (window);
3330 /* GdkPixbuf RGBA C-Source image dump */
3332 static const guint8 apple[] =
3334 /* Pixbuf magic (0x47646b50) */
3336 /* length: header (24) + pixel_data (2304) */
3338 /* pixdata_type (0x1010002) */
3340 /* rowstride (96) */
3347 "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
3348 "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
3349 "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
3350 "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
3351 "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
3352 "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
3353 "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\26\24"
3354 "\17\11\0\0\0\2\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
3355 "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`m"
3356 "[pn{a\344hv_\345_k[`\0\0\0\0\0\0\0\0\0\0\0\0D>/\305\0\0\0_\0\0\0\0\0"
3357 "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
3358 "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`l[Blza\373s\202d\354w\206g\372p~c"
3359 "\374`l[y\0\0\0\0[S\77/\27\25\17\335\0\0\0\20\0\0\0\0\0\0\0\0\0\0\0\0"
3360 "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
3361 "\0\0\0\0\0\0`l\\\20iw_\356y\211h\373x\207g\364~\216i\364u\204e\366gt"
3362 "_\374^jX\241A;-_\0\0\0~\0\0\0\0SM4)SM21B9&\22\320\270\204\1\320\270\204"
3363 "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0eq"
3364 "]\212r\200c\366v\205f\371jx_\323_kY\232_kZH^jY\26]iW\211@G9\272:6%j\220"
3365 "\211]\320\221\211`\377\212\203Z\377~xP\377mkE\331]^;|/0\37\21\0\0\0\0"
3366 "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0ly`\40p~b\360lz`\353^kY\246["
3367 "eT<\216\200Z\203\227\211_\354\234\217c\377\232\217b\362\232\220c\337"
3368 "\243\233k\377\252\241p\377\250\236p\377\241\225h\377\231\214_\377\210"
3369 "\202U\377srI\377[]:\355KO0U\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0i"
3370 "v^\200`lY\211^jY\"\0\0\0\0\221\204\\\273\250\233r\377\302\267\224\377"
3371 "\311\300\237\377\272\256\204\377\271\256\177\377\271\257\200\377\267"
3372 "\260\177\377\260\251x\377\250\236l\377\242\225e\377\226\213]\377~zP\377"
3373 "ff@\377QT5\377LR2d\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0]iW(\0\0\0\0\0\0\0"
3374 "\0\213\203[v\253\240t\377\334\326\301\377\344\340\317\377\321\312\253"
3375 "\377\303\271\217\377\300\270\213\377\277\267\210\377\272\264\203\377"
3376 "\261\255z\377\250\242n\377\243\232h\377\232\220`\377\210\202V\377nnE"
3377 "\377SW6\377RX6\364Za<\34\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0b]@\20"
3378 "\234\222e\362\304\274\232\377\337\333\306\377\332\325\273\377\311\302"
3379 "\232\377\312\303\236\377\301\273\216\377\300\271\212\377\270\264\200"
3380 "\377\256\253v\377\246\243n\377\236\232h\377\230\220`\377\213\203V\377"
3381 "wvL\377X]:\377KR0\377NU5v\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\212"
3382 "\203Zl\242\234l\377\321\315\260\377\331\324\271\377\320\313\251\377\307"
3383 "\301\232\377\303\276\224\377\300\272\214\377\274\267\206\377\264\260"
3384 "|\377\253\251s\377\244\243n\377\232\230e\377\223\216^\377\207\200U\377"
3385 "ttJ\377[_<\377HO/\377GN0\200\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
3386 "\210\204Y\240\245\237o\377\316\310\253\377\310\303\237\377\304\300\230"
3387 "\377\303\277\225\377\277\272\216\377\274\270\210\377\266\263\200\377"
3388 "\256\254v\377\247\246p\377\237\236j\377\227\226d\377\215\212[\377\203"
3389 "\177T\377qsH\377X]8\377FN.\377DK-\200\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
3390 "\0\0\0\0\207\204X\257\244\240o\377\300\275\231\377\301\275\226\377\274"
3391 "\270\213\377\274\270\214\377\267\264\205\377\264\262\200\377\260\256"
3392 "z\377\251\251s\377\243\244n\377\231\232g\377\220\222`\377\210\211Y\377"
3393 "|}Q\377hlC\377PU3\377CK,\377DL/Y\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
3394 "\0\0\205\204X\220\232\230h\377\261\260\204\377\266\264\212\377\261\260"
3395 "\201\377\263\260\200\377\260\257}\377\256\256x\377\253\254t\377\244\246"
3396 "o\377\233\236i\377\221\224b\377\211\214\\\377\202\204V\377txM\377]b>"
3397 "\377HP0\377@H+\373CJ-\25\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0xxO>"
3398 "\215\215_\377\237\237r\377\247\247x\377\247\247t\377\252\252w\377\252"
3399 "\252u\377\252\253t\377\243\246o\377\235\240j\377\223\230c\377\213\217"
3400 "]\377\201\206V\377x}P\377gkD\377RY5\377BI,\377AI,\262\0\0\0\0\0\0\0\0"
3401 "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\202\205W\312\216\220`\377\230"
3402 "\232g\377\234\236i\377\236\241l\377\241\244n\377\240\244m\377\232\237"
3403 "i\377\223\230c\377\212\221]\377\200\210W\377v|P\377jnG\377Za>\377HP2"
3404 "\377=D)\377HQ1:\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
3405 "\0wzQ6\177\201U\371\206\211Z\377\216\222`\377\220\225a\377\220\225b\377"
3406 "\220\226a\377\213\221_\377\204\213Z\377{\203R\377ryN\377iqH\377^fA\377"
3407 "R[;\377BJ-\3778@'\317\0\0\0>\0\0\0\36\0\0\0\7\0\0\0\0\0\0\0\0\0\0\0\0"
3408 "\0\0\0\0\0\0\0\0\0\0\0\0ptJTw|Q\371z\177R\377}\202T\377|\203T\377z\200"
3409 "R\377v|O\377pwL\377jpF\377dlB\377`hB\377Yb@\377LT6\377<C*\377\11\12\6"
3410 "\376\0\0\0\347\0\0\0\262\0\0\0Y\0\0\0\32\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
3411 "\0\0\0\0\0\0\0\0\0\0\\`=UgnE\370hnG\377gmE\377djB\377]d>\377[c<\377Y"
3412 "b<\377Zc>\377V_>\377OW8\377BK/\377\16\20\12\377\0\0\0\377\0\0\0\377\0"
3413 "\0\0\374\0\0\0\320\0\0\0I\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
3414 "\0\1\0\0\0\40\22\24\15\260@D+\377W`;\377OV5\377.3\36\377.3\37\377IP0"
3415 "\377RZ7\377PZ8\3776=&\377\14\15\10\377\0\0\0\377\0\0\0\377\0\0\0\377"
3416 "\0\0\0\347\0\0\0\217\0\0\0""4\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
3417 "\0\0\0\0\0\0\0\20\0\0\0P\0\0\0\252\7\10\5\346\7\7\5\375\0\0\0\377\0\0"
3418 "\0\377\0\0\0\377\0\0\0\377\0\0\0\377\0\0\0\377\0\0\0\377\0\0\0\374\0"
3419 "\0\0\336\0\0\0\254\0\0\0i\0\0\0""2\0\0\0\10\0\0\0\0\0\0\0\0\0\0\0\0\0"
3420 "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\11\0\0\0\40\0\0\0D\0\0\0m\0\0\0"
3421 "\226\0\0\0\234\0\0\0\234\0\0\0\244\0\0\0\246\0\0\0\232\0\0\0\202\0\0"
3422 "\0i\0\0\0T\0\0\0,\0\0\0\15\0\0\0\2\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
3423 "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\2\0\0\0\6\0\0\0"
3424 "\16\0\0\0\22\0\0\0\24\0\0\0\23\0\0\0\17\0\0\0\14\0\0\0\13\0\0\0\10\0"
3425 "\0\0\5\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"};
3429 accel_button_new (GtkAccelGroup *accel_group,
3434 GdkModifierType modifiers;
3438 gtk_accelerator_parse (accel, &keyval, &modifiers);
3441 button = gtk_button_new ();
3442 gtk_widget_add_accelerator (button, "activate", accel_group,
3443 keyval, modifiers, GTK_ACCEL_VISIBLE | GTK_ACCEL_LOCKED);
3445 label = gtk_accel_label_new (text);
3446 gtk_accel_label_set_accel_widget (GTK_ACCEL_LABEL (label), button);
3447 gtk_widget_show (label);
3449 gtk_container_add (GTK_CONTAINER (button), label);
3455 create_key_lookup (GtkWidget *widget)
3457 static GtkWidget *window = NULL;
3458 gpointer window_ptr;
3462 GtkAccelGroup *accel_group = gtk_accel_group_new ();
3464 GtkWidget *content_area;
3466 window = gtk_dialog_new_with_buttons ("Key Lookup", NULL, 0,
3467 GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE,
3470 gtk_window_set_screen (GTK_WINDOW (window),
3471 gtk_widget_get_screen (widget));
3473 /* We have to expand it so the accel labels will draw their labels
3475 gtk_window_set_default_size (GTK_WINDOW (window), 300, -1);
3477 gtk_window_add_accel_group (GTK_WINDOW (window), accel_group);
3479 content_area = gtk_dialog_get_content_area (GTK_DIALOG (window));
3481 button = gtk_button_new_with_mnemonic ("Button 1 (_a)");
3482 gtk_box_pack_start (GTK_BOX (content_area), button, FALSE, FALSE, 0);
3483 button = gtk_button_new_with_mnemonic ("Button 2 (_A)");
3484 gtk_box_pack_start (GTK_BOX (content_area), button, FALSE, FALSE, 0);
3485 button = gtk_button_new_with_mnemonic ("Button 3 (_\321\204)");
3486 gtk_box_pack_start (GTK_BOX (content_area), button, FALSE, FALSE, 0);
3487 button = gtk_button_new_with_mnemonic ("Button 4 (_\320\244)");
3488 gtk_box_pack_start (GTK_BOX (content_area), button, FALSE, FALSE, 0);
3489 button = gtk_button_new_with_mnemonic ("Button 6 (_b)");
3490 gtk_box_pack_start (GTK_BOX (content_area), button, FALSE, FALSE, 0);
3491 button = accel_button_new (accel_group, "Button 7", "<Alt><Shift>b");
3492 gtk_box_pack_start (GTK_BOX (content_area), button, FALSE, FALSE, 0);
3493 button = accel_button_new (accel_group, "Button 8", "<Alt>d");
3494 gtk_box_pack_start (GTK_BOX (content_area), button, FALSE, FALSE, 0);
3495 button = accel_button_new (accel_group, "Button 9", "<Alt>Cyrillic_ve");
3496 gtk_box_pack_start (GTK_BOX (content_area), button, FALSE, FALSE, 0);
3497 button = gtk_button_new_with_mnemonic ("Button 10 (_1)");
3498 gtk_box_pack_start (GTK_BOX (content_area), button, FALSE, FALSE, 0);
3499 button = gtk_button_new_with_mnemonic ("Button 11 (_!)");
3500 gtk_box_pack_start (GTK_BOX (content_area), button, FALSE, FALSE, 0);
3501 button = accel_button_new (accel_group, "Button 12", "<Super>a");
3502 gtk_box_pack_start (GTK_BOX (content_area), button, FALSE, FALSE, 0);
3503 button = accel_button_new (accel_group, "Button 13", "<Hyper>a");
3504 gtk_box_pack_start (GTK_BOX (content_area), button, FALSE, FALSE, 0);
3505 button = accel_button_new (accel_group, "Button 14", "<Meta>a");
3506 gtk_box_pack_start (GTK_BOX (content_area), button, FALSE, FALSE, 0);
3507 button = accel_button_new (accel_group, "Button 15", "<Shift><Mod4>b");
3508 gtk_box_pack_start (GTK_BOX (content_area), button, FALSE, FALSE, 0);
3510 window_ptr = &window;
3511 g_object_add_weak_pointer (G_OBJECT (window), window_ptr);
3512 g_signal_connect (window, "response", G_CALLBACK (gtk_widget_destroy), NULL);
3514 gtk_widget_show_all (window);
3517 gtk_widget_destroy (window);
3526 cmw_destroy_cb(GtkWidget *widget)
3528 /* This is needed to get out of gtk_main */
3535 cmw_color (GtkWidget *widget, GtkWidget *parent)
3538 GtkWidget *colorsel;
3539 GtkWidget *ok_button, *cancel_button;
3541 csd = gtk_color_selection_dialog_new ("This is a modal color selection dialog");
3543 gtk_window_set_screen (GTK_WINDOW (csd), gtk_widget_get_screen (parent));
3545 colorsel = gtk_color_selection_dialog_get_color_selection (GTK_COLOR_SELECTION_DIALOG (csd));
3546 gtk_color_selection_set_has_palette (GTK_COLOR_SELECTION (colorsel),
3550 gtk_window_set_modal (GTK_WINDOW(csd),TRUE);
3552 /* And mark it as a transient dialog */
3553 gtk_window_set_transient_for (GTK_WINDOW (csd), GTK_WINDOW (parent));
3555 g_signal_connect (csd, "destroy",
3556 G_CALLBACK (cmw_destroy_cb), NULL);
3559 "ok-button", &ok_button,
3560 "cancel-button", &cancel_button,
3563 g_signal_connect_swapped (ok_button,
3564 "clicked", G_CALLBACK (gtk_widget_destroy), csd);
3565 g_signal_connect_swapped (cancel_button,
3566 "clicked", G_CALLBACK (gtk_widget_destroy), csd);
3568 /* wait until destroy calls gtk_main_quit */
3569 gtk_widget_show (csd);
3574 cmw_file (GtkWidget *widget, GtkWidget *parent)
3578 fs = gtk_file_chooser_dialog_new ("This is a modal file selection dialog",
3579 GTK_WINDOW (parent), GTK_FILE_CHOOSER_ACTION_OPEN,
3580 GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
3581 GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
3583 gtk_window_set_screen (GTK_WINDOW (fs), gtk_widget_get_screen (parent));
3584 gtk_window_set_modal (GTK_WINDOW (fs), TRUE);
3586 g_signal_connect (fs, "destroy",
3587 G_CALLBACK (cmw_destroy_cb), NULL);
3588 g_signal_connect_swapped (fs, "response",
3589 G_CALLBACK (gtk_widget_destroy), fs);
3591 /* wait until destroy calls gtk_main_quit */
3592 gtk_widget_show (fs);
3598 create_modal_window (GtkWidget *widget)
3600 GtkWidget *window = NULL;
3601 GtkWidget *box1,*box2;
3603 GtkWidget *btnColor,*btnFile,*btnClose;
3605 /* Create modal window (Here you can use any window descendent )*/
3606 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
3607 gtk_window_set_screen (GTK_WINDOW (window),
3608 gtk_widget_get_screen (widget));
3610 gtk_window_set_title (GTK_WINDOW(window),"This window is modal");
3612 /* Set window as modal */
3613 gtk_window_set_modal (GTK_WINDOW(window),TRUE);
3615 /* Create widgets */
3616 box1 = gtk_vbox_new (FALSE,5);
3617 frame1 = gtk_frame_new ("Standard dialogs in modal form");
3618 box2 = gtk_vbox_new (TRUE,5);
3619 btnColor = gtk_button_new_with_label ("Color");
3620 btnFile = gtk_button_new_with_label ("File Selection");
3621 btnClose = gtk_button_new_with_label ("Close");
3624 gtk_container_set_border_width (GTK_CONTAINER (box1), 3);
3625 gtk_container_set_border_width (GTK_CONTAINER (box2), 3);
3628 gtk_container_add (GTK_CONTAINER (window), box1);
3629 gtk_box_pack_start (GTK_BOX (box1), frame1, TRUE, TRUE, 4);
3630 gtk_container_add (GTK_CONTAINER (frame1), box2);
3631 gtk_box_pack_start (GTK_BOX (box2), btnColor, FALSE, FALSE, 4);
3632 gtk_box_pack_start (GTK_BOX (box2), btnFile, FALSE, FALSE, 4);
3633 gtk_box_pack_start (GTK_BOX (box1), gtk_hseparator_new (), FALSE, FALSE, 4);
3634 gtk_box_pack_start (GTK_BOX (box1), btnClose, FALSE, FALSE, 4);
3636 /* connect signals */
3637 g_signal_connect_swapped (btnClose, "clicked",
3638 G_CALLBACK (gtk_widget_destroy), window);
3640 g_signal_connect (window, "destroy",
3641 G_CALLBACK (cmw_destroy_cb), NULL);
3643 g_signal_connect (btnColor, "clicked",
3644 G_CALLBACK (cmw_color), window);
3645 g_signal_connect (btnFile, "clicked",
3646 G_CALLBACK (cmw_file), window);
3649 gtk_widget_show_all (window);
3651 /* wait until dialog get destroyed */
3660 make_message_dialog (GdkScreen *screen,
3662 GtkMessageType type,
3663 GtkButtonsType buttons,
3664 guint default_response)
3668 gtk_widget_destroy (*dialog);
3673 *dialog = gtk_message_dialog_new (NULL, 0, type, buttons,
3674 "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.)");
3676 gtk_window_set_screen (GTK_WINDOW (*dialog), screen);
3678 g_signal_connect_swapped (*dialog,
3680 G_CALLBACK (gtk_widget_destroy),
3683 g_signal_connect (*dialog,
3685 G_CALLBACK (gtk_widget_destroyed),
3688 gtk_dialog_set_default_response (GTK_DIALOG (*dialog), default_response);
3690 gtk_widget_show (*dialog);
3694 create_message_dialog (GtkWidget *widget)
3696 static GtkWidget *info = NULL;
3697 static GtkWidget *warning = NULL;
3698 static GtkWidget *error = NULL;
3699 static GtkWidget *question = NULL;
3700 GdkScreen *screen = gtk_widget_get_screen (widget);
3702 make_message_dialog (screen, &info, GTK_MESSAGE_INFO, GTK_BUTTONS_OK, GTK_RESPONSE_OK);
3703 make_message_dialog (screen, &warning, GTK_MESSAGE_WARNING, GTK_BUTTONS_CLOSE, GTK_RESPONSE_CLOSE);
3704 make_message_dialog (screen, &error, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK_CANCEL, GTK_RESPONSE_OK);
3705 make_message_dialog (screen, &question, GTK_MESSAGE_QUESTION, GTK_BUTTONS_YES_NO, GTK_RESPONSE_NO);
3712 static GtkWidget *sw_parent = NULL;
3713 static GtkWidget *sw_float_parent;
3714 static guint sw_destroyed_handler = 0;
3717 scrolled_windows_delete_cb (GtkWidget *widget, GdkEventAny *event, GtkWidget *scrollwin)
3719 gtk_widget_reparent (scrollwin, sw_parent);
3721 g_signal_handler_disconnect (sw_parent, sw_destroyed_handler);
3722 sw_float_parent = NULL;
3724 sw_destroyed_handler = 0;
3730 scrolled_windows_destroy_cb (GtkWidget *widget, GtkWidget *scrollwin)
3732 gtk_widget_destroy (sw_float_parent);
3734 sw_float_parent = NULL;
3736 sw_destroyed_handler = 0;
3740 scrolled_windows_remove (GtkWidget *widget, GtkWidget *scrollwin)
3744 gtk_widget_reparent (scrollwin, sw_parent);
3745 gtk_widget_destroy (sw_float_parent);
3747 g_signal_handler_disconnect (sw_parent, sw_destroyed_handler);
3748 sw_float_parent = NULL;
3750 sw_destroyed_handler = 0;
3754 sw_parent = gtk_widget_get_parent (scrollwin);
3755 sw_float_parent = gtk_window_new (GTK_WINDOW_TOPLEVEL);
3756 gtk_window_set_screen (GTK_WINDOW (sw_float_parent),
3757 gtk_widget_get_screen (widget));
3759 gtk_window_set_default_size (GTK_WINDOW (sw_float_parent), 200, 200);
3761 gtk_widget_reparent (scrollwin, sw_float_parent);
3762 gtk_widget_show (sw_float_parent);
3764 sw_destroyed_handler =
3765 g_signal_connect (sw_parent, "destroy",
3766 G_CALLBACK (scrolled_windows_destroy_cb), scrollwin);
3767 g_signal_connect (sw_float_parent, "delete_event",
3768 G_CALLBACK (scrolled_windows_delete_cb), scrollwin);
3773 create_scrolled_windows (GtkWidget *widget)
3775 static GtkWidget *window;
3776 GtkWidget *content_area, *action_area;
3777 GtkWidget *scrolled_window;
3785 window = gtk_dialog_new ();
3787 gtk_window_set_screen (GTK_WINDOW (window),
3788 gtk_widget_get_screen (widget));
3790 g_signal_connect (window, "destroy",
3791 G_CALLBACK (gtk_widget_destroyed),
3794 content_area = gtk_dialog_get_content_area (GTK_DIALOG (window));
3795 action_area = gtk_dialog_get_action_area (GTK_DIALOG (window));
3797 gtk_window_set_title (GTK_WINDOW (window), "dialog");
3798 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
3800 scrolled_window = gtk_scrolled_window_new (NULL, NULL);
3801 gtk_container_set_border_width (GTK_CONTAINER (scrolled_window), 10);
3802 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
3803 GTK_POLICY_AUTOMATIC,
3804 GTK_POLICY_AUTOMATIC);
3805 gtk_box_pack_start (GTK_BOX (content_area), scrolled_window, TRUE, TRUE, 0);
3806 gtk_widget_show (scrolled_window);
3808 table = gtk_table_new (20, 20, FALSE);
3809 gtk_table_set_row_spacings (GTK_TABLE (table), 10);
3810 gtk_table_set_col_spacings (GTK_TABLE (table), 10);
3811 gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (scrolled_window), table);
3812 gtk_container_set_focus_hadjustment (GTK_CONTAINER (table),
3813 gtk_scrolled_window_get_hadjustment (GTK_SCROLLED_WINDOW (scrolled_window)));
3814 gtk_container_set_focus_vadjustment (GTK_CONTAINER (table),
3815 gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (scrolled_window)));
3816 gtk_widget_show (table);
3818 for (i = 0; i < 20; i++)
3819 for (j = 0; j < 20; j++)
3821 sprintf (buffer, "button (%d,%d)\n", i, j);
3822 button = gtk_toggle_button_new_with_label (buffer);
3823 gtk_table_attach_defaults (GTK_TABLE (table), button,
3825 gtk_widget_show (button);
3829 button = gtk_button_new_with_label ("Close");
3830 g_signal_connect_swapped (button, "clicked",
3831 G_CALLBACK (gtk_widget_destroy),
3833 gtk_widget_set_can_default (button, TRUE);
3834 gtk_box_pack_start (GTK_BOX (action_area), button, TRUE, TRUE, 0);
3835 gtk_widget_grab_default (button);
3836 gtk_widget_show (button);
3838 button = gtk_button_new_with_label ("Reparent Out");
3839 g_signal_connect (button, "clicked",
3840 G_CALLBACK (scrolled_windows_remove),
3842 gtk_widget_set_can_default (button, TRUE);
3843 gtk_box_pack_start (GTK_BOX (action_area), button, TRUE, TRUE, 0);
3844 gtk_widget_grab_default (button);
3845 gtk_widget_show (button);
3847 gtk_window_set_default_size (GTK_WINDOW (window), 300, 300);
3850 if (!gtk_widget_get_visible (window))
3851 gtk_widget_show (window);
3853 gtk_widget_destroy (window);
3861 entry_toggle_frame (GtkWidget *checkbutton,
3864 gtk_entry_set_has_frame (GTK_ENTRY(entry),
3865 GTK_TOGGLE_BUTTON(checkbutton)->active);
3869 entry_toggle_sensitive (GtkWidget *checkbutton,
3872 gtk_widget_set_sensitive (entry, GTK_TOGGLE_BUTTON(checkbutton)->active);
3876 entry_progress_timeout (gpointer data)
3878 if (GPOINTER_TO_INT (g_object_get_data (G_OBJECT (data), "progress-pulse")))
3880 gtk_entry_progress_pulse (GTK_ENTRY (data));
3886 fraction = gtk_entry_get_progress_fraction (GTK_ENTRY (data));
3889 if (fraction > 1.0001)
3892 gtk_entry_set_progress_fraction (GTK_ENTRY (data), fraction);
3899 entry_remove_timeout (gpointer data)
3901 g_source_remove (GPOINTER_TO_UINT (data));
3905 entry_toggle_progress (GtkWidget *checkbutton,
3908 if (GTK_TOGGLE_BUTTON (checkbutton)->active)
3910 guint timeout = gdk_threads_add_timeout (100,
3911 entry_progress_timeout,
3913 g_object_set_data_full (G_OBJECT (entry), "timeout-id",
3914 GUINT_TO_POINTER (timeout),
3915 entry_remove_timeout);
3919 g_object_set_data (G_OBJECT (entry), "timeout-id",
3920 GUINT_TO_POINTER (0));
3922 gtk_entry_set_progress_fraction (GTK_ENTRY (entry), 0.0);
3927 entry_toggle_pulse (GtkWidget *checkbutton,
3930 g_object_set_data (G_OBJECT (entry), "progress-pulse",
3931 GUINT_TO_POINTER ((guint) GTK_TOGGLE_BUTTON (checkbutton)->active));
3935 props_clicked (GtkWidget *button,
3938 GtkWidget *window = create_prop_editor (object, 0);
3940 gtk_window_set_title (GTK_WINDOW (window), "Object Properties");
3944 create_entry (GtkWidget *widget)
3946 static GtkWidget *window = NULL;
3950 GtkWidget *has_frame_check;
3951 GtkWidget *sensitive_check;
3952 GtkWidget *progress_check;
3955 GtkWidget *cb_entry;
3957 GtkWidget *separator;
3961 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
3962 gtk_window_set_screen (GTK_WINDOW (window),
3963 gtk_widget_get_screen (widget));
3965 g_signal_connect (window, "destroy",
3966 G_CALLBACK (gtk_widget_destroyed),
3969 gtk_window_set_title (GTK_WINDOW (window), "entry");
3970 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
3973 box1 = gtk_vbox_new (FALSE, 0);
3974 gtk_container_add (GTK_CONTAINER (window), box1);
3977 box2 = gtk_vbox_new (FALSE, 10);
3978 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
3979 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
3981 hbox = gtk_hbox_new (FALSE, 5);
3982 gtk_box_pack_start (GTK_BOX (box2), hbox, TRUE, TRUE, 0);
3984 entry = gtk_entry_new ();
3985 gtk_entry_set_text (GTK_ENTRY (entry), "hello world \330\247\331\204\330\263\331\204\330\247\331\205 \330\271\331\204\331\212\331\203\331\205");
3986 gtk_editable_select_region (GTK_EDITABLE (entry), 0, 5);
3987 gtk_box_pack_start (GTK_BOX (hbox), entry, TRUE, TRUE, 0);
3989 button = gtk_button_new_with_mnemonic ("_Props");
3990 gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0);
3991 g_signal_connect (button, "clicked",
3992 G_CALLBACK (props_clicked),
3995 cb = GTK_COMBO_BOX (gtk_combo_box_entry_new_text ());
3996 gtk_combo_box_append_text (cb, "item0");
3997 gtk_combo_box_append_text (cb, "item0");
3998 gtk_combo_box_append_text (cb, "item1 item1");
3999 gtk_combo_box_append_text (cb, "item2 item2 item2");
4000 gtk_combo_box_append_text (cb, "item3 item3 item3 item3");
4001 gtk_combo_box_append_text (cb, "item4 item4 item4 item4 item4");
4002 gtk_combo_box_append_text (cb, "item5 item5 item5 item5 item5 item5");
4003 gtk_combo_box_append_text (cb, "item6 item6 item6 item6 item6");
4004 gtk_combo_box_append_text (cb, "item7 item7 item7 item7");
4005 gtk_combo_box_append_text (cb, "item8 item8 item8");
4006 gtk_combo_box_append_text (cb, "item9 item9");
4008 cb_entry = gtk_bin_get_child (GTK_BIN (cb));
4009 gtk_entry_set_text (GTK_ENTRY (cb_entry), "hello world \n\n\n foo");
4010 gtk_editable_select_region (GTK_EDITABLE (cb_entry), 0, -1);
4011 gtk_box_pack_start (GTK_BOX (box2), GTK_WIDGET (cb), TRUE, TRUE, 0);
4013 sensitive_check = gtk_check_button_new_with_label("Sensitive");
4014 gtk_box_pack_start (GTK_BOX (box2), sensitive_check, FALSE, TRUE, 0);
4015 g_signal_connect (sensitive_check, "toggled",
4016 G_CALLBACK (entry_toggle_sensitive), entry);
4017 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (sensitive_check), TRUE);
4019 has_frame_check = gtk_check_button_new_with_label("Has Frame");
4020 gtk_box_pack_start (GTK_BOX (box2), has_frame_check, FALSE, TRUE, 0);
4021 g_signal_connect (has_frame_check, "toggled",
4022 G_CALLBACK (entry_toggle_frame), entry);
4023 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (has_frame_check), TRUE);
4025 progress_check = gtk_check_button_new_with_label("Show Progress");
4026 gtk_box_pack_start (GTK_BOX (box2), progress_check, FALSE, TRUE, 0);
4027 g_signal_connect (progress_check, "toggled",
4028 G_CALLBACK (entry_toggle_progress), entry);
4030 progress_check = gtk_check_button_new_with_label("Pulse Progress");
4031 gtk_box_pack_start (GTK_BOX (box2), progress_check, FALSE, TRUE, 0);
4032 g_signal_connect (progress_check, "toggled",
4033 G_CALLBACK (entry_toggle_pulse), entry);
4035 separator = gtk_hseparator_new ();
4036 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
4038 box2 = gtk_vbox_new (FALSE, 10);
4039 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
4040 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
4042 button = gtk_button_new_with_label ("close");
4043 g_signal_connect_swapped (button, "clicked",
4044 G_CALLBACK (gtk_widget_destroy),
4046 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
4047 gtk_widget_set_can_default (button, TRUE);
4048 gtk_widget_grab_default (button);
4051 if (!gtk_widget_get_visible (window))
4052 gtk_widget_show_all (window);
4054 gtk_widget_destroy (window);
4058 create_expander (GtkWidget *widget)
4061 GtkWidget *expander;
4063 static GtkWidget *window = NULL;
4067 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
4068 gtk_window_set_screen (GTK_WINDOW (window),
4069 gtk_widget_get_screen (widget));
4071 g_signal_connect (window, "destroy",
4072 G_CALLBACK (gtk_widget_destroyed),
4075 gtk_window_set_title (GTK_WINDOW (window), "expander");
4076 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
4078 box1 = gtk_vbox_new (FALSE, 0);
4079 gtk_container_add (GTK_CONTAINER (window), box1);
4081 expander = gtk_expander_new ("The Hidden");
4083 gtk_box_pack_start (GTK_BOX (box1), expander, TRUE, TRUE, 0);
4085 hidden = gtk_label_new ("Revealed!");
4087 gtk_container_add (GTK_CONTAINER (expander), hidden);
4090 if (!gtk_widget_get_visible (window))
4091 gtk_widget_show_all (window);
4093 gtk_widget_destroy (window);
4101 event_box_label_pressed (GtkWidget *widget,
4102 GdkEventButton *event,
4105 g_print ("clicked on event box\n");
4109 event_box_button_clicked (GtkWidget *widget,
4113 g_print ("pushed button\n");
4117 event_box_toggle_visible_window (GtkWidget *checkbutton,
4118 GtkEventBox *event_box)
4120 gtk_event_box_set_visible_window (event_box,
4121 GTK_TOGGLE_BUTTON(checkbutton)->active);
4125 event_box_toggle_above_child (GtkWidget *checkbutton,
4126 GtkEventBox *event_box)
4128 gtk_event_box_set_above_child (event_box,
4129 GTK_TOGGLE_BUTTON(checkbutton)->active);
4133 create_event_box (GtkWidget *widget)
4135 static GtkWidget *window = NULL;
4141 GtkWidget *separator;
4142 GtkWidget *event_box;
4144 GtkWidget *visible_window_check;
4145 GtkWidget *above_child_check;
4154 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
4155 gtk_window_set_screen (GTK_WINDOW (window),
4156 gtk_widget_get_screen (widget));
4158 g_signal_connect (window, "destroy",
4159 G_CALLBACK (gtk_widget_destroyed),
4162 gtk_window_set_title (GTK_WINDOW (window), "event box");
4163 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
4165 box1 = gtk_vbox_new (FALSE, 0);
4166 gtk_container_add (GTK_CONTAINER (window), box1);
4167 gtk_widget_modify_bg (window, GTK_STATE_NORMAL, &color);
4169 hbox = gtk_hbox_new (FALSE, 0);
4170 gtk_box_pack_start (GTK_BOX (box1), hbox, TRUE, FALSE, 0);
4172 event_box = gtk_event_box_new ();
4173 gtk_box_pack_start (GTK_BOX (hbox), event_box, TRUE, FALSE, 0);
4175 vbox = gtk_vbox_new (FALSE, 0);
4176 gtk_container_add (GTK_CONTAINER (event_box), vbox);
4177 g_signal_connect (event_box, "button_press_event",
4178 G_CALLBACK (event_box_label_pressed),
4181 label = gtk_label_new ("Click on this label");
4182 gtk_box_pack_start (GTK_BOX (vbox), label, TRUE, FALSE, 0);
4184 button = gtk_button_new_with_label ("button in eventbox");
4185 gtk_box_pack_start (GTK_BOX (vbox), button, TRUE, FALSE, 0);
4186 g_signal_connect (button, "clicked",
4187 G_CALLBACK (event_box_button_clicked),
4191 visible_window_check = gtk_check_button_new_with_label("Visible Window");
4192 gtk_box_pack_start (GTK_BOX (box1), visible_window_check, FALSE, TRUE, 0);
4193 g_signal_connect (visible_window_check, "toggled",
4194 G_CALLBACK (event_box_toggle_visible_window), event_box);
4195 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (visible_window_check), FALSE);
4197 above_child_check = gtk_check_button_new_with_label("Above Child");
4198 gtk_box_pack_start (GTK_BOX (box1), above_child_check, FALSE, TRUE, 0);
4199 g_signal_connect (above_child_check, "toggled",
4200 G_CALLBACK (event_box_toggle_above_child), event_box);
4201 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (above_child_check), FALSE);
4203 separator = gtk_hseparator_new ();
4204 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
4206 box2 = gtk_vbox_new (FALSE, 10);
4207 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
4208 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
4210 button = gtk_button_new_with_label ("close");
4211 g_signal_connect_swapped (button, "clicked",
4212 G_CALLBACK (gtk_widget_destroy),
4214 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
4215 gtk_widget_set_can_default (button, TRUE);
4216 gtk_widget_grab_default (button);
4219 if (!gtk_widget_get_visible (window))
4220 gtk_widget_show_all (window);
4222 gtk_widget_destroy (window);
4230 #define SIZE_GROUP_INITIAL_SIZE 50
4233 size_group_hsize_changed (GtkSpinButton *spin_button,
4236 gtk_widget_set_size_request (gtk_bin_get_child (GTK_BIN (button)),
4237 gtk_spin_button_get_value_as_int (spin_button),
4242 size_group_vsize_changed (GtkSpinButton *spin_button,
4245 gtk_widget_set_size_request (gtk_bin_get_child (GTK_BIN (button)),
4247 gtk_spin_button_get_value_as_int (spin_button));
4251 create_size_group_window (GdkScreen *screen,
4252 GtkSizeGroup *master_size_group)
4254 GtkWidget *content_area;
4257 GtkWidget *main_button;
4259 GtkWidget *spin_button;
4261 GtkSizeGroup *hgroup1;
4262 GtkSizeGroup *hgroup2;
4263 GtkSizeGroup *vgroup1;
4264 GtkSizeGroup *vgroup2;
4266 window = gtk_dialog_new_with_buttons ("GtkSizeGroup",
4272 gtk_window_set_screen (GTK_WINDOW (window), screen);
4274 gtk_window_set_resizable (GTK_WINDOW (window), TRUE);
4276 g_signal_connect (window, "response",
4277 G_CALLBACK (gtk_widget_destroy),
4280 content_area = gtk_dialog_get_content_area (GTK_DIALOG (window));
4282 table = gtk_table_new (2, 2, FALSE);
4283 gtk_box_pack_start (GTK_BOX (content_area), table, TRUE, TRUE, 0);
4285 gtk_table_set_row_spacings (GTK_TABLE (table), 5);
4286 gtk_table_set_col_spacings (GTK_TABLE (table), 5);
4287 gtk_container_set_border_width (GTK_CONTAINER (table), 5);
4288 gtk_widget_set_size_request (table, 250, 250);
4290 hgroup1 = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
4291 hgroup2 = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
4292 vgroup1 = gtk_size_group_new (GTK_SIZE_GROUP_VERTICAL);
4293 vgroup2 = gtk_size_group_new (GTK_SIZE_GROUP_VERTICAL);
4295 main_button = gtk_button_new_with_label ("X");
4297 gtk_table_attach (GTK_TABLE (table), main_button,
4299 GTK_EXPAND, GTK_EXPAND,
4301 gtk_size_group_add_widget (master_size_group, main_button);
4302 gtk_size_group_add_widget (hgroup1, main_button);
4303 gtk_size_group_add_widget (vgroup1, main_button);
4304 gtk_widget_set_size_request (gtk_bin_get_child (GTK_BIN (main_button)),
4305 SIZE_GROUP_INITIAL_SIZE,
4306 SIZE_GROUP_INITIAL_SIZE);
4308 button = gtk_button_new ();
4309 gtk_table_attach (GTK_TABLE (table), button,
4311 GTK_EXPAND, GTK_EXPAND,
4313 gtk_size_group_add_widget (vgroup1, button);
4314 gtk_size_group_add_widget (vgroup2, button);
4316 button = gtk_button_new ();
4317 gtk_table_attach (GTK_TABLE (table), button,
4319 GTK_EXPAND, GTK_EXPAND,
4321 gtk_size_group_add_widget (hgroup1, button);
4322 gtk_size_group_add_widget (hgroup2, button);
4324 button = gtk_button_new ();
4325 gtk_table_attach (GTK_TABLE (table), button,
4327 GTK_EXPAND, GTK_EXPAND,
4329 gtk_size_group_add_widget (hgroup2, button);
4330 gtk_size_group_add_widget (vgroup2, button);
4332 g_object_unref (hgroup1);
4333 g_object_unref (hgroup2);
4334 g_object_unref (vgroup1);
4335 g_object_unref (vgroup2);
4337 hbox = gtk_hbox_new (FALSE, 5);
4338 gtk_box_pack_start (GTK_BOX (content_area), hbox, FALSE, FALSE, 0);
4340 spin_button = gtk_spin_button_new_with_range (1, 100, 1);
4341 gtk_spin_button_set_value (GTK_SPIN_BUTTON (spin_button), SIZE_GROUP_INITIAL_SIZE);
4342 gtk_box_pack_start (GTK_BOX (hbox), spin_button, TRUE, TRUE, 0);
4343 g_signal_connect (spin_button, "value_changed",
4344 G_CALLBACK (size_group_hsize_changed), main_button);
4346 spin_button = gtk_spin_button_new_with_range (1, 100, 1);
4347 gtk_spin_button_set_value (GTK_SPIN_BUTTON (spin_button), SIZE_GROUP_INITIAL_SIZE);
4348 gtk_box_pack_start (GTK_BOX (hbox), spin_button, TRUE, TRUE, 0);
4349 g_signal_connect (spin_button, "value_changed",
4350 G_CALLBACK (size_group_vsize_changed), main_button);
4356 create_size_groups (GtkWidget *widget)
4358 static GtkWidget *window1 = NULL;
4359 static GtkWidget *window2 = NULL;
4360 static GtkSizeGroup *master_size_group;
4362 if (!master_size_group)
4363 master_size_group = gtk_size_group_new (GTK_SIZE_GROUP_BOTH);
4367 window1 = create_size_group_window (gtk_widget_get_screen (widget),
4370 g_signal_connect (window1, "destroy",
4371 G_CALLBACK (gtk_widget_destroyed),
4377 window2 = create_size_group_window (gtk_widget_get_screen (widget),
4380 g_signal_connect (window2, "destroy",
4381 G_CALLBACK (gtk_widget_destroyed),
4385 if (gtk_widget_get_visible (window1) && gtk_widget_get_visible (window2))
4387 gtk_widget_destroy (window1);
4388 gtk_widget_destroy (window2);
4392 if (!gtk_widget_get_visible (window1))
4393 gtk_widget_show_all (window1);
4394 if (!gtk_widget_get_visible (window2))
4395 gtk_widget_show_all (window2);
4403 static GtkWidget *spinner1;
4406 toggle_snap (GtkWidget *widget, GtkSpinButton *spin)
4408 gtk_spin_button_set_snap_to_ticks (spin, GTK_TOGGLE_BUTTON (widget)->active);
4412 toggle_numeric (GtkWidget *widget, GtkSpinButton *spin)
4414 gtk_spin_button_set_numeric (spin, GTK_TOGGLE_BUTTON (widget)->active);
4418 change_digits (GtkWidget *widget, GtkSpinButton *spin)
4420 gtk_spin_button_set_digits (GTK_SPIN_BUTTON (spinner1),
4421 gtk_spin_button_get_value_as_int (spin));
4425 get_value (GtkWidget *widget, gpointer data)
4429 GtkSpinButton *spin;
4431 spin = GTK_SPIN_BUTTON (spinner1);
4432 label = GTK_LABEL (g_object_get_data (G_OBJECT (widget), "user_data"));
4433 if (GPOINTER_TO_INT (data) == 1)
4434 sprintf (buf, "%d", gtk_spin_button_get_value_as_int (spin));
4436 sprintf (buf, "%0.*f",
4437 gtk_spin_button_get_digits (spin),
4438 gtk_spin_button_get_value (spin));
4440 gtk_label_set_text (label, buf);
4444 get_spin_value (GtkWidget *widget, gpointer data)
4448 GtkSpinButton *spin;
4450 spin = GTK_SPIN_BUTTON (widget);
4451 label = GTK_LABEL (data);
4453 buffer = g_strdup_printf ("%0.*f",
4454 gtk_spin_button_get_digits (spin),
4455 gtk_spin_button_get_value (spin));
4456 gtk_label_set_text (label, buffer);
4462 spin_button_time_output_func (GtkSpinButton *spin_button)
4464 GtkAdjustment *adjustment;
4465 static gchar buf[6];
4469 adjustment = gtk_spin_button_get_adjustment (spin_button);
4470 hours = gtk_adjustment_get_value (adjustment) / 60.0;
4471 minutes = (fabs(floor (hours) - hours) < 1e-5) ? 0.0 : 30;
4472 sprintf (buf, "%02.0f:%02.0f", floor (hours), minutes);
4473 if (strcmp (buf, gtk_entry_get_text (GTK_ENTRY (spin_button))))
4474 gtk_entry_set_text (GTK_ENTRY (spin_button), buf);
4479 spin_button_month_input_func (GtkSpinButton *spin_button,
4483 static gchar *month[12] = { "January", "February", "March", "April",
4484 "May", "June", "July", "August",
4485 "September", "October", "November", "December" };
4487 gboolean found = FALSE;
4489 for (i = 1; i <= 12; i++)
4491 tmp1 = g_ascii_strup (month[i - 1], -1);
4492 tmp2 = g_ascii_strup (gtk_entry_get_text (GTK_ENTRY (spin_button)), -1);
4493 if (strstr (tmp1, tmp2) == tmp1)
4503 return GTK_INPUT_ERROR;
4505 *new_val = (gdouble) i;
4510 spin_button_month_output_func (GtkSpinButton *spin_button)
4512 GtkAdjustment *adjustment;
4515 static gchar *month[12] = { "January", "February", "March", "April",
4516 "May", "June", "July", "August", "September",
4517 "October", "November", "December" };
4519 adjustment = gtk_spin_button_get_adjustment (spin_button);
4520 value = gtk_adjustment_get_value (adjustment);
4521 for (i = 1; i <= 12; i++)
4522 if (fabs (value - (double)i) < 1e-5)
4524 if (strcmp (month[i-1], gtk_entry_get_text (GTK_ENTRY (spin_button))))
4525 gtk_entry_set_text (GTK_ENTRY (spin_button), month[i-1]);
4531 spin_button_hex_input_func (GtkSpinButton *spin_button,
4538 buf = gtk_entry_get_text (GTK_ENTRY (spin_button));
4539 res = strtol(buf, &err, 16);
4542 return GTK_INPUT_ERROR;
4548 spin_button_hex_output_func (GtkSpinButton *spin_button)
4550 GtkAdjustment *adjustment;
4551 static gchar buf[7];
4554 adjustment = gtk_spin_button_get_adjustment (spin_button);
4555 val = (gint) gtk_adjustment_get_value (adjustment);
4556 if (fabs (val) < 1e-5)
4557 sprintf (buf, "0x00");
4559 sprintf (buf, "0x%.2X", val);
4560 if (strcmp (buf, gtk_entry_get_text (GTK_ENTRY (spin_button))))
4561 gtk_entry_set_text (GTK_ENTRY (spin_button), buf);
4566 create_spins (GtkWidget *widget)
4568 static GtkWidget *window = NULL;
4571 GtkWidget *main_vbox;
4574 GtkWidget *spinner2;
4578 GtkWidget *val_label;
4583 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
4584 gtk_window_set_screen (GTK_WINDOW (window),
4585 gtk_widget_get_screen (widget));
4587 g_signal_connect (window, "destroy",
4588 G_CALLBACK (gtk_widget_destroyed),
4591 gtk_window_set_title (GTK_WINDOW (window), "GtkSpinButton");
4593 main_vbox = gtk_vbox_new (FALSE, 5);
4594 gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 10);
4595 gtk_container_add (GTK_CONTAINER (window), main_vbox);
4597 frame = gtk_frame_new ("Not accelerated");
4598 gtk_box_pack_start (GTK_BOX (main_vbox), frame, TRUE, TRUE, 0);
4600 vbox = gtk_vbox_new (FALSE, 0);
4601 gtk_container_set_border_width (GTK_CONTAINER (vbox), 5);
4602 gtk_container_add (GTK_CONTAINER (frame), vbox);
4604 /* Time, month, hex spinners */
4606 hbox = gtk_hbox_new (FALSE, 0);
4607 gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 5);
4609 vbox2 = gtk_vbox_new (FALSE, 0);
4610 gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 5);
4612 label = gtk_label_new ("Time :");
4613 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
4614 gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, TRUE, 0);
4616 adj = gtk_adjustment_new (0, 0, 1410, 30, 60, 0);
4617 spinner = gtk_spin_button_new (adj, 0, 0);
4618 gtk_editable_set_editable (GTK_EDITABLE (spinner), FALSE);
4619 g_signal_connect (spinner,
4621 G_CALLBACK (spin_button_time_output_func),
4623 gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spinner), TRUE);
4624 gtk_entry_set_width_chars (GTK_ENTRY (spinner), 5);
4625 gtk_box_pack_start (GTK_BOX (vbox2), spinner, FALSE, TRUE, 0);
4627 vbox2 = gtk_vbox_new (FALSE, 0);
4628 gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 5);
4630 label = gtk_label_new ("Month :");
4631 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
4632 gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, TRUE, 0);
4634 adj = gtk_adjustment_new (1.0, 1.0, 12.0, 1.0,
4636 spinner = gtk_spin_button_new (adj, 0, 0);
4637 gtk_spin_button_set_update_policy (GTK_SPIN_BUTTON (spinner),
4638 GTK_UPDATE_IF_VALID);
4639 g_signal_connect (spinner,
4641 G_CALLBACK (spin_button_month_input_func),
4643 g_signal_connect (spinner,
4645 G_CALLBACK (spin_button_month_output_func),
4647 gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spinner), TRUE);
4648 gtk_entry_set_width_chars (GTK_ENTRY (spinner), 9);
4649 gtk_box_pack_start (GTK_BOX (vbox2), spinner, FALSE, TRUE, 0);
4651 vbox2 = gtk_vbox_new (FALSE, 0);
4652 gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 5);
4654 label = gtk_label_new ("Hex :");
4655 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
4656 gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, TRUE, 0);
4658 adj = gtk_adjustment_new (0, 0, 255, 1, 16, 0);
4659 spinner = gtk_spin_button_new (adj, 0, 0);
4660 gtk_editable_set_editable (GTK_EDITABLE (spinner), TRUE);
4661 g_signal_connect (spinner,
4663 G_CALLBACK (spin_button_hex_input_func),
4665 g_signal_connect (spinner,
4667 G_CALLBACK (spin_button_hex_output_func),
4669 gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spinner), TRUE);
4670 gtk_entry_set_width_chars (GTK_ENTRY (spinner), 4);
4671 gtk_box_pack_start (GTK_BOX (vbox2), spinner, FALSE, TRUE, 0);
4673 frame = gtk_frame_new ("Accelerated");
4674 gtk_box_pack_start (GTK_BOX (main_vbox), frame, TRUE, TRUE, 0);
4676 vbox = gtk_vbox_new (FALSE, 0);
4677 gtk_container_set_border_width (GTK_CONTAINER (vbox), 5);
4678 gtk_container_add (GTK_CONTAINER (frame), vbox);
4680 hbox = gtk_hbox_new (FALSE, 0);
4681 gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 5);
4683 vbox2 = gtk_vbox_new (FALSE, 0);
4684 gtk_box_pack_start (GTK_BOX (hbox), vbox2, FALSE, FALSE, 5);
4686 label = gtk_label_new ("Value :");
4687 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
4688 gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, TRUE, 0);
4690 adj = gtk_adjustment_new (0.0, -10000.0, 10000.0,
4692 spinner1 = gtk_spin_button_new (adj, 1.0, 2);
4693 gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spinner1), TRUE);
4694 gtk_box_pack_start (GTK_BOX (vbox2), spinner1, FALSE, TRUE, 0);
4696 vbox2 = gtk_vbox_new (FALSE, 0);
4697 gtk_box_pack_start (GTK_BOX (hbox), vbox2, FALSE, FALSE, 5);
4699 label = gtk_label_new ("Digits :");
4700 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
4701 gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, TRUE, 0);
4703 adj = gtk_adjustment_new (2, 1, 15, 1, 1, 0);
4704 spinner2 = gtk_spin_button_new (adj, 0.0, 0);
4705 g_signal_connect (adj, "value_changed",
4706 G_CALLBACK (change_digits),
4708 gtk_box_pack_start (GTK_BOX (vbox2), spinner2, FALSE, TRUE, 0);
4710 hbox = gtk_hbox_new (FALSE, 0);
4711 gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 5);
4713 button = gtk_check_button_new_with_label ("Snap to 0.5-ticks");
4714 g_signal_connect (button, "clicked",
4715 G_CALLBACK (toggle_snap),
4717 gtk_box_pack_start (GTK_BOX (vbox), button, TRUE, TRUE, 0);
4718 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
4720 button = gtk_check_button_new_with_label ("Numeric only input mode");
4721 g_signal_connect (button, "clicked",
4722 G_CALLBACK (toggle_numeric),
4724 gtk_box_pack_start (GTK_BOX (vbox), button, TRUE, TRUE, 0);
4725 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
4727 val_label = gtk_label_new ("");
4729 hbox = gtk_hbox_new (FALSE, 0);
4730 gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 5);
4732 button = gtk_button_new_with_label ("Value as Int");
4733 g_object_set_data (G_OBJECT (button), "user_data", val_label);
4734 g_signal_connect (button, "clicked",
4735 G_CALLBACK (get_value),
4736 GINT_TO_POINTER (1));
4737 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
4739 button = gtk_button_new_with_label ("Value as Float");
4740 g_object_set_data (G_OBJECT (button), "user_data", val_label);
4741 g_signal_connect (button, "clicked",
4742 G_CALLBACK (get_value),
4743 GINT_TO_POINTER (2));
4744 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
4746 gtk_box_pack_start (GTK_BOX (vbox), val_label, TRUE, TRUE, 0);
4747 gtk_label_set_text (GTK_LABEL (val_label), "0");
4749 frame = gtk_frame_new ("Using Convenience Constructor");
4750 gtk_box_pack_start (GTK_BOX (main_vbox), frame, TRUE, TRUE, 0);
4752 hbox = gtk_hbox_new (FALSE, 0);
4753 gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
4754 gtk_container_add (GTK_CONTAINER (frame), hbox);
4756 val_label = gtk_label_new ("0.0");
4758 spinner = gtk_spin_button_new_with_range (0.0, 10.0, 0.009);
4759 gtk_spin_button_set_value (GTK_SPIN_BUTTON (spinner), 0.0);
4760 g_signal_connect (spinner, "value_changed",
4761 G_CALLBACK (get_spin_value), val_label);
4762 gtk_box_pack_start (GTK_BOX (hbox), spinner, TRUE, TRUE, 5);
4763 gtk_box_pack_start (GTK_BOX (hbox), val_label, TRUE, TRUE, 5);
4765 hbox = gtk_hbox_new (FALSE, 0);
4766 gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, TRUE, 0);
4768 button = gtk_button_new_with_label ("Close");
4769 g_signal_connect_swapped (button, "clicked",
4770 G_CALLBACK (gtk_widget_destroy),
4772 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
4775 if (!gtk_widget_get_visible (window))
4776 gtk_widget_show_all (window);
4778 gtk_widget_destroy (window);
4787 cursor_draw (GtkWidget *widget,
4793 width = gtk_widget_get_allocated_width (widget);
4794 height = gtk_widget_get_allocated_height (widget);
4796 cairo_set_source_rgb (cr, 1, 1, 1);
4797 cairo_rectangle (cr, 0, 0, width, height / 2);
4800 cairo_set_source_rgb (cr, 0, 0, 0);
4801 cairo_rectangle (cr, 0, height / 2, width, height / 2);
4804 gdk_cairo_set_source_color (cr, >k_widget_get_style (widget)->bg[GTK_STATE_NORMAL]);
4805 cairo_rectangle (cr, width / 3, height / 3, width / 3, height / 3);
4812 set_cursor (GtkWidget *spinner,
4821 c = CLAMP (gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (spinner)), 0, 152);
4824 label = g_object_get_data (G_OBJECT (spinner), "user_data");
4826 class = g_type_class_ref (GDK_TYPE_CURSOR_TYPE);
4827 vals = class->values;
4829 while (vals && vals->value != c)
4832 gtk_label_set_text (GTK_LABEL (label), vals->value_nick);
4834 gtk_label_set_text (GTK_LABEL (label), "<unknown>");
4836 g_type_class_unref (class);
4838 cursor = gdk_cursor_new_for_display (gtk_widget_get_display (widget), c);
4839 gdk_window_set_cursor (gtk_widget_get_window (widget),
4841 gdk_cursor_unref (cursor);
4845 cursor_event (GtkWidget *widget,
4847 GtkSpinButton *spinner)
4849 if ((event->type == GDK_BUTTON_PRESS) &&
4850 ((event->button.button == 1) ||
4851 (event->button.button == 3)))
4853 gtk_spin_button_spin (spinner, event->button.button == 1 ?
4854 GTK_SPIN_STEP_FORWARD : GTK_SPIN_STEP_BACKWARD, 0);
4861 #ifdef GDK_WINDOWING_X11
4862 #include "x11/gdkx.h"
4865 change_cursor_theme (GtkWidget *widget,
4872 children = gtk_container_get_children (GTK_CONTAINER (data));
4874 theme = gtk_entry_get_text (GTK_ENTRY (children->next->data));
4875 size = (gint) gtk_spin_button_get_value (GTK_SPIN_BUTTON (children->next->next->data));
4877 g_list_free (children);
4879 gdk_x11_display_set_cursor_theme (gtk_widget_get_display (widget),
4886 create_cursors (GtkWidget *widget)
4888 static GtkWidget *window = NULL;
4891 GtkWidget *main_vbox;
4904 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
4905 gtk_window_set_screen (GTK_WINDOW (window),
4906 gtk_widget_get_screen (widget));
4908 g_signal_connect (window, "destroy",
4909 G_CALLBACK (gtk_widget_destroyed),
4912 gtk_window_set_title (GTK_WINDOW (window), "Cursors");
4914 main_vbox = gtk_vbox_new (FALSE, 5);
4915 gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 0);
4916 gtk_container_add (GTK_CONTAINER (window), main_vbox);
4919 g_object_new (gtk_vbox_get_type (),
4920 "GtkBox::homogeneous", FALSE,
4921 "GtkBox::spacing", 5,
4922 "GtkContainer::border_width", 10,
4923 "GtkWidget::parent", main_vbox,
4924 "GtkWidget::visible", TRUE,
4927 #ifdef GDK_WINDOWING_X11
4928 hbox = gtk_hbox_new (FALSE, 0);
4929 gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
4930 gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0);
4932 label = gtk_label_new ("Cursor Theme : ");
4933 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
4934 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
4936 entry = gtk_entry_new ();
4937 gtk_entry_set_text (GTK_ENTRY (entry), "default");
4938 gtk_box_pack_start (GTK_BOX (hbox), entry, FALSE, TRUE, 0);
4940 size = gtk_spin_button_new_with_range (1.0, 64.0, 1.0);
4941 gtk_spin_button_set_value (GTK_SPIN_BUTTON (size), 24.0);
4942 gtk_box_pack_start (GTK_BOX (hbox), size, TRUE, TRUE, 0);
4944 g_signal_connect (entry, "changed",
4945 G_CALLBACK (change_cursor_theme), hbox);
4946 g_signal_connect (size, "changed",
4947 G_CALLBACK (change_cursor_theme), hbox);
4950 hbox = gtk_hbox_new (FALSE, 0);
4951 gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
4952 gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0);
4954 label = gtk_label_new ("Cursor Value : ");
4955 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
4956 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
4958 adj = gtk_adjustment_new (0,
4962 spinner = gtk_spin_button_new (adj, 0, 0);
4963 gtk_box_pack_start (GTK_BOX (hbox), spinner, TRUE, TRUE, 0);
4966 g_object_new (gtk_frame_get_type (),
4967 "GtkFrame::label_xalign", 0.5,
4968 "GtkFrame::label", "Cursor Area",
4969 "GtkContainer::border_width", 10,
4970 "GtkWidget::parent", vbox,
4971 "GtkWidget::visible", TRUE,
4974 darea = gtk_drawing_area_new ();
4975 gtk_widget_set_size_request (darea, 80, 80);
4976 gtk_container_add (GTK_CONTAINER (frame), darea);
4977 g_signal_connect (darea,
4979 G_CALLBACK (cursor_draw),
4981 gtk_widget_set_events (darea, GDK_EXPOSURE_MASK | GDK_BUTTON_PRESS_MASK);
4982 g_signal_connect (darea,
4983 "button_press_event",
4984 G_CALLBACK (cursor_event),
4986 gtk_widget_show (darea);
4988 g_signal_connect (spinner, "changed",
4989 G_CALLBACK (set_cursor),
4992 label = g_object_new (GTK_TYPE_LABEL,
4997 gtk_container_child_set (GTK_CONTAINER (vbox), label,
5000 g_object_set_data (G_OBJECT (spinner), "user_data", label);
5003 g_object_new (gtk_hseparator_get_type (),
5004 "GtkWidget::visible", TRUE,
5006 gtk_box_pack_start (GTK_BOX (main_vbox), any, FALSE, TRUE, 0);
5008 hbox = gtk_hbox_new (FALSE, 0);
5009 gtk_container_set_border_width (GTK_CONTAINER (hbox), 10);
5010 gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, TRUE, 0);
5012 button = gtk_button_new_with_label ("Close");
5013 g_signal_connect_swapped (button, "clicked",
5014 G_CALLBACK (gtk_widget_destroy),
5016 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
5018 gtk_widget_show_all (window);
5020 set_cursor (spinner, darea);
5023 gtk_widget_destroy (window);
5031 color_selection_ok (GtkWidget *w,
5032 GtkColorSelectionDialog *cs)
5034 GtkWidget *colorsel;
5037 colorsel = gtk_color_selection_dialog_get_color_selection (cs);
5039 gtk_color_selection_get_current_color (GTK_COLOR_SELECTION (colorsel), &color);
5040 gtk_color_selection_set_current_color (GTK_COLOR_SELECTION (colorsel), &color);
5044 color_selection_changed (GtkWidget *w,
5045 GtkColorSelectionDialog *cs)
5047 GtkWidget *colorsel;
5050 colorsel = gtk_color_selection_dialog_get_color_selection (cs);
5051 gtk_color_selection_get_current_color (GTK_COLOR_SELECTION (colorsel), &color);
5052 gtk_color_selection_set_current_color (GTK_COLOR_SELECTION (colorsel), &color);
5057 opacity_toggled_cb (GtkWidget *w,
5058 GtkColorSelectionDialog *cs)
5060 GtkColorSelection *colorsel;
5062 colorsel = GTK_COLOR_SELECTION (cs->colorsel);
5063 gtk_color_selection_set_has_opacity_control (colorsel,
5064 gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (w)));
5068 palette_toggled_cb (GtkWidget *w,
5069 GtkColorSelectionDialog *cs)
5071 GtkColorSelection *colorsel;
5073 colorsel = GTK_COLOR_SELECTION (cs->colorsel);
5074 gtk_color_selection_set_has_palette (colorsel,
5075 gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (w)));
5080 create_color_selection (GtkWidget *widget)
5082 static GtkWidget *window = NULL;
5091 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
5092 gtk_window_set_screen (GTK_WINDOW (window),
5093 gtk_widget_get_screen (widget));
5095 g_signal_connect (window, "destroy",
5096 G_CALLBACK (gtk_widget_destroyed),
5099 gtk_window_set_title (GTK_WINDOW (window), "GtkColorButton");
5100 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
5102 hbox = gtk_hbox_new (FALSE, 8);
5103 gtk_container_set_border_width (GTK_CONTAINER (hbox), 8);
5104 gtk_container_add (GTK_CONTAINER (window), hbox);
5106 label = gtk_label_new ("Pick a color");
5107 gtk_container_add (GTK_CONTAINER (hbox), label);
5109 picker = gtk_color_button_new ();
5110 gtk_color_button_set_use_alpha (GTK_COLOR_BUTTON (picker), TRUE);
5111 gtk_container_add (GTK_CONTAINER (hbox), picker);
5113 button = gtk_button_new_with_mnemonic ("_Props");
5114 gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0);
5115 g_signal_connect (button, "clicked",
5116 G_CALLBACK (props_clicked),
5120 if (!gtk_widget_get_visible (window))
5121 gtk_widget_show_all (window);
5123 gtk_widget_destroy (window);
5127 flipping_toggled_cb (GtkWidget *widget, gpointer data)
5129 int state = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget));
5130 int new_direction = state ? GTK_TEXT_DIR_RTL : GTK_TEXT_DIR_LTR;
5132 gtk_widget_set_default_direction (new_direction);
5136 orientable_toggle_orientation (GtkOrientable *orientable)
5138 GtkOrientation orientation;
5140 orientation = gtk_orientable_get_orientation (orientable);
5141 gtk_orientable_set_orientation (orientable,
5142 orientation == GTK_ORIENTATION_HORIZONTAL ?
5143 GTK_ORIENTATION_VERTICAL :
5144 GTK_ORIENTATION_HORIZONTAL);
5146 if (GTK_IS_CONTAINER (orientable))
5151 children = gtk_container_get_children (GTK_CONTAINER (orientable));
5153 for (child = children; child; child = child->next)
5155 if (GTK_IS_ORIENTABLE (child->data))
5156 orientable_toggle_orientation (child->data);
5159 g_list_free (children);
5164 flipping_orientation_toggled_cb (GtkWidget *widget, gpointer data)
5166 GtkWidget *content_area;
5167 GtkWidget *toplevel;
5169 toplevel = gtk_widget_get_toplevel (widget);
5170 content_area = gtk_dialog_get_content_area (GTK_DIALOG (toplevel));
5171 orientable_toggle_orientation (GTK_ORIENTABLE (content_area));
5175 set_direction_recurse (GtkWidget *widget,
5178 GtkTextDirection *dir = data;
5180 gtk_widget_set_direction (widget, *dir);
5181 if (GTK_IS_CONTAINER (widget))
5182 gtk_container_foreach (GTK_CONTAINER (widget),
5183 set_direction_recurse,
5188 create_forward_back (const char *title,
5189 GtkTextDirection text_dir)
5191 GtkWidget *frame = gtk_frame_new (title);
5192 GtkWidget *bbox = gtk_hbutton_box_new ();
5193 GtkWidget *back_button = gtk_button_new_from_stock (GTK_STOCK_GO_BACK);
5194 GtkWidget *forward_button = gtk_button_new_from_stock (GTK_STOCK_GO_FORWARD);
5196 gtk_container_set_border_width (GTK_CONTAINER (bbox), 5);
5198 gtk_container_add (GTK_CONTAINER (frame), bbox);
5199 gtk_container_add (GTK_CONTAINER (bbox), back_button);
5200 gtk_container_add (GTK_CONTAINER (bbox), forward_button);
5202 set_direction_recurse (frame, &text_dir);
5208 create_flipping (GtkWidget *widget)
5210 static GtkWidget *window = NULL;
5211 GtkWidget *check_button, *button;
5212 GtkWidget *action_area, *content_area;
5216 window = gtk_dialog_new ();
5218 gtk_window_set_screen (GTK_WINDOW (window),
5219 gtk_widget_get_screen (widget));
5221 g_signal_connect (window, "destroy",
5222 G_CALLBACK (gtk_widget_destroyed),
5225 content_area = gtk_dialog_get_content_area (GTK_DIALOG (window));
5226 action_area = gtk_dialog_get_action_area (GTK_DIALOG (window));
5228 gtk_window_set_title (GTK_WINDOW (window), "Bidirectional Flipping");
5230 check_button = gtk_check_button_new_with_label ("Right-to-left global direction");
5231 gtk_container_set_border_width (GTK_CONTAINER (check_button), 10);
5232 gtk_box_pack_start (GTK_BOX (content_area), check_button, TRUE, TRUE, 0);
5234 if (gtk_widget_get_default_direction () == GTK_TEXT_DIR_RTL)
5235 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check_button), TRUE);
5237 g_signal_connect (check_button, "toggled",
5238 G_CALLBACK (flipping_toggled_cb), NULL);
5240 check_button = gtk_check_button_new_with_label ("Toggle orientation of all boxes");
5241 gtk_container_set_border_width (GTK_CONTAINER (check_button), 10);
5242 gtk_box_pack_start (GTK_BOX (content_area), check_button, TRUE, TRUE, 0);
5244 g_signal_connect (check_button, "toggled",
5245 G_CALLBACK (flipping_orientation_toggled_cb), NULL);
5247 gtk_box_pack_start (GTK_BOX (content_area),
5248 create_forward_back ("Default", GTK_TEXT_DIR_NONE),
5251 gtk_box_pack_start (GTK_BOX (content_area),
5252 create_forward_back ("Left-to-Right", GTK_TEXT_DIR_LTR),
5255 gtk_box_pack_start (GTK_BOX (content_area),
5256 create_forward_back ("Right-to-Left", GTK_TEXT_DIR_RTL),
5259 button = gtk_button_new_with_label ("Close");
5260 g_signal_connect_swapped (button, "clicked",
5261 G_CALLBACK (gtk_widget_destroy), window);
5262 gtk_box_pack_start (GTK_BOX (action_area), button, TRUE, TRUE, 0);
5265 if (!gtk_widget_get_visible (window))
5266 gtk_widget_show_all (window);
5268 gtk_widget_destroy (window);
5276 make_focus_table (GList **list)
5281 table = gtk_table_new (5, 5, FALSE);
5294 widget = gtk_entry_new ();
5296 widget = gtk_button_new_with_label ("Foo");
5298 *list = g_list_prepend (*list, widget);
5300 gtk_table_attach (GTK_TABLE (table),
5304 GTK_EXPAND | GTK_FILL,
5305 GTK_EXPAND | GTK_FILL,
5314 *list = g_list_reverse (*list);
5320 create_focus (GtkWidget *widget)
5322 static GtkWidget *window = NULL;
5326 GtkWidget *content_area;
5331 window = gtk_dialog_new_with_buttons ("Keyboard focus navigation",
5337 gtk_window_set_screen (GTK_WINDOW (window),
5338 gtk_widget_get_screen (widget));
5340 g_signal_connect (window, "destroy",
5341 G_CALLBACK (gtk_widget_destroyed),
5344 g_signal_connect (window, "response",
5345 G_CALLBACK (gtk_widget_destroy),
5348 content_area = gtk_dialog_get_content_area (GTK_DIALOG (window));
5350 gtk_window_set_title (GTK_WINDOW (window), "Keyboard Focus Navigation");
5352 frame = gtk_frame_new ("Weird tab focus chain");
5354 gtk_box_pack_start (GTK_BOX (content_area), frame, TRUE, TRUE, 0);
5356 table = make_focus_table (&list);
5358 gtk_container_add (GTK_CONTAINER (frame), table);
5360 gtk_container_set_focus_chain (GTK_CONTAINER (table),
5365 frame = gtk_frame_new ("Default tab focus chain");
5367 gtk_box_pack_start (GTK_BOX (content_area), frame, TRUE, TRUE, 0);
5370 table = make_focus_table (&list);
5374 gtk_container_add (GTK_CONTAINER (frame), table);
5377 if (!gtk_widget_get_visible (window))
5378 gtk_widget_show_all (window);
5380 gtk_widget_destroy (window);
5388 font_selection_ok (GtkWidget *w,
5389 GtkFontSelectionDialog *fs)
5391 gchar *s = gtk_font_selection_dialog_get_font_name (fs);
5393 g_print ("%s\n", s);
5395 gtk_widget_destroy (GTK_WIDGET (fs));
5399 create_font_selection (GtkWidget *widget)
5401 static GtkWidget *window = NULL;
5409 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
5410 gtk_window_set_screen (GTK_WINDOW (window),
5411 gtk_widget_get_screen (widget));
5413 g_signal_connect (window, "destroy",
5414 G_CALLBACK (gtk_widget_destroyed),
5417 gtk_window_set_title (GTK_WINDOW (window), "GtkFontButton");
5418 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
5420 hbox = gtk_hbox_new (FALSE, 8);
5421 gtk_container_set_border_width (GTK_CONTAINER (hbox), 8);
5422 gtk_container_add (GTK_CONTAINER (window), hbox);
5424 label = gtk_label_new ("Pick a font");
5425 gtk_container_add (GTK_CONTAINER (hbox), label);
5427 picker = gtk_font_button_new ();
5428 gtk_font_button_set_use_font (GTK_FONT_BUTTON (picker), TRUE);
5429 gtk_container_add (GTK_CONTAINER (hbox), picker);
5432 if (!gtk_widget_get_visible (window))
5433 gtk_widget_show_all (window);
5435 gtk_widget_destroy (window);
5442 static GtkWidget *dialog_window = NULL;
5445 label_toggle (GtkWidget *widget,
5450 *label = gtk_label_new ("Dialog Test");
5451 g_signal_connect (*label,
5453 G_CALLBACK (gtk_widget_destroyed),
5455 gtk_misc_set_padding (GTK_MISC (*label), 10, 10);
5456 gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog_window))),
5457 *label, TRUE, TRUE, 0);
5458 gtk_widget_show (*label);
5461 gtk_widget_destroy (*label);
5465 create_dialog (GtkWidget *widget)
5467 static GtkWidget *label;
5468 GtkWidget *action_area;
5473 /* This is a terrible example; it's much simpler to create
5474 * dialogs than this. Don't use testgtk for example code,
5478 dialog_window = gtk_dialog_new ();
5479 gtk_window_set_screen (GTK_WINDOW (dialog_window),
5480 gtk_widget_get_screen (widget));
5482 g_signal_connect (dialog_window, "destroy",
5483 G_CALLBACK (gtk_widget_destroyed),
5486 action_area = gtk_dialog_get_action_area (GTK_DIALOG (dialog_window));
5488 gtk_window_set_title (GTK_WINDOW (dialog_window), "GtkDialog");
5489 gtk_container_set_border_width (GTK_CONTAINER (dialog_window), 0);
5491 button = gtk_button_new_with_label ("OK");
5492 gtk_widget_set_can_default (button, TRUE);
5493 gtk_box_pack_start (GTK_BOX (action_area), button, TRUE, TRUE, 0);
5494 gtk_widget_grab_default (button);
5495 gtk_widget_show (button);
5497 button = gtk_button_new_with_label ("Toggle");
5498 g_signal_connect (button, "clicked",
5499 G_CALLBACK (label_toggle),
5501 gtk_widget_set_can_default (button, TRUE);
5502 gtk_box_pack_start (GTK_BOX (action_area), button, TRUE, TRUE, 0);
5503 gtk_widget_show (button);
5508 if (!gtk_widget_get_visible (dialog_window))
5509 gtk_widget_show (dialog_window);
5511 gtk_widget_destroy (dialog_window);
5514 /* Display & Screen test
5521 GtkWidget *radio_dpy;
5522 GtkWidget *toplevel;
5523 GtkWidget *dialog_window;
5524 } ScreenDisplaySelection;
5527 screen_display_check (GtkWidget *widget, ScreenDisplaySelection *data)
5529 const gchar *display_name;
5530 GdkDisplay *display = gtk_widget_get_display (widget);
5532 GdkScreen *new_screen = NULL;
5533 GdkScreen *current_screen = gtk_widget_get_screen (widget);
5535 if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (data->radio_dpy)))
5537 display_name = gtk_entry_get_text (GTK_ENTRY (data->entry));
5538 display = gdk_display_open (display_name);
5542 dialog = gtk_message_dialog_new (GTK_WINDOW (gtk_widget_get_toplevel (widget)),
5543 GTK_DIALOG_DESTROY_WITH_PARENT,
5546 "The display :\n%s\ncannot be opened",
5548 gtk_window_set_screen (GTK_WINDOW (dialog), current_screen);
5549 gtk_widget_show (dialog);
5550 g_signal_connect (dialog, "response",
5551 G_CALLBACK (gtk_widget_destroy),
5556 GtkTreeModel *model = gtk_combo_box_get_model (GTK_COMBO_BOX (data->combo));
5559 gboolean found = FALSE;
5560 while (gtk_tree_model_iter_nth_child (model, &iter, NULL, i++))
5563 gtk_tree_model_get (model, &iter, 0, &name, -1);
5564 found = !g_ascii_strcasecmp (display_name, name);
5571 gtk_combo_box_append_text (GTK_COMBO_BOX (data->combo), display_name);
5572 new_screen = gdk_display_get_default_screen (display);
5577 gint number_of_screens = gdk_display_get_n_screens (display);
5578 gint screen_num = gdk_screen_get_number (current_screen);
5579 if ((screen_num +1) < number_of_screens)
5580 new_screen = gdk_display_get_screen (display, screen_num + 1);
5582 new_screen = gdk_display_get_screen (display, 0);
5587 gtk_window_set_screen (GTK_WINDOW (data->toplevel), new_screen);
5588 gtk_widget_destroy (data->dialog_window);
5593 screen_display_destroy_diag (GtkWidget *widget, GtkWidget *data)
5595 gtk_widget_destroy (data);
5599 create_display_screen (GtkWidget *widget)
5601 GtkWidget *table, *frame, *window, *combo_dpy, *vbox;
5602 GtkWidget *radio_dpy, *radio_scr, *applyb, *cancelb;
5604 ScreenDisplaySelection *scr_dpy_data;
5605 GdkScreen *screen = gtk_widget_get_screen (widget);
5606 GdkDisplay *display = gdk_screen_get_display (screen);
5608 window = g_object_new (gtk_window_get_type (),
5611 "type", GTK_WINDOW_TOPLEVEL,
5613 "Screen or Display selection",
5614 "border_width", 10, NULL);
5615 g_signal_connect (window, "destroy",
5616 G_CALLBACK (gtk_widget_destroy), NULL);
5618 vbox = gtk_vbox_new (FALSE, 3);
5619 gtk_container_add (GTK_CONTAINER (window), vbox);
5621 frame = gtk_frame_new ("Select screen or display");
5622 gtk_container_add (GTK_CONTAINER (vbox), frame);
5624 table = gtk_table_new (2, 2, TRUE);
5625 gtk_table_set_row_spacings (GTK_TABLE (table), 3);
5626 gtk_table_set_col_spacings (GTK_TABLE (table), 3);
5628 gtk_container_add (GTK_CONTAINER (frame), table);
5630 radio_dpy = gtk_radio_button_new_with_label (NULL, "move to another X display");
5631 if (gdk_display_get_n_screens(display) > 1)
5632 radio_scr = gtk_radio_button_new_with_label
5633 (gtk_radio_button_get_group (GTK_RADIO_BUTTON (radio_dpy)), "move to next screen");
5636 radio_scr = gtk_radio_button_new_with_label
5637 (gtk_radio_button_get_group (GTK_RADIO_BUTTON (radio_dpy)),
5638 "only one screen on the current display");
5639 gtk_widget_set_sensitive (radio_scr, FALSE);
5641 combo_dpy = gtk_combo_box_new_text ();
5642 gtk_combo_box_append_text (GTK_COMBO_BOX (combo_dpy), "diabolo:0.0");
5643 gtk_entry_set_text (GTK_ENTRY (gtk_bin_get_child (GTK_BIN (combo_dpy))),
5644 "<hostname>:<X Server Num>.<Screen Num>");
5646 gtk_table_attach_defaults (GTK_TABLE (table), radio_dpy, 0, 1, 0, 1);
5647 gtk_table_attach_defaults (GTK_TABLE (table), radio_scr, 0, 1, 1, 2);
5648 gtk_table_attach_defaults (GTK_TABLE (table), combo_dpy, 1, 2, 0, 1);
5650 bbox = gtk_hbutton_box_new ();
5651 applyb = gtk_button_new_from_stock (GTK_STOCK_APPLY);
5652 cancelb = gtk_button_new_from_stock (GTK_STOCK_CANCEL);
5654 gtk_container_add (GTK_CONTAINER (vbox), bbox);
5656 gtk_container_add (GTK_CONTAINER (bbox), applyb);
5657 gtk_container_add (GTK_CONTAINER (bbox), cancelb);
5659 scr_dpy_data = g_new0 (ScreenDisplaySelection, 1);
5661 scr_dpy_data->entry = gtk_bin_get_child (GTK_BIN (combo_dpy));
5662 scr_dpy_data->radio_dpy = radio_dpy;
5663 scr_dpy_data->toplevel = gtk_widget_get_toplevel (widget);
5664 scr_dpy_data->dialog_window = window;
5666 g_signal_connect (cancelb, "clicked",
5667 G_CALLBACK (screen_display_destroy_diag), window);
5668 g_signal_connect (applyb, "clicked",
5669 G_CALLBACK (screen_display_check), scr_dpy_data);
5670 gtk_widget_show_all (window);
5675 static gboolean event_watcher_enter_id = 0;
5676 static gboolean event_watcher_leave_id = 0;
5679 event_watcher (GSignalInvocationHint *ihint,
5680 guint n_param_values,
5681 const GValue *param_values,
5684 g_print ("Watch: \"%s\" emitted for %s\n",
5685 g_signal_name (ihint->signal_id),
5686 G_OBJECT_TYPE_NAME (g_value_get_object (param_values + 0)));
5692 event_watcher_down (void)
5694 if (event_watcher_enter_id)
5698 signal_id = g_signal_lookup ("enter_notify_event", GTK_TYPE_WIDGET);
5699 g_signal_remove_emission_hook (signal_id, event_watcher_enter_id);
5700 event_watcher_enter_id = 0;
5701 signal_id = g_signal_lookup ("leave_notify_event", GTK_TYPE_WIDGET);
5702 g_signal_remove_emission_hook (signal_id, event_watcher_leave_id);
5703 event_watcher_leave_id = 0;
5708 event_watcher_toggle (void)
5710 if (event_watcher_enter_id)
5711 event_watcher_down ();
5716 signal_id = g_signal_lookup ("enter_notify_event", GTK_TYPE_WIDGET);
5717 event_watcher_enter_id = g_signal_add_emission_hook (signal_id, 0, event_watcher, NULL, NULL);
5718 signal_id = g_signal_lookup ("leave_notify_event", GTK_TYPE_WIDGET);
5719 event_watcher_leave_id = g_signal_add_emission_hook (signal_id, 0, event_watcher, NULL, NULL);
5724 create_event_watcher (GtkWidget *widget)
5726 GtkWidget *action_area, *content_area;
5731 dialog_window = gtk_dialog_new ();
5732 gtk_window_set_screen (GTK_WINDOW (dialog_window),
5733 gtk_widget_get_screen (widget));
5735 g_signal_connect (dialog_window, "destroy",
5736 G_CALLBACK (gtk_widget_destroyed),
5738 g_signal_connect (dialog_window, "destroy",
5739 G_CALLBACK (event_watcher_down),
5742 content_area = gtk_dialog_get_content_area (GTK_DIALOG (dialog_window));
5743 action_area = gtk_dialog_get_action_area (GTK_DIALOG (dialog_window));
5745 gtk_window_set_title (GTK_WINDOW (dialog_window), "Event Watcher");
5746 gtk_container_set_border_width (GTK_CONTAINER (dialog_window), 0);
5747 gtk_widget_set_size_request (dialog_window, 200, 110);
5749 button = gtk_toggle_button_new_with_label ("Activate Watch");
5750 g_signal_connect (button, "clicked",
5751 G_CALLBACK (event_watcher_toggle),
5753 gtk_container_set_border_width (GTK_CONTAINER (button), 10);
5754 gtk_box_pack_start (GTK_BOX (content_area), button, TRUE, TRUE, 0);
5755 gtk_widget_show (button);
5757 button = gtk_button_new_with_label ("Close");
5758 g_signal_connect_swapped (button, "clicked",
5759 G_CALLBACK (gtk_widget_destroy),
5761 gtk_widget_set_can_default (button, TRUE);
5762 gtk_box_pack_start (GTK_BOX (action_area), button, TRUE, TRUE, 0);
5763 gtk_widget_grab_default (button);
5764 gtk_widget_show (button);
5767 if (!gtk_widget_get_visible (dialog_window))
5768 gtk_widget_show (dialog_window);
5770 gtk_widget_destroy (dialog_window);
5778 reformat_value (GtkScale *scale,
5781 return g_strdup_printf ("-->%0.*g<--",
5782 gtk_scale_get_digits (scale), value);
5786 create_range_controls (GtkWidget *widget)
5788 static GtkWidget *window = NULL;
5792 GtkWidget *scrollbar;
5794 GtkWidget *separator;
5795 GtkAdjustment *adjustment;
5800 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
5802 gtk_window_set_screen (GTK_WINDOW (window),
5803 gtk_widget_get_screen (widget));
5805 g_signal_connect (window, "destroy",
5806 G_CALLBACK (gtk_widget_destroyed),
5809 gtk_window_set_title (GTK_WINDOW (window), "range controls");
5810 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
5813 box1 = gtk_vbox_new (FALSE, 0);
5814 gtk_container_add (GTK_CONTAINER (window), box1);
5815 gtk_widget_show (box1);
5818 box2 = gtk_vbox_new (FALSE, 10);
5819 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
5820 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
5821 gtk_widget_show (box2);
5824 adjustment = gtk_adjustment_new (0.0, 0.0, 101.0, 0.1, 1.0, 1.0);
5826 scale = gtk_hscale_new (GTK_ADJUSTMENT (adjustment));
5827 gtk_widget_set_size_request (GTK_WIDGET (scale), 150, -1);
5828 gtk_range_set_update_policy (GTK_RANGE (scale), GTK_UPDATE_DELAYED);
5829 gtk_scale_set_digits (GTK_SCALE (scale), 1);
5830 gtk_scale_set_draw_value (GTK_SCALE (scale), TRUE);
5831 gtk_box_pack_start (GTK_BOX (box2), scale, TRUE, TRUE, 0);
5832 gtk_widget_show (scale);
5834 scrollbar = gtk_hscrollbar_new (GTK_ADJUSTMENT (adjustment));
5835 gtk_range_set_update_policy (GTK_RANGE (scrollbar),
5836 GTK_UPDATE_CONTINUOUS);
5837 gtk_box_pack_start (GTK_BOX (box2), scrollbar, TRUE, TRUE, 0);
5838 gtk_widget_show (scrollbar);
5840 scale = gtk_hscale_new (GTK_ADJUSTMENT (adjustment));
5841 gtk_scale_set_draw_value (GTK_SCALE (scale), TRUE);
5842 g_signal_connect (scale,
5844 G_CALLBACK (reformat_value),
5846 gtk_box_pack_start (GTK_BOX (box2), scale, TRUE, TRUE, 0);
5847 gtk_widget_show (scale);
5849 hbox = gtk_hbox_new (FALSE, 0);
5851 scale = gtk_vscale_new (GTK_ADJUSTMENT (adjustment));
5852 gtk_widget_set_size_request (scale, -1, 200);
5853 gtk_scale_set_digits (GTK_SCALE (scale), 2);
5854 gtk_scale_set_draw_value (GTK_SCALE (scale), TRUE);
5855 gtk_box_pack_start (GTK_BOX (hbox), scale, TRUE, TRUE, 0);
5856 gtk_widget_show (scale);
5858 scale = gtk_vscale_new (GTK_ADJUSTMENT (adjustment));
5859 gtk_widget_set_size_request (scale, -1, 200);
5860 gtk_scale_set_digits (GTK_SCALE (scale), 2);
5861 gtk_scale_set_draw_value (GTK_SCALE (scale), TRUE);
5862 gtk_range_set_inverted (GTK_RANGE (scale), TRUE);
5863 gtk_box_pack_start (GTK_BOX (hbox), scale, TRUE, TRUE, 0);
5864 gtk_widget_show (scale);
5866 scale = gtk_vscale_new (GTK_ADJUSTMENT (adjustment));
5867 gtk_scale_set_draw_value (GTK_SCALE (scale), TRUE);
5868 g_signal_connect (scale,
5870 G_CALLBACK (reformat_value),
5872 gtk_box_pack_start (GTK_BOX (hbox), scale, TRUE, TRUE, 0);
5873 gtk_widget_show (scale);
5876 gtk_box_pack_start (GTK_BOX (box2), hbox, TRUE, TRUE, 0);
5877 gtk_widget_show (hbox);
5879 separator = gtk_hseparator_new ();
5880 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
5881 gtk_widget_show (separator);
5884 box2 = gtk_vbox_new (FALSE, 10);
5885 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
5886 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
5887 gtk_widget_show (box2);
5890 button = gtk_button_new_with_label ("close");
5891 g_signal_connect_swapped (button, "clicked",
5892 G_CALLBACK (gtk_widget_destroy),
5894 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
5895 gtk_widget_set_can_default (button, TRUE);
5896 gtk_widget_grab_default (button);
5897 gtk_widget_show (button);
5900 if (!gtk_widget_get_visible (window))
5901 gtk_widget_show (window);
5903 gtk_widget_destroy (window);
5911 create_rulers (GtkWidget *widget)
5913 static GtkWidget *window = NULL;
5919 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
5921 gtk_window_set_screen (GTK_WINDOW (window),
5922 gtk_widget_get_screen (widget));
5924 gtk_window_set_resizable (GTK_WINDOW (window), TRUE);
5926 g_signal_connect (window, "destroy",
5927 G_CALLBACK (gtk_widget_destroyed),
5930 gtk_window_set_title (GTK_WINDOW (window), "rulers");
5931 gtk_widget_set_size_request (window, 300, 300);
5932 gtk_widget_set_events (window,
5933 GDK_POINTER_MOTION_MASK
5934 | GDK_POINTER_MOTION_HINT_MASK);
5935 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
5937 table = gtk_table_new (2, 2, FALSE);
5938 gtk_container_add (GTK_CONTAINER (window), table);
5939 gtk_widget_show (table);
5941 ruler = gtk_hruler_new ();
5942 gtk_ruler_set_metric (GTK_RULER (ruler), GTK_CENTIMETERS);
5943 gtk_ruler_set_range (GTK_RULER (ruler), 100, 0, 0, 20);
5945 g_signal_connect_swapped (window,
5946 "motion_notify_event",
5947 G_CALLBACK (GTK_WIDGET_GET_CLASS (ruler)->motion_notify_event),
5950 gtk_table_attach (GTK_TABLE (table), ruler, 1, 2, 0, 1,
5951 GTK_EXPAND | GTK_FILL, GTK_FILL, 0, 0);
5952 gtk_widget_show (ruler);
5955 ruler = gtk_vruler_new ();
5956 gtk_ruler_set_range (GTK_RULER (ruler), 5, 15, 0, 20);
5958 g_signal_connect_swapped (window,
5959 "motion_notify_event",
5960 G_CALLBACK (GTK_WIDGET_GET_CLASS (ruler)->motion_notify_event),
5963 gtk_table_attach (GTK_TABLE (table), ruler, 0, 1, 1, 2,
5964 GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
5965 gtk_widget_show (ruler);
5968 if (!gtk_widget_get_visible (window))
5969 gtk_widget_show (window);
5971 gtk_widget_destroy (window);
5978 { { 0, 0x0000, 0x0000, 0x0000 }, "black" },
5979 { { 0, 0xFFFF, 0xFFFF, 0xFFFF }, "white" },
5980 { { 0, 0xFFFF, 0x0000, 0x0000 }, "red" },
5981 { { 0, 0x0000, 0xFFFF, 0x0000 }, "green" },
5982 { { 0, 0x0000, 0x0000, 0xFFFF }, "blue" },
5983 { { 0, 0x0000, 0xFFFF, 0xFFFF }, "cyan" },
5984 { { 0, 0xFFFF, 0x0000, 0xFFFF }, "magenta" },
5985 { { 0, 0xFFFF, 0xFFFF, 0x0000 }, "yellow" }
5988 int ntext_colors = sizeof(text_colors) / sizeof(text_colors[0]);
5994 static const char * book_open_xpm[] = {
6017 static const char * book_closed_xpm[] = {
6042 GdkPixbuf *book_open;
6043 GdkPixbuf *book_closed;
6044 GtkWidget *sample_notebook;
6047 set_page_image (GtkNotebook *notebook, gint page_num, GdkPixbuf *pixbuf)
6049 GtkWidget *page_widget;
6052 page_widget = gtk_notebook_get_nth_page (notebook, page_num);
6054 pixwid = g_object_get_data (G_OBJECT (page_widget), "tab_pixmap");
6055 gtk_image_set_from_pixbuf (GTK_IMAGE (pixwid), pixbuf);
6057 pixwid = g_object_get_data (G_OBJECT (page_widget), "menu_pixmap");
6058 gtk_image_set_from_pixbuf (GTK_IMAGE (pixwid), pixbuf);
6062 page_switch (GtkWidget *widget, gpointer *page, gint page_num)
6064 GtkNotebook *notebook = GTK_NOTEBOOK (widget);
6065 gint old_page_num = gtk_notebook_get_current_page (notebook);
6067 if (page_num == old_page_num)
6070 set_page_image (notebook, page_num, book_open);
6072 if (old_page_num != -1)
6073 set_page_image (notebook, old_page_num, book_closed);
6077 tab_fill (GtkToggleButton *button, GtkWidget *child)
6079 gtk_container_child_set (GTK_CONTAINER (sample_notebook), child,
6080 "tab-fill", gtk_toggle_button_get_active (button),
6085 tab_expand (GtkToggleButton *button, GtkWidget *child)
6087 gtk_container_child_set (GTK_CONTAINER (sample_notebook), child,
6088 "tab-expand", gtk_toggle_button_get_active (button),
6093 create_pages (GtkNotebook *notebook, gint start, gint end)
6095 GtkWidget *child = NULL;
6100 GtkWidget *label_box;
6101 GtkWidget *menu_box;
6105 char accel_buffer[32];
6107 for (i = start; i <= end; i++)
6109 sprintf (buffer, "Page %d", i);
6110 sprintf (accel_buffer, "Page _%d", i);
6112 child = gtk_frame_new (buffer);
6113 gtk_container_set_border_width (GTK_CONTAINER (child), 10);
6115 vbox = gtk_vbox_new (TRUE,0);
6116 gtk_container_set_border_width (GTK_CONTAINER (vbox), 10);
6117 gtk_container_add (GTK_CONTAINER (child), vbox);
6119 hbox = gtk_hbox_new (TRUE,0);
6120 gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 5);
6122 button = gtk_check_button_new_with_label ("Fill Tab");
6123 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
6124 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
6125 g_signal_connect (button, "toggled",
6126 G_CALLBACK (tab_fill), child);
6128 button = gtk_check_button_new_with_label ("Expand Tab");
6129 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
6130 g_signal_connect (button, "toggled",
6131 G_CALLBACK (tab_expand), child);
6133 button = gtk_button_new_with_label ("Hide Page");
6134 gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 5);
6135 g_signal_connect_swapped (button, "clicked",
6136 G_CALLBACK (gtk_widget_hide),
6139 gtk_widget_show_all (child);
6141 label_box = gtk_hbox_new (FALSE, 0);
6142 pixwid = gtk_image_new_from_pixbuf (book_closed);
6143 g_object_set_data (G_OBJECT (child), "tab_pixmap", pixwid);
6145 gtk_box_pack_start (GTK_BOX (label_box), pixwid, FALSE, TRUE, 0);
6146 gtk_misc_set_padding (GTK_MISC (pixwid), 3, 1);
6147 label = gtk_label_new_with_mnemonic (accel_buffer);
6148 gtk_box_pack_start (GTK_BOX (label_box), label, FALSE, TRUE, 0);
6149 gtk_widget_show_all (label_box);
6152 menu_box = gtk_hbox_new (FALSE, 0);
6153 pixwid = gtk_image_new_from_pixbuf (book_closed);
6154 g_object_set_data (G_OBJECT (child), "menu_pixmap", pixwid);
6156 gtk_box_pack_start (GTK_BOX (menu_box), pixwid, FALSE, TRUE, 0);
6157 gtk_misc_set_padding (GTK_MISC (pixwid), 3, 1);
6158 label = gtk_label_new (buffer);
6159 gtk_box_pack_start (GTK_BOX (menu_box), label, FALSE, TRUE, 0);
6160 gtk_widget_show_all (menu_box);
6162 gtk_notebook_append_page_menu (notebook, child, label_box, menu_box);
6167 rotate_notebook (GtkButton *button,
6168 GtkNotebook *notebook)
6170 gtk_notebook_set_tab_pos (notebook, (gtk_notebook_get_tab_pos (notebook) + 1) % 4);
6174 show_all_pages (GtkButton *button,
6175 GtkNotebook *notebook)
6177 gtk_container_foreach (GTK_CONTAINER (notebook),
6178 (GtkCallback) gtk_widget_show, NULL);
6182 notebook_type_changed (GtkWidget *optionmenu,
6185 GtkNotebook *notebook;
6195 notebook = GTK_NOTEBOOK (data);
6197 c = gtk_combo_box_get_active (GTK_COMBO_BOX (optionmenu));
6202 /* standard notebook */
6203 gtk_notebook_set_show_tabs (notebook, TRUE);
6204 gtk_notebook_set_show_border (notebook, TRUE);
6205 gtk_notebook_set_scrollable (notebook, FALSE);
6209 /* notabs notebook */
6210 gtk_notebook_set_show_tabs (notebook, FALSE);
6211 gtk_notebook_set_show_border (notebook, TRUE);
6216 gtk_notebook_set_show_tabs (notebook, FALSE);
6217 gtk_notebook_set_show_border (notebook, FALSE);
6222 gtk_notebook_set_show_tabs (notebook, TRUE);
6223 gtk_notebook_set_show_border (notebook, TRUE);
6224 gtk_notebook_set_scrollable (notebook, TRUE);
6225 if (gtk_notebook_get_n_pages (notebook) == 5)
6226 create_pages (notebook, 6, 15);
6232 if (gtk_notebook_get_n_pages (notebook) == 15)
6233 for (i = 0; i < 10; i++)
6234 gtk_notebook_remove_page (notebook, 5);
6238 notebook_popup (GtkToggleButton *button,
6239 GtkNotebook *notebook)
6242 gtk_notebook_popup_enable (notebook);
6244 gtk_notebook_popup_disable (notebook);
6248 create_notebook (GtkWidget *widget)
6250 static GtkWidget *window = NULL;
6254 GtkWidget *separator;
6258 static gchar *items[] =
6268 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
6269 gtk_window_set_screen (GTK_WINDOW (window),
6270 gtk_widget_get_screen (widget));
6272 g_signal_connect (window, "destroy",
6273 G_CALLBACK (gtk_widget_destroyed),
6276 gtk_window_set_title (GTK_WINDOW (window), "notebook");
6277 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
6279 box1 = gtk_vbox_new (FALSE, 0);
6280 gtk_container_add (GTK_CONTAINER (window), box1);
6282 sample_notebook = gtk_notebook_new ();
6283 g_signal_connect (sample_notebook, "switch_page",
6284 G_CALLBACK (page_switch), NULL);
6285 gtk_notebook_set_tab_pos (GTK_NOTEBOOK (sample_notebook), GTK_POS_TOP);
6286 gtk_box_pack_start (GTK_BOX (box1), sample_notebook, TRUE, TRUE, 0);
6287 gtk_container_set_border_width (GTK_CONTAINER (sample_notebook), 10);
6289 gtk_widget_realize (sample_notebook);
6292 book_open = gdk_pixbuf_new_from_xpm_data (book_open_xpm);
6295 book_closed = gdk_pixbuf_new_from_xpm_data (book_closed_xpm);
6297 create_pages (GTK_NOTEBOOK (sample_notebook), 1, 5);
6299 separator = gtk_hseparator_new ();
6300 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 10);
6302 box2 = gtk_hbox_new (FALSE, 5);
6303 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
6304 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
6306 button = gtk_check_button_new_with_label ("popup menu");
6307 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, FALSE, 0);
6308 g_signal_connect (button, "clicked",
6309 G_CALLBACK (notebook_popup),
6312 box2 = gtk_hbox_new (FALSE, 5);
6313 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
6314 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
6316 label = gtk_label_new ("Notebook Style :");
6317 gtk_box_pack_start (GTK_BOX (box2), label, FALSE, TRUE, 0);
6319 omenu = build_option_menu (items, G_N_ELEMENTS (items), 0,
6320 notebook_type_changed,
6322 gtk_box_pack_start (GTK_BOX (box2), omenu, FALSE, TRUE, 0);
6324 button = gtk_button_new_with_label ("Show all Pages");
6325 gtk_box_pack_start (GTK_BOX (box2), button, FALSE, TRUE, 0);
6326 g_signal_connect (button, "clicked",
6327 G_CALLBACK (show_all_pages), sample_notebook);
6329 box2 = gtk_hbox_new (TRUE, 10);
6330 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
6331 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
6333 button = gtk_button_new_with_label ("prev");
6334 g_signal_connect_swapped (button, "clicked",
6335 G_CALLBACK (gtk_notebook_prev_page),
6337 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
6339 button = gtk_button_new_with_label ("next");
6340 g_signal_connect_swapped (button, "clicked",
6341 G_CALLBACK (gtk_notebook_next_page),
6343 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
6345 button = gtk_button_new_with_label ("rotate");
6346 g_signal_connect (button, "clicked",
6347 G_CALLBACK (rotate_notebook), sample_notebook);
6348 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
6350 separator = gtk_hseparator_new ();
6351 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 5);
6353 button = gtk_button_new_with_label ("close");
6354 gtk_container_set_border_width (GTK_CONTAINER (button), 5);
6355 g_signal_connect_swapped (button, "clicked",
6356 G_CALLBACK (gtk_widget_destroy),
6358 gtk_box_pack_start (GTK_BOX (box1), button, FALSE, FALSE, 0);
6359 gtk_widget_set_can_default (button, TRUE);
6360 gtk_widget_grab_default (button);
6363 if (!gtk_widget_get_visible (window))
6364 gtk_widget_show_all (window);
6366 gtk_widget_destroy (window);
6374 toggle_resize (GtkWidget *widget, GtkWidget *child)
6376 GtkContainer *container = GTK_CONTAINER (gtk_widget_get_parent (child));
6377 GValue value = { 0, };
6378 g_value_init (&value, G_TYPE_BOOLEAN);
6379 gtk_container_child_get_property (container, child, "resize", &value);
6380 g_value_set_boolean (&value, !g_value_get_boolean (&value));
6381 gtk_container_child_set_property (container, child, "resize", &value);
6385 toggle_shrink (GtkWidget *widget, GtkWidget *child)
6387 GtkContainer *container = GTK_CONTAINER (gtk_widget_get_parent (child));
6388 GValue value = { 0, };
6389 g_value_init (&value, G_TYPE_BOOLEAN);
6390 gtk_container_child_get_property (container, child, "shrink", &value);
6391 g_value_set_boolean (&value, !g_value_get_boolean (&value));
6392 gtk_container_child_set_property (container, child, "shrink", &value);
6396 paned_props_clicked (GtkWidget *button,
6399 GtkWidget *window = create_prop_editor (paned, GTK_TYPE_PANED);
6401 gtk_window_set_title (GTK_WINDOW (window), "Paned Properties");
6405 create_pane_options (GtkPaned *paned,
6406 const gchar *frame_label,
6407 const gchar *label1,
6408 const gchar *label2)
6410 GtkWidget *child1, *child2;
6415 GtkWidget *check_button;
6417 child1 = gtk_paned_get_child1 (paned);
6418 child2 = gtk_paned_get_child2 (paned);
6420 frame = gtk_frame_new (frame_label);
6421 gtk_container_set_border_width (GTK_CONTAINER (frame), 4);
6423 table = gtk_table_new (4, 2, 4);
6424 gtk_container_add (GTK_CONTAINER (frame), table);
6426 label = gtk_label_new (label1);
6427 gtk_table_attach_defaults (GTK_TABLE (table), label,
6430 check_button = gtk_check_button_new_with_label ("Resize");
6431 gtk_table_attach_defaults (GTK_TABLE (table), check_button,
6433 g_signal_connect (check_button, "toggled",
6434 G_CALLBACK (toggle_resize),
6437 check_button = gtk_check_button_new_with_label ("Shrink");
6438 gtk_table_attach_defaults (GTK_TABLE (table), check_button,
6440 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check_button),
6442 g_signal_connect (check_button, "toggled",
6443 G_CALLBACK (toggle_shrink),
6446 label = gtk_label_new (label2);
6447 gtk_table_attach_defaults (GTK_TABLE (table), label,
6450 check_button = gtk_check_button_new_with_label ("Resize");
6451 gtk_table_attach_defaults (GTK_TABLE (table), check_button,
6453 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check_button),
6455 g_signal_connect (check_button, "toggled",
6456 G_CALLBACK (toggle_resize),
6459 check_button = gtk_check_button_new_with_label ("Shrink");
6460 gtk_table_attach_defaults (GTK_TABLE (table), check_button,
6462 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check_button),
6464 g_signal_connect (check_button, "toggled",
6465 G_CALLBACK (toggle_shrink),
6468 button = gtk_button_new_with_mnemonic ("_Properties");
6469 gtk_table_attach_defaults (GTK_TABLE (table), button,
6471 g_signal_connect (button, "clicked",
6472 G_CALLBACK (paned_props_clicked),
6479 create_panes (GtkWidget *widget)
6481 static GtkWidget *window = NULL;
6490 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
6492 gtk_window_set_screen (GTK_WINDOW (window),
6493 gtk_widget_get_screen (widget));
6495 g_signal_connect (window, "destroy",
6496 G_CALLBACK (gtk_widget_destroyed),
6499 gtk_window_set_title (GTK_WINDOW (window), "Panes");
6500 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
6502 vbox = gtk_vbox_new (FALSE, 0);
6503 gtk_container_add (GTK_CONTAINER (window), vbox);
6505 vpaned = gtk_vpaned_new ();
6506 gtk_box_pack_start (GTK_BOX (vbox), vpaned, TRUE, TRUE, 0);
6507 gtk_container_set_border_width (GTK_CONTAINER(vpaned), 5);
6509 hpaned = gtk_hpaned_new ();
6510 gtk_paned_add1 (GTK_PANED (vpaned), hpaned);
6512 frame = gtk_frame_new (NULL);
6513 gtk_frame_set_shadow_type (GTK_FRAME(frame), GTK_SHADOW_IN);
6514 gtk_widget_set_size_request (frame, 60, 60);
6515 gtk_paned_add1 (GTK_PANED (hpaned), frame);
6517 button = gtk_button_new_with_label ("Hi there");
6518 gtk_container_add (GTK_CONTAINER(frame), button);
6520 frame = gtk_frame_new (NULL);
6521 gtk_frame_set_shadow_type (GTK_FRAME(frame), GTK_SHADOW_IN);
6522 gtk_widget_set_size_request (frame, 80, 60);
6523 gtk_paned_add2 (GTK_PANED (hpaned), frame);
6525 frame = gtk_frame_new (NULL);
6526 gtk_frame_set_shadow_type (GTK_FRAME(frame), GTK_SHADOW_IN);
6527 gtk_widget_set_size_request (frame, 60, 80);
6528 gtk_paned_add2 (GTK_PANED (vpaned), frame);
6530 /* Now create toggle buttons to control sizing */
6532 gtk_box_pack_start (GTK_BOX (vbox),
6533 create_pane_options (GTK_PANED (hpaned),
6539 gtk_box_pack_start (GTK_BOX (vbox),
6540 create_pane_options (GTK_PANED (vpaned),
6546 gtk_widget_show_all (vbox);
6549 if (!gtk_widget_get_visible (window))
6550 gtk_widget_show (window);
6552 gtk_widget_destroy (window);
6556 * Paned keyboard navigation
6560 paned_keyboard_window1 (GtkWidget *widget)
6583 window1 = gtk_window_new (GTK_WINDOW_TOPLEVEL);
6584 gtk_window_set_title (GTK_WINDOW (window1), "Basic paned navigation");
6585 gtk_window_set_screen (GTK_WINDOW (window1),
6586 gtk_widget_get_screen (widget));
6588 hpaned1 = gtk_hpaned_new ();
6589 gtk_container_add (GTK_CONTAINER (window1), hpaned1);
6591 frame1 = gtk_frame_new (NULL);
6592 gtk_paned_pack1 (GTK_PANED (hpaned1), frame1, FALSE, TRUE);
6593 gtk_frame_set_shadow_type (GTK_FRAME (frame1), GTK_SHADOW_IN);
6595 vbox1 = gtk_vbox_new (FALSE, 0);
6596 gtk_container_add (GTK_CONTAINER (frame1), vbox1);
6598 button7 = gtk_button_new_with_label ("button7");
6599 gtk_box_pack_start (GTK_BOX (vbox1), button7, FALSE, FALSE, 0);
6601 button8 = gtk_button_new_with_label ("button8");
6602 gtk_box_pack_start (GTK_BOX (vbox1), button8, FALSE, FALSE, 0);
6604 button9 = gtk_button_new_with_label ("button9");
6605 gtk_box_pack_start (GTK_BOX (vbox1), button9, FALSE, FALSE, 0);
6607 vpaned1 = gtk_vpaned_new ();
6608 gtk_paned_pack2 (GTK_PANED (hpaned1), vpaned1, TRUE, TRUE);
6610 frame2 = gtk_frame_new (NULL);
6611 gtk_paned_pack1 (GTK_PANED (vpaned1), frame2, FALSE, TRUE);
6612 gtk_frame_set_shadow_type (GTK_FRAME (frame2), GTK_SHADOW_IN);
6614 frame5 = gtk_frame_new (NULL);
6615 gtk_container_add (GTK_CONTAINER (frame2), frame5);
6617 hbox1 = gtk_hbox_new (FALSE, 0);
6618 gtk_container_add (GTK_CONTAINER (frame5), hbox1);
6620 button5 = gtk_button_new_with_label ("button5");
6621 gtk_box_pack_start (GTK_BOX (hbox1), button5, FALSE, FALSE, 0);
6623 button6 = gtk_button_new_with_label ("button6");
6624 gtk_box_pack_start (GTK_BOX (hbox1), button6, FALSE, FALSE, 0);
6626 frame3 = gtk_frame_new (NULL);
6627 gtk_paned_pack2 (GTK_PANED (vpaned1), frame3, TRUE, TRUE);
6628 gtk_frame_set_shadow_type (GTK_FRAME (frame3), GTK_SHADOW_IN);
6630 frame4 = gtk_frame_new ("Buttons");
6631 gtk_container_add (GTK_CONTAINER (frame3), frame4);
6632 gtk_container_set_border_width (GTK_CONTAINER (frame4), 15);
6634 table1 = gtk_table_new (2, 2, FALSE);
6635 gtk_container_add (GTK_CONTAINER (frame4), table1);
6636 gtk_container_set_border_width (GTK_CONTAINER (table1), 11);
6638 button1 = gtk_button_new_with_label ("button1");
6639 gtk_table_attach (GTK_TABLE (table1), button1, 0, 1, 0, 1,
6640 (GtkAttachOptions) (GTK_FILL),
6641 (GtkAttachOptions) (0), 0, 0);
6643 button2 = gtk_button_new_with_label ("button2");
6644 gtk_table_attach (GTK_TABLE (table1), button2, 1, 2, 0, 1,
6645 (GtkAttachOptions) (GTK_FILL),
6646 (GtkAttachOptions) (0), 0, 0);
6648 button3 = gtk_button_new_with_label ("button3");
6649 gtk_table_attach (GTK_TABLE (table1), button3, 0, 1, 1, 2,
6650 (GtkAttachOptions) (GTK_FILL),
6651 (GtkAttachOptions) (0), 0, 0);
6653 button4 = gtk_button_new_with_label ("button4");
6654 gtk_table_attach (GTK_TABLE (table1), button4, 1, 2, 1, 2,
6655 (GtkAttachOptions) (GTK_FILL),
6656 (GtkAttachOptions) (0), 0, 0);
6662 paned_keyboard_window2 (GtkWidget *widget)
6667 GtkWidget *button13;
6671 GtkWidget *button12;
6673 GtkWidget *button11;
6674 GtkWidget *button10;
6676 window2 = gtk_window_new (GTK_WINDOW_TOPLEVEL);
6677 gtk_window_set_title (GTK_WINDOW (window2), "\"button 10\" is not inside the horisontal pane");
6679 gtk_window_set_screen (GTK_WINDOW (window2),
6680 gtk_widget_get_screen (widget));
6682 hpaned2 = gtk_hpaned_new ();
6683 gtk_container_add (GTK_CONTAINER (window2), hpaned2);
6685 frame6 = gtk_frame_new (NULL);
6686 gtk_paned_pack1 (GTK_PANED (hpaned2), frame6, FALSE, TRUE);
6687 gtk_frame_set_shadow_type (GTK_FRAME (frame6), GTK_SHADOW_IN);
6689 button13 = gtk_button_new_with_label ("button13");
6690 gtk_container_add (GTK_CONTAINER (frame6), button13);
6692 hbox2 = gtk_hbox_new (FALSE, 0);
6693 gtk_paned_pack2 (GTK_PANED (hpaned2), hbox2, TRUE, TRUE);
6695 vpaned2 = gtk_vpaned_new ();
6696 gtk_box_pack_start (GTK_BOX (hbox2), vpaned2, TRUE, TRUE, 0);
6698 frame7 = gtk_frame_new (NULL);
6699 gtk_paned_pack1 (GTK_PANED (vpaned2), frame7, FALSE, TRUE);
6700 gtk_frame_set_shadow_type (GTK_FRAME (frame7), GTK_SHADOW_IN);
6702 button12 = gtk_button_new_with_label ("button12");
6703 gtk_container_add (GTK_CONTAINER (frame7), button12);
6705 frame8 = gtk_frame_new (NULL);
6706 gtk_paned_pack2 (GTK_PANED (vpaned2), frame8, TRUE, TRUE);
6707 gtk_frame_set_shadow_type (GTK_FRAME (frame8), GTK_SHADOW_IN);
6709 button11 = gtk_button_new_with_label ("button11");
6710 gtk_container_add (GTK_CONTAINER (frame8), button11);
6712 button10 = gtk_button_new_with_label ("button10");
6713 gtk_box_pack_start (GTK_BOX (hbox2), button10, FALSE, FALSE, 0);
6719 paned_keyboard_window3 (GtkWidget *widget)
6726 GtkWidget *button14;
6729 GtkWidget *button15;
6732 GtkWidget *button16;
6734 GtkWidget *button17;
6736 window3 = gtk_window_new (GTK_WINDOW_TOPLEVEL);
6737 g_object_set_data (G_OBJECT (window3), "window3", window3);
6738 gtk_window_set_title (GTK_WINDOW (window3), "Nested panes");
6740 gtk_window_set_screen (GTK_WINDOW (window3),
6741 gtk_widget_get_screen (widget));
6744 vbox2 = gtk_vbox_new (FALSE, 0);
6745 gtk_container_add (GTK_CONTAINER (window3), vbox2);
6747 label1 = gtk_label_new ("Three panes nested inside each other");
6748 gtk_box_pack_start (GTK_BOX (vbox2), label1, FALSE, FALSE, 0);
6750 hpaned3 = gtk_hpaned_new ();
6751 gtk_box_pack_start (GTK_BOX (vbox2), hpaned3, TRUE, TRUE, 0);
6753 frame9 = gtk_frame_new (NULL);
6754 gtk_paned_pack1 (GTK_PANED (hpaned3), frame9, FALSE, TRUE);
6755 gtk_frame_set_shadow_type (GTK_FRAME (frame9), GTK_SHADOW_IN);
6757 button14 = gtk_button_new_with_label ("button14");
6758 gtk_container_add (GTK_CONTAINER (frame9), button14);
6760 hpaned4 = gtk_hpaned_new ();
6761 gtk_paned_pack2 (GTK_PANED (hpaned3), hpaned4, TRUE, TRUE);
6763 frame10 = gtk_frame_new (NULL);
6764 gtk_paned_pack1 (GTK_PANED (hpaned4), frame10, FALSE, TRUE);
6765 gtk_frame_set_shadow_type (GTK_FRAME (frame10), GTK_SHADOW_IN);
6767 button15 = gtk_button_new_with_label ("button15");
6768 gtk_container_add (GTK_CONTAINER (frame10), button15);
6770 hpaned5 = gtk_hpaned_new ();
6771 gtk_paned_pack2 (GTK_PANED (hpaned4), hpaned5, TRUE, TRUE);
6773 frame11 = gtk_frame_new (NULL);
6774 gtk_paned_pack1 (GTK_PANED (hpaned5), frame11, FALSE, TRUE);
6775 gtk_frame_set_shadow_type (GTK_FRAME (frame11), GTK_SHADOW_IN);
6777 button16 = gtk_button_new_with_label ("button16");
6778 gtk_container_add (GTK_CONTAINER (frame11), button16);
6780 frame12 = gtk_frame_new (NULL);
6781 gtk_paned_pack2 (GTK_PANED (hpaned5), frame12, TRUE, TRUE);
6782 gtk_frame_set_shadow_type (GTK_FRAME (frame12), GTK_SHADOW_IN);
6784 button17 = gtk_button_new_with_label ("button17");
6785 gtk_container_add (GTK_CONTAINER (frame12), button17);
6791 paned_keyboard_window4 (GtkWidget *widget)
6798 GtkWidget *button19;
6799 GtkWidget *button18;
6802 GtkWidget *button21;
6803 GtkWidget *button20;
6805 GtkWidget *button23;
6806 GtkWidget *button22;
6808 GtkWidget *button25;
6809 GtkWidget *button24;
6811 window4 = gtk_window_new (GTK_WINDOW_TOPLEVEL);
6812 g_object_set_data (G_OBJECT (window4), "window4", window4);
6813 gtk_window_set_title (GTK_WINDOW (window4), "window4");
6815 gtk_window_set_screen (GTK_WINDOW (window4),
6816 gtk_widget_get_screen (widget));
6818 vbox3 = gtk_vbox_new (FALSE, 0);
6819 gtk_container_add (GTK_CONTAINER (window4), vbox3);
6821 label2 = gtk_label_new ("Widget tree:\n\nhpaned \n - vpaned\n - hbox\n - vpaned\n - vpaned\n - vpaned\n");
6822 gtk_box_pack_start (GTK_BOX (vbox3), label2, FALSE, FALSE, 0);
6823 gtk_label_set_justify (GTK_LABEL (label2), GTK_JUSTIFY_LEFT);
6825 hpaned6 = gtk_hpaned_new ();
6826 gtk_box_pack_start (GTK_BOX (vbox3), hpaned6, TRUE, TRUE, 0);
6828 vpaned3 = gtk_vpaned_new ();
6829 gtk_paned_pack1 (GTK_PANED (hpaned6), vpaned3, FALSE, TRUE);
6831 button19 = gtk_button_new_with_label ("button19");
6832 gtk_paned_pack1 (GTK_PANED (vpaned3), button19, FALSE, TRUE);
6834 button18 = gtk_button_new_with_label ("button18");
6835 gtk_paned_pack2 (GTK_PANED (vpaned3), button18, TRUE, TRUE);
6837 hbox3 = gtk_hbox_new (FALSE, 0);
6838 gtk_paned_pack2 (GTK_PANED (hpaned6), hbox3, TRUE, TRUE);
6840 vpaned4 = gtk_vpaned_new ();
6841 gtk_box_pack_start (GTK_BOX (hbox3), vpaned4, TRUE, TRUE, 0);
6843 button21 = gtk_button_new_with_label ("button21");
6844 gtk_paned_pack1 (GTK_PANED (vpaned4), button21, FALSE, TRUE);
6846 button20 = gtk_button_new_with_label ("button20");
6847 gtk_paned_pack2 (GTK_PANED (vpaned4), button20, TRUE, TRUE);
6849 vpaned5 = gtk_vpaned_new ();
6850 gtk_box_pack_start (GTK_BOX (hbox3), vpaned5, TRUE, TRUE, 0);
6852 button23 = gtk_button_new_with_label ("button23");
6853 gtk_paned_pack1 (GTK_PANED (vpaned5), button23, FALSE, TRUE);
6855 button22 = gtk_button_new_with_label ("button22");
6856 gtk_paned_pack2 (GTK_PANED (vpaned5), button22, TRUE, TRUE);
6858 vpaned6 = gtk_vpaned_new ();
6859 gtk_box_pack_start (GTK_BOX (hbox3), vpaned6, TRUE, TRUE, 0);
6861 button25 = gtk_button_new_with_label ("button25");
6862 gtk_paned_pack1 (GTK_PANED (vpaned6), button25, FALSE, TRUE);
6864 button24 = gtk_button_new_with_label ("button24");
6865 gtk_paned_pack2 (GTK_PANED (vpaned6), button24, TRUE, TRUE);
6871 create_paned_keyboard_navigation (GtkWidget *widget)
6873 static GtkWidget *window1 = NULL;
6874 static GtkWidget *window2 = NULL;
6875 static GtkWidget *window3 = NULL;
6876 static GtkWidget *window4 = NULL;
6879 (gtk_widget_get_screen (window1) != gtk_widget_get_screen (widget)))
6881 gtk_widget_destroy (window1);
6882 gtk_widget_destroy (window2);
6883 gtk_widget_destroy (window3);
6884 gtk_widget_destroy (window4);
6889 window1 = paned_keyboard_window1 (widget);
6890 g_signal_connect (window1, "destroy",
6891 G_CALLBACK (gtk_widget_destroyed),
6897 window2 = paned_keyboard_window2 (widget);
6898 g_signal_connect (window2, "destroy",
6899 G_CALLBACK (gtk_widget_destroyed),
6905 window3 = paned_keyboard_window3 (widget);
6906 g_signal_connect (window3, "destroy",
6907 G_CALLBACK (gtk_widget_destroyed),
6913 window4 = paned_keyboard_window4 (widget);
6914 g_signal_connect (window4, "destroy",
6915 G_CALLBACK (gtk_widget_destroyed),
6919 if (gtk_widget_get_visible (window1))
6920 gtk_widget_destroy (GTK_WIDGET (window1));
6922 gtk_widget_show_all (GTK_WIDGET (window1));
6924 if (gtk_widget_get_visible (window2))
6925 gtk_widget_destroy (GTK_WIDGET (window2));
6927 gtk_widget_show_all (GTK_WIDGET (window2));
6929 if (gtk_widget_get_visible (window3))
6930 gtk_widget_destroy (GTK_WIDGET (window3));
6932 gtk_widget_show_all (GTK_WIDGET (window3));
6934 if (gtk_widget_get_visible (window4))
6935 gtk_widget_destroy (GTK_WIDGET (window4));
6937 gtk_widget_show_all (GTK_WIDGET (window4));
6945 typedef struct _cursoroffset {gint x,y;} CursorOffset;
6948 shape_pressed (GtkWidget *widget, GdkEventButton *event)
6952 /* ignore double and triple click */
6953 if (event->type != GDK_BUTTON_PRESS)
6956 p = g_object_get_data (G_OBJECT (widget), "cursor_offset");
6957 p->x = (int) event->x;
6958 p->y = (int) event->y;
6960 gtk_grab_add (widget);
6961 gdk_pointer_grab (gtk_widget_get_window (widget), TRUE,
6962 GDK_BUTTON_RELEASE_MASK |
6963 GDK_BUTTON_MOTION_MASK |
6964 GDK_POINTER_MOTION_HINT_MASK,
6969 shape_released (GtkWidget *widget)
6971 gtk_grab_remove (widget);
6972 gdk_display_pointer_ungrab (gtk_widget_get_display (widget),
6977 shape_motion (GtkWidget *widget,
6978 GdkEventMotion *event)
6982 GdkModifierType mask;
6984 p = g_object_get_data (G_OBJECT (widget), "cursor_offset");
6987 * Can't use event->x / event->y here
6988 * because I need absolute coordinates.
6990 gdk_window_get_pointer (NULL, &xp, &yp, &mask);
6991 gtk_window_move (GTK_WINDOW (widget), xp - p->x, yp - p->y);
6995 shape_create_icon (GdkScreen *screen,
7006 CursorOffset* icon_pos;
7007 cairo_surface_t *mask;
7008 cairo_region_t *mask_region;
7013 * GDK_WINDOW_TOPLEVEL works also, giving you a title border
7015 window = gtk_window_new (window_type);
7016 gtk_window_set_screen (GTK_WINDOW (window), screen);
7018 fixed = gtk_fixed_new ();
7019 gtk_widget_set_size_request (fixed, 100, 100);
7020 gtk_container_add (GTK_CONTAINER (window), fixed);
7021 gtk_widget_show (fixed);
7023 gtk_widget_set_events (window,
7024 gtk_widget_get_events (window) |
7025 GDK_BUTTON_MOTION_MASK |
7026 GDK_POINTER_MOTION_HINT_MASK |
7027 GDK_BUTTON_PRESS_MASK);
7029 gtk_widget_realize (window);
7031 pixbuf = gdk_pixbuf_new_from_file (xpm_file, NULL);
7032 g_assert (pixbuf); /* FIXME: error handling */
7034 mask = cairo_image_surface_create (CAIRO_FORMAT_A1,
7035 gdk_pixbuf_get_width (pixbuf),
7036 gdk_pixbuf_get_height (pixbuf));
7037 cr = cairo_create (mask);
7038 gdk_cairo_set_source_pixbuf (cr, pixbuf, 0, 0);
7042 mask_region = gdk_cairo_region_create_from_surface (mask);
7044 cairo_region_translate (mask_region, px, py);
7046 image = gtk_image_new_from_pixbuf (pixbuf);
7047 gtk_fixed_put (GTK_FIXED (fixed), image, px,py);
7048 gtk_widget_show (image);
7050 gtk_widget_shape_combine_region (window, mask_region);
7052 cairo_region_destroy (mask_region);
7053 cairo_surface_destroy (mask);
7054 g_object_unref (pixbuf);
7056 g_signal_connect (window, "button_press_event",
7057 G_CALLBACK (shape_pressed), NULL);
7058 g_signal_connect (window, "button_release_event",
7059 G_CALLBACK (shape_released), NULL);
7060 g_signal_connect (window, "motion_notify_event",
7061 G_CALLBACK (shape_motion), NULL);
7063 icon_pos = g_new (CursorOffset, 1);
7064 g_object_set_data (G_OBJECT (window), "cursor_offset", icon_pos);
7066 gtk_window_move (GTK_WINDOW (window), x, y);
7067 gtk_widget_show (window);
7073 create_shapes (GtkWidget *widget)
7075 /* Variables used by the Drag/Drop and Shape Window demos */
7076 static GtkWidget *modeller = NULL;
7077 static GtkWidget *sheets = NULL;
7078 static GtkWidget *rings = NULL;
7079 static GtkWidget *with_region = NULL;
7080 GdkScreen *screen = gtk_widget_get_screen (widget);
7082 if (!(file_exists ("Modeller.xpm") &&
7083 file_exists ("FilesQueue.xpm") &&
7084 file_exists ("3DRings.xpm")))
7090 modeller = shape_create_icon (screen, "Modeller.xpm",
7091 440, 140, 0,0, GTK_WINDOW_POPUP);
7093 g_signal_connect (modeller, "destroy",
7094 G_CALLBACK (gtk_widget_destroyed),
7098 gtk_widget_destroy (modeller);
7102 sheets = shape_create_icon (screen, "FilesQueue.xpm",
7103 580, 170, 0,0, GTK_WINDOW_POPUP);
7105 g_signal_connect (sheets, "destroy",
7106 G_CALLBACK (gtk_widget_destroyed),
7111 gtk_widget_destroy (sheets);
7115 rings = shape_create_icon (screen, "3DRings.xpm",
7116 460, 270, 25,25, GTK_WINDOW_TOPLEVEL);
7118 g_signal_connect (rings, "destroy",
7119 G_CALLBACK (gtk_widget_destroyed),
7123 gtk_widget_destroy (rings);
7127 cairo_region_t *region;
7130 with_region = shape_create_icon (screen, "3DRings.xpm",
7131 460, 270, 25,25, GTK_WINDOW_TOPLEVEL);
7133 gtk_window_set_decorated (GTK_WINDOW (with_region), FALSE);
7135 g_signal_connect (with_region, "destroy",
7136 G_CALLBACK (gtk_widget_destroyed),
7139 /* reset shape from mask to a region */
7142 region = cairo_region_create ();
7154 cairo_region_union_rectangle (region, &rect);
7162 gdk_window_shape_combine_region (gtk_widget_get_window (with_region),
7167 gtk_widget_destroy (with_region);
7175 create_wmhints (GtkWidget *widget)
7177 static GtkWidget *window = NULL;
7179 GtkWidget *separator;
7183 GdkWindow *gdk_window;
7189 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
7191 gtk_window_set_screen (GTK_WINDOW (window),
7192 gtk_widget_get_screen (widget));
7194 g_signal_connect (window, "destroy",
7195 G_CALLBACK (gtk_widget_destroyed),
7198 gtk_window_set_title (GTK_WINDOW (window), "WM Hints");
7199 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
7201 gtk_widget_realize (window);
7203 gdk_window = gtk_widget_get_window (window);
7205 pixbuf = gdk_pixbuf_new_from_xpm_data ((const char **) openfile);
7206 list = g_list_prepend (NULL, pixbuf);
7208 gdk_window_set_icon_list (gdk_window, list);
7211 g_object_unref (pixbuf);
7213 gdk_window_set_icon_name (gdk_window, "WMHints Test Icon");
7215 gdk_window_set_decorations (gdk_window, GDK_DECOR_ALL | GDK_DECOR_MENU);
7216 gdk_window_set_functions (gdk_window, GDK_FUNC_ALL | GDK_FUNC_RESIZE);
7218 box1 = gtk_vbox_new (FALSE, 0);
7219 gtk_container_add (GTK_CONTAINER (window), box1);
7220 gtk_widget_show (box1);
7222 label = gtk_label_new ("Try iconizing me!");
7223 gtk_widget_set_size_request (label, 150, 50);
7224 gtk_box_pack_start (GTK_BOX (box1), label, TRUE, TRUE, 0);
7225 gtk_widget_show (label);
7228 separator = gtk_hseparator_new ();
7229 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
7230 gtk_widget_show (separator);
7233 box2 = gtk_vbox_new (FALSE, 10);
7234 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
7235 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
7236 gtk_widget_show (box2);
7239 button = gtk_button_new_with_label ("close");
7241 g_signal_connect_swapped (button, "clicked",
7242 G_CALLBACK (gtk_widget_destroy),
7245 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
7246 gtk_widget_set_can_default (button, TRUE);
7247 gtk_widget_grab_default (button);
7248 gtk_widget_show (button);
7251 if (!gtk_widget_get_visible (window))
7252 gtk_widget_show (window);
7254 gtk_widget_destroy (window);
7259 * Window state tracking
7263 window_state_callback (GtkWidget *widget,
7264 GdkEventWindowState *event,
7267 GtkWidget *label = data;
7270 msg = g_strconcat (gtk_window_get_title (GTK_WINDOW (widget)), ": ",
7271 (event->new_window_state & GDK_WINDOW_STATE_WITHDRAWN) ?
7272 "withdrawn" : "not withdrawn", ", ",
7273 (event->new_window_state & GDK_WINDOW_STATE_ICONIFIED) ?
7274 "iconified" : "not iconified", ", ",
7275 (event->new_window_state & GDK_WINDOW_STATE_STICKY) ?
7276 "sticky" : "not sticky", ", ",
7277 (event->new_window_state & GDK_WINDOW_STATE_MAXIMIZED) ?
7278 "maximized" : "not maximized", ", ",
7279 (event->new_window_state & GDK_WINDOW_STATE_FULLSCREEN) ?
7280 "fullscreen" : "not fullscreen",
7281 (event->new_window_state & GDK_WINDOW_STATE_ABOVE) ?
7282 "above" : "not above", ", ",
7283 (event->new_window_state & GDK_WINDOW_STATE_BELOW) ?
7284 "below" : "not below", ", ",
7287 gtk_label_set_text (GTK_LABEL (label), msg);
7295 tracking_label (GtkWidget *window)
7301 hbox = gtk_hbox_new (FALSE, 5);
7303 g_signal_connect_object (hbox,
7305 G_CALLBACK (gtk_widget_destroy),
7309 label = gtk_label_new ("<no window state events received>");
7310 gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
7311 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
7313 g_signal_connect (window,
7314 "window_state_event",
7315 G_CALLBACK (window_state_callback),
7318 button = gtk_button_new_with_label ("Deiconify");
7319 g_signal_connect_object (button,
7321 G_CALLBACK (gtk_window_deiconify),
7324 gtk_box_pack_end (GTK_BOX (hbox), button, FALSE, FALSE, 0);
7326 button = gtk_button_new_with_label ("Iconify");
7327 g_signal_connect_object (button,
7329 G_CALLBACK (gtk_window_iconify),
7332 gtk_box_pack_end (GTK_BOX (hbox), button, FALSE, FALSE, 0);
7334 button = gtk_button_new_with_label ("Fullscreen");
7335 g_signal_connect_object (button,
7337 G_CALLBACK (gtk_window_fullscreen),
7340 gtk_box_pack_end (GTK_BOX (hbox), button, FALSE, FALSE, 0);
7342 button = gtk_button_new_with_label ("Unfullscreen");
7343 g_signal_connect_object (button,
7345 G_CALLBACK (gtk_window_unfullscreen),
7348 gtk_box_pack_end (GTK_BOX (hbox), button, FALSE, FALSE, 0);
7350 button = gtk_button_new_with_label ("Present");
7351 g_signal_connect_object (button,
7353 G_CALLBACK (gtk_window_present),
7356 gtk_box_pack_end (GTK_BOX (hbox), button, FALSE, FALSE, 0);
7358 button = gtk_button_new_with_label ("Show");
7359 g_signal_connect_object (button,
7361 G_CALLBACK (gtk_widget_show),
7364 gtk_box_pack_end (GTK_BOX (hbox), button, FALSE, FALSE, 0);
7366 gtk_widget_show_all (hbox);
7372 keep_window_above (GtkToggleButton *togglebutton, gpointer data)
7374 GtkWidget *button = g_object_get_data (G_OBJECT (togglebutton), "radio");
7376 gtk_window_set_keep_above (GTK_WINDOW (data),
7377 gtk_toggle_button_get_active (togglebutton));
7379 if (gtk_toggle_button_get_active (togglebutton))
7380 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), FALSE);
7384 keep_window_below (GtkToggleButton *togglebutton, gpointer data)
7386 GtkWidget *button = g_object_get_data (G_OBJECT (togglebutton), "radio");
7388 gtk_window_set_keep_below (GTK_WINDOW (data),
7389 gtk_toggle_button_get_active (togglebutton));
7391 if (gtk_toggle_button_get_active (togglebutton))
7392 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), FALSE);
7397 get_state_controls (GtkWidget *window)
7401 GtkWidget *button_above;
7402 GtkWidget *button_below;
7404 vbox = gtk_vbox_new (FALSE, 0);
7406 button = gtk_button_new_with_label ("Stick");
7407 g_signal_connect_object (button,
7409 G_CALLBACK (gtk_window_stick),
7412 gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
7414 button = gtk_button_new_with_label ("Unstick");
7415 g_signal_connect_object (button,
7417 G_CALLBACK (gtk_window_unstick),
7420 gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
7422 button = gtk_button_new_with_label ("Maximize");
7423 g_signal_connect_object (button,
7425 G_CALLBACK (gtk_window_maximize),
7428 gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
7430 button = gtk_button_new_with_label ("Unmaximize");
7431 g_signal_connect_object (button,
7433 G_CALLBACK (gtk_window_unmaximize),
7436 gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
7438 button = gtk_button_new_with_label ("Iconify");
7439 g_signal_connect_object (button,
7441 G_CALLBACK (gtk_window_iconify),
7444 gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
7446 button = gtk_button_new_with_label ("Fullscreen");
7447 g_signal_connect_object (button,
7449 G_CALLBACK (gtk_window_fullscreen),
7452 gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
7454 button = gtk_button_new_with_label ("Unfullscreen");
7455 g_signal_connect_object (button,
7457 G_CALLBACK (gtk_window_unfullscreen),
7460 gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
7462 button_above = gtk_toggle_button_new_with_label ("Keep above");
7463 g_signal_connect (button_above,
7465 G_CALLBACK (keep_window_above),
7467 gtk_box_pack_start (GTK_BOX (vbox), button_above, FALSE, FALSE, 0);
7469 button_below = gtk_toggle_button_new_with_label ("Keep below");
7470 g_signal_connect (button_below,
7472 G_CALLBACK (keep_window_below),
7474 gtk_box_pack_start (GTK_BOX (vbox), button_below, FALSE, FALSE, 0);
7476 g_object_set_data (G_OBJECT (button_above), "radio", button_below);
7477 g_object_set_data (G_OBJECT (button_below), "radio", button_above);
7479 button = gtk_button_new_with_label ("Hide (withdraw)");
7480 g_signal_connect_object (button,
7482 G_CALLBACK (gtk_widget_hide),
7485 gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
7487 gtk_widget_show_all (vbox);
7493 create_window_states (GtkWidget *widget)
7495 static GtkWidget *window = NULL;
7498 GtkWidget *iconified;
7500 GtkWidget *controls;
7504 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
7505 gtk_window_set_screen (GTK_WINDOW (window),
7506 gtk_widget_get_screen (widget));
7508 g_signal_connect (window, "destroy",
7509 G_CALLBACK (gtk_widget_destroyed),
7512 gtk_window_set_title (GTK_WINDOW (window), "Window states");
7514 box1 = gtk_vbox_new (FALSE, 0);
7515 gtk_container_add (GTK_CONTAINER (window), box1);
7517 iconified = gtk_window_new (GTK_WINDOW_TOPLEVEL);
7519 gtk_window_set_screen (GTK_WINDOW (iconified),
7520 gtk_widget_get_screen (widget));
7522 g_signal_connect_object (iconified, "destroy",
7523 G_CALLBACK (gtk_widget_destroy),
7526 gtk_window_iconify (GTK_WINDOW (iconified));
7527 gtk_window_set_title (GTK_WINDOW (iconified), "Iconified initially");
7528 controls = get_state_controls (iconified);
7529 gtk_container_add (GTK_CONTAINER (iconified), controls);
7531 normal = gtk_window_new (GTK_WINDOW_TOPLEVEL);
7533 gtk_window_set_screen (GTK_WINDOW (normal),
7534 gtk_widget_get_screen (widget));
7536 g_signal_connect_object (normal, "destroy",
7537 G_CALLBACK (gtk_widget_destroy),
7541 gtk_window_set_title (GTK_WINDOW (normal), "Deiconified initially");
7542 controls = get_state_controls (normal);
7543 gtk_container_add (GTK_CONTAINER (normal), controls);
7545 label = tracking_label (iconified);
7546 gtk_container_add (GTK_CONTAINER (box1), label);
7548 label = tracking_label (normal);
7549 gtk_container_add (GTK_CONTAINER (box1), label);
7551 gtk_widget_show_all (iconified);
7552 gtk_widget_show_all (normal);
7553 gtk_widget_show_all (box1);
7556 if (!gtk_widget_get_visible (window))
7557 gtk_widget_show (window);
7559 gtk_widget_destroy (window);
7567 configure_event_callback (GtkWidget *widget,
7568 GdkEventConfigure *event,
7571 GtkWidget *label = data;
7575 gtk_window_get_position (GTK_WINDOW (widget), &x, &y);
7577 msg = g_strdup_printf ("event: %d,%d %d x %d\n"
7579 event->x, event->y, event->width, event->height,
7582 gtk_label_set_text (GTK_LABEL (label), msg);
7590 get_ints (GtkWidget *window,
7597 spin1 = g_object_get_data (G_OBJECT (window), "spin1");
7598 spin2 = g_object_get_data (G_OBJECT (window), "spin2");
7600 *a = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (spin1));
7601 *b = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (spin2));
7605 set_size_callback (GtkWidget *widget,
7610 get_ints (data, &w, &h);
7612 gtk_window_resize (GTK_WINDOW (g_object_get_data (data, "target")), w, h);
7616 unset_default_size_callback (GtkWidget *widget,
7619 gtk_window_set_default_size (g_object_get_data (data, "target"),
7624 set_default_size_callback (GtkWidget *widget,
7629 get_ints (data, &w, &h);
7631 gtk_window_set_default_size (g_object_get_data (data, "target"),
7636 unset_size_request_callback (GtkWidget *widget,
7639 gtk_widget_set_size_request (g_object_get_data (data, "target"),
7644 set_size_request_callback (GtkWidget *widget,
7649 get_ints (data, &w, &h);
7651 gtk_widget_set_size_request (g_object_get_data (data, "target"),
7656 set_location_callback (GtkWidget *widget,
7661 get_ints (data, &x, &y);
7663 gtk_window_move (g_object_get_data (data, "target"), x, y);
7667 move_to_position_callback (GtkWidget *widget,
7673 window = g_object_get_data (data, "target");
7675 gtk_window_get_position (window, &x, &y);
7677 gtk_window_move (window, x, y);
7681 set_geometry_callback (GtkWidget *entry,
7687 target = GTK_WINDOW (g_object_get_data (G_OBJECT (data), "target"));
7689 text = gtk_editable_get_chars (GTK_EDITABLE (entry), 0, -1);
7691 if (!gtk_window_parse_geometry (target, text))
7692 g_print ("Bad geometry string '%s'\n", text);
7698 resizable_callback (GtkWidget *widget,
7701 g_object_set (g_object_get_data (data, "target"),
7702 "resizable", GTK_TOGGLE_BUTTON (widget)->active,
7707 gravity_selected (GtkWidget *widget,
7710 gtk_window_set_gravity (GTK_WINDOW (g_object_get_data (data, "target")),
7711 gtk_combo_box_get_active (GTK_COMBO_BOX (widget)) + GDK_GRAVITY_NORTH_WEST);
7715 pos_selected (GtkWidget *widget,
7718 gtk_window_set_position (GTK_WINDOW (g_object_get_data (data, "target")),
7719 gtk_combo_box_get_active (GTK_COMBO_BOX (widget)) + GTK_WIN_POS_NONE);
7723 move_gravity_window_to_current_position (GtkWidget *widget,
7729 window = GTK_WINDOW (data);
7731 gtk_window_get_position (window, &x, &y);
7733 gtk_window_move (window, x, y);
7737 get_screen_corner (GtkWindow *window,
7742 GdkScreen * screen = gtk_window_get_screen (window);
7744 gtk_window_get_size (GTK_WINDOW (window), &w, &h);
7746 switch (gtk_window_get_gravity (window))
7748 case GDK_GRAVITY_SOUTH_EAST:
7749 *x = gdk_screen_get_width (screen) - w;
7750 *y = gdk_screen_get_height (screen) - h;
7753 case GDK_GRAVITY_NORTH_EAST:
7754 *x = gdk_screen_get_width (screen) - w;
7758 case GDK_GRAVITY_SOUTH_WEST:
7760 *y = gdk_screen_get_height (screen) - h;
7763 case GDK_GRAVITY_NORTH_WEST:
7768 case GDK_GRAVITY_SOUTH:
7769 *x = (gdk_screen_get_width (screen) - w) / 2;
7770 *y = gdk_screen_get_height (screen) - h;
7773 case GDK_GRAVITY_NORTH:
7774 *x = (gdk_screen_get_width (screen) - w) / 2;
7778 case GDK_GRAVITY_WEST:
7780 *y = (gdk_screen_get_height (screen) - h) / 2;
7783 case GDK_GRAVITY_EAST:
7784 *x = gdk_screen_get_width (screen) - w;
7785 *y = (gdk_screen_get_height (screen) - h) / 2;
7788 case GDK_GRAVITY_CENTER:
7789 *x = (gdk_screen_get_width (screen) - w) / 2;
7790 *y = (gdk_screen_get_height (screen) - h) / 2;
7793 case GDK_GRAVITY_STATIC:
7794 /* pick some random numbers */
7800 g_assert_not_reached ();
7806 move_gravity_window_to_starting_position (GtkWidget *widget,
7812 window = GTK_WINDOW (data);
7814 get_screen_corner (window,
7817 gtk_window_move (window, x, y);
7821 make_gravity_window (GtkWidget *destroy_with,
7830 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
7832 gtk_window_set_screen (GTK_WINDOW (window),
7833 gtk_widget_get_screen (destroy_with));
7835 vbox = gtk_vbox_new (FALSE, 0);
7836 gtk_widget_show (vbox);
7838 gtk_container_add (GTK_CONTAINER (window), vbox);
7839 gtk_window_set_title (GTK_WINDOW (window), title);
7840 gtk_window_set_gravity (GTK_WINDOW (window), gravity);
7842 g_signal_connect_object (destroy_with,
7844 G_CALLBACK (gtk_widget_destroy),
7849 button = gtk_button_new_with_mnemonic ("_Move to current position");
7851 g_signal_connect (button, "clicked",
7852 G_CALLBACK (move_gravity_window_to_current_position),
7855 gtk_container_add (GTK_CONTAINER (vbox), button);
7856 gtk_widget_show (button);
7858 button = gtk_button_new_with_mnemonic ("Move to _starting position");
7860 g_signal_connect (button, "clicked",
7861 G_CALLBACK (move_gravity_window_to_starting_position),
7864 gtk_container_add (GTK_CONTAINER (vbox), button);
7865 gtk_widget_show (button);
7867 /* Pretend this is the result of --geometry.
7868 * DO NOT COPY THIS CODE unless you are setting --geometry results,
7869 * and in that case you probably should just use gtk_window_parse_geometry().
7870 * AGAIN, DO NOT SET GDK_HINT_USER_POS! It violates the ICCCM unless
7871 * you are parsing --geometry or equivalent.
7873 gtk_window_set_geometry_hints (GTK_WINDOW (window),
7877 gtk_window_set_default_size (GTK_WINDOW (window),
7880 get_screen_corner (GTK_WINDOW (window), &x, &y);
7882 gtk_window_move (GTK_WINDOW (window),
7889 do_gravity_test (GtkWidget *widget,
7892 GtkWidget *destroy_with = data;
7895 /* We put a window at each gravity point on the screen. */
7896 window = make_gravity_window (destroy_with, GDK_GRAVITY_NORTH_WEST,
7898 gtk_widget_show (window);
7900 window = make_gravity_window (destroy_with, GDK_GRAVITY_SOUTH_EAST,
7902 gtk_widget_show (window);
7904 window = make_gravity_window (destroy_with, GDK_GRAVITY_NORTH_EAST,
7906 gtk_widget_show (window);
7908 window = make_gravity_window (destroy_with, GDK_GRAVITY_SOUTH_WEST,
7910 gtk_widget_show (window);
7912 window = make_gravity_window (destroy_with, GDK_GRAVITY_SOUTH,
7914 gtk_widget_show (window);
7916 window = make_gravity_window (destroy_with, GDK_GRAVITY_NORTH,
7918 gtk_widget_show (window);
7921 window = make_gravity_window (destroy_with, GDK_GRAVITY_WEST,
7923 gtk_widget_show (window);
7926 window = make_gravity_window (destroy_with, GDK_GRAVITY_EAST,
7928 gtk_widget_show (window);
7930 window = make_gravity_window (destroy_with, GDK_GRAVITY_CENTER,
7932 gtk_widget_show (window);
7934 window = make_gravity_window (destroy_with, GDK_GRAVITY_STATIC,
7936 gtk_widget_show (window);
7940 window_controls (GtkWidget *window)
7942 GtkWidget *control_window;
7952 control_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
7954 gtk_window_set_screen (GTK_WINDOW (control_window),
7955 gtk_widget_get_screen (window));
7957 gtk_window_set_title (GTK_WINDOW (control_window), "Size controls");
7959 g_object_set_data (G_OBJECT (control_window),
7963 g_signal_connect_object (control_window,
7965 G_CALLBACK (gtk_widget_destroy),
7969 vbox = gtk_vbox_new (FALSE, 5);
7971 gtk_container_add (GTK_CONTAINER (control_window), vbox);
7973 label = gtk_label_new ("<no configure events>");
7974 gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
7976 g_signal_connect (window,
7978 G_CALLBACK (configure_event_callback),
7981 adj = gtk_adjustment_new (10.0, -2000.0, 2000.0, 1.0, 5.0, 0.0);
7982 spin = gtk_spin_button_new (adj, 0, 0);
7984 gtk_box_pack_start (GTK_BOX (vbox), spin, FALSE, FALSE, 0);
7986 g_object_set_data (G_OBJECT (control_window), "spin1", spin);
7988 adj = gtk_adjustment_new (10.0, -2000.0, 2000.0, 1.0, 5.0, 0.0);
7989 spin = gtk_spin_button_new (adj, 0, 0);
7991 gtk_box_pack_start (GTK_BOX (vbox), spin, FALSE, FALSE, 0);
7993 g_object_set_data (G_OBJECT (control_window), "spin2", spin);
7995 entry = gtk_entry_new ();
7996 gtk_box_pack_start (GTK_BOX (vbox), entry, FALSE, FALSE, 0);
7998 g_signal_connect (entry, "changed",
7999 G_CALLBACK (set_geometry_callback),
8002 button = gtk_button_new_with_label ("Show gravity test windows");
8003 g_signal_connect_swapped (button,
8005 G_CALLBACK (do_gravity_test),
8007 gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
8009 button = gtk_button_new_with_label ("Reshow with initial size");
8010 g_signal_connect_object (button,
8012 G_CALLBACK (gtk_window_reshow_with_initial_size),
8015 gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
8017 button = gtk_button_new_with_label ("Queue resize");
8018 g_signal_connect_object (button,
8020 G_CALLBACK (gtk_widget_queue_resize),
8023 gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
8025 button = gtk_button_new_with_label ("Resize");
8026 g_signal_connect (button,
8028 G_CALLBACK (set_size_callback),
8030 gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
8032 button = gtk_button_new_with_label ("Set default size");
8033 g_signal_connect (button,
8035 G_CALLBACK (set_default_size_callback),
8037 gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
8039 button = gtk_button_new_with_label ("Unset default size");
8040 g_signal_connect (button,
8042 G_CALLBACK (unset_default_size_callback),
8044 gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
8046 button = gtk_button_new_with_label ("Set size request");
8047 g_signal_connect (button,
8049 G_CALLBACK (set_size_request_callback),
8051 gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
8053 button = gtk_button_new_with_label ("Unset size request");
8054 g_signal_connect (button,
8056 G_CALLBACK (unset_size_request_callback),
8058 gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
8060 button = gtk_button_new_with_label ("Move");
8061 g_signal_connect (button,
8063 G_CALLBACK (set_location_callback),
8065 gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
8067 button = gtk_button_new_with_label ("Move to current position");
8068 g_signal_connect (button,
8070 G_CALLBACK (move_to_position_callback),
8072 gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
8074 button = gtk_check_button_new_with_label ("Allow resize");
8075 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
8076 g_signal_connect (button,
8078 G_CALLBACK (resizable_callback),
8080 gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
8082 button = gtk_button_new_with_mnemonic ("_Show");
8083 g_signal_connect_object (button,
8085 G_CALLBACK (gtk_widget_show),
8088 gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
8090 button = gtk_button_new_with_mnemonic ("_Hide");
8091 g_signal_connect_object (button,
8093 G_CALLBACK (gtk_widget_hide),
8096 gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
8098 om = gtk_combo_box_new_text ();
8102 static gchar *names[] = {
8103 "GDK_GRAVITY_NORTH_WEST",
8104 "GDK_GRAVITY_NORTH",
8105 "GDK_GRAVITY_NORTH_EAST",
8107 "GDK_GRAVITY_CENTER",
8109 "GDK_GRAVITY_SOUTH_WEST",
8110 "GDK_GRAVITY_SOUTH",
8111 "GDK_GRAVITY_SOUTH_EAST",
8112 "GDK_GRAVITY_STATIC",
8116 g_assert (names[i]);
8117 gtk_combo_box_append_text (GTK_COMBO_BOX (om), names[i]);
8122 g_signal_connect (om,
8124 G_CALLBACK (gravity_selected),
8127 gtk_box_pack_end (GTK_BOX (vbox), om, FALSE, FALSE, 0);
8130 om = gtk_combo_box_new_text ();
8134 static gchar *names[] = {
8136 "GTK_WIN_POS_CENTER",
8137 "GTK_WIN_POS_MOUSE",
8138 "GTK_WIN_POS_CENTER_ALWAYS",
8139 "GTK_WIN_POS_CENTER_ON_PARENT",
8143 g_assert (names[i]);
8144 gtk_combo_box_append_text (GTK_COMBO_BOX (om), names[i]);
8149 g_signal_connect (om,
8151 G_CALLBACK (pos_selected),
8154 gtk_box_pack_end (GTK_BOX (vbox), om, FALSE, FALSE, 0);
8156 gtk_widget_show_all (vbox);
8158 return control_window;
8162 create_window_sizing (GtkWidget *widget)
8164 static GtkWidget *window = NULL;
8165 static GtkWidget *target_window = NULL;
8171 target_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
8172 gtk_window_set_screen (GTK_WINDOW (target_window),
8173 gtk_widget_get_screen (widget));
8174 label = gtk_label_new (NULL);
8175 gtk_label_set_markup (GTK_LABEL (label), "<span foreground=\"purple\"><big>Window being resized</big></span>\nBlah blah blah blah\nblah blah blah\nblah blah blah blah blah");
8176 gtk_container_add (GTK_CONTAINER (target_window), label);
8177 gtk_widget_show (label);
8179 g_signal_connect (target_window, "destroy",
8180 G_CALLBACK (gtk_widget_destroyed),
8183 window = window_controls (target_window);
8185 g_signal_connect (window, "destroy",
8186 G_CALLBACK (gtk_widget_destroyed),
8189 gtk_window_set_title (GTK_WINDOW (target_window), "Window to size");
8192 /* don't show target window by default, we want to allow testing
8193 * of behavior on first show.
8196 if (!gtk_widget_get_visible (window))
8197 gtk_widget_show (window);
8199 gtk_widget_destroy (window);
8206 typedef struct _ProgressData {
8209 GtkWidget *block_spin;
8210 GtkWidget *x_align_spin;
8211 GtkWidget *y_align_spin;
8212 GtkWidget *step_spin;
8213 GtkWidget *act_blocks_spin;
8224 progress_timeout (gpointer data)
8226 ProgressData *pdata = data;
8230 if (pdata->activity)
8232 gtk_progress_bar_pulse (GTK_PROGRESS_BAR (pdata->pbar));
8234 text = g_strdup_printf ("%s", "???");
8238 new_val = gtk_progress_bar_get_fraction (GTK_PROGRESS_BAR (pdata->pbar)) + 0.01;
8241 gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR (pdata->pbar), new_val);
8243 text = g_strdup_printf ("%.0f%%", 100 * new_val);
8246 gtk_label_set_text (GTK_LABEL (pdata->label), text);
8253 destroy_progress (GtkWidget *widget,
8254 ProgressData **pdata)
8256 g_source_remove ((*pdata)->timer);
8257 (*pdata)->timer = 0;
8258 (*pdata)->window = NULL;
8264 progressbar_toggle_orientation (GtkWidget *widget, gpointer data)
8266 ProgressData *pdata;
8269 pdata = (ProgressData *) data;
8271 if (!gtk_widget_get_mapped (widget))
8274 i = gtk_combo_box_get_active (GTK_COMBO_BOX (widget));
8276 if (i == 0 || i == 1)
8277 gtk_orientable_set_orientation (GTK_ORIENTABLE (pdata->pbar), GTK_ORIENTATION_HORIZONTAL);
8279 gtk_orientable_set_orientation (GTK_ORIENTABLE (pdata->pbar), GTK_ORIENTATION_VERTICAL);
8281 if (i == 1 || i == 2)
8282 gtk_progress_bar_set_inverted (GTK_PROGRESS_BAR (pdata->pbar), TRUE);
8284 gtk_progress_bar_set_inverted (GTK_PROGRESS_BAR (pdata->pbar), FALSE);
8288 toggle_show_text (GtkWidget *widget, ProgressData *pdata)
8292 active = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget));
8293 gtk_progress_bar_set_show_text (GTK_PROGRESS_BAR (pdata->pbar), active);
8297 progressbar_toggle_ellipsize (GtkWidget *widget,
8300 ProgressData *pdata = data;
8301 if (gtk_widget_is_drawable (widget))
8303 gint i = gtk_combo_box_get_active (GTK_COMBO_BOX (widget));
8304 gtk_progress_bar_set_ellipsize (GTK_PROGRESS_BAR (pdata->pbar), i);
8309 toggle_activity_mode (GtkWidget *widget, ProgressData *pdata)
8311 pdata->activity = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget));
8315 entry_changed (GtkWidget *widget, ProgressData *pdata)
8317 gtk_progress_bar_set_text (GTK_PROGRESS_BAR (pdata->pbar),
8318 gtk_entry_get_text (GTK_ENTRY (pdata->entry)));
8322 create_progress_bar (GtkWidget *widget)
8324 GtkWidget *action_area, *content_area;
8334 static ProgressData *pdata = NULL;
8336 static gchar *items1[] =
8344 static char *ellipsize_items[] = {
8345 "None", // PANGO_ELLIPSIZE_NONE,
8346 "Start", // PANGO_ELLIPSIZE_START,
8347 "Middle", // PANGO_ELLIPSIZE_MIDDLE,
8348 "End", // PANGO_ELLIPSIZE_END
8352 pdata = g_new0 (ProgressData, 1);
8356 pdata->window = gtk_dialog_new ();
8358 gtk_window_set_screen (GTK_WINDOW (pdata->window),
8359 gtk_widget_get_screen (widget));
8361 gtk_window_set_resizable (GTK_WINDOW (pdata->window), TRUE);
8363 g_signal_connect (pdata->window, "destroy",
8364 G_CALLBACK (destroy_progress),
8368 content_area = gtk_dialog_get_content_area (GTK_DIALOG (pdata->window));
8369 action_area = gtk_dialog_get_action_area (GTK_DIALOG (pdata->window));
8371 gtk_window_set_title (GTK_WINDOW (pdata->window), "GtkProgressBar");
8372 gtk_container_set_border_width (GTK_CONTAINER (pdata->window), 0);
8374 vbox = gtk_vbox_new (FALSE, 5);
8375 gtk_container_set_border_width (GTK_CONTAINER (vbox), 10);
8376 gtk_box_pack_start (GTK_BOX (content_area), vbox, FALSE, TRUE, 0);
8378 frame = gtk_frame_new ("Progress");
8379 gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, TRUE, 0);
8381 vbox2 = gtk_vbox_new (FALSE, 5);
8382 gtk_container_add (GTK_CONTAINER (frame), vbox2);
8384 align = gtk_alignment_new (0.5, 0.5, 0, 0);
8385 gtk_box_pack_start (GTK_BOX (vbox2), align, FALSE, FALSE, 5);
8387 pdata->pbar = gtk_progress_bar_new ();
8388 gtk_progress_bar_set_ellipsize (GTK_PROGRESS_BAR (pdata->pbar),
8389 PANGO_ELLIPSIZE_MIDDLE);
8391 gtk_container_add (GTK_CONTAINER (align), pdata->pbar);
8392 pdata->timer = g_timeout_add (100, (GSourceFunc)progress_timeout, pdata);
8394 align = gtk_alignment_new (0.5, 0.5, 0, 0);
8395 gtk_box_pack_start (GTK_BOX (vbox2), align, FALSE, FALSE, 5);
8397 hbox = gtk_hbox_new (FALSE, 5);
8398 gtk_container_add (GTK_CONTAINER (align), hbox);
8399 label = gtk_label_new ("Label updated by user :");
8400 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
8401 pdata->label = gtk_label_new ("");
8402 gtk_box_pack_start (GTK_BOX (hbox), pdata->label, FALSE, TRUE, 0);
8404 frame = gtk_frame_new ("Options");
8405 gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, TRUE, 0);
8407 vbox2 = gtk_vbox_new (FALSE, 5);
8408 gtk_container_add (GTK_CONTAINER (frame), vbox2);
8410 tab = gtk_table_new (7, 2, FALSE);
8411 gtk_box_pack_start (GTK_BOX (vbox2), tab, FALSE, TRUE, 0);
8413 label = gtk_label_new ("Orientation :");
8414 gtk_table_attach (GTK_TABLE (tab), label, 0, 1, 0, 1,
8415 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
8417 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
8419 pdata->omenu1 = build_option_menu (items1, 4, 0,
8420 progressbar_toggle_orientation,
8422 hbox = gtk_hbox_new (FALSE, 0);
8423 gtk_table_attach (GTK_TABLE (tab), hbox, 1, 2, 0, 1,
8424 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
8426 gtk_box_pack_start (GTK_BOX (hbox), pdata->omenu1, TRUE, TRUE, 0);
8428 check = gtk_check_button_new_with_label ("Show text");
8429 g_signal_connect (check, "clicked",
8430 G_CALLBACK (toggle_show_text),
8432 gtk_table_attach (GTK_TABLE (tab), check, 0, 1, 1, 2,
8433 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
8436 hbox = gtk_hbox_new (FALSE, 0);
8437 gtk_table_attach (GTK_TABLE (tab), hbox, 1, 2, 1, 2,
8438 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
8441 label = gtk_label_new ("Text: ");
8442 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
8444 pdata->entry = gtk_entry_new ();
8445 g_signal_connect (pdata->entry, "changed",
8446 G_CALLBACK (entry_changed),
8448 gtk_box_pack_start (GTK_BOX (hbox), pdata->entry, TRUE, TRUE, 0);
8449 gtk_widget_set_size_request (pdata->entry, 100, -1);
8451 label = gtk_label_new ("Ellipsize text :");
8452 gtk_table_attach (GTK_TABLE (tab), label, 0, 1, 10, 11,
8453 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
8455 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
8456 pdata->elmenu = build_option_menu (ellipsize_items,
8457 sizeof (ellipsize_items) / sizeof (ellipsize_items[0]),
8458 2, // PANGO_ELLIPSIZE_MIDDLE
8459 progressbar_toggle_ellipsize,
8461 hbox = gtk_hbox_new (FALSE, 0);
8462 gtk_table_attach (GTK_TABLE (tab), hbox, 1, 2, 10, 11,
8463 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
8465 gtk_box_pack_start (GTK_BOX (hbox), pdata->elmenu, TRUE, TRUE, 0);
8467 check = gtk_check_button_new_with_label ("Activity mode");
8468 g_signal_connect (check, "clicked",
8469 G_CALLBACK (toggle_activity_mode), pdata);
8470 gtk_table_attach (GTK_TABLE (tab), check, 0, 1, 15, 16,
8471 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
8474 button = gtk_button_new_with_label ("close");
8475 g_signal_connect_swapped (button, "clicked",
8476 G_CALLBACK (gtk_widget_destroy),
8478 gtk_widget_set_can_default (button, TRUE);
8479 gtk_box_pack_start (GTK_BOX (action_area), button, TRUE, TRUE, 0);
8480 gtk_widget_grab_default (button);
8483 if (!gtk_widget_get_visible (pdata->window))
8484 gtk_widget_show_all (pdata->window);
8486 gtk_widget_destroy (pdata->window);
8498 GtkWidget *res_widget;
8502 find_widget (GtkWidget *widget, FindWidgetData *data)
8504 GtkAllocation new_allocation;
8508 gtk_widget_get_allocation (widget, &new_allocation);
8510 if (data->found || !gtk_widget_get_mapped (widget))
8513 /* Note that in the following code, we only count the
8514 * position as being inside a WINDOW widget if it is inside
8515 * widget->window; points that are outside of widget->window
8516 * but within the allocation are not counted. This is consistent
8517 * with the way we highlight drag targets.
8519 if (gtk_widget_get_has_window (widget))
8521 new_allocation.x = 0;
8522 new_allocation.y = 0;
8525 if (gtk_widget_get_parent (widget) && !data->first)
8527 GdkWindow *window = gtk_widget_get_window (widget);
8528 while (window != gtk_widget_get_window (gtk_widget_get_parent (widget)))
8530 gint tx, ty, twidth, theight;
8532 twidth = gdk_window_get_width (window);
8533 theight = gdk_window_get_height (window);
8535 if (new_allocation.x < 0)
8537 new_allocation.width += new_allocation.x;
8538 new_allocation.x = 0;
8540 if (new_allocation.y < 0)
8542 new_allocation.height += new_allocation.y;
8543 new_allocation.y = 0;
8545 if (new_allocation.x + new_allocation.width > twidth)
8546 new_allocation.width = twidth - new_allocation.x;
8547 if (new_allocation.y + new_allocation.height > theight)
8548 new_allocation.height = theight - new_allocation.y;
8550 gdk_window_get_position (window, &tx, &ty);
8551 new_allocation.x += tx;
8553 new_allocation.y += ty;
8556 window = gdk_window_get_parent (window);
8560 if ((data->x >= new_allocation.x) && (data->y >= new_allocation.y) &&
8561 (data->x < new_allocation.x + new_allocation.width) &&
8562 (data->y < new_allocation.y + new_allocation.height))
8564 /* First, check if the drag is in a valid drop site in
8565 * one of our children
8567 if (GTK_IS_CONTAINER (widget))
8569 FindWidgetData new_data = *data;
8571 new_data.x -= x_offset;
8572 new_data.y -= y_offset;
8573 new_data.found = FALSE;
8574 new_data.first = FALSE;
8576 gtk_container_forall (GTK_CONTAINER (widget),
8577 (GtkCallback)find_widget,
8580 data->found = new_data.found;
8582 data->res_widget = new_data.res_widget;
8585 /* If not, and this widget is registered as a drop site, check to
8586 * emit "drag_motion" to check if we are actually in
8592 data->res_widget = widget;
8598 find_widget_at_pointer (GdkDisplay *display)
8600 GtkWidget *widget = NULL;
8601 GdkWindow *pointer_window;
8603 FindWidgetData data;
8605 pointer_window = gdk_display_get_window_at_pointer (display, NULL, NULL);
8609 gpointer widget_ptr;
8611 gdk_window_get_user_data (pointer_window, &widget_ptr);
8612 widget = widget_ptr;
8617 gdk_window_get_pointer (gtk_widget_get_window (widget),
8625 find_widget (widget, &data);
8627 return data.res_widget;
8633 struct PropertiesData {
8641 destroy_properties (GtkWidget *widget,
8642 struct PropertiesData *data)
8646 *data->window = NULL;
8647 data->window = NULL;
8652 gdk_cursor_unref (data->cursor);
8653 data->cursor = NULL;
8658 g_signal_handler_disconnect (widget, data->handler);
8666 property_query_event (GtkWidget *widget,
8668 struct PropertiesData *data)
8670 GtkWidget *res_widget = NULL;
8672 if (!data->in_query)
8675 if (event->type == GDK_BUTTON_RELEASE)
8677 gtk_grab_remove (widget);
8678 gdk_display_pointer_ungrab (gtk_widget_get_display (widget),
8681 res_widget = find_widget_at_pointer (gtk_widget_get_display (widget));
8684 g_object_set_data (G_OBJECT (res_widget), "prop-editor-screen",
8685 gtk_widget_get_screen (widget));
8686 create_prop_editor (G_OBJECT (res_widget), 0);
8689 data->in_query = FALSE;
8696 query_properties (GtkButton *button,
8697 struct PropertiesData *data)
8699 GtkWidget *widget = GTK_WIDGET (button);
8702 g_signal_connect (button, "event",
8703 G_CALLBACK (property_query_event), data);
8707 data->cursor = gdk_cursor_new_for_display (gtk_widget_get_display (widget),
8710 failure = gdk_pointer_grab (gtk_widget_get_window (widget),
8712 GDK_BUTTON_RELEASE_MASK,
8717 gtk_grab_add (widget);
8719 data->in_query = TRUE;
8723 create_properties (GtkWidget *widget)
8725 static GtkWidget *window = NULL;
8729 struct PropertiesData *data;
8731 data = g_new (struct PropertiesData, 1);
8732 data->window = &window;
8733 data->in_query = FALSE;
8734 data->cursor = NULL;
8739 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
8741 gtk_window_set_screen (GTK_WINDOW (window),
8742 gtk_widget_get_screen (widget));
8744 data->handler = g_signal_connect (window, "destroy",
8745 G_CALLBACK (destroy_properties),
8748 gtk_window_set_title (GTK_WINDOW (window), "test properties");
8749 gtk_container_set_border_width (GTK_CONTAINER (window), 10);
8751 vbox = gtk_vbox_new (FALSE, 1);
8752 gtk_container_add (GTK_CONTAINER (window), vbox);
8754 label = gtk_label_new ("This is just a dumb test to test properties.\nIf you need a generic module, get GLE.");
8755 gtk_box_pack_start (GTK_BOX (vbox), label, TRUE, TRUE, 0);
8757 button = gtk_button_new_with_label ("Query properties");
8758 gtk_box_pack_start (GTK_BOX (vbox), button, TRUE, TRUE, 0);
8759 g_signal_connect (button, "clicked",
8760 G_CALLBACK (query_properties),
8764 if (!gtk_widget_get_visible (window))
8765 gtk_widget_show_all (window);
8767 gtk_widget_destroy (window);
8771 struct SnapshotData {
8772 GtkWidget *toplevel_button;
8776 gboolean is_toplevel;
8781 destroy_snapshot_data (GtkWidget *widget,
8782 struct SnapshotData *data)
8785 *data->window = NULL;
8789 gdk_cursor_unref (data->cursor);
8790 data->cursor = NULL;
8795 g_signal_handler_disconnect (widget, data->handler);
8803 snapshot_widget_event (GtkWidget *widget,
8805 struct SnapshotData *data)
8807 GtkWidget *res_widget = NULL;
8809 if (!data->in_query)
8812 if (event->type == GDK_BUTTON_RELEASE)
8814 gtk_grab_remove (widget);
8815 gdk_display_pointer_ungrab (gtk_widget_get_display (widget),
8818 res_widget = find_widget_at_pointer (gtk_widget_get_display (widget));
8819 if (data->is_toplevel && res_widget)
8820 res_widget = gtk_widget_get_toplevel (res_widget);
8823 cairo_surface_t *surface;
8824 GtkWidget *window, *image;
8829 width = gtk_widget_get_allocated_width (res_widget);
8830 height = gtk_widget_get_allocated_height (res_widget);
8832 surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, width, height);
8834 cr = cairo_create (surface);
8835 gtk_widget_draw (res_widget, cr);
8838 pixbuf = gdk_pixbuf_get_from_surface (surface,
8841 cairo_surface_destroy (surface);
8843 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
8844 image = gtk_image_new_from_pixbuf (pixbuf);
8845 g_object_unref (pixbuf);
8847 gtk_container_add (GTK_CONTAINER (window), image);
8848 gtk_widget_show_all (window);
8851 data->in_query = FALSE;
8858 snapshot_widget (GtkButton *button,
8859 struct SnapshotData *data)
8861 GtkWidget *widget = GTK_WIDGET (button);
8864 g_signal_connect (button, "event",
8865 G_CALLBACK (snapshot_widget_event), data);
8867 data->is_toplevel = widget == data->toplevel_button;
8870 data->cursor = gdk_cursor_new_for_display (gtk_widget_get_display (widget),
8873 failure = gdk_pointer_grab (gtk_widget_get_window (widget),
8875 GDK_BUTTON_RELEASE_MASK,
8880 gtk_grab_add (widget);
8882 data->in_query = TRUE;
8886 create_snapshot (GtkWidget *widget)
8888 static GtkWidget *window = NULL;
8891 struct SnapshotData *data;
8893 data = g_new (struct SnapshotData, 1);
8894 data->window = &window;
8895 data->in_query = FALSE;
8896 data->cursor = NULL;
8901 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
8903 gtk_window_set_screen (GTK_WINDOW (window),
8904 gtk_widget_get_screen (widget));
8906 data->handler = g_signal_connect (window, "destroy",
8907 G_CALLBACK (destroy_snapshot_data),
8910 gtk_window_set_title (GTK_WINDOW (window), "test snapshot");
8911 gtk_container_set_border_width (GTK_CONTAINER (window), 10);
8913 vbox = gtk_vbox_new (FALSE, 1);
8914 gtk_container_add (GTK_CONTAINER (window), vbox);
8916 button = gtk_button_new_with_label ("Snapshot widget");
8917 gtk_box_pack_start (GTK_BOX (vbox), button, TRUE, TRUE, 0);
8918 g_signal_connect (button, "clicked",
8919 G_CALLBACK (snapshot_widget),
8922 button = gtk_button_new_with_label ("Snapshot toplevel");
8923 data->toplevel_button = button;
8924 gtk_box_pack_start (GTK_BOX (vbox), button, TRUE, TRUE, 0);
8925 g_signal_connect (button, "clicked",
8926 G_CALLBACK (snapshot_widget),
8930 if (!gtk_widget_get_visible (window))
8931 gtk_widget_show_all (window);
8933 gtk_widget_destroy (window);
8942 selection_test_received (GtkWidget *tree_view,
8943 GtkSelectionData *data)
8945 GtkTreeModel *model;
8946 GtkListStore *store;
8950 if (data->length < 0)
8952 g_print ("Selection retrieval failed\n");
8955 if (data->type != GDK_SELECTION_TYPE_ATOM)
8957 g_print ("Selection \"TARGETS\" was not returned as atoms!\n");
8961 /* Clear out any current list items */
8963 model = gtk_tree_view_get_model (GTK_TREE_VIEW (tree_view));
8964 store = GTK_LIST_STORE (model);
8965 gtk_list_store_clear (store);
8967 /* Add new items to list */
8969 atoms = (GdkAtom *)data->data;
8971 l = data->length / sizeof (GdkAtom);
8972 for (i = 0; i < l; i++)
8977 name = gdk_atom_name (atoms[i]);
8980 gtk_list_store_insert_with_values (store, &iter, i, 0, name, -1);
8984 gtk_list_store_insert_with_values (store, &iter, i, 0, "(bad atom)", -1);
8991 selection_test_get_targets (GtkWidget *widget, GtkWidget *tree_view)
8993 static GdkAtom targets_atom = GDK_NONE;
8995 if (targets_atom == GDK_NONE)
8996 targets_atom = gdk_atom_intern ("TARGETS", FALSE);
8998 gtk_selection_convert (tree_view, GDK_SELECTION_PRIMARY, targets_atom,
9003 create_selection_test (GtkWidget *widget)
9005 static GtkWidget *window = NULL;
9006 GtkWidget *action_area, *content_area;
9009 GtkWidget *scrolled_win;
9010 GtkListStore* store;
9011 GtkWidget *tree_view;
9012 GtkTreeViewColumn *column;
9013 GtkCellRenderer *renderer;
9018 window = gtk_dialog_new ();
9020 gtk_window_set_screen (GTK_WINDOW (window),
9021 gtk_widget_get_screen (widget));
9023 g_signal_connect (window, "destroy",
9024 G_CALLBACK (gtk_widget_destroyed),
9027 content_area = gtk_dialog_get_content_area (GTK_DIALOG (window));
9028 action_area = gtk_dialog_get_action_area (GTK_DIALOG (window));
9030 gtk_window_set_title (GTK_WINDOW (window), "Selection Test");
9031 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
9033 /* Create the list */
9035 vbox = gtk_vbox_new (FALSE, 5);
9036 gtk_container_set_border_width (GTK_CONTAINER (vbox), 10);
9037 gtk_box_pack_start (GTK_BOX (content_area), vbox, TRUE, TRUE, 0);
9039 label = gtk_label_new ("Gets available targets for current selection");
9040 gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
9042 scrolled_win = gtk_scrolled_window_new (NULL, NULL);
9043 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
9044 GTK_POLICY_AUTOMATIC,
9045 GTK_POLICY_AUTOMATIC);
9046 gtk_box_pack_start (GTK_BOX (vbox), scrolled_win, TRUE, TRUE, 0);
9047 gtk_widget_set_size_request (scrolled_win, 100, 200);
9049 store = gtk_list_store_new (1, G_TYPE_STRING);
9050 tree_view = gtk_tree_view_new_with_model (GTK_TREE_MODEL (store));
9051 gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (scrolled_win), tree_view);
9053 renderer = gtk_cell_renderer_text_new ();
9054 column = gtk_tree_view_column_new_with_attributes ("Target", renderer,
9056 gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), column);
9058 g_signal_connect (tree_view, "selection_received",
9059 G_CALLBACK (selection_test_received), NULL);
9061 /* .. And create some buttons */
9062 button = gtk_button_new_with_label ("Get Targets");
9063 gtk_box_pack_start (GTK_BOX (action_area), button, TRUE, TRUE, 0);
9065 g_signal_connect (button, "clicked",
9066 G_CALLBACK (selection_test_get_targets), tree_view);
9068 button = gtk_button_new_with_label ("Quit");
9069 gtk_box_pack_start (GTK_BOX (action_area), button, TRUE, TRUE, 0);
9071 g_signal_connect_swapped (button, "clicked",
9072 G_CALLBACK (gtk_widget_destroy),
9076 if (!gtk_widget_get_visible (window))
9077 gtk_widget_show_all (window);
9079 gtk_widget_destroy (window);
9086 static int scroll_test_pos = 0.0;
9089 scroll_test_draw (GtkWidget *widget,
9094 gint imin, imax, jmin, jmax;
9097 gdk_cairo_get_clip_rectangle (cr, &clip);
9099 imin = (clip.x) / 10;
9100 imax = (clip.x + clip.width + 9) / 10;
9102 jmin = ((int)adj->value + clip.y) / 10;
9103 jmax = ((int)adj->value + clip.y + clip.height + 9) / 10;
9105 for (i=imin; i<imax; i++)
9106 for (j=jmin; j<jmax; j++)
9108 cairo_rectangle (cr, 10*i, 10*j - (int)adj->value, 1+i%10, 1+j%10);
9116 scroll_test_scroll (GtkWidget *widget, GdkEventScroll *event,
9119 gdouble new_value = adj->value + ((event->direction == GDK_SCROLL_UP) ?
9120 -adj->page_increment / 2:
9121 adj->page_increment / 2);
9122 new_value = CLAMP (new_value, adj->lower, adj->upper - adj->page_size);
9123 gtk_adjustment_set_value (adj, new_value);
9129 scroll_test_configure (GtkWidget *widget, GdkEventConfigure *event,
9132 GtkAllocation allocation;
9134 gtk_widget_get_allocation (widget, &allocation);
9135 adj->page_increment = 0.9 * allocation.height;
9136 adj->page_size = allocation.height;
9138 g_signal_emit_by_name (adj, "changed");
9142 scroll_test_adjustment_changed (GtkAdjustment *adj, GtkWidget *widget)
9147 dy = scroll_test_pos - (int)adj->value;
9148 scroll_test_pos = adj->value;
9150 if (!gtk_widget_is_drawable (widget))
9153 window = gtk_widget_get_window (widget);
9154 gdk_window_scroll (window, 0, dy);
9155 gdk_window_process_updates (window, FALSE);
9160 create_scroll_test (GtkWidget *widget)
9162 static GtkWidget *window = NULL;
9163 GtkWidget *action_area, *content_area;
9165 GtkWidget *drawing_area;
9166 GtkWidget *scrollbar;
9169 GdkGeometry geometry;
9170 GdkWindowHints geometry_mask;
9174 window = gtk_dialog_new ();
9176 gtk_window_set_screen (GTK_WINDOW (window),
9177 gtk_widget_get_screen (widget));
9179 g_signal_connect (window, "destroy",
9180 G_CALLBACK (gtk_widget_destroyed),
9183 content_area = gtk_dialog_get_content_area (GTK_DIALOG (window));
9184 action_area = gtk_dialog_get_action_area (GTK_DIALOG (window));
9186 gtk_window_set_title (GTK_WINDOW (window), "Scroll Test");
9187 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
9189 hbox = gtk_hbox_new (FALSE, 0);
9190 gtk_box_pack_start (GTK_BOX (content_area), hbox, TRUE, TRUE, 0);
9191 gtk_widget_show (hbox);
9193 drawing_area = gtk_drawing_area_new ();
9194 gtk_widget_set_size_request (drawing_area, 200, 200);
9195 gtk_box_pack_start (GTK_BOX (hbox), drawing_area, TRUE, TRUE, 0);
9196 gtk_widget_show (drawing_area);
9198 gtk_widget_set_events (drawing_area, GDK_EXPOSURE_MASK | GDK_SCROLL_MASK);
9200 adj = gtk_adjustment_new (0.0, 0.0, 1000.0, 1.0, 180.0, 200.0);
9201 scroll_test_pos = 0.0;
9203 scrollbar = gtk_vscrollbar_new (adj);
9204 gtk_box_pack_start (GTK_BOX (hbox), scrollbar, FALSE, FALSE, 0);
9205 gtk_widget_show (scrollbar);
9207 g_signal_connect (drawing_area, "draw",
9208 G_CALLBACK (scroll_test_draw), adj);
9209 g_signal_connect (drawing_area, "configure_event",
9210 G_CALLBACK (scroll_test_configure), adj);
9211 g_signal_connect (drawing_area, "scroll_event",
9212 G_CALLBACK (scroll_test_scroll), adj);
9214 g_signal_connect (adj, "value_changed",
9215 G_CALLBACK (scroll_test_adjustment_changed),
9218 /* .. And create some buttons */
9220 button = gtk_button_new_with_label ("Quit");
9221 gtk_box_pack_start (GTK_BOX (action_area), button, TRUE, TRUE, 0);
9223 g_signal_connect_swapped (button, "clicked",
9224 G_CALLBACK (gtk_widget_destroy),
9226 gtk_widget_show (button);
9228 /* Set up gridded geometry */
9230 geometry_mask = GDK_HINT_MIN_SIZE |
9231 GDK_HINT_BASE_SIZE |
9232 GDK_HINT_RESIZE_INC;
9234 geometry.min_width = 20;
9235 geometry.min_height = 20;
9236 geometry.base_width = 0;
9237 geometry.base_height = 0;
9238 geometry.width_inc = 10;
9239 geometry.height_inc = 10;
9241 gtk_window_set_geometry_hints (GTK_WINDOW (window),
9242 drawing_area, &geometry, geometry_mask);
9245 if (!gtk_widget_get_visible (window))
9246 gtk_widget_show (window);
9248 gtk_widget_destroy (window);
9255 static int timer = 0;
9258 timeout_test (GtkWidget *label)
9260 static int count = 0;
9261 static char buffer[32];
9263 sprintf (buffer, "count: %d", ++count);
9264 gtk_label_set_text (GTK_LABEL (label), buffer);
9270 start_timeout_test (GtkWidget *widget,
9275 timer = g_timeout_add (100, (GSourceFunc)timeout_test, label);
9280 stop_timeout_test (GtkWidget *widget,
9285 g_source_remove (timer);
9291 destroy_timeout_test (GtkWidget *widget,
9294 stop_timeout_test (NULL, NULL);
9300 create_timeout_test (GtkWidget *widget)
9302 static GtkWidget *window = NULL;
9303 GtkWidget *action_area, *content_area;
9309 window = gtk_dialog_new ();
9311 gtk_window_set_screen (GTK_WINDOW (window),
9312 gtk_widget_get_screen (widget));
9314 g_signal_connect (window, "destroy",
9315 G_CALLBACK (destroy_timeout_test),
9318 content_area = gtk_dialog_get_content_area (GTK_DIALOG (window));
9319 action_area = gtk_dialog_get_content_area (GTK_DIALOG (window));
9321 gtk_window_set_title (GTK_WINDOW (window), "Timeout Test");
9322 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
9324 label = gtk_label_new ("count: 0");
9325 gtk_misc_set_padding (GTK_MISC (label), 10, 10);
9326 gtk_box_pack_start (GTK_BOX (content_area), label, TRUE, TRUE, 0);
9327 gtk_widget_show (label);
9329 button = gtk_button_new_with_label ("close");
9330 g_signal_connect_swapped (button, "clicked",
9331 G_CALLBACK (gtk_widget_destroy),
9333 gtk_widget_set_can_default (button, TRUE);
9334 gtk_box_pack_start (GTK_BOX (action_area), button, TRUE, TRUE, 0);
9335 gtk_widget_grab_default (button);
9336 gtk_widget_show (button);
9338 button = gtk_button_new_with_label ("start");
9339 g_signal_connect (button, "clicked",
9340 G_CALLBACK(start_timeout_test),
9342 gtk_widget_set_can_default (button, TRUE);
9343 gtk_box_pack_start (GTK_BOX (action_area), button, TRUE, TRUE, 0);
9344 gtk_widget_show (button);
9346 button = gtk_button_new_with_label ("stop");
9347 g_signal_connect (button, "clicked",
9348 G_CALLBACK (stop_timeout_test),
9350 gtk_widget_set_can_default (button, TRUE);
9351 gtk_box_pack_start (GTK_BOX (action_area), button, TRUE, TRUE, 0);
9352 gtk_widget_show (button);
9355 if (!gtk_widget_get_visible (window))
9356 gtk_widget_show (window);
9358 gtk_widget_destroy (window);
9365 static int idle_id = 0;
9368 idle_test (GtkWidget *label)
9370 static int count = 0;
9371 static char buffer[32];
9373 sprintf (buffer, "count: %d", ++count);
9374 gtk_label_set_text (GTK_LABEL (label), buffer);
9380 start_idle_test (GtkWidget *widget,
9385 idle_id = g_idle_add ((GSourceFunc) idle_test, label);
9390 stop_idle_test (GtkWidget *widget,
9395 g_source_remove (idle_id);
9401 destroy_idle_test (GtkWidget *widget,
9404 stop_idle_test (NULL, NULL);
9410 toggle_idle_container (GObject *button,
9411 GtkContainer *container)
9413 gtk_container_set_resize_mode (container, GPOINTER_TO_INT (g_object_get_data (button, "user_data")));
9417 create_idle_test (GtkWidget *widget)
9419 static GtkWidget *window = NULL;
9422 GtkWidget *container;
9426 GtkWidget *action_area, *content_area;
9431 window = gtk_dialog_new ();
9433 gtk_window_set_screen (GTK_WINDOW (window),
9434 gtk_widget_get_screen (widget));
9436 g_signal_connect (window, "destroy",
9437 G_CALLBACK (destroy_idle_test),
9440 content_area = gtk_dialog_get_content_area (GTK_DIALOG (window));
9441 action_area = gtk_dialog_get_action_area (GTK_DIALOG (window));
9443 gtk_window_set_title (GTK_WINDOW (window), "Idle Test");
9444 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
9446 label = gtk_label_new ("count: 0");
9447 gtk_misc_set_padding (GTK_MISC (label), 10, 10);
9448 gtk_widget_show (label);
9451 g_object_new (GTK_TYPE_HBOX,
9453 /* "GtkContainer::child", g_object_new (GTK_TYPE_HBOX,
9454 * "GtkWidget::visible", TRUE,
9459 gtk_box_pack_start (GTK_BOX (content_area), container, TRUE, TRUE, 0);
9462 g_object_new (GTK_TYPE_FRAME,
9464 "label", "Label Container",
9466 "parent", content_area,
9469 g_object_new (GTK_TYPE_VBOX,
9474 g_object_connect (g_object_new (GTK_TYPE_RADIO_BUTTON,
9475 "label", "Resize-Parent",
9476 "user_data", (void*)GTK_RESIZE_PARENT,
9480 "signal::clicked", toggle_idle_container, container,
9482 button = g_object_new (GTK_TYPE_RADIO_BUTTON,
9483 "label", "Resize-Queue",
9484 "user_data", (void*)GTK_RESIZE_QUEUE,
9489 g_object_connect (button,
9490 "signal::clicked", toggle_idle_container, container,
9492 button2 = g_object_new (GTK_TYPE_RADIO_BUTTON,
9493 "label", "Resize-Immediate",
9494 "user_data", (void*)GTK_RESIZE_IMMEDIATE,
9496 g_object_connect (button2,
9497 "signal::clicked", toggle_idle_container, container,
9499 g_object_set (button2,
9505 button = gtk_button_new_with_label ("close");
9506 g_signal_connect_swapped (button, "clicked",
9507 G_CALLBACK (gtk_widget_destroy),
9509 gtk_widget_set_can_default (button, TRUE);
9510 gtk_box_pack_start (GTK_BOX (action_area), button, TRUE, TRUE, 0);
9511 gtk_widget_grab_default (button);
9512 gtk_widget_show (button);
9514 button = gtk_button_new_with_label ("start");
9515 g_signal_connect (button, "clicked",
9516 G_CALLBACK (start_idle_test),
9518 gtk_widget_set_can_default (button, TRUE);
9519 gtk_box_pack_start (GTK_BOX (action_area), button, TRUE, TRUE, 0);
9520 gtk_widget_show (button);
9522 button = gtk_button_new_with_label ("stop");
9523 g_signal_connect (button, "clicked",
9524 G_CALLBACK (stop_idle_test),
9526 gtk_widget_set_can_default (button, TRUE);
9527 gtk_box_pack_start (GTK_BOX (action_area), button, TRUE, TRUE, 0);
9528 gtk_widget_show (button);
9531 if (!gtk_widget_get_visible (window))
9532 gtk_widget_show (window);
9534 gtk_widget_destroy (window);
9542 reload_all_rc_files (void)
9544 static GdkAtom atom_rcfiles = GDK_NONE;
9546 GdkEvent *send_event = gdk_event_new (GDK_CLIENT_EVENT);
9550 atom_rcfiles = gdk_atom_intern("_GTK_READ_RCFILES", FALSE);
9552 for(i = 0; i < 5; i++)
9553 send_event->client.data.l[i] = 0;
9554 send_event->client.data_format = 32;
9555 send_event->client.message_type = atom_rcfiles;
9556 gdk_event_send_clientmessage_toall (send_event);
9558 gdk_event_free (send_event);
9562 create_rc_file (GtkWidget *widget)
9564 static GtkWidget *window = NULL;
9565 GtkWidget *action_area, *content_area;
9573 window = gtk_dialog_new ();
9575 gtk_window_set_screen (GTK_WINDOW (window),
9576 gtk_widget_get_screen (widget));
9578 g_signal_connect (window, "destroy",
9579 G_CALLBACK (gtk_widget_destroyed),
9582 content_area = gtk_dialog_get_content_area (GTK_DIALOG (window));
9583 action_area = gtk_dialog_get_action_area (GTK_DIALOG (window));
9585 frame = gtk_aspect_frame_new ("Testing RC file prioritization", 0.5, 0.5, 0.0, TRUE);
9586 gtk_box_pack_start (GTK_BOX (content_area), frame, FALSE, FALSE, 0);
9588 vbox = gtk_vbox_new (FALSE, 0);
9589 gtk_container_add (GTK_CONTAINER (frame), vbox);
9591 label = gtk_label_new ("This label should be red");
9592 gtk_widget_set_name (label, "testgtk-red-label");
9593 gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
9595 label = gtk_label_new ("This label should be green");
9596 gtk_widget_set_name (label, "testgtk-green-label");
9597 gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
9599 label = gtk_label_new ("This label should be blue");
9600 gtk_widget_set_name (label, "testgtk-blue-label");
9601 gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
9603 gtk_window_set_title (GTK_WINDOW (window), "Reload Rc file");
9604 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
9606 button = gtk_button_new_with_label ("Reload");
9607 g_signal_connect (button, "clicked",
9608 G_CALLBACK (gtk_rc_reparse_all), NULL);
9609 gtk_widget_set_can_default (button, TRUE);
9610 gtk_box_pack_start (GTK_BOX (action_area), button, TRUE, TRUE, 0);
9611 gtk_widget_grab_default (button);
9613 button = gtk_button_new_with_label ("Reload All");
9614 g_signal_connect (button, "clicked",
9615 G_CALLBACK (reload_all_rc_files), NULL);
9616 gtk_widget_set_can_default (button, TRUE);
9617 gtk_box_pack_start (GTK_BOX (action_area), button, TRUE, TRUE, 0);
9619 button = gtk_button_new_with_label ("Close");
9620 g_signal_connect_swapped (button, "clicked",
9621 G_CALLBACK (gtk_widget_destroy),
9623 gtk_widget_set_can_default (button, TRUE);
9624 gtk_box_pack_start (GTK_BOX (action_area), button, TRUE, TRUE, 0);
9627 if (!gtk_widget_get_visible (window))
9628 gtk_widget_show_all (window);
9630 gtk_widget_destroy (window);
9634 * Test of recursive mainloop
9638 mainloop_destroyed (GtkWidget *w, GtkWidget **window)
9645 create_mainloop (GtkWidget *widget)
9647 static GtkWidget *window = NULL;
9648 GtkWidget *action_area, *content_area;
9654 window = gtk_dialog_new ();
9656 gtk_window_set_screen (GTK_WINDOW (window),
9657 gtk_widget_get_screen (widget));
9659 gtk_window_set_title (GTK_WINDOW (window), "Test Main Loop");
9661 g_signal_connect (window, "destroy",
9662 G_CALLBACK (mainloop_destroyed),
9665 content_area = gtk_dialog_get_content_area (GTK_DIALOG (window));
9666 action_area = gtk_dialog_get_action_area (GTK_DIALOG (window));
9668 label = gtk_label_new ("In recursive main loop...");
9669 gtk_misc_set_padding (GTK_MISC(label), 20, 20);
9671 gtk_box_pack_start (GTK_BOX (content_area), label, TRUE, TRUE, 0);
9672 gtk_widget_show (label);
9674 button = gtk_button_new_with_label ("Leave");
9675 gtk_box_pack_start (GTK_BOX (action_area), button, FALSE, TRUE, 0);
9677 g_signal_connect_swapped (button, "clicked",
9678 G_CALLBACK (gtk_widget_destroy),
9681 gtk_widget_set_can_default (button, TRUE);
9682 gtk_widget_grab_default (button);
9684 gtk_widget_show (button);
9687 if (!gtk_widget_get_visible (window))
9689 gtk_widget_show (window);
9691 g_print ("create_mainloop: start\n");
9693 g_print ("create_mainloop: done\n");
9696 gtk_widget_destroy (window);
9700 layout_draw_handler (GtkWidget *widget, cairo_t *cr)
9703 GdkWindow *bin_window;
9706 gint imin, imax, jmin, jmax;
9708 layout = GTK_LAYOUT (widget);
9709 bin_window = gtk_layout_get_bin_window (layout);
9711 if (!gtk_cairo_should_draw_window (cr, bin_window))
9714 gdk_window_get_position (bin_window, &x, &y);
9715 cairo_translate (cr, x, y);
9717 gdk_cairo_get_clip_rectangle (cr, &clip);
9719 imin = (clip.x) / 10;
9720 imax = (clip.x + clip.width + 9) / 10;
9722 jmin = (clip.y) / 10;
9723 jmax = (clip.y + clip.height + 9) / 10;
9725 for (i=imin; i<imax; i++)
9726 for (j=jmin; j<jmax; j++)
9728 cairo_rectangle (cr,
9737 void create_layout (GtkWidget *widget)
9739 GtkAdjustment *hadjustment, *vadjustment;
9741 static GtkWidget *window = NULL;
9742 GtkWidget *layout_widget;
9743 GtkWidget *scrolledwindow;
9752 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
9753 gtk_window_set_screen (GTK_WINDOW (window),
9754 gtk_widget_get_screen (widget));
9756 g_signal_connect (window, "destroy",
9757 G_CALLBACK (gtk_widget_destroyed),
9760 gtk_window_set_title (GTK_WINDOW (window), "Layout");
9761 gtk_widget_set_size_request (window, 200, 200);
9763 scrolledwindow = gtk_scrolled_window_new (NULL, NULL);
9764 gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolledwindow),
9766 gtk_scrolled_window_set_placement (GTK_SCROLLED_WINDOW (scrolledwindow),
9767 GTK_CORNER_TOP_RIGHT);
9769 gtk_container_add (GTK_CONTAINER (window), scrolledwindow);
9771 layout_widget = gtk_layout_new (NULL, NULL);
9772 layout = GTK_LAYOUT (layout_widget);
9773 gtk_container_add (GTK_CONTAINER (scrolledwindow), layout_widget);
9775 /* We set step sizes here since GtkLayout does not set
9778 hadjustment = gtk_layout_get_hadjustment (layout);
9779 vadjustment = gtk_layout_get_vadjustment (layout);
9780 gtk_adjustment_set_step_increment (hadjustment, 10.0);
9781 gtk_adjustment_set_step_increment (vadjustment, 10.0);
9782 gtk_layout_set_hadjustment (layout, hadjustment);
9783 gtk_layout_set_vadjustment (layout, vadjustment);
9785 gtk_widget_set_events (layout_widget, GDK_EXPOSURE_MASK);
9786 g_signal_connect (layout, "draw",
9787 G_CALLBACK (layout_draw_handler), NULL);
9789 gtk_layout_set_size (layout, 1600, 128000);
9791 for (i=0 ; i < 16 ; i++)
9792 for (j=0 ; j < 16 ; j++)
9794 sprintf(buf, "Button %d, %d", i, j);
9796 button = gtk_button_new_with_label (buf);
9798 button = gtk_label_new (buf);
9800 gtk_layout_put (layout, button, j*100, i*100);
9803 for (i=16; i < 1280; i++)
9805 sprintf(buf, "Button %d, %d", i, 0);
9807 button = gtk_button_new_with_label (buf);
9809 button = gtk_label_new (buf);
9811 gtk_layout_put (layout, button, 0, i*100);
9815 if (!gtk_widget_get_visible (window))
9816 gtk_widget_show_all (window);
9818 gtk_widget_destroy (window);
9822 create_styles (GtkWidget *widget)
9824 static GtkWidget *window = NULL;
9825 GtkWidget *content_area, *action_area;
9830 static GdkColor red = { 0, 0xffff, 0, 0 };
9831 static GdkColor green = { 0, 0, 0xffff, 0 };
9832 static GdkColor blue = { 0, 0, 0, 0xffff };
9833 static GdkColor yellow = { 0, 0xffff, 0xffff, 0 };
9834 static GdkColor cyan = { 0, 0 , 0xffff, 0xffff };
9835 PangoFontDescription *font_desc;
9837 GtkRcStyle *rc_style;
9841 window = gtk_dialog_new ();
9842 gtk_window_set_screen (GTK_WINDOW (window),
9843 gtk_widget_get_screen (widget));
9845 g_signal_connect (window, "destroy",
9846 G_CALLBACK (gtk_widget_destroyed),
9849 content_area = gtk_dialog_get_content_area (GTK_DIALOG (window));
9850 action_area = gtk_dialog_get_action_area (GTK_DIALOG (window));
9852 button = gtk_button_new_with_label ("Close");
9853 g_signal_connect_swapped (button, "clicked",
9854 G_CALLBACK (gtk_widget_destroy),
9856 gtk_widget_set_can_default (button, TRUE);
9857 gtk_box_pack_start (GTK_BOX (action_area), button, TRUE, TRUE, 0);
9858 gtk_widget_show (button);
9860 vbox = gtk_vbox_new (FALSE, 5);
9861 gtk_container_set_border_width (GTK_CONTAINER (vbox), 10);
9862 gtk_box_pack_start (GTK_BOX (content_area), vbox, FALSE, FALSE, 0);
9864 label = gtk_label_new ("Font:");
9865 gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
9866 gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
9868 font_desc = pango_font_description_from_string ("Helvetica,Sans Oblique 18");
9870 button = gtk_button_new_with_label ("Some Text");
9871 gtk_widget_modify_font (gtk_bin_get_child (GTK_BIN (button)),
9873 gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
9875 label = gtk_label_new ("Foreground:");
9876 gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
9877 gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
9879 button = gtk_button_new_with_label ("Some Text");
9880 gtk_widget_modify_fg (gtk_bin_get_child (GTK_BIN (button)),
9881 GTK_STATE_NORMAL, &red);
9882 gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
9884 label = gtk_label_new ("Background:");
9885 gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
9886 gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
9888 button = gtk_button_new_with_label ("Some Text");
9889 gtk_widget_modify_bg (button, GTK_STATE_NORMAL, &green);
9890 gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
9892 label = gtk_label_new ("Text:");
9893 gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
9894 gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
9896 entry = gtk_entry_new ();
9897 gtk_entry_set_text (GTK_ENTRY (entry), "Some Text");
9898 gtk_widget_modify_text (entry, GTK_STATE_NORMAL, &blue);
9899 gtk_box_pack_start (GTK_BOX (vbox), entry, FALSE, FALSE, 0);
9901 label = gtk_label_new ("Base:");
9902 gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
9903 gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
9905 entry = gtk_entry_new ();
9906 gtk_entry_set_text (GTK_ENTRY (entry), "Some Text");
9907 gtk_widget_modify_base (entry, GTK_STATE_NORMAL, &yellow);
9908 gtk_box_pack_start (GTK_BOX (vbox), entry, FALSE, FALSE, 0);
9910 label = gtk_label_new ("Cursor:");
9911 gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
9912 gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
9914 entry = gtk_entry_new ();
9915 gtk_entry_set_text (GTK_ENTRY (entry), "Some Text");
9916 gtk_widget_modify_cursor (entry, &red, &red);
9917 gtk_box_pack_start (GTK_BOX (vbox), entry, FALSE, FALSE, 0);
9919 label = gtk_label_new ("Multiple:");
9920 gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
9921 gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
9923 button = gtk_button_new_with_label ("Some Text");
9925 rc_style = gtk_rc_style_new ();
9927 rc_style->font_desc = pango_font_description_copy (font_desc);
9928 rc_style->color_flags[GTK_STATE_NORMAL] = GTK_RC_FG | GTK_RC_BG;
9929 rc_style->color_flags[GTK_STATE_PRELIGHT] = GTK_RC_FG | GTK_RC_BG;
9930 rc_style->color_flags[GTK_STATE_ACTIVE] = GTK_RC_FG | GTK_RC_BG;
9931 rc_style->fg[GTK_STATE_NORMAL] = yellow;
9932 rc_style->bg[GTK_STATE_NORMAL] = blue;
9933 rc_style->fg[GTK_STATE_PRELIGHT] = blue;
9934 rc_style->bg[GTK_STATE_PRELIGHT] = yellow;
9935 rc_style->fg[GTK_STATE_ACTIVE] = red;
9936 rc_style->bg[GTK_STATE_ACTIVE] = cyan;
9937 rc_style->xthickness = 5;
9938 rc_style->ythickness = 5;
9940 gtk_widget_modify_style (button, rc_style);
9941 gtk_widget_modify_style (gtk_bin_get_child (GTK_BIN (button)), rc_style);
9943 g_object_unref (rc_style);
9945 gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
9948 if (!gtk_widget_get_visible (window))
9949 gtk_widget_show_all (window);
9951 gtk_widget_destroy (window);
9955 * Main Window and Exit
9959 do_exit (GtkWidget *widget, GtkWidget *window)
9961 gtk_widget_destroy (window);
9967 void (*func) (GtkWidget *widget);
9968 gboolean do_not_benchmark;
9971 { "alpha window", create_alpha_window },
9972 { "big windows", create_big_windows },
9973 { "button box", create_button_box },
9974 { "buttons", create_buttons },
9975 { "check buttons", create_check_buttons },
9976 { "color selection", create_color_selection },
9977 { "composited window", create_composited_window },
9978 { "cursors", create_cursors },
9979 { "dialog", create_dialog },
9980 { "display & screen", create_display_screen, TRUE },
9981 { "entry", create_entry },
9982 { "event box", create_event_box },
9983 { "event watcher", create_event_watcher },
9984 { "expander", create_expander },
9985 { "flipping", create_flipping },
9986 { "focus", create_focus },
9987 { "font selection", create_font_selection },
9988 { "handle box", create_handle_box },
9989 { "image", create_image },
9990 { "key lookup", create_key_lookup },
9991 { "labels", create_labels },
9992 { "layout", create_layout },
9993 { "menus", create_menus },
9994 { "message dialog", create_message_dialog },
9995 { "modal window", create_modal_window, TRUE },
9996 { "notebook", create_notebook },
9997 { "panes", create_panes },
9998 { "paned keyboard", create_paned_keyboard_navigation },
9999 { "pixbuf", create_pixbuf },
10000 { "progress bar", create_progress_bar },
10001 { "properties", create_properties },
10002 { "radio buttons", create_radio_buttons },
10003 { "range controls", create_range_controls },
10004 { "rc file", create_rc_file },
10005 { "reparent", create_reparent },
10006 { "resize grips", create_resize_grips },
10007 { "rotated label", create_rotated_label },
10008 { "rotated text", create_rotated_text },
10009 { "rulers", create_rulers },
10010 { "saved position", create_saved_position },
10011 { "scrolled windows", create_scrolled_windows },
10012 { "shapes", create_shapes },
10013 { "size groups", create_size_groups },
10014 { "snapshot", create_snapshot },
10015 { "spinbutton", create_spins },
10016 { "statusbar", create_statusbar },
10017 { "styles", create_styles },
10018 { "test idle", create_idle_test },
10019 { "test mainloop", create_mainloop, TRUE },
10020 { "test scrolling", create_scroll_test },
10021 { "test selection", create_selection_test },
10022 { "test timeout", create_timeout_test },
10023 { "toggle buttons", create_toggle_buttons },
10024 { "toolbar", create_toolbar },
10025 { "tooltips", create_tooltips },
10026 { "WM hints", create_wmhints },
10027 { "window sizing", create_window_sizing },
10028 { "window states", create_window_states }
10030 int nbuttons = sizeof (buttons) / sizeof (buttons[0]);
10033 create_main_window (void)
10038 GtkWidget *scrolled_window;
10042 GtkWidget *separator;
10043 GdkGeometry geometry;
10046 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
10047 gtk_widget_set_name (window, "main window");
10048 gtk_window_move (GTK_WINDOW (window), 50, 20);
10049 gtk_window_set_default_size (GTK_WINDOW (window), -1, 400);
10051 geometry.min_width = -1;
10052 geometry.min_height = -1;
10053 geometry.max_width = -1;
10054 geometry.max_height = G_MAXSHORT;
10055 gtk_window_set_geometry_hints (GTK_WINDOW (window), NULL,
10057 GDK_HINT_MIN_SIZE | GDK_HINT_MAX_SIZE);
10059 g_signal_connect (window, "destroy",
10060 G_CALLBACK (gtk_main_quit),
10062 g_signal_connect (window, "delete-event",
10063 G_CALLBACK (gtk_false),
10066 box1 = gtk_vbox_new (FALSE, 0);
10067 gtk_container_add (GTK_CONTAINER (window), box1);
10069 if (gtk_micro_version > 0)
10072 gtk_get_major_version (),
10073 gtk_get_minor_version (),
10074 gtk_get_micro_version ());
10078 gtk_get_major_version (),
10079 gtk_get_minor_version ());
10081 label = gtk_label_new (buffer);
10082 gtk_box_pack_start (GTK_BOX (box1), label, FALSE, FALSE, 0);
10083 gtk_widget_set_name (label, "testgtk-version-label");
10085 scrolled_window = gtk_scrolled_window_new (NULL, NULL);
10086 gtk_container_set_border_width (GTK_CONTAINER (scrolled_window), 10);
10087 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
10089 GTK_POLICY_AUTOMATIC);
10090 gtk_box_pack_start (GTK_BOX (box1), scrolled_window, TRUE, TRUE, 0);
10092 box2 = gtk_vbox_new (FALSE, 0);
10093 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
10094 gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (scrolled_window), box2);
10095 gtk_container_set_focus_vadjustment (GTK_CONTAINER (box2),
10096 gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (scrolled_window)));
10097 gtk_widget_show (box2);
10099 for (i = 0; i < nbuttons; i++)
10101 button = gtk_button_new_with_label (buttons[i].label);
10102 if (buttons[i].func)
10103 g_signal_connect (button,
10105 G_CALLBACK(buttons[i].func),
10108 gtk_widget_set_sensitive (button, FALSE);
10109 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
10112 separator = gtk_hseparator_new ();
10113 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
10115 box2 = gtk_vbox_new (FALSE, 10);
10116 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
10117 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
10119 button = gtk_button_new_with_mnemonic ("_Close");
10120 g_signal_connect (button, "clicked",
10121 G_CALLBACK (do_exit),
10123 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
10124 gtk_widget_set_can_default (button, TRUE);
10125 gtk_widget_grab_default (button);
10127 gtk_widget_show_all (window);
10133 if (g_file_test ("../gdk-pixbuf/libpixbufloader-pnm.la",
10134 G_FILE_TEST_EXISTS))
10136 g_setenv ("GDK_PIXBUF_MODULE_FILE", "../gdk-pixbuf/loaders.cache", TRUE);
10137 g_setenv ("GTK_IM_MODULE_FILE", "../modules/input/immodules.cache", TRUE);
10142 pad (const char *str, int to)
10144 static char buf[256];
10145 int len = strlen (str);
10148 for (i = 0; i < to; i++)
10153 memcpy (buf, str, len);
10159 bench_iteration (GtkWidget *widget, void (* fn) (GtkWidget *widget))
10161 fn (widget); /* on */
10162 while (g_main_context_iteration (NULL, FALSE));
10163 fn (widget); /* off */
10164 while (g_main_context_iteration (NULL, FALSE));
10168 do_real_bench (GtkWidget *widget, void (* fn) (GtkWidget *widget), char *name, int num)
10174 static gboolean printed_headers = FALSE;
10176 if (!printed_headers) {
10177 g_print ("Test Iters First Other\n");
10178 g_print ("-------------------- ----- ---------- ----------\n");
10179 printed_headers = TRUE;
10182 g_get_current_time (&tv0);
10183 bench_iteration (widget, fn);
10184 g_get_current_time (&tv1);
10186 dt_first = ((double)tv1.tv_sec - tv0.tv_sec) * 1000.0
10187 + (tv1.tv_usec - tv0.tv_usec) / 1000.0;
10189 g_get_current_time (&tv0);
10190 for (n = 0; n < num - 1; n++)
10191 bench_iteration (widget, fn);
10192 g_get_current_time (&tv1);
10193 dt = ((double)tv1.tv_sec - tv0.tv_sec) * 1000.0
10194 + (tv1.tv_usec - tv0.tv_usec) / 1000.0;
10196 g_print ("%s %5d ", pad (name, 20), num);
10198 g_print ("%10.1f %10.1f\n", dt_first, dt/(num-1));
10200 g_print ("%10.1f\n", dt_first);
10204 do_bench (char* what, int num)
10208 void (* fn) (GtkWidget *widget);
10210 widget = gtk_window_new (GTK_WINDOW_TOPLEVEL);
10212 if (g_ascii_strcasecmp (what, "ALL") == 0)
10214 for (i = 0; i < nbuttons; i++)
10216 if (!buttons[i].do_not_benchmark)
10217 do_real_bench (widget, buttons[i].func, buttons[i].label, num);
10224 for (i = 0; i < nbuttons; i++)
10226 if (strcmp (buttons[i].label, what) == 0)
10228 fn = buttons[i].func;
10234 g_print ("Can't bench: \"%s\" not found.\n", what);
10236 do_real_bench (widget, fn, buttons[i].label, num);
10243 fprintf (stderr, "Usage: testgtk [--bench ALL|<bench>[:<count>]]\n");
10248 main (int argc, char *argv[])
10250 GtkBindingSet *binding_set;
10252 gboolean done_benchmarks = FALSE;
10254 srand (time (NULL));
10258 /* Check to see if we are being run from the correct
10261 if (file_exists ("testgtkrc"))
10262 gtk_rc_add_default_file ("testgtkrc");
10263 else if (file_exists ("tests/testgtkrc"))
10264 gtk_rc_add_default_file ("tests/testgtkrc");
10266 g_warning ("Couldn't find file \"testgtkrc\".");
10268 g_set_application_name ("GTK+ Test Program");
10270 gtk_init (&argc, &argv);
10272 gtk_accelerator_set_default_mod_mask (GDK_SHIFT_MASK |
10281 for (i = 1; i < argc; i++)
10283 if (strncmp (argv[i], "--bench", strlen("--bench")) == 0)
10290 nextarg = strchr (argv[i], '=');
10301 count = strchr (nextarg, ':');
10304 what = g_strndup (nextarg, count - nextarg);
10306 num = atoi (count);
10311 what = g_strdup (nextarg);
10313 do_bench (what, num ? num : 1);
10314 done_benchmarks = TRUE;
10319 if (done_benchmarks)
10324 binding_set = gtk_binding_set_by_class (g_type_class_ref (GTK_TYPE_WIDGET));
10325 gtk_binding_entry_add_signal (binding_set,
10326 '9', GDK_CONTROL_MASK | GDK_RELEASE_MASK,
10329 G_TYPE_STRING, "GtkWidgetClass <ctrl><release>9 test");
10331 /* We use gtk_rc_parse_string() here so we can make sure it works across theme
10335 gtk_rc_parse_string ("style \"testgtk-version-label\" { "
10336 " fg[NORMAL] = \"#ff0000\"\n"
10337 " font = \"Sans 18\"\n"
10339 "widget \"*.testgtk-version-label\" style \"testgtk-version-label\"");
10341 create_main_window ();
10347 while (g_main_context_pending (NULL))
10348 g_main_context_iteration (NULL, FALSE);
10351 while (g_main_context_pending (NULL))
10352 g_main_context_iteration (NULL, FALSE);