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_text_new ();
113 g_signal_connect (omenu, "changed",
114 G_CALLBACK (func), data);
116 for (i = 0; i < num_items; i++)
117 gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (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_separator_new (GTK_ORIENTATION_HORIZONTAL);
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_separator_new (GTK_ORIENTATION_HORIZONTAL);
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_separator_new (GTK_ORIENTATION_HORIZONTAL);
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_separator_new (GTK_ORIENTATION_HORIZONTAL);
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_separator_new (GTK_ORIENTATION_HORIZONTAL);
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_button_box_new (GTK_ORIENTATION_HORIZONTAL);
1093 bbox = gtk_button_box_new (GTK_ORIENTATION_VERTICAL);
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_separator_new (GTK_ORIENTATION_HORIZONTAL);
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_separator_new (GTK_ORIENTATION_HORIZONTAL);
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_separator_new (GTK_ORIENTATION_HORIZONTAL);
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,
1777 gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (toggle)));
1781 create_sensitivity_control (GtkWidget *widget)
1785 button = gtk_toggle_button_new_with_label ("Sensitive");
1787 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button),
1788 gtk_widget_is_sensitive (widget));
1790 g_signal_connect (button,
1792 G_CALLBACK (sensitivity_toggled),
1795 gtk_widget_show_all (button);
1801 set_selectable_recursive (GtkWidget *widget,
1804 if (GTK_IS_CONTAINER (widget))
1809 children = gtk_container_get_children (GTK_CONTAINER (widget));
1813 set_selectable_recursive (tmp->data, setting);
1817 g_list_free (children);
1819 else if (GTK_IS_LABEL (widget))
1821 gtk_label_set_selectable (GTK_LABEL (widget), setting);
1826 selectable_toggled (GtkWidget *toggle,
1829 set_selectable_recursive (widget,
1830 gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (toggle)));
1834 create_selectable_control (GtkWidget *widget)
1838 button = gtk_toggle_button_new_with_label ("Selectable");
1840 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button),
1843 g_signal_connect (button,
1845 G_CALLBACK (selectable_toggled),
1848 gtk_widget_show_all (button);
1854 dialog_response (GtkWidget *dialog, gint response_id, GtkLabel *label)
1858 gtk_widget_destroy (dialog);
1860 text = "Some <a href=\"http://en.wikipedia.org/wiki/Text\" title=\"plain text\">text</a> may be marked up\n"
1861 "as hyperlinks, which can be clicked\n"
1862 "or activated via <a href=\"keynav\">keynav</a>.\n"
1863 "The links remain the same.";
1864 gtk_label_set_markup (label, text);
1868 activate_link (GtkWidget *label, const gchar *uri, gpointer data)
1870 if (g_strcmp0 (uri, "keynav") == 0)
1874 dialog = gtk_message_dialog_new_with_markup (GTK_WINDOW (gtk_widget_get_toplevel (label)),
1875 GTK_DIALOG_DESTROY_WITH_PARENT,
1878 "The term <i>keynav</i> is a shorthand for "
1879 "keyboard navigation and refers to the process of using a program "
1880 "(exclusively) via keyboard input.");
1882 gtk_window_present (GTK_WINDOW (dialog));
1884 g_signal_connect (dialog, "response", G_CALLBACK (dialog_response), label);
1892 void create_labels (GtkWidget *widget)
1894 static GtkWidget *window = NULL;
1903 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
1905 gtk_window_set_screen (GTK_WINDOW (window),
1906 gtk_widget_get_screen (widget));
1908 g_signal_connect (window, "destroy",
1909 G_CALLBACK (gtk_widget_destroyed),
1912 gtk_window_set_title (GTK_WINDOW (window), "Label");
1914 vbox = gtk_vbox_new (FALSE, 5);
1916 hbox = gtk_hbox_new (FALSE, 5);
1917 gtk_container_add (GTK_CONTAINER (window), vbox);
1919 gtk_box_pack_end (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
1921 button = create_sensitivity_control (hbox);
1923 gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
1925 button = create_selectable_control (hbox);
1927 gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
1929 vbox = gtk_vbox_new (FALSE, 5);
1931 gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 0);
1932 gtk_container_set_border_width (GTK_CONTAINER (window), 5);
1934 frame = gtk_frame_new ("Normal Label");
1935 label = gtk_label_new ("This is a Normal label");
1936 gtk_label_set_ellipsize (GTK_LABEL (label), PANGO_ELLIPSIZE_START);
1937 gtk_container_add (GTK_CONTAINER (frame), label);
1938 gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
1940 frame = gtk_frame_new ("Multi-line Label");
1941 label = gtk_label_new ("This is a Multi-line label.\nSecond line\nThird line");
1942 gtk_label_set_ellipsize (GTK_LABEL (label), PANGO_ELLIPSIZE_END);
1943 gtk_container_add (GTK_CONTAINER (frame), label);
1944 gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
1946 frame = gtk_frame_new ("Left Justified Label");
1947 label = gtk_label_new ("This is a Left-Justified\nMulti-line label.\nThird line");
1948 gtk_label_set_ellipsize (GTK_LABEL (label), PANGO_ELLIPSIZE_MIDDLE);
1949 gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
1950 gtk_container_add (GTK_CONTAINER (frame), label);
1951 gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
1953 frame = gtk_frame_new ("Right Justified Label");
1954 gtk_label_set_ellipsize (GTK_LABEL (label), PANGO_ELLIPSIZE_START);
1955 label = gtk_label_new ("This is a Right-Justified\nMulti-line label.\nFourth line, (j/k)");
1956 gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_RIGHT);
1957 gtk_container_add (GTK_CONTAINER (frame), label);
1958 gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
1960 frame = gtk_frame_new ("Internationalized Label");
1961 label = gtk_label_new (NULL);
1962 gtk_label_set_markup (GTK_LABEL (label),
1963 "French (Fran\303\247ais) Bonjour, Salut\n"
1964 "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"
1965 "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"
1966 "Chinese (Simplified) <span lang=\"zh-cn\">\345\205\203\346\260\224 \345\274\200\345\217\221</span>\n"
1967 "Chinese (Traditional) <span lang=\"zh-tw\">\345\205\203\346\260\243 \351\226\213\347\231\274</span>\n"
1968 "Japanese <span lang=\"ja\">\345\205\203\346\260\227 \351\226\213\347\231\272</span>");
1969 gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
1970 gtk_container_add (GTK_CONTAINER (frame), label);
1971 gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
1973 frame = gtk_frame_new ("Bidirection Label");
1974 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"
1975 "\342\200\217Hebrew \327\251\327\234\327\225\327\235");
1976 gtk_container_add (GTK_CONTAINER (frame), label);
1977 gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
1979 frame = gtk_frame_new ("Links in a label");
1980 label = gtk_label_new ("Some <a href=\"http://en.wikipedia.org/wiki/Text\" title=\"plain text\">text</a> may be marked up\n"
1981 "as hyperlinks, which can be clicked\n"
1982 "or activated via <a href=\"keynav\">keynav</a>");
1983 gtk_label_set_use_markup (GTK_LABEL (label), TRUE);
1984 gtk_container_add (GTK_CONTAINER (frame), label);
1985 gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
1986 g_signal_connect (label, "activate-link", G_CALLBACK (activate_link), NULL);
1988 vbox = gtk_vbox_new (FALSE, 5);
1989 gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 0);
1990 frame = gtk_frame_new ("Line wrapped label");
1991 label = gtk_label_new ("This is an example of a line-wrapped label. It should not be taking "\
1992 "up the entire "/* big space to test spacing */\
1993 "width allocated to it, but automatically wraps the words to fit. "\
1994 "The time has come, for all good men, to come to the aid of their party. "\
1995 "The sixth sheik's six sheep's sick.\n"\
1996 " It supports multiple paragraphs correctly, and correctly adds "\
1997 "many extra spaces. ");
1999 gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
2000 gtk_container_add (GTK_CONTAINER (frame), label);
2001 gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
2003 frame = gtk_frame_new ("Filled, wrapped label");
2004 label = gtk_label_new ("This is an example of a line-wrapped, filled label. It should be taking "\
2005 "up the entire width allocated to it. Here is a seneance to prove "\
2006 "my point. Here is another sentence. "\
2007 "Here comes the sun, do de do de do.\n"\
2008 " This is a new paragraph.\n"\
2009 " This is another newer, longer, better paragraph. It is coming to an end, "\
2011 gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_FILL);
2012 gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
2013 gtk_container_add (GTK_CONTAINER (frame), label);
2014 gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
2016 frame = gtk_frame_new ("Underlined label");
2017 label = gtk_label_new ("This label is underlined!\n"
2018 "This one is underlined (\343\201\223\343\202\223\343\201\253\343\201\241\343\201\257) in quite a funky fashion");
2019 gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
2020 gtk_label_set_pattern (GTK_LABEL (label), "_________________________ _ _________ _ _____ _ __ __ ___ ____ _____");
2021 gtk_container_add (GTK_CONTAINER (frame), label);
2022 gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
2024 frame = gtk_frame_new ("Markup label");
2025 label = gtk_label_new (NULL);
2027 /* There's also a gtk_label_set_markup() without accel if you
2028 * don't have an accelerator key
2030 gtk_label_set_markup_with_mnemonic (GTK_LABEL (label),
2031 "This <span foreground=\"blue\" background=\"orange\">label</span> has "
2032 "<b>markup</b> _such as "
2033 "<big><i>Big Italics</i></big>\n"
2034 "<tt>Monospace font</tt>\n"
2035 "<u>Underline!</u>\n"
2037 "<span foreground=\"green\" background=\"red\">Ugly colors</span>\n"
2038 "and nothing on this line,\n"
2041 "or even on this one\n"
2042 "la <big>la <big>la <big>la <big>la</big></big></big></big>\n"
2043 "but this _word is <span foreground=\"purple\"><big>purple</big></span>\n"
2044 "<span underline=\"double\">We like <sup>superscript</sup> and <sub>subscript</sub> too</span>");
2046 g_assert (gtk_label_get_mnemonic_keyval (GTK_LABEL (label)) == GDK_KEY_s);
2048 gtk_container_add (GTK_CONTAINER (frame), label);
2049 gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
2052 if (!gtk_widget_get_visible (window))
2053 gtk_widget_show_all (window);
2055 gtk_widget_destroy (window);
2059 on_angle_scale_changed (GtkRange *range,
2062 gtk_label_set_angle (GTK_LABEL (label), gtk_range_get_value (range));
2066 create_rotated_label (GtkWidget *widget)
2068 static GtkWidget *window = NULL;
2069 GtkWidget *content_area;
2073 GtkWidget *scale_label;
2074 GtkWidget *scale_hbox;
2078 window = gtk_dialog_new_with_buttons ("Rotated Label",
2079 GTK_WINDOW (gtk_widget_get_toplevel (widget)), 0,
2080 GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE,
2083 gtk_window_set_resizable (GTK_WINDOW (window), TRUE);
2085 gtk_window_set_screen (GTK_WINDOW (window),
2086 gtk_widget_get_screen (widget));
2088 g_signal_connect (window, "response",
2089 G_CALLBACK (gtk_widget_destroy), NULL);
2090 g_signal_connect (window, "destroy",
2091 G_CALLBACK (gtk_widget_destroyed), &window);
2093 content_area = gtk_dialog_get_content_area (GTK_DIALOG (window));
2095 vbox = gtk_vbox_new (FALSE, 5);
2096 gtk_box_pack_start (GTK_BOX (content_area), vbox, TRUE, TRUE, 0);
2097 gtk_container_set_border_width (GTK_CONTAINER (vbox), 10);
2099 label = gtk_label_new (NULL);
2100 gtk_label_set_markup (GTK_LABEL (label), "Hello World\n<i>Rotate</i> <span underline='single' foreground='blue'>me</span>");
2101 gtk_box_pack_start (GTK_BOX (vbox), label, TRUE, TRUE, 0);
2103 scale_hbox = gtk_hbox_new (FALSE, 0);
2104 gtk_box_pack_start (GTK_BOX (vbox), scale_hbox, FALSE, FALSE, 0);
2106 scale_label = gtk_label_new (NULL);
2107 gtk_label_set_markup (GTK_LABEL (scale_label), "<i>Angle: </i>");
2108 gtk_box_pack_start (GTK_BOX (scale_hbox), scale_label, FALSE, FALSE, 0);
2110 hscale = gtk_hscale_new_with_range (0, 360, 5);
2111 g_signal_connect (hscale, "value-changed",
2112 G_CALLBACK (on_angle_scale_changed), label);
2114 gtk_range_set_value (GTK_RANGE (hscale), 45);
2115 gtk_widget_set_size_request (hscale, 200, -1);
2116 gtk_box_pack_start (GTK_BOX (scale_hbox), hscale, TRUE, TRUE, 0);
2119 if (!gtk_widget_get_visible (window))
2120 gtk_widget_show_all (window);
2122 gtk_widget_destroy (window);
2125 #define DEFAULT_TEXT_RADIUS 200
2128 on_rotated_text_unrealize (GtkWidget *widget)
2130 g_object_set_data (G_OBJECT (widget), "text-gc", NULL);
2134 on_rotated_text_draw (GtkWidget *widget,
2136 GdkPixbuf *tile_pixbuf)
2138 static const gchar *words[] = { "The", "grand", "old", "Duke", "of", "York",
2139 "had", "10,000", "men" };
2144 PangoLayout *layout;
2145 PangoContext *context;
2146 PangoFontDescription *desc;
2150 gdk_cairo_set_source_pixbuf (cr, tile_pixbuf, 0, 0);
2151 cairo_pattern_set_extend (cairo_get_source (cr), CAIRO_EXTEND_REPEAT);
2154 cairo_set_source_rgb (cr, 0, 0, 0);
2156 width = gtk_widget_get_allocated_width (widget);
2157 height = gtk_widget_get_allocated_height (widget);
2158 radius = MIN (width, height) / 2.;
2160 cairo_translate (cr,
2161 radius + (width - 2 * radius) / 2,
2162 radius + (height - 2 * radius) / 2);
2163 cairo_scale (cr, radius / DEFAULT_TEXT_RADIUS, radius / DEFAULT_TEXT_RADIUS);
2165 context = gtk_widget_get_pango_context (widget);
2166 layout = pango_layout_new (context);
2167 desc = pango_font_description_from_string ("Sans Bold 30");
2168 pango_layout_set_font_description (layout, desc);
2169 pango_font_description_free (desc);
2171 n_words = G_N_ELEMENTS (words);
2172 for (i = 0; i < n_words; i++)
2178 cairo_rotate (cr, 2 * G_PI * i / n_words);
2179 pango_cairo_update_layout (cr, layout);
2181 pango_layout_set_text (layout, words[i], -1);
2182 pango_layout_get_size (layout, &width, &height);
2184 cairo_move_to (cr, - width / 2 / PANGO_SCALE, - DEFAULT_TEXT_RADIUS);
2185 pango_cairo_show_layout (cr, layout);
2190 g_object_unref (layout);
2196 create_rotated_text (GtkWidget *widget)
2198 static GtkWidget *window = NULL;
2202 const GdkColor white = { 0, 0xffff, 0xffff, 0xffff };
2203 GtkRequisition requisition;
2204 GtkWidget *content_area;
2205 GtkWidget *drawing_area;
2206 GdkPixbuf *tile_pixbuf;
2208 window = gtk_dialog_new_with_buttons ("Rotated Text",
2209 GTK_WINDOW (gtk_widget_get_toplevel (widget)), 0,
2210 GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE,
2213 gtk_window_set_resizable (GTK_WINDOW (window), TRUE);
2215 gtk_window_set_screen (GTK_WINDOW (window),
2216 gtk_widget_get_screen (widget));
2218 g_signal_connect (window, "response",
2219 G_CALLBACK (gtk_widget_destroy), NULL);
2220 g_signal_connect (window, "destroy",
2221 G_CALLBACK (gtk_widget_destroyed), &window);
2223 content_area = gtk_dialog_get_content_area (GTK_DIALOG (window));
2225 drawing_area = gtk_drawing_area_new ();
2226 gtk_box_pack_start (GTK_BOX (content_area), drawing_area, TRUE, TRUE, 0);
2227 gtk_widget_modify_bg (drawing_area, GTK_STATE_NORMAL, &white);
2229 tile_pixbuf = gdk_pixbuf_new_from_file ("marble.xpm", NULL);
2231 g_signal_connect (drawing_area, "draw",
2232 G_CALLBACK (on_rotated_text_draw), tile_pixbuf);
2233 g_signal_connect (drawing_area, "unrealize",
2234 G_CALLBACK (on_rotated_text_unrealize), NULL);
2236 gtk_widget_show_all (gtk_bin_get_child (GTK_BIN (window)));
2238 gtk_widget_set_size_request (drawing_area, DEFAULT_TEXT_RADIUS * 2, DEFAULT_TEXT_RADIUS * 2);
2239 gtk_widget_get_preferred_size ( (window),
2240 &requisition, NULL);
2241 gtk_widget_set_size_request (drawing_area, -1, -1);
2242 gtk_window_resize (GTK_WINDOW (window), requisition.width, requisition.height);
2245 if (!gtk_widget_get_visible (window))
2246 gtk_widget_show (window);
2248 gtk_widget_destroy (window);
2256 reparent_label (GtkWidget *widget,
2257 GtkWidget *new_parent)
2261 label = g_object_get_data (G_OBJECT (widget), "user_data");
2263 gtk_widget_reparent (label, new_parent);
2267 set_parent_signal (GtkWidget *child,
2268 GtkWidget *old_parent,
2273 parent = gtk_widget_get_parent (child);
2274 g_message ("set_parent for \"%s\": new parent: \"%s\", old parent: \"%s\", data: %d\n",
2275 g_type_name (G_OBJECT_TYPE (child)),
2276 parent ? g_type_name (G_OBJECT_TYPE (parent)) : "NULL",
2277 old_parent ? g_type_name (G_OBJECT_TYPE (old_parent)) : "NULL",
2278 GPOINTER_TO_INT (func_data));
2282 create_reparent (GtkWidget *widget)
2284 static GtkWidget *window = NULL;
2291 GtkWidget *separator;
2292 GtkWidget *event_box;
2296 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
2298 gtk_window_set_screen (GTK_WINDOW (window),
2299 gtk_widget_get_screen (widget));
2301 g_signal_connect (window, "destroy",
2302 G_CALLBACK (gtk_widget_destroyed),
2305 gtk_window_set_title (GTK_WINDOW (window), "reparent");
2306 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
2308 box1 = gtk_vbox_new (FALSE, 0);
2309 gtk_container_add (GTK_CONTAINER (window), box1);
2311 box2 = gtk_hbox_new (FALSE, 5);
2312 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
2313 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
2315 label = gtk_label_new ("Hello World");
2317 frame = gtk_frame_new ("Frame 1");
2318 gtk_box_pack_start (GTK_BOX (box2), frame, TRUE, TRUE, 0);
2320 box3 = gtk_vbox_new (FALSE, 5);
2321 gtk_container_set_border_width (GTK_CONTAINER (box3), 5);
2322 gtk_container_add (GTK_CONTAINER (frame), box3);
2324 button = gtk_button_new_with_label ("switch");
2325 g_object_set_data (G_OBJECT (button), "user_data", label);
2326 gtk_box_pack_start (GTK_BOX (box3), button, FALSE, TRUE, 0);
2328 event_box = gtk_event_box_new ();
2329 gtk_box_pack_start (GTK_BOX (box3), event_box, FALSE, TRUE, 0);
2330 gtk_container_add (GTK_CONTAINER (event_box), label);
2332 g_signal_connect (button, "clicked",
2333 G_CALLBACK (reparent_label),
2336 g_signal_connect (label, "parent_set",
2337 G_CALLBACK (set_parent_signal),
2338 GINT_TO_POINTER (42));
2340 frame = gtk_frame_new ("Frame 2");
2341 gtk_box_pack_start (GTK_BOX (box2), frame, TRUE, TRUE, 0);
2343 box3 = gtk_vbox_new (FALSE, 5);
2344 gtk_container_set_border_width (GTK_CONTAINER (box3), 5);
2345 gtk_container_add (GTK_CONTAINER (frame), box3);
2347 button = gtk_button_new_with_label ("switch");
2348 g_object_set_data (G_OBJECT (button), "user_data", label);
2349 gtk_box_pack_start (GTK_BOX (box3), button, FALSE, TRUE, 0);
2351 event_box = gtk_event_box_new ();
2352 gtk_box_pack_start (GTK_BOX (box3), event_box, FALSE, TRUE, 0);
2354 g_signal_connect (button, "clicked",
2355 G_CALLBACK (reparent_label),
2358 separator = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
2359 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
2361 box2 = gtk_vbox_new (FALSE, 10);
2362 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
2363 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
2365 button = gtk_button_new_with_label ("close");
2366 g_signal_connect_swapped (button, "clicked",
2367 G_CALLBACK (gtk_widget_destroy), window);
2368 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
2369 gtk_widget_set_can_default (button, TRUE);
2370 gtk_widget_grab_default (button);
2373 if (!gtk_widget_get_visible (window))
2374 gtk_widget_show_all (window);
2376 gtk_widget_destroy (window);
2383 grippy_button_press (GtkWidget *area, GdkEventButton *event, GdkWindowEdge edge)
2385 if (event->type == GDK_BUTTON_PRESS)
2387 if (event->button == 1)
2388 gtk_window_begin_resize_drag (GTK_WINDOW (gtk_widget_get_toplevel (area)), edge,
2389 event->button, event->x_root, event->y_root,
2391 else if (event->button == 2)
2392 gtk_window_begin_move_drag (GTK_WINDOW (gtk_widget_get_toplevel (area)),
2393 event->button, event->x_root, event->y_root,
2400 grippy_draw (GtkWidget *area, cairo_t *cr, GdkWindowEdge edge)
2402 gtk_paint_resize_grip (gtk_widget_get_style (area),
2404 gtk_widget_get_state (area),
2409 gtk_widget_get_allocated_width (area),
2410 gtk_widget_get_allocated_height (area));
2416 create_resize_grips (GtkWidget *widget)
2418 static GtkWidget *window = NULL;
2420 GtkWidget *hbox, *vbox;
2423 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
2425 gtk_window_set_screen (GTK_WINDOW (window),
2426 gtk_widget_get_screen (widget));
2428 gtk_window_set_title (GTK_WINDOW (window), "resize grips");
2430 g_signal_connect (window, "destroy",
2431 G_CALLBACK (gtk_widget_destroyed),
2434 vbox = gtk_vbox_new (FALSE, 0);
2435 gtk_container_add (GTK_CONTAINER (window), vbox);
2437 hbox = gtk_hbox_new (FALSE, 0);
2438 gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 0);
2441 area = gtk_drawing_area_new ();
2442 gtk_widget_add_events (area, GDK_BUTTON_PRESS_MASK);
2443 gtk_box_pack_start (GTK_BOX (hbox), area, TRUE, TRUE, 0);
2444 g_signal_connect (area, "draw", G_CALLBACK (grippy_draw),
2445 GINT_TO_POINTER (GDK_WINDOW_EDGE_NORTH_WEST));
2446 g_signal_connect (area, "button_press_event", G_CALLBACK (grippy_button_press),
2447 GINT_TO_POINTER (GDK_WINDOW_EDGE_NORTH_WEST));
2450 area = gtk_drawing_area_new ();
2451 gtk_widget_add_events (area, GDK_BUTTON_PRESS_MASK);
2452 gtk_box_pack_start (GTK_BOX (hbox), area, TRUE, TRUE, 0);
2453 g_signal_connect (area, "draw", G_CALLBACK (grippy_draw),
2454 GINT_TO_POINTER (GDK_WINDOW_EDGE_NORTH));
2455 g_signal_connect (area, "button_press_event", G_CALLBACK (grippy_button_press),
2456 GINT_TO_POINTER (GDK_WINDOW_EDGE_NORTH));
2459 area = gtk_drawing_area_new ();
2460 gtk_widget_add_events (area, GDK_BUTTON_PRESS_MASK);
2461 gtk_box_pack_start (GTK_BOX (hbox), area, TRUE, TRUE, 0);
2462 g_signal_connect (area, "draw", G_CALLBACK (grippy_draw),
2463 GINT_TO_POINTER (GDK_WINDOW_EDGE_NORTH_EAST));
2464 g_signal_connect (area, "button_press_event", G_CALLBACK (grippy_button_press),
2465 GINT_TO_POINTER (GDK_WINDOW_EDGE_NORTH_EAST));
2467 hbox = gtk_hbox_new (FALSE, 0);
2468 gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 0);
2471 area = gtk_drawing_area_new ();
2472 gtk_widget_add_events (area, GDK_BUTTON_PRESS_MASK);
2473 gtk_box_pack_start (GTK_BOX (hbox), area, TRUE, TRUE, 0);
2474 g_signal_connect (area, "draw", G_CALLBACK (grippy_draw),
2475 GINT_TO_POINTER (GDK_WINDOW_EDGE_WEST));
2476 g_signal_connect (area, "button_press_event", G_CALLBACK (grippy_button_press),
2477 GINT_TO_POINTER (GDK_WINDOW_EDGE_WEST));
2480 area = gtk_drawing_area_new ();
2481 gtk_box_pack_start (GTK_BOX (hbox), area, TRUE, TRUE, 0);
2484 area = gtk_drawing_area_new ();
2485 gtk_widget_add_events (area, GDK_BUTTON_PRESS_MASK);
2486 gtk_box_pack_start (GTK_BOX (hbox), area, TRUE, TRUE, 0);
2487 g_signal_connect (area, "draw", G_CALLBACK (grippy_draw),
2488 GINT_TO_POINTER (GDK_WINDOW_EDGE_EAST));
2489 g_signal_connect (area, "button_press_event", G_CALLBACK (grippy_button_press),
2490 GINT_TO_POINTER (GDK_WINDOW_EDGE_EAST));
2493 hbox = gtk_hbox_new (FALSE, 0);
2494 gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 0);
2497 area = gtk_drawing_area_new ();
2498 gtk_widget_add_events (area, GDK_BUTTON_PRESS_MASK);
2499 gtk_box_pack_start (GTK_BOX (hbox), area, TRUE, TRUE, 0);
2500 g_signal_connect (area, "draw", G_CALLBACK (grippy_draw),
2501 GINT_TO_POINTER (GDK_WINDOW_EDGE_SOUTH_WEST));
2502 g_signal_connect (area, "button_press_event", G_CALLBACK (grippy_button_press),
2503 GINT_TO_POINTER (GDK_WINDOW_EDGE_SOUTH_WEST));
2505 area = gtk_drawing_area_new ();
2506 gtk_widget_add_events (area, GDK_BUTTON_PRESS_MASK);
2507 gtk_box_pack_start (GTK_BOX (hbox), area, TRUE, TRUE, 0);
2508 g_signal_connect (area, "draw", G_CALLBACK (grippy_draw),
2509 GINT_TO_POINTER (GDK_WINDOW_EDGE_SOUTH));
2510 g_signal_connect (area, "button_press_event", G_CALLBACK (grippy_button_press),
2511 GINT_TO_POINTER (GDK_WINDOW_EDGE_SOUTH));
2514 area = gtk_drawing_area_new ();
2515 gtk_widget_add_events (area, GDK_BUTTON_PRESS_MASK);
2516 gtk_box_pack_start (GTK_BOX (hbox), area, TRUE, TRUE, 0);
2517 g_signal_connect (area, "draw", G_CALLBACK (grippy_draw),
2518 GINT_TO_POINTER (GDK_WINDOW_EDGE_SOUTH_EAST));
2519 g_signal_connect (area, "button_press_event", G_CALLBACK (grippy_button_press),
2520 GINT_TO_POINTER (GDK_WINDOW_EDGE_SOUTH_EAST));
2523 if (!gtk_widget_get_visible (window))
2524 gtk_widget_show_all (window);
2526 gtk_widget_destroy (window);
2532 gint upositionx = 0;
2533 gint upositiony = 0;
2536 uposition_configure (GtkWidget *window)
2542 lx = g_object_get_data (G_OBJECT (window), "x");
2543 ly = g_object_get_data (G_OBJECT (window), "y");
2545 gdk_window_get_root_origin (gtk_widget_get_window (window),
2546 &upositionx, &upositiony);
2547 sprintf (buffer, "%d", upositionx);
2548 gtk_label_set_text (lx, buffer);
2549 sprintf (buffer, "%d", upositiony);
2550 gtk_label_set_text (ly, buffer);
2556 uposition_stop_configure (GtkToggleButton *toggle,
2559 if (gtk_toggle_button_get_active (toggle))
2560 g_signal_handlers_block_by_func (window, G_CALLBACK (uposition_configure), NULL);
2562 g_signal_handlers_unblock_by_func (window, G_CALLBACK (uposition_configure), NULL);
2566 create_saved_position (GtkWidget *widget)
2568 static GtkWidget *window = NULL;
2573 GtkWidget *main_vbox;
2581 window = g_object_connect (g_object_new (GTK_TYPE_WINDOW,
2582 "type", GTK_WINDOW_TOPLEVEL,
2583 "title", "Saved Position",
2585 "signal::configure_event", uposition_configure, NULL,
2588 gtk_window_move (GTK_WINDOW (window), upositionx, upositiony);
2590 gtk_window_set_screen (GTK_WINDOW (window),
2591 gtk_widget_get_screen (widget));
2594 g_signal_connect (window, "destroy",
2595 G_CALLBACK (gtk_widget_destroyed),
2598 main_vbox = gtk_vbox_new (FALSE, 5);
2599 gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 0);
2600 gtk_container_add (GTK_CONTAINER (window), main_vbox);
2603 g_object_new (gtk_vbox_get_type (),
2604 "GtkBox::homogeneous", FALSE,
2605 "GtkBox::spacing", 5,
2606 "GtkContainer::border_width", 10,
2607 "GtkWidget::parent", main_vbox,
2608 "GtkWidget::visible", TRUE,
2609 "child", g_object_connect (g_object_new (GTK_TYPE_TOGGLE_BUTTON,
2610 "label", "Stop Events",
2614 "signal::clicked", uposition_stop_configure, window,
2618 hbox = gtk_hbox_new (FALSE, 0);
2619 gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
2620 gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0);
2622 label = gtk_label_new ("X Origin : ");
2623 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
2624 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
2626 x_label = gtk_label_new ("");
2627 gtk_box_pack_start (GTK_BOX (hbox), x_label, TRUE, TRUE, 0);
2628 g_object_set_data (G_OBJECT (window), "x", x_label);
2630 hbox = gtk_hbox_new (FALSE, 0);
2631 gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
2632 gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0);
2634 label = gtk_label_new ("Y Origin : ");
2635 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
2636 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
2638 y_label = gtk_label_new ("");
2639 gtk_box_pack_start (GTK_BOX (hbox), y_label, TRUE, TRUE, 0);
2640 g_object_set_data (G_OBJECT (window), "y", y_label);
2643 g_object_new (gtk_hseparator_get_type (),
2644 "GtkWidget::visible", TRUE,
2646 gtk_box_pack_start (GTK_BOX (main_vbox), any, FALSE, TRUE, 0);
2648 hbox = gtk_hbox_new (FALSE, 0);
2649 gtk_container_set_border_width (GTK_CONTAINER (hbox), 10);
2650 gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, TRUE, 0);
2652 button = gtk_button_new_with_label ("Close");
2653 g_signal_connect_swapped (button, "clicked",
2654 G_CALLBACK (gtk_widget_destroy),
2656 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
2657 gtk_widget_set_can_default (button, TRUE);
2658 gtk_widget_grab_default (button);
2660 gtk_widget_show_all (window);
2663 gtk_widget_destroy (window);
2671 create_pixbuf (GtkWidget *widget)
2673 static GtkWidget *window = NULL;
2679 GtkWidget *separator;
2680 GtkWidget *pixbufwid;
2681 GdkWindow *gdk_window;
2685 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
2687 gtk_window_set_screen (GTK_WINDOW (window),
2688 gtk_widget_get_screen (widget));
2690 g_signal_connect (window, "destroy",
2691 G_CALLBACK (gtk_widget_destroyed),
2694 gtk_window_set_title (GTK_WINDOW (window), "GtkPixmap");
2695 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
2696 gtk_widget_realize(window);
2698 box1 = gtk_vbox_new (FALSE, 0);
2699 gtk_container_add (GTK_CONTAINER (window), box1);
2701 box2 = gtk_vbox_new (FALSE, 10);
2702 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
2703 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
2705 button = gtk_button_new ();
2706 gtk_box_pack_start (GTK_BOX (box2), button, FALSE, FALSE, 0);
2708 gdk_window = gtk_widget_get_window (window);
2710 pixbufwid = new_pixbuf ("test.xpm", gdk_window, NULL);
2712 label = gtk_label_new ("Pixbuf\ntest");
2713 box3 = gtk_hbox_new (FALSE, 0);
2714 gtk_container_set_border_width (GTK_CONTAINER (box3), 2);
2715 gtk_container_add (GTK_CONTAINER (box3), pixbufwid);
2716 gtk_container_add (GTK_CONTAINER (box3), label);
2717 gtk_container_add (GTK_CONTAINER (button), box3);
2719 button = gtk_button_new ();
2720 gtk_box_pack_start (GTK_BOX (box2), button, FALSE, FALSE, 0);
2722 pixbufwid = new_pixbuf ("test.xpm", gdk_window, NULL);
2724 label = gtk_label_new ("Pixbuf\ntest");
2725 box3 = gtk_hbox_new (FALSE, 0);
2726 gtk_container_set_border_width (GTK_CONTAINER (box3), 2);
2727 gtk_container_add (GTK_CONTAINER (box3), pixbufwid);
2728 gtk_container_add (GTK_CONTAINER (box3), label);
2729 gtk_container_add (GTK_CONTAINER (button), box3);
2731 gtk_widget_set_sensitive (button, FALSE);
2733 separator = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
2734 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
2736 box2 = gtk_vbox_new (FALSE, 10);
2737 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
2738 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
2740 button = gtk_button_new_with_label ("close");
2741 g_signal_connect_swapped (button, "clicked",
2742 G_CALLBACK (gtk_widget_destroy),
2744 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
2745 gtk_widget_set_can_default (button, TRUE);
2746 gtk_widget_grab_default (button);
2749 if (!gtk_widget_get_visible (window))
2750 gtk_widget_show_all (window);
2752 gtk_widget_destroy (window);
2756 create_tooltips (GtkWidget *widget)
2758 static GtkWidget *window = NULL;
2765 GtkWidget *separator;
2770 g_object_new (gtk_window_get_type (),
2771 "GtkWindow::type", GTK_WINDOW_TOPLEVEL,
2772 "GtkContainer::border_width", 0,
2773 "GtkWindow::title", "Tooltips",
2774 "GtkWindow::resizable", FALSE,
2777 gtk_window_set_screen (GTK_WINDOW (window),
2778 gtk_widget_get_screen (widget));
2780 box1 = gtk_vbox_new (FALSE, 0);
2781 gtk_container_add (GTK_CONTAINER (window), box1);
2783 box2 = gtk_vbox_new (FALSE, 10);
2784 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
2785 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
2787 button = gtk_toggle_button_new_with_label ("button1");
2788 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
2790 gtk_widget_set_tooltip_text (button, "This is button 1");
2792 button = gtk_toggle_button_new_with_label ("button2");
2793 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
2795 gtk_widget_set_tooltip_text (button,
2796 "This is button 2. This is also a really long tooltip which probably "
2797 "won't fit on a single line and will therefore need to be wrapped. "
2798 "Hopefully the wrapping will work correctly.");
2800 toggle = gtk_toggle_button_new_with_label ("Override TipsQuery Label");
2801 gtk_box_pack_start (GTK_BOX (box2), toggle, TRUE, TRUE, 0);
2803 gtk_widget_set_tooltip_text (toggle, "Toggle TipsQuery view.");
2806 g_object_new (gtk_vbox_get_type (),
2807 "homogeneous", FALSE,
2814 g_object_new (gtk_button_get_type (),
2819 gtk_box_set_child_packing (GTK_BOX (box3), button, FALSE, FALSE, 0, GTK_PACK_START);
2820 gtk_widget_set_tooltip_text (button, "Start the Tooltips Inspector");
2822 frame = g_object_new (gtk_frame_get_type (),
2823 "label", "ToolTips Inspector",
2824 "label_xalign", (double) 0.5,
2830 gtk_box_set_child_packing (GTK_BOX (box2), frame, TRUE, TRUE, 10, GTK_PACK_START);
2832 separator = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
2833 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
2835 box2 = gtk_vbox_new (FALSE, 10);
2836 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
2837 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
2839 button = gtk_button_new_with_label ("close");
2840 g_signal_connect_swapped (button, "clicked",
2841 G_CALLBACK (gtk_widget_destroy),
2843 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
2844 gtk_widget_set_can_default (button, TRUE);
2845 gtk_widget_grab_default (button);
2847 gtk_widget_set_tooltip_text (button, "Push this button to close window");
2850 if (!gtk_widget_get_visible (window))
2851 gtk_widget_show_all (window);
2853 gtk_widget_destroy (window);
2861 pack_image (GtkWidget *box,
2865 gtk_box_pack_start (GTK_BOX (box),
2866 gtk_label_new (text),
2869 gtk_box_pack_start (GTK_BOX (box),
2875 create_image (GtkWidget *widget)
2877 static GtkWidget *window = NULL;
2884 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
2886 gtk_window_set_screen (GTK_WINDOW (window),
2887 gtk_widget_get_screen (widget));
2889 /* this is bogus for testing drawing when allocation < request,
2890 * don't copy into real code
2892 gtk_window_set_resizable (GTK_WINDOW (window), TRUE);
2894 g_signal_connect (window, "destroy",
2895 G_CALLBACK (gtk_widget_destroyed),
2898 vbox = gtk_vbox_new (FALSE, 5);
2900 gtk_container_add (GTK_CONTAINER (window), vbox);
2902 pack_image (vbox, "Stock Warning Dialog",
2903 gtk_image_new_from_stock (GTK_STOCK_DIALOG_WARNING,
2904 GTK_ICON_SIZE_DIALOG));
2906 pixbuf = gdk_pixbuf_new_from_xpm_data ((const char **) openfile);
2908 pack_image (vbox, "Pixbuf",
2909 gtk_image_new_from_pixbuf (pixbuf));
2911 g_object_unref (pixbuf);
2914 if (!gtk_widget_get_visible (window))
2915 gtk_widget_show_all (window);
2917 gtk_widget_destroy (window);
2925 create_menu (GdkScreen *screen, gint depth, gint length, gboolean tearoff)
2928 GtkWidget *menuitem;
2937 menu = gtk_menu_new ();
2938 gtk_menu_set_screen (GTK_MENU (menu), screen);
2944 menuitem = gtk_tearoff_menu_item_new ();
2945 gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
2946 gtk_widget_show (menuitem);
2949 image = gtk_image_new_from_stock (GTK_STOCK_OPEN,
2950 GTK_ICON_SIZE_MENU);
2951 gtk_widget_show (image);
2952 menuitem = gtk_image_menu_item_new_with_label ("Image item");
2953 gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menuitem), image);
2954 gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
2955 gtk_widget_show (menuitem);
2957 for (i = 0, j = 1; i < length; i++, j++)
2959 sprintf (buf, "item %2d - %d", depth, j);
2961 menuitem = gtk_radio_menu_item_new_with_label (group, buf);
2962 group = gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (menuitem));
2964 gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
2965 gtk_widget_show (menuitem);
2967 gtk_widget_set_sensitive (menuitem, FALSE);
2970 gtk_check_menu_item_set_inconsistent (GTK_CHECK_MENU_ITEM (menuitem),
2974 gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem),
2975 create_menu (screen, depth - 1, 5, TRUE));
2982 create_table_menu (GdkScreen *screen, gint cols, gint rows, gboolean tearoff)
2985 GtkWidget *menuitem;
2991 menu = gtk_menu_new ();
2992 gtk_menu_set_screen (GTK_MENU (menu), screen);
2997 menuitem = gtk_tearoff_menu_item_new ();
2998 gtk_menu_attach (GTK_MENU (menu), menuitem, 0, cols, j, j + 1);
2999 gtk_widget_show (menuitem);
3003 menuitem = gtk_menu_item_new_with_label ("items");
3004 gtk_menu_attach (GTK_MENU (menu), menuitem, 0, cols, j, j + 1);
3006 submenu = gtk_menu_new ();
3007 gtk_menu_set_screen (GTK_MENU (submenu), screen);
3008 gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), submenu);
3009 gtk_widget_show (menuitem);
3012 /* now fill the items submenu */
3013 image = gtk_image_new_from_stock (GTK_STOCK_HELP,
3014 GTK_ICON_SIZE_MENU);
3015 gtk_widget_show (image);
3016 menuitem = gtk_image_menu_item_new_with_label ("Image");
3017 gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menuitem), image);
3018 gtk_menu_attach (GTK_MENU (submenu), menuitem, 0, 1, 0, 1);
3019 gtk_widget_show (menuitem);
3021 menuitem = gtk_menu_item_new_with_label ("x");
3022 gtk_menu_attach (GTK_MENU (submenu), menuitem, 1, 2, 0, 1);
3023 gtk_widget_show (menuitem);
3025 menuitem = gtk_menu_item_new_with_label ("x");
3026 gtk_menu_attach (GTK_MENU (submenu), menuitem, 0, 1, 1, 2);
3027 gtk_widget_show (menuitem);
3029 image = gtk_image_new_from_stock (GTK_STOCK_HELP,
3030 GTK_ICON_SIZE_MENU);
3031 gtk_widget_show (image);
3032 menuitem = gtk_image_menu_item_new_with_label ("Image");
3033 gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menuitem), image);
3034 gtk_menu_attach (GTK_MENU (submenu), menuitem, 1, 2, 1, 2);
3035 gtk_widget_show (menuitem);
3037 menuitem = gtk_radio_menu_item_new_with_label (NULL, "Radio");
3038 gtk_menu_attach (GTK_MENU (submenu), menuitem, 0, 1, 2, 3);
3039 gtk_widget_show (menuitem);
3041 menuitem = gtk_menu_item_new_with_label ("x");
3042 gtk_menu_attach (GTK_MENU (submenu), menuitem, 1, 2, 2, 3);
3043 gtk_widget_show (menuitem);
3045 menuitem = gtk_menu_item_new_with_label ("x");
3046 gtk_menu_attach (GTK_MENU (submenu), menuitem, 0, 1, 3, 4);
3047 gtk_widget_show (menuitem);
3049 menuitem = gtk_radio_menu_item_new_with_label (NULL, "Radio");
3050 gtk_menu_attach (GTK_MENU (submenu), menuitem, 1, 2, 3, 4);
3051 gtk_widget_show (menuitem);
3053 menuitem = gtk_check_menu_item_new_with_label ("Check");
3054 gtk_menu_attach (GTK_MENU (submenu), menuitem, 0, 1, 4, 5);
3055 gtk_widget_show (menuitem);
3057 menuitem = gtk_menu_item_new_with_label ("x");
3058 gtk_menu_attach (GTK_MENU (submenu), menuitem, 1, 2, 4, 5);
3059 gtk_widget_show (menuitem);
3061 menuitem = gtk_menu_item_new_with_label ("x");
3062 gtk_menu_attach (GTK_MENU (submenu), menuitem, 0, 1, 5, 6);
3063 gtk_widget_show (menuitem);
3065 menuitem = gtk_check_menu_item_new_with_label ("Check");
3066 gtk_menu_attach (GTK_MENU (submenu), menuitem, 1, 2, 5, 6);
3067 gtk_widget_show (menuitem);
3069 menuitem = gtk_menu_item_new_with_label ("1. Inserted normally (8)");
3070 gtk_widget_show (menuitem);
3071 gtk_menu_shell_insert (GTK_MENU_SHELL (submenu), menuitem, 8);
3073 menuitem = gtk_menu_item_new_with_label ("2. Inserted normally (2)");
3074 gtk_widget_show (menuitem);
3075 gtk_menu_shell_insert (GTK_MENU_SHELL (submenu), menuitem, 2);
3077 menuitem = gtk_menu_item_new_with_label ("3. Inserted normally (0)");
3078 gtk_widget_show (menuitem);
3079 gtk_menu_shell_insert (GTK_MENU_SHELL (submenu), menuitem, 0);
3081 menuitem = gtk_menu_item_new_with_label ("4. Inserted normally (-1)");
3082 gtk_widget_show (menuitem);
3083 gtk_menu_shell_insert (GTK_MENU_SHELL (submenu), menuitem, -1);
3085 /* end of items submenu */
3087 menuitem = gtk_menu_item_new_with_label ("spanning");
3088 gtk_menu_attach (GTK_MENU (menu), menuitem, 0, cols, j, j + 1);
3090 submenu = gtk_menu_new ();
3091 gtk_menu_set_screen (GTK_MENU (submenu), screen);
3092 gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), submenu);
3093 gtk_widget_show (menuitem);
3096 /* now fill the spanning submenu */
3097 menuitem = gtk_menu_item_new_with_label ("a");
3098 gtk_menu_attach (GTK_MENU (submenu), menuitem, 0, 2, 0, 1);
3099 gtk_widget_show (menuitem);
3101 menuitem = gtk_menu_item_new_with_label ("b");
3102 gtk_menu_attach (GTK_MENU (submenu), menuitem, 2, 3, 0, 2);
3103 gtk_widget_show (menuitem);
3105 menuitem = gtk_menu_item_new_with_label ("c");
3106 gtk_menu_attach (GTK_MENU (submenu), menuitem, 0, 1, 1, 3);
3107 gtk_widget_show (menuitem);
3109 menuitem = gtk_menu_item_new_with_label ("d");
3110 gtk_menu_attach (GTK_MENU (submenu), menuitem, 1, 2, 1, 2);
3111 gtk_widget_show (menuitem);
3113 menuitem = gtk_menu_item_new_with_label ("e");
3114 gtk_menu_attach (GTK_MENU (submenu), menuitem, 1, 3, 2, 3);
3115 gtk_widget_show (menuitem);
3116 /* end of spanning submenu */
3118 menuitem = gtk_menu_item_new_with_label ("left");
3119 gtk_menu_attach (GTK_MENU (menu), menuitem, 0, 1, j, j + 1);
3120 submenu = gtk_menu_new ();
3121 gtk_menu_set_screen (GTK_MENU (submenu), screen);
3122 gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), submenu);
3123 gtk_widget_show (menuitem);
3125 menuitem = gtk_menu_item_new_with_label ("Empty");
3126 gtk_menu_attach (GTK_MENU (submenu), menuitem, 0, 1, 0, 1);
3127 submenu = gtk_menu_new ();
3128 gtk_menu_set_screen (GTK_MENU (submenu), screen);
3129 gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), submenu);
3130 gtk_widget_show (menuitem);
3132 menuitem = gtk_menu_item_new_with_label ("right");
3133 gtk_menu_attach (GTK_MENU (menu), menuitem, 1, 2, j, j + 1);
3134 submenu = gtk_menu_new ();
3135 gtk_menu_set_screen (GTK_MENU (submenu), screen);
3136 gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), submenu);
3137 gtk_widget_show (menuitem);
3139 menuitem = gtk_menu_item_new_with_label ("Empty");
3140 gtk_menu_attach (GTK_MENU (submenu), menuitem, 0, 1, 0, 1);
3141 gtk_widget_show (menuitem);
3145 for (; j < rows; j++)
3146 for (i = 0; i < cols; i++)
3148 sprintf (buf, "(%d %d)", i, j);
3149 menuitem = gtk_menu_item_new_with_label (buf);
3150 gtk_menu_attach (GTK_MENU (menu), menuitem, i, i + 1, j, j + 1);
3151 gtk_widget_show (menuitem);
3154 menuitem = gtk_menu_item_new_with_label ("1. Inserted normally (8)");
3155 gtk_menu_shell_insert (GTK_MENU_SHELL (menu), menuitem, 8);
3156 gtk_widget_show (menuitem);
3157 menuitem = gtk_menu_item_new_with_label ("2. Inserted normally (2)");
3158 gtk_menu_shell_insert (GTK_MENU_SHELL (menu), menuitem, 2);
3159 gtk_widget_show (menuitem);
3160 menuitem = gtk_menu_item_new_with_label ("3. Inserted normally (0)");
3161 gtk_menu_shell_insert (GTK_MENU_SHELL (menu), menuitem, 0);
3162 gtk_widget_show (menuitem);
3163 menuitem = gtk_menu_item_new_with_label ("4. Inserted normally (-1)");
3164 gtk_menu_shell_insert (GTK_MENU_SHELL (menu), menuitem, -1);
3165 gtk_widget_show (menuitem);
3171 create_menus (GtkWidget *widget)
3173 static GtkWidget *window = NULL;
3177 GtkWidget *optionmenu;
3178 GtkWidget *separator;
3184 GtkWidget *menuitem;
3185 GtkAccelGroup *accel_group;
3187 GdkScreen *screen = gtk_widget_get_screen (widget);
3189 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
3191 gtk_window_set_screen (GTK_WINDOW (window), screen);
3193 g_signal_connect (window, "destroy",
3194 G_CALLBACK (gtk_widget_destroyed),
3196 g_signal_connect (window, "delete-event",
3197 G_CALLBACK (gtk_true),
3200 accel_group = gtk_accel_group_new ();
3201 gtk_window_add_accel_group (GTK_WINDOW (window), accel_group);
3203 gtk_window_set_title (GTK_WINDOW (window), "menus");
3204 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
3207 box1 = gtk_vbox_new (FALSE, 0);
3208 gtk_container_add (GTK_CONTAINER (window), box1);
3209 gtk_widget_show (box1);
3211 menubar = gtk_menu_bar_new ();
3212 gtk_box_pack_start (GTK_BOX (box1), menubar, FALSE, TRUE, 0);
3213 gtk_widget_show (menubar);
3215 menu = create_menu (screen, 2, 50, TRUE);
3217 menuitem = gtk_menu_item_new_with_label ("test\nline2");
3218 gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), menu);
3219 gtk_menu_shell_append (GTK_MENU_SHELL (menubar), menuitem);
3220 gtk_widget_show (menuitem);
3222 menu = create_table_menu (screen, 2, 50, TRUE);
3224 menuitem = gtk_menu_item_new_with_label ("table");
3225 gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), menu);
3226 gtk_menu_shell_append (GTK_MENU_SHELL (menubar), menuitem);
3227 gtk_widget_show (menuitem);
3229 menuitem = gtk_menu_item_new_with_label ("foo");
3230 gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), create_menu (screen, 3, 5, TRUE));
3231 gtk_menu_shell_append (GTK_MENU_SHELL (menubar), menuitem);
3232 gtk_widget_show (menuitem);
3234 image = gtk_image_new_from_stock (GTK_STOCK_HELP,
3235 GTK_ICON_SIZE_MENU);
3236 gtk_widget_show (image);
3237 menuitem = gtk_image_menu_item_new_with_label ("Help");
3238 gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menuitem), image);
3239 gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), create_menu (screen, 4, 5, TRUE));
3240 gtk_menu_item_set_right_justified (GTK_MENU_ITEM (menuitem), TRUE);
3241 gtk_menu_shell_append (GTK_MENU_SHELL (menubar), menuitem);
3242 gtk_widget_show (menuitem);
3244 menubar = gtk_menu_bar_new ();
3245 gtk_box_pack_start (GTK_BOX (box1), menubar, FALSE, TRUE, 0);
3246 gtk_widget_show (menubar);
3248 menu = create_menu (screen, 2, 10, TRUE);
3250 menuitem = gtk_menu_item_new_with_label ("Second menu bar");
3251 gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), menu);
3252 gtk_menu_shell_append (GTK_MENU_SHELL (menubar), menuitem);
3253 gtk_widget_show (menuitem);
3255 box2 = gtk_vbox_new (FALSE, 10);
3256 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
3257 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
3258 gtk_widget_show (box2);
3260 menu = create_menu (screen, 1, 5, FALSE);
3261 gtk_menu_set_accel_group (GTK_MENU (menu), accel_group);
3263 menuitem = gtk_image_menu_item_new_from_stock (GTK_STOCK_NEW, accel_group);
3264 gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
3265 gtk_widget_show (menuitem);
3267 menuitem = gtk_check_menu_item_new_with_label ("Accelerate Me");
3268 gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
3269 gtk_widget_show (menuitem);
3270 gtk_widget_add_accelerator (menuitem,
3276 menuitem = gtk_check_menu_item_new_with_label ("Accelerator Locked");
3277 gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
3278 gtk_widget_show (menuitem);
3279 gtk_widget_add_accelerator (menuitem,
3284 GTK_ACCEL_VISIBLE | GTK_ACCEL_LOCKED);
3285 menuitem = gtk_check_menu_item_new_with_label ("Accelerators Frozen");
3286 gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
3287 gtk_widget_show (menuitem);
3288 gtk_widget_add_accelerator (menuitem,
3294 gtk_widget_add_accelerator (menuitem,
3301 optionmenu = gtk_combo_box_text_new ();
3302 gtk_combo_box_set_active (GTK_COMBO_BOX (optionmenu), 3);
3303 gtk_box_pack_start (GTK_BOX (box2), optionmenu, TRUE, TRUE, 0);
3304 gtk_widget_show (optionmenu);
3306 separator = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
3307 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
3308 gtk_widget_show (separator);
3310 box2 = gtk_vbox_new (FALSE, 10);
3311 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
3312 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
3313 gtk_widget_show (box2);
3315 button = gtk_button_new_with_label ("close");
3316 g_signal_connect_swapped (button, "clicked",
3317 G_CALLBACK (gtk_widget_destroy),
3319 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
3320 gtk_widget_set_can_default (button, TRUE);
3321 gtk_widget_grab_default (button);
3322 gtk_widget_show (button);
3325 if (!gtk_widget_get_visible (window))
3326 gtk_widget_show (window);
3328 gtk_widget_destroy (window);
3331 /* GdkPixbuf RGBA C-Source image dump */
3333 static const guint8 apple[] =
3335 /* Pixbuf magic (0x47646b50) */
3337 /* length: header (24) + pixel_data (2304) */
3339 /* pixdata_type (0x1010002) */
3341 /* rowstride (96) */
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\0\0"
3354 "\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"
3355 "\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"
3356 "\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"
3357 "[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"
3358 "\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"
3359 "\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"
3360 "\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"
3361 "\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"
3362 "\0\0\0\0\0\0`l\\\20iw_\356y\211h\373x\207g\364~\216i\364u\204e\366gt"
3363 "_\374^jX\241A;-_\0\0\0~\0\0\0\0SM4)SM21B9&\22\320\270\204\1\320\270\204"
3364 "\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"
3365 "]\212r\200c\366v\205f\371jx_\323_kY\232_kZH^jY\26]iW\211@G9\272:6%j\220"
3366 "\211]\320\221\211`\377\212\203Z\377~xP\377mkE\331]^;|/0\37\21\0\0\0\0"
3367 "\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["
3368 "eT<\216\200Z\203\227\211_\354\234\217c\377\232\217b\362\232\220c\337"
3369 "\243\233k\377\252\241p\377\250\236p\377\241\225h\377\231\214_\377\210"
3370 "\202U\377srI\377[]:\355KO0U\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0i"
3371 "v^\200`lY\211^jY\"\0\0\0\0\221\204\\\273\250\233r\377\302\267\224\377"
3372 "\311\300\237\377\272\256\204\377\271\256\177\377\271\257\200\377\267"
3373 "\260\177\377\260\251x\377\250\236l\377\242\225e\377\226\213]\377~zP\377"
3374 "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"
3375 "\0\213\203[v\253\240t\377\334\326\301\377\344\340\317\377\321\312\253"
3376 "\377\303\271\217\377\300\270\213\377\277\267\210\377\272\264\203\377"
3377 "\261\255z\377\250\242n\377\243\232h\377\232\220`\377\210\202V\377nnE"
3378 "\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"
3379 "\234\222e\362\304\274\232\377\337\333\306\377\332\325\273\377\311\302"
3380 "\232\377\312\303\236\377\301\273\216\377\300\271\212\377\270\264\200"
3381 "\377\256\253v\377\246\243n\377\236\232h\377\230\220`\377\213\203V\377"
3382 "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"
3383 "\203Zl\242\234l\377\321\315\260\377\331\324\271\377\320\313\251\377\307"
3384 "\301\232\377\303\276\224\377\300\272\214\377\274\267\206\377\264\260"
3385 "|\377\253\251s\377\244\243n\377\232\230e\377\223\216^\377\207\200U\377"
3386 "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"
3387 "\210\204Y\240\245\237o\377\316\310\253\377\310\303\237\377\304\300\230"
3388 "\377\303\277\225\377\277\272\216\377\274\270\210\377\266\263\200\377"
3389 "\256\254v\377\247\246p\377\237\236j\377\227\226d\377\215\212[\377\203"
3390 "\177T\377qsH\377X]8\377FN.\377DK-\200\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
3391 "\0\0\0\0\207\204X\257\244\240o\377\300\275\231\377\301\275\226\377\274"
3392 "\270\213\377\274\270\214\377\267\264\205\377\264\262\200\377\260\256"
3393 "z\377\251\251s\377\243\244n\377\231\232g\377\220\222`\377\210\211Y\377"
3394 "|}Q\377hlC\377PU3\377CK,\377DL/Y\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
3395 "\0\0\205\204X\220\232\230h\377\261\260\204\377\266\264\212\377\261\260"
3396 "\201\377\263\260\200\377\260\257}\377\256\256x\377\253\254t\377\244\246"
3397 "o\377\233\236i\377\221\224b\377\211\214\\\377\202\204V\377txM\377]b>"
3398 "\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>"
3399 "\215\215_\377\237\237r\377\247\247x\377\247\247t\377\252\252w\377\252"
3400 "\252u\377\252\253t\377\243\246o\377\235\240j\377\223\230c\377\213\217"
3401 "]\377\201\206V\377x}P\377gkD\377RY5\377BI,\377AI,\262\0\0\0\0\0\0\0\0"
3402 "\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"
3403 "\232g\377\234\236i\377\236\241l\377\241\244n\377\240\244m\377\232\237"
3404 "i\377\223\230c\377\212\221]\377\200\210W\377v|P\377jnG\377Za>\377HP2"
3405 "\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"
3406 "\0wzQ6\177\201U\371\206\211Z\377\216\222`\377\220\225a\377\220\225b\377"
3407 "\220\226a\377\213\221_\377\204\213Z\377{\203R\377ryN\377iqH\377^fA\377"
3408 "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"
3409 "\0\0\0\0\0\0\0\0\0\0\0\0ptJTw|Q\371z\177R\377}\202T\377|\203T\377z\200"
3410 "R\377v|O\377pwL\377jpF\377dlB\377`hB\377Yb@\377LT6\377<C*\377\11\12\6"
3411 "\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"
3412 "\0\0\0\0\0\0\0\0\0\0\\`=UgnE\370hnG\377gmE\377djB\377]d>\377[c<\377Y"
3413 "b<\377Zc>\377V_>\377OW8\377BK/\377\16\20\12\377\0\0\0\377\0\0\0\377\0"
3414 "\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"
3415 "\0\1\0\0\0\40\22\24\15\260@D+\377W`;\377OV5\377.3\36\377.3\37\377IP0"
3416 "\377RZ7\377PZ8\3776=&\377\14\15\10\377\0\0\0\377\0\0\0\377\0\0\0\377"
3417 "\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"
3418 "\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"
3419 "\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"
3420 "\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"
3421 "\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"
3422 "\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"
3423 "\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"
3424 "\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"
3425 "\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"
3426 "\0\0\5\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"};
3430 accel_button_new (GtkAccelGroup *accel_group,
3435 GdkModifierType modifiers;
3439 gtk_accelerator_parse (accel, &keyval, &modifiers);
3442 button = gtk_button_new ();
3443 gtk_widget_add_accelerator (button, "activate", accel_group,
3444 keyval, modifiers, GTK_ACCEL_VISIBLE | GTK_ACCEL_LOCKED);
3446 label = gtk_accel_label_new (text);
3447 gtk_accel_label_set_accel_widget (GTK_ACCEL_LABEL (label), button);
3448 gtk_widget_show (label);
3450 gtk_container_add (GTK_CONTAINER (button), label);
3456 create_key_lookup (GtkWidget *widget)
3458 static GtkWidget *window = NULL;
3459 gpointer window_ptr;
3463 GtkAccelGroup *accel_group = gtk_accel_group_new ();
3465 GtkWidget *content_area;
3467 window = gtk_dialog_new_with_buttons ("Key Lookup", NULL, 0,
3468 GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE,
3471 gtk_window_set_screen (GTK_WINDOW (window),
3472 gtk_widget_get_screen (widget));
3474 /* We have to expand it so the accel labels will draw their labels
3476 gtk_window_set_default_size (GTK_WINDOW (window), 300, -1);
3478 gtk_window_add_accel_group (GTK_WINDOW (window), accel_group);
3480 content_area = gtk_dialog_get_content_area (GTK_DIALOG (window));
3482 button = gtk_button_new_with_mnemonic ("Button 1 (_a)");
3483 gtk_box_pack_start (GTK_BOX (content_area), button, FALSE, FALSE, 0);
3484 button = gtk_button_new_with_mnemonic ("Button 2 (_A)");
3485 gtk_box_pack_start (GTK_BOX (content_area), button, FALSE, FALSE, 0);
3486 button = gtk_button_new_with_mnemonic ("Button 3 (_\321\204)");
3487 gtk_box_pack_start (GTK_BOX (content_area), button, FALSE, FALSE, 0);
3488 button = gtk_button_new_with_mnemonic ("Button 4 (_\320\244)");
3489 gtk_box_pack_start (GTK_BOX (content_area), button, FALSE, FALSE, 0);
3490 button = gtk_button_new_with_mnemonic ("Button 6 (_b)");
3491 gtk_box_pack_start (GTK_BOX (content_area), button, FALSE, FALSE, 0);
3492 button = accel_button_new (accel_group, "Button 7", "<Alt><Shift>b");
3493 gtk_box_pack_start (GTK_BOX (content_area), button, FALSE, FALSE, 0);
3494 button = accel_button_new (accel_group, "Button 8", "<Alt>d");
3495 gtk_box_pack_start (GTK_BOX (content_area), button, FALSE, FALSE, 0);
3496 button = accel_button_new (accel_group, "Button 9", "<Alt>Cyrillic_ve");
3497 gtk_box_pack_start (GTK_BOX (content_area), button, FALSE, FALSE, 0);
3498 button = gtk_button_new_with_mnemonic ("Button 10 (_1)");
3499 gtk_box_pack_start (GTK_BOX (content_area), button, FALSE, FALSE, 0);
3500 button = gtk_button_new_with_mnemonic ("Button 11 (_!)");
3501 gtk_box_pack_start (GTK_BOX (content_area), button, FALSE, FALSE, 0);
3502 button = accel_button_new (accel_group, "Button 12", "<Super>a");
3503 gtk_box_pack_start (GTK_BOX (content_area), button, FALSE, FALSE, 0);
3504 button = accel_button_new (accel_group, "Button 13", "<Hyper>a");
3505 gtk_box_pack_start (GTK_BOX (content_area), button, FALSE, FALSE, 0);
3506 button = accel_button_new (accel_group, "Button 14", "<Meta>a");
3507 gtk_box_pack_start (GTK_BOX (content_area), button, FALSE, FALSE, 0);
3508 button = accel_button_new (accel_group, "Button 15", "<Shift><Mod4>b");
3509 gtk_box_pack_start (GTK_BOX (content_area), button, FALSE, FALSE, 0);
3511 window_ptr = &window;
3512 g_object_add_weak_pointer (G_OBJECT (window), window_ptr);
3513 g_signal_connect (window, "response", G_CALLBACK (gtk_widget_destroy), NULL);
3515 gtk_widget_show_all (window);
3518 gtk_widget_destroy (window);
3527 cmw_destroy_cb(GtkWidget *widget)
3529 /* This is needed to get out of gtk_main */
3536 cmw_color (GtkWidget *widget, GtkWidget *parent)
3539 GtkWidget *colorsel;
3540 GtkWidget *ok_button, *cancel_button;
3542 csd = gtk_color_selection_dialog_new ("This is a modal color selection dialog");
3544 gtk_window_set_screen (GTK_WINDOW (csd), gtk_widget_get_screen (parent));
3546 colorsel = gtk_color_selection_dialog_get_color_selection (GTK_COLOR_SELECTION_DIALOG (csd));
3547 gtk_color_selection_set_has_palette (GTK_COLOR_SELECTION (colorsel),
3551 gtk_window_set_modal (GTK_WINDOW(csd),TRUE);
3553 /* And mark it as a transient dialog */
3554 gtk_window_set_transient_for (GTK_WINDOW (csd), GTK_WINDOW (parent));
3556 g_signal_connect (csd, "destroy",
3557 G_CALLBACK (cmw_destroy_cb), NULL);
3560 "ok-button", &ok_button,
3561 "cancel-button", &cancel_button,
3564 g_signal_connect_swapped (ok_button,
3565 "clicked", G_CALLBACK (gtk_widget_destroy), csd);
3566 g_signal_connect_swapped (cancel_button,
3567 "clicked", G_CALLBACK (gtk_widget_destroy), csd);
3569 /* wait until destroy calls gtk_main_quit */
3570 gtk_widget_show (csd);
3575 cmw_file (GtkWidget *widget, GtkWidget *parent)
3579 fs = gtk_file_chooser_dialog_new ("This is a modal file selection dialog",
3580 GTK_WINDOW (parent), GTK_FILE_CHOOSER_ACTION_OPEN,
3581 GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
3582 GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
3584 gtk_window_set_screen (GTK_WINDOW (fs), gtk_widget_get_screen (parent));
3585 gtk_window_set_modal (GTK_WINDOW (fs), TRUE);
3587 g_signal_connect (fs, "destroy",
3588 G_CALLBACK (cmw_destroy_cb), NULL);
3589 g_signal_connect_swapped (fs, "response",
3590 G_CALLBACK (gtk_widget_destroy), fs);
3592 /* wait until destroy calls gtk_main_quit */
3593 gtk_widget_show (fs);
3599 create_modal_window (GtkWidget *widget)
3601 GtkWidget *window = NULL;
3602 GtkWidget *box1,*box2;
3604 GtkWidget *btnColor,*btnFile,*btnClose;
3606 /* Create modal window (Here you can use any window descendent )*/
3607 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
3608 gtk_window_set_screen (GTK_WINDOW (window),
3609 gtk_widget_get_screen (widget));
3611 gtk_window_set_title (GTK_WINDOW(window),"This window is modal");
3613 /* Set window as modal */
3614 gtk_window_set_modal (GTK_WINDOW(window),TRUE);
3616 /* Create widgets */
3617 box1 = gtk_vbox_new (FALSE,5);
3618 frame1 = gtk_frame_new ("Standard dialogs in modal form");
3619 box2 = gtk_vbox_new (TRUE,5);
3620 btnColor = gtk_button_new_with_label ("Color");
3621 btnFile = gtk_button_new_with_label ("File Selection");
3622 btnClose = gtk_button_new_with_label ("Close");
3625 gtk_container_set_border_width (GTK_CONTAINER (box1), 3);
3626 gtk_container_set_border_width (GTK_CONTAINER (box2), 3);
3629 gtk_container_add (GTK_CONTAINER (window), box1);
3630 gtk_box_pack_start (GTK_BOX (box1), frame1, TRUE, TRUE, 4);
3631 gtk_container_add (GTK_CONTAINER (frame1), box2);
3632 gtk_box_pack_start (GTK_BOX (box2), btnColor, FALSE, FALSE, 4);
3633 gtk_box_pack_start (GTK_BOX (box2), btnFile, FALSE, FALSE, 4);
3634 gtk_box_pack_start (GTK_BOX (box1), gtk_separator_new (GTK_ORIENTATION_HORIZONTAL), FALSE, FALSE, 4);
3635 gtk_box_pack_start (GTK_BOX (box1), btnClose, FALSE, FALSE, 4);
3637 /* connect signals */
3638 g_signal_connect_swapped (btnClose, "clicked",
3639 G_CALLBACK (gtk_widget_destroy), window);
3641 g_signal_connect (window, "destroy",
3642 G_CALLBACK (cmw_destroy_cb), NULL);
3644 g_signal_connect (btnColor, "clicked",
3645 G_CALLBACK (cmw_color), window);
3646 g_signal_connect (btnFile, "clicked",
3647 G_CALLBACK (cmw_file), window);
3650 gtk_widget_show_all (window);
3652 /* wait until dialog get destroyed */
3661 make_message_dialog (GdkScreen *screen,
3663 GtkMessageType type,
3664 GtkButtonsType buttons,
3665 guint default_response)
3669 gtk_widget_destroy (*dialog);
3674 *dialog = gtk_message_dialog_new (NULL, 0, type, buttons,
3675 "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.)");
3677 gtk_window_set_screen (GTK_WINDOW (*dialog), screen);
3679 g_signal_connect_swapped (*dialog,
3681 G_CALLBACK (gtk_widget_destroy),
3684 g_signal_connect (*dialog,
3686 G_CALLBACK (gtk_widget_destroyed),
3689 gtk_dialog_set_default_response (GTK_DIALOG (*dialog), default_response);
3691 gtk_widget_show (*dialog);
3695 create_message_dialog (GtkWidget *widget)
3697 static GtkWidget *info = NULL;
3698 static GtkWidget *warning = NULL;
3699 static GtkWidget *error = NULL;
3700 static GtkWidget *question = NULL;
3701 GdkScreen *screen = gtk_widget_get_screen (widget);
3703 make_message_dialog (screen, &info, GTK_MESSAGE_INFO, GTK_BUTTONS_OK, GTK_RESPONSE_OK);
3704 make_message_dialog (screen, &warning, GTK_MESSAGE_WARNING, GTK_BUTTONS_CLOSE, GTK_RESPONSE_CLOSE);
3705 make_message_dialog (screen, &error, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK_CANCEL, GTK_RESPONSE_OK);
3706 make_message_dialog (screen, &question, GTK_MESSAGE_QUESTION, GTK_BUTTONS_YES_NO, GTK_RESPONSE_NO);
3713 static GtkWidget *sw_parent = NULL;
3714 static GtkWidget *sw_float_parent;
3715 static gulong sw_destroyed_handler = 0;
3718 scrolled_windows_delete_cb (GtkWidget *widget, GdkEventAny *event, GtkWidget *scrollwin)
3720 gtk_widget_reparent (scrollwin, sw_parent);
3722 g_signal_handler_disconnect (sw_parent, sw_destroyed_handler);
3723 sw_float_parent = NULL;
3725 sw_destroyed_handler = 0;
3731 scrolled_windows_destroy_cb (GtkWidget *widget, GtkWidget *scrollwin)
3733 gtk_widget_destroy (sw_float_parent);
3735 sw_float_parent = NULL;
3737 sw_destroyed_handler = 0;
3741 scrolled_windows_remove (GtkWidget *widget, GtkWidget *scrollwin)
3745 gtk_widget_reparent (scrollwin, sw_parent);
3746 gtk_widget_destroy (sw_float_parent);
3748 g_signal_handler_disconnect (sw_parent, sw_destroyed_handler);
3749 sw_float_parent = NULL;
3751 sw_destroyed_handler = 0;
3755 sw_parent = gtk_widget_get_parent (scrollwin);
3756 sw_float_parent = gtk_window_new (GTK_WINDOW_TOPLEVEL);
3757 gtk_window_set_screen (GTK_WINDOW (sw_float_parent),
3758 gtk_widget_get_screen (widget));
3760 gtk_window_set_default_size (GTK_WINDOW (sw_float_parent), 200, 200);
3762 gtk_widget_reparent (scrollwin, sw_float_parent);
3763 gtk_widget_show (sw_float_parent);
3765 sw_destroyed_handler =
3766 g_signal_connect (sw_parent, "destroy",
3767 G_CALLBACK (scrolled_windows_destroy_cb), scrollwin);
3768 g_signal_connect (sw_float_parent, "delete_event",
3769 G_CALLBACK (scrolled_windows_delete_cb), scrollwin);
3774 create_scrolled_windows (GtkWidget *widget)
3776 static GtkWidget *window;
3777 GtkWidget *content_area, *action_area;
3778 GtkWidget *scrolled_window;
3786 window = gtk_dialog_new ();
3788 gtk_window_set_screen (GTK_WINDOW (window),
3789 gtk_widget_get_screen (widget));
3791 g_signal_connect (window, "destroy",
3792 G_CALLBACK (gtk_widget_destroyed),
3795 content_area = gtk_dialog_get_content_area (GTK_DIALOG (window));
3796 action_area = gtk_dialog_get_action_area (GTK_DIALOG (window));
3798 gtk_window_set_title (GTK_WINDOW (window), "dialog");
3799 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
3801 scrolled_window = gtk_scrolled_window_new (NULL, NULL);
3802 gtk_container_set_border_width (GTK_CONTAINER (scrolled_window), 10);
3803 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
3804 GTK_POLICY_AUTOMATIC,
3805 GTK_POLICY_AUTOMATIC);
3806 gtk_box_pack_start (GTK_BOX (content_area), scrolled_window, TRUE, TRUE, 0);
3807 gtk_widget_show (scrolled_window);
3809 table = gtk_table_new (20, 20, FALSE);
3810 gtk_table_set_row_spacings (GTK_TABLE (table), 10);
3811 gtk_table_set_col_spacings (GTK_TABLE (table), 10);
3812 gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (scrolled_window), table);
3813 gtk_container_set_focus_hadjustment (GTK_CONTAINER (table),
3814 gtk_scrolled_window_get_hadjustment (GTK_SCROLLED_WINDOW (scrolled_window)));
3815 gtk_container_set_focus_vadjustment (GTK_CONTAINER (table),
3816 gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (scrolled_window)));
3817 gtk_widget_show (table);
3819 for (i = 0; i < 20; i++)
3820 for (j = 0; j < 20; j++)
3822 sprintf (buffer, "button (%d,%d)\n", i, j);
3823 button = gtk_toggle_button_new_with_label (buffer);
3824 gtk_table_attach_defaults (GTK_TABLE (table), button,
3826 gtk_widget_show (button);
3830 button = gtk_button_new_with_label ("Close");
3831 g_signal_connect_swapped (button, "clicked",
3832 G_CALLBACK (gtk_widget_destroy),
3834 gtk_widget_set_can_default (button, TRUE);
3835 gtk_box_pack_start (GTK_BOX (action_area), button, TRUE, TRUE, 0);
3836 gtk_widget_grab_default (button);
3837 gtk_widget_show (button);
3839 button = gtk_button_new_with_label ("Reparent Out");
3840 g_signal_connect (button, "clicked",
3841 G_CALLBACK (scrolled_windows_remove),
3843 gtk_widget_set_can_default (button, TRUE);
3844 gtk_box_pack_start (GTK_BOX (action_area), button, TRUE, TRUE, 0);
3845 gtk_widget_grab_default (button);
3846 gtk_widget_show (button);
3848 gtk_window_set_default_size (GTK_WINDOW (window), 300, 300);
3851 if (!gtk_widget_get_visible (window))
3852 gtk_widget_show (window);
3854 gtk_widget_destroy (window);
3862 entry_toggle_frame (GtkWidget *checkbutton,
3865 gtk_entry_set_has_frame (GTK_ENTRY(entry),
3866 gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (checkbutton)));
3870 entry_toggle_sensitive (GtkWidget *checkbutton,
3873 gtk_widget_set_sensitive (entry,
3874 gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON(checkbutton)));
3878 entry_progress_timeout (gpointer data)
3880 if (GPOINTER_TO_INT (g_object_get_data (G_OBJECT (data), "progress-pulse")))
3882 gtk_entry_progress_pulse (GTK_ENTRY (data));
3888 fraction = gtk_entry_get_progress_fraction (GTK_ENTRY (data));
3891 if (fraction > 1.0001)
3894 gtk_entry_set_progress_fraction (GTK_ENTRY (data), fraction);
3901 entry_remove_timeout (gpointer data)
3903 g_source_remove (GPOINTER_TO_UINT (data));
3907 entry_toggle_progress (GtkWidget *checkbutton,
3910 if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (checkbutton)))
3912 guint timeout = gdk_threads_add_timeout (100,
3913 entry_progress_timeout,
3915 g_object_set_data_full (G_OBJECT (entry), "timeout-id",
3916 GUINT_TO_POINTER (timeout),
3917 entry_remove_timeout);
3921 g_object_set_data (G_OBJECT (entry), "timeout-id",
3922 GUINT_TO_POINTER (0));
3924 gtk_entry_set_progress_fraction (GTK_ENTRY (entry), 0.0);
3929 entry_toggle_pulse (GtkWidget *checkbutton,
3932 g_object_set_data (G_OBJECT (entry), "progress-pulse",
3933 GUINT_TO_POINTER ((guint) gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (checkbutton))));
3937 props_clicked (GtkWidget *button,
3940 GtkWidget *window = create_prop_editor (object, 0);
3942 gtk_window_set_title (GTK_WINDOW (window), "Object Properties");
3946 create_entry (GtkWidget *widget)
3948 static GtkWidget *window = NULL;
3952 GtkWidget *has_frame_check;
3953 GtkWidget *sensitive_check;
3954 GtkWidget *progress_check;
3956 GtkComboBoxText *cb;
3957 GtkWidget *cb_entry;
3959 GtkWidget *separator;
3963 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
3964 gtk_window_set_screen (GTK_WINDOW (window),
3965 gtk_widget_get_screen (widget));
3967 g_signal_connect (window, "destroy",
3968 G_CALLBACK (gtk_widget_destroyed),
3971 gtk_window_set_title (GTK_WINDOW (window), "entry");
3972 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
3975 box1 = gtk_vbox_new (FALSE, 0);
3976 gtk_container_add (GTK_CONTAINER (window), box1);
3979 box2 = gtk_vbox_new (FALSE, 10);
3980 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
3981 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
3983 hbox = gtk_hbox_new (FALSE, 5);
3984 gtk_box_pack_start (GTK_BOX (box2), hbox, TRUE, TRUE, 0);
3986 entry = gtk_entry_new ();
3987 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");
3988 gtk_editable_select_region (GTK_EDITABLE (entry), 0, 5);
3989 gtk_box_pack_start (GTK_BOX (hbox), entry, TRUE, TRUE, 0);
3991 button = gtk_button_new_with_mnemonic ("_Props");
3992 gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0);
3993 g_signal_connect (button, "clicked",
3994 G_CALLBACK (props_clicked),
3997 cb = GTK_COMBO_BOX_TEXT (gtk_combo_box_text_new_with_entry ());
3999 gtk_combo_box_text_append_text (cb, "item0");
4000 gtk_combo_box_text_append_text (cb, "item0");
4001 gtk_combo_box_text_append_text (cb, "item1 item1");
4002 gtk_combo_box_text_append_text (cb, "item2 item2 item2");
4003 gtk_combo_box_text_append_text (cb, "item3 item3 item3 item3");
4004 gtk_combo_box_text_append_text (cb, "item4 item4 item4 item4 item4");
4005 gtk_combo_box_text_append_text (cb, "item5 item5 item5 item5 item5 item5");
4006 gtk_combo_box_text_append_text (cb, "item6 item6 item6 item6 item6");
4007 gtk_combo_box_text_append_text (cb, "item7 item7 item7 item7");
4008 gtk_combo_box_text_append_text (cb, "item8 item8 item8");
4009 gtk_combo_box_text_append_text (cb, "item9 item9");
4011 cb_entry = gtk_bin_get_child (GTK_BIN (cb));
4012 gtk_entry_set_text (GTK_ENTRY (cb_entry), "hello world \n\n\n foo");
4013 gtk_editable_select_region (GTK_EDITABLE (cb_entry), 0, -1);
4014 gtk_box_pack_start (GTK_BOX (box2), GTK_WIDGET (cb), TRUE, TRUE, 0);
4016 sensitive_check = gtk_check_button_new_with_label("Sensitive");
4017 gtk_box_pack_start (GTK_BOX (box2), sensitive_check, FALSE, TRUE, 0);
4018 g_signal_connect (sensitive_check, "toggled",
4019 G_CALLBACK (entry_toggle_sensitive), entry);
4020 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (sensitive_check), TRUE);
4022 has_frame_check = gtk_check_button_new_with_label("Has Frame");
4023 gtk_box_pack_start (GTK_BOX (box2), has_frame_check, FALSE, TRUE, 0);
4024 g_signal_connect (has_frame_check, "toggled",
4025 G_CALLBACK (entry_toggle_frame), entry);
4026 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (has_frame_check), TRUE);
4028 progress_check = gtk_check_button_new_with_label("Show Progress");
4029 gtk_box_pack_start (GTK_BOX (box2), progress_check, FALSE, TRUE, 0);
4030 g_signal_connect (progress_check, "toggled",
4031 G_CALLBACK (entry_toggle_progress), entry);
4033 progress_check = gtk_check_button_new_with_label("Pulse Progress");
4034 gtk_box_pack_start (GTK_BOX (box2), progress_check, FALSE, TRUE, 0);
4035 g_signal_connect (progress_check, "toggled",
4036 G_CALLBACK (entry_toggle_pulse), entry);
4038 separator = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
4039 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
4041 box2 = gtk_vbox_new (FALSE, 10);
4042 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
4043 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
4045 button = gtk_button_new_with_label ("close");
4046 g_signal_connect_swapped (button, "clicked",
4047 G_CALLBACK (gtk_widget_destroy),
4049 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
4050 gtk_widget_set_can_default (button, TRUE);
4051 gtk_widget_grab_default (button);
4054 if (!gtk_widget_get_visible (window))
4055 gtk_widget_show_all (window);
4057 gtk_widget_destroy (window);
4061 create_expander (GtkWidget *widget)
4064 GtkWidget *expander;
4066 static GtkWidget *window = NULL;
4070 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
4071 gtk_window_set_screen (GTK_WINDOW (window),
4072 gtk_widget_get_screen (widget));
4074 g_signal_connect (window, "destroy",
4075 G_CALLBACK (gtk_widget_destroyed),
4078 gtk_window_set_title (GTK_WINDOW (window), "expander");
4079 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
4081 box1 = gtk_vbox_new (FALSE, 0);
4082 gtk_container_add (GTK_CONTAINER (window), box1);
4084 expander = gtk_expander_new ("The Hidden");
4086 gtk_box_pack_start (GTK_BOX (box1), expander, TRUE, TRUE, 0);
4088 hidden = gtk_label_new ("Revealed!");
4090 gtk_container_add (GTK_CONTAINER (expander), hidden);
4093 if (!gtk_widget_get_visible (window))
4094 gtk_widget_show_all (window);
4096 gtk_widget_destroy (window);
4104 event_box_label_pressed (GtkWidget *widget,
4105 GdkEventButton *event,
4108 g_print ("clicked on event box\n");
4112 event_box_button_clicked (GtkWidget *widget,
4116 g_print ("pushed button\n");
4120 event_box_toggle_visible_window (GtkWidget *checkbutton,
4121 GtkEventBox *event_box)
4123 gtk_event_box_set_visible_window (event_box,
4124 gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (checkbutton)));
4128 event_box_toggle_above_child (GtkWidget *checkbutton,
4129 GtkEventBox *event_box)
4131 gtk_event_box_set_above_child (event_box,
4132 gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (checkbutton)));
4136 create_event_box (GtkWidget *widget)
4138 static GtkWidget *window = NULL;
4144 GtkWidget *separator;
4145 GtkWidget *event_box;
4147 GtkWidget *visible_window_check;
4148 GtkWidget *above_child_check;
4157 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
4158 gtk_window_set_screen (GTK_WINDOW (window),
4159 gtk_widget_get_screen (widget));
4161 g_signal_connect (window, "destroy",
4162 G_CALLBACK (gtk_widget_destroyed),
4165 gtk_window_set_title (GTK_WINDOW (window), "event box");
4166 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
4168 box1 = gtk_vbox_new (FALSE, 0);
4169 gtk_container_add (GTK_CONTAINER (window), box1);
4170 gtk_widget_modify_bg (window, GTK_STATE_NORMAL, &color);
4172 hbox = gtk_hbox_new (FALSE, 0);
4173 gtk_box_pack_start (GTK_BOX (box1), hbox, TRUE, FALSE, 0);
4175 event_box = gtk_event_box_new ();
4176 gtk_box_pack_start (GTK_BOX (hbox), event_box, TRUE, FALSE, 0);
4178 vbox = gtk_vbox_new (FALSE, 0);
4179 gtk_container_add (GTK_CONTAINER (event_box), vbox);
4180 g_signal_connect (event_box, "button_press_event",
4181 G_CALLBACK (event_box_label_pressed),
4184 label = gtk_label_new ("Click on this label");
4185 gtk_box_pack_start (GTK_BOX (vbox), label, TRUE, FALSE, 0);
4187 button = gtk_button_new_with_label ("button in eventbox");
4188 gtk_box_pack_start (GTK_BOX (vbox), button, TRUE, FALSE, 0);
4189 g_signal_connect (button, "clicked",
4190 G_CALLBACK (event_box_button_clicked),
4194 visible_window_check = gtk_check_button_new_with_label("Visible Window");
4195 gtk_box_pack_start (GTK_BOX (box1), visible_window_check, FALSE, TRUE, 0);
4196 g_signal_connect (visible_window_check, "toggled",
4197 G_CALLBACK (event_box_toggle_visible_window), event_box);
4198 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (visible_window_check), FALSE);
4200 above_child_check = gtk_check_button_new_with_label("Above Child");
4201 gtk_box_pack_start (GTK_BOX (box1), above_child_check, FALSE, TRUE, 0);
4202 g_signal_connect (above_child_check, "toggled",
4203 G_CALLBACK (event_box_toggle_above_child), event_box);
4204 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (above_child_check), FALSE);
4206 separator = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
4207 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
4209 box2 = gtk_vbox_new (FALSE, 10);
4210 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
4211 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
4213 button = gtk_button_new_with_label ("close");
4214 g_signal_connect_swapped (button, "clicked",
4215 G_CALLBACK (gtk_widget_destroy),
4217 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
4218 gtk_widget_set_can_default (button, TRUE);
4219 gtk_widget_grab_default (button);
4222 if (!gtk_widget_get_visible (window))
4223 gtk_widget_show_all (window);
4225 gtk_widget_destroy (window);
4233 #define SIZE_GROUP_INITIAL_SIZE 50
4236 size_group_hsize_changed (GtkSpinButton *spin_button,
4239 gtk_widget_set_size_request (gtk_bin_get_child (GTK_BIN (button)),
4240 gtk_spin_button_get_value_as_int (spin_button),
4245 size_group_vsize_changed (GtkSpinButton *spin_button,
4248 gtk_widget_set_size_request (gtk_bin_get_child (GTK_BIN (button)),
4250 gtk_spin_button_get_value_as_int (spin_button));
4254 create_size_group_window (GdkScreen *screen,
4255 GtkSizeGroup *master_size_group)
4257 GtkWidget *content_area;
4260 GtkWidget *main_button;
4262 GtkWidget *spin_button;
4264 GtkSizeGroup *hgroup1;
4265 GtkSizeGroup *hgroup2;
4266 GtkSizeGroup *vgroup1;
4267 GtkSizeGroup *vgroup2;
4269 window = gtk_dialog_new_with_buttons ("GtkSizeGroup",
4275 gtk_window_set_screen (GTK_WINDOW (window), screen);
4277 gtk_window_set_resizable (GTK_WINDOW (window), TRUE);
4279 g_signal_connect (window, "response",
4280 G_CALLBACK (gtk_widget_destroy),
4283 content_area = gtk_dialog_get_content_area (GTK_DIALOG (window));
4285 table = gtk_table_new (2, 2, FALSE);
4286 gtk_box_pack_start (GTK_BOX (content_area), table, TRUE, TRUE, 0);
4288 gtk_table_set_row_spacings (GTK_TABLE (table), 5);
4289 gtk_table_set_col_spacings (GTK_TABLE (table), 5);
4290 gtk_container_set_border_width (GTK_CONTAINER (table), 5);
4291 gtk_widget_set_size_request (table, 250, 250);
4293 hgroup1 = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
4294 hgroup2 = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
4295 vgroup1 = gtk_size_group_new (GTK_SIZE_GROUP_VERTICAL);
4296 vgroup2 = gtk_size_group_new (GTK_SIZE_GROUP_VERTICAL);
4298 main_button = gtk_button_new_with_label ("X");
4300 gtk_table_attach (GTK_TABLE (table), main_button,
4302 GTK_EXPAND, GTK_EXPAND,
4304 gtk_size_group_add_widget (master_size_group, main_button);
4305 gtk_size_group_add_widget (hgroup1, main_button);
4306 gtk_size_group_add_widget (vgroup1, main_button);
4307 gtk_widget_set_size_request (gtk_bin_get_child (GTK_BIN (main_button)),
4308 SIZE_GROUP_INITIAL_SIZE,
4309 SIZE_GROUP_INITIAL_SIZE);
4311 button = gtk_button_new ();
4312 gtk_table_attach (GTK_TABLE (table), button,
4314 GTK_EXPAND, GTK_EXPAND,
4316 gtk_size_group_add_widget (vgroup1, button);
4317 gtk_size_group_add_widget (vgroup2, button);
4319 button = gtk_button_new ();
4320 gtk_table_attach (GTK_TABLE (table), button,
4322 GTK_EXPAND, GTK_EXPAND,
4324 gtk_size_group_add_widget (hgroup1, button);
4325 gtk_size_group_add_widget (hgroup2, button);
4327 button = gtk_button_new ();
4328 gtk_table_attach (GTK_TABLE (table), button,
4330 GTK_EXPAND, GTK_EXPAND,
4332 gtk_size_group_add_widget (hgroup2, button);
4333 gtk_size_group_add_widget (vgroup2, button);
4335 g_object_unref (hgroup1);
4336 g_object_unref (hgroup2);
4337 g_object_unref (vgroup1);
4338 g_object_unref (vgroup2);
4340 hbox = gtk_hbox_new (FALSE, 5);
4341 gtk_box_pack_start (GTK_BOX (content_area), hbox, FALSE, FALSE, 0);
4343 spin_button = gtk_spin_button_new_with_range (1, 100, 1);
4344 gtk_spin_button_set_value (GTK_SPIN_BUTTON (spin_button), SIZE_GROUP_INITIAL_SIZE);
4345 gtk_box_pack_start (GTK_BOX (hbox), spin_button, TRUE, TRUE, 0);
4346 g_signal_connect (spin_button, "value_changed",
4347 G_CALLBACK (size_group_hsize_changed), main_button);
4349 spin_button = gtk_spin_button_new_with_range (1, 100, 1);
4350 gtk_spin_button_set_value (GTK_SPIN_BUTTON (spin_button), SIZE_GROUP_INITIAL_SIZE);
4351 gtk_box_pack_start (GTK_BOX (hbox), spin_button, TRUE, TRUE, 0);
4352 g_signal_connect (spin_button, "value_changed",
4353 G_CALLBACK (size_group_vsize_changed), main_button);
4359 create_size_groups (GtkWidget *widget)
4361 static GtkWidget *window1 = NULL;
4362 static GtkWidget *window2 = NULL;
4363 static GtkSizeGroup *master_size_group;
4365 if (!master_size_group)
4366 master_size_group = gtk_size_group_new (GTK_SIZE_GROUP_BOTH);
4370 window1 = create_size_group_window (gtk_widget_get_screen (widget),
4373 g_signal_connect (window1, "destroy",
4374 G_CALLBACK (gtk_widget_destroyed),
4380 window2 = create_size_group_window (gtk_widget_get_screen (widget),
4383 g_signal_connect (window2, "destroy",
4384 G_CALLBACK (gtk_widget_destroyed),
4388 if (gtk_widget_get_visible (window1) && gtk_widget_get_visible (window2))
4390 gtk_widget_destroy (window1);
4391 gtk_widget_destroy (window2);
4395 if (!gtk_widget_get_visible (window1))
4396 gtk_widget_show_all (window1);
4397 if (!gtk_widget_get_visible (window2))
4398 gtk_widget_show_all (window2);
4406 static GtkWidget *spinner1;
4409 toggle_snap (GtkWidget *widget, GtkSpinButton *spin)
4411 gtk_spin_button_set_snap_to_ticks (spin,
4412 gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget)));
4416 toggle_numeric (GtkWidget *widget, GtkSpinButton *spin)
4418 gtk_spin_button_set_numeric (spin,
4419 gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget)));
4423 change_digits (GtkWidget *widget, GtkSpinButton *spin)
4425 gtk_spin_button_set_digits (GTK_SPIN_BUTTON (spinner1),
4426 gtk_spin_button_get_value_as_int (spin));
4430 get_value (GtkWidget *widget, gpointer data)
4434 GtkSpinButton *spin;
4436 spin = GTK_SPIN_BUTTON (spinner1);
4437 label = GTK_LABEL (g_object_get_data (G_OBJECT (widget), "user_data"));
4438 if (GPOINTER_TO_INT (data) == 1)
4439 sprintf (buf, "%d", gtk_spin_button_get_value_as_int (spin));
4441 sprintf (buf, "%0.*f",
4442 gtk_spin_button_get_digits (spin),
4443 gtk_spin_button_get_value (spin));
4445 gtk_label_set_text (label, buf);
4449 get_spin_value (GtkWidget *widget, gpointer data)
4453 GtkSpinButton *spin;
4455 spin = GTK_SPIN_BUTTON (widget);
4456 label = GTK_LABEL (data);
4458 buffer = g_strdup_printf ("%0.*f",
4459 gtk_spin_button_get_digits (spin),
4460 gtk_spin_button_get_value (spin));
4461 gtk_label_set_text (label, buffer);
4467 spin_button_time_output_func (GtkSpinButton *spin_button)
4469 GtkAdjustment *adjustment;
4470 static gchar buf[6];
4474 adjustment = gtk_spin_button_get_adjustment (spin_button);
4475 hours = gtk_adjustment_get_value (adjustment) / 60.0;
4476 minutes = (fabs(floor (hours) - hours) < 1e-5) ? 0.0 : 30;
4477 sprintf (buf, "%02.0f:%02.0f", floor (hours), minutes);
4478 if (strcmp (buf, gtk_entry_get_text (GTK_ENTRY (spin_button))))
4479 gtk_entry_set_text (GTK_ENTRY (spin_button), buf);
4484 spin_button_month_input_func (GtkSpinButton *spin_button,
4488 static gchar *month[12] = { "January", "February", "March", "April",
4489 "May", "June", "July", "August",
4490 "September", "October", "November", "December" };
4492 gboolean found = FALSE;
4494 for (i = 1; i <= 12; i++)
4496 tmp1 = g_ascii_strup (month[i - 1], -1);
4497 tmp2 = g_ascii_strup (gtk_entry_get_text (GTK_ENTRY (spin_button)), -1);
4498 if (strstr (tmp1, tmp2) == tmp1)
4508 return GTK_INPUT_ERROR;
4510 *new_val = (gdouble) i;
4515 spin_button_month_output_func (GtkSpinButton *spin_button)
4517 GtkAdjustment *adjustment;
4520 static gchar *month[12] = { "January", "February", "March", "April",
4521 "May", "June", "July", "August", "September",
4522 "October", "November", "December" };
4524 adjustment = gtk_spin_button_get_adjustment (spin_button);
4525 value = gtk_adjustment_get_value (adjustment);
4526 for (i = 1; i <= 12; i++)
4527 if (fabs (value - (double)i) < 1e-5)
4529 if (strcmp (month[i-1], gtk_entry_get_text (GTK_ENTRY (spin_button))))
4530 gtk_entry_set_text (GTK_ENTRY (spin_button), month[i-1]);
4536 spin_button_hex_input_func (GtkSpinButton *spin_button,
4543 buf = gtk_entry_get_text (GTK_ENTRY (spin_button));
4544 res = strtol(buf, &err, 16);
4547 return GTK_INPUT_ERROR;
4553 spin_button_hex_output_func (GtkSpinButton *spin_button)
4555 GtkAdjustment *adjustment;
4556 static gchar buf[7];
4559 adjustment = gtk_spin_button_get_adjustment (spin_button);
4560 val = (gint) gtk_adjustment_get_value (adjustment);
4561 if (fabs (val) < 1e-5)
4562 sprintf (buf, "0x00");
4564 sprintf (buf, "0x%.2X", val);
4565 if (strcmp (buf, gtk_entry_get_text (GTK_ENTRY (spin_button))))
4566 gtk_entry_set_text (GTK_ENTRY (spin_button), buf);
4571 create_spins (GtkWidget *widget)
4573 static GtkWidget *window = NULL;
4576 GtkWidget *main_vbox;
4579 GtkWidget *spinner2;
4583 GtkWidget *val_label;
4588 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
4589 gtk_window_set_screen (GTK_WINDOW (window),
4590 gtk_widget_get_screen (widget));
4592 g_signal_connect (window, "destroy",
4593 G_CALLBACK (gtk_widget_destroyed),
4596 gtk_window_set_title (GTK_WINDOW (window), "GtkSpinButton");
4598 main_vbox = gtk_vbox_new (FALSE, 5);
4599 gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 10);
4600 gtk_container_add (GTK_CONTAINER (window), main_vbox);
4602 frame = gtk_frame_new ("Not accelerated");
4603 gtk_box_pack_start (GTK_BOX (main_vbox), frame, TRUE, TRUE, 0);
4605 vbox = gtk_vbox_new (FALSE, 0);
4606 gtk_container_set_border_width (GTK_CONTAINER (vbox), 5);
4607 gtk_container_add (GTK_CONTAINER (frame), vbox);
4609 /* Time, month, hex spinners */
4611 hbox = gtk_hbox_new (FALSE, 0);
4612 gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 5);
4614 vbox2 = gtk_vbox_new (FALSE, 0);
4615 gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 5);
4617 label = gtk_label_new ("Time :");
4618 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
4619 gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, TRUE, 0);
4621 adj = gtk_adjustment_new (0, 0, 1410, 30, 60, 0);
4622 spinner = gtk_spin_button_new (adj, 0, 0);
4623 gtk_editable_set_editable (GTK_EDITABLE (spinner), FALSE);
4624 g_signal_connect (spinner,
4626 G_CALLBACK (spin_button_time_output_func),
4628 gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spinner), TRUE);
4629 gtk_entry_set_width_chars (GTK_ENTRY (spinner), 5);
4630 gtk_box_pack_start (GTK_BOX (vbox2), spinner, FALSE, TRUE, 0);
4632 vbox2 = gtk_vbox_new (FALSE, 0);
4633 gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 5);
4635 label = gtk_label_new ("Month :");
4636 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
4637 gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, TRUE, 0);
4639 adj = gtk_adjustment_new (1.0, 1.0, 12.0, 1.0,
4641 spinner = gtk_spin_button_new (adj, 0, 0);
4642 gtk_spin_button_set_update_policy (GTK_SPIN_BUTTON (spinner),
4643 GTK_UPDATE_IF_VALID);
4644 g_signal_connect (spinner,
4646 G_CALLBACK (spin_button_month_input_func),
4648 g_signal_connect (spinner,
4650 G_CALLBACK (spin_button_month_output_func),
4652 gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spinner), TRUE);
4653 gtk_entry_set_width_chars (GTK_ENTRY (spinner), 9);
4654 gtk_box_pack_start (GTK_BOX (vbox2), spinner, FALSE, TRUE, 0);
4656 vbox2 = gtk_vbox_new (FALSE, 0);
4657 gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 5);
4659 label = gtk_label_new ("Hex :");
4660 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
4661 gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, TRUE, 0);
4663 adj = gtk_adjustment_new (0, 0, 255, 1, 16, 0);
4664 spinner = gtk_spin_button_new (adj, 0, 0);
4665 gtk_editable_set_editable (GTK_EDITABLE (spinner), TRUE);
4666 g_signal_connect (spinner,
4668 G_CALLBACK (spin_button_hex_input_func),
4670 g_signal_connect (spinner,
4672 G_CALLBACK (spin_button_hex_output_func),
4674 gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spinner), TRUE);
4675 gtk_entry_set_width_chars (GTK_ENTRY (spinner), 4);
4676 gtk_box_pack_start (GTK_BOX (vbox2), spinner, FALSE, TRUE, 0);
4678 frame = gtk_frame_new ("Accelerated");
4679 gtk_box_pack_start (GTK_BOX (main_vbox), frame, TRUE, TRUE, 0);
4681 vbox = gtk_vbox_new (FALSE, 0);
4682 gtk_container_set_border_width (GTK_CONTAINER (vbox), 5);
4683 gtk_container_add (GTK_CONTAINER (frame), vbox);
4685 hbox = gtk_hbox_new (FALSE, 0);
4686 gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 5);
4688 vbox2 = gtk_vbox_new (FALSE, 0);
4689 gtk_box_pack_start (GTK_BOX (hbox), vbox2, FALSE, FALSE, 5);
4691 label = gtk_label_new ("Value :");
4692 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
4693 gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, TRUE, 0);
4695 adj = gtk_adjustment_new (0.0, -10000.0, 10000.0,
4697 spinner1 = gtk_spin_button_new (adj, 1.0, 2);
4698 gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spinner1), TRUE);
4699 gtk_box_pack_start (GTK_BOX (vbox2), spinner1, FALSE, TRUE, 0);
4701 vbox2 = gtk_vbox_new (FALSE, 0);
4702 gtk_box_pack_start (GTK_BOX (hbox), vbox2, FALSE, FALSE, 5);
4704 label = gtk_label_new ("Digits :");
4705 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
4706 gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, TRUE, 0);
4708 adj = gtk_adjustment_new (2, 1, 15, 1, 1, 0);
4709 spinner2 = gtk_spin_button_new (adj, 0.0, 0);
4710 g_signal_connect (adj, "value_changed",
4711 G_CALLBACK (change_digits),
4713 gtk_box_pack_start (GTK_BOX (vbox2), spinner2, FALSE, TRUE, 0);
4715 hbox = gtk_hbox_new (FALSE, 0);
4716 gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 5);
4718 button = gtk_check_button_new_with_label ("Snap to 0.5-ticks");
4719 g_signal_connect (button, "clicked",
4720 G_CALLBACK (toggle_snap),
4722 gtk_box_pack_start (GTK_BOX (vbox), button, TRUE, TRUE, 0);
4723 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
4725 button = gtk_check_button_new_with_label ("Numeric only input mode");
4726 g_signal_connect (button, "clicked",
4727 G_CALLBACK (toggle_numeric),
4729 gtk_box_pack_start (GTK_BOX (vbox), button, TRUE, TRUE, 0);
4730 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
4732 val_label = gtk_label_new ("");
4734 hbox = gtk_hbox_new (FALSE, 0);
4735 gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 5);
4737 button = gtk_button_new_with_label ("Value as Int");
4738 g_object_set_data (G_OBJECT (button), "user_data", val_label);
4739 g_signal_connect (button, "clicked",
4740 G_CALLBACK (get_value),
4741 GINT_TO_POINTER (1));
4742 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
4744 button = gtk_button_new_with_label ("Value as Float");
4745 g_object_set_data (G_OBJECT (button), "user_data", val_label);
4746 g_signal_connect (button, "clicked",
4747 G_CALLBACK (get_value),
4748 GINT_TO_POINTER (2));
4749 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
4751 gtk_box_pack_start (GTK_BOX (vbox), val_label, TRUE, TRUE, 0);
4752 gtk_label_set_text (GTK_LABEL (val_label), "0");
4754 frame = gtk_frame_new ("Using Convenience Constructor");
4755 gtk_box_pack_start (GTK_BOX (main_vbox), frame, TRUE, TRUE, 0);
4757 hbox = gtk_hbox_new (FALSE, 0);
4758 gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
4759 gtk_container_add (GTK_CONTAINER (frame), hbox);
4761 val_label = gtk_label_new ("0.0");
4763 spinner = gtk_spin_button_new_with_range (0.0, 10.0, 0.009);
4764 gtk_spin_button_set_value (GTK_SPIN_BUTTON (spinner), 0.0);
4765 g_signal_connect (spinner, "value_changed",
4766 G_CALLBACK (get_spin_value), val_label);
4767 gtk_box_pack_start (GTK_BOX (hbox), spinner, TRUE, TRUE, 5);
4768 gtk_box_pack_start (GTK_BOX (hbox), val_label, TRUE, TRUE, 5);
4770 hbox = gtk_hbox_new (FALSE, 0);
4771 gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, TRUE, 0);
4773 button = gtk_button_new_with_label ("Close");
4774 g_signal_connect_swapped (button, "clicked",
4775 G_CALLBACK (gtk_widget_destroy),
4777 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
4780 if (!gtk_widget_get_visible (window))
4781 gtk_widget_show_all (window);
4783 gtk_widget_destroy (window);
4792 cursor_draw (GtkWidget *widget,
4798 width = gtk_widget_get_allocated_width (widget);
4799 height = gtk_widget_get_allocated_height (widget);
4801 cairo_set_source_rgb (cr, 1, 1, 1);
4802 cairo_rectangle (cr, 0, 0, width, height / 2);
4805 cairo_set_source_rgb (cr, 0, 0, 0);
4806 cairo_rectangle (cr, 0, height / 2, width, height / 2);
4809 gdk_cairo_set_source_color (cr, >k_widget_get_style (widget)->bg[GTK_STATE_NORMAL]);
4810 cairo_rectangle (cr, width / 3, height / 3, width / 3, height / 3);
4817 set_cursor (GtkWidget *spinner,
4826 c = CLAMP (gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (spinner)), 0, 152);
4829 label = g_object_get_data (G_OBJECT (spinner), "user_data");
4831 class = g_type_class_ref (GDK_TYPE_CURSOR_TYPE);
4832 vals = class->values;
4834 while (vals && vals->value != c)
4837 gtk_label_set_text (GTK_LABEL (label), vals->value_nick);
4839 gtk_label_set_text (GTK_LABEL (label), "<unknown>");
4841 g_type_class_unref (class);
4843 cursor = gdk_cursor_new_for_display (gtk_widget_get_display (widget), c);
4844 gdk_window_set_cursor (gtk_widget_get_window (widget),
4846 gdk_cursor_unref (cursor);
4850 cursor_event (GtkWidget *widget,
4852 GtkSpinButton *spinner)
4854 if ((event->type == GDK_BUTTON_PRESS) &&
4855 ((event->button.button == 1) ||
4856 (event->button.button == 3)))
4858 gtk_spin_button_spin (spinner, event->button.button == 1 ?
4859 GTK_SPIN_STEP_FORWARD : GTK_SPIN_STEP_BACKWARD, 0);
4866 #ifdef GDK_WINDOWING_X11
4867 #include "x11/gdkx.h"
4870 change_cursor_theme (GtkWidget *widget,
4877 children = gtk_container_get_children (GTK_CONTAINER (data));
4879 theme = gtk_entry_get_text (GTK_ENTRY (children->next->data));
4880 size = (gint) gtk_spin_button_get_value (GTK_SPIN_BUTTON (children->next->next->data));
4882 g_list_free (children);
4884 gdk_x11_display_set_cursor_theme (gtk_widget_get_display (widget),
4891 create_cursors (GtkWidget *widget)
4893 static GtkWidget *window = NULL;
4896 GtkWidget *main_vbox;
4909 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
4910 gtk_window_set_screen (GTK_WINDOW (window),
4911 gtk_widget_get_screen (widget));
4913 g_signal_connect (window, "destroy",
4914 G_CALLBACK (gtk_widget_destroyed),
4917 gtk_window_set_title (GTK_WINDOW (window), "Cursors");
4919 main_vbox = gtk_vbox_new (FALSE, 5);
4920 gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 0);
4921 gtk_container_add (GTK_CONTAINER (window), main_vbox);
4924 g_object_new (gtk_vbox_get_type (),
4925 "GtkBox::homogeneous", FALSE,
4926 "GtkBox::spacing", 5,
4927 "GtkContainer::border_width", 10,
4928 "GtkWidget::parent", main_vbox,
4929 "GtkWidget::visible", TRUE,
4932 #ifdef GDK_WINDOWING_X11
4933 hbox = gtk_hbox_new (FALSE, 0);
4934 gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
4935 gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0);
4937 label = gtk_label_new ("Cursor Theme : ");
4938 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
4939 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
4941 entry = gtk_entry_new ();
4942 gtk_entry_set_text (GTK_ENTRY (entry), "default");
4943 gtk_box_pack_start (GTK_BOX (hbox), entry, FALSE, TRUE, 0);
4945 size = gtk_spin_button_new_with_range (1.0, 64.0, 1.0);
4946 gtk_spin_button_set_value (GTK_SPIN_BUTTON (size), 24.0);
4947 gtk_box_pack_start (GTK_BOX (hbox), size, TRUE, TRUE, 0);
4949 g_signal_connect (entry, "changed",
4950 G_CALLBACK (change_cursor_theme), hbox);
4951 g_signal_connect (size, "changed",
4952 G_CALLBACK (change_cursor_theme), hbox);
4955 hbox = gtk_hbox_new (FALSE, 0);
4956 gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
4957 gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0);
4959 label = gtk_label_new ("Cursor Value : ");
4960 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
4961 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
4963 adj = gtk_adjustment_new (0,
4967 spinner = gtk_spin_button_new (adj, 0, 0);
4968 gtk_box_pack_start (GTK_BOX (hbox), spinner, TRUE, TRUE, 0);
4971 g_object_new (gtk_frame_get_type (),
4972 "GtkFrame::label_xalign", 0.5,
4973 "GtkFrame::label", "Cursor Area",
4974 "GtkContainer::border_width", 10,
4975 "GtkWidget::parent", vbox,
4976 "GtkWidget::visible", TRUE,
4979 darea = gtk_drawing_area_new ();
4980 gtk_widget_set_size_request (darea, 80, 80);
4981 gtk_container_add (GTK_CONTAINER (frame), darea);
4982 g_signal_connect (darea,
4984 G_CALLBACK (cursor_draw),
4986 gtk_widget_set_events (darea, GDK_EXPOSURE_MASK | GDK_BUTTON_PRESS_MASK);
4987 g_signal_connect (darea,
4988 "button_press_event",
4989 G_CALLBACK (cursor_event),
4991 gtk_widget_show (darea);
4993 g_signal_connect (spinner, "changed",
4994 G_CALLBACK (set_cursor),
4997 label = g_object_new (GTK_TYPE_LABEL,
5002 gtk_container_child_set (GTK_CONTAINER (vbox), label,
5005 g_object_set_data (G_OBJECT (spinner), "user_data", label);
5008 g_object_new (gtk_hseparator_get_type (),
5009 "GtkWidget::visible", TRUE,
5011 gtk_box_pack_start (GTK_BOX (main_vbox), any, FALSE, TRUE, 0);
5013 hbox = gtk_hbox_new (FALSE, 0);
5014 gtk_container_set_border_width (GTK_CONTAINER (hbox), 10);
5015 gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, TRUE, 0);
5017 button = gtk_button_new_with_label ("Close");
5018 g_signal_connect_swapped (button, "clicked",
5019 G_CALLBACK (gtk_widget_destroy),
5021 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
5023 gtk_widget_show_all (window);
5025 set_cursor (spinner, darea);
5028 gtk_widget_destroy (window);
5036 color_selection_ok (GtkWidget *w,
5037 GtkColorSelectionDialog *cs)
5039 GtkWidget *colorsel;
5042 colorsel = gtk_color_selection_dialog_get_color_selection (cs);
5044 gtk_color_selection_get_current_color (GTK_COLOR_SELECTION (colorsel), &color);
5045 gtk_color_selection_set_current_color (GTK_COLOR_SELECTION (colorsel), &color);
5049 color_selection_changed (GtkWidget *w,
5050 GtkColorSelectionDialog *cs)
5052 GtkWidget *colorsel;
5055 colorsel = gtk_color_selection_dialog_get_color_selection (cs);
5056 gtk_color_selection_get_current_color (GTK_COLOR_SELECTION (colorsel), &color);
5057 gtk_color_selection_set_current_color (GTK_COLOR_SELECTION (colorsel), &color);
5062 opacity_toggled_cb (GtkWidget *w,
5063 GtkColorSelectionDialog *cs)
5065 GtkColorSelection *colorsel;
5067 colorsel = GTK_COLOR_SELECTION (cs->colorsel);
5068 gtk_color_selection_set_has_opacity_control (colorsel,
5069 gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (w)));
5073 palette_toggled_cb (GtkWidget *w,
5074 GtkColorSelectionDialog *cs)
5076 GtkColorSelection *colorsel;
5078 colorsel = GTK_COLOR_SELECTION (cs->colorsel);
5079 gtk_color_selection_set_has_palette (colorsel,
5080 gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (w)));
5085 create_color_selection (GtkWidget *widget)
5087 static GtkWidget *window = NULL;
5096 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
5097 gtk_window_set_screen (GTK_WINDOW (window),
5098 gtk_widget_get_screen (widget));
5100 g_signal_connect (window, "destroy",
5101 G_CALLBACK (gtk_widget_destroyed),
5104 gtk_window_set_title (GTK_WINDOW (window), "GtkColorButton");
5105 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
5107 hbox = gtk_hbox_new (FALSE, 8);
5108 gtk_container_set_border_width (GTK_CONTAINER (hbox), 8);
5109 gtk_container_add (GTK_CONTAINER (window), hbox);
5111 label = gtk_label_new ("Pick a color");
5112 gtk_container_add (GTK_CONTAINER (hbox), label);
5114 picker = gtk_color_button_new ();
5115 gtk_color_button_set_use_alpha (GTK_COLOR_BUTTON (picker), TRUE);
5116 gtk_container_add (GTK_CONTAINER (hbox), picker);
5118 button = gtk_button_new_with_mnemonic ("_Props");
5119 gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0);
5120 g_signal_connect (button, "clicked",
5121 G_CALLBACK (props_clicked),
5125 if (!gtk_widget_get_visible (window))
5126 gtk_widget_show_all (window);
5128 gtk_widget_destroy (window);
5132 flipping_toggled_cb (GtkWidget *widget, gpointer data)
5134 int state = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget));
5135 int new_direction = state ? GTK_TEXT_DIR_RTL : GTK_TEXT_DIR_LTR;
5137 gtk_widget_set_default_direction (new_direction);
5141 orientable_toggle_orientation (GtkOrientable *orientable)
5143 GtkOrientation orientation;
5145 orientation = gtk_orientable_get_orientation (orientable);
5146 gtk_orientable_set_orientation (orientable,
5147 orientation == GTK_ORIENTATION_HORIZONTAL ?
5148 GTK_ORIENTATION_VERTICAL :
5149 GTK_ORIENTATION_HORIZONTAL);
5151 if (GTK_IS_CONTAINER (orientable))
5156 children = gtk_container_get_children (GTK_CONTAINER (orientable));
5158 for (child = children; child; child = child->next)
5160 if (GTK_IS_ORIENTABLE (child->data))
5161 orientable_toggle_orientation (child->data);
5164 g_list_free (children);
5169 flipping_orientation_toggled_cb (GtkWidget *widget, gpointer data)
5171 GtkWidget *content_area;
5172 GtkWidget *toplevel;
5174 toplevel = gtk_widget_get_toplevel (widget);
5175 content_area = gtk_dialog_get_content_area (GTK_DIALOG (toplevel));
5176 orientable_toggle_orientation (GTK_ORIENTABLE (content_area));
5180 set_direction_recurse (GtkWidget *widget,
5183 GtkTextDirection *dir = data;
5185 gtk_widget_set_direction (widget, *dir);
5186 if (GTK_IS_CONTAINER (widget))
5187 gtk_container_foreach (GTK_CONTAINER (widget),
5188 set_direction_recurse,
5193 create_forward_back (const char *title,
5194 GtkTextDirection text_dir)
5196 GtkWidget *frame = gtk_frame_new (title);
5197 GtkWidget *bbox = gtk_button_box_new (GTK_ORIENTATION_HORIZONTAL);
5198 GtkWidget *back_button = gtk_button_new_from_stock (GTK_STOCK_GO_BACK);
5199 GtkWidget *forward_button = gtk_button_new_from_stock (GTK_STOCK_GO_FORWARD);
5201 gtk_container_set_border_width (GTK_CONTAINER (bbox), 5);
5203 gtk_container_add (GTK_CONTAINER (frame), bbox);
5204 gtk_container_add (GTK_CONTAINER (bbox), back_button);
5205 gtk_container_add (GTK_CONTAINER (bbox), forward_button);
5207 set_direction_recurse (frame, &text_dir);
5213 create_flipping (GtkWidget *widget)
5215 static GtkWidget *window = NULL;
5216 GtkWidget *check_button, *button;
5217 GtkWidget *action_area, *content_area;
5221 window = gtk_dialog_new ();
5223 gtk_window_set_screen (GTK_WINDOW (window),
5224 gtk_widget_get_screen (widget));
5226 g_signal_connect (window, "destroy",
5227 G_CALLBACK (gtk_widget_destroyed),
5230 content_area = gtk_dialog_get_content_area (GTK_DIALOG (window));
5231 action_area = gtk_dialog_get_action_area (GTK_DIALOG (window));
5233 gtk_window_set_title (GTK_WINDOW (window), "Bidirectional Flipping");
5235 check_button = gtk_check_button_new_with_label ("Right-to-left global direction");
5236 gtk_container_set_border_width (GTK_CONTAINER (check_button), 10);
5237 gtk_box_pack_start (GTK_BOX (content_area), check_button, TRUE, TRUE, 0);
5239 if (gtk_widget_get_default_direction () == GTK_TEXT_DIR_RTL)
5240 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check_button), TRUE);
5242 g_signal_connect (check_button, "toggled",
5243 G_CALLBACK (flipping_toggled_cb), NULL);
5245 check_button = gtk_check_button_new_with_label ("Toggle orientation of all boxes");
5246 gtk_container_set_border_width (GTK_CONTAINER (check_button), 10);
5247 gtk_box_pack_start (GTK_BOX (content_area), check_button, TRUE, TRUE, 0);
5249 g_signal_connect (check_button, "toggled",
5250 G_CALLBACK (flipping_orientation_toggled_cb), NULL);
5252 gtk_box_pack_start (GTK_BOX (content_area),
5253 create_forward_back ("Default", GTK_TEXT_DIR_NONE),
5256 gtk_box_pack_start (GTK_BOX (content_area),
5257 create_forward_back ("Left-to-Right", GTK_TEXT_DIR_LTR),
5260 gtk_box_pack_start (GTK_BOX (content_area),
5261 create_forward_back ("Right-to-Left", GTK_TEXT_DIR_RTL),
5264 button = gtk_button_new_with_label ("Close");
5265 g_signal_connect_swapped (button, "clicked",
5266 G_CALLBACK (gtk_widget_destroy), window);
5267 gtk_box_pack_start (GTK_BOX (action_area), button, TRUE, TRUE, 0);
5270 if (!gtk_widget_get_visible (window))
5271 gtk_widget_show_all (window);
5273 gtk_widget_destroy (window);
5281 make_focus_table (GList **list)
5286 table = gtk_table_new (5, 5, FALSE);
5299 widget = gtk_entry_new ();
5301 widget = gtk_button_new_with_label ("Foo");
5303 *list = g_list_prepend (*list, widget);
5305 gtk_table_attach (GTK_TABLE (table),
5309 GTK_EXPAND | GTK_FILL,
5310 GTK_EXPAND | GTK_FILL,
5319 *list = g_list_reverse (*list);
5325 create_focus (GtkWidget *widget)
5327 static GtkWidget *window = NULL;
5331 GtkWidget *content_area;
5336 window = gtk_dialog_new_with_buttons ("Keyboard focus navigation",
5342 gtk_window_set_screen (GTK_WINDOW (window),
5343 gtk_widget_get_screen (widget));
5345 g_signal_connect (window, "destroy",
5346 G_CALLBACK (gtk_widget_destroyed),
5349 g_signal_connect (window, "response",
5350 G_CALLBACK (gtk_widget_destroy),
5353 content_area = gtk_dialog_get_content_area (GTK_DIALOG (window));
5355 gtk_window_set_title (GTK_WINDOW (window), "Keyboard Focus Navigation");
5357 frame = gtk_frame_new ("Weird tab focus chain");
5359 gtk_box_pack_start (GTK_BOX (content_area), frame, TRUE, TRUE, 0);
5361 table = make_focus_table (&list);
5363 gtk_container_add (GTK_CONTAINER (frame), table);
5365 gtk_container_set_focus_chain (GTK_CONTAINER (table),
5370 frame = gtk_frame_new ("Default tab focus chain");
5372 gtk_box_pack_start (GTK_BOX (content_area), frame, TRUE, TRUE, 0);
5375 table = make_focus_table (&list);
5379 gtk_container_add (GTK_CONTAINER (frame), table);
5382 if (!gtk_widget_get_visible (window))
5383 gtk_widget_show_all (window);
5385 gtk_widget_destroy (window);
5393 font_selection_ok (GtkWidget *w,
5394 GtkFontSelectionDialog *fs)
5396 gchar *s = gtk_font_selection_dialog_get_font_name (fs);
5398 g_print ("%s\n", s);
5400 gtk_widget_destroy (GTK_WIDGET (fs));
5404 create_font_selection (GtkWidget *widget)
5406 static GtkWidget *window = NULL;
5414 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
5415 gtk_window_set_screen (GTK_WINDOW (window),
5416 gtk_widget_get_screen (widget));
5418 g_signal_connect (window, "destroy",
5419 G_CALLBACK (gtk_widget_destroyed),
5422 gtk_window_set_title (GTK_WINDOW (window), "GtkFontButton");
5423 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
5425 hbox = gtk_hbox_new (FALSE, 8);
5426 gtk_container_set_border_width (GTK_CONTAINER (hbox), 8);
5427 gtk_container_add (GTK_CONTAINER (window), hbox);
5429 label = gtk_label_new ("Pick a font");
5430 gtk_container_add (GTK_CONTAINER (hbox), label);
5432 picker = gtk_font_button_new ();
5433 gtk_font_button_set_use_font (GTK_FONT_BUTTON (picker), TRUE);
5434 gtk_container_add (GTK_CONTAINER (hbox), picker);
5437 if (!gtk_widget_get_visible (window))
5438 gtk_widget_show_all (window);
5440 gtk_widget_destroy (window);
5447 static GtkWidget *dialog_window = NULL;
5450 label_toggle (GtkWidget *widget,
5455 *label = gtk_label_new ("Dialog Test");
5456 g_signal_connect (*label,
5458 G_CALLBACK (gtk_widget_destroyed),
5460 gtk_misc_set_padding (GTK_MISC (*label), 10, 10);
5461 gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog_window))),
5462 *label, TRUE, TRUE, 0);
5463 gtk_widget_show (*label);
5466 gtk_widget_destroy (*label);
5470 create_dialog (GtkWidget *widget)
5472 static GtkWidget *label;
5473 GtkWidget *action_area;
5478 /* This is a terrible example; it's much simpler to create
5479 * dialogs than this. Don't use testgtk for example code,
5483 dialog_window = gtk_dialog_new ();
5484 gtk_window_set_screen (GTK_WINDOW (dialog_window),
5485 gtk_widget_get_screen (widget));
5487 g_signal_connect (dialog_window, "destroy",
5488 G_CALLBACK (gtk_widget_destroyed),
5491 action_area = gtk_dialog_get_action_area (GTK_DIALOG (dialog_window));
5493 gtk_window_set_title (GTK_WINDOW (dialog_window), "GtkDialog");
5494 gtk_container_set_border_width (GTK_CONTAINER (dialog_window), 0);
5496 button = gtk_button_new_with_label ("OK");
5497 gtk_widget_set_can_default (button, TRUE);
5498 gtk_box_pack_start (GTK_BOX (action_area), button, TRUE, TRUE, 0);
5499 gtk_widget_grab_default (button);
5500 gtk_widget_show (button);
5502 button = gtk_button_new_with_label ("Toggle");
5503 g_signal_connect (button, "clicked",
5504 G_CALLBACK (label_toggle),
5506 gtk_widget_set_can_default (button, TRUE);
5507 gtk_box_pack_start (GTK_BOX (action_area), button, TRUE, TRUE, 0);
5508 gtk_widget_show (button);
5513 if (!gtk_widget_get_visible (dialog_window))
5514 gtk_widget_show (dialog_window);
5516 gtk_widget_destroy (dialog_window);
5519 /* Display & Screen test
5526 GtkWidget *radio_dpy;
5527 GtkWidget *toplevel;
5528 GtkWidget *dialog_window;
5529 } ScreenDisplaySelection;
5532 screen_display_check (GtkWidget *widget, ScreenDisplaySelection *data)
5534 const gchar *display_name;
5535 GdkDisplay *display = gtk_widget_get_display (widget);
5537 GdkScreen *new_screen = NULL;
5538 GdkScreen *current_screen = gtk_widget_get_screen (widget);
5540 if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (data->radio_dpy)))
5542 display_name = gtk_entry_get_text (GTK_ENTRY (data->entry));
5543 display = gdk_display_open (display_name);
5547 dialog = gtk_message_dialog_new (GTK_WINDOW (gtk_widget_get_toplevel (widget)),
5548 GTK_DIALOG_DESTROY_WITH_PARENT,
5551 "The display :\n%s\ncannot be opened",
5553 gtk_window_set_screen (GTK_WINDOW (dialog), current_screen);
5554 gtk_widget_show (dialog);
5555 g_signal_connect (dialog, "response",
5556 G_CALLBACK (gtk_widget_destroy),
5561 GtkTreeModel *model = gtk_combo_box_get_model (GTK_COMBO_BOX (data->combo));
5564 gboolean found = FALSE;
5565 while (gtk_tree_model_iter_nth_child (model, &iter, NULL, i++))
5568 gtk_tree_model_get (model, &iter, 0, &name, -1);
5569 found = !g_ascii_strcasecmp (display_name, name);
5576 gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (data->combo), display_name);
5577 new_screen = gdk_display_get_default_screen (display);
5582 gint number_of_screens = gdk_display_get_n_screens (display);
5583 gint screen_num = gdk_screen_get_number (current_screen);
5584 if ((screen_num +1) < number_of_screens)
5585 new_screen = gdk_display_get_screen (display, screen_num + 1);
5587 new_screen = gdk_display_get_screen (display, 0);
5592 gtk_window_set_screen (GTK_WINDOW (data->toplevel), new_screen);
5593 gtk_widget_destroy (data->dialog_window);
5598 screen_display_destroy_diag (GtkWidget *widget, GtkWidget *data)
5600 gtk_widget_destroy (data);
5604 create_display_screen (GtkWidget *widget)
5606 GtkWidget *table, *frame, *window, *combo_dpy, *vbox;
5607 GtkWidget *radio_dpy, *radio_scr, *applyb, *cancelb;
5609 ScreenDisplaySelection *scr_dpy_data;
5610 GdkScreen *screen = gtk_widget_get_screen (widget);
5611 GdkDisplay *display = gdk_screen_get_display (screen);
5613 window = g_object_new (gtk_window_get_type (),
5616 "type", GTK_WINDOW_TOPLEVEL,
5618 "Screen or Display selection",
5619 "border_width", 10, NULL);
5620 g_signal_connect (window, "destroy",
5621 G_CALLBACK (gtk_widget_destroy), NULL);
5623 vbox = gtk_vbox_new (FALSE, 3);
5624 gtk_container_add (GTK_CONTAINER (window), vbox);
5626 frame = gtk_frame_new ("Select screen or display");
5627 gtk_container_add (GTK_CONTAINER (vbox), frame);
5629 table = gtk_table_new (2, 2, TRUE);
5630 gtk_table_set_row_spacings (GTK_TABLE (table), 3);
5631 gtk_table_set_col_spacings (GTK_TABLE (table), 3);
5633 gtk_container_add (GTK_CONTAINER (frame), table);
5635 radio_dpy = gtk_radio_button_new_with_label (NULL, "move to another X display");
5636 if (gdk_display_get_n_screens(display) > 1)
5637 radio_scr = gtk_radio_button_new_with_label
5638 (gtk_radio_button_get_group (GTK_RADIO_BUTTON (radio_dpy)), "move to next screen");
5641 radio_scr = gtk_radio_button_new_with_label
5642 (gtk_radio_button_get_group (GTK_RADIO_BUTTON (radio_dpy)),
5643 "only one screen on the current display");
5644 gtk_widget_set_sensitive (radio_scr, FALSE);
5646 combo_dpy = gtk_combo_box_text_new_with_entry ();
5647 gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo_dpy), "diabolo:0.0");
5648 gtk_entry_set_text (GTK_ENTRY (gtk_bin_get_child (GTK_BIN (combo_dpy))),
5649 "<hostname>:<X Server Num>.<Screen Num>");
5651 gtk_table_attach_defaults (GTK_TABLE (table), radio_dpy, 0, 1, 0, 1);
5652 gtk_table_attach_defaults (GTK_TABLE (table), radio_scr, 0, 1, 1, 2);
5653 gtk_table_attach_defaults (GTK_TABLE (table), combo_dpy, 1, 2, 0, 1);
5655 bbox = gtk_button_box_new (GTK_ORIENTATION_HORIZONTAL);
5656 applyb = gtk_button_new_from_stock (GTK_STOCK_APPLY);
5657 cancelb = gtk_button_new_from_stock (GTK_STOCK_CANCEL);
5659 gtk_container_add (GTK_CONTAINER (vbox), bbox);
5661 gtk_container_add (GTK_CONTAINER (bbox), applyb);
5662 gtk_container_add (GTK_CONTAINER (bbox), cancelb);
5664 scr_dpy_data = g_new0 (ScreenDisplaySelection, 1);
5666 scr_dpy_data->entry = gtk_bin_get_child (GTK_BIN (combo_dpy));
5667 scr_dpy_data->radio_dpy = radio_dpy;
5668 scr_dpy_data->toplevel = gtk_widget_get_toplevel (widget);
5669 scr_dpy_data->dialog_window = window;
5671 g_signal_connect (cancelb, "clicked",
5672 G_CALLBACK (screen_display_destroy_diag), window);
5673 g_signal_connect (applyb, "clicked",
5674 G_CALLBACK (screen_display_check), scr_dpy_data);
5675 gtk_widget_show_all (window);
5680 static gulong event_watcher_enter_id = 0;
5681 static gulong event_watcher_leave_id = 0;
5684 event_watcher (GSignalInvocationHint *ihint,
5685 guint n_param_values,
5686 const GValue *param_values,
5689 g_print ("Watch: \"%s\" emitted for %s\n",
5690 g_signal_name (ihint->signal_id),
5691 G_OBJECT_TYPE_NAME (g_value_get_object (param_values + 0)));
5697 event_watcher_down (void)
5699 if (event_watcher_enter_id)
5703 signal_id = g_signal_lookup ("enter_notify_event", GTK_TYPE_WIDGET);
5704 g_signal_remove_emission_hook (signal_id, event_watcher_enter_id);
5705 event_watcher_enter_id = 0;
5706 signal_id = g_signal_lookup ("leave_notify_event", GTK_TYPE_WIDGET);
5707 g_signal_remove_emission_hook (signal_id, event_watcher_leave_id);
5708 event_watcher_leave_id = 0;
5713 event_watcher_toggle (void)
5715 if (event_watcher_enter_id)
5716 event_watcher_down ();
5721 signal_id = g_signal_lookup ("enter_notify_event", GTK_TYPE_WIDGET);
5722 event_watcher_enter_id = g_signal_add_emission_hook (signal_id, 0, event_watcher, NULL, NULL);
5723 signal_id = g_signal_lookup ("leave_notify_event", GTK_TYPE_WIDGET);
5724 event_watcher_leave_id = g_signal_add_emission_hook (signal_id, 0, event_watcher, NULL, NULL);
5729 create_event_watcher (GtkWidget *widget)
5731 GtkWidget *action_area, *content_area;
5736 dialog_window = gtk_dialog_new ();
5737 gtk_window_set_screen (GTK_WINDOW (dialog_window),
5738 gtk_widget_get_screen (widget));
5740 g_signal_connect (dialog_window, "destroy",
5741 G_CALLBACK (gtk_widget_destroyed),
5743 g_signal_connect (dialog_window, "destroy",
5744 G_CALLBACK (event_watcher_down),
5747 content_area = gtk_dialog_get_content_area (GTK_DIALOG (dialog_window));
5748 action_area = gtk_dialog_get_action_area (GTK_DIALOG (dialog_window));
5750 gtk_window_set_title (GTK_WINDOW (dialog_window), "Event Watcher");
5751 gtk_container_set_border_width (GTK_CONTAINER (dialog_window), 0);
5752 gtk_widget_set_size_request (dialog_window, 200, 110);
5754 button = gtk_toggle_button_new_with_label ("Activate Watch");
5755 g_signal_connect (button, "clicked",
5756 G_CALLBACK (event_watcher_toggle),
5758 gtk_container_set_border_width (GTK_CONTAINER (button), 10);
5759 gtk_box_pack_start (GTK_BOX (content_area), button, TRUE, TRUE, 0);
5760 gtk_widget_show (button);
5762 button = gtk_button_new_with_label ("Close");
5763 g_signal_connect_swapped (button, "clicked",
5764 G_CALLBACK (gtk_widget_destroy),
5766 gtk_widget_set_can_default (button, TRUE);
5767 gtk_box_pack_start (GTK_BOX (action_area), button, TRUE, TRUE, 0);
5768 gtk_widget_grab_default (button);
5769 gtk_widget_show (button);
5772 if (!gtk_widget_get_visible (dialog_window))
5773 gtk_widget_show (dialog_window);
5775 gtk_widget_destroy (dialog_window);
5783 reformat_value (GtkScale *scale,
5786 return g_strdup_printf ("-->%0.*g<--",
5787 gtk_scale_get_digits (scale), value);
5791 create_range_controls (GtkWidget *widget)
5793 static GtkWidget *window = NULL;
5797 GtkWidget *scrollbar;
5799 GtkWidget *separator;
5800 GtkAdjustment *adjustment;
5805 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
5807 gtk_window_set_screen (GTK_WINDOW (window),
5808 gtk_widget_get_screen (widget));
5810 g_signal_connect (window, "destroy",
5811 G_CALLBACK (gtk_widget_destroyed),
5814 gtk_window_set_title (GTK_WINDOW (window), "range controls");
5815 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
5818 box1 = gtk_vbox_new (FALSE, 0);
5819 gtk_container_add (GTK_CONTAINER (window), box1);
5820 gtk_widget_show (box1);
5823 box2 = gtk_vbox_new (FALSE, 10);
5824 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
5825 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
5826 gtk_widget_show (box2);
5829 adjustment = gtk_adjustment_new (0.0, 0.0, 101.0, 0.1, 1.0, 1.0);
5831 scale = gtk_hscale_new (GTK_ADJUSTMENT (adjustment));
5832 gtk_widget_set_size_request (GTK_WIDGET (scale), 150, -1);
5833 gtk_range_set_update_policy (GTK_RANGE (scale), GTK_UPDATE_DELAYED);
5834 gtk_scale_set_digits (GTK_SCALE (scale), 1);
5835 gtk_scale_set_draw_value (GTK_SCALE (scale), TRUE);
5836 gtk_box_pack_start (GTK_BOX (box2), scale, TRUE, TRUE, 0);
5837 gtk_widget_show (scale);
5839 scrollbar = gtk_hscrollbar_new (GTK_ADJUSTMENT (adjustment));
5840 gtk_range_set_update_policy (GTK_RANGE (scrollbar),
5841 GTK_UPDATE_CONTINUOUS);
5842 gtk_box_pack_start (GTK_BOX (box2), scrollbar, TRUE, TRUE, 0);
5843 gtk_widget_show (scrollbar);
5845 scale = gtk_hscale_new (GTK_ADJUSTMENT (adjustment));
5846 gtk_scale_set_draw_value (GTK_SCALE (scale), TRUE);
5847 g_signal_connect (scale,
5849 G_CALLBACK (reformat_value),
5851 gtk_box_pack_start (GTK_BOX (box2), scale, TRUE, TRUE, 0);
5852 gtk_widget_show (scale);
5854 hbox = gtk_hbox_new (FALSE, 0);
5856 scale = gtk_vscale_new (GTK_ADJUSTMENT (adjustment));
5857 gtk_widget_set_size_request (scale, -1, 200);
5858 gtk_scale_set_digits (GTK_SCALE (scale), 2);
5859 gtk_scale_set_draw_value (GTK_SCALE (scale), TRUE);
5860 gtk_box_pack_start (GTK_BOX (hbox), scale, TRUE, TRUE, 0);
5861 gtk_widget_show (scale);
5863 scale = gtk_vscale_new (GTK_ADJUSTMENT (adjustment));
5864 gtk_widget_set_size_request (scale, -1, 200);
5865 gtk_scale_set_digits (GTK_SCALE (scale), 2);
5866 gtk_scale_set_draw_value (GTK_SCALE (scale), TRUE);
5867 gtk_range_set_inverted (GTK_RANGE (scale), TRUE);
5868 gtk_box_pack_start (GTK_BOX (hbox), scale, TRUE, TRUE, 0);
5869 gtk_widget_show (scale);
5871 scale = gtk_vscale_new (GTK_ADJUSTMENT (adjustment));
5872 gtk_scale_set_draw_value (GTK_SCALE (scale), TRUE);
5873 g_signal_connect (scale,
5875 G_CALLBACK (reformat_value),
5877 gtk_box_pack_start (GTK_BOX (hbox), scale, TRUE, TRUE, 0);
5878 gtk_widget_show (scale);
5881 gtk_box_pack_start (GTK_BOX (box2), hbox, TRUE, TRUE, 0);
5882 gtk_widget_show (hbox);
5884 separator = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
5885 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
5886 gtk_widget_show (separator);
5889 box2 = gtk_vbox_new (FALSE, 10);
5890 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
5891 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
5892 gtk_widget_show (box2);
5895 button = gtk_button_new_with_label ("close");
5896 g_signal_connect_swapped (button, "clicked",
5897 G_CALLBACK (gtk_widget_destroy),
5899 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
5900 gtk_widget_set_can_default (button, TRUE);
5901 gtk_widget_grab_default (button);
5902 gtk_widget_show (button);
5905 if (!gtk_widget_get_visible (window))
5906 gtk_widget_show (window);
5908 gtk_widget_destroy (window);
5916 create_rulers (GtkWidget *widget)
5918 static GtkWidget *window = NULL;
5924 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
5926 gtk_window_set_screen (GTK_WINDOW (window),
5927 gtk_widget_get_screen (widget));
5929 gtk_window_set_resizable (GTK_WINDOW (window), TRUE);
5931 g_signal_connect (window, "destroy",
5932 G_CALLBACK (gtk_widget_destroyed),
5935 gtk_window_set_title (GTK_WINDOW (window), "rulers");
5936 gtk_widget_set_size_request (window, 300, 300);
5937 gtk_widget_set_events (window,
5938 GDK_POINTER_MOTION_MASK
5939 | GDK_POINTER_MOTION_HINT_MASK);
5940 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
5942 table = gtk_table_new (2, 2, FALSE);
5943 gtk_container_add (GTK_CONTAINER (window), table);
5944 gtk_widget_show (table);
5946 ruler = gtk_ruler_new (GTK_ORIENTATION_HORIZONTAL);
5947 gtk_ruler_set_metric (GTK_RULER (ruler), GTK_CENTIMETERS);
5948 gtk_ruler_set_range (GTK_RULER (ruler), 100, 0, 0, 20);
5950 g_signal_connect_swapped (window,
5951 "motion_notify_event",
5952 G_CALLBACK (GTK_WIDGET_GET_CLASS (ruler)->motion_notify_event),
5955 gtk_table_attach (GTK_TABLE (table), ruler, 1, 2, 0, 1,
5956 GTK_EXPAND | GTK_FILL, GTK_FILL, 0, 0);
5957 gtk_widget_show (ruler);
5960 ruler = gtk_ruler_new (GTK_ORIENTATION_VERTICAL);
5961 gtk_ruler_set_range (GTK_RULER (ruler), 5, 15, 0, 20);
5963 g_signal_connect_swapped (window,
5964 "motion_notify_event",
5965 G_CALLBACK (GTK_WIDGET_GET_CLASS (ruler)->motion_notify_event),
5968 gtk_table_attach (GTK_TABLE (table), ruler, 0, 1, 1, 2,
5969 GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
5970 gtk_widget_show (ruler);
5973 if (!gtk_widget_get_visible (window))
5974 gtk_widget_show (window);
5976 gtk_widget_destroy (window);
5983 { { 0, 0x0000, 0x0000, 0x0000 }, "black" },
5984 { { 0, 0xFFFF, 0xFFFF, 0xFFFF }, "white" },
5985 { { 0, 0xFFFF, 0x0000, 0x0000 }, "red" },
5986 { { 0, 0x0000, 0xFFFF, 0x0000 }, "green" },
5987 { { 0, 0x0000, 0x0000, 0xFFFF }, "blue" },
5988 { { 0, 0x0000, 0xFFFF, 0xFFFF }, "cyan" },
5989 { { 0, 0xFFFF, 0x0000, 0xFFFF }, "magenta" },
5990 { { 0, 0xFFFF, 0xFFFF, 0x0000 }, "yellow" }
5993 int ntext_colors = sizeof(text_colors) / sizeof(text_colors[0]);
5999 static const char * book_open_xpm[] = {
6022 static const char * book_closed_xpm[] = {
6047 GdkPixbuf *book_open;
6048 GdkPixbuf *book_closed;
6049 GtkWidget *sample_notebook;
6052 set_page_image (GtkNotebook *notebook, gint page_num, GdkPixbuf *pixbuf)
6054 GtkWidget *page_widget;
6057 page_widget = gtk_notebook_get_nth_page (notebook, page_num);
6059 pixwid = g_object_get_data (G_OBJECT (page_widget), "tab_pixmap");
6060 gtk_image_set_from_pixbuf (GTK_IMAGE (pixwid), pixbuf);
6062 pixwid = g_object_get_data (G_OBJECT (page_widget), "menu_pixmap");
6063 gtk_image_set_from_pixbuf (GTK_IMAGE (pixwid), pixbuf);
6067 page_switch (GtkWidget *widget, gpointer *page, gint page_num)
6069 GtkNotebook *notebook = GTK_NOTEBOOK (widget);
6070 gint old_page_num = gtk_notebook_get_current_page (notebook);
6072 if (page_num == old_page_num)
6075 set_page_image (notebook, page_num, book_open);
6077 if (old_page_num != -1)
6078 set_page_image (notebook, old_page_num, book_closed);
6082 tab_fill (GtkToggleButton *button, GtkWidget *child)
6084 gtk_container_child_set (GTK_CONTAINER (sample_notebook), child,
6085 "tab-fill", gtk_toggle_button_get_active (button),
6090 tab_expand (GtkToggleButton *button, GtkWidget *child)
6092 gtk_container_child_set (GTK_CONTAINER (sample_notebook), child,
6093 "tab-expand", gtk_toggle_button_get_active (button),
6098 create_pages (GtkNotebook *notebook, gint start, gint end)
6100 GtkWidget *child = NULL;
6105 GtkWidget *label_box;
6106 GtkWidget *menu_box;
6110 char accel_buffer[32];
6112 for (i = start; i <= end; i++)
6114 sprintf (buffer, "Page %d", i);
6115 sprintf (accel_buffer, "Page _%d", i);
6117 child = gtk_frame_new (buffer);
6118 gtk_container_set_border_width (GTK_CONTAINER (child), 10);
6120 vbox = gtk_vbox_new (TRUE,0);
6121 gtk_container_set_border_width (GTK_CONTAINER (vbox), 10);
6122 gtk_container_add (GTK_CONTAINER (child), vbox);
6124 hbox = gtk_hbox_new (TRUE,0);
6125 gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 5);
6127 button = gtk_check_button_new_with_label ("Fill Tab");
6128 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
6129 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
6130 g_signal_connect (button, "toggled",
6131 G_CALLBACK (tab_fill), child);
6133 button = gtk_check_button_new_with_label ("Expand Tab");
6134 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
6135 g_signal_connect (button, "toggled",
6136 G_CALLBACK (tab_expand), child);
6138 button = gtk_button_new_with_label ("Hide Page");
6139 gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 5);
6140 g_signal_connect_swapped (button, "clicked",
6141 G_CALLBACK (gtk_widget_hide),
6144 gtk_widget_show_all (child);
6146 label_box = gtk_hbox_new (FALSE, 0);
6147 pixwid = gtk_image_new_from_pixbuf (book_closed);
6148 g_object_set_data (G_OBJECT (child), "tab_pixmap", pixwid);
6150 gtk_box_pack_start (GTK_BOX (label_box), pixwid, FALSE, TRUE, 0);
6151 gtk_misc_set_padding (GTK_MISC (pixwid), 3, 1);
6152 label = gtk_label_new_with_mnemonic (accel_buffer);
6153 gtk_box_pack_start (GTK_BOX (label_box), label, FALSE, TRUE, 0);
6154 gtk_widget_show_all (label_box);
6157 menu_box = gtk_hbox_new (FALSE, 0);
6158 pixwid = gtk_image_new_from_pixbuf (book_closed);
6159 g_object_set_data (G_OBJECT (child), "menu_pixmap", pixwid);
6161 gtk_box_pack_start (GTK_BOX (menu_box), pixwid, FALSE, TRUE, 0);
6162 gtk_misc_set_padding (GTK_MISC (pixwid), 3, 1);
6163 label = gtk_label_new (buffer);
6164 gtk_box_pack_start (GTK_BOX (menu_box), label, FALSE, TRUE, 0);
6165 gtk_widget_show_all (menu_box);
6167 gtk_notebook_append_page_menu (notebook, child, label_box, menu_box);
6172 rotate_notebook (GtkButton *button,
6173 GtkNotebook *notebook)
6175 gtk_notebook_set_tab_pos (notebook, (gtk_notebook_get_tab_pos (notebook) + 1) % 4);
6179 show_all_pages (GtkButton *button,
6180 GtkNotebook *notebook)
6182 gtk_container_foreach (GTK_CONTAINER (notebook),
6183 (GtkCallback) gtk_widget_show, NULL);
6187 notebook_type_changed (GtkWidget *optionmenu,
6190 GtkNotebook *notebook;
6200 notebook = GTK_NOTEBOOK (data);
6202 c = gtk_combo_box_get_active (GTK_COMBO_BOX (optionmenu));
6207 /* standard notebook */
6208 gtk_notebook_set_show_tabs (notebook, TRUE);
6209 gtk_notebook_set_show_border (notebook, TRUE);
6210 gtk_notebook_set_scrollable (notebook, FALSE);
6214 /* notabs notebook */
6215 gtk_notebook_set_show_tabs (notebook, FALSE);
6216 gtk_notebook_set_show_border (notebook, TRUE);
6221 gtk_notebook_set_show_tabs (notebook, FALSE);
6222 gtk_notebook_set_show_border (notebook, FALSE);
6227 gtk_notebook_set_show_tabs (notebook, TRUE);
6228 gtk_notebook_set_show_border (notebook, TRUE);
6229 gtk_notebook_set_scrollable (notebook, TRUE);
6230 if (gtk_notebook_get_n_pages (notebook) == 5)
6231 create_pages (notebook, 6, 15);
6237 if (gtk_notebook_get_n_pages (notebook) == 15)
6238 for (i = 0; i < 10; i++)
6239 gtk_notebook_remove_page (notebook, 5);
6243 notebook_popup (GtkToggleButton *button,
6244 GtkNotebook *notebook)
6246 if (gtk_toggle_button_get_active (button))
6247 gtk_notebook_popup_enable (notebook);
6249 gtk_notebook_popup_disable (notebook);
6253 create_notebook (GtkWidget *widget)
6255 static GtkWidget *window = NULL;
6259 GtkWidget *separator;
6263 static gchar *items[] =
6273 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
6274 gtk_window_set_screen (GTK_WINDOW (window),
6275 gtk_widget_get_screen (widget));
6277 g_signal_connect (window, "destroy",
6278 G_CALLBACK (gtk_widget_destroyed),
6281 gtk_window_set_title (GTK_WINDOW (window), "notebook");
6282 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
6284 box1 = gtk_vbox_new (FALSE, 0);
6285 gtk_container_add (GTK_CONTAINER (window), box1);
6287 sample_notebook = gtk_notebook_new ();
6288 g_signal_connect (sample_notebook, "switch_page",
6289 G_CALLBACK (page_switch), NULL);
6290 gtk_notebook_set_tab_pos (GTK_NOTEBOOK (sample_notebook), GTK_POS_TOP);
6291 gtk_box_pack_start (GTK_BOX (box1), sample_notebook, TRUE, TRUE, 0);
6292 gtk_container_set_border_width (GTK_CONTAINER (sample_notebook), 10);
6294 gtk_widget_realize (sample_notebook);
6297 book_open = gdk_pixbuf_new_from_xpm_data (book_open_xpm);
6300 book_closed = gdk_pixbuf_new_from_xpm_data (book_closed_xpm);
6302 create_pages (GTK_NOTEBOOK (sample_notebook), 1, 5);
6304 separator = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
6305 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 10);
6307 box2 = gtk_hbox_new (FALSE, 5);
6308 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
6309 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
6311 button = gtk_check_button_new_with_label ("popup menu");
6312 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, FALSE, 0);
6313 g_signal_connect (button, "clicked",
6314 G_CALLBACK (notebook_popup),
6317 box2 = gtk_hbox_new (FALSE, 5);
6318 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
6319 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
6321 label = gtk_label_new ("Notebook Style :");
6322 gtk_box_pack_start (GTK_BOX (box2), label, FALSE, TRUE, 0);
6324 omenu = build_option_menu (items, G_N_ELEMENTS (items), 0,
6325 notebook_type_changed,
6327 gtk_box_pack_start (GTK_BOX (box2), omenu, FALSE, TRUE, 0);
6329 button = gtk_button_new_with_label ("Show all Pages");
6330 gtk_box_pack_start (GTK_BOX (box2), button, FALSE, TRUE, 0);
6331 g_signal_connect (button, "clicked",
6332 G_CALLBACK (show_all_pages), sample_notebook);
6334 box2 = gtk_hbox_new (TRUE, 10);
6335 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
6336 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
6338 button = gtk_button_new_with_label ("prev");
6339 g_signal_connect_swapped (button, "clicked",
6340 G_CALLBACK (gtk_notebook_prev_page),
6342 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
6344 button = gtk_button_new_with_label ("next");
6345 g_signal_connect_swapped (button, "clicked",
6346 G_CALLBACK (gtk_notebook_next_page),
6348 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
6350 button = gtk_button_new_with_label ("rotate");
6351 g_signal_connect (button, "clicked",
6352 G_CALLBACK (rotate_notebook), sample_notebook);
6353 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
6355 separator = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
6356 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 5);
6358 button = gtk_button_new_with_label ("close");
6359 gtk_container_set_border_width (GTK_CONTAINER (button), 5);
6360 g_signal_connect_swapped (button, "clicked",
6361 G_CALLBACK (gtk_widget_destroy),
6363 gtk_box_pack_start (GTK_BOX (box1), button, FALSE, FALSE, 0);
6364 gtk_widget_set_can_default (button, TRUE);
6365 gtk_widget_grab_default (button);
6368 if (!gtk_widget_get_visible (window))
6369 gtk_widget_show_all (window);
6371 gtk_widget_destroy (window);
6379 toggle_resize (GtkWidget *widget, GtkWidget *child)
6381 GtkContainer *container = GTK_CONTAINER (gtk_widget_get_parent (child));
6382 GValue value = { 0, };
6383 g_value_init (&value, G_TYPE_BOOLEAN);
6384 gtk_container_child_get_property (container, child, "resize", &value);
6385 g_value_set_boolean (&value, !g_value_get_boolean (&value));
6386 gtk_container_child_set_property (container, child, "resize", &value);
6390 toggle_shrink (GtkWidget *widget, GtkWidget *child)
6392 GtkContainer *container = GTK_CONTAINER (gtk_widget_get_parent (child));
6393 GValue value = { 0, };
6394 g_value_init (&value, G_TYPE_BOOLEAN);
6395 gtk_container_child_get_property (container, child, "shrink", &value);
6396 g_value_set_boolean (&value, !g_value_get_boolean (&value));
6397 gtk_container_child_set_property (container, child, "shrink", &value);
6401 paned_props_clicked (GtkWidget *button,
6404 GtkWidget *window = create_prop_editor (paned, GTK_TYPE_PANED);
6406 gtk_window_set_title (GTK_WINDOW (window), "Paned Properties");
6410 create_pane_options (GtkPaned *paned,
6411 const gchar *frame_label,
6412 const gchar *label1,
6413 const gchar *label2)
6415 GtkWidget *child1, *child2;
6420 GtkWidget *check_button;
6422 child1 = gtk_paned_get_child1 (paned);
6423 child2 = gtk_paned_get_child2 (paned);
6425 frame = gtk_frame_new (frame_label);
6426 gtk_container_set_border_width (GTK_CONTAINER (frame), 4);
6428 table = gtk_table_new (4, 2, 4);
6429 gtk_container_add (GTK_CONTAINER (frame), table);
6431 label = gtk_label_new (label1);
6432 gtk_table_attach_defaults (GTK_TABLE (table), label,
6435 check_button = gtk_check_button_new_with_label ("Resize");
6436 gtk_table_attach_defaults (GTK_TABLE (table), check_button,
6438 g_signal_connect (check_button, "toggled",
6439 G_CALLBACK (toggle_resize),
6442 check_button = gtk_check_button_new_with_label ("Shrink");
6443 gtk_table_attach_defaults (GTK_TABLE (table), check_button,
6445 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check_button),
6447 g_signal_connect (check_button, "toggled",
6448 G_CALLBACK (toggle_shrink),
6451 label = gtk_label_new (label2);
6452 gtk_table_attach_defaults (GTK_TABLE (table), label,
6455 check_button = gtk_check_button_new_with_label ("Resize");
6456 gtk_table_attach_defaults (GTK_TABLE (table), check_button,
6458 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check_button),
6460 g_signal_connect (check_button, "toggled",
6461 G_CALLBACK (toggle_resize),
6464 check_button = gtk_check_button_new_with_label ("Shrink");
6465 gtk_table_attach_defaults (GTK_TABLE (table), check_button,
6467 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check_button),
6469 g_signal_connect (check_button, "toggled",
6470 G_CALLBACK (toggle_shrink),
6473 button = gtk_button_new_with_mnemonic ("_Properties");
6474 gtk_table_attach_defaults (GTK_TABLE (table), button,
6476 g_signal_connect (button, "clicked",
6477 G_CALLBACK (paned_props_clicked),
6484 create_panes (GtkWidget *widget)
6486 static GtkWidget *window = NULL;
6495 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
6497 gtk_window_set_screen (GTK_WINDOW (window),
6498 gtk_widget_get_screen (widget));
6500 g_signal_connect (window, "destroy",
6501 G_CALLBACK (gtk_widget_destroyed),
6504 gtk_window_set_title (GTK_WINDOW (window), "Panes");
6505 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
6507 vbox = gtk_vbox_new (FALSE, 0);
6508 gtk_container_add (GTK_CONTAINER (window), vbox);
6510 vpaned = gtk_vpaned_new ();
6511 gtk_box_pack_start (GTK_BOX (vbox), vpaned, TRUE, TRUE, 0);
6512 gtk_container_set_border_width (GTK_CONTAINER(vpaned), 5);
6514 hpaned = gtk_hpaned_new ();
6515 gtk_paned_add1 (GTK_PANED (vpaned), hpaned);
6517 frame = gtk_frame_new (NULL);
6518 gtk_frame_set_shadow_type (GTK_FRAME(frame), GTK_SHADOW_IN);
6519 gtk_widget_set_size_request (frame, 60, 60);
6520 gtk_paned_add1 (GTK_PANED (hpaned), frame);
6522 button = gtk_button_new_with_label ("Hi there");
6523 gtk_container_add (GTK_CONTAINER(frame), button);
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, 80, 60);
6528 gtk_paned_add2 (GTK_PANED (hpaned), frame);
6530 frame = gtk_frame_new (NULL);
6531 gtk_frame_set_shadow_type (GTK_FRAME(frame), GTK_SHADOW_IN);
6532 gtk_widget_set_size_request (frame, 60, 80);
6533 gtk_paned_add2 (GTK_PANED (vpaned), frame);
6535 /* Now create toggle buttons to control sizing */
6537 gtk_box_pack_start (GTK_BOX (vbox),
6538 create_pane_options (GTK_PANED (hpaned),
6544 gtk_box_pack_start (GTK_BOX (vbox),
6545 create_pane_options (GTK_PANED (vpaned),
6551 gtk_widget_show_all (vbox);
6554 if (!gtk_widget_get_visible (window))
6555 gtk_widget_show (window);
6557 gtk_widget_destroy (window);
6561 * Paned keyboard navigation
6565 paned_keyboard_window1 (GtkWidget *widget)
6588 window1 = gtk_window_new (GTK_WINDOW_TOPLEVEL);
6589 gtk_window_set_title (GTK_WINDOW (window1), "Basic paned navigation");
6590 gtk_window_set_screen (GTK_WINDOW (window1),
6591 gtk_widget_get_screen (widget));
6593 hpaned1 = gtk_hpaned_new ();
6594 gtk_container_add (GTK_CONTAINER (window1), hpaned1);
6596 frame1 = gtk_frame_new (NULL);
6597 gtk_paned_pack1 (GTK_PANED (hpaned1), frame1, FALSE, TRUE);
6598 gtk_frame_set_shadow_type (GTK_FRAME (frame1), GTK_SHADOW_IN);
6600 vbox1 = gtk_vbox_new (FALSE, 0);
6601 gtk_container_add (GTK_CONTAINER (frame1), vbox1);
6603 button7 = gtk_button_new_with_label ("button7");
6604 gtk_box_pack_start (GTK_BOX (vbox1), button7, FALSE, FALSE, 0);
6606 button8 = gtk_button_new_with_label ("button8");
6607 gtk_box_pack_start (GTK_BOX (vbox1), button8, FALSE, FALSE, 0);
6609 button9 = gtk_button_new_with_label ("button9");
6610 gtk_box_pack_start (GTK_BOX (vbox1), button9, FALSE, FALSE, 0);
6612 vpaned1 = gtk_vpaned_new ();
6613 gtk_paned_pack2 (GTK_PANED (hpaned1), vpaned1, TRUE, TRUE);
6615 frame2 = gtk_frame_new (NULL);
6616 gtk_paned_pack1 (GTK_PANED (vpaned1), frame2, FALSE, TRUE);
6617 gtk_frame_set_shadow_type (GTK_FRAME (frame2), GTK_SHADOW_IN);
6619 frame5 = gtk_frame_new (NULL);
6620 gtk_container_add (GTK_CONTAINER (frame2), frame5);
6622 hbox1 = gtk_hbox_new (FALSE, 0);
6623 gtk_container_add (GTK_CONTAINER (frame5), hbox1);
6625 button5 = gtk_button_new_with_label ("button5");
6626 gtk_box_pack_start (GTK_BOX (hbox1), button5, FALSE, FALSE, 0);
6628 button6 = gtk_button_new_with_label ("button6");
6629 gtk_box_pack_start (GTK_BOX (hbox1), button6, FALSE, FALSE, 0);
6631 frame3 = gtk_frame_new (NULL);
6632 gtk_paned_pack2 (GTK_PANED (vpaned1), frame3, TRUE, TRUE);
6633 gtk_frame_set_shadow_type (GTK_FRAME (frame3), GTK_SHADOW_IN);
6635 frame4 = gtk_frame_new ("Buttons");
6636 gtk_container_add (GTK_CONTAINER (frame3), frame4);
6637 gtk_container_set_border_width (GTK_CONTAINER (frame4), 15);
6639 table1 = gtk_table_new (2, 2, FALSE);
6640 gtk_container_add (GTK_CONTAINER (frame4), table1);
6641 gtk_container_set_border_width (GTK_CONTAINER (table1), 11);
6643 button1 = gtk_button_new_with_label ("button1");
6644 gtk_table_attach (GTK_TABLE (table1), button1, 0, 1, 0, 1,
6645 (GtkAttachOptions) (GTK_FILL),
6646 (GtkAttachOptions) (0), 0, 0);
6648 button2 = gtk_button_new_with_label ("button2");
6649 gtk_table_attach (GTK_TABLE (table1), button2, 1, 2, 0, 1,
6650 (GtkAttachOptions) (GTK_FILL),
6651 (GtkAttachOptions) (0), 0, 0);
6653 button3 = gtk_button_new_with_label ("button3");
6654 gtk_table_attach (GTK_TABLE (table1), button3, 0, 1, 1, 2,
6655 (GtkAttachOptions) (GTK_FILL),
6656 (GtkAttachOptions) (0), 0, 0);
6658 button4 = gtk_button_new_with_label ("button4");
6659 gtk_table_attach (GTK_TABLE (table1), button4, 1, 2, 1, 2,
6660 (GtkAttachOptions) (GTK_FILL),
6661 (GtkAttachOptions) (0), 0, 0);
6667 paned_keyboard_window2 (GtkWidget *widget)
6672 GtkWidget *button13;
6676 GtkWidget *button12;
6678 GtkWidget *button11;
6679 GtkWidget *button10;
6681 window2 = gtk_window_new (GTK_WINDOW_TOPLEVEL);
6682 gtk_window_set_title (GTK_WINDOW (window2), "\"button 10\" is not inside the horisontal pane");
6684 gtk_window_set_screen (GTK_WINDOW (window2),
6685 gtk_widget_get_screen (widget));
6687 hpaned2 = gtk_hpaned_new ();
6688 gtk_container_add (GTK_CONTAINER (window2), hpaned2);
6690 frame6 = gtk_frame_new (NULL);
6691 gtk_paned_pack1 (GTK_PANED (hpaned2), frame6, FALSE, TRUE);
6692 gtk_frame_set_shadow_type (GTK_FRAME (frame6), GTK_SHADOW_IN);
6694 button13 = gtk_button_new_with_label ("button13");
6695 gtk_container_add (GTK_CONTAINER (frame6), button13);
6697 hbox2 = gtk_hbox_new (FALSE, 0);
6698 gtk_paned_pack2 (GTK_PANED (hpaned2), hbox2, TRUE, TRUE);
6700 vpaned2 = gtk_vpaned_new ();
6701 gtk_box_pack_start (GTK_BOX (hbox2), vpaned2, TRUE, TRUE, 0);
6703 frame7 = gtk_frame_new (NULL);
6704 gtk_paned_pack1 (GTK_PANED (vpaned2), frame7, FALSE, TRUE);
6705 gtk_frame_set_shadow_type (GTK_FRAME (frame7), GTK_SHADOW_IN);
6707 button12 = gtk_button_new_with_label ("button12");
6708 gtk_container_add (GTK_CONTAINER (frame7), button12);
6710 frame8 = gtk_frame_new (NULL);
6711 gtk_paned_pack2 (GTK_PANED (vpaned2), frame8, TRUE, TRUE);
6712 gtk_frame_set_shadow_type (GTK_FRAME (frame8), GTK_SHADOW_IN);
6714 button11 = gtk_button_new_with_label ("button11");
6715 gtk_container_add (GTK_CONTAINER (frame8), button11);
6717 button10 = gtk_button_new_with_label ("button10");
6718 gtk_box_pack_start (GTK_BOX (hbox2), button10, FALSE, FALSE, 0);
6724 paned_keyboard_window3 (GtkWidget *widget)
6731 GtkWidget *button14;
6734 GtkWidget *button15;
6737 GtkWidget *button16;
6739 GtkWidget *button17;
6741 window3 = gtk_window_new (GTK_WINDOW_TOPLEVEL);
6742 g_object_set_data (G_OBJECT (window3), "window3", window3);
6743 gtk_window_set_title (GTK_WINDOW (window3), "Nested panes");
6745 gtk_window_set_screen (GTK_WINDOW (window3),
6746 gtk_widget_get_screen (widget));
6749 vbox2 = gtk_vbox_new (FALSE, 0);
6750 gtk_container_add (GTK_CONTAINER (window3), vbox2);
6752 label1 = gtk_label_new ("Three panes nested inside each other");
6753 gtk_box_pack_start (GTK_BOX (vbox2), label1, FALSE, FALSE, 0);
6755 hpaned3 = gtk_hpaned_new ();
6756 gtk_box_pack_start (GTK_BOX (vbox2), hpaned3, TRUE, TRUE, 0);
6758 frame9 = gtk_frame_new (NULL);
6759 gtk_paned_pack1 (GTK_PANED (hpaned3), frame9, FALSE, TRUE);
6760 gtk_frame_set_shadow_type (GTK_FRAME (frame9), GTK_SHADOW_IN);
6762 button14 = gtk_button_new_with_label ("button14");
6763 gtk_container_add (GTK_CONTAINER (frame9), button14);
6765 hpaned4 = gtk_hpaned_new ();
6766 gtk_paned_pack2 (GTK_PANED (hpaned3), hpaned4, TRUE, TRUE);
6768 frame10 = gtk_frame_new (NULL);
6769 gtk_paned_pack1 (GTK_PANED (hpaned4), frame10, FALSE, TRUE);
6770 gtk_frame_set_shadow_type (GTK_FRAME (frame10), GTK_SHADOW_IN);
6772 button15 = gtk_button_new_with_label ("button15");
6773 gtk_container_add (GTK_CONTAINER (frame10), button15);
6775 hpaned5 = gtk_hpaned_new ();
6776 gtk_paned_pack2 (GTK_PANED (hpaned4), hpaned5, TRUE, TRUE);
6778 frame11 = gtk_frame_new (NULL);
6779 gtk_paned_pack1 (GTK_PANED (hpaned5), frame11, FALSE, TRUE);
6780 gtk_frame_set_shadow_type (GTK_FRAME (frame11), GTK_SHADOW_IN);
6782 button16 = gtk_button_new_with_label ("button16");
6783 gtk_container_add (GTK_CONTAINER (frame11), button16);
6785 frame12 = gtk_frame_new (NULL);
6786 gtk_paned_pack2 (GTK_PANED (hpaned5), frame12, TRUE, TRUE);
6787 gtk_frame_set_shadow_type (GTK_FRAME (frame12), GTK_SHADOW_IN);
6789 button17 = gtk_button_new_with_label ("button17");
6790 gtk_container_add (GTK_CONTAINER (frame12), button17);
6796 paned_keyboard_window4 (GtkWidget *widget)
6803 GtkWidget *button19;
6804 GtkWidget *button18;
6807 GtkWidget *button21;
6808 GtkWidget *button20;
6810 GtkWidget *button23;
6811 GtkWidget *button22;
6813 GtkWidget *button25;
6814 GtkWidget *button24;
6816 window4 = gtk_window_new (GTK_WINDOW_TOPLEVEL);
6817 g_object_set_data (G_OBJECT (window4), "window4", window4);
6818 gtk_window_set_title (GTK_WINDOW (window4), "window4");
6820 gtk_window_set_screen (GTK_WINDOW (window4),
6821 gtk_widget_get_screen (widget));
6823 vbox3 = gtk_vbox_new (FALSE, 0);
6824 gtk_container_add (GTK_CONTAINER (window4), vbox3);
6826 label2 = gtk_label_new ("Widget tree:\n\nhpaned \n - vpaned\n - hbox\n - vpaned\n - vpaned\n - vpaned\n");
6827 gtk_box_pack_start (GTK_BOX (vbox3), label2, FALSE, FALSE, 0);
6828 gtk_label_set_justify (GTK_LABEL (label2), GTK_JUSTIFY_LEFT);
6830 hpaned6 = gtk_hpaned_new ();
6831 gtk_box_pack_start (GTK_BOX (vbox3), hpaned6, TRUE, TRUE, 0);
6833 vpaned3 = gtk_vpaned_new ();
6834 gtk_paned_pack1 (GTK_PANED (hpaned6), vpaned3, FALSE, TRUE);
6836 button19 = gtk_button_new_with_label ("button19");
6837 gtk_paned_pack1 (GTK_PANED (vpaned3), button19, FALSE, TRUE);
6839 button18 = gtk_button_new_with_label ("button18");
6840 gtk_paned_pack2 (GTK_PANED (vpaned3), button18, TRUE, TRUE);
6842 hbox3 = gtk_hbox_new (FALSE, 0);
6843 gtk_paned_pack2 (GTK_PANED (hpaned6), hbox3, TRUE, TRUE);
6845 vpaned4 = gtk_vpaned_new ();
6846 gtk_box_pack_start (GTK_BOX (hbox3), vpaned4, TRUE, TRUE, 0);
6848 button21 = gtk_button_new_with_label ("button21");
6849 gtk_paned_pack1 (GTK_PANED (vpaned4), button21, FALSE, TRUE);
6851 button20 = gtk_button_new_with_label ("button20");
6852 gtk_paned_pack2 (GTK_PANED (vpaned4), button20, TRUE, TRUE);
6854 vpaned5 = gtk_vpaned_new ();
6855 gtk_box_pack_start (GTK_BOX (hbox3), vpaned5, TRUE, TRUE, 0);
6857 button23 = gtk_button_new_with_label ("button23");
6858 gtk_paned_pack1 (GTK_PANED (vpaned5), button23, FALSE, TRUE);
6860 button22 = gtk_button_new_with_label ("button22");
6861 gtk_paned_pack2 (GTK_PANED (vpaned5), button22, TRUE, TRUE);
6863 vpaned6 = gtk_vpaned_new ();
6864 gtk_box_pack_start (GTK_BOX (hbox3), vpaned6, TRUE, TRUE, 0);
6866 button25 = gtk_button_new_with_label ("button25");
6867 gtk_paned_pack1 (GTK_PANED (vpaned6), button25, FALSE, TRUE);
6869 button24 = gtk_button_new_with_label ("button24");
6870 gtk_paned_pack2 (GTK_PANED (vpaned6), button24, TRUE, TRUE);
6876 create_paned_keyboard_navigation (GtkWidget *widget)
6878 static GtkWidget *window1 = NULL;
6879 static GtkWidget *window2 = NULL;
6880 static GtkWidget *window3 = NULL;
6881 static GtkWidget *window4 = NULL;
6884 (gtk_widget_get_screen (window1) != gtk_widget_get_screen (widget)))
6886 gtk_widget_destroy (window1);
6887 gtk_widget_destroy (window2);
6888 gtk_widget_destroy (window3);
6889 gtk_widget_destroy (window4);
6894 window1 = paned_keyboard_window1 (widget);
6895 g_signal_connect (window1, "destroy",
6896 G_CALLBACK (gtk_widget_destroyed),
6902 window2 = paned_keyboard_window2 (widget);
6903 g_signal_connect (window2, "destroy",
6904 G_CALLBACK (gtk_widget_destroyed),
6910 window3 = paned_keyboard_window3 (widget);
6911 g_signal_connect (window3, "destroy",
6912 G_CALLBACK (gtk_widget_destroyed),
6918 window4 = paned_keyboard_window4 (widget);
6919 g_signal_connect (window4, "destroy",
6920 G_CALLBACK (gtk_widget_destroyed),
6924 if (gtk_widget_get_visible (window1))
6925 gtk_widget_destroy (GTK_WIDGET (window1));
6927 gtk_widget_show_all (GTK_WIDGET (window1));
6929 if (gtk_widget_get_visible (window2))
6930 gtk_widget_destroy (GTK_WIDGET (window2));
6932 gtk_widget_show_all (GTK_WIDGET (window2));
6934 if (gtk_widget_get_visible (window3))
6935 gtk_widget_destroy (GTK_WIDGET (window3));
6937 gtk_widget_show_all (GTK_WIDGET (window3));
6939 if (gtk_widget_get_visible (window4))
6940 gtk_widget_destroy (GTK_WIDGET (window4));
6942 gtk_widget_show_all (GTK_WIDGET (window4));
6950 typedef struct _cursoroffset {gint x,y;} CursorOffset;
6953 shape_pressed (GtkWidget *widget, GdkEventButton *event)
6957 /* ignore double and triple click */
6958 if (event->type != GDK_BUTTON_PRESS)
6961 p = g_object_get_data (G_OBJECT (widget), "cursor_offset");
6962 p->x = (int) event->x;
6963 p->y = (int) event->y;
6965 gtk_grab_add (widget);
6966 gdk_pointer_grab (gtk_widget_get_window (widget), TRUE,
6967 GDK_BUTTON_RELEASE_MASK |
6968 GDK_BUTTON_MOTION_MASK |
6969 GDK_POINTER_MOTION_HINT_MASK,
6974 shape_released (GtkWidget *widget)
6976 gtk_grab_remove (widget);
6977 gdk_display_pointer_ungrab (gtk_widget_get_display (widget),
6982 shape_motion (GtkWidget *widget,
6983 GdkEventMotion *event)
6987 GdkModifierType mask;
6989 p = g_object_get_data (G_OBJECT (widget), "cursor_offset");
6992 * Can't use event->x / event->y here
6993 * because I need absolute coordinates.
6995 gdk_window_get_pointer (NULL, &xp, &yp, &mask);
6996 gtk_window_move (GTK_WINDOW (widget), xp - p->x, yp - p->y);
7000 shape_create_icon (GdkScreen *screen,
7011 CursorOffset* icon_pos;
7012 cairo_surface_t *mask;
7013 cairo_region_t *mask_region;
7018 * GDK_WINDOW_TOPLEVEL works also, giving you a title border
7020 window = gtk_window_new (window_type);
7021 gtk_window_set_screen (GTK_WINDOW (window), screen);
7023 fixed = gtk_fixed_new ();
7024 gtk_widget_set_size_request (fixed, 100, 100);
7025 gtk_container_add (GTK_CONTAINER (window), fixed);
7026 gtk_widget_show (fixed);
7028 gtk_widget_set_events (window,
7029 gtk_widget_get_events (window) |
7030 GDK_BUTTON_MOTION_MASK |
7031 GDK_POINTER_MOTION_HINT_MASK |
7032 GDK_BUTTON_PRESS_MASK);
7034 gtk_widget_realize (window);
7036 pixbuf = gdk_pixbuf_new_from_file (xpm_file, NULL);
7037 g_assert (pixbuf); /* FIXME: error handling */
7039 mask = cairo_image_surface_create (CAIRO_FORMAT_A1,
7040 gdk_pixbuf_get_width (pixbuf),
7041 gdk_pixbuf_get_height (pixbuf));
7042 cr = cairo_create (mask);
7043 gdk_cairo_set_source_pixbuf (cr, pixbuf, 0, 0);
7047 mask_region = gdk_cairo_region_create_from_surface (mask);
7049 cairo_region_translate (mask_region, px, py);
7051 image = gtk_image_new_from_pixbuf (pixbuf);
7052 gtk_fixed_put (GTK_FIXED (fixed), image, px,py);
7053 gtk_widget_show (image);
7055 gtk_widget_shape_combine_region (window, mask_region);
7057 cairo_region_destroy (mask_region);
7058 cairo_surface_destroy (mask);
7059 g_object_unref (pixbuf);
7061 g_signal_connect (window, "button_press_event",
7062 G_CALLBACK (shape_pressed), NULL);
7063 g_signal_connect (window, "button_release_event",
7064 G_CALLBACK (shape_released), NULL);
7065 g_signal_connect (window, "motion_notify_event",
7066 G_CALLBACK (shape_motion), NULL);
7068 icon_pos = g_new (CursorOffset, 1);
7069 g_object_set_data (G_OBJECT (window), "cursor_offset", icon_pos);
7071 gtk_window_move (GTK_WINDOW (window), x, y);
7072 gtk_widget_show (window);
7078 create_shapes (GtkWidget *widget)
7080 /* Variables used by the Drag/Drop and Shape Window demos */
7081 static GtkWidget *modeller = NULL;
7082 static GtkWidget *sheets = NULL;
7083 static GtkWidget *rings = NULL;
7084 static GtkWidget *with_region = NULL;
7085 GdkScreen *screen = gtk_widget_get_screen (widget);
7087 if (!(file_exists ("Modeller.xpm") &&
7088 file_exists ("FilesQueue.xpm") &&
7089 file_exists ("3DRings.xpm")))
7095 modeller = shape_create_icon (screen, "Modeller.xpm",
7096 440, 140, 0,0, GTK_WINDOW_POPUP);
7098 g_signal_connect (modeller, "destroy",
7099 G_CALLBACK (gtk_widget_destroyed),
7103 gtk_widget_destroy (modeller);
7107 sheets = shape_create_icon (screen, "FilesQueue.xpm",
7108 580, 170, 0,0, GTK_WINDOW_POPUP);
7110 g_signal_connect (sheets, "destroy",
7111 G_CALLBACK (gtk_widget_destroyed),
7116 gtk_widget_destroy (sheets);
7120 rings = shape_create_icon (screen, "3DRings.xpm",
7121 460, 270, 25,25, GTK_WINDOW_TOPLEVEL);
7123 g_signal_connect (rings, "destroy",
7124 G_CALLBACK (gtk_widget_destroyed),
7128 gtk_widget_destroy (rings);
7132 cairo_region_t *region;
7135 with_region = shape_create_icon (screen, "3DRings.xpm",
7136 460, 270, 25,25, GTK_WINDOW_TOPLEVEL);
7138 gtk_window_set_decorated (GTK_WINDOW (with_region), FALSE);
7140 g_signal_connect (with_region, "destroy",
7141 G_CALLBACK (gtk_widget_destroyed),
7144 /* reset shape from mask to a region */
7147 region = cairo_region_create ();
7159 cairo_region_union_rectangle (region, &rect);
7167 gdk_window_shape_combine_region (gtk_widget_get_window (with_region),
7172 gtk_widget_destroy (with_region);
7180 create_wmhints (GtkWidget *widget)
7182 static GtkWidget *window = NULL;
7184 GtkWidget *separator;
7188 GdkWindow *gdk_window;
7194 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
7196 gtk_window_set_screen (GTK_WINDOW (window),
7197 gtk_widget_get_screen (widget));
7199 g_signal_connect (window, "destroy",
7200 G_CALLBACK (gtk_widget_destroyed),
7203 gtk_window_set_title (GTK_WINDOW (window), "WM Hints");
7204 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
7206 gtk_widget_realize (window);
7208 gdk_window = gtk_widget_get_window (window);
7210 pixbuf = gdk_pixbuf_new_from_xpm_data ((const char **) openfile);
7211 list = g_list_prepend (NULL, pixbuf);
7213 gdk_window_set_icon_list (gdk_window, list);
7216 g_object_unref (pixbuf);
7218 gdk_window_set_icon_name (gdk_window, "WMHints Test Icon");
7220 gdk_window_set_decorations (gdk_window, GDK_DECOR_ALL | GDK_DECOR_MENU);
7221 gdk_window_set_functions (gdk_window, GDK_FUNC_ALL | GDK_FUNC_RESIZE);
7223 box1 = gtk_vbox_new (FALSE, 0);
7224 gtk_container_add (GTK_CONTAINER (window), box1);
7225 gtk_widget_show (box1);
7227 label = gtk_label_new ("Try iconizing me!");
7228 gtk_widget_set_size_request (label, 150, 50);
7229 gtk_box_pack_start (GTK_BOX (box1), label, TRUE, TRUE, 0);
7230 gtk_widget_show (label);
7233 separator = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
7234 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
7235 gtk_widget_show (separator);
7238 box2 = gtk_vbox_new (FALSE, 10);
7239 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
7240 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
7241 gtk_widget_show (box2);
7244 button = gtk_button_new_with_label ("close");
7246 g_signal_connect_swapped (button, "clicked",
7247 G_CALLBACK (gtk_widget_destroy),
7250 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
7251 gtk_widget_set_can_default (button, TRUE);
7252 gtk_widget_grab_default (button);
7253 gtk_widget_show (button);
7256 if (!gtk_widget_get_visible (window))
7257 gtk_widget_show (window);
7259 gtk_widget_destroy (window);
7264 * Window state tracking
7268 window_state_callback (GtkWidget *widget,
7269 GdkEventWindowState *event,
7272 GtkWidget *label = data;
7275 msg = g_strconcat (gtk_window_get_title (GTK_WINDOW (widget)), ": ",
7276 (event->new_window_state & GDK_WINDOW_STATE_WITHDRAWN) ?
7277 "withdrawn" : "not withdrawn", ", ",
7278 (event->new_window_state & GDK_WINDOW_STATE_ICONIFIED) ?
7279 "iconified" : "not iconified", ", ",
7280 (event->new_window_state & GDK_WINDOW_STATE_STICKY) ?
7281 "sticky" : "not sticky", ", ",
7282 (event->new_window_state & GDK_WINDOW_STATE_MAXIMIZED) ?
7283 "maximized" : "not maximized", ", ",
7284 (event->new_window_state & GDK_WINDOW_STATE_FULLSCREEN) ?
7285 "fullscreen" : "not fullscreen",
7286 (event->new_window_state & GDK_WINDOW_STATE_ABOVE) ?
7287 "above" : "not above", ", ",
7288 (event->new_window_state & GDK_WINDOW_STATE_BELOW) ?
7289 "below" : "not below", ", ",
7292 gtk_label_set_text (GTK_LABEL (label), msg);
7300 tracking_label (GtkWidget *window)
7306 hbox = gtk_hbox_new (FALSE, 5);
7308 g_signal_connect_object (hbox,
7310 G_CALLBACK (gtk_widget_destroy),
7314 label = gtk_label_new ("<no window state events received>");
7315 gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
7316 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
7318 g_signal_connect (window,
7319 "window_state_event",
7320 G_CALLBACK (window_state_callback),
7323 button = gtk_button_new_with_label ("Deiconify");
7324 g_signal_connect_object (button,
7326 G_CALLBACK (gtk_window_deiconify),
7329 gtk_box_pack_end (GTK_BOX (hbox), button, FALSE, FALSE, 0);
7331 button = gtk_button_new_with_label ("Iconify");
7332 g_signal_connect_object (button,
7334 G_CALLBACK (gtk_window_iconify),
7337 gtk_box_pack_end (GTK_BOX (hbox), button, FALSE, FALSE, 0);
7339 button = gtk_button_new_with_label ("Fullscreen");
7340 g_signal_connect_object (button,
7342 G_CALLBACK (gtk_window_fullscreen),
7345 gtk_box_pack_end (GTK_BOX (hbox), button, FALSE, FALSE, 0);
7347 button = gtk_button_new_with_label ("Unfullscreen");
7348 g_signal_connect_object (button,
7350 G_CALLBACK (gtk_window_unfullscreen),
7353 gtk_box_pack_end (GTK_BOX (hbox), button, FALSE, FALSE, 0);
7355 button = gtk_button_new_with_label ("Present");
7356 g_signal_connect_object (button,
7358 G_CALLBACK (gtk_window_present),
7361 gtk_box_pack_end (GTK_BOX (hbox), button, FALSE, FALSE, 0);
7363 button = gtk_button_new_with_label ("Show");
7364 g_signal_connect_object (button,
7366 G_CALLBACK (gtk_widget_show),
7369 gtk_box_pack_end (GTK_BOX (hbox), button, FALSE, FALSE, 0);
7371 gtk_widget_show_all (hbox);
7377 keep_window_above (GtkToggleButton *togglebutton, gpointer data)
7379 GtkWidget *button = g_object_get_data (G_OBJECT (togglebutton), "radio");
7381 gtk_window_set_keep_above (GTK_WINDOW (data),
7382 gtk_toggle_button_get_active (togglebutton));
7384 if (gtk_toggle_button_get_active (togglebutton))
7385 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), FALSE);
7389 keep_window_below (GtkToggleButton *togglebutton, gpointer data)
7391 GtkWidget *button = g_object_get_data (G_OBJECT (togglebutton), "radio");
7393 gtk_window_set_keep_below (GTK_WINDOW (data),
7394 gtk_toggle_button_get_active (togglebutton));
7396 if (gtk_toggle_button_get_active (togglebutton))
7397 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), FALSE);
7402 get_state_controls (GtkWidget *window)
7406 GtkWidget *button_above;
7407 GtkWidget *button_below;
7409 vbox = gtk_vbox_new (FALSE, 0);
7411 button = gtk_button_new_with_label ("Stick");
7412 g_signal_connect_object (button,
7414 G_CALLBACK (gtk_window_stick),
7417 gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
7419 button = gtk_button_new_with_label ("Unstick");
7420 g_signal_connect_object (button,
7422 G_CALLBACK (gtk_window_unstick),
7425 gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
7427 button = gtk_button_new_with_label ("Maximize");
7428 g_signal_connect_object (button,
7430 G_CALLBACK (gtk_window_maximize),
7433 gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
7435 button = gtk_button_new_with_label ("Unmaximize");
7436 g_signal_connect_object (button,
7438 G_CALLBACK (gtk_window_unmaximize),
7441 gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
7443 button = gtk_button_new_with_label ("Iconify");
7444 g_signal_connect_object (button,
7446 G_CALLBACK (gtk_window_iconify),
7449 gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
7451 button = gtk_button_new_with_label ("Fullscreen");
7452 g_signal_connect_object (button,
7454 G_CALLBACK (gtk_window_fullscreen),
7457 gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
7459 button = gtk_button_new_with_label ("Unfullscreen");
7460 g_signal_connect_object (button,
7462 G_CALLBACK (gtk_window_unfullscreen),
7465 gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
7467 button_above = gtk_toggle_button_new_with_label ("Keep above");
7468 g_signal_connect (button_above,
7470 G_CALLBACK (keep_window_above),
7472 gtk_box_pack_start (GTK_BOX (vbox), button_above, FALSE, FALSE, 0);
7474 button_below = gtk_toggle_button_new_with_label ("Keep below");
7475 g_signal_connect (button_below,
7477 G_CALLBACK (keep_window_below),
7479 gtk_box_pack_start (GTK_BOX (vbox), button_below, FALSE, FALSE, 0);
7481 g_object_set_data (G_OBJECT (button_above), "radio", button_below);
7482 g_object_set_data (G_OBJECT (button_below), "radio", button_above);
7484 button = gtk_button_new_with_label ("Hide (withdraw)");
7485 g_signal_connect_object (button,
7487 G_CALLBACK (gtk_widget_hide),
7490 gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
7492 gtk_widget_show_all (vbox);
7498 create_window_states (GtkWidget *widget)
7500 static GtkWidget *window = NULL;
7503 GtkWidget *iconified;
7505 GtkWidget *controls;
7509 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
7510 gtk_window_set_screen (GTK_WINDOW (window),
7511 gtk_widget_get_screen (widget));
7513 g_signal_connect (window, "destroy",
7514 G_CALLBACK (gtk_widget_destroyed),
7517 gtk_window_set_title (GTK_WINDOW (window), "Window states");
7519 box1 = gtk_vbox_new (FALSE, 0);
7520 gtk_container_add (GTK_CONTAINER (window), box1);
7522 iconified = gtk_window_new (GTK_WINDOW_TOPLEVEL);
7524 gtk_window_set_screen (GTK_WINDOW (iconified),
7525 gtk_widget_get_screen (widget));
7527 g_signal_connect_object (iconified, "destroy",
7528 G_CALLBACK (gtk_widget_destroy),
7531 gtk_window_iconify (GTK_WINDOW (iconified));
7532 gtk_window_set_title (GTK_WINDOW (iconified), "Iconified initially");
7533 controls = get_state_controls (iconified);
7534 gtk_container_add (GTK_CONTAINER (iconified), controls);
7536 normal = gtk_window_new (GTK_WINDOW_TOPLEVEL);
7538 gtk_window_set_screen (GTK_WINDOW (normal),
7539 gtk_widget_get_screen (widget));
7541 g_signal_connect_object (normal, "destroy",
7542 G_CALLBACK (gtk_widget_destroy),
7546 gtk_window_set_title (GTK_WINDOW (normal), "Deiconified initially");
7547 controls = get_state_controls (normal);
7548 gtk_container_add (GTK_CONTAINER (normal), controls);
7550 label = tracking_label (iconified);
7551 gtk_container_add (GTK_CONTAINER (box1), label);
7553 label = tracking_label (normal);
7554 gtk_container_add (GTK_CONTAINER (box1), label);
7556 gtk_widget_show_all (iconified);
7557 gtk_widget_show_all (normal);
7558 gtk_widget_show_all (box1);
7561 if (!gtk_widget_get_visible (window))
7562 gtk_widget_show (window);
7564 gtk_widget_destroy (window);
7572 configure_event_callback (GtkWidget *widget,
7573 GdkEventConfigure *event,
7576 GtkWidget *label = data;
7580 gtk_window_get_position (GTK_WINDOW (widget), &x, &y);
7582 msg = g_strdup_printf ("event: %d,%d %d x %d\n"
7584 event->x, event->y, event->width, event->height,
7587 gtk_label_set_text (GTK_LABEL (label), msg);
7595 get_ints (GtkWidget *window,
7602 spin1 = g_object_get_data (G_OBJECT (window), "spin1");
7603 spin2 = g_object_get_data (G_OBJECT (window), "spin2");
7605 *a = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (spin1));
7606 *b = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (spin2));
7610 set_size_callback (GtkWidget *widget,
7615 get_ints (data, &w, &h);
7617 gtk_window_resize (GTK_WINDOW (g_object_get_data (data, "target")), w, h);
7621 unset_default_size_callback (GtkWidget *widget,
7624 gtk_window_set_default_size (g_object_get_data (data, "target"),
7629 set_default_size_callback (GtkWidget *widget,
7634 get_ints (data, &w, &h);
7636 gtk_window_set_default_size (g_object_get_data (data, "target"),
7641 unset_size_request_callback (GtkWidget *widget,
7644 gtk_widget_set_size_request (g_object_get_data (data, "target"),
7649 set_size_request_callback (GtkWidget *widget,
7654 get_ints (data, &w, &h);
7656 gtk_widget_set_size_request (g_object_get_data (data, "target"),
7661 set_location_callback (GtkWidget *widget,
7666 get_ints (data, &x, &y);
7668 gtk_window_move (g_object_get_data (data, "target"), x, y);
7672 move_to_position_callback (GtkWidget *widget,
7678 window = g_object_get_data (data, "target");
7680 gtk_window_get_position (window, &x, &y);
7682 gtk_window_move (window, x, y);
7686 set_geometry_callback (GtkWidget *entry,
7692 target = GTK_WINDOW (g_object_get_data (G_OBJECT (data), "target"));
7694 text = gtk_editable_get_chars (GTK_EDITABLE (entry), 0, -1);
7696 if (!gtk_window_parse_geometry (target, text))
7697 g_print ("Bad geometry string '%s'\n", text);
7703 resizable_callback (GtkWidget *widget,
7706 g_object_set (g_object_get_data (data, "target"),
7707 "resizable", gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget)),
7712 gravity_selected (GtkWidget *widget,
7715 gtk_window_set_gravity (GTK_WINDOW (g_object_get_data (data, "target")),
7716 gtk_combo_box_get_active (GTK_COMBO_BOX (widget)) + GDK_GRAVITY_NORTH_WEST);
7720 pos_selected (GtkWidget *widget,
7723 gtk_window_set_position (GTK_WINDOW (g_object_get_data (data, "target")),
7724 gtk_combo_box_get_active (GTK_COMBO_BOX (widget)) + GTK_WIN_POS_NONE);
7728 move_gravity_window_to_current_position (GtkWidget *widget,
7734 window = GTK_WINDOW (data);
7736 gtk_window_get_position (window, &x, &y);
7738 gtk_window_move (window, x, y);
7742 get_screen_corner (GtkWindow *window,
7747 GdkScreen * screen = gtk_window_get_screen (window);
7749 gtk_window_get_size (GTK_WINDOW (window), &w, &h);
7751 switch (gtk_window_get_gravity (window))
7753 case GDK_GRAVITY_SOUTH_EAST:
7754 *x = gdk_screen_get_width (screen) - w;
7755 *y = gdk_screen_get_height (screen) - h;
7758 case GDK_GRAVITY_NORTH_EAST:
7759 *x = gdk_screen_get_width (screen) - w;
7763 case GDK_GRAVITY_SOUTH_WEST:
7765 *y = gdk_screen_get_height (screen) - h;
7768 case GDK_GRAVITY_NORTH_WEST:
7773 case GDK_GRAVITY_SOUTH:
7774 *x = (gdk_screen_get_width (screen) - w) / 2;
7775 *y = gdk_screen_get_height (screen) - h;
7778 case GDK_GRAVITY_NORTH:
7779 *x = (gdk_screen_get_width (screen) - w) / 2;
7783 case GDK_GRAVITY_WEST:
7785 *y = (gdk_screen_get_height (screen) - h) / 2;
7788 case GDK_GRAVITY_EAST:
7789 *x = gdk_screen_get_width (screen) - w;
7790 *y = (gdk_screen_get_height (screen) - h) / 2;
7793 case GDK_GRAVITY_CENTER:
7794 *x = (gdk_screen_get_width (screen) - w) / 2;
7795 *y = (gdk_screen_get_height (screen) - h) / 2;
7798 case GDK_GRAVITY_STATIC:
7799 /* pick some random numbers */
7805 g_assert_not_reached ();
7811 move_gravity_window_to_starting_position (GtkWidget *widget,
7817 window = GTK_WINDOW (data);
7819 get_screen_corner (window,
7822 gtk_window_move (window, x, y);
7826 make_gravity_window (GtkWidget *destroy_with,
7835 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
7837 gtk_window_set_screen (GTK_WINDOW (window),
7838 gtk_widget_get_screen (destroy_with));
7840 vbox = gtk_vbox_new (FALSE, 0);
7841 gtk_widget_show (vbox);
7843 gtk_container_add (GTK_CONTAINER (window), vbox);
7844 gtk_window_set_title (GTK_WINDOW (window), title);
7845 gtk_window_set_gravity (GTK_WINDOW (window), gravity);
7847 g_signal_connect_object (destroy_with,
7849 G_CALLBACK (gtk_widget_destroy),
7854 button = gtk_button_new_with_mnemonic ("_Move to current position");
7856 g_signal_connect (button, "clicked",
7857 G_CALLBACK (move_gravity_window_to_current_position),
7860 gtk_container_add (GTK_CONTAINER (vbox), button);
7861 gtk_widget_show (button);
7863 button = gtk_button_new_with_mnemonic ("Move to _starting position");
7865 g_signal_connect (button, "clicked",
7866 G_CALLBACK (move_gravity_window_to_starting_position),
7869 gtk_container_add (GTK_CONTAINER (vbox), button);
7870 gtk_widget_show (button);
7872 /* Pretend this is the result of --geometry.
7873 * DO NOT COPY THIS CODE unless you are setting --geometry results,
7874 * and in that case you probably should just use gtk_window_parse_geometry().
7875 * AGAIN, DO NOT SET GDK_HINT_USER_POS! It violates the ICCCM unless
7876 * you are parsing --geometry or equivalent.
7878 gtk_window_set_geometry_hints (GTK_WINDOW (window),
7882 gtk_window_set_default_size (GTK_WINDOW (window),
7885 get_screen_corner (GTK_WINDOW (window), &x, &y);
7887 gtk_window_move (GTK_WINDOW (window),
7894 do_gravity_test (GtkWidget *widget,
7897 GtkWidget *destroy_with = data;
7900 /* We put a window at each gravity point on the screen. */
7901 window = make_gravity_window (destroy_with, GDK_GRAVITY_NORTH_WEST,
7903 gtk_widget_show (window);
7905 window = make_gravity_window (destroy_with, GDK_GRAVITY_SOUTH_EAST,
7907 gtk_widget_show (window);
7909 window = make_gravity_window (destroy_with, GDK_GRAVITY_NORTH_EAST,
7911 gtk_widget_show (window);
7913 window = make_gravity_window (destroy_with, GDK_GRAVITY_SOUTH_WEST,
7915 gtk_widget_show (window);
7917 window = make_gravity_window (destroy_with, GDK_GRAVITY_SOUTH,
7919 gtk_widget_show (window);
7921 window = make_gravity_window (destroy_with, GDK_GRAVITY_NORTH,
7923 gtk_widget_show (window);
7926 window = make_gravity_window (destroy_with, GDK_GRAVITY_WEST,
7928 gtk_widget_show (window);
7931 window = make_gravity_window (destroy_with, GDK_GRAVITY_EAST,
7933 gtk_widget_show (window);
7935 window = make_gravity_window (destroy_with, GDK_GRAVITY_CENTER,
7937 gtk_widget_show (window);
7939 window = make_gravity_window (destroy_with, GDK_GRAVITY_STATIC,
7941 gtk_widget_show (window);
7945 window_controls (GtkWidget *window)
7947 GtkWidget *control_window;
7957 control_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
7959 gtk_window_set_screen (GTK_WINDOW (control_window),
7960 gtk_widget_get_screen (window));
7962 gtk_window_set_title (GTK_WINDOW (control_window), "Size controls");
7964 g_object_set_data (G_OBJECT (control_window),
7968 g_signal_connect_object (control_window,
7970 G_CALLBACK (gtk_widget_destroy),
7974 vbox = gtk_vbox_new (FALSE, 5);
7976 gtk_container_add (GTK_CONTAINER (control_window), vbox);
7978 label = gtk_label_new ("<no configure events>");
7979 gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
7981 g_signal_connect (window,
7983 G_CALLBACK (configure_event_callback),
7986 adj = gtk_adjustment_new (10.0, -2000.0, 2000.0, 1.0, 5.0, 0.0);
7987 spin = gtk_spin_button_new (adj, 0, 0);
7989 gtk_box_pack_start (GTK_BOX (vbox), spin, FALSE, FALSE, 0);
7991 g_object_set_data (G_OBJECT (control_window), "spin1", spin);
7993 adj = gtk_adjustment_new (10.0, -2000.0, 2000.0, 1.0, 5.0, 0.0);
7994 spin = gtk_spin_button_new (adj, 0, 0);
7996 gtk_box_pack_start (GTK_BOX (vbox), spin, FALSE, FALSE, 0);
7998 g_object_set_data (G_OBJECT (control_window), "spin2", spin);
8000 entry = gtk_entry_new ();
8001 gtk_box_pack_start (GTK_BOX (vbox), entry, FALSE, FALSE, 0);
8003 g_signal_connect (entry, "changed",
8004 G_CALLBACK (set_geometry_callback),
8007 button = gtk_button_new_with_label ("Show gravity test windows");
8008 g_signal_connect_swapped (button,
8010 G_CALLBACK (do_gravity_test),
8012 gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
8014 button = gtk_button_new_with_label ("Reshow with initial size");
8015 g_signal_connect_object (button,
8017 G_CALLBACK (gtk_window_reshow_with_initial_size),
8020 gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
8022 button = gtk_button_new_with_label ("Queue resize");
8023 g_signal_connect_object (button,
8025 G_CALLBACK (gtk_widget_queue_resize),
8028 gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
8030 button = gtk_button_new_with_label ("Resize");
8031 g_signal_connect (button,
8033 G_CALLBACK (set_size_callback),
8035 gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
8037 button = gtk_button_new_with_label ("Set default size");
8038 g_signal_connect (button,
8040 G_CALLBACK (set_default_size_callback),
8042 gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
8044 button = gtk_button_new_with_label ("Unset default size");
8045 g_signal_connect (button,
8047 G_CALLBACK (unset_default_size_callback),
8049 gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
8051 button = gtk_button_new_with_label ("Set size request");
8052 g_signal_connect (button,
8054 G_CALLBACK (set_size_request_callback),
8056 gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
8058 button = gtk_button_new_with_label ("Unset size request");
8059 g_signal_connect (button,
8061 G_CALLBACK (unset_size_request_callback),
8063 gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
8065 button = gtk_button_new_with_label ("Move");
8066 g_signal_connect (button,
8068 G_CALLBACK (set_location_callback),
8070 gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
8072 button = gtk_button_new_with_label ("Move to current position");
8073 g_signal_connect (button,
8075 G_CALLBACK (move_to_position_callback),
8077 gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
8079 button = gtk_check_button_new_with_label ("Allow resize");
8080 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
8081 g_signal_connect (button,
8083 G_CALLBACK (resizable_callback),
8085 gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
8087 button = gtk_button_new_with_mnemonic ("_Show");
8088 g_signal_connect_object (button,
8090 G_CALLBACK (gtk_widget_show),
8093 gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
8095 button = gtk_button_new_with_mnemonic ("_Hide");
8096 g_signal_connect_object (button,
8098 G_CALLBACK (gtk_widget_hide),
8101 gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
8103 om = gtk_combo_box_text_new ();
8107 static gchar *names[] = {
8108 "GDK_GRAVITY_NORTH_WEST",
8109 "GDK_GRAVITY_NORTH",
8110 "GDK_GRAVITY_NORTH_EAST",
8112 "GDK_GRAVITY_CENTER",
8114 "GDK_GRAVITY_SOUTH_WEST",
8115 "GDK_GRAVITY_SOUTH",
8116 "GDK_GRAVITY_SOUTH_EAST",
8117 "GDK_GRAVITY_STATIC",
8121 g_assert (names[i]);
8122 gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (om), names[i]);
8127 g_signal_connect (om,
8129 G_CALLBACK (gravity_selected),
8132 gtk_box_pack_end (GTK_BOX (vbox), om, FALSE, FALSE, 0);
8135 om = gtk_combo_box_text_new ();
8139 static gchar *names[] = {
8141 "GTK_WIN_POS_CENTER",
8142 "GTK_WIN_POS_MOUSE",
8143 "GTK_WIN_POS_CENTER_ALWAYS",
8144 "GTK_WIN_POS_CENTER_ON_PARENT",
8148 g_assert (names[i]);
8149 gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (om), names[i]);
8154 g_signal_connect (om,
8156 G_CALLBACK (pos_selected),
8159 gtk_box_pack_end (GTK_BOX (vbox), om, FALSE, FALSE, 0);
8161 gtk_widget_show_all (vbox);
8163 return control_window;
8167 create_window_sizing (GtkWidget *widget)
8169 static GtkWidget *window = NULL;
8170 static GtkWidget *target_window = NULL;
8176 target_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
8177 gtk_window_set_screen (GTK_WINDOW (target_window),
8178 gtk_widget_get_screen (widget));
8179 label = gtk_label_new (NULL);
8180 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");
8181 gtk_container_add (GTK_CONTAINER (target_window), label);
8182 gtk_widget_show (label);
8184 g_signal_connect (target_window, "destroy",
8185 G_CALLBACK (gtk_widget_destroyed),
8188 window = window_controls (target_window);
8190 g_signal_connect (window, "destroy",
8191 G_CALLBACK (gtk_widget_destroyed),
8194 gtk_window_set_title (GTK_WINDOW (target_window), "Window to size");
8197 /* don't show target window by default, we want to allow testing
8198 * of behavior on first show.
8201 if (!gtk_widget_get_visible (window))
8202 gtk_widget_show (window);
8204 gtk_widget_destroy (window);
8211 typedef struct _ProgressData {
8214 GtkWidget *block_spin;
8215 GtkWidget *x_align_spin;
8216 GtkWidget *y_align_spin;
8217 GtkWidget *step_spin;
8218 GtkWidget *act_blocks_spin;
8229 progress_timeout (gpointer data)
8231 ProgressData *pdata = data;
8235 if (pdata->activity)
8237 gtk_progress_bar_pulse (GTK_PROGRESS_BAR (pdata->pbar));
8239 text = g_strdup_printf ("%s", "???");
8243 new_val = gtk_progress_bar_get_fraction (GTK_PROGRESS_BAR (pdata->pbar)) + 0.01;
8246 gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR (pdata->pbar), new_val);
8248 text = g_strdup_printf ("%.0f%%", 100 * new_val);
8251 gtk_label_set_text (GTK_LABEL (pdata->label), text);
8258 destroy_progress (GtkWidget *widget,
8259 ProgressData **pdata)
8261 g_source_remove ((*pdata)->timer);
8262 (*pdata)->timer = 0;
8263 (*pdata)->window = NULL;
8269 progressbar_toggle_orientation (GtkWidget *widget, gpointer data)
8271 ProgressData *pdata;
8274 pdata = (ProgressData *) data;
8276 if (!gtk_widget_get_mapped (widget))
8279 i = gtk_combo_box_get_active (GTK_COMBO_BOX (widget));
8281 if (i == 0 || i == 1)
8282 gtk_orientable_set_orientation (GTK_ORIENTABLE (pdata->pbar), GTK_ORIENTATION_HORIZONTAL);
8284 gtk_orientable_set_orientation (GTK_ORIENTABLE (pdata->pbar), GTK_ORIENTATION_VERTICAL);
8286 if (i == 1 || i == 2)
8287 gtk_progress_bar_set_inverted (GTK_PROGRESS_BAR (pdata->pbar), TRUE);
8289 gtk_progress_bar_set_inverted (GTK_PROGRESS_BAR (pdata->pbar), FALSE);
8293 toggle_show_text (GtkWidget *widget, ProgressData *pdata)
8297 active = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget));
8298 gtk_progress_bar_set_show_text (GTK_PROGRESS_BAR (pdata->pbar), active);
8302 progressbar_toggle_ellipsize (GtkWidget *widget,
8305 ProgressData *pdata = data;
8306 if (gtk_widget_is_drawable (widget))
8308 gint i = gtk_combo_box_get_active (GTK_COMBO_BOX (widget));
8309 gtk_progress_bar_set_ellipsize (GTK_PROGRESS_BAR (pdata->pbar), i);
8314 toggle_activity_mode (GtkWidget *widget, ProgressData *pdata)
8316 pdata->activity = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget));
8320 entry_changed (GtkWidget *widget, ProgressData *pdata)
8322 gtk_progress_bar_set_text (GTK_PROGRESS_BAR (pdata->pbar),
8323 gtk_entry_get_text (GTK_ENTRY (pdata->entry)));
8327 create_progress_bar (GtkWidget *widget)
8329 GtkWidget *action_area, *content_area;
8339 static ProgressData *pdata = NULL;
8341 static gchar *items1[] =
8349 static char *ellipsize_items[] = {
8350 "None", // PANGO_ELLIPSIZE_NONE,
8351 "Start", // PANGO_ELLIPSIZE_START,
8352 "Middle", // PANGO_ELLIPSIZE_MIDDLE,
8353 "End", // PANGO_ELLIPSIZE_END
8357 pdata = g_new0 (ProgressData, 1);
8361 pdata->window = gtk_dialog_new ();
8363 gtk_window_set_screen (GTK_WINDOW (pdata->window),
8364 gtk_widget_get_screen (widget));
8366 gtk_window_set_resizable (GTK_WINDOW (pdata->window), TRUE);
8368 g_signal_connect (pdata->window, "destroy",
8369 G_CALLBACK (destroy_progress),
8373 content_area = gtk_dialog_get_content_area (GTK_DIALOG (pdata->window));
8374 action_area = gtk_dialog_get_action_area (GTK_DIALOG (pdata->window));
8376 gtk_window_set_title (GTK_WINDOW (pdata->window), "GtkProgressBar");
8377 gtk_container_set_border_width (GTK_CONTAINER (pdata->window), 0);
8379 vbox = gtk_vbox_new (FALSE, 5);
8380 gtk_container_set_border_width (GTK_CONTAINER (vbox), 10);
8381 gtk_box_pack_start (GTK_BOX (content_area), vbox, FALSE, TRUE, 0);
8383 frame = gtk_frame_new ("Progress");
8384 gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, TRUE, 0);
8386 vbox2 = gtk_vbox_new (FALSE, 5);
8387 gtk_container_add (GTK_CONTAINER (frame), vbox2);
8389 align = gtk_alignment_new (0.5, 0.5, 0, 0);
8390 gtk_box_pack_start (GTK_BOX (vbox2), align, FALSE, FALSE, 5);
8392 pdata->pbar = gtk_progress_bar_new ();
8393 gtk_progress_bar_set_ellipsize (GTK_PROGRESS_BAR (pdata->pbar),
8394 PANGO_ELLIPSIZE_MIDDLE);
8396 gtk_container_add (GTK_CONTAINER (align), pdata->pbar);
8397 pdata->timer = g_timeout_add (100, (GSourceFunc)progress_timeout, pdata);
8399 align = gtk_alignment_new (0.5, 0.5, 0, 0);
8400 gtk_box_pack_start (GTK_BOX (vbox2), align, FALSE, FALSE, 5);
8402 hbox = gtk_hbox_new (FALSE, 5);
8403 gtk_container_add (GTK_CONTAINER (align), hbox);
8404 label = gtk_label_new ("Label updated by user :");
8405 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
8406 pdata->label = gtk_label_new ("");
8407 gtk_box_pack_start (GTK_BOX (hbox), pdata->label, FALSE, TRUE, 0);
8409 frame = gtk_frame_new ("Options");
8410 gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, TRUE, 0);
8412 vbox2 = gtk_vbox_new (FALSE, 5);
8413 gtk_container_add (GTK_CONTAINER (frame), vbox2);
8415 tab = gtk_table_new (7, 2, FALSE);
8416 gtk_box_pack_start (GTK_BOX (vbox2), tab, FALSE, TRUE, 0);
8418 label = gtk_label_new ("Orientation :");
8419 gtk_table_attach (GTK_TABLE (tab), label, 0, 1, 0, 1,
8420 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
8422 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
8424 pdata->omenu1 = build_option_menu (items1, 4, 0,
8425 progressbar_toggle_orientation,
8427 hbox = gtk_hbox_new (FALSE, 0);
8428 gtk_table_attach (GTK_TABLE (tab), hbox, 1, 2, 0, 1,
8429 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
8431 gtk_box_pack_start (GTK_BOX (hbox), pdata->omenu1, TRUE, TRUE, 0);
8433 check = gtk_check_button_new_with_label ("Show text");
8434 g_signal_connect (check, "clicked",
8435 G_CALLBACK (toggle_show_text),
8437 gtk_table_attach (GTK_TABLE (tab), check, 0, 1, 1, 2,
8438 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
8441 hbox = gtk_hbox_new (FALSE, 0);
8442 gtk_table_attach (GTK_TABLE (tab), hbox, 1, 2, 1, 2,
8443 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
8446 label = gtk_label_new ("Text: ");
8447 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
8449 pdata->entry = gtk_entry_new ();
8450 g_signal_connect (pdata->entry, "changed",
8451 G_CALLBACK (entry_changed),
8453 gtk_box_pack_start (GTK_BOX (hbox), pdata->entry, TRUE, TRUE, 0);
8454 gtk_widget_set_size_request (pdata->entry, 100, -1);
8456 label = gtk_label_new ("Ellipsize text :");
8457 gtk_table_attach (GTK_TABLE (tab), label, 0, 1, 10, 11,
8458 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
8460 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
8461 pdata->elmenu = build_option_menu (ellipsize_items,
8462 sizeof (ellipsize_items) / sizeof (ellipsize_items[0]),
8463 2, // PANGO_ELLIPSIZE_MIDDLE
8464 progressbar_toggle_ellipsize,
8466 hbox = gtk_hbox_new (FALSE, 0);
8467 gtk_table_attach (GTK_TABLE (tab), hbox, 1, 2, 10, 11,
8468 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
8470 gtk_box_pack_start (GTK_BOX (hbox), pdata->elmenu, TRUE, TRUE, 0);
8472 check = gtk_check_button_new_with_label ("Activity mode");
8473 g_signal_connect (check, "clicked",
8474 G_CALLBACK (toggle_activity_mode), pdata);
8475 gtk_table_attach (GTK_TABLE (tab), check, 0, 1, 15, 16,
8476 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
8479 button = gtk_button_new_with_label ("close");
8480 g_signal_connect_swapped (button, "clicked",
8481 G_CALLBACK (gtk_widget_destroy),
8483 gtk_widget_set_can_default (button, TRUE);
8484 gtk_box_pack_start (GTK_BOX (action_area), button, TRUE, TRUE, 0);
8485 gtk_widget_grab_default (button);
8488 if (!gtk_widget_get_visible (pdata->window))
8489 gtk_widget_show_all (pdata->window);
8491 gtk_widget_destroy (pdata->window);
8503 GtkWidget *res_widget;
8507 find_widget (GtkWidget *widget, FindWidgetData *data)
8509 GtkAllocation new_allocation;
8513 gtk_widget_get_allocation (widget, &new_allocation);
8515 if (data->found || !gtk_widget_get_mapped (widget))
8518 /* Note that in the following code, we only count the
8519 * position as being inside a WINDOW widget if it is inside
8520 * widget->window; points that are outside of widget->window
8521 * but within the allocation are not counted. This is consistent
8522 * with the way we highlight drag targets.
8524 if (gtk_widget_get_has_window (widget))
8526 new_allocation.x = 0;
8527 new_allocation.y = 0;
8530 if (gtk_widget_get_parent (widget) && !data->first)
8532 GdkWindow *window = gtk_widget_get_window (widget);
8533 while (window != gtk_widget_get_window (gtk_widget_get_parent (widget)))
8535 gint tx, ty, twidth, theight;
8537 twidth = gdk_window_get_width (window);
8538 theight = gdk_window_get_height (window);
8540 if (new_allocation.x < 0)
8542 new_allocation.width += new_allocation.x;
8543 new_allocation.x = 0;
8545 if (new_allocation.y < 0)
8547 new_allocation.height += new_allocation.y;
8548 new_allocation.y = 0;
8550 if (new_allocation.x + new_allocation.width > twidth)
8551 new_allocation.width = twidth - new_allocation.x;
8552 if (new_allocation.y + new_allocation.height > theight)
8553 new_allocation.height = theight - new_allocation.y;
8555 gdk_window_get_position (window, &tx, &ty);
8556 new_allocation.x += tx;
8558 new_allocation.y += ty;
8561 window = gdk_window_get_parent (window);
8565 if ((data->x >= new_allocation.x) && (data->y >= new_allocation.y) &&
8566 (data->x < new_allocation.x + new_allocation.width) &&
8567 (data->y < new_allocation.y + new_allocation.height))
8569 /* First, check if the drag is in a valid drop site in
8570 * one of our children
8572 if (GTK_IS_CONTAINER (widget))
8574 FindWidgetData new_data = *data;
8576 new_data.x -= x_offset;
8577 new_data.y -= y_offset;
8578 new_data.found = FALSE;
8579 new_data.first = FALSE;
8581 gtk_container_forall (GTK_CONTAINER (widget),
8582 (GtkCallback)find_widget,
8585 data->found = new_data.found;
8587 data->res_widget = new_data.res_widget;
8590 /* If not, and this widget is registered as a drop site, check to
8591 * emit "drag_motion" to check if we are actually in
8597 data->res_widget = widget;
8603 find_widget_at_pointer (GdkDisplay *display)
8605 GtkWidget *widget = NULL;
8606 GdkWindow *pointer_window;
8608 FindWidgetData data;
8610 pointer_window = gdk_display_get_window_at_pointer (display, NULL, NULL);
8614 gpointer widget_ptr;
8616 gdk_window_get_user_data (pointer_window, &widget_ptr);
8617 widget = widget_ptr;
8622 gdk_window_get_pointer (gtk_widget_get_window (widget),
8630 find_widget (widget, &data);
8632 return data.res_widget;
8638 struct PropertiesData {
8646 destroy_properties (GtkWidget *widget,
8647 struct PropertiesData *data)
8651 *data->window = NULL;
8652 data->window = NULL;
8657 gdk_cursor_unref (data->cursor);
8658 data->cursor = NULL;
8663 g_signal_handler_disconnect (widget, data->handler);
8671 property_query_event (GtkWidget *widget,
8673 struct PropertiesData *data)
8675 GtkWidget *res_widget = NULL;
8677 if (!data->in_query)
8680 if (event->type == GDK_BUTTON_RELEASE)
8682 gtk_grab_remove (widget);
8683 gdk_display_pointer_ungrab (gtk_widget_get_display (widget),
8686 res_widget = find_widget_at_pointer (gtk_widget_get_display (widget));
8689 g_object_set_data (G_OBJECT (res_widget), "prop-editor-screen",
8690 gtk_widget_get_screen (widget));
8691 create_prop_editor (G_OBJECT (res_widget), 0);
8694 data->in_query = FALSE;
8701 query_properties (GtkButton *button,
8702 struct PropertiesData *data)
8704 GtkWidget *widget = GTK_WIDGET (button);
8707 g_signal_connect (button, "event",
8708 G_CALLBACK (property_query_event), data);
8712 data->cursor = gdk_cursor_new_for_display (gtk_widget_get_display (widget),
8715 failure = gdk_pointer_grab (gtk_widget_get_window (widget),
8717 GDK_BUTTON_RELEASE_MASK,
8722 gtk_grab_add (widget);
8724 data->in_query = TRUE;
8728 create_properties (GtkWidget *widget)
8730 static GtkWidget *window = NULL;
8734 struct PropertiesData *data;
8736 data = g_new (struct PropertiesData, 1);
8737 data->window = &window;
8738 data->in_query = FALSE;
8739 data->cursor = NULL;
8744 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
8746 gtk_window_set_screen (GTK_WINDOW (window),
8747 gtk_widget_get_screen (widget));
8749 data->handler = g_signal_connect (window, "destroy",
8750 G_CALLBACK (destroy_properties),
8753 gtk_window_set_title (GTK_WINDOW (window), "test properties");
8754 gtk_container_set_border_width (GTK_CONTAINER (window), 10);
8756 vbox = gtk_vbox_new (FALSE, 1);
8757 gtk_container_add (GTK_CONTAINER (window), vbox);
8759 label = gtk_label_new ("This is just a dumb test to test properties.\nIf you need a generic module, get GLE.");
8760 gtk_box_pack_start (GTK_BOX (vbox), label, TRUE, TRUE, 0);
8762 button = gtk_button_new_with_label ("Query properties");
8763 gtk_box_pack_start (GTK_BOX (vbox), button, TRUE, TRUE, 0);
8764 g_signal_connect (button, "clicked",
8765 G_CALLBACK (query_properties),
8769 if (!gtk_widget_get_visible (window))
8770 gtk_widget_show_all (window);
8772 gtk_widget_destroy (window);
8776 struct SnapshotData {
8777 GtkWidget *toplevel_button;
8781 gboolean is_toplevel;
8786 destroy_snapshot_data (GtkWidget *widget,
8787 struct SnapshotData *data)
8790 *data->window = NULL;
8794 gdk_cursor_unref (data->cursor);
8795 data->cursor = NULL;
8800 g_signal_handler_disconnect (widget, data->handler);
8808 snapshot_widget_event (GtkWidget *widget,
8810 struct SnapshotData *data)
8812 GtkWidget *res_widget = NULL;
8814 if (!data->in_query)
8817 if (event->type == GDK_BUTTON_RELEASE)
8819 gtk_grab_remove (widget);
8820 gdk_display_pointer_ungrab (gtk_widget_get_display (widget),
8823 res_widget = find_widget_at_pointer (gtk_widget_get_display (widget));
8824 if (data->is_toplevel && res_widget)
8825 res_widget = gtk_widget_get_toplevel (res_widget);
8828 cairo_surface_t *surface;
8829 GtkWidget *window, *image;
8834 width = gtk_widget_get_allocated_width (res_widget);
8835 height = gtk_widget_get_allocated_height (res_widget);
8837 surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, width, height);
8839 cr = cairo_create (surface);
8840 gtk_widget_draw (res_widget, cr);
8843 pixbuf = gdk_pixbuf_get_from_surface (surface,
8846 cairo_surface_destroy (surface);
8848 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
8849 image = gtk_image_new_from_pixbuf (pixbuf);
8850 g_object_unref (pixbuf);
8852 gtk_container_add (GTK_CONTAINER (window), image);
8853 gtk_widget_show_all (window);
8856 data->in_query = FALSE;
8863 snapshot_widget (GtkButton *button,
8864 struct SnapshotData *data)
8866 GtkWidget *widget = GTK_WIDGET (button);
8869 g_signal_connect (button, "event",
8870 G_CALLBACK (snapshot_widget_event), data);
8872 data->is_toplevel = widget == data->toplevel_button;
8875 data->cursor = gdk_cursor_new_for_display (gtk_widget_get_display (widget),
8878 failure = gdk_pointer_grab (gtk_widget_get_window (widget),
8880 GDK_BUTTON_RELEASE_MASK,
8885 gtk_grab_add (widget);
8887 data->in_query = TRUE;
8891 create_snapshot (GtkWidget *widget)
8893 static GtkWidget *window = NULL;
8896 struct SnapshotData *data;
8898 data = g_new (struct SnapshotData, 1);
8899 data->window = &window;
8900 data->in_query = FALSE;
8901 data->cursor = NULL;
8906 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
8908 gtk_window_set_screen (GTK_WINDOW (window),
8909 gtk_widget_get_screen (widget));
8911 data->handler = g_signal_connect (window, "destroy",
8912 G_CALLBACK (destroy_snapshot_data),
8915 gtk_window_set_title (GTK_WINDOW (window), "test snapshot");
8916 gtk_container_set_border_width (GTK_CONTAINER (window), 10);
8918 vbox = gtk_vbox_new (FALSE, 1);
8919 gtk_container_add (GTK_CONTAINER (window), vbox);
8921 button = gtk_button_new_with_label ("Snapshot widget");
8922 gtk_box_pack_start (GTK_BOX (vbox), button, TRUE, TRUE, 0);
8923 g_signal_connect (button, "clicked",
8924 G_CALLBACK (snapshot_widget),
8927 button = gtk_button_new_with_label ("Snapshot toplevel");
8928 data->toplevel_button = button;
8929 gtk_box_pack_start (GTK_BOX (vbox), button, TRUE, TRUE, 0);
8930 g_signal_connect (button, "clicked",
8931 G_CALLBACK (snapshot_widget),
8935 if (!gtk_widget_get_visible (window))
8936 gtk_widget_show_all (window);
8938 gtk_widget_destroy (window);
8947 selection_test_received (GtkWidget *tree_view,
8948 GtkSelectionData *data)
8950 GtkTreeModel *model;
8951 GtkListStore *store;
8955 if (data->length < 0)
8957 g_print ("Selection retrieval failed\n");
8960 if (data->type != GDK_SELECTION_TYPE_ATOM)
8962 g_print ("Selection \"TARGETS\" was not returned as atoms!\n");
8966 /* Clear out any current list items */
8968 model = gtk_tree_view_get_model (GTK_TREE_VIEW (tree_view));
8969 store = GTK_LIST_STORE (model);
8970 gtk_list_store_clear (store);
8972 /* Add new items to list */
8974 atoms = (GdkAtom *)data->data;
8976 l = data->length / sizeof (GdkAtom);
8977 for (i = 0; i < l; i++)
8982 name = gdk_atom_name (atoms[i]);
8985 gtk_list_store_insert_with_values (store, &iter, i, 0, name, -1);
8989 gtk_list_store_insert_with_values (store, &iter, i, 0, "(bad atom)", -1);
8996 selection_test_get_targets (GtkWidget *widget, GtkWidget *tree_view)
8998 static GdkAtom targets_atom = GDK_NONE;
9000 if (targets_atom == GDK_NONE)
9001 targets_atom = gdk_atom_intern ("TARGETS", FALSE);
9003 gtk_selection_convert (tree_view, GDK_SELECTION_PRIMARY, targets_atom,
9008 create_selection_test (GtkWidget *widget)
9010 static GtkWidget *window = NULL;
9011 GtkWidget *action_area, *content_area;
9014 GtkWidget *scrolled_win;
9015 GtkListStore* store;
9016 GtkWidget *tree_view;
9017 GtkTreeViewColumn *column;
9018 GtkCellRenderer *renderer;
9023 window = gtk_dialog_new ();
9025 gtk_window_set_screen (GTK_WINDOW (window),
9026 gtk_widget_get_screen (widget));
9028 g_signal_connect (window, "destroy",
9029 G_CALLBACK (gtk_widget_destroyed),
9032 content_area = gtk_dialog_get_content_area (GTK_DIALOG (window));
9033 action_area = gtk_dialog_get_action_area (GTK_DIALOG (window));
9035 gtk_window_set_title (GTK_WINDOW (window), "Selection Test");
9036 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
9038 /* Create the list */
9040 vbox = gtk_vbox_new (FALSE, 5);
9041 gtk_container_set_border_width (GTK_CONTAINER (vbox), 10);
9042 gtk_box_pack_start (GTK_BOX (content_area), vbox, TRUE, TRUE, 0);
9044 label = gtk_label_new ("Gets available targets for current selection");
9045 gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
9047 scrolled_win = gtk_scrolled_window_new (NULL, NULL);
9048 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
9049 GTK_POLICY_AUTOMATIC,
9050 GTK_POLICY_AUTOMATIC);
9051 gtk_box_pack_start (GTK_BOX (vbox), scrolled_win, TRUE, TRUE, 0);
9052 gtk_widget_set_size_request (scrolled_win, 100, 200);
9054 store = gtk_list_store_new (1, G_TYPE_STRING);
9055 tree_view = gtk_tree_view_new_with_model (GTK_TREE_MODEL (store));
9056 gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (scrolled_win), tree_view);
9058 renderer = gtk_cell_renderer_text_new ();
9059 column = gtk_tree_view_column_new_with_attributes ("Target", renderer,
9061 gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), column);
9063 g_signal_connect (tree_view, "selection_received",
9064 G_CALLBACK (selection_test_received), NULL);
9066 /* .. And create some buttons */
9067 button = gtk_button_new_with_label ("Get Targets");
9068 gtk_box_pack_start (GTK_BOX (action_area), button, TRUE, TRUE, 0);
9070 g_signal_connect (button, "clicked",
9071 G_CALLBACK (selection_test_get_targets), tree_view);
9073 button = gtk_button_new_with_label ("Quit");
9074 gtk_box_pack_start (GTK_BOX (action_area), button, TRUE, TRUE, 0);
9076 g_signal_connect_swapped (button, "clicked",
9077 G_CALLBACK (gtk_widget_destroy),
9081 if (!gtk_widget_get_visible (window))
9082 gtk_widget_show_all (window);
9084 gtk_widget_destroy (window);
9091 static int scroll_test_pos = 0.0;
9094 scroll_test_draw (GtkWidget *widget,
9099 gint imin, imax, jmin, jmax;
9102 gdk_cairo_get_clip_rectangle (cr, &clip);
9104 imin = (clip.x) / 10;
9105 imax = (clip.x + clip.width + 9) / 10;
9107 jmin = ((int)adj->value + clip.y) / 10;
9108 jmax = ((int)adj->value + clip.y + clip.height + 9) / 10;
9110 for (i=imin; i<imax; i++)
9111 for (j=jmin; j<jmax; j++)
9113 cairo_rectangle (cr, 10*i, 10*j - (int)adj->value, 1+i%10, 1+j%10);
9121 scroll_test_scroll (GtkWidget *widget, GdkEventScroll *event,
9124 gdouble new_value = adj->value + ((event->direction == GDK_SCROLL_UP) ?
9125 -adj->page_increment / 2:
9126 adj->page_increment / 2);
9127 new_value = CLAMP (new_value, adj->lower, adj->upper - adj->page_size);
9128 gtk_adjustment_set_value (adj, new_value);
9134 scroll_test_configure (GtkWidget *widget, GdkEventConfigure *event,
9137 GtkAllocation allocation;
9139 gtk_widget_get_allocation (widget, &allocation);
9140 adj->page_increment = 0.9 * allocation.height;
9141 adj->page_size = allocation.height;
9143 g_signal_emit_by_name (adj, "changed");
9147 scroll_test_adjustment_changed (GtkAdjustment *adj, GtkWidget *widget)
9152 dy = scroll_test_pos - (int)adj->value;
9153 scroll_test_pos = adj->value;
9155 if (!gtk_widget_is_drawable (widget))
9158 window = gtk_widget_get_window (widget);
9159 gdk_window_scroll (window, 0, dy);
9160 gdk_window_process_updates (window, FALSE);
9165 create_scroll_test (GtkWidget *widget)
9167 static GtkWidget *window = NULL;
9168 GtkWidget *action_area, *content_area;
9170 GtkWidget *drawing_area;
9171 GtkWidget *scrollbar;
9174 GdkGeometry geometry;
9175 GdkWindowHints geometry_mask;
9179 window = gtk_dialog_new ();
9181 gtk_window_set_screen (GTK_WINDOW (window),
9182 gtk_widget_get_screen (widget));
9184 g_signal_connect (window, "destroy",
9185 G_CALLBACK (gtk_widget_destroyed),
9188 content_area = gtk_dialog_get_content_area (GTK_DIALOG (window));
9189 action_area = gtk_dialog_get_action_area (GTK_DIALOG (window));
9191 gtk_window_set_title (GTK_WINDOW (window), "Scroll Test");
9192 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
9194 hbox = gtk_hbox_new (FALSE, 0);
9195 gtk_box_pack_start (GTK_BOX (content_area), hbox, TRUE, TRUE, 0);
9196 gtk_widget_show (hbox);
9198 drawing_area = gtk_drawing_area_new ();
9199 gtk_widget_set_size_request (drawing_area, 200, 200);
9200 gtk_box_pack_start (GTK_BOX (hbox), drawing_area, TRUE, TRUE, 0);
9201 gtk_widget_show (drawing_area);
9203 gtk_widget_set_events (drawing_area, GDK_EXPOSURE_MASK | GDK_SCROLL_MASK);
9205 adj = gtk_adjustment_new (0.0, 0.0, 1000.0, 1.0, 180.0, 200.0);
9206 scroll_test_pos = 0.0;
9208 scrollbar = gtk_vscrollbar_new (adj);
9209 gtk_box_pack_start (GTK_BOX (hbox), scrollbar, FALSE, FALSE, 0);
9210 gtk_widget_show (scrollbar);
9212 g_signal_connect (drawing_area, "draw",
9213 G_CALLBACK (scroll_test_draw), adj);
9214 g_signal_connect (drawing_area, "configure_event",
9215 G_CALLBACK (scroll_test_configure), adj);
9216 g_signal_connect (drawing_area, "scroll_event",
9217 G_CALLBACK (scroll_test_scroll), adj);
9219 g_signal_connect (adj, "value_changed",
9220 G_CALLBACK (scroll_test_adjustment_changed),
9223 /* .. And create some buttons */
9225 button = gtk_button_new_with_label ("Quit");
9226 gtk_box_pack_start (GTK_BOX (action_area), button, TRUE, TRUE, 0);
9228 g_signal_connect_swapped (button, "clicked",
9229 G_CALLBACK (gtk_widget_destroy),
9231 gtk_widget_show (button);
9233 /* Set up gridded geometry */
9235 geometry_mask = GDK_HINT_MIN_SIZE |
9236 GDK_HINT_BASE_SIZE |
9237 GDK_HINT_RESIZE_INC;
9239 geometry.min_width = 20;
9240 geometry.min_height = 20;
9241 geometry.base_width = 0;
9242 geometry.base_height = 0;
9243 geometry.width_inc = 10;
9244 geometry.height_inc = 10;
9246 gtk_window_set_geometry_hints (GTK_WINDOW (window),
9247 drawing_area, &geometry, geometry_mask);
9250 if (!gtk_widget_get_visible (window))
9251 gtk_widget_show (window);
9253 gtk_widget_destroy (window);
9260 static int timer = 0;
9263 timeout_test (GtkWidget *label)
9265 static int count = 0;
9266 static char buffer[32];
9268 sprintf (buffer, "count: %d", ++count);
9269 gtk_label_set_text (GTK_LABEL (label), buffer);
9275 start_timeout_test (GtkWidget *widget,
9280 timer = g_timeout_add (100, (GSourceFunc)timeout_test, label);
9285 stop_timeout_test (GtkWidget *widget,
9290 g_source_remove (timer);
9296 destroy_timeout_test (GtkWidget *widget,
9299 stop_timeout_test (NULL, NULL);
9305 create_timeout_test (GtkWidget *widget)
9307 static GtkWidget *window = NULL;
9308 GtkWidget *action_area, *content_area;
9314 window = gtk_dialog_new ();
9316 gtk_window_set_screen (GTK_WINDOW (window),
9317 gtk_widget_get_screen (widget));
9319 g_signal_connect (window, "destroy",
9320 G_CALLBACK (destroy_timeout_test),
9323 content_area = gtk_dialog_get_content_area (GTK_DIALOG (window));
9324 action_area = gtk_dialog_get_content_area (GTK_DIALOG (window));
9326 gtk_window_set_title (GTK_WINDOW (window), "Timeout Test");
9327 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
9329 label = gtk_label_new ("count: 0");
9330 gtk_misc_set_padding (GTK_MISC (label), 10, 10);
9331 gtk_box_pack_start (GTK_BOX (content_area), label, TRUE, TRUE, 0);
9332 gtk_widget_show (label);
9334 button = gtk_button_new_with_label ("close");
9335 g_signal_connect_swapped (button, "clicked",
9336 G_CALLBACK (gtk_widget_destroy),
9338 gtk_widget_set_can_default (button, TRUE);
9339 gtk_box_pack_start (GTK_BOX (action_area), button, TRUE, TRUE, 0);
9340 gtk_widget_grab_default (button);
9341 gtk_widget_show (button);
9343 button = gtk_button_new_with_label ("start");
9344 g_signal_connect (button, "clicked",
9345 G_CALLBACK(start_timeout_test),
9347 gtk_widget_set_can_default (button, TRUE);
9348 gtk_box_pack_start (GTK_BOX (action_area), button, TRUE, TRUE, 0);
9349 gtk_widget_show (button);
9351 button = gtk_button_new_with_label ("stop");
9352 g_signal_connect (button, "clicked",
9353 G_CALLBACK (stop_timeout_test),
9355 gtk_widget_set_can_default (button, TRUE);
9356 gtk_box_pack_start (GTK_BOX (action_area), button, TRUE, TRUE, 0);
9357 gtk_widget_show (button);
9360 if (!gtk_widget_get_visible (window))
9361 gtk_widget_show (window);
9363 gtk_widget_destroy (window);
9370 static int idle_id = 0;
9373 idle_test (GtkWidget *label)
9375 static int count = 0;
9376 static char buffer[32];
9378 sprintf (buffer, "count: %d", ++count);
9379 gtk_label_set_text (GTK_LABEL (label), buffer);
9385 start_idle_test (GtkWidget *widget,
9390 idle_id = g_idle_add ((GSourceFunc) idle_test, label);
9395 stop_idle_test (GtkWidget *widget,
9400 g_source_remove (idle_id);
9406 destroy_idle_test (GtkWidget *widget,
9409 stop_idle_test (NULL, NULL);
9415 toggle_idle_container (GObject *button,
9416 GtkContainer *container)
9418 gtk_container_set_resize_mode (container, GPOINTER_TO_INT (g_object_get_data (button, "user_data")));
9422 create_idle_test (GtkWidget *widget)
9424 static GtkWidget *window = NULL;
9427 GtkWidget *container;
9431 GtkWidget *action_area, *content_area;
9436 window = gtk_dialog_new ();
9438 gtk_window_set_screen (GTK_WINDOW (window),
9439 gtk_widget_get_screen (widget));
9441 g_signal_connect (window, "destroy",
9442 G_CALLBACK (destroy_idle_test),
9445 content_area = gtk_dialog_get_content_area (GTK_DIALOG (window));
9446 action_area = gtk_dialog_get_action_area (GTK_DIALOG (window));
9448 gtk_window_set_title (GTK_WINDOW (window), "Idle Test");
9449 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
9451 label = gtk_label_new ("count: 0");
9452 gtk_misc_set_padding (GTK_MISC (label), 10, 10);
9453 gtk_widget_show (label);
9456 g_object_new (GTK_TYPE_HBOX,
9458 /* "GtkContainer::child", g_object_new (GTK_TYPE_HBOX,
9459 * "GtkWidget::visible", TRUE,
9464 gtk_box_pack_start (GTK_BOX (content_area), container, TRUE, TRUE, 0);
9467 g_object_new (GTK_TYPE_FRAME,
9469 "label", "Label Container",
9471 "parent", content_area,
9474 g_object_new (GTK_TYPE_VBOX,
9479 g_object_connect (g_object_new (GTK_TYPE_RADIO_BUTTON,
9480 "label", "Resize-Parent",
9481 "user_data", (void*)GTK_RESIZE_PARENT,
9485 "signal::clicked", toggle_idle_container, container,
9487 button = g_object_new (GTK_TYPE_RADIO_BUTTON,
9488 "label", "Resize-Queue",
9489 "user_data", (void*)GTK_RESIZE_QUEUE,
9494 g_object_connect (button,
9495 "signal::clicked", toggle_idle_container, container,
9497 button2 = g_object_new (GTK_TYPE_RADIO_BUTTON,
9498 "label", "Resize-Immediate",
9499 "user_data", (void*)GTK_RESIZE_IMMEDIATE,
9501 g_object_connect (button2,
9502 "signal::clicked", toggle_idle_container, container,
9504 g_object_set (button2,
9510 button = gtk_button_new_with_label ("close");
9511 g_signal_connect_swapped (button, "clicked",
9512 G_CALLBACK (gtk_widget_destroy),
9514 gtk_widget_set_can_default (button, TRUE);
9515 gtk_box_pack_start (GTK_BOX (action_area), button, TRUE, TRUE, 0);
9516 gtk_widget_grab_default (button);
9517 gtk_widget_show (button);
9519 button = gtk_button_new_with_label ("start");
9520 g_signal_connect (button, "clicked",
9521 G_CALLBACK (start_idle_test),
9523 gtk_widget_set_can_default (button, TRUE);
9524 gtk_box_pack_start (GTK_BOX (action_area), button, TRUE, TRUE, 0);
9525 gtk_widget_show (button);
9527 button = gtk_button_new_with_label ("stop");
9528 g_signal_connect (button, "clicked",
9529 G_CALLBACK (stop_idle_test),
9531 gtk_widget_set_can_default (button, TRUE);
9532 gtk_box_pack_start (GTK_BOX (action_area), button, TRUE, TRUE, 0);
9533 gtk_widget_show (button);
9536 if (!gtk_widget_get_visible (window))
9537 gtk_widget_show (window);
9539 gtk_widget_destroy (window);
9547 reload_all_rc_files (void)
9549 static GdkAtom atom_rcfiles = GDK_NONE;
9551 GdkEvent *send_event = gdk_event_new (GDK_CLIENT_EVENT);
9555 atom_rcfiles = gdk_atom_intern("_GTK_READ_RCFILES", FALSE);
9557 for(i = 0; i < 5; i++)
9558 send_event->client.data.l[i] = 0;
9559 send_event->client.data_format = 32;
9560 send_event->client.message_type = atom_rcfiles;
9561 gdk_event_send_clientmessage_toall (send_event);
9563 gdk_event_free (send_event);
9567 create_rc_file (GtkWidget *widget)
9569 static GtkWidget *window = NULL;
9570 GtkWidget *action_area, *content_area;
9578 window = gtk_dialog_new ();
9580 gtk_window_set_screen (GTK_WINDOW (window),
9581 gtk_widget_get_screen (widget));
9583 g_signal_connect (window, "destroy",
9584 G_CALLBACK (gtk_widget_destroyed),
9587 content_area = gtk_dialog_get_content_area (GTK_DIALOG (window));
9588 action_area = gtk_dialog_get_action_area (GTK_DIALOG (window));
9590 frame = gtk_aspect_frame_new ("Testing RC file prioritization", 0.5, 0.5, 0.0, TRUE);
9591 gtk_box_pack_start (GTK_BOX (content_area), frame, FALSE, FALSE, 0);
9593 vbox = gtk_vbox_new (FALSE, 0);
9594 gtk_container_add (GTK_CONTAINER (frame), vbox);
9596 label = gtk_label_new ("This label should be red");
9597 gtk_widget_set_name (label, "testgtk-red-label");
9598 gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
9600 label = gtk_label_new ("This label should be green");
9601 gtk_widget_set_name (label, "testgtk-green-label");
9602 gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
9604 label = gtk_label_new ("This label should be blue");
9605 gtk_widget_set_name (label, "testgtk-blue-label");
9606 gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
9608 gtk_window_set_title (GTK_WINDOW (window), "Reload Rc file");
9609 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
9611 button = gtk_button_new_with_label ("Reload");
9612 g_signal_connect (button, "clicked",
9613 G_CALLBACK (gtk_rc_reparse_all), NULL);
9614 gtk_widget_set_can_default (button, TRUE);
9615 gtk_box_pack_start (GTK_BOX (action_area), button, TRUE, TRUE, 0);
9616 gtk_widget_grab_default (button);
9618 button = gtk_button_new_with_label ("Reload All");
9619 g_signal_connect (button, "clicked",
9620 G_CALLBACK (reload_all_rc_files), NULL);
9621 gtk_widget_set_can_default (button, TRUE);
9622 gtk_box_pack_start (GTK_BOX (action_area), button, TRUE, TRUE, 0);
9624 button = gtk_button_new_with_label ("Close");
9625 g_signal_connect_swapped (button, "clicked",
9626 G_CALLBACK (gtk_widget_destroy),
9628 gtk_widget_set_can_default (button, TRUE);
9629 gtk_box_pack_start (GTK_BOX (action_area), button, TRUE, TRUE, 0);
9632 if (!gtk_widget_get_visible (window))
9633 gtk_widget_show_all (window);
9635 gtk_widget_destroy (window);
9639 * Test of recursive mainloop
9643 mainloop_destroyed (GtkWidget *w, GtkWidget **window)
9650 create_mainloop (GtkWidget *widget)
9652 static GtkWidget *window = NULL;
9653 GtkWidget *action_area, *content_area;
9659 window = gtk_dialog_new ();
9661 gtk_window_set_screen (GTK_WINDOW (window),
9662 gtk_widget_get_screen (widget));
9664 gtk_window_set_title (GTK_WINDOW (window), "Test Main Loop");
9666 g_signal_connect (window, "destroy",
9667 G_CALLBACK (mainloop_destroyed),
9670 content_area = gtk_dialog_get_content_area (GTK_DIALOG (window));
9671 action_area = gtk_dialog_get_action_area (GTK_DIALOG (window));
9673 label = gtk_label_new ("In recursive main loop...");
9674 gtk_misc_set_padding (GTK_MISC(label), 20, 20);
9676 gtk_box_pack_start (GTK_BOX (content_area), label, TRUE, TRUE, 0);
9677 gtk_widget_show (label);
9679 button = gtk_button_new_with_label ("Leave");
9680 gtk_box_pack_start (GTK_BOX (action_area), button, FALSE, TRUE, 0);
9682 g_signal_connect_swapped (button, "clicked",
9683 G_CALLBACK (gtk_widget_destroy),
9686 gtk_widget_set_can_default (button, TRUE);
9687 gtk_widget_grab_default (button);
9689 gtk_widget_show (button);
9692 if (!gtk_widget_get_visible (window))
9694 gtk_widget_show (window);
9696 g_print ("create_mainloop: start\n");
9698 g_print ("create_mainloop: done\n");
9701 gtk_widget_destroy (window);
9705 layout_draw_handler (GtkWidget *widget, cairo_t *cr)
9708 GdkWindow *bin_window;
9711 gint imin, imax, jmin, jmax;
9713 layout = GTK_LAYOUT (widget);
9714 bin_window = gtk_layout_get_bin_window (layout);
9716 if (!gtk_cairo_should_draw_window (cr, bin_window))
9719 gdk_window_get_position (bin_window, &x, &y);
9720 cairo_translate (cr, x, y);
9722 gdk_cairo_get_clip_rectangle (cr, &clip);
9724 imin = (clip.x) / 10;
9725 imax = (clip.x + clip.width + 9) / 10;
9727 jmin = (clip.y) / 10;
9728 jmax = (clip.y + clip.height + 9) / 10;
9730 for (i=imin; i<imax; i++)
9731 for (j=jmin; j<jmax; j++)
9733 cairo_rectangle (cr,
9742 void create_layout (GtkWidget *widget)
9744 GtkAdjustment *hadjustment, *vadjustment;
9746 static GtkWidget *window = NULL;
9747 GtkWidget *layout_widget;
9748 GtkWidget *scrolledwindow;
9757 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
9758 gtk_window_set_screen (GTK_WINDOW (window),
9759 gtk_widget_get_screen (widget));
9761 g_signal_connect (window, "destroy",
9762 G_CALLBACK (gtk_widget_destroyed),
9765 gtk_window_set_title (GTK_WINDOW (window), "Layout");
9766 gtk_widget_set_size_request (window, 200, 200);
9768 scrolledwindow = gtk_scrolled_window_new (NULL, NULL);
9769 gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolledwindow),
9771 gtk_scrolled_window_set_placement (GTK_SCROLLED_WINDOW (scrolledwindow),
9772 GTK_CORNER_TOP_RIGHT);
9774 gtk_container_add (GTK_CONTAINER (window), scrolledwindow);
9776 layout_widget = gtk_layout_new (NULL, NULL);
9777 layout = GTK_LAYOUT (layout_widget);
9778 gtk_container_add (GTK_CONTAINER (scrolledwindow), layout_widget);
9780 /* We set step sizes here since GtkLayout does not set
9783 hadjustment = gtk_scrollable_get_hadjustment (GTK_SCROLLABLE (layout));
9784 vadjustment = gtk_scrollable_get_vadjustment (GTK_SCROLLABLE (layout));
9785 gtk_adjustment_set_step_increment (hadjustment, 10.0);
9786 gtk_adjustment_set_step_increment (vadjustment, 10.0);
9787 gtk_scrollable_set_hadjustment (GTK_SCROLLABLE (layout), hadjustment);
9788 gtk_scrollable_set_vadjustment (GTK_SCROLLABLE (layout), vadjustment);
9790 gtk_widget_set_events (layout_widget, GDK_EXPOSURE_MASK);
9791 g_signal_connect (layout, "draw",
9792 G_CALLBACK (layout_draw_handler), NULL);
9794 gtk_layout_set_size (layout, 1600, 128000);
9796 for (i=0 ; i < 16 ; i++)
9797 for (j=0 ; j < 16 ; j++)
9799 sprintf(buf, "Button %d, %d", i, j);
9801 button = gtk_button_new_with_label (buf);
9803 button = gtk_label_new (buf);
9805 gtk_layout_put (layout, button, j*100, i*100);
9808 for (i=16; i < 1280; i++)
9810 sprintf(buf, "Button %d, %d", i, 0);
9812 button = gtk_button_new_with_label (buf);
9814 button = gtk_label_new (buf);
9816 gtk_layout_put (layout, button, 0, i*100);
9820 if (!gtk_widget_get_visible (window))
9821 gtk_widget_show_all (window);
9823 gtk_widget_destroy (window);
9827 create_styles (GtkWidget *widget)
9829 static GtkWidget *window = NULL;
9830 GtkWidget *content_area, *action_area;
9835 static GdkColor red = { 0, 0xffff, 0, 0 };
9836 static GdkColor green = { 0, 0, 0xffff, 0 };
9837 static GdkColor blue = { 0, 0, 0, 0xffff };
9838 static GdkColor yellow = { 0, 0xffff, 0xffff, 0 };
9839 static GdkColor cyan = { 0, 0 , 0xffff, 0xffff };
9840 PangoFontDescription *font_desc;
9842 GtkRcStyle *rc_style;
9846 window = gtk_dialog_new ();
9847 gtk_window_set_screen (GTK_WINDOW (window),
9848 gtk_widget_get_screen (widget));
9850 g_signal_connect (window, "destroy",
9851 G_CALLBACK (gtk_widget_destroyed),
9854 content_area = gtk_dialog_get_content_area (GTK_DIALOG (window));
9855 action_area = gtk_dialog_get_action_area (GTK_DIALOG (window));
9857 button = gtk_button_new_with_label ("Close");
9858 g_signal_connect_swapped (button, "clicked",
9859 G_CALLBACK (gtk_widget_destroy),
9861 gtk_widget_set_can_default (button, TRUE);
9862 gtk_box_pack_start (GTK_BOX (action_area), button, TRUE, TRUE, 0);
9863 gtk_widget_show (button);
9865 vbox = gtk_vbox_new (FALSE, 5);
9866 gtk_container_set_border_width (GTK_CONTAINER (vbox), 10);
9867 gtk_box_pack_start (GTK_BOX (content_area), vbox, FALSE, FALSE, 0);
9869 label = gtk_label_new ("Font:");
9870 gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
9871 gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
9873 font_desc = pango_font_description_from_string ("Helvetica,Sans Oblique 18");
9875 button = gtk_button_new_with_label ("Some Text");
9876 gtk_widget_modify_font (gtk_bin_get_child (GTK_BIN (button)),
9878 gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
9880 label = gtk_label_new ("Foreground:");
9881 gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
9882 gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
9884 button = gtk_button_new_with_label ("Some Text");
9885 gtk_widget_modify_fg (gtk_bin_get_child (GTK_BIN (button)),
9886 GTK_STATE_NORMAL, &red);
9887 gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
9889 label = gtk_label_new ("Background:");
9890 gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
9891 gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
9893 button = gtk_button_new_with_label ("Some Text");
9894 gtk_widget_modify_bg (button, GTK_STATE_NORMAL, &green);
9895 gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
9897 label = gtk_label_new ("Text:");
9898 gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
9899 gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
9901 entry = gtk_entry_new ();
9902 gtk_entry_set_text (GTK_ENTRY (entry), "Some Text");
9903 gtk_widget_modify_text (entry, GTK_STATE_NORMAL, &blue);
9904 gtk_box_pack_start (GTK_BOX (vbox), entry, FALSE, FALSE, 0);
9906 label = gtk_label_new ("Base:");
9907 gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
9908 gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
9910 entry = gtk_entry_new ();
9911 gtk_entry_set_text (GTK_ENTRY (entry), "Some Text");
9912 gtk_widget_modify_base (entry, GTK_STATE_NORMAL, &yellow);
9913 gtk_box_pack_start (GTK_BOX (vbox), entry, FALSE, FALSE, 0);
9915 label = gtk_label_new ("Cursor:");
9916 gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
9917 gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
9919 entry = gtk_entry_new ();
9920 gtk_entry_set_text (GTK_ENTRY (entry), "Some Text");
9921 gtk_widget_modify_cursor (entry, &red, &red);
9922 gtk_box_pack_start (GTK_BOX (vbox), entry, FALSE, FALSE, 0);
9924 label = gtk_label_new ("Multiple:");
9925 gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
9926 gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
9928 button = gtk_button_new_with_label ("Some Text");
9930 rc_style = gtk_rc_style_new ();
9932 rc_style->font_desc = pango_font_description_copy (font_desc);
9933 rc_style->color_flags[GTK_STATE_NORMAL] = GTK_RC_FG | GTK_RC_BG;
9934 rc_style->color_flags[GTK_STATE_PRELIGHT] = GTK_RC_FG | GTK_RC_BG;
9935 rc_style->color_flags[GTK_STATE_ACTIVE] = GTK_RC_FG | GTK_RC_BG;
9936 rc_style->fg[GTK_STATE_NORMAL] = yellow;
9937 rc_style->bg[GTK_STATE_NORMAL] = blue;
9938 rc_style->fg[GTK_STATE_PRELIGHT] = blue;
9939 rc_style->bg[GTK_STATE_PRELIGHT] = yellow;
9940 rc_style->fg[GTK_STATE_ACTIVE] = red;
9941 rc_style->bg[GTK_STATE_ACTIVE] = cyan;
9942 rc_style->xthickness = 5;
9943 rc_style->ythickness = 5;
9945 gtk_widget_modify_style (button, rc_style);
9946 gtk_widget_modify_style (gtk_bin_get_child (GTK_BIN (button)), rc_style);
9948 g_object_unref (rc_style);
9950 gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
9953 if (!gtk_widget_get_visible (window))
9954 gtk_widget_show_all (window);
9956 gtk_widget_destroy (window);
9960 * Main Window and Exit
9964 do_exit (GtkWidget *widget, GtkWidget *window)
9966 gtk_widget_destroy (window);
9972 void (*func) (GtkWidget *widget);
9973 gboolean do_not_benchmark;
9976 { "alpha window", create_alpha_window },
9977 { "big windows", create_big_windows },
9978 { "button box", create_button_box },
9979 { "buttons", create_buttons },
9980 { "check buttons", create_check_buttons },
9981 { "color selection", create_color_selection },
9982 { "composited window", create_composited_window },
9983 { "cursors", create_cursors },
9984 { "dialog", create_dialog },
9985 { "display & screen", create_display_screen, TRUE },
9986 { "entry", create_entry },
9987 { "event box", create_event_box },
9988 { "event watcher", create_event_watcher },
9989 { "expander", create_expander },
9990 { "flipping", create_flipping },
9991 { "focus", create_focus },
9992 { "font selection", create_font_selection },
9993 { "handle box", create_handle_box },
9994 { "image", create_image },
9995 { "key lookup", create_key_lookup },
9996 { "labels", create_labels },
9997 { "layout", create_layout },
9998 { "menus", create_menus },
9999 { "message dialog", create_message_dialog },
10000 { "modal window", create_modal_window, TRUE },
10001 { "notebook", create_notebook },
10002 { "panes", create_panes },
10003 { "paned keyboard", create_paned_keyboard_navigation },
10004 { "pixbuf", create_pixbuf },
10005 { "progress bar", create_progress_bar },
10006 { "properties", create_properties },
10007 { "radio buttons", create_radio_buttons },
10008 { "range controls", create_range_controls },
10009 { "rc file", create_rc_file },
10010 { "reparent", create_reparent },
10011 { "resize grips", create_resize_grips },
10012 { "rotated label", create_rotated_label },
10013 { "rotated text", create_rotated_text },
10014 { "rulers", create_rulers },
10015 { "saved position", create_saved_position },
10016 { "scrolled windows", create_scrolled_windows },
10017 { "shapes", create_shapes },
10018 { "size groups", create_size_groups },
10019 { "snapshot", create_snapshot },
10020 { "spinbutton", create_spins },
10021 { "statusbar", create_statusbar },
10022 { "styles", create_styles },
10023 { "test idle", create_idle_test },
10024 { "test mainloop", create_mainloop, TRUE },
10025 { "test scrolling", create_scroll_test },
10026 { "test selection", create_selection_test },
10027 { "test timeout", create_timeout_test },
10028 { "toggle buttons", create_toggle_buttons },
10029 { "toolbar", create_toolbar },
10030 { "tooltips", create_tooltips },
10031 { "WM hints", create_wmhints },
10032 { "window sizing", create_window_sizing },
10033 { "window states", create_window_states }
10035 int nbuttons = sizeof (buttons) / sizeof (buttons[0]);
10038 create_main_window (void)
10043 GtkWidget *scrolled_window;
10047 GtkWidget *separator;
10048 GdkGeometry geometry;
10051 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
10052 gtk_widget_set_name (window, "main window");
10053 gtk_window_move (GTK_WINDOW (window), 50, 20);
10054 gtk_window_set_default_size (GTK_WINDOW (window), -1, 400);
10056 geometry.min_width = -1;
10057 geometry.min_height = -1;
10058 geometry.max_width = -1;
10059 geometry.max_height = G_MAXSHORT;
10060 gtk_window_set_geometry_hints (GTK_WINDOW (window), NULL,
10062 GDK_HINT_MIN_SIZE | GDK_HINT_MAX_SIZE);
10064 g_signal_connect (window, "destroy",
10065 G_CALLBACK (gtk_main_quit),
10067 g_signal_connect (window, "delete-event",
10068 G_CALLBACK (gtk_false),
10071 box1 = gtk_vbox_new (FALSE, 0);
10072 gtk_container_add (GTK_CONTAINER (window), box1);
10074 if (gtk_micro_version > 0)
10077 gtk_get_major_version (),
10078 gtk_get_minor_version (),
10079 gtk_get_micro_version ());
10083 gtk_get_major_version (),
10084 gtk_get_minor_version ());
10086 label = gtk_label_new (buffer);
10087 gtk_box_pack_start (GTK_BOX (box1), label, FALSE, FALSE, 0);
10088 gtk_widget_set_name (label, "testgtk-version-label");
10090 scrolled_window = gtk_scrolled_window_new (NULL, NULL);
10091 gtk_container_set_border_width (GTK_CONTAINER (scrolled_window), 10);
10092 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
10094 GTK_POLICY_AUTOMATIC);
10095 gtk_box_pack_start (GTK_BOX (box1), scrolled_window, TRUE, TRUE, 0);
10097 box2 = gtk_vbox_new (FALSE, 0);
10098 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
10099 gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (scrolled_window), box2);
10100 gtk_container_set_focus_vadjustment (GTK_CONTAINER (box2),
10101 gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (scrolled_window)));
10102 gtk_widget_show (box2);
10104 for (i = 0; i < nbuttons; i++)
10106 button = gtk_button_new_with_label (buttons[i].label);
10107 if (buttons[i].func)
10108 g_signal_connect (button,
10110 G_CALLBACK(buttons[i].func),
10113 gtk_widget_set_sensitive (button, FALSE);
10114 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
10117 separator = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
10118 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
10120 box2 = gtk_vbox_new (FALSE, 10);
10121 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
10122 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
10124 button = gtk_button_new_with_mnemonic ("_Close");
10125 g_signal_connect (button, "clicked",
10126 G_CALLBACK (do_exit),
10128 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
10129 gtk_widget_set_can_default (button, TRUE);
10130 gtk_widget_grab_default (button);
10132 gtk_widget_show_all (window);
10138 if (g_file_test ("../gdk-pixbuf/libpixbufloader-pnm.la",
10139 G_FILE_TEST_EXISTS))
10141 g_setenv ("GDK_PIXBUF_MODULE_FILE", "../gdk-pixbuf/loaders.cache", TRUE);
10142 g_setenv ("GTK_IM_MODULE_FILE", "../modules/input/immodules.cache", TRUE);
10147 pad (const char *str, int to)
10149 static char buf[256];
10150 int len = strlen (str);
10153 for (i = 0; i < to; i++)
10158 memcpy (buf, str, len);
10164 bench_iteration (GtkWidget *widget, void (* fn) (GtkWidget *widget))
10166 fn (widget); /* on */
10167 while (g_main_context_iteration (NULL, FALSE));
10168 fn (widget); /* off */
10169 while (g_main_context_iteration (NULL, FALSE));
10173 do_real_bench (GtkWidget *widget, void (* fn) (GtkWidget *widget), char *name, int num)
10179 static gboolean printed_headers = FALSE;
10181 if (!printed_headers) {
10182 g_print ("Test Iters First Other\n");
10183 g_print ("-------------------- ----- ---------- ----------\n");
10184 printed_headers = TRUE;
10187 g_get_current_time (&tv0);
10188 bench_iteration (widget, fn);
10189 g_get_current_time (&tv1);
10191 dt_first = ((double)tv1.tv_sec - tv0.tv_sec) * 1000.0
10192 + (tv1.tv_usec - tv0.tv_usec) / 1000.0;
10194 g_get_current_time (&tv0);
10195 for (n = 0; n < num - 1; n++)
10196 bench_iteration (widget, fn);
10197 g_get_current_time (&tv1);
10198 dt = ((double)tv1.tv_sec - tv0.tv_sec) * 1000.0
10199 + (tv1.tv_usec - tv0.tv_usec) / 1000.0;
10201 g_print ("%s %5d ", pad (name, 20), num);
10203 g_print ("%10.1f %10.1f\n", dt_first, dt/(num-1));
10205 g_print ("%10.1f\n", dt_first);
10209 do_bench (char* what, int num)
10213 void (* fn) (GtkWidget *widget);
10215 widget = gtk_window_new (GTK_WINDOW_TOPLEVEL);
10217 if (g_ascii_strcasecmp (what, "ALL") == 0)
10219 for (i = 0; i < nbuttons; i++)
10221 if (!buttons[i].do_not_benchmark)
10222 do_real_bench (widget, buttons[i].func, buttons[i].label, num);
10229 for (i = 0; i < nbuttons; i++)
10231 if (strcmp (buttons[i].label, what) == 0)
10233 fn = buttons[i].func;
10239 g_print ("Can't bench: \"%s\" not found.\n", what);
10241 do_real_bench (widget, fn, buttons[i].label, num);
10248 fprintf (stderr, "Usage: testgtk [--bench ALL|<bench>[:<count>]]\n");
10253 main (int argc, char *argv[])
10255 GtkBindingSet *binding_set;
10257 gboolean done_benchmarks = FALSE;
10259 srand (time (NULL));
10263 /* Check to see if we are being run from the correct
10266 if (file_exists ("testgtkrc"))
10267 gtk_rc_add_default_file ("testgtkrc");
10268 else if (file_exists ("tests/testgtkrc"))
10269 gtk_rc_add_default_file ("tests/testgtkrc");
10271 g_warning ("Couldn't find file \"testgtkrc\".");
10273 g_set_application_name ("GTK+ Test Program");
10275 gtk_init (&argc, &argv);
10277 gtk_accelerator_set_default_mod_mask (GDK_SHIFT_MASK |
10286 for (i = 1; i < argc; i++)
10288 if (strncmp (argv[i], "--bench", strlen("--bench")) == 0)
10295 nextarg = strchr (argv[i], '=');
10306 count = strchr (nextarg, ':');
10309 what = g_strndup (nextarg, count - nextarg);
10311 num = atoi (count);
10316 what = g_strdup (nextarg);
10318 do_bench (what, num ? num : 1);
10319 done_benchmarks = TRUE;
10324 if (done_benchmarks)
10329 binding_set = gtk_binding_set_by_class (g_type_class_ref (GTK_TYPE_WIDGET));
10330 gtk_binding_entry_add_signal (binding_set,
10331 '9', GDK_CONTROL_MASK | GDK_RELEASE_MASK,
10334 G_TYPE_STRING, "GtkWidgetClass <ctrl><release>9 test");
10336 /* We use gtk_rc_parse_string() here so we can make sure it works across theme
10340 gtk_rc_parse_string ("style \"testgtk-version-label\" { "
10341 " fg[NORMAL] = \"#ff0000\"\n"
10342 " font = \"Sans 18\"\n"
10344 "widget \"*.testgtk-version-label\" style \"testgtk-version-label\"");
10346 create_main_window ();
10352 while (g_main_context_pending (NULL))
10353 g_main_context_iteration (NULL, FALSE);
10356 while (g_main_context_pending (NULL))
10357 g_main_context_iteration (NULL, FALSE);