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_box_new (GTK_ORIENTATION_HORIZONTAL, 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_box_new (GTK_ORIENTATION_VERTICAL, 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_scrollbar_new (GTK_ORIENTATION_HORIZONTAL, hadj);
634 gtk_table_attach (GTK_TABLE (table), scrollbar,
636 GTK_FILL | GTK_EXPAND, GTK_FILL,
639 scrollbar = gtk_scrollbar_new (GTK_ORIENTATION_VERTICAL, 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_box_new (GTK_ORIENTATION_VERTICAL, 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_box_new (GTK_ORIENTATION_VERTICAL, 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_box_new (GTK_ORIENTATION_VERTICAL, 0);
814 gtk_container_add (GTK_CONTAINER (window), box1);
816 box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 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_box_new (GTK_ORIENTATION_VERTICAL, 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_box_new (GTK_ORIENTATION_VERTICAL, 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_box_new (GTK_ORIENTATION_VERTICAL, 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_box_new (GTK_ORIENTATION_VERTICAL, 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_box_new (GTK_ORIENTATION_VERTICAL, 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_box_new (GTK_ORIENTATION_VERTICAL, 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_box_new (GTK_ORIENTATION_HORIZONTAL, 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_box_new (GTK_ORIENTATION_VERTICAL, 0);
1571 gtk_container_add (GTK_CONTAINER (window), box1);
1573 box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 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_box_new (GTK_ORIENTATION_VERTICAL, 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_box_new (GTK_ORIENTATION_VERTICAL, 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_box_new (GTK_ORIENTATION_HORIZONTAL, 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_box_new (GTK_ORIENTATION_VERTICAL, 5);
1916 hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 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_box_new (GTK_ORIENTATION_VERTICAL, 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_box_new (GTK_ORIENTATION_VERTICAL, 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_box_new (GTK_ORIENTATION_VERTICAL, 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_box_new (GTK_ORIENTATION_HORIZONTAL, 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_scale_new_with_range (GTK_ORIENTATION_HORIZONTAL,
2112 g_signal_connect (hscale, "value-changed",
2113 G_CALLBACK (on_angle_scale_changed), label);
2115 gtk_range_set_value (GTK_RANGE (hscale), 45);
2116 gtk_widget_set_size_request (hscale, 200, -1);
2117 gtk_box_pack_start (GTK_BOX (scale_hbox), hscale, TRUE, TRUE, 0);
2120 if (!gtk_widget_get_visible (window))
2121 gtk_widget_show_all (window);
2123 gtk_widget_destroy (window);
2126 #define DEFAULT_TEXT_RADIUS 200
2129 on_rotated_text_unrealize (GtkWidget *widget)
2131 g_object_set_data (G_OBJECT (widget), "text-gc", NULL);
2135 on_rotated_text_draw (GtkWidget *widget,
2137 GdkPixbuf *tile_pixbuf)
2139 static const gchar *words[] = { "The", "grand", "old", "Duke", "of", "York",
2140 "had", "10,000", "men" };
2145 PangoLayout *layout;
2146 PangoContext *context;
2147 PangoFontDescription *desc;
2151 gdk_cairo_set_source_pixbuf (cr, tile_pixbuf, 0, 0);
2152 cairo_pattern_set_extend (cairo_get_source (cr), CAIRO_EXTEND_REPEAT);
2155 cairo_set_source_rgb (cr, 0, 0, 0);
2157 width = gtk_widget_get_allocated_width (widget);
2158 height = gtk_widget_get_allocated_height (widget);
2159 radius = MIN (width, height) / 2.;
2161 cairo_translate (cr,
2162 radius + (width - 2 * radius) / 2,
2163 radius + (height - 2 * radius) / 2);
2164 cairo_scale (cr, radius / DEFAULT_TEXT_RADIUS, radius / DEFAULT_TEXT_RADIUS);
2166 context = gtk_widget_get_pango_context (widget);
2167 layout = pango_layout_new (context);
2168 desc = pango_font_description_from_string ("Sans Bold 30");
2169 pango_layout_set_font_description (layout, desc);
2170 pango_font_description_free (desc);
2172 n_words = G_N_ELEMENTS (words);
2173 for (i = 0; i < n_words; i++)
2179 cairo_rotate (cr, 2 * G_PI * i / n_words);
2180 pango_cairo_update_layout (cr, layout);
2182 pango_layout_set_text (layout, words[i], -1);
2183 pango_layout_get_size (layout, &width, &height);
2185 cairo_move_to (cr, - width / 2 / PANGO_SCALE, - DEFAULT_TEXT_RADIUS);
2186 pango_cairo_show_layout (cr, layout);
2191 g_object_unref (layout);
2197 create_rotated_text (GtkWidget *widget)
2199 static GtkWidget *window = NULL;
2203 const GdkColor white = { 0, 0xffff, 0xffff, 0xffff };
2204 GtkRequisition requisition;
2205 GtkWidget *content_area;
2206 GtkWidget *drawing_area;
2207 GdkPixbuf *tile_pixbuf;
2209 window = gtk_dialog_new_with_buttons ("Rotated Text",
2210 GTK_WINDOW (gtk_widget_get_toplevel (widget)), 0,
2211 GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE,
2214 gtk_window_set_resizable (GTK_WINDOW (window), TRUE);
2216 gtk_window_set_screen (GTK_WINDOW (window),
2217 gtk_widget_get_screen (widget));
2219 g_signal_connect (window, "response",
2220 G_CALLBACK (gtk_widget_destroy), NULL);
2221 g_signal_connect (window, "destroy",
2222 G_CALLBACK (gtk_widget_destroyed), &window);
2224 content_area = gtk_dialog_get_content_area (GTK_DIALOG (window));
2226 drawing_area = gtk_drawing_area_new ();
2227 gtk_box_pack_start (GTK_BOX (content_area), drawing_area, TRUE, TRUE, 0);
2228 gtk_widget_modify_bg (drawing_area, GTK_STATE_NORMAL, &white);
2230 tile_pixbuf = gdk_pixbuf_new_from_file ("marble.xpm", NULL);
2232 g_signal_connect (drawing_area, "draw",
2233 G_CALLBACK (on_rotated_text_draw), tile_pixbuf);
2234 g_signal_connect (drawing_area, "unrealize",
2235 G_CALLBACK (on_rotated_text_unrealize), NULL);
2237 gtk_widget_show_all (gtk_bin_get_child (GTK_BIN (window)));
2239 gtk_widget_set_size_request (drawing_area, DEFAULT_TEXT_RADIUS * 2, DEFAULT_TEXT_RADIUS * 2);
2240 gtk_widget_get_preferred_size ( (window),
2241 &requisition, NULL);
2242 gtk_widget_set_size_request (drawing_area, -1, -1);
2243 gtk_window_resize (GTK_WINDOW (window), requisition.width, requisition.height);
2246 if (!gtk_widget_get_visible (window))
2247 gtk_widget_show (window);
2249 gtk_widget_destroy (window);
2257 reparent_label (GtkWidget *widget,
2258 GtkWidget *new_parent)
2262 label = g_object_get_data (G_OBJECT (widget), "user_data");
2264 gtk_widget_reparent (label, new_parent);
2268 set_parent_signal (GtkWidget *child,
2269 GtkWidget *old_parent,
2274 parent = gtk_widget_get_parent (child);
2275 g_message ("set_parent for \"%s\": new parent: \"%s\", old parent: \"%s\", data: %d\n",
2276 g_type_name (G_OBJECT_TYPE (child)),
2277 parent ? g_type_name (G_OBJECT_TYPE (parent)) : "NULL",
2278 old_parent ? g_type_name (G_OBJECT_TYPE (old_parent)) : "NULL",
2279 GPOINTER_TO_INT (func_data));
2283 create_reparent (GtkWidget *widget)
2285 static GtkWidget *window = NULL;
2292 GtkWidget *separator;
2293 GtkWidget *event_box;
2297 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
2299 gtk_window_set_screen (GTK_WINDOW (window),
2300 gtk_widget_get_screen (widget));
2302 g_signal_connect (window, "destroy",
2303 G_CALLBACK (gtk_widget_destroyed),
2306 gtk_window_set_title (GTK_WINDOW (window), "reparent");
2307 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
2309 box1 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
2310 gtk_container_add (GTK_CONTAINER (window), box1);
2312 box2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 5);
2313 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
2314 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
2316 label = gtk_label_new ("Hello World");
2318 frame = gtk_frame_new ("Frame 1");
2319 gtk_box_pack_start (GTK_BOX (box2), frame, TRUE, TRUE, 0);
2321 box3 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
2322 gtk_container_set_border_width (GTK_CONTAINER (box3), 5);
2323 gtk_container_add (GTK_CONTAINER (frame), box3);
2325 button = gtk_button_new_with_label ("switch");
2326 g_object_set_data (G_OBJECT (button), "user_data", label);
2327 gtk_box_pack_start (GTK_BOX (box3), button, FALSE, TRUE, 0);
2329 event_box = gtk_event_box_new ();
2330 gtk_box_pack_start (GTK_BOX (box3), event_box, FALSE, TRUE, 0);
2331 gtk_container_add (GTK_CONTAINER (event_box), label);
2333 g_signal_connect (button, "clicked",
2334 G_CALLBACK (reparent_label),
2337 g_signal_connect (label, "parent_set",
2338 G_CALLBACK (set_parent_signal),
2339 GINT_TO_POINTER (42));
2341 frame = gtk_frame_new ("Frame 2");
2342 gtk_box_pack_start (GTK_BOX (box2), frame, TRUE, TRUE, 0);
2344 box3 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
2345 gtk_container_set_border_width (GTK_CONTAINER (box3), 5);
2346 gtk_container_add (GTK_CONTAINER (frame), box3);
2348 button = gtk_button_new_with_label ("switch");
2349 g_object_set_data (G_OBJECT (button), "user_data", label);
2350 gtk_box_pack_start (GTK_BOX (box3), button, FALSE, TRUE, 0);
2352 event_box = gtk_event_box_new ();
2353 gtk_box_pack_start (GTK_BOX (box3), event_box, FALSE, TRUE, 0);
2355 g_signal_connect (button, "clicked",
2356 G_CALLBACK (reparent_label),
2359 separator = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
2360 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
2362 box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10);
2363 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
2364 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
2366 button = gtk_button_new_with_label ("close");
2367 g_signal_connect_swapped (button, "clicked",
2368 G_CALLBACK (gtk_widget_destroy), window);
2369 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
2370 gtk_widget_set_can_default (button, TRUE);
2371 gtk_widget_grab_default (button);
2374 if (!gtk_widget_get_visible (window))
2375 gtk_widget_show_all (window);
2377 gtk_widget_destroy (window);
2384 grippy_button_press (GtkWidget *area, GdkEventButton *event, GdkWindowEdge edge)
2386 if (event->type == GDK_BUTTON_PRESS)
2388 if (event->button == 1)
2389 gtk_window_begin_resize_drag (GTK_WINDOW (gtk_widget_get_toplevel (area)), edge,
2390 event->button, event->x_root, event->y_root,
2392 else if (event->button == 2)
2393 gtk_window_begin_move_drag (GTK_WINDOW (gtk_widget_get_toplevel (area)),
2394 event->button, event->x_root, event->y_root,
2401 grippy_draw (GtkWidget *area, cairo_t *cr, GdkWindowEdge edge)
2403 gtk_paint_resize_grip (gtk_widget_get_style (area),
2405 gtk_widget_get_state (area),
2410 gtk_widget_get_allocated_width (area),
2411 gtk_widget_get_allocated_height (area));
2417 create_resize_grips (GtkWidget *widget)
2419 static GtkWidget *window = NULL;
2421 GtkWidget *hbox, *vbox;
2424 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
2426 gtk_window_set_screen (GTK_WINDOW (window),
2427 gtk_widget_get_screen (widget));
2429 gtk_window_set_title (GTK_WINDOW (window), "resize grips");
2431 g_signal_connect (window, "destroy",
2432 G_CALLBACK (gtk_widget_destroyed),
2435 vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
2436 gtk_container_add (GTK_CONTAINER (window), vbox);
2438 hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
2439 gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 0);
2442 area = gtk_drawing_area_new ();
2443 gtk_widget_add_events (area, GDK_BUTTON_PRESS_MASK);
2444 gtk_box_pack_start (GTK_BOX (hbox), area, TRUE, TRUE, 0);
2445 g_signal_connect (area, "draw", G_CALLBACK (grippy_draw),
2446 GINT_TO_POINTER (GDK_WINDOW_EDGE_NORTH_WEST));
2447 g_signal_connect (area, "button_press_event", G_CALLBACK (grippy_button_press),
2448 GINT_TO_POINTER (GDK_WINDOW_EDGE_NORTH_WEST));
2451 area = gtk_drawing_area_new ();
2452 gtk_widget_add_events (area, GDK_BUTTON_PRESS_MASK);
2453 gtk_box_pack_start (GTK_BOX (hbox), area, TRUE, TRUE, 0);
2454 g_signal_connect (area, "draw", G_CALLBACK (grippy_draw),
2455 GINT_TO_POINTER (GDK_WINDOW_EDGE_NORTH));
2456 g_signal_connect (area, "button_press_event", G_CALLBACK (grippy_button_press),
2457 GINT_TO_POINTER (GDK_WINDOW_EDGE_NORTH));
2460 area = gtk_drawing_area_new ();
2461 gtk_widget_add_events (area, GDK_BUTTON_PRESS_MASK);
2462 gtk_box_pack_start (GTK_BOX (hbox), area, TRUE, TRUE, 0);
2463 g_signal_connect (area, "draw", G_CALLBACK (grippy_draw),
2464 GINT_TO_POINTER (GDK_WINDOW_EDGE_NORTH_EAST));
2465 g_signal_connect (area, "button_press_event", G_CALLBACK (grippy_button_press),
2466 GINT_TO_POINTER (GDK_WINDOW_EDGE_NORTH_EAST));
2468 hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
2469 gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 0);
2472 area = gtk_drawing_area_new ();
2473 gtk_widget_add_events (area, GDK_BUTTON_PRESS_MASK);
2474 gtk_box_pack_start (GTK_BOX (hbox), area, TRUE, TRUE, 0);
2475 g_signal_connect (area, "draw", G_CALLBACK (grippy_draw),
2476 GINT_TO_POINTER (GDK_WINDOW_EDGE_WEST));
2477 g_signal_connect (area, "button_press_event", G_CALLBACK (grippy_button_press),
2478 GINT_TO_POINTER (GDK_WINDOW_EDGE_WEST));
2481 area = gtk_drawing_area_new ();
2482 gtk_box_pack_start (GTK_BOX (hbox), area, TRUE, TRUE, 0);
2485 area = gtk_drawing_area_new ();
2486 gtk_widget_add_events (area, GDK_BUTTON_PRESS_MASK);
2487 gtk_box_pack_start (GTK_BOX (hbox), area, TRUE, TRUE, 0);
2488 g_signal_connect (area, "draw", G_CALLBACK (grippy_draw),
2489 GINT_TO_POINTER (GDK_WINDOW_EDGE_EAST));
2490 g_signal_connect (area, "button_press_event", G_CALLBACK (grippy_button_press),
2491 GINT_TO_POINTER (GDK_WINDOW_EDGE_EAST));
2494 hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
2495 gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 0);
2498 area = gtk_drawing_area_new ();
2499 gtk_widget_add_events (area, GDK_BUTTON_PRESS_MASK);
2500 gtk_box_pack_start (GTK_BOX (hbox), area, TRUE, TRUE, 0);
2501 g_signal_connect (area, "draw", G_CALLBACK (grippy_draw),
2502 GINT_TO_POINTER (GDK_WINDOW_EDGE_SOUTH_WEST));
2503 g_signal_connect (area, "button_press_event", G_CALLBACK (grippy_button_press),
2504 GINT_TO_POINTER (GDK_WINDOW_EDGE_SOUTH_WEST));
2506 area = gtk_drawing_area_new ();
2507 gtk_widget_add_events (area, GDK_BUTTON_PRESS_MASK);
2508 gtk_box_pack_start (GTK_BOX (hbox), area, TRUE, TRUE, 0);
2509 g_signal_connect (area, "draw", G_CALLBACK (grippy_draw),
2510 GINT_TO_POINTER (GDK_WINDOW_EDGE_SOUTH));
2511 g_signal_connect (area, "button_press_event", G_CALLBACK (grippy_button_press),
2512 GINT_TO_POINTER (GDK_WINDOW_EDGE_SOUTH));
2515 area = gtk_drawing_area_new ();
2516 gtk_widget_add_events (area, GDK_BUTTON_PRESS_MASK);
2517 gtk_box_pack_start (GTK_BOX (hbox), area, TRUE, TRUE, 0);
2518 g_signal_connect (area, "draw", G_CALLBACK (grippy_draw),
2519 GINT_TO_POINTER (GDK_WINDOW_EDGE_SOUTH_EAST));
2520 g_signal_connect (area, "button_press_event", G_CALLBACK (grippy_button_press),
2521 GINT_TO_POINTER (GDK_WINDOW_EDGE_SOUTH_EAST));
2524 if (!gtk_widget_get_visible (window))
2525 gtk_widget_show_all (window);
2527 gtk_widget_destroy (window);
2533 gint upositionx = 0;
2534 gint upositiony = 0;
2537 uposition_configure (GtkWidget *window)
2543 lx = g_object_get_data (G_OBJECT (window), "x");
2544 ly = g_object_get_data (G_OBJECT (window), "y");
2546 gdk_window_get_root_origin (gtk_widget_get_window (window),
2547 &upositionx, &upositiony);
2548 sprintf (buffer, "%d", upositionx);
2549 gtk_label_set_text (lx, buffer);
2550 sprintf (buffer, "%d", upositiony);
2551 gtk_label_set_text (ly, buffer);
2557 uposition_stop_configure (GtkToggleButton *toggle,
2560 if (gtk_toggle_button_get_active (toggle))
2561 g_signal_handlers_block_by_func (window, G_CALLBACK (uposition_configure), NULL);
2563 g_signal_handlers_unblock_by_func (window, G_CALLBACK (uposition_configure), NULL);
2567 create_saved_position (GtkWidget *widget)
2569 static GtkWidget *window = NULL;
2574 GtkWidget *main_vbox;
2582 window = g_object_connect (g_object_new (GTK_TYPE_WINDOW,
2583 "type", GTK_WINDOW_TOPLEVEL,
2584 "title", "Saved Position",
2586 "signal::configure_event", uposition_configure, NULL,
2589 gtk_window_move (GTK_WINDOW (window), upositionx, upositiony);
2591 gtk_window_set_screen (GTK_WINDOW (window),
2592 gtk_widget_get_screen (widget));
2595 g_signal_connect (window, "destroy",
2596 G_CALLBACK (gtk_widget_destroyed),
2599 main_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
2600 gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 0);
2601 gtk_container_add (GTK_CONTAINER (window), main_vbox);
2604 g_object_new (gtk_vbox_get_type (),
2605 "GtkBox::homogeneous", FALSE,
2606 "GtkBox::spacing", 5,
2607 "GtkContainer::border_width", 10,
2608 "GtkWidget::parent", main_vbox,
2609 "GtkWidget::visible", TRUE,
2610 "child", g_object_connect (g_object_new (GTK_TYPE_TOGGLE_BUTTON,
2611 "label", "Stop Events",
2615 "signal::clicked", uposition_stop_configure, window,
2619 hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
2620 gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
2621 gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0);
2623 label = gtk_label_new ("X Origin : ");
2624 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
2625 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
2627 x_label = gtk_label_new ("");
2628 gtk_box_pack_start (GTK_BOX (hbox), x_label, TRUE, TRUE, 0);
2629 g_object_set_data (G_OBJECT (window), "x", x_label);
2631 hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
2632 gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
2633 gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0);
2635 label = gtk_label_new ("Y Origin : ");
2636 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
2637 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
2639 y_label = gtk_label_new ("");
2640 gtk_box_pack_start (GTK_BOX (hbox), y_label, TRUE, TRUE, 0);
2641 g_object_set_data (G_OBJECT (window), "y", y_label);
2644 g_object_new (gtk_hseparator_get_type (),
2645 "GtkWidget::visible", TRUE,
2647 gtk_box_pack_start (GTK_BOX (main_vbox), any, FALSE, TRUE, 0);
2649 hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
2650 gtk_container_set_border_width (GTK_CONTAINER (hbox), 10);
2651 gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, TRUE, 0);
2653 button = gtk_button_new_with_label ("Close");
2654 g_signal_connect_swapped (button, "clicked",
2655 G_CALLBACK (gtk_widget_destroy),
2657 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
2658 gtk_widget_set_can_default (button, TRUE);
2659 gtk_widget_grab_default (button);
2661 gtk_widget_show_all (window);
2664 gtk_widget_destroy (window);
2672 create_pixbuf (GtkWidget *widget)
2674 static GtkWidget *window = NULL;
2680 GtkWidget *separator;
2681 GtkWidget *pixbufwid;
2682 GdkWindow *gdk_window;
2686 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
2688 gtk_window_set_screen (GTK_WINDOW (window),
2689 gtk_widget_get_screen (widget));
2691 g_signal_connect (window, "destroy",
2692 G_CALLBACK (gtk_widget_destroyed),
2695 gtk_window_set_title (GTK_WINDOW (window), "GtkPixmap");
2696 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
2697 gtk_widget_realize(window);
2699 box1 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
2700 gtk_container_add (GTK_CONTAINER (window), box1);
2702 box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10);
2703 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
2704 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
2706 button = gtk_button_new ();
2707 gtk_box_pack_start (GTK_BOX (box2), button, FALSE, FALSE, 0);
2709 gdk_window = gtk_widget_get_window (window);
2711 pixbufwid = new_pixbuf ("test.xpm", gdk_window, NULL);
2713 label = gtk_label_new ("Pixbuf\ntest");
2714 box3 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
2715 gtk_container_set_border_width (GTK_CONTAINER (box3), 2);
2716 gtk_container_add (GTK_CONTAINER (box3), pixbufwid);
2717 gtk_container_add (GTK_CONTAINER (box3), label);
2718 gtk_container_add (GTK_CONTAINER (button), box3);
2720 button = gtk_button_new ();
2721 gtk_box_pack_start (GTK_BOX (box2), button, FALSE, FALSE, 0);
2723 pixbufwid = new_pixbuf ("test.xpm", gdk_window, NULL);
2725 label = gtk_label_new ("Pixbuf\ntest");
2726 box3 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
2727 gtk_container_set_border_width (GTK_CONTAINER (box3), 2);
2728 gtk_container_add (GTK_CONTAINER (box3), pixbufwid);
2729 gtk_container_add (GTK_CONTAINER (box3), label);
2730 gtk_container_add (GTK_CONTAINER (button), box3);
2732 gtk_widget_set_sensitive (button, FALSE);
2734 separator = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
2735 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
2737 box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10);
2738 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
2739 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
2741 button = gtk_button_new_with_label ("close");
2742 g_signal_connect_swapped (button, "clicked",
2743 G_CALLBACK (gtk_widget_destroy),
2745 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
2746 gtk_widget_set_can_default (button, TRUE);
2747 gtk_widget_grab_default (button);
2750 if (!gtk_widget_get_visible (window))
2751 gtk_widget_show_all (window);
2753 gtk_widget_destroy (window);
2757 create_tooltips (GtkWidget *widget)
2759 static GtkWidget *window = NULL;
2766 GtkWidget *separator;
2771 g_object_new (gtk_window_get_type (),
2772 "GtkWindow::type", GTK_WINDOW_TOPLEVEL,
2773 "GtkContainer::border_width", 0,
2774 "GtkWindow::title", "Tooltips",
2775 "GtkWindow::resizable", FALSE,
2778 gtk_window_set_screen (GTK_WINDOW (window),
2779 gtk_widget_get_screen (widget));
2781 box1 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
2782 gtk_container_add (GTK_CONTAINER (window), box1);
2784 box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10);
2785 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
2786 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
2788 button = gtk_toggle_button_new_with_label ("button1");
2789 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
2791 gtk_widget_set_tooltip_text (button, "This is button 1");
2793 button = gtk_toggle_button_new_with_label ("button2");
2794 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
2796 gtk_widget_set_tooltip_text (button,
2797 "This is button 2. This is also a really long tooltip which probably "
2798 "won't fit on a single line and will therefore need to be wrapped. "
2799 "Hopefully the wrapping will work correctly.");
2801 toggle = gtk_toggle_button_new_with_label ("Override TipsQuery Label");
2802 gtk_box_pack_start (GTK_BOX (box2), toggle, TRUE, TRUE, 0);
2804 gtk_widget_set_tooltip_text (toggle, "Toggle TipsQuery view.");
2807 g_object_new (gtk_vbox_get_type (),
2808 "homogeneous", FALSE,
2815 g_object_new (gtk_button_get_type (),
2820 gtk_box_set_child_packing (GTK_BOX (box3), button, FALSE, FALSE, 0, GTK_PACK_START);
2821 gtk_widget_set_tooltip_text (button, "Start the Tooltips Inspector");
2823 frame = g_object_new (gtk_frame_get_type (),
2824 "label", "ToolTips Inspector",
2825 "label_xalign", (double) 0.5,
2831 gtk_box_set_child_packing (GTK_BOX (box2), frame, TRUE, TRUE, 10, GTK_PACK_START);
2833 separator = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
2834 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
2836 box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10);
2837 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
2838 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
2840 button = gtk_button_new_with_label ("close");
2841 g_signal_connect_swapped (button, "clicked",
2842 G_CALLBACK (gtk_widget_destroy),
2844 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
2845 gtk_widget_set_can_default (button, TRUE);
2846 gtk_widget_grab_default (button);
2848 gtk_widget_set_tooltip_text (button, "Push this button to close window");
2851 if (!gtk_widget_get_visible (window))
2852 gtk_widget_show_all (window);
2854 gtk_widget_destroy (window);
2862 pack_image (GtkWidget *box,
2866 gtk_box_pack_start (GTK_BOX (box),
2867 gtk_label_new (text),
2870 gtk_box_pack_start (GTK_BOX (box),
2876 create_image (GtkWidget *widget)
2878 static GtkWidget *window = NULL;
2885 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
2887 gtk_window_set_screen (GTK_WINDOW (window),
2888 gtk_widget_get_screen (widget));
2890 /* this is bogus for testing drawing when allocation < request,
2891 * don't copy into real code
2893 gtk_window_set_resizable (GTK_WINDOW (window), TRUE);
2895 g_signal_connect (window, "destroy",
2896 G_CALLBACK (gtk_widget_destroyed),
2899 vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
2901 gtk_container_add (GTK_CONTAINER (window), vbox);
2903 pack_image (vbox, "Stock Warning Dialog",
2904 gtk_image_new_from_stock (GTK_STOCK_DIALOG_WARNING,
2905 GTK_ICON_SIZE_DIALOG));
2907 pixbuf = gdk_pixbuf_new_from_xpm_data ((const char **) openfile);
2909 pack_image (vbox, "Pixbuf",
2910 gtk_image_new_from_pixbuf (pixbuf));
2912 g_object_unref (pixbuf);
2915 if (!gtk_widget_get_visible (window))
2916 gtk_widget_show_all (window);
2918 gtk_widget_destroy (window);
2926 create_menu (GdkScreen *screen, gint depth, gint length, gboolean tearoff)
2929 GtkWidget *menuitem;
2938 menu = gtk_menu_new ();
2939 gtk_menu_set_screen (GTK_MENU (menu), screen);
2945 menuitem = gtk_tearoff_menu_item_new ();
2946 gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
2947 gtk_widget_show (menuitem);
2950 image = gtk_image_new_from_stock (GTK_STOCK_OPEN,
2951 GTK_ICON_SIZE_MENU);
2952 gtk_widget_show (image);
2953 menuitem = gtk_image_menu_item_new_with_label ("Image item");
2954 gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menuitem), image);
2955 gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
2956 gtk_widget_show (menuitem);
2958 for (i = 0, j = 1; i < length; i++, j++)
2960 sprintf (buf, "item %2d - %d", depth, j);
2962 menuitem = gtk_radio_menu_item_new_with_label (group, buf);
2963 group = gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (menuitem));
2965 gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
2966 gtk_widget_show (menuitem);
2968 gtk_widget_set_sensitive (menuitem, FALSE);
2971 gtk_check_menu_item_set_inconsistent (GTK_CHECK_MENU_ITEM (menuitem),
2975 gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem),
2976 create_menu (screen, depth - 1, 5, TRUE));
2983 create_table_menu (GdkScreen *screen, gint cols, gint rows, gboolean tearoff)
2986 GtkWidget *menuitem;
2992 menu = gtk_menu_new ();
2993 gtk_menu_set_screen (GTK_MENU (menu), screen);
2998 menuitem = gtk_tearoff_menu_item_new ();
2999 gtk_menu_attach (GTK_MENU (menu), menuitem, 0, cols, j, j + 1);
3000 gtk_widget_show (menuitem);
3004 menuitem = gtk_menu_item_new_with_label ("items");
3005 gtk_menu_attach (GTK_MENU (menu), menuitem, 0, cols, j, j + 1);
3007 submenu = gtk_menu_new ();
3008 gtk_menu_set_screen (GTK_MENU (submenu), screen);
3009 gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), submenu);
3010 gtk_widget_show (menuitem);
3013 /* now fill the items submenu */
3014 image = gtk_image_new_from_stock (GTK_STOCK_HELP,
3015 GTK_ICON_SIZE_MENU);
3016 gtk_widget_show (image);
3017 menuitem = gtk_image_menu_item_new_with_label ("Image");
3018 gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menuitem), image);
3019 gtk_menu_attach (GTK_MENU (submenu), menuitem, 0, 1, 0, 1);
3020 gtk_widget_show (menuitem);
3022 menuitem = gtk_menu_item_new_with_label ("x");
3023 gtk_menu_attach (GTK_MENU (submenu), menuitem, 1, 2, 0, 1);
3024 gtk_widget_show (menuitem);
3026 menuitem = gtk_menu_item_new_with_label ("x");
3027 gtk_menu_attach (GTK_MENU (submenu), menuitem, 0, 1, 1, 2);
3028 gtk_widget_show (menuitem);
3030 image = gtk_image_new_from_stock (GTK_STOCK_HELP,
3031 GTK_ICON_SIZE_MENU);
3032 gtk_widget_show (image);
3033 menuitem = gtk_image_menu_item_new_with_label ("Image");
3034 gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menuitem), image);
3035 gtk_menu_attach (GTK_MENU (submenu), menuitem, 1, 2, 1, 2);
3036 gtk_widget_show (menuitem);
3038 menuitem = gtk_radio_menu_item_new_with_label (NULL, "Radio");
3039 gtk_menu_attach (GTK_MENU (submenu), menuitem, 0, 1, 2, 3);
3040 gtk_widget_show (menuitem);
3042 menuitem = gtk_menu_item_new_with_label ("x");
3043 gtk_menu_attach (GTK_MENU (submenu), menuitem, 1, 2, 2, 3);
3044 gtk_widget_show (menuitem);
3046 menuitem = gtk_menu_item_new_with_label ("x");
3047 gtk_menu_attach (GTK_MENU (submenu), menuitem, 0, 1, 3, 4);
3048 gtk_widget_show (menuitem);
3050 menuitem = gtk_radio_menu_item_new_with_label (NULL, "Radio");
3051 gtk_menu_attach (GTK_MENU (submenu), menuitem, 1, 2, 3, 4);
3052 gtk_widget_show (menuitem);
3054 menuitem = gtk_check_menu_item_new_with_label ("Check");
3055 gtk_menu_attach (GTK_MENU (submenu), menuitem, 0, 1, 4, 5);
3056 gtk_widget_show (menuitem);
3058 menuitem = gtk_menu_item_new_with_label ("x");
3059 gtk_menu_attach (GTK_MENU (submenu), menuitem, 1, 2, 4, 5);
3060 gtk_widget_show (menuitem);
3062 menuitem = gtk_menu_item_new_with_label ("x");
3063 gtk_menu_attach (GTK_MENU (submenu), menuitem, 0, 1, 5, 6);
3064 gtk_widget_show (menuitem);
3066 menuitem = gtk_check_menu_item_new_with_label ("Check");
3067 gtk_menu_attach (GTK_MENU (submenu), menuitem, 1, 2, 5, 6);
3068 gtk_widget_show (menuitem);
3070 menuitem = gtk_menu_item_new_with_label ("1. Inserted normally (8)");
3071 gtk_widget_show (menuitem);
3072 gtk_menu_shell_insert (GTK_MENU_SHELL (submenu), menuitem, 8);
3074 menuitem = gtk_menu_item_new_with_label ("2. Inserted normally (2)");
3075 gtk_widget_show (menuitem);
3076 gtk_menu_shell_insert (GTK_MENU_SHELL (submenu), menuitem, 2);
3078 menuitem = gtk_menu_item_new_with_label ("3. Inserted normally (0)");
3079 gtk_widget_show (menuitem);
3080 gtk_menu_shell_insert (GTK_MENU_SHELL (submenu), menuitem, 0);
3082 menuitem = gtk_menu_item_new_with_label ("4. Inserted normally (-1)");
3083 gtk_widget_show (menuitem);
3084 gtk_menu_shell_insert (GTK_MENU_SHELL (submenu), menuitem, -1);
3086 /* end of items submenu */
3088 menuitem = gtk_menu_item_new_with_label ("spanning");
3089 gtk_menu_attach (GTK_MENU (menu), menuitem, 0, cols, j, j + 1);
3091 submenu = gtk_menu_new ();
3092 gtk_menu_set_screen (GTK_MENU (submenu), screen);
3093 gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), submenu);
3094 gtk_widget_show (menuitem);
3097 /* now fill the spanning submenu */
3098 menuitem = gtk_menu_item_new_with_label ("a");
3099 gtk_menu_attach (GTK_MENU (submenu), menuitem, 0, 2, 0, 1);
3100 gtk_widget_show (menuitem);
3102 menuitem = gtk_menu_item_new_with_label ("b");
3103 gtk_menu_attach (GTK_MENU (submenu), menuitem, 2, 3, 0, 2);
3104 gtk_widget_show (menuitem);
3106 menuitem = gtk_menu_item_new_with_label ("c");
3107 gtk_menu_attach (GTK_MENU (submenu), menuitem, 0, 1, 1, 3);
3108 gtk_widget_show (menuitem);
3110 menuitem = gtk_menu_item_new_with_label ("d");
3111 gtk_menu_attach (GTK_MENU (submenu), menuitem, 1, 2, 1, 2);
3112 gtk_widget_show (menuitem);
3114 menuitem = gtk_menu_item_new_with_label ("e");
3115 gtk_menu_attach (GTK_MENU (submenu), menuitem, 1, 3, 2, 3);
3116 gtk_widget_show (menuitem);
3117 /* end of spanning submenu */
3119 menuitem = gtk_menu_item_new_with_label ("left");
3120 gtk_menu_attach (GTK_MENU (menu), menuitem, 0, 1, j, j + 1);
3121 submenu = gtk_menu_new ();
3122 gtk_menu_set_screen (GTK_MENU (submenu), screen);
3123 gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), submenu);
3124 gtk_widget_show (menuitem);
3126 menuitem = gtk_menu_item_new_with_label ("Empty");
3127 gtk_menu_attach (GTK_MENU (submenu), menuitem, 0, 1, 0, 1);
3128 submenu = gtk_menu_new ();
3129 gtk_menu_set_screen (GTK_MENU (submenu), screen);
3130 gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), submenu);
3131 gtk_widget_show (menuitem);
3133 menuitem = gtk_menu_item_new_with_label ("right");
3134 gtk_menu_attach (GTK_MENU (menu), menuitem, 1, 2, j, j + 1);
3135 submenu = gtk_menu_new ();
3136 gtk_menu_set_screen (GTK_MENU (submenu), screen);
3137 gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), submenu);
3138 gtk_widget_show (menuitem);
3140 menuitem = gtk_menu_item_new_with_label ("Empty");
3141 gtk_menu_attach (GTK_MENU (submenu), menuitem, 0, 1, 0, 1);
3142 gtk_widget_show (menuitem);
3146 for (; j < rows; j++)
3147 for (i = 0; i < cols; i++)
3149 sprintf (buf, "(%d %d)", i, j);
3150 menuitem = gtk_menu_item_new_with_label (buf);
3151 gtk_menu_attach (GTK_MENU (menu), menuitem, i, i + 1, j, j + 1);
3152 gtk_widget_show (menuitem);
3155 menuitem = gtk_menu_item_new_with_label ("1. Inserted normally (8)");
3156 gtk_menu_shell_insert (GTK_MENU_SHELL (menu), menuitem, 8);
3157 gtk_widget_show (menuitem);
3158 menuitem = gtk_menu_item_new_with_label ("2. Inserted normally (2)");
3159 gtk_menu_shell_insert (GTK_MENU_SHELL (menu), menuitem, 2);
3160 gtk_widget_show (menuitem);
3161 menuitem = gtk_menu_item_new_with_label ("3. Inserted normally (0)");
3162 gtk_menu_shell_insert (GTK_MENU_SHELL (menu), menuitem, 0);
3163 gtk_widget_show (menuitem);
3164 menuitem = gtk_menu_item_new_with_label ("4. Inserted normally (-1)");
3165 gtk_menu_shell_insert (GTK_MENU_SHELL (menu), menuitem, -1);
3166 gtk_widget_show (menuitem);
3172 create_menus (GtkWidget *widget)
3174 static GtkWidget *window = NULL;
3178 GtkWidget *optionmenu;
3179 GtkWidget *separator;
3185 GtkWidget *menuitem;
3186 GtkAccelGroup *accel_group;
3188 GdkScreen *screen = gtk_widget_get_screen (widget);
3190 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
3192 gtk_window_set_screen (GTK_WINDOW (window), screen);
3194 g_signal_connect (window, "destroy",
3195 G_CALLBACK (gtk_widget_destroyed),
3197 g_signal_connect (window, "delete-event",
3198 G_CALLBACK (gtk_true),
3201 accel_group = gtk_accel_group_new ();
3202 gtk_window_add_accel_group (GTK_WINDOW (window), accel_group);
3204 gtk_window_set_title (GTK_WINDOW (window), "menus");
3205 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
3208 box1 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
3209 gtk_container_add (GTK_CONTAINER (window), box1);
3210 gtk_widget_show (box1);
3212 menubar = gtk_menu_bar_new ();
3213 gtk_box_pack_start (GTK_BOX (box1), menubar, FALSE, TRUE, 0);
3214 gtk_widget_show (menubar);
3216 menu = create_menu (screen, 2, 50, TRUE);
3218 menuitem = gtk_menu_item_new_with_label ("test\nline2");
3219 gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), menu);
3220 gtk_menu_shell_append (GTK_MENU_SHELL (menubar), menuitem);
3221 gtk_widget_show (menuitem);
3223 menu = create_table_menu (screen, 2, 50, TRUE);
3225 menuitem = gtk_menu_item_new_with_label ("table");
3226 gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), menu);
3227 gtk_menu_shell_append (GTK_MENU_SHELL (menubar), menuitem);
3228 gtk_widget_show (menuitem);
3230 menuitem = gtk_menu_item_new_with_label ("foo");
3231 gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), create_menu (screen, 3, 5, TRUE));
3232 gtk_menu_shell_append (GTK_MENU_SHELL (menubar), menuitem);
3233 gtk_widget_show (menuitem);
3235 image = gtk_image_new_from_stock (GTK_STOCK_HELP,
3236 GTK_ICON_SIZE_MENU);
3237 gtk_widget_show (image);
3238 menuitem = gtk_image_menu_item_new_with_label ("Help");
3239 gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menuitem), image);
3240 gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), create_menu (screen, 4, 5, TRUE));
3241 gtk_menu_item_set_right_justified (GTK_MENU_ITEM (menuitem), TRUE);
3242 gtk_menu_shell_append (GTK_MENU_SHELL (menubar), menuitem);
3243 gtk_widget_show (menuitem);
3245 menubar = gtk_menu_bar_new ();
3246 gtk_box_pack_start (GTK_BOX (box1), menubar, FALSE, TRUE, 0);
3247 gtk_widget_show (menubar);
3249 menu = create_menu (screen, 2, 10, TRUE);
3251 menuitem = gtk_menu_item_new_with_label ("Second menu bar");
3252 gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), menu);
3253 gtk_menu_shell_append (GTK_MENU_SHELL (menubar), menuitem);
3254 gtk_widget_show (menuitem);
3256 box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10);
3257 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
3258 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
3259 gtk_widget_show (box2);
3261 menu = create_menu (screen, 1, 5, FALSE);
3262 gtk_menu_set_accel_group (GTK_MENU (menu), accel_group);
3264 menuitem = gtk_image_menu_item_new_from_stock (GTK_STOCK_NEW, accel_group);
3265 gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
3266 gtk_widget_show (menuitem);
3268 menuitem = gtk_check_menu_item_new_with_label ("Accelerate Me");
3269 gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
3270 gtk_widget_show (menuitem);
3271 gtk_widget_add_accelerator (menuitem,
3277 menuitem = gtk_check_menu_item_new_with_label ("Accelerator Locked");
3278 gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
3279 gtk_widget_show (menuitem);
3280 gtk_widget_add_accelerator (menuitem,
3285 GTK_ACCEL_VISIBLE | GTK_ACCEL_LOCKED);
3286 menuitem = gtk_check_menu_item_new_with_label ("Accelerators Frozen");
3287 gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
3288 gtk_widget_show (menuitem);
3289 gtk_widget_add_accelerator (menuitem,
3295 gtk_widget_add_accelerator (menuitem,
3302 optionmenu = gtk_combo_box_text_new ();
3303 gtk_combo_box_set_active (GTK_COMBO_BOX (optionmenu), 3);
3304 gtk_box_pack_start (GTK_BOX (box2), optionmenu, TRUE, TRUE, 0);
3305 gtk_widget_show (optionmenu);
3307 separator = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
3308 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
3309 gtk_widget_show (separator);
3311 box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10);
3312 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
3313 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
3314 gtk_widget_show (box2);
3316 button = gtk_button_new_with_label ("close");
3317 g_signal_connect_swapped (button, "clicked",
3318 G_CALLBACK (gtk_widget_destroy),
3320 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
3321 gtk_widget_set_can_default (button, TRUE);
3322 gtk_widget_grab_default (button);
3323 gtk_widget_show (button);
3326 if (!gtk_widget_get_visible (window))
3327 gtk_widget_show (window);
3329 gtk_widget_destroy (window);
3332 /* GdkPixbuf RGBA C-Source image dump */
3334 static const guint8 apple[] =
3336 /* Pixbuf magic (0x47646b50) */
3338 /* length: header (24) + pixel_data (2304) */
3340 /* pixdata_type (0x1010002) */
3342 /* rowstride (96) */
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\0\0"
3355 "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\26\24"
3356 "\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"
3357 "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`m"
3358 "[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"
3359 "\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"
3360 "\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"
3361 "\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"
3362 "\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"
3363 "\0\0\0\0\0\0`l\\\20iw_\356y\211h\373x\207g\364~\216i\364u\204e\366gt"
3364 "_\374^jX\241A;-_\0\0\0~\0\0\0\0SM4)SM21B9&\22\320\270\204\1\320\270\204"
3365 "\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"
3366 "]\212r\200c\366v\205f\371jx_\323_kY\232_kZH^jY\26]iW\211@G9\272:6%j\220"
3367 "\211]\320\221\211`\377\212\203Z\377~xP\377mkE\331]^;|/0\37\21\0\0\0\0"
3368 "\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["
3369 "eT<\216\200Z\203\227\211_\354\234\217c\377\232\217b\362\232\220c\337"
3370 "\243\233k\377\252\241p\377\250\236p\377\241\225h\377\231\214_\377\210"
3371 "\202U\377srI\377[]:\355KO0U\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0i"
3372 "v^\200`lY\211^jY\"\0\0\0\0\221\204\\\273\250\233r\377\302\267\224\377"
3373 "\311\300\237\377\272\256\204\377\271\256\177\377\271\257\200\377\267"
3374 "\260\177\377\260\251x\377\250\236l\377\242\225e\377\226\213]\377~zP\377"
3375 "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"
3376 "\0\213\203[v\253\240t\377\334\326\301\377\344\340\317\377\321\312\253"
3377 "\377\303\271\217\377\300\270\213\377\277\267\210\377\272\264\203\377"
3378 "\261\255z\377\250\242n\377\243\232h\377\232\220`\377\210\202V\377nnE"
3379 "\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"
3380 "\234\222e\362\304\274\232\377\337\333\306\377\332\325\273\377\311\302"
3381 "\232\377\312\303\236\377\301\273\216\377\300\271\212\377\270\264\200"
3382 "\377\256\253v\377\246\243n\377\236\232h\377\230\220`\377\213\203V\377"
3383 "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"
3384 "\203Zl\242\234l\377\321\315\260\377\331\324\271\377\320\313\251\377\307"
3385 "\301\232\377\303\276\224\377\300\272\214\377\274\267\206\377\264\260"
3386 "|\377\253\251s\377\244\243n\377\232\230e\377\223\216^\377\207\200U\377"
3387 "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"
3388 "\210\204Y\240\245\237o\377\316\310\253\377\310\303\237\377\304\300\230"
3389 "\377\303\277\225\377\277\272\216\377\274\270\210\377\266\263\200\377"
3390 "\256\254v\377\247\246p\377\237\236j\377\227\226d\377\215\212[\377\203"
3391 "\177T\377qsH\377X]8\377FN.\377DK-\200\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
3392 "\0\0\0\0\207\204X\257\244\240o\377\300\275\231\377\301\275\226\377\274"
3393 "\270\213\377\274\270\214\377\267\264\205\377\264\262\200\377\260\256"
3394 "z\377\251\251s\377\243\244n\377\231\232g\377\220\222`\377\210\211Y\377"
3395 "|}Q\377hlC\377PU3\377CK,\377DL/Y\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
3396 "\0\0\205\204X\220\232\230h\377\261\260\204\377\266\264\212\377\261\260"
3397 "\201\377\263\260\200\377\260\257}\377\256\256x\377\253\254t\377\244\246"
3398 "o\377\233\236i\377\221\224b\377\211\214\\\377\202\204V\377txM\377]b>"
3399 "\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>"
3400 "\215\215_\377\237\237r\377\247\247x\377\247\247t\377\252\252w\377\252"
3401 "\252u\377\252\253t\377\243\246o\377\235\240j\377\223\230c\377\213\217"
3402 "]\377\201\206V\377x}P\377gkD\377RY5\377BI,\377AI,\262\0\0\0\0\0\0\0\0"
3403 "\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"
3404 "\232g\377\234\236i\377\236\241l\377\241\244n\377\240\244m\377\232\237"
3405 "i\377\223\230c\377\212\221]\377\200\210W\377v|P\377jnG\377Za>\377HP2"
3406 "\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"
3407 "\0wzQ6\177\201U\371\206\211Z\377\216\222`\377\220\225a\377\220\225b\377"
3408 "\220\226a\377\213\221_\377\204\213Z\377{\203R\377ryN\377iqH\377^fA\377"
3409 "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"
3410 "\0\0\0\0\0\0\0\0\0\0\0\0ptJTw|Q\371z\177R\377}\202T\377|\203T\377z\200"
3411 "R\377v|O\377pwL\377jpF\377dlB\377`hB\377Yb@\377LT6\377<C*\377\11\12\6"
3412 "\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"
3413 "\0\0\0\0\0\0\0\0\0\0\\`=UgnE\370hnG\377gmE\377djB\377]d>\377[c<\377Y"
3414 "b<\377Zc>\377V_>\377OW8\377BK/\377\16\20\12\377\0\0\0\377\0\0\0\377\0"
3415 "\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"
3416 "\0\1\0\0\0\40\22\24\15\260@D+\377W`;\377OV5\377.3\36\377.3\37\377IP0"
3417 "\377RZ7\377PZ8\3776=&\377\14\15\10\377\0\0\0\377\0\0\0\377\0\0\0\377"
3418 "\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"
3419 "\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"
3420 "\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"
3421 "\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"
3422 "\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"
3423 "\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"
3424 "\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"
3425 "\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"
3426 "\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"
3427 "\0\0\5\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"};
3431 accel_button_new (GtkAccelGroup *accel_group,
3436 GdkModifierType modifiers;
3440 gtk_accelerator_parse (accel, &keyval, &modifiers);
3443 button = gtk_button_new ();
3444 gtk_widget_add_accelerator (button, "activate", accel_group,
3445 keyval, modifiers, GTK_ACCEL_VISIBLE | GTK_ACCEL_LOCKED);
3447 label = gtk_accel_label_new (text);
3448 gtk_accel_label_set_accel_widget (GTK_ACCEL_LABEL (label), button);
3449 gtk_widget_show (label);
3451 gtk_container_add (GTK_CONTAINER (button), label);
3457 create_key_lookup (GtkWidget *widget)
3459 static GtkWidget *window = NULL;
3460 gpointer window_ptr;
3464 GtkAccelGroup *accel_group = gtk_accel_group_new ();
3466 GtkWidget *content_area;
3468 window = gtk_dialog_new_with_buttons ("Key Lookup", NULL, 0,
3469 GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE,
3472 gtk_window_set_screen (GTK_WINDOW (window),
3473 gtk_widget_get_screen (widget));
3475 /* We have to expand it so the accel labels will draw their labels
3477 gtk_window_set_default_size (GTK_WINDOW (window), 300, -1);
3479 gtk_window_add_accel_group (GTK_WINDOW (window), accel_group);
3481 content_area = gtk_dialog_get_content_area (GTK_DIALOG (window));
3483 button = gtk_button_new_with_mnemonic ("Button 1 (_a)");
3484 gtk_box_pack_start (GTK_BOX (content_area), button, FALSE, FALSE, 0);
3485 button = gtk_button_new_with_mnemonic ("Button 2 (_A)");
3486 gtk_box_pack_start (GTK_BOX (content_area), button, FALSE, FALSE, 0);
3487 button = gtk_button_new_with_mnemonic ("Button 3 (_\321\204)");
3488 gtk_box_pack_start (GTK_BOX (content_area), button, FALSE, FALSE, 0);
3489 button = gtk_button_new_with_mnemonic ("Button 4 (_\320\244)");
3490 gtk_box_pack_start (GTK_BOX (content_area), button, FALSE, FALSE, 0);
3491 button = gtk_button_new_with_mnemonic ("Button 6 (_b)");
3492 gtk_box_pack_start (GTK_BOX (content_area), button, FALSE, FALSE, 0);
3493 button = accel_button_new (accel_group, "Button 7", "<Alt><Shift>b");
3494 gtk_box_pack_start (GTK_BOX (content_area), button, FALSE, FALSE, 0);
3495 button = accel_button_new (accel_group, "Button 8", "<Alt>d");
3496 gtk_box_pack_start (GTK_BOX (content_area), button, FALSE, FALSE, 0);
3497 button = accel_button_new (accel_group, "Button 9", "<Alt>Cyrillic_ve");
3498 gtk_box_pack_start (GTK_BOX (content_area), button, FALSE, FALSE, 0);
3499 button = gtk_button_new_with_mnemonic ("Button 10 (_1)");
3500 gtk_box_pack_start (GTK_BOX (content_area), button, FALSE, FALSE, 0);
3501 button = gtk_button_new_with_mnemonic ("Button 11 (_!)");
3502 gtk_box_pack_start (GTK_BOX (content_area), button, FALSE, FALSE, 0);
3503 button = accel_button_new (accel_group, "Button 12", "<Super>a");
3504 gtk_box_pack_start (GTK_BOX (content_area), button, FALSE, FALSE, 0);
3505 button = accel_button_new (accel_group, "Button 13", "<Hyper>a");
3506 gtk_box_pack_start (GTK_BOX (content_area), button, FALSE, FALSE, 0);
3507 button = accel_button_new (accel_group, "Button 14", "<Meta>a");
3508 gtk_box_pack_start (GTK_BOX (content_area), button, FALSE, FALSE, 0);
3509 button = accel_button_new (accel_group, "Button 15", "<Shift><Mod4>b");
3510 gtk_box_pack_start (GTK_BOX (content_area), button, FALSE, FALSE, 0);
3512 window_ptr = &window;
3513 g_object_add_weak_pointer (G_OBJECT (window), window_ptr);
3514 g_signal_connect (window, "response", G_CALLBACK (gtk_widget_destroy), NULL);
3516 gtk_widget_show_all (window);
3519 gtk_widget_destroy (window);
3528 cmw_destroy_cb(GtkWidget *widget)
3530 /* This is needed to get out of gtk_main */
3537 cmw_color (GtkWidget *widget, GtkWidget *parent)
3540 GtkWidget *colorsel;
3541 GtkWidget *ok_button, *cancel_button;
3543 csd = gtk_color_selection_dialog_new ("This is a modal color selection dialog");
3545 gtk_window_set_screen (GTK_WINDOW (csd), gtk_widget_get_screen (parent));
3547 colorsel = gtk_color_selection_dialog_get_color_selection (GTK_COLOR_SELECTION_DIALOG (csd));
3548 gtk_color_selection_set_has_palette (GTK_COLOR_SELECTION (colorsel),
3552 gtk_window_set_modal (GTK_WINDOW(csd),TRUE);
3554 /* And mark it as a transient dialog */
3555 gtk_window_set_transient_for (GTK_WINDOW (csd), GTK_WINDOW (parent));
3557 g_signal_connect (csd, "destroy",
3558 G_CALLBACK (cmw_destroy_cb), NULL);
3561 "ok-button", &ok_button,
3562 "cancel-button", &cancel_button,
3565 g_signal_connect_swapped (ok_button,
3566 "clicked", G_CALLBACK (gtk_widget_destroy), csd);
3567 g_signal_connect_swapped (cancel_button,
3568 "clicked", G_CALLBACK (gtk_widget_destroy), csd);
3570 /* wait until destroy calls gtk_main_quit */
3571 gtk_widget_show (csd);
3576 cmw_file (GtkWidget *widget, GtkWidget *parent)
3580 fs = gtk_file_chooser_dialog_new ("This is a modal file selection dialog",
3581 GTK_WINDOW (parent), GTK_FILE_CHOOSER_ACTION_OPEN,
3582 GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
3583 GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
3585 gtk_window_set_screen (GTK_WINDOW (fs), gtk_widget_get_screen (parent));
3586 gtk_window_set_modal (GTK_WINDOW (fs), TRUE);
3588 g_signal_connect (fs, "destroy",
3589 G_CALLBACK (cmw_destroy_cb), NULL);
3590 g_signal_connect_swapped (fs, "response",
3591 G_CALLBACK (gtk_widget_destroy), fs);
3593 /* wait until destroy calls gtk_main_quit */
3594 gtk_widget_show (fs);
3600 create_modal_window (GtkWidget *widget)
3602 GtkWidget *window = NULL;
3603 GtkWidget *box1,*box2;
3605 GtkWidget *btnColor,*btnFile,*btnClose;
3607 /* Create modal window (Here you can use any window descendent )*/
3608 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
3609 gtk_window_set_screen (GTK_WINDOW (window),
3610 gtk_widget_get_screen (widget));
3612 gtk_window_set_title (GTK_WINDOW(window),"This window is modal");
3614 /* Set window as modal */
3615 gtk_window_set_modal (GTK_WINDOW(window),TRUE);
3617 /* Create widgets */
3618 box1 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
3619 frame1 = gtk_frame_new ("Standard dialogs in modal form");
3620 box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
3621 gtk_box_set_homogeneous (GTK_BOX (box2), TRUE);
3622 btnColor = gtk_button_new_with_label ("Color");
3623 btnFile = gtk_button_new_with_label ("File Selection");
3624 btnClose = gtk_button_new_with_label ("Close");
3627 gtk_container_set_border_width (GTK_CONTAINER (box1), 3);
3628 gtk_container_set_border_width (GTK_CONTAINER (box2), 3);
3631 gtk_container_add (GTK_CONTAINER (window), box1);
3632 gtk_box_pack_start (GTK_BOX (box1), frame1, TRUE, TRUE, 4);
3633 gtk_container_add (GTK_CONTAINER (frame1), box2);
3634 gtk_box_pack_start (GTK_BOX (box2), btnColor, FALSE, FALSE, 4);
3635 gtk_box_pack_start (GTK_BOX (box2), btnFile, FALSE, FALSE, 4);
3636 gtk_box_pack_start (GTK_BOX (box1), gtk_separator_new (GTK_ORIENTATION_HORIZONTAL), FALSE, FALSE, 4);
3637 gtk_box_pack_start (GTK_BOX (box1), btnClose, FALSE, FALSE, 4);
3639 /* connect signals */
3640 g_signal_connect_swapped (btnClose, "clicked",
3641 G_CALLBACK (gtk_widget_destroy), window);
3643 g_signal_connect (window, "destroy",
3644 G_CALLBACK (cmw_destroy_cb), NULL);
3646 g_signal_connect (btnColor, "clicked",
3647 G_CALLBACK (cmw_color), window);
3648 g_signal_connect (btnFile, "clicked",
3649 G_CALLBACK (cmw_file), window);
3652 gtk_widget_show_all (window);
3654 /* wait until dialog get destroyed */
3663 make_message_dialog (GdkScreen *screen,
3665 GtkMessageType type,
3666 GtkButtonsType buttons,
3667 guint default_response)
3671 gtk_widget_destroy (*dialog);
3676 *dialog = gtk_message_dialog_new (NULL, 0, type, buttons,
3677 "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.)");
3679 gtk_window_set_screen (GTK_WINDOW (*dialog), screen);
3681 g_signal_connect_swapped (*dialog,
3683 G_CALLBACK (gtk_widget_destroy),
3686 g_signal_connect (*dialog,
3688 G_CALLBACK (gtk_widget_destroyed),
3691 gtk_dialog_set_default_response (GTK_DIALOG (*dialog), default_response);
3693 gtk_widget_show (*dialog);
3697 create_message_dialog (GtkWidget *widget)
3699 static GtkWidget *info = NULL;
3700 static GtkWidget *warning = NULL;
3701 static GtkWidget *error = NULL;
3702 static GtkWidget *question = NULL;
3703 GdkScreen *screen = gtk_widget_get_screen (widget);
3705 make_message_dialog (screen, &info, GTK_MESSAGE_INFO, GTK_BUTTONS_OK, GTK_RESPONSE_OK);
3706 make_message_dialog (screen, &warning, GTK_MESSAGE_WARNING, GTK_BUTTONS_CLOSE, GTK_RESPONSE_CLOSE);
3707 make_message_dialog (screen, &error, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK_CANCEL, GTK_RESPONSE_OK);
3708 make_message_dialog (screen, &question, GTK_MESSAGE_QUESTION, GTK_BUTTONS_YES_NO, GTK_RESPONSE_NO);
3715 static GtkWidget *sw_parent = NULL;
3716 static GtkWidget *sw_float_parent;
3717 static gulong sw_destroyed_handler = 0;
3720 scrolled_windows_delete_cb (GtkWidget *widget, GdkEventAny *event, GtkWidget *scrollwin)
3722 gtk_widget_reparent (scrollwin, sw_parent);
3724 g_signal_handler_disconnect (sw_parent, sw_destroyed_handler);
3725 sw_float_parent = NULL;
3727 sw_destroyed_handler = 0;
3733 scrolled_windows_destroy_cb (GtkWidget *widget, GtkWidget *scrollwin)
3735 gtk_widget_destroy (sw_float_parent);
3737 sw_float_parent = NULL;
3739 sw_destroyed_handler = 0;
3743 scrolled_windows_remove (GtkWidget *widget, GtkWidget *scrollwin)
3747 gtk_widget_reparent (scrollwin, sw_parent);
3748 gtk_widget_destroy (sw_float_parent);
3750 g_signal_handler_disconnect (sw_parent, sw_destroyed_handler);
3751 sw_float_parent = NULL;
3753 sw_destroyed_handler = 0;
3757 sw_parent = gtk_widget_get_parent (scrollwin);
3758 sw_float_parent = gtk_window_new (GTK_WINDOW_TOPLEVEL);
3759 gtk_window_set_screen (GTK_WINDOW (sw_float_parent),
3760 gtk_widget_get_screen (widget));
3762 gtk_window_set_default_size (GTK_WINDOW (sw_float_parent), 200, 200);
3764 gtk_widget_reparent (scrollwin, sw_float_parent);
3765 gtk_widget_show (sw_float_parent);
3767 sw_destroyed_handler =
3768 g_signal_connect (sw_parent, "destroy",
3769 G_CALLBACK (scrolled_windows_destroy_cb), scrollwin);
3770 g_signal_connect (sw_float_parent, "delete_event",
3771 G_CALLBACK (scrolled_windows_delete_cb), scrollwin);
3776 create_scrolled_windows (GtkWidget *widget)
3778 static GtkWidget *window;
3779 GtkWidget *content_area, *action_area;
3780 GtkWidget *scrolled_window;
3788 window = gtk_dialog_new ();
3790 gtk_window_set_screen (GTK_WINDOW (window),
3791 gtk_widget_get_screen (widget));
3793 g_signal_connect (window, "destroy",
3794 G_CALLBACK (gtk_widget_destroyed),
3797 content_area = gtk_dialog_get_content_area (GTK_DIALOG (window));
3798 action_area = gtk_dialog_get_action_area (GTK_DIALOG (window));
3800 gtk_window_set_title (GTK_WINDOW (window), "dialog");
3801 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
3803 scrolled_window = gtk_scrolled_window_new (NULL, NULL);
3804 gtk_container_set_border_width (GTK_CONTAINER (scrolled_window), 10);
3805 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
3806 GTK_POLICY_AUTOMATIC,
3807 GTK_POLICY_AUTOMATIC);
3808 gtk_box_pack_start (GTK_BOX (content_area), scrolled_window, TRUE, TRUE, 0);
3809 gtk_widget_show (scrolled_window);
3811 table = gtk_table_new (20, 20, FALSE);
3812 gtk_table_set_row_spacings (GTK_TABLE (table), 10);
3813 gtk_table_set_col_spacings (GTK_TABLE (table), 10);
3814 gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (scrolled_window), table);
3815 gtk_container_set_focus_hadjustment (GTK_CONTAINER (table),
3816 gtk_scrolled_window_get_hadjustment (GTK_SCROLLED_WINDOW (scrolled_window)));
3817 gtk_container_set_focus_vadjustment (GTK_CONTAINER (table),
3818 gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (scrolled_window)));
3819 gtk_widget_show (table);
3821 for (i = 0; i < 20; i++)
3822 for (j = 0; j < 20; j++)
3824 sprintf (buffer, "button (%d,%d)\n", i, j);
3825 button = gtk_toggle_button_new_with_label (buffer);
3826 gtk_table_attach_defaults (GTK_TABLE (table), button,
3828 gtk_widget_show (button);
3832 button = gtk_button_new_with_label ("Close");
3833 g_signal_connect_swapped (button, "clicked",
3834 G_CALLBACK (gtk_widget_destroy),
3836 gtk_widget_set_can_default (button, TRUE);
3837 gtk_box_pack_start (GTK_BOX (action_area), button, TRUE, TRUE, 0);
3838 gtk_widget_grab_default (button);
3839 gtk_widget_show (button);
3841 button = gtk_button_new_with_label ("Reparent Out");
3842 g_signal_connect (button, "clicked",
3843 G_CALLBACK (scrolled_windows_remove),
3845 gtk_widget_set_can_default (button, TRUE);
3846 gtk_box_pack_start (GTK_BOX (action_area), button, TRUE, TRUE, 0);
3847 gtk_widget_grab_default (button);
3848 gtk_widget_show (button);
3850 gtk_window_set_default_size (GTK_WINDOW (window), 300, 300);
3853 if (!gtk_widget_get_visible (window))
3854 gtk_widget_show (window);
3856 gtk_widget_destroy (window);
3864 entry_toggle_frame (GtkWidget *checkbutton,
3867 gtk_entry_set_has_frame (GTK_ENTRY(entry),
3868 gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (checkbutton)));
3872 entry_toggle_sensitive (GtkWidget *checkbutton,
3875 gtk_widget_set_sensitive (entry,
3876 gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON(checkbutton)));
3880 entry_progress_timeout (gpointer data)
3882 if (GPOINTER_TO_INT (g_object_get_data (G_OBJECT (data), "progress-pulse")))
3884 gtk_entry_progress_pulse (GTK_ENTRY (data));
3890 fraction = gtk_entry_get_progress_fraction (GTK_ENTRY (data));
3893 if (fraction > 1.0001)
3896 gtk_entry_set_progress_fraction (GTK_ENTRY (data), fraction);
3903 entry_remove_timeout (gpointer data)
3905 g_source_remove (GPOINTER_TO_UINT (data));
3909 entry_toggle_progress (GtkWidget *checkbutton,
3912 if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (checkbutton)))
3914 guint timeout = gdk_threads_add_timeout (100,
3915 entry_progress_timeout,
3917 g_object_set_data_full (G_OBJECT (entry), "timeout-id",
3918 GUINT_TO_POINTER (timeout),
3919 entry_remove_timeout);
3923 g_object_set_data (G_OBJECT (entry), "timeout-id",
3924 GUINT_TO_POINTER (0));
3926 gtk_entry_set_progress_fraction (GTK_ENTRY (entry), 0.0);
3931 entry_toggle_pulse (GtkWidget *checkbutton,
3934 g_object_set_data (G_OBJECT (entry), "progress-pulse",
3935 GUINT_TO_POINTER ((guint) gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (checkbutton))));
3939 props_clicked (GtkWidget *button,
3942 GtkWidget *window = create_prop_editor (object, 0);
3944 gtk_window_set_title (GTK_WINDOW (window), "Object Properties");
3948 create_entry (GtkWidget *widget)
3950 static GtkWidget *window = NULL;
3954 GtkWidget *has_frame_check;
3955 GtkWidget *sensitive_check;
3956 GtkWidget *progress_check;
3958 GtkComboBoxText *cb;
3959 GtkWidget *cb_entry;
3961 GtkWidget *separator;
3965 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
3966 gtk_window_set_screen (GTK_WINDOW (window),
3967 gtk_widget_get_screen (widget));
3969 g_signal_connect (window, "destroy",
3970 G_CALLBACK (gtk_widget_destroyed),
3973 gtk_window_set_title (GTK_WINDOW (window), "entry");
3974 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
3977 box1 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
3978 gtk_container_add (GTK_CONTAINER (window), box1);
3981 box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10);
3982 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
3983 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
3985 hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 5);
3986 gtk_box_pack_start (GTK_BOX (box2), hbox, TRUE, TRUE, 0);
3988 entry = gtk_entry_new ();
3989 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");
3990 gtk_editable_select_region (GTK_EDITABLE (entry), 0, 5);
3991 gtk_box_pack_start (GTK_BOX (hbox), entry, TRUE, TRUE, 0);
3993 button = gtk_button_new_with_mnemonic ("_Props");
3994 gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0);
3995 g_signal_connect (button, "clicked",
3996 G_CALLBACK (props_clicked),
3999 cb = GTK_COMBO_BOX_TEXT (gtk_combo_box_text_new_with_entry ());
4001 gtk_combo_box_text_append_text (cb, "item0");
4002 gtk_combo_box_text_append_text (cb, "item0");
4003 gtk_combo_box_text_append_text (cb, "item1 item1");
4004 gtk_combo_box_text_append_text (cb, "item2 item2 item2");
4005 gtk_combo_box_text_append_text (cb, "item3 item3 item3 item3");
4006 gtk_combo_box_text_append_text (cb, "item4 item4 item4 item4 item4");
4007 gtk_combo_box_text_append_text (cb, "item5 item5 item5 item5 item5 item5");
4008 gtk_combo_box_text_append_text (cb, "item6 item6 item6 item6 item6");
4009 gtk_combo_box_text_append_text (cb, "item7 item7 item7 item7");
4010 gtk_combo_box_text_append_text (cb, "item8 item8 item8");
4011 gtk_combo_box_text_append_text (cb, "item9 item9");
4013 cb_entry = gtk_bin_get_child (GTK_BIN (cb));
4014 gtk_entry_set_text (GTK_ENTRY (cb_entry), "hello world \n\n\n foo");
4015 gtk_editable_select_region (GTK_EDITABLE (cb_entry), 0, -1);
4016 gtk_box_pack_start (GTK_BOX (box2), GTK_WIDGET (cb), TRUE, TRUE, 0);
4018 sensitive_check = gtk_check_button_new_with_label("Sensitive");
4019 gtk_box_pack_start (GTK_BOX (box2), sensitive_check, FALSE, TRUE, 0);
4020 g_signal_connect (sensitive_check, "toggled",
4021 G_CALLBACK (entry_toggle_sensitive), entry);
4022 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (sensitive_check), TRUE);
4024 has_frame_check = gtk_check_button_new_with_label("Has Frame");
4025 gtk_box_pack_start (GTK_BOX (box2), has_frame_check, FALSE, TRUE, 0);
4026 g_signal_connect (has_frame_check, "toggled",
4027 G_CALLBACK (entry_toggle_frame), entry);
4028 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (has_frame_check), TRUE);
4030 progress_check = gtk_check_button_new_with_label("Show Progress");
4031 gtk_box_pack_start (GTK_BOX (box2), progress_check, FALSE, TRUE, 0);
4032 g_signal_connect (progress_check, "toggled",
4033 G_CALLBACK (entry_toggle_progress), entry);
4035 progress_check = gtk_check_button_new_with_label("Pulse Progress");
4036 gtk_box_pack_start (GTK_BOX (box2), progress_check, FALSE, TRUE, 0);
4037 g_signal_connect (progress_check, "toggled",
4038 G_CALLBACK (entry_toggle_pulse), entry);
4040 separator = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
4041 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
4043 box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10);
4044 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
4045 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
4047 button = gtk_button_new_with_label ("close");
4048 g_signal_connect_swapped (button, "clicked",
4049 G_CALLBACK (gtk_widget_destroy),
4051 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
4052 gtk_widget_set_can_default (button, TRUE);
4053 gtk_widget_grab_default (button);
4056 if (!gtk_widget_get_visible (window))
4057 gtk_widget_show_all (window);
4059 gtk_widget_destroy (window);
4063 create_expander (GtkWidget *widget)
4066 GtkWidget *expander;
4068 static GtkWidget *window = NULL;
4072 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
4073 gtk_window_set_screen (GTK_WINDOW (window),
4074 gtk_widget_get_screen (widget));
4076 g_signal_connect (window, "destroy",
4077 G_CALLBACK (gtk_widget_destroyed),
4080 gtk_window_set_title (GTK_WINDOW (window), "expander");
4081 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
4083 box1 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
4084 gtk_container_add (GTK_CONTAINER (window), box1);
4086 expander = gtk_expander_new ("The Hidden");
4088 gtk_box_pack_start (GTK_BOX (box1), expander, TRUE, TRUE, 0);
4090 hidden = gtk_label_new ("Revealed!");
4092 gtk_container_add (GTK_CONTAINER (expander), hidden);
4095 if (!gtk_widget_get_visible (window))
4096 gtk_widget_show_all (window);
4098 gtk_widget_destroy (window);
4106 event_box_label_pressed (GtkWidget *widget,
4107 GdkEventButton *event,
4110 g_print ("clicked on event box\n");
4114 event_box_button_clicked (GtkWidget *widget,
4118 g_print ("pushed button\n");
4122 event_box_toggle_visible_window (GtkWidget *checkbutton,
4123 GtkEventBox *event_box)
4125 gtk_event_box_set_visible_window (event_box,
4126 gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (checkbutton)));
4130 event_box_toggle_above_child (GtkWidget *checkbutton,
4131 GtkEventBox *event_box)
4133 gtk_event_box_set_above_child (event_box,
4134 gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (checkbutton)));
4138 create_event_box (GtkWidget *widget)
4140 static GtkWidget *window = NULL;
4146 GtkWidget *separator;
4147 GtkWidget *event_box;
4149 GtkWidget *visible_window_check;
4150 GtkWidget *above_child_check;
4159 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
4160 gtk_window_set_screen (GTK_WINDOW (window),
4161 gtk_widget_get_screen (widget));
4163 g_signal_connect (window, "destroy",
4164 G_CALLBACK (gtk_widget_destroyed),
4167 gtk_window_set_title (GTK_WINDOW (window), "event box");
4168 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
4170 box1 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
4171 gtk_container_add (GTK_CONTAINER (window), box1);
4172 gtk_widget_modify_bg (window, GTK_STATE_NORMAL, &color);
4174 hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
4175 gtk_box_pack_start (GTK_BOX (box1), hbox, TRUE, FALSE, 0);
4177 event_box = gtk_event_box_new ();
4178 gtk_box_pack_start (GTK_BOX (hbox), event_box, TRUE, FALSE, 0);
4180 vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
4181 gtk_container_add (GTK_CONTAINER (event_box), vbox);
4182 g_signal_connect (event_box, "button_press_event",
4183 G_CALLBACK (event_box_label_pressed),
4186 label = gtk_label_new ("Click on this label");
4187 gtk_box_pack_start (GTK_BOX (vbox), label, TRUE, FALSE, 0);
4189 button = gtk_button_new_with_label ("button in eventbox");
4190 gtk_box_pack_start (GTK_BOX (vbox), button, TRUE, FALSE, 0);
4191 g_signal_connect (button, "clicked",
4192 G_CALLBACK (event_box_button_clicked),
4196 visible_window_check = gtk_check_button_new_with_label("Visible Window");
4197 gtk_box_pack_start (GTK_BOX (box1), visible_window_check, FALSE, TRUE, 0);
4198 g_signal_connect (visible_window_check, "toggled",
4199 G_CALLBACK (event_box_toggle_visible_window), event_box);
4200 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (visible_window_check), FALSE);
4202 above_child_check = gtk_check_button_new_with_label("Above Child");
4203 gtk_box_pack_start (GTK_BOX (box1), above_child_check, FALSE, TRUE, 0);
4204 g_signal_connect (above_child_check, "toggled",
4205 G_CALLBACK (event_box_toggle_above_child), event_box);
4206 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (above_child_check), FALSE);
4208 separator = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
4209 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
4211 box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10);
4212 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
4213 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
4215 button = gtk_button_new_with_label ("close");
4216 g_signal_connect_swapped (button, "clicked",
4217 G_CALLBACK (gtk_widget_destroy),
4219 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
4220 gtk_widget_set_can_default (button, TRUE);
4221 gtk_widget_grab_default (button);
4224 if (!gtk_widget_get_visible (window))
4225 gtk_widget_show_all (window);
4227 gtk_widget_destroy (window);
4235 #define SIZE_GROUP_INITIAL_SIZE 50
4238 size_group_hsize_changed (GtkSpinButton *spin_button,
4241 gtk_widget_set_size_request (gtk_bin_get_child (GTK_BIN (button)),
4242 gtk_spin_button_get_value_as_int (spin_button),
4247 size_group_vsize_changed (GtkSpinButton *spin_button,
4250 gtk_widget_set_size_request (gtk_bin_get_child (GTK_BIN (button)),
4252 gtk_spin_button_get_value_as_int (spin_button));
4256 create_size_group_window (GdkScreen *screen,
4257 GtkSizeGroup *master_size_group)
4259 GtkWidget *content_area;
4262 GtkWidget *main_button;
4264 GtkWidget *spin_button;
4266 GtkSizeGroup *hgroup1;
4267 GtkSizeGroup *hgroup2;
4268 GtkSizeGroup *vgroup1;
4269 GtkSizeGroup *vgroup2;
4271 window = gtk_dialog_new_with_buttons ("GtkSizeGroup",
4277 gtk_window_set_screen (GTK_WINDOW (window), screen);
4279 gtk_window_set_resizable (GTK_WINDOW (window), TRUE);
4281 g_signal_connect (window, "response",
4282 G_CALLBACK (gtk_widget_destroy),
4285 content_area = gtk_dialog_get_content_area (GTK_DIALOG (window));
4287 table = gtk_table_new (2, 2, FALSE);
4288 gtk_box_pack_start (GTK_BOX (content_area), table, TRUE, TRUE, 0);
4290 gtk_table_set_row_spacings (GTK_TABLE (table), 5);
4291 gtk_table_set_col_spacings (GTK_TABLE (table), 5);
4292 gtk_container_set_border_width (GTK_CONTAINER (table), 5);
4293 gtk_widget_set_size_request (table, 250, 250);
4295 hgroup1 = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
4296 hgroup2 = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
4297 vgroup1 = gtk_size_group_new (GTK_SIZE_GROUP_VERTICAL);
4298 vgroup2 = gtk_size_group_new (GTK_SIZE_GROUP_VERTICAL);
4300 main_button = gtk_button_new_with_label ("X");
4302 gtk_table_attach (GTK_TABLE (table), main_button,
4304 GTK_EXPAND, GTK_EXPAND,
4306 gtk_size_group_add_widget (master_size_group, main_button);
4307 gtk_size_group_add_widget (hgroup1, main_button);
4308 gtk_size_group_add_widget (vgroup1, main_button);
4309 gtk_widget_set_size_request (gtk_bin_get_child (GTK_BIN (main_button)),
4310 SIZE_GROUP_INITIAL_SIZE,
4311 SIZE_GROUP_INITIAL_SIZE);
4313 button = gtk_button_new ();
4314 gtk_table_attach (GTK_TABLE (table), button,
4316 GTK_EXPAND, GTK_EXPAND,
4318 gtk_size_group_add_widget (vgroup1, button);
4319 gtk_size_group_add_widget (vgroup2, button);
4321 button = gtk_button_new ();
4322 gtk_table_attach (GTK_TABLE (table), button,
4324 GTK_EXPAND, GTK_EXPAND,
4326 gtk_size_group_add_widget (hgroup1, button);
4327 gtk_size_group_add_widget (hgroup2, button);
4329 button = gtk_button_new ();
4330 gtk_table_attach (GTK_TABLE (table), button,
4332 GTK_EXPAND, GTK_EXPAND,
4334 gtk_size_group_add_widget (hgroup2, button);
4335 gtk_size_group_add_widget (vgroup2, button);
4337 g_object_unref (hgroup1);
4338 g_object_unref (hgroup2);
4339 g_object_unref (vgroup1);
4340 g_object_unref (vgroup2);
4342 hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 5);
4343 gtk_box_pack_start (GTK_BOX (content_area), hbox, FALSE, FALSE, 0);
4345 spin_button = gtk_spin_button_new_with_range (1, 100, 1);
4346 gtk_spin_button_set_value (GTK_SPIN_BUTTON (spin_button), SIZE_GROUP_INITIAL_SIZE);
4347 gtk_box_pack_start (GTK_BOX (hbox), spin_button, TRUE, TRUE, 0);
4348 g_signal_connect (spin_button, "value_changed",
4349 G_CALLBACK (size_group_hsize_changed), main_button);
4351 spin_button = gtk_spin_button_new_with_range (1, 100, 1);
4352 gtk_spin_button_set_value (GTK_SPIN_BUTTON (spin_button), SIZE_GROUP_INITIAL_SIZE);
4353 gtk_box_pack_start (GTK_BOX (hbox), spin_button, TRUE, TRUE, 0);
4354 g_signal_connect (spin_button, "value_changed",
4355 G_CALLBACK (size_group_vsize_changed), main_button);
4361 create_size_groups (GtkWidget *widget)
4363 static GtkWidget *window1 = NULL;
4364 static GtkWidget *window2 = NULL;
4365 static GtkSizeGroup *master_size_group;
4367 if (!master_size_group)
4368 master_size_group = gtk_size_group_new (GTK_SIZE_GROUP_BOTH);
4372 window1 = create_size_group_window (gtk_widget_get_screen (widget),
4375 g_signal_connect (window1, "destroy",
4376 G_CALLBACK (gtk_widget_destroyed),
4382 window2 = create_size_group_window (gtk_widget_get_screen (widget),
4385 g_signal_connect (window2, "destroy",
4386 G_CALLBACK (gtk_widget_destroyed),
4390 if (gtk_widget_get_visible (window1) && gtk_widget_get_visible (window2))
4392 gtk_widget_destroy (window1);
4393 gtk_widget_destroy (window2);
4397 if (!gtk_widget_get_visible (window1))
4398 gtk_widget_show_all (window1);
4399 if (!gtk_widget_get_visible (window2))
4400 gtk_widget_show_all (window2);
4408 static GtkWidget *spinner1;
4411 toggle_snap (GtkWidget *widget, GtkSpinButton *spin)
4413 gtk_spin_button_set_snap_to_ticks (spin,
4414 gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget)));
4418 toggle_numeric (GtkWidget *widget, GtkSpinButton *spin)
4420 gtk_spin_button_set_numeric (spin,
4421 gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget)));
4425 change_digits (GtkWidget *widget, GtkSpinButton *spin)
4427 gtk_spin_button_set_digits (GTK_SPIN_BUTTON (spinner1),
4428 gtk_spin_button_get_value_as_int (spin));
4432 get_value (GtkWidget *widget, gpointer data)
4436 GtkSpinButton *spin;
4438 spin = GTK_SPIN_BUTTON (spinner1);
4439 label = GTK_LABEL (g_object_get_data (G_OBJECT (widget), "user_data"));
4440 if (GPOINTER_TO_INT (data) == 1)
4441 sprintf (buf, "%d", gtk_spin_button_get_value_as_int (spin));
4443 sprintf (buf, "%0.*f",
4444 gtk_spin_button_get_digits (spin),
4445 gtk_spin_button_get_value (spin));
4447 gtk_label_set_text (label, buf);
4451 get_spin_value (GtkWidget *widget, gpointer data)
4455 GtkSpinButton *spin;
4457 spin = GTK_SPIN_BUTTON (widget);
4458 label = GTK_LABEL (data);
4460 buffer = g_strdup_printf ("%0.*f",
4461 gtk_spin_button_get_digits (spin),
4462 gtk_spin_button_get_value (spin));
4463 gtk_label_set_text (label, buffer);
4469 spin_button_time_output_func (GtkSpinButton *spin_button)
4471 GtkAdjustment *adjustment;
4472 static gchar buf[6];
4476 adjustment = gtk_spin_button_get_adjustment (spin_button);
4477 hours = gtk_adjustment_get_value (adjustment) / 60.0;
4478 minutes = (fabs(floor (hours) - hours) < 1e-5) ? 0.0 : 30;
4479 sprintf (buf, "%02.0f:%02.0f", floor (hours), minutes);
4480 if (strcmp (buf, gtk_entry_get_text (GTK_ENTRY (spin_button))))
4481 gtk_entry_set_text (GTK_ENTRY (spin_button), buf);
4486 spin_button_month_input_func (GtkSpinButton *spin_button,
4490 static gchar *month[12] = { "January", "February", "March", "April",
4491 "May", "June", "July", "August",
4492 "September", "October", "November", "December" };
4494 gboolean found = FALSE;
4496 for (i = 1; i <= 12; i++)
4498 tmp1 = g_ascii_strup (month[i - 1], -1);
4499 tmp2 = g_ascii_strup (gtk_entry_get_text (GTK_ENTRY (spin_button)), -1);
4500 if (strstr (tmp1, tmp2) == tmp1)
4510 return GTK_INPUT_ERROR;
4512 *new_val = (gdouble) i;
4517 spin_button_month_output_func (GtkSpinButton *spin_button)
4519 GtkAdjustment *adjustment;
4522 static gchar *month[12] = { "January", "February", "March", "April",
4523 "May", "June", "July", "August", "September",
4524 "October", "November", "December" };
4526 adjustment = gtk_spin_button_get_adjustment (spin_button);
4527 value = gtk_adjustment_get_value (adjustment);
4528 for (i = 1; i <= 12; i++)
4529 if (fabs (value - (double)i) < 1e-5)
4531 if (strcmp (month[i-1], gtk_entry_get_text (GTK_ENTRY (spin_button))))
4532 gtk_entry_set_text (GTK_ENTRY (spin_button), month[i-1]);
4538 spin_button_hex_input_func (GtkSpinButton *spin_button,
4545 buf = gtk_entry_get_text (GTK_ENTRY (spin_button));
4546 res = strtol(buf, &err, 16);
4549 return GTK_INPUT_ERROR;
4555 spin_button_hex_output_func (GtkSpinButton *spin_button)
4557 GtkAdjustment *adjustment;
4558 static gchar buf[7];
4561 adjustment = gtk_spin_button_get_adjustment (spin_button);
4562 val = (gint) gtk_adjustment_get_value (adjustment);
4563 if (fabs (val) < 1e-5)
4564 sprintf (buf, "0x00");
4566 sprintf (buf, "0x%.2X", val);
4567 if (strcmp (buf, gtk_entry_get_text (GTK_ENTRY (spin_button))))
4568 gtk_entry_set_text (GTK_ENTRY (spin_button), buf);
4573 create_spins (GtkWidget *widget)
4575 static GtkWidget *window = NULL;
4578 GtkWidget *main_vbox;
4581 GtkWidget *spinner2;
4585 GtkWidget *val_label;
4590 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
4591 gtk_window_set_screen (GTK_WINDOW (window),
4592 gtk_widget_get_screen (widget));
4594 g_signal_connect (window, "destroy",
4595 G_CALLBACK (gtk_widget_destroyed),
4598 gtk_window_set_title (GTK_WINDOW (window), "GtkSpinButton");
4600 main_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
4601 gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 10);
4602 gtk_container_add (GTK_CONTAINER (window), main_vbox);
4604 frame = gtk_frame_new ("Not accelerated");
4605 gtk_box_pack_start (GTK_BOX (main_vbox), frame, TRUE, TRUE, 0);
4607 vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
4608 gtk_container_set_border_width (GTK_CONTAINER (vbox), 5);
4609 gtk_container_add (GTK_CONTAINER (frame), vbox);
4611 /* Time, month, hex spinners */
4613 hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
4614 gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 5);
4616 vbox2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
4617 gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 5);
4619 label = gtk_label_new ("Time :");
4620 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
4621 gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, TRUE, 0);
4623 adj = gtk_adjustment_new (0, 0, 1410, 30, 60, 0);
4624 spinner = gtk_spin_button_new (adj, 0, 0);
4625 gtk_editable_set_editable (GTK_EDITABLE (spinner), FALSE);
4626 g_signal_connect (spinner,
4628 G_CALLBACK (spin_button_time_output_func),
4630 gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spinner), TRUE);
4631 gtk_entry_set_width_chars (GTK_ENTRY (spinner), 5);
4632 gtk_box_pack_start (GTK_BOX (vbox2), spinner, FALSE, TRUE, 0);
4634 vbox2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
4635 gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 5);
4637 label = gtk_label_new ("Month :");
4638 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
4639 gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, TRUE, 0);
4641 adj = gtk_adjustment_new (1.0, 1.0, 12.0, 1.0,
4643 spinner = gtk_spin_button_new (adj, 0, 0);
4644 gtk_spin_button_set_update_policy (GTK_SPIN_BUTTON (spinner),
4645 GTK_UPDATE_IF_VALID);
4646 g_signal_connect (spinner,
4648 G_CALLBACK (spin_button_month_input_func),
4650 g_signal_connect (spinner,
4652 G_CALLBACK (spin_button_month_output_func),
4654 gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spinner), TRUE);
4655 gtk_entry_set_width_chars (GTK_ENTRY (spinner), 9);
4656 gtk_box_pack_start (GTK_BOX (vbox2), spinner, FALSE, TRUE, 0);
4658 vbox2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
4659 gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 5);
4661 label = gtk_label_new ("Hex :");
4662 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
4663 gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, TRUE, 0);
4665 adj = gtk_adjustment_new (0, 0, 255, 1, 16, 0);
4666 spinner = gtk_spin_button_new (adj, 0, 0);
4667 gtk_editable_set_editable (GTK_EDITABLE (spinner), TRUE);
4668 g_signal_connect (spinner,
4670 G_CALLBACK (spin_button_hex_input_func),
4672 g_signal_connect (spinner,
4674 G_CALLBACK (spin_button_hex_output_func),
4676 gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spinner), TRUE);
4677 gtk_entry_set_width_chars (GTK_ENTRY (spinner), 4);
4678 gtk_box_pack_start (GTK_BOX (vbox2), spinner, FALSE, TRUE, 0);
4680 frame = gtk_frame_new ("Accelerated");
4681 gtk_box_pack_start (GTK_BOX (main_vbox), frame, TRUE, TRUE, 0);
4683 vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
4684 gtk_container_set_border_width (GTK_CONTAINER (vbox), 5);
4685 gtk_container_add (GTK_CONTAINER (frame), vbox);
4687 hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
4688 gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 5);
4690 vbox2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
4691 gtk_box_pack_start (GTK_BOX (hbox), vbox2, FALSE, FALSE, 5);
4693 label = gtk_label_new ("Value :");
4694 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
4695 gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, TRUE, 0);
4697 adj = gtk_adjustment_new (0.0, -10000.0, 10000.0,
4699 spinner1 = gtk_spin_button_new (adj, 1.0, 2);
4700 gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spinner1), TRUE);
4701 gtk_box_pack_start (GTK_BOX (vbox2), spinner1, FALSE, TRUE, 0);
4703 vbox2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
4704 gtk_box_pack_start (GTK_BOX (hbox), vbox2, FALSE, FALSE, 5);
4706 label = gtk_label_new ("Digits :");
4707 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
4708 gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, TRUE, 0);
4710 adj = gtk_adjustment_new (2, 1, 15, 1, 1, 0);
4711 spinner2 = gtk_spin_button_new (adj, 0.0, 0);
4712 g_signal_connect (adj, "value_changed",
4713 G_CALLBACK (change_digits),
4715 gtk_box_pack_start (GTK_BOX (vbox2), spinner2, FALSE, TRUE, 0);
4717 hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
4718 gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 5);
4720 button = gtk_check_button_new_with_label ("Snap to 0.5-ticks");
4721 g_signal_connect (button, "clicked",
4722 G_CALLBACK (toggle_snap),
4724 gtk_box_pack_start (GTK_BOX (vbox), button, TRUE, TRUE, 0);
4725 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
4727 button = gtk_check_button_new_with_label ("Numeric only input mode");
4728 g_signal_connect (button, "clicked",
4729 G_CALLBACK (toggle_numeric),
4731 gtk_box_pack_start (GTK_BOX (vbox), button, TRUE, TRUE, 0);
4732 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
4734 val_label = gtk_label_new ("");
4736 hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
4737 gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 5);
4739 button = gtk_button_new_with_label ("Value as Int");
4740 g_object_set_data (G_OBJECT (button), "user_data", val_label);
4741 g_signal_connect (button, "clicked",
4742 G_CALLBACK (get_value),
4743 GINT_TO_POINTER (1));
4744 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
4746 button = gtk_button_new_with_label ("Value as Float");
4747 g_object_set_data (G_OBJECT (button), "user_data", val_label);
4748 g_signal_connect (button, "clicked",
4749 G_CALLBACK (get_value),
4750 GINT_TO_POINTER (2));
4751 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
4753 gtk_box_pack_start (GTK_BOX (vbox), val_label, TRUE, TRUE, 0);
4754 gtk_label_set_text (GTK_LABEL (val_label), "0");
4756 frame = gtk_frame_new ("Using Convenience Constructor");
4757 gtk_box_pack_start (GTK_BOX (main_vbox), frame, TRUE, TRUE, 0);
4759 hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
4760 gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
4761 gtk_container_add (GTK_CONTAINER (frame), hbox);
4763 val_label = gtk_label_new ("0.0");
4765 spinner = gtk_spin_button_new_with_range (0.0, 10.0, 0.009);
4766 gtk_spin_button_set_value (GTK_SPIN_BUTTON (spinner), 0.0);
4767 g_signal_connect (spinner, "value_changed",
4768 G_CALLBACK (get_spin_value), val_label);
4769 gtk_box_pack_start (GTK_BOX (hbox), spinner, TRUE, TRUE, 5);
4770 gtk_box_pack_start (GTK_BOX (hbox), val_label, TRUE, TRUE, 5);
4772 hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
4773 gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, TRUE, 0);
4775 button = gtk_button_new_with_label ("Close");
4776 g_signal_connect_swapped (button, "clicked",
4777 G_CALLBACK (gtk_widget_destroy),
4779 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
4782 if (!gtk_widget_get_visible (window))
4783 gtk_widget_show_all (window);
4785 gtk_widget_destroy (window);
4794 cursor_draw (GtkWidget *widget,
4800 width = gtk_widget_get_allocated_width (widget);
4801 height = gtk_widget_get_allocated_height (widget);
4803 cairo_set_source_rgb (cr, 1, 1, 1);
4804 cairo_rectangle (cr, 0, 0, width, height / 2);
4807 cairo_set_source_rgb (cr, 0, 0, 0);
4808 cairo_rectangle (cr, 0, height / 2, width, height / 2);
4811 gdk_cairo_set_source_color (cr, >k_widget_get_style (widget)->bg[GTK_STATE_NORMAL]);
4812 cairo_rectangle (cr, width / 3, height / 3, width / 3, height / 3);
4819 set_cursor (GtkWidget *spinner,
4828 c = CLAMP (gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (spinner)), 0, 152);
4831 label = g_object_get_data (G_OBJECT (spinner), "user_data");
4833 class = g_type_class_ref (GDK_TYPE_CURSOR_TYPE);
4834 vals = class->values;
4836 while (vals && vals->value != c)
4839 gtk_label_set_text (GTK_LABEL (label), vals->value_nick);
4841 gtk_label_set_text (GTK_LABEL (label), "<unknown>");
4843 g_type_class_unref (class);
4845 cursor = gdk_cursor_new_for_display (gtk_widget_get_display (widget), c);
4846 gdk_window_set_cursor (gtk_widget_get_window (widget),
4848 gdk_cursor_unref (cursor);
4852 cursor_event (GtkWidget *widget,
4854 GtkSpinButton *spinner)
4856 if ((event->type == GDK_BUTTON_PRESS) &&
4857 ((event->button.button == 1) ||
4858 (event->button.button == 3)))
4860 gtk_spin_button_spin (spinner, event->button.button == 1 ?
4861 GTK_SPIN_STEP_FORWARD : GTK_SPIN_STEP_BACKWARD, 0);
4868 #ifdef GDK_WINDOWING_X11
4869 #include "x11/gdkx.h"
4872 change_cursor_theme (GtkWidget *widget,
4879 children = gtk_container_get_children (GTK_CONTAINER (data));
4881 theme = gtk_entry_get_text (GTK_ENTRY (children->next->data));
4882 size = (gint) gtk_spin_button_get_value (GTK_SPIN_BUTTON (children->next->next->data));
4884 g_list_free (children);
4886 gdk_x11_display_set_cursor_theme (gtk_widget_get_display (widget),
4893 create_cursors (GtkWidget *widget)
4895 static GtkWidget *window = NULL;
4898 GtkWidget *main_vbox;
4911 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
4912 gtk_window_set_screen (GTK_WINDOW (window),
4913 gtk_widget_get_screen (widget));
4915 g_signal_connect (window, "destroy",
4916 G_CALLBACK (gtk_widget_destroyed),
4919 gtk_window_set_title (GTK_WINDOW (window), "Cursors");
4921 main_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
4922 gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 0);
4923 gtk_container_add (GTK_CONTAINER (window), main_vbox);
4926 g_object_new (gtk_vbox_get_type (),
4927 "GtkBox::homogeneous", FALSE,
4928 "GtkBox::spacing", 5,
4929 "GtkContainer::border_width", 10,
4930 "GtkWidget::parent", main_vbox,
4931 "GtkWidget::visible", TRUE,
4934 #ifdef GDK_WINDOWING_X11
4935 hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
4936 gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
4937 gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0);
4939 label = gtk_label_new ("Cursor Theme : ");
4940 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
4941 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
4943 entry = gtk_entry_new ();
4944 gtk_entry_set_text (GTK_ENTRY (entry), "default");
4945 gtk_box_pack_start (GTK_BOX (hbox), entry, FALSE, TRUE, 0);
4947 size = gtk_spin_button_new_with_range (1.0, 64.0, 1.0);
4948 gtk_spin_button_set_value (GTK_SPIN_BUTTON (size), 24.0);
4949 gtk_box_pack_start (GTK_BOX (hbox), size, TRUE, TRUE, 0);
4951 g_signal_connect (entry, "changed",
4952 G_CALLBACK (change_cursor_theme), hbox);
4953 g_signal_connect (size, "changed",
4954 G_CALLBACK (change_cursor_theme), hbox);
4957 hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
4958 gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
4959 gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0);
4961 label = gtk_label_new ("Cursor Value : ");
4962 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
4963 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
4965 adj = gtk_adjustment_new (0,
4969 spinner = gtk_spin_button_new (adj, 0, 0);
4970 gtk_box_pack_start (GTK_BOX (hbox), spinner, TRUE, TRUE, 0);
4973 g_object_new (gtk_frame_get_type (),
4974 "GtkFrame::label_xalign", 0.5,
4975 "GtkFrame::label", "Cursor Area",
4976 "GtkContainer::border_width", 10,
4977 "GtkWidget::parent", vbox,
4978 "GtkWidget::visible", TRUE,
4981 darea = gtk_drawing_area_new ();
4982 gtk_widget_set_size_request (darea, 80, 80);
4983 gtk_container_add (GTK_CONTAINER (frame), darea);
4984 g_signal_connect (darea,
4986 G_CALLBACK (cursor_draw),
4988 gtk_widget_set_events (darea, GDK_EXPOSURE_MASK | GDK_BUTTON_PRESS_MASK);
4989 g_signal_connect (darea,
4990 "button_press_event",
4991 G_CALLBACK (cursor_event),
4993 gtk_widget_show (darea);
4995 g_signal_connect (spinner, "changed",
4996 G_CALLBACK (set_cursor),
4999 label = g_object_new (GTK_TYPE_LABEL,
5004 gtk_container_child_set (GTK_CONTAINER (vbox), label,
5007 g_object_set_data (G_OBJECT (spinner), "user_data", label);
5010 g_object_new (gtk_hseparator_get_type (),
5011 "GtkWidget::visible", TRUE,
5013 gtk_box_pack_start (GTK_BOX (main_vbox), any, FALSE, TRUE, 0);
5015 hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
5016 gtk_container_set_border_width (GTK_CONTAINER (hbox), 10);
5017 gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, TRUE, 0);
5019 button = gtk_button_new_with_label ("Close");
5020 g_signal_connect_swapped (button, "clicked",
5021 G_CALLBACK (gtk_widget_destroy),
5023 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
5025 gtk_widget_show_all (window);
5027 set_cursor (spinner, darea);
5030 gtk_widget_destroy (window);
5038 color_selection_ok (GtkWidget *w,
5039 GtkColorSelectionDialog *cs)
5041 GtkWidget *colorsel;
5044 colorsel = gtk_color_selection_dialog_get_color_selection (cs);
5046 gtk_color_selection_get_current_color (GTK_COLOR_SELECTION (colorsel), &color);
5047 gtk_color_selection_set_current_color (GTK_COLOR_SELECTION (colorsel), &color);
5051 color_selection_changed (GtkWidget *w,
5052 GtkColorSelectionDialog *cs)
5054 GtkWidget *colorsel;
5057 colorsel = gtk_color_selection_dialog_get_color_selection (cs);
5058 gtk_color_selection_get_current_color (GTK_COLOR_SELECTION (colorsel), &color);
5059 gtk_color_selection_set_current_color (GTK_COLOR_SELECTION (colorsel), &color);
5064 opacity_toggled_cb (GtkWidget *w,
5065 GtkColorSelectionDialog *cs)
5067 GtkColorSelection *colorsel;
5069 colorsel = GTK_COLOR_SELECTION (cs->colorsel);
5070 gtk_color_selection_set_has_opacity_control (colorsel,
5071 gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (w)));
5075 palette_toggled_cb (GtkWidget *w,
5076 GtkColorSelectionDialog *cs)
5078 GtkColorSelection *colorsel;
5080 colorsel = GTK_COLOR_SELECTION (cs->colorsel);
5081 gtk_color_selection_set_has_palette (colorsel,
5082 gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (w)));
5087 create_color_selection (GtkWidget *widget)
5089 static GtkWidget *window = NULL;
5098 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
5099 gtk_window_set_screen (GTK_WINDOW (window),
5100 gtk_widget_get_screen (widget));
5102 g_signal_connect (window, "destroy",
5103 G_CALLBACK (gtk_widget_destroyed),
5106 gtk_window_set_title (GTK_WINDOW (window), "GtkColorButton");
5107 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
5109 hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 8);
5110 gtk_container_set_border_width (GTK_CONTAINER (hbox), 8);
5111 gtk_container_add (GTK_CONTAINER (window), hbox);
5113 label = gtk_label_new ("Pick a color");
5114 gtk_container_add (GTK_CONTAINER (hbox), label);
5116 picker = gtk_color_button_new ();
5117 gtk_color_button_set_use_alpha (GTK_COLOR_BUTTON (picker), TRUE);
5118 gtk_container_add (GTK_CONTAINER (hbox), picker);
5120 button = gtk_button_new_with_mnemonic ("_Props");
5121 gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0);
5122 g_signal_connect (button, "clicked",
5123 G_CALLBACK (props_clicked),
5127 if (!gtk_widget_get_visible (window))
5128 gtk_widget_show_all (window);
5130 gtk_widget_destroy (window);
5134 flipping_toggled_cb (GtkWidget *widget, gpointer data)
5136 int state = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget));
5137 int new_direction = state ? GTK_TEXT_DIR_RTL : GTK_TEXT_DIR_LTR;
5139 gtk_widget_set_default_direction (new_direction);
5143 orientable_toggle_orientation (GtkOrientable *orientable)
5145 GtkOrientation orientation;
5147 orientation = gtk_orientable_get_orientation (orientable);
5148 gtk_orientable_set_orientation (orientable,
5149 orientation == GTK_ORIENTATION_HORIZONTAL ?
5150 GTK_ORIENTATION_VERTICAL :
5151 GTK_ORIENTATION_HORIZONTAL);
5153 if (GTK_IS_CONTAINER (orientable))
5158 children = gtk_container_get_children (GTK_CONTAINER (orientable));
5160 for (child = children; child; child = child->next)
5162 if (GTK_IS_ORIENTABLE (child->data))
5163 orientable_toggle_orientation (child->data);
5166 g_list_free (children);
5171 flipping_orientation_toggled_cb (GtkWidget *widget, gpointer data)
5173 GtkWidget *content_area;
5174 GtkWidget *toplevel;
5176 toplevel = gtk_widget_get_toplevel (widget);
5177 content_area = gtk_dialog_get_content_area (GTK_DIALOG (toplevel));
5178 orientable_toggle_orientation (GTK_ORIENTABLE (content_area));
5182 set_direction_recurse (GtkWidget *widget,
5185 GtkTextDirection *dir = data;
5187 gtk_widget_set_direction (widget, *dir);
5188 if (GTK_IS_CONTAINER (widget))
5189 gtk_container_foreach (GTK_CONTAINER (widget),
5190 set_direction_recurse,
5195 create_forward_back (const char *title,
5196 GtkTextDirection text_dir)
5198 GtkWidget *frame = gtk_frame_new (title);
5199 GtkWidget *bbox = gtk_button_box_new (GTK_ORIENTATION_HORIZONTAL);
5200 GtkWidget *back_button = gtk_button_new_from_stock (GTK_STOCK_GO_BACK);
5201 GtkWidget *forward_button = gtk_button_new_from_stock (GTK_STOCK_GO_FORWARD);
5203 gtk_container_set_border_width (GTK_CONTAINER (bbox), 5);
5205 gtk_container_add (GTK_CONTAINER (frame), bbox);
5206 gtk_container_add (GTK_CONTAINER (bbox), back_button);
5207 gtk_container_add (GTK_CONTAINER (bbox), forward_button);
5209 set_direction_recurse (frame, &text_dir);
5215 create_flipping (GtkWidget *widget)
5217 static GtkWidget *window = NULL;
5218 GtkWidget *check_button, *button;
5219 GtkWidget *action_area, *content_area;
5223 window = gtk_dialog_new ();
5225 gtk_window_set_screen (GTK_WINDOW (window),
5226 gtk_widget_get_screen (widget));
5228 g_signal_connect (window, "destroy",
5229 G_CALLBACK (gtk_widget_destroyed),
5232 content_area = gtk_dialog_get_content_area (GTK_DIALOG (window));
5233 action_area = gtk_dialog_get_action_area (GTK_DIALOG (window));
5235 gtk_window_set_title (GTK_WINDOW (window), "Bidirectional Flipping");
5237 check_button = gtk_check_button_new_with_label ("Right-to-left global direction");
5238 gtk_container_set_border_width (GTK_CONTAINER (check_button), 10);
5239 gtk_box_pack_start (GTK_BOX (content_area), check_button, TRUE, TRUE, 0);
5241 if (gtk_widget_get_default_direction () == GTK_TEXT_DIR_RTL)
5242 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check_button), TRUE);
5244 g_signal_connect (check_button, "toggled",
5245 G_CALLBACK (flipping_toggled_cb), NULL);
5247 check_button = gtk_check_button_new_with_label ("Toggle orientation of all boxes");
5248 gtk_container_set_border_width (GTK_CONTAINER (check_button), 10);
5249 gtk_box_pack_start (GTK_BOX (content_area), check_button, TRUE, TRUE, 0);
5251 g_signal_connect (check_button, "toggled",
5252 G_CALLBACK (flipping_orientation_toggled_cb), NULL);
5254 gtk_box_pack_start (GTK_BOX (content_area),
5255 create_forward_back ("Default", GTK_TEXT_DIR_NONE),
5258 gtk_box_pack_start (GTK_BOX (content_area),
5259 create_forward_back ("Left-to-Right", GTK_TEXT_DIR_LTR),
5262 gtk_box_pack_start (GTK_BOX (content_area),
5263 create_forward_back ("Right-to-Left", GTK_TEXT_DIR_RTL),
5266 button = gtk_button_new_with_label ("Close");
5267 g_signal_connect_swapped (button, "clicked",
5268 G_CALLBACK (gtk_widget_destroy), window);
5269 gtk_box_pack_start (GTK_BOX (action_area), button, TRUE, TRUE, 0);
5272 if (!gtk_widget_get_visible (window))
5273 gtk_widget_show_all (window);
5275 gtk_widget_destroy (window);
5283 make_focus_table (GList **list)
5288 table = gtk_table_new (5, 5, FALSE);
5301 widget = gtk_entry_new ();
5303 widget = gtk_button_new_with_label ("Foo");
5305 *list = g_list_prepend (*list, widget);
5307 gtk_table_attach (GTK_TABLE (table),
5311 GTK_EXPAND | GTK_FILL,
5312 GTK_EXPAND | GTK_FILL,
5321 *list = g_list_reverse (*list);
5327 create_focus (GtkWidget *widget)
5329 static GtkWidget *window = NULL;
5333 GtkWidget *content_area;
5338 window = gtk_dialog_new_with_buttons ("Keyboard focus navigation",
5344 gtk_window_set_screen (GTK_WINDOW (window),
5345 gtk_widget_get_screen (widget));
5347 g_signal_connect (window, "destroy",
5348 G_CALLBACK (gtk_widget_destroyed),
5351 g_signal_connect (window, "response",
5352 G_CALLBACK (gtk_widget_destroy),
5355 content_area = gtk_dialog_get_content_area (GTK_DIALOG (window));
5357 gtk_window_set_title (GTK_WINDOW (window), "Keyboard Focus Navigation");
5359 frame = gtk_frame_new ("Weird tab focus chain");
5361 gtk_box_pack_start (GTK_BOX (content_area), frame, TRUE, TRUE, 0);
5363 table = make_focus_table (&list);
5365 gtk_container_add (GTK_CONTAINER (frame), table);
5367 gtk_container_set_focus_chain (GTK_CONTAINER (table),
5372 frame = gtk_frame_new ("Default tab focus chain");
5374 gtk_box_pack_start (GTK_BOX (content_area), frame, TRUE, TRUE, 0);
5377 table = make_focus_table (&list);
5381 gtk_container_add (GTK_CONTAINER (frame), table);
5384 if (!gtk_widget_get_visible (window))
5385 gtk_widget_show_all (window);
5387 gtk_widget_destroy (window);
5395 font_selection_ok (GtkWidget *w,
5396 GtkFontSelectionDialog *fs)
5398 gchar *s = gtk_font_selection_dialog_get_font_name (fs);
5400 g_print ("%s\n", s);
5402 gtk_widget_destroy (GTK_WIDGET (fs));
5406 create_font_selection (GtkWidget *widget)
5408 static GtkWidget *window = NULL;
5416 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
5417 gtk_window_set_screen (GTK_WINDOW (window),
5418 gtk_widget_get_screen (widget));
5420 g_signal_connect (window, "destroy",
5421 G_CALLBACK (gtk_widget_destroyed),
5424 gtk_window_set_title (GTK_WINDOW (window), "GtkFontButton");
5425 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
5427 hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 8);
5428 gtk_container_set_border_width (GTK_CONTAINER (hbox), 8);
5429 gtk_container_add (GTK_CONTAINER (window), hbox);
5431 label = gtk_label_new ("Pick a font");
5432 gtk_container_add (GTK_CONTAINER (hbox), label);
5434 picker = gtk_font_button_new ();
5435 gtk_font_button_set_use_font (GTK_FONT_BUTTON (picker), TRUE);
5436 gtk_container_add (GTK_CONTAINER (hbox), picker);
5439 if (!gtk_widget_get_visible (window))
5440 gtk_widget_show_all (window);
5442 gtk_widget_destroy (window);
5449 static GtkWidget *dialog_window = NULL;
5452 label_toggle (GtkWidget *widget,
5457 *label = gtk_label_new ("Dialog Test");
5458 g_signal_connect (*label,
5460 G_CALLBACK (gtk_widget_destroyed),
5462 gtk_misc_set_padding (GTK_MISC (*label), 10, 10);
5463 gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog_window))),
5464 *label, TRUE, TRUE, 0);
5465 gtk_widget_show (*label);
5468 gtk_widget_destroy (*label);
5472 create_dialog (GtkWidget *widget)
5474 static GtkWidget *label;
5475 GtkWidget *action_area;
5480 /* This is a terrible example; it's much simpler to create
5481 * dialogs than this. Don't use testgtk for example code,
5485 dialog_window = gtk_dialog_new ();
5486 gtk_window_set_screen (GTK_WINDOW (dialog_window),
5487 gtk_widget_get_screen (widget));
5489 g_signal_connect (dialog_window, "destroy",
5490 G_CALLBACK (gtk_widget_destroyed),
5493 action_area = gtk_dialog_get_action_area (GTK_DIALOG (dialog_window));
5495 gtk_window_set_title (GTK_WINDOW (dialog_window), "GtkDialog");
5496 gtk_container_set_border_width (GTK_CONTAINER (dialog_window), 0);
5498 button = gtk_button_new_with_label ("OK");
5499 gtk_widget_set_can_default (button, TRUE);
5500 gtk_box_pack_start (GTK_BOX (action_area), button, TRUE, TRUE, 0);
5501 gtk_widget_grab_default (button);
5502 gtk_widget_show (button);
5504 button = gtk_button_new_with_label ("Toggle");
5505 g_signal_connect (button, "clicked",
5506 G_CALLBACK (label_toggle),
5508 gtk_widget_set_can_default (button, TRUE);
5509 gtk_box_pack_start (GTK_BOX (action_area), button, TRUE, TRUE, 0);
5510 gtk_widget_show (button);
5515 if (!gtk_widget_get_visible (dialog_window))
5516 gtk_widget_show (dialog_window);
5518 gtk_widget_destroy (dialog_window);
5521 /* Display & Screen test
5528 GtkWidget *radio_dpy;
5529 GtkWidget *toplevel;
5530 GtkWidget *dialog_window;
5531 } ScreenDisplaySelection;
5534 screen_display_check (GtkWidget *widget, ScreenDisplaySelection *data)
5536 const gchar *display_name;
5537 GdkDisplay *display = gtk_widget_get_display (widget);
5539 GdkScreen *new_screen = NULL;
5540 GdkScreen *current_screen = gtk_widget_get_screen (widget);
5542 if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (data->radio_dpy)))
5544 display_name = gtk_entry_get_text (GTK_ENTRY (data->entry));
5545 display = gdk_display_open (display_name);
5549 dialog = gtk_message_dialog_new (GTK_WINDOW (gtk_widget_get_toplevel (widget)),
5550 GTK_DIALOG_DESTROY_WITH_PARENT,
5553 "The display :\n%s\ncannot be opened",
5555 gtk_window_set_screen (GTK_WINDOW (dialog), current_screen);
5556 gtk_widget_show (dialog);
5557 g_signal_connect (dialog, "response",
5558 G_CALLBACK (gtk_widget_destroy),
5563 GtkTreeModel *model = gtk_combo_box_get_model (GTK_COMBO_BOX (data->combo));
5566 gboolean found = FALSE;
5567 while (gtk_tree_model_iter_nth_child (model, &iter, NULL, i++))
5570 gtk_tree_model_get (model, &iter, 0, &name, -1);
5571 found = !g_ascii_strcasecmp (display_name, name);
5578 gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (data->combo), display_name);
5579 new_screen = gdk_display_get_default_screen (display);
5584 gint number_of_screens = gdk_display_get_n_screens (display);
5585 gint screen_num = gdk_screen_get_number (current_screen);
5586 if ((screen_num +1) < number_of_screens)
5587 new_screen = gdk_display_get_screen (display, screen_num + 1);
5589 new_screen = gdk_display_get_screen (display, 0);
5594 gtk_window_set_screen (GTK_WINDOW (data->toplevel), new_screen);
5595 gtk_widget_destroy (data->dialog_window);
5600 screen_display_destroy_diag (GtkWidget *widget, GtkWidget *data)
5602 gtk_widget_destroy (data);
5606 create_display_screen (GtkWidget *widget)
5608 GtkWidget *table, *frame, *window, *combo_dpy, *vbox;
5609 GtkWidget *radio_dpy, *radio_scr, *applyb, *cancelb;
5611 ScreenDisplaySelection *scr_dpy_data;
5612 GdkScreen *screen = gtk_widget_get_screen (widget);
5613 GdkDisplay *display = gdk_screen_get_display (screen);
5615 window = g_object_new (gtk_window_get_type (),
5618 "type", GTK_WINDOW_TOPLEVEL,
5620 "Screen or Display selection",
5621 "border_width", 10, NULL);
5622 g_signal_connect (window, "destroy",
5623 G_CALLBACK (gtk_widget_destroy), NULL);
5625 vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 3);
5626 gtk_container_add (GTK_CONTAINER (window), vbox);
5628 frame = gtk_frame_new ("Select screen or display");
5629 gtk_container_add (GTK_CONTAINER (vbox), frame);
5631 table = gtk_table_new (2, 2, TRUE);
5632 gtk_table_set_row_spacings (GTK_TABLE (table), 3);
5633 gtk_table_set_col_spacings (GTK_TABLE (table), 3);
5635 gtk_container_add (GTK_CONTAINER (frame), table);
5637 radio_dpy = gtk_radio_button_new_with_label (NULL, "move to another X display");
5638 if (gdk_display_get_n_screens(display) > 1)
5639 radio_scr = gtk_radio_button_new_with_label
5640 (gtk_radio_button_get_group (GTK_RADIO_BUTTON (radio_dpy)), "move to next screen");
5643 radio_scr = gtk_radio_button_new_with_label
5644 (gtk_radio_button_get_group (GTK_RADIO_BUTTON (radio_dpy)),
5645 "only one screen on the current display");
5646 gtk_widget_set_sensitive (radio_scr, FALSE);
5648 combo_dpy = gtk_combo_box_text_new_with_entry ();
5649 gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo_dpy), "diabolo:0.0");
5650 gtk_entry_set_text (GTK_ENTRY (gtk_bin_get_child (GTK_BIN (combo_dpy))),
5651 "<hostname>:<X Server Num>.<Screen Num>");
5653 gtk_table_attach_defaults (GTK_TABLE (table), radio_dpy, 0, 1, 0, 1);
5654 gtk_table_attach_defaults (GTK_TABLE (table), radio_scr, 0, 1, 1, 2);
5655 gtk_table_attach_defaults (GTK_TABLE (table), combo_dpy, 1, 2, 0, 1);
5657 bbox = gtk_button_box_new (GTK_ORIENTATION_HORIZONTAL);
5658 applyb = gtk_button_new_from_stock (GTK_STOCK_APPLY);
5659 cancelb = gtk_button_new_from_stock (GTK_STOCK_CANCEL);
5661 gtk_container_add (GTK_CONTAINER (vbox), bbox);
5663 gtk_container_add (GTK_CONTAINER (bbox), applyb);
5664 gtk_container_add (GTK_CONTAINER (bbox), cancelb);
5666 scr_dpy_data = g_new0 (ScreenDisplaySelection, 1);
5668 scr_dpy_data->entry = gtk_bin_get_child (GTK_BIN (combo_dpy));
5669 scr_dpy_data->radio_dpy = radio_dpy;
5670 scr_dpy_data->toplevel = gtk_widget_get_toplevel (widget);
5671 scr_dpy_data->dialog_window = window;
5673 g_signal_connect (cancelb, "clicked",
5674 G_CALLBACK (screen_display_destroy_diag), window);
5675 g_signal_connect (applyb, "clicked",
5676 G_CALLBACK (screen_display_check), scr_dpy_data);
5677 gtk_widget_show_all (window);
5682 static gulong event_watcher_enter_id = 0;
5683 static gulong event_watcher_leave_id = 0;
5686 event_watcher (GSignalInvocationHint *ihint,
5687 guint n_param_values,
5688 const GValue *param_values,
5691 g_print ("Watch: \"%s\" emitted for %s\n",
5692 g_signal_name (ihint->signal_id),
5693 G_OBJECT_TYPE_NAME (g_value_get_object (param_values + 0)));
5699 event_watcher_down (void)
5701 if (event_watcher_enter_id)
5705 signal_id = g_signal_lookup ("enter_notify_event", GTK_TYPE_WIDGET);
5706 g_signal_remove_emission_hook (signal_id, event_watcher_enter_id);
5707 event_watcher_enter_id = 0;
5708 signal_id = g_signal_lookup ("leave_notify_event", GTK_TYPE_WIDGET);
5709 g_signal_remove_emission_hook (signal_id, event_watcher_leave_id);
5710 event_watcher_leave_id = 0;
5715 event_watcher_toggle (void)
5717 if (event_watcher_enter_id)
5718 event_watcher_down ();
5723 signal_id = g_signal_lookup ("enter_notify_event", GTK_TYPE_WIDGET);
5724 event_watcher_enter_id = g_signal_add_emission_hook (signal_id, 0, event_watcher, NULL, NULL);
5725 signal_id = g_signal_lookup ("leave_notify_event", GTK_TYPE_WIDGET);
5726 event_watcher_leave_id = g_signal_add_emission_hook (signal_id, 0, event_watcher, NULL, NULL);
5731 create_event_watcher (GtkWidget *widget)
5733 GtkWidget *action_area, *content_area;
5738 dialog_window = gtk_dialog_new ();
5739 gtk_window_set_screen (GTK_WINDOW (dialog_window),
5740 gtk_widget_get_screen (widget));
5742 g_signal_connect (dialog_window, "destroy",
5743 G_CALLBACK (gtk_widget_destroyed),
5745 g_signal_connect (dialog_window, "destroy",
5746 G_CALLBACK (event_watcher_down),
5749 content_area = gtk_dialog_get_content_area (GTK_DIALOG (dialog_window));
5750 action_area = gtk_dialog_get_action_area (GTK_DIALOG (dialog_window));
5752 gtk_window_set_title (GTK_WINDOW (dialog_window), "Event Watcher");
5753 gtk_container_set_border_width (GTK_CONTAINER (dialog_window), 0);
5754 gtk_widget_set_size_request (dialog_window, 200, 110);
5756 button = gtk_toggle_button_new_with_label ("Activate Watch");
5757 g_signal_connect (button, "clicked",
5758 G_CALLBACK (event_watcher_toggle),
5760 gtk_container_set_border_width (GTK_CONTAINER (button), 10);
5761 gtk_box_pack_start (GTK_BOX (content_area), button, TRUE, TRUE, 0);
5762 gtk_widget_show (button);
5764 button = gtk_button_new_with_label ("Close");
5765 g_signal_connect_swapped (button, "clicked",
5766 G_CALLBACK (gtk_widget_destroy),
5768 gtk_widget_set_can_default (button, TRUE);
5769 gtk_box_pack_start (GTK_BOX (action_area), button, TRUE, TRUE, 0);
5770 gtk_widget_grab_default (button);
5771 gtk_widget_show (button);
5774 if (!gtk_widget_get_visible (dialog_window))
5775 gtk_widget_show (dialog_window);
5777 gtk_widget_destroy (dialog_window);
5785 reformat_value (GtkScale *scale,
5788 return g_strdup_printf ("-->%0.*g<--",
5789 gtk_scale_get_digits (scale), value);
5793 create_range_controls (GtkWidget *widget)
5795 static GtkWidget *window = NULL;
5799 GtkWidget *scrollbar;
5801 GtkWidget *separator;
5802 GtkAdjustment *adjustment;
5807 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
5809 gtk_window_set_screen (GTK_WINDOW (window),
5810 gtk_widget_get_screen (widget));
5812 g_signal_connect (window, "destroy",
5813 G_CALLBACK (gtk_widget_destroyed),
5816 gtk_window_set_title (GTK_WINDOW (window), "range controls");
5817 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
5820 box1 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
5821 gtk_container_add (GTK_CONTAINER (window), box1);
5822 gtk_widget_show (box1);
5825 box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10);
5826 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
5827 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
5828 gtk_widget_show (box2);
5831 adjustment = gtk_adjustment_new (0.0, 0.0, 101.0, 0.1, 1.0, 1.0);
5833 scale = gtk_scale_new (GTK_ORIENTATION_HORIZONTAL, GTK_ADJUSTMENT (adjustment));
5834 gtk_widget_set_size_request (GTK_WIDGET (scale), 150, -1);
5835 gtk_range_set_update_policy (GTK_RANGE (scale), GTK_UPDATE_DELAYED);
5836 gtk_scale_set_digits (GTK_SCALE (scale), 1);
5837 gtk_scale_set_draw_value (GTK_SCALE (scale), TRUE);
5838 gtk_box_pack_start (GTK_BOX (box2), scale, TRUE, TRUE, 0);
5839 gtk_widget_show (scale);
5841 scrollbar = gtk_scrollbar_new (GTK_ORIENTATION_HORIZONTAL, GTK_ADJUSTMENT (adjustment));
5842 gtk_range_set_update_policy (GTK_RANGE (scrollbar),
5843 GTK_UPDATE_CONTINUOUS);
5844 gtk_box_pack_start (GTK_BOX (box2), scrollbar, TRUE, TRUE, 0);
5845 gtk_widget_show (scrollbar);
5847 scale = gtk_scale_new (GTK_ORIENTATION_HORIZONTAL, GTK_ADJUSTMENT (adjustment));
5848 gtk_scale_set_draw_value (GTK_SCALE (scale), TRUE);
5849 g_signal_connect (scale,
5851 G_CALLBACK (reformat_value),
5853 gtk_box_pack_start (GTK_BOX (box2), scale, TRUE, TRUE, 0);
5854 gtk_widget_show (scale);
5856 hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
5858 scale = gtk_scale_new (GTK_ORIENTATION_VERTICAL, GTK_ADJUSTMENT (adjustment));
5859 gtk_widget_set_size_request (scale, -1, 200);
5860 gtk_scale_set_digits (GTK_SCALE (scale), 2);
5861 gtk_scale_set_draw_value (GTK_SCALE (scale), TRUE);
5862 gtk_box_pack_start (GTK_BOX (hbox), scale, TRUE, TRUE, 0);
5863 gtk_widget_show (scale);
5865 scale = gtk_scale_new (GTK_ORIENTATION_VERTICAL, GTK_ADJUSTMENT (adjustment));
5866 gtk_widget_set_size_request (scale, -1, 200);
5867 gtk_scale_set_digits (GTK_SCALE (scale), 2);
5868 gtk_scale_set_draw_value (GTK_SCALE (scale), TRUE);
5869 gtk_range_set_inverted (GTK_RANGE (scale), TRUE);
5870 gtk_box_pack_start (GTK_BOX (hbox), scale, TRUE, TRUE, 0);
5871 gtk_widget_show (scale);
5873 scale = gtk_scale_new (GTK_ORIENTATION_VERTICAL, GTK_ADJUSTMENT (adjustment));
5874 gtk_scale_set_draw_value (GTK_SCALE (scale), TRUE);
5875 g_signal_connect (scale,
5877 G_CALLBACK (reformat_value),
5879 gtk_box_pack_start (GTK_BOX (hbox), scale, TRUE, TRUE, 0);
5880 gtk_widget_show (scale);
5883 gtk_box_pack_start (GTK_BOX (box2), hbox, TRUE, TRUE, 0);
5884 gtk_widget_show (hbox);
5886 separator = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
5887 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
5888 gtk_widget_show (separator);
5891 box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10);
5892 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
5893 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
5894 gtk_widget_show (box2);
5897 button = gtk_button_new_with_label ("close");
5898 g_signal_connect_swapped (button, "clicked",
5899 G_CALLBACK (gtk_widget_destroy),
5901 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
5902 gtk_widget_set_can_default (button, TRUE);
5903 gtk_widget_grab_default (button);
5904 gtk_widget_show (button);
5907 if (!gtk_widget_get_visible (window))
5908 gtk_widget_show (window);
5910 gtk_widget_destroy (window);
5917 { { 0, 0x0000, 0x0000, 0x0000 }, "black" },
5918 { { 0, 0xFFFF, 0xFFFF, 0xFFFF }, "white" },
5919 { { 0, 0xFFFF, 0x0000, 0x0000 }, "red" },
5920 { { 0, 0x0000, 0xFFFF, 0x0000 }, "green" },
5921 { { 0, 0x0000, 0x0000, 0xFFFF }, "blue" },
5922 { { 0, 0x0000, 0xFFFF, 0xFFFF }, "cyan" },
5923 { { 0, 0xFFFF, 0x0000, 0xFFFF }, "magenta" },
5924 { { 0, 0xFFFF, 0xFFFF, 0x0000 }, "yellow" }
5927 int ntext_colors = sizeof(text_colors) / sizeof(text_colors[0]);
5933 static const char * book_open_xpm[] = {
5956 static const char * book_closed_xpm[] = {
5981 GdkPixbuf *book_open;
5982 GdkPixbuf *book_closed;
5983 GtkWidget *sample_notebook;
5986 set_page_image (GtkNotebook *notebook, gint page_num, GdkPixbuf *pixbuf)
5988 GtkWidget *page_widget;
5991 page_widget = gtk_notebook_get_nth_page (notebook, page_num);
5993 pixwid = g_object_get_data (G_OBJECT (page_widget), "tab_pixmap");
5994 gtk_image_set_from_pixbuf (GTK_IMAGE (pixwid), pixbuf);
5996 pixwid = g_object_get_data (G_OBJECT (page_widget), "menu_pixmap");
5997 gtk_image_set_from_pixbuf (GTK_IMAGE (pixwid), pixbuf);
6001 page_switch (GtkWidget *widget, gpointer *page, gint page_num)
6003 GtkNotebook *notebook = GTK_NOTEBOOK (widget);
6004 gint old_page_num = gtk_notebook_get_current_page (notebook);
6006 if (page_num == old_page_num)
6009 set_page_image (notebook, page_num, book_open);
6011 if (old_page_num != -1)
6012 set_page_image (notebook, old_page_num, book_closed);
6016 tab_fill (GtkToggleButton *button, GtkWidget *child)
6018 gtk_container_child_set (GTK_CONTAINER (sample_notebook), child,
6019 "tab-fill", gtk_toggle_button_get_active (button),
6024 tab_expand (GtkToggleButton *button, GtkWidget *child)
6026 gtk_container_child_set (GTK_CONTAINER (sample_notebook), child,
6027 "tab-expand", gtk_toggle_button_get_active (button),
6032 create_pages (GtkNotebook *notebook, gint start, gint end)
6034 GtkWidget *child = NULL;
6039 GtkWidget *label_box;
6040 GtkWidget *menu_box;
6044 char accel_buffer[32];
6046 for (i = start; i <= end; i++)
6048 sprintf (buffer, "Page %d", i);
6049 sprintf (accel_buffer, "Page _%d", i);
6051 child = gtk_frame_new (buffer);
6052 gtk_container_set_border_width (GTK_CONTAINER (child), 10);
6054 vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
6055 gtk_box_set_homogeneous (GTK_BOX (vbox), TRUE);
6056 gtk_container_set_border_width (GTK_CONTAINER (vbox), 10);
6057 gtk_container_add (GTK_CONTAINER (child), vbox);
6059 hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
6060 gtk_box_set_homogeneous (GTK_BOX (hbox), TRUE);
6061 gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 5);
6063 button = gtk_check_button_new_with_label ("Fill Tab");
6064 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
6065 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
6066 g_signal_connect (button, "toggled",
6067 G_CALLBACK (tab_fill), child);
6069 button = gtk_check_button_new_with_label ("Expand Tab");
6070 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
6071 g_signal_connect (button, "toggled",
6072 G_CALLBACK (tab_expand), child);
6074 button = gtk_button_new_with_label ("Hide Page");
6075 gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 5);
6076 g_signal_connect_swapped (button, "clicked",
6077 G_CALLBACK (gtk_widget_hide),
6080 gtk_widget_show_all (child);
6082 label_box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
6083 pixwid = gtk_image_new_from_pixbuf (book_closed);
6084 g_object_set_data (G_OBJECT (child), "tab_pixmap", pixwid);
6086 gtk_box_pack_start (GTK_BOX (label_box), pixwid, FALSE, TRUE, 0);
6087 gtk_misc_set_padding (GTK_MISC (pixwid), 3, 1);
6088 label = gtk_label_new_with_mnemonic (accel_buffer);
6089 gtk_box_pack_start (GTK_BOX (label_box), label, FALSE, TRUE, 0);
6090 gtk_widget_show_all (label_box);
6093 menu_box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
6094 pixwid = gtk_image_new_from_pixbuf (book_closed);
6095 g_object_set_data (G_OBJECT (child), "menu_pixmap", pixwid);
6097 gtk_box_pack_start (GTK_BOX (menu_box), pixwid, FALSE, TRUE, 0);
6098 gtk_misc_set_padding (GTK_MISC (pixwid), 3, 1);
6099 label = gtk_label_new (buffer);
6100 gtk_box_pack_start (GTK_BOX (menu_box), label, FALSE, TRUE, 0);
6101 gtk_widget_show_all (menu_box);
6103 gtk_notebook_append_page_menu (notebook, child, label_box, menu_box);
6108 rotate_notebook (GtkButton *button,
6109 GtkNotebook *notebook)
6111 gtk_notebook_set_tab_pos (notebook, (gtk_notebook_get_tab_pos (notebook) + 1) % 4);
6115 show_all_pages (GtkButton *button,
6116 GtkNotebook *notebook)
6118 gtk_container_foreach (GTK_CONTAINER (notebook),
6119 (GtkCallback) gtk_widget_show, NULL);
6123 notebook_type_changed (GtkWidget *optionmenu,
6126 GtkNotebook *notebook;
6136 notebook = GTK_NOTEBOOK (data);
6138 c = gtk_combo_box_get_active (GTK_COMBO_BOX (optionmenu));
6143 /* standard notebook */
6144 gtk_notebook_set_show_tabs (notebook, TRUE);
6145 gtk_notebook_set_show_border (notebook, TRUE);
6146 gtk_notebook_set_scrollable (notebook, FALSE);
6150 /* notabs notebook */
6151 gtk_notebook_set_show_tabs (notebook, FALSE);
6152 gtk_notebook_set_show_border (notebook, TRUE);
6157 gtk_notebook_set_show_tabs (notebook, FALSE);
6158 gtk_notebook_set_show_border (notebook, FALSE);
6163 gtk_notebook_set_show_tabs (notebook, TRUE);
6164 gtk_notebook_set_show_border (notebook, TRUE);
6165 gtk_notebook_set_scrollable (notebook, TRUE);
6166 if (gtk_notebook_get_n_pages (notebook) == 5)
6167 create_pages (notebook, 6, 15);
6173 if (gtk_notebook_get_n_pages (notebook) == 15)
6174 for (i = 0; i < 10; i++)
6175 gtk_notebook_remove_page (notebook, 5);
6179 notebook_popup (GtkToggleButton *button,
6180 GtkNotebook *notebook)
6182 if (gtk_toggle_button_get_active (button))
6183 gtk_notebook_popup_enable (notebook);
6185 gtk_notebook_popup_disable (notebook);
6189 create_notebook (GtkWidget *widget)
6191 static GtkWidget *window = NULL;
6195 GtkWidget *separator;
6199 static gchar *items[] =
6209 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
6210 gtk_window_set_screen (GTK_WINDOW (window),
6211 gtk_widget_get_screen (widget));
6213 g_signal_connect (window, "destroy",
6214 G_CALLBACK (gtk_widget_destroyed),
6217 gtk_window_set_title (GTK_WINDOW (window), "notebook");
6218 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
6220 box1 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
6221 gtk_container_add (GTK_CONTAINER (window), box1);
6223 sample_notebook = gtk_notebook_new ();
6224 g_signal_connect (sample_notebook, "switch_page",
6225 G_CALLBACK (page_switch), NULL);
6226 gtk_notebook_set_tab_pos (GTK_NOTEBOOK (sample_notebook), GTK_POS_TOP);
6227 gtk_box_pack_start (GTK_BOX (box1), sample_notebook, TRUE, TRUE, 0);
6228 gtk_container_set_border_width (GTK_CONTAINER (sample_notebook), 10);
6230 gtk_widget_realize (sample_notebook);
6233 book_open = gdk_pixbuf_new_from_xpm_data (book_open_xpm);
6236 book_closed = gdk_pixbuf_new_from_xpm_data (book_closed_xpm);
6238 create_pages (GTK_NOTEBOOK (sample_notebook), 1, 5);
6240 separator = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
6241 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 10);
6243 box2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 5);
6244 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
6245 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
6247 button = gtk_check_button_new_with_label ("popup menu");
6248 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, FALSE, 0);
6249 g_signal_connect (button, "clicked",
6250 G_CALLBACK (notebook_popup),
6253 box2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 5);
6254 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
6255 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
6257 label = gtk_label_new ("Notebook Style :");
6258 gtk_box_pack_start (GTK_BOX (box2), label, FALSE, TRUE, 0);
6260 omenu = build_option_menu (items, G_N_ELEMENTS (items), 0,
6261 notebook_type_changed,
6263 gtk_box_pack_start (GTK_BOX (box2), omenu, FALSE, TRUE, 0);
6265 button = gtk_button_new_with_label ("Show all Pages");
6266 gtk_box_pack_start (GTK_BOX (box2), button, FALSE, TRUE, 0);
6267 g_signal_connect (button, "clicked",
6268 G_CALLBACK (show_all_pages), sample_notebook);
6270 box2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 10);
6271 gtk_box_set_homogeneous (GTK_BOX (box2), TRUE);
6272 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
6273 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
6275 button = gtk_button_new_with_label ("prev");
6276 g_signal_connect_swapped (button, "clicked",
6277 G_CALLBACK (gtk_notebook_prev_page),
6279 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
6281 button = gtk_button_new_with_label ("next");
6282 g_signal_connect_swapped (button, "clicked",
6283 G_CALLBACK (gtk_notebook_next_page),
6285 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
6287 button = gtk_button_new_with_label ("rotate");
6288 g_signal_connect (button, "clicked",
6289 G_CALLBACK (rotate_notebook), sample_notebook);
6290 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
6292 separator = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
6293 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 5);
6295 button = gtk_button_new_with_label ("close");
6296 gtk_container_set_border_width (GTK_CONTAINER (button), 5);
6297 g_signal_connect_swapped (button, "clicked",
6298 G_CALLBACK (gtk_widget_destroy),
6300 gtk_box_pack_start (GTK_BOX (box1), button, FALSE, FALSE, 0);
6301 gtk_widget_set_can_default (button, TRUE);
6302 gtk_widget_grab_default (button);
6305 if (!gtk_widget_get_visible (window))
6306 gtk_widget_show_all (window);
6308 gtk_widget_destroy (window);
6316 toggle_resize (GtkWidget *widget, GtkWidget *child)
6318 GtkContainer *container = GTK_CONTAINER (gtk_widget_get_parent (child));
6319 GValue value = { 0, };
6320 g_value_init (&value, G_TYPE_BOOLEAN);
6321 gtk_container_child_get_property (container, child, "resize", &value);
6322 g_value_set_boolean (&value, !g_value_get_boolean (&value));
6323 gtk_container_child_set_property (container, child, "resize", &value);
6327 toggle_shrink (GtkWidget *widget, GtkWidget *child)
6329 GtkContainer *container = GTK_CONTAINER (gtk_widget_get_parent (child));
6330 GValue value = { 0, };
6331 g_value_init (&value, G_TYPE_BOOLEAN);
6332 gtk_container_child_get_property (container, child, "shrink", &value);
6333 g_value_set_boolean (&value, !g_value_get_boolean (&value));
6334 gtk_container_child_set_property (container, child, "shrink", &value);
6338 paned_props_clicked (GtkWidget *button,
6341 GtkWidget *window = create_prop_editor (paned, GTK_TYPE_PANED);
6343 gtk_window_set_title (GTK_WINDOW (window), "Paned Properties");
6347 create_pane_options (GtkPaned *paned,
6348 const gchar *frame_label,
6349 const gchar *label1,
6350 const gchar *label2)
6352 GtkWidget *child1, *child2;
6357 GtkWidget *check_button;
6359 child1 = gtk_paned_get_child1 (paned);
6360 child2 = gtk_paned_get_child2 (paned);
6362 frame = gtk_frame_new (frame_label);
6363 gtk_container_set_border_width (GTK_CONTAINER (frame), 4);
6365 table = gtk_table_new (4, 2, 4);
6366 gtk_container_add (GTK_CONTAINER (frame), table);
6368 label = gtk_label_new (label1);
6369 gtk_table_attach_defaults (GTK_TABLE (table), label,
6372 check_button = gtk_check_button_new_with_label ("Resize");
6373 gtk_table_attach_defaults (GTK_TABLE (table), check_button,
6375 g_signal_connect (check_button, "toggled",
6376 G_CALLBACK (toggle_resize),
6379 check_button = gtk_check_button_new_with_label ("Shrink");
6380 gtk_table_attach_defaults (GTK_TABLE (table), check_button,
6382 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check_button),
6384 g_signal_connect (check_button, "toggled",
6385 G_CALLBACK (toggle_shrink),
6388 label = gtk_label_new (label2);
6389 gtk_table_attach_defaults (GTK_TABLE (table), label,
6392 check_button = gtk_check_button_new_with_label ("Resize");
6393 gtk_table_attach_defaults (GTK_TABLE (table), check_button,
6395 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check_button),
6397 g_signal_connect (check_button, "toggled",
6398 G_CALLBACK (toggle_resize),
6401 check_button = gtk_check_button_new_with_label ("Shrink");
6402 gtk_table_attach_defaults (GTK_TABLE (table), check_button,
6404 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check_button),
6406 g_signal_connect (check_button, "toggled",
6407 G_CALLBACK (toggle_shrink),
6410 button = gtk_button_new_with_mnemonic ("_Properties");
6411 gtk_table_attach_defaults (GTK_TABLE (table), button,
6413 g_signal_connect (button, "clicked",
6414 G_CALLBACK (paned_props_clicked),
6421 create_panes (GtkWidget *widget)
6423 static GtkWidget *window = NULL;
6432 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
6434 gtk_window_set_screen (GTK_WINDOW (window),
6435 gtk_widget_get_screen (widget));
6437 g_signal_connect (window, "destroy",
6438 G_CALLBACK (gtk_widget_destroyed),
6441 gtk_window_set_title (GTK_WINDOW (window), "Panes");
6442 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
6444 vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
6445 gtk_container_add (GTK_CONTAINER (window), vbox);
6447 vpaned = gtk_paned_new (GTK_ORIENTATION_VERTICAL);
6448 gtk_box_pack_start (GTK_BOX (vbox), vpaned, TRUE, TRUE, 0);
6449 gtk_container_set_border_width (GTK_CONTAINER(vpaned), 5);
6451 hpaned = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL);
6452 gtk_paned_add1 (GTK_PANED (vpaned), hpaned);
6454 frame = gtk_frame_new (NULL);
6455 gtk_frame_set_shadow_type (GTK_FRAME(frame), GTK_SHADOW_IN);
6456 gtk_widget_set_size_request (frame, 60, 60);
6457 gtk_paned_add1 (GTK_PANED (hpaned), frame);
6459 button = gtk_button_new_with_label ("Hi there");
6460 gtk_container_add (GTK_CONTAINER(frame), button);
6462 frame = gtk_frame_new (NULL);
6463 gtk_frame_set_shadow_type (GTK_FRAME(frame), GTK_SHADOW_IN);
6464 gtk_widget_set_size_request (frame, 80, 60);
6465 gtk_paned_add2 (GTK_PANED (hpaned), frame);
6467 frame = gtk_frame_new (NULL);
6468 gtk_frame_set_shadow_type (GTK_FRAME(frame), GTK_SHADOW_IN);
6469 gtk_widget_set_size_request (frame, 60, 80);
6470 gtk_paned_add2 (GTK_PANED (vpaned), frame);
6472 /* Now create toggle buttons to control sizing */
6474 gtk_box_pack_start (GTK_BOX (vbox),
6475 create_pane_options (GTK_PANED (hpaned),
6481 gtk_box_pack_start (GTK_BOX (vbox),
6482 create_pane_options (GTK_PANED (vpaned),
6488 gtk_widget_show_all (vbox);
6491 if (!gtk_widget_get_visible (window))
6492 gtk_widget_show (window);
6494 gtk_widget_destroy (window);
6498 * Paned keyboard navigation
6502 paned_keyboard_window1 (GtkWidget *widget)
6525 window1 = gtk_window_new (GTK_WINDOW_TOPLEVEL);
6526 gtk_window_set_title (GTK_WINDOW (window1), "Basic paned navigation");
6527 gtk_window_set_screen (GTK_WINDOW (window1),
6528 gtk_widget_get_screen (widget));
6530 hpaned1 = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL);
6531 gtk_container_add (GTK_CONTAINER (window1), hpaned1);
6533 frame1 = gtk_frame_new (NULL);
6534 gtk_paned_pack1 (GTK_PANED (hpaned1), frame1, FALSE, TRUE);
6535 gtk_frame_set_shadow_type (GTK_FRAME (frame1), GTK_SHADOW_IN);
6537 vbox1 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
6538 gtk_container_add (GTK_CONTAINER (frame1), vbox1);
6540 button7 = gtk_button_new_with_label ("button7");
6541 gtk_box_pack_start (GTK_BOX (vbox1), button7, FALSE, FALSE, 0);
6543 button8 = gtk_button_new_with_label ("button8");
6544 gtk_box_pack_start (GTK_BOX (vbox1), button8, FALSE, FALSE, 0);
6546 button9 = gtk_button_new_with_label ("button9");
6547 gtk_box_pack_start (GTK_BOX (vbox1), button9, FALSE, FALSE, 0);
6549 vpaned1 = gtk_paned_new (GTK_ORIENTATION_VERTICAL);
6550 gtk_paned_pack2 (GTK_PANED (hpaned1), vpaned1, TRUE, TRUE);
6552 frame2 = gtk_frame_new (NULL);
6553 gtk_paned_pack1 (GTK_PANED (vpaned1), frame2, FALSE, TRUE);
6554 gtk_frame_set_shadow_type (GTK_FRAME (frame2), GTK_SHADOW_IN);
6556 frame5 = gtk_frame_new (NULL);
6557 gtk_container_add (GTK_CONTAINER (frame2), frame5);
6559 hbox1 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
6560 gtk_container_add (GTK_CONTAINER (frame5), hbox1);
6562 button5 = gtk_button_new_with_label ("button5");
6563 gtk_box_pack_start (GTK_BOX (hbox1), button5, FALSE, FALSE, 0);
6565 button6 = gtk_button_new_with_label ("button6");
6566 gtk_box_pack_start (GTK_BOX (hbox1), button6, FALSE, FALSE, 0);
6568 frame3 = gtk_frame_new (NULL);
6569 gtk_paned_pack2 (GTK_PANED (vpaned1), frame3, TRUE, TRUE);
6570 gtk_frame_set_shadow_type (GTK_FRAME (frame3), GTK_SHADOW_IN);
6572 frame4 = gtk_frame_new ("Buttons");
6573 gtk_container_add (GTK_CONTAINER (frame3), frame4);
6574 gtk_container_set_border_width (GTK_CONTAINER (frame4), 15);
6576 table1 = gtk_table_new (2, 2, FALSE);
6577 gtk_container_add (GTK_CONTAINER (frame4), table1);
6578 gtk_container_set_border_width (GTK_CONTAINER (table1), 11);
6580 button1 = gtk_button_new_with_label ("button1");
6581 gtk_table_attach (GTK_TABLE (table1), button1, 0, 1, 0, 1,
6582 (GtkAttachOptions) (GTK_FILL),
6583 (GtkAttachOptions) (0), 0, 0);
6585 button2 = gtk_button_new_with_label ("button2");
6586 gtk_table_attach (GTK_TABLE (table1), button2, 1, 2, 0, 1,
6587 (GtkAttachOptions) (GTK_FILL),
6588 (GtkAttachOptions) (0), 0, 0);
6590 button3 = gtk_button_new_with_label ("button3");
6591 gtk_table_attach (GTK_TABLE (table1), button3, 0, 1, 1, 2,
6592 (GtkAttachOptions) (GTK_FILL),
6593 (GtkAttachOptions) (0), 0, 0);
6595 button4 = gtk_button_new_with_label ("button4");
6596 gtk_table_attach (GTK_TABLE (table1), button4, 1, 2, 1, 2,
6597 (GtkAttachOptions) (GTK_FILL),
6598 (GtkAttachOptions) (0), 0, 0);
6604 paned_keyboard_window2 (GtkWidget *widget)
6609 GtkWidget *button13;
6613 GtkWidget *button12;
6615 GtkWidget *button11;
6616 GtkWidget *button10;
6618 window2 = gtk_window_new (GTK_WINDOW_TOPLEVEL);
6619 gtk_window_set_title (GTK_WINDOW (window2), "\"button 10\" is not inside the horisontal pane");
6621 gtk_window_set_screen (GTK_WINDOW (window2),
6622 gtk_widget_get_screen (widget));
6624 hpaned2 = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL);
6625 gtk_container_add (GTK_CONTAINER (window2), hpaned2);
6627 frame6 = gtk_frame_new (NULL);
6628 gtk_paned_pack1 (GTK_PANED (hpaned2), frame6, FALSE, TRUE);
6629 gtk_frame_set_shadow_type (GTK_FRAME (frame6), GTK_SHADOW_IN);
6631 button13 = gtk_button_new_with_label ("button13");
6632 gtk_container_add (GTK_CONTAINER (frame6), button13);
6634 hbox2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
6635 gtk_paned_pack2 (GTK_PANED (hpaned2), hbox2, TRUE, TRUE);
6637 vpaned2 = gtk_paned_new (GTK_ORIENTATION_VERTICAL);
6638 gtk_box_pack_start (GTK_BOX (hbox2), vpaned2, TRUE, TRUE, 0);
6640 frame7 = gtk_frame_new (NULL);
6641 gtk_paned_pack1 (GTK_PANED (vpaned2), frame7, FALSE, TRUE);
6642 gtk_frame_set_shadow_type (GTK_FRAME (frame7), GTK_SHADOW_IN);
6644 button12 = gtk_button_new_with_label ("button12");
6645 gtk_container_add (GTK_CONTAINER (frame7), button12);
6647 frame8 = gtk_frame_new (NULL);
6648 gtk_paned_pack2 (GTK_PANED (vpaned2), frame8, TRUE, TRUE);
6649 gtk_frame_set_shadow_type (GTK_FRAME (frame8), GTK_SHADOW_IN);
6651 button11 = gtk_button_new_with_label ("button11");
6652 gtk_container_add (GTK_CONTAINER (frame8), button11);
6654 button10 = gtk_button_new_with_label ("button10");
6655 gtk_box_pack_start (GTK_BOX (hbox2), button10, FALSE, FALSE, 0);
6661 paned_keyboard_window3 (GtkWidget *widget)
6668 GtkWidget *button14;
6671 GtkWidget *button15;
6674 GtkWidget *button16;
6676 GtkWidget *button17;
6678 window3 = gtk_window_new (GTK_WINDOW_TOPLEVEL);
6679 g_object_set_data (G_OBJECT (window3), "window3", window3);
6680 gtk_window_set_title (GTK_WINDOW (window3), "Nested panes");
6682 gtk_window_set_screen (GTK_WINDOW (window3),
6683 gtk_widget_get_screen (widget));
6686 vbox2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
6687 gtk_container_add (GTK_CONTAINER (window3), vbox2);
6689 label1 = gtk_label_new ("Three panes nested inside each other");
6690 gtk_box_pack_start (GTK_BOX (vbox2), label1, FALSE, FALSE, 0);
6692 hpaned3 = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL);
6693 gtk_box_pack_start (GTK_BOX (vbox2), hpaned3, TRUE, TRUE, 0);
6695 frame9 = gtk_frame_new (NULL);
6696 gtk_paned_pack1 (GTK_PANED (hpaned3), frame9, FALSE, TRUE);
6697 gtk_frame_set_shadow_type (GTK_FRAME (frame9), GTK_SHADOW_IN);
6699 button14 = gtk_button_new_with_label ("button14");
6700 gtk_container_add (GTK_CONTAINER (frame9), button14);
6702 hpaned4 = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL);
6703 gtk_paned_pack2 (GTK_PANED (hpaned3), hpaned4, TRUE, TRUE);
6705 frame10 = gtk_frame_new (NULL);
6706 gtk_paned_pack1 (GTK_PANED (hpaned4), frame10, FALSE, TRUE);
6707 gtk_frame_set_shadow_type (GTK_FRAME (frame10), GTK_SHADOW_IN);
6709 button15 = gtk_button_new_with_label ("button15");
6710 gtk_container_add (GTK_CONTAINER (frame10), button15);
6712 hpaned5 = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL);
6713 gtk_paned_pack2 (GTK_PANED (hpaned4), hpaned5, TRUE, TRUE);
6715 frame11 = gtk_frame_new (NULL);
6716 gtk_paned_pack1 (GTK_PANED (hpaned5), frame11, FALSE, TRUE);
6717 gtk_frame_set_shadow_type (GTK_FRAME (frame11), GTK_SHADOW_IN);
6719 button16 = gtk_button_new_with_label ("button16");
6720 gtk_container_add (GTK_CONTAINER (frame11), button16);
6722 frame12 = gtk_frame_new (NULL);
6723 gtk_paned_pack2 (GTK_PANED (hpaned5), frame12, TRUE, TRUE);
6724 gtk_frame_set_shadow_type (GTK_FRAME (frame12), GTK_SHADOW_IN);
6726 button17 = gtk_button_new_with_label ("button17");
6727 gtk_container_add (GTK_CONTAINER (frame12), button17);
6733 paned_keyboard_window4 (GtkWidget *widget)
6740 GtkWidget *button19;
6741 GtkWidget *button18;
6744 GtkWidget *button21;
6745 GtkWidget *button20;
6747 GtkWidget *button23;
6748 GtkWidget *button22;
6750 GtkWidget *button25;
6751 GtkWidget *button24;
6753 window4 = gtk_window_new (GTK_WINDOW_TOPLEVEL);
6754 g_object_set_data (G_OBJECT (window4), "window4", window4);
6755 gtk_window_set_title (GTK_WINDOW (window4), "window4");
6757 gtk_window_set_screen (GTK_WINDOW (window4),
6758 gtk_widget_get_screen (widget));
6760 vbox3 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
6761 gtk_container_add (GTK_CONTAINER (window4), vbox3);
6763 label2 = gtk_label_new ("Widget tree:\n\nhpaned \n - vpaned\n - hbox\n - vpaned\n - vpaned\n - vpaned\n");
6764 gtk_box_pack_start (GTK_BOX (vbox3), label2, FALSE, FALSE, 0);
6765 gtk_label_set_justify (GTK_LABEL (label2), GTK_JUSTIFY_LEFT);
6767 hpaned6 = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL);
6768 gtk_box_pack_start (GTK_BOX (vbox3), hpaned6, TRUE, TRUE, 0);
6770 vpaned3 = gtk_paned_new (GTK_ORIENTATION_VERTICAL);
6771 gtk_paned_pack1 (GTK_PANED (hpaned6), vpaned3, FALSE, TRUE);
6773 button19 = gtk_button_new_with_label ("button19");
6774 gtk_paned_pack1 (GTK_PANED (vpaned3), button19, FALSE, TRUE);
6776 button18 = gtk_button_new_with_label ("button18");
6777 gtk_paned_pack2 (GTK_PANED (vpaned3), button18, TRUE, TRUE);
6779 hbox3 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
6780 gtk_paned_pack2 (GTK_PANED (hpaned6), hbox3, TRUE, TRUE);
6782 vpaned4 = gtk_paned_new (GTK_ORIENTATION_VERTICAL);
6783 gtk_box_pack_start (GTK_BOX (hbox3), vpaned4, TRUE, TRUE, 0);
6785 button21 = gtk_button_new_with_label ("button21");
6786 gtk_paned_pack1 (GTK_PANED (vpaned4), button21, FALSE, TRUE);
6788 button20 = gtk_button_new_with_label ("button20");
6789 gtk_paned_pack2 (GTK_PANED (vpaned4), button20, TRUE, TRUE);
6791 vpaned5 = gtk_paned_new (GTK_ORIENTATION_VERTICAL);
6792 gtk_box_pack_start (GTK_BOX (hbox3), vpaned5, TRUE, TRUE, 0);
6794 button23 = gtk_button_new_with_label ("button23");
6795 gtk_paned_pack1 (GTK_PANED (vpaned5), button23, FALSE, TRUE);
6797 button22 = gtk_button_new_with_label ("button22");
6798 gtk_paned_pack2 (GTK_PANED (vpaned5), button22, TRUE, TRUE);
6800 vpaned6 = gtk_paned_new (GTK_ORIENTATION_VERTICAL);
6801 gtk_box_pack_start (GTK_BOX (hbox3), vpaned6, TRUE, TRUE, 0);
6803 button25 = gtk_button_new_with_label ("button25");
6804 gtk_paned_pack1 (GTK_PANED (vpaned6), button25, FALSE, TRUE);
6806 button24 = gtk_button_new_with_label ("button24");
6807 gtk_paned_pack2 (GTK_PANED (vpaned6), button24, TRUE, TRUE);
6813 create_paned_keyboard_navigation (GtkWidget *widget)
6815 static GtkWidget *window1 = NULL;
6816 static GtkWidget *window2 = NULL;
6817 static GtkWidget *window3 = NULL;
6818 static GtkWidget *window4 = NULL;
6821 (gtk_widget_get_screen (window1) != gtk_widget_get_screen (widget)))
6823 gtk_widget_destroy (window1);
6824 gtk_widget_destroy (window2);
6825 gtk_widget_destroy (window3);
6826 gtk_widget_destroy (window4);
6831 window1 = paned_keyboard_window1 (widget);
6832 g_signal_connect (window1, "destroy",
6833 G_CALLBACK (gtk_widget_destroyed),
6839 window2 = paned_keyboard_window2 (widget);
6840 g_signal_connect (window2, "destroy",
6841 G_CALLBACK (gtk_widget_destroyed),
6847 window3 = paned_keyboard_window3 (widget);
6848 g_signal_connect (window3, "destroy",
6849 G_CALLBACK (gtk_widget_destroyed),
6855 window4 = paned_keyboard_window4 (widget);
6856 g_signal_connect (window4, "destroy",
6857 G_CALLBACK (gtk_widget_destroyed),
6861 if (gtk_widget_get_visible (window1))
6862 gtk_widget_destroy (GTK_WIDGET (window1));
6864 gtk_widget_show_all (GTK_WIDGET (window1));
6866 if (gtk_widget_get_visible (window2))
6867 gtk_widget_destroy (GTK_WIDGET (window2));
6869 gtk_widget_show_all (GTK_WIDGET (window2));
6871 if (gtk_widget_get_visible (window3))
6872 gtk_widget_destroy (GTK_WIDGET (window3));
6874 gtk_widget_show_all (GTK_WIDGET (window3));
6876 if (gtk_widget_get_visible (window4))
6877 gtk_widget_destroy (GTK_WIDGET (window4));
6879 gtk_widget_show_all (GTK_WIDGET (window4));
6887 typedef struct _cursoroffset {gint x,y;} CursorOffset;
6890 shape_pressed (GtkWidget *widget, GdkEventButton *event)
6894 /* ignore double and triple click */
6895 if (event->type != GDK_BUTTON_PRESS)
6898 p = g_object_get_data (G_OBJECT (widget), "cursor_offset");
6899 p->x = (int) event->x;
6900 p->y = (int) event->y;
6902 gtk_grab_add (widget);
6903 gdk_pointer_grab (gtk_widget_get_window (widget), TRUE,
6904 GDK_BUTTON_RELEASE_MASK |
6905 GDK_BUTTON_MOTION_MASK |
6906 GDK_POINTER_MOTION_HINT_MASK,
6911 shape_released (GtkWidget *widget)
6913 gtk_grab_remove (widget);
6914 gdk_display_pointer_ungrab (gtk_widget_get_display (widget),
6919 shape_motion (GtkWidget *widget,
6920 GdkEventMotion *event)
6924 GdkModifierType mask;
6926 p = g_object_get_data (G_OBJECT (widget), "cursor_offset");
6929 * Can't use event->x / event->y here
6930 * because I need absolute coordinates.
6932 gdk_window_get_pointer (NULL, &xp, &yp, &mask);
6933 gtk_window_move (GTK_WINDOW (widget), xp - p->x, yp - p->y);
6937 shape_create_icon (GdkScreen *screen,
6948 CursorOffset* icon_pos;
6949 cairo_surface_t *mask;
6950 cairo_region_t *mask_region;
6955 * GDK_WINDOW_TOPLEVEL works also, giving you a title border
6957 window = gtk_window_new (window_type);
6958 gtk_window_set_screen (GTK_WINDOW (window), screen);
6960 fixed = gtk_fixed_new ();
6961 gtk_widget_set_size_request (fixed, 100, 100);
6962 gtk_container_add (GTK_CONTAINER (window), fixed);
6963 gtk_widget_show (fixed);
6965 gtk_widget_set_events (window,
6966 gtk_widget_get_events (window) |
6967 GDK_BUTTON_MOTION_MASK |
6968 GDK_POINTER_MOTION_HINT_MASK |
6969 GDK_BUTTON_PRESS_MASK);
6971 gtk_widget_realize (window);
6973 pixbuf = gdk_pixbuf_new_from_file (xpm_file, NULL);
6974 g_assert (pixbuf); /* FIXME: error handling */
6976 mask = cairo_image_surface_create (CAIRO_FORMAT_A1,
6977 gdk_pixbuf_get_width (pixbuf),
6978 gdk_pixbuf_get_height (pixbuf));
6979 cr = cairo_create (mask);
6980 gdk_cairo_set_source_pixbuf (cr, pixbuf, 0, 0);
6984 mask_region = gdk_cairo_region_create_from_surface (mask);
6986 cairo_region_translate (mask_region, px, py);
6988 image = gtk_image_new_from_pixbuf (pixbuf);
6989 gtk_fixed_put (GTK_FIXED (fixed), image, px,py);
6990 gtk_widget_show (image);
6992 gtk_widget_shape_combine_region (window, mask_region);
6994 cairo_region_destroy (mask_region);
6995 cairo_surface_destroy (mask);
6996 g_object_unref (pixbuf);
6998 g_signal_connect (window, "button_press_event",
6999 G_CALLBACK (shape_pressed), NULL);
7000 g_signal_connect (window, "button_release_event",
7001 G_CALLBACK (shape_released), NULL);
7002 g_signal_connect (window, "motion_notify_event",
7003 G_CALLBACK (shape_motion), NULL);
7005 icon_pos = g_new (CursorOffset, 1);
7006 g_object_set_data (G_OBJECT (window), "cursor_offset", icon_pos);
7008 gtk_window_move (GTK_WINDOW (window), x, y);
7009 gtk_widget_show (window);
7015 create_shapes (GtkWidget *widget)
7017 /* Variables used by the Drag/Drop and Shape Window demos */
7018 static GtkWidget *modeller = NULL;
7019 static GtkWidget *sheets = NULL;
7020 static GtkWidget *rings = NULL;
7021 static GtkWidget *with_region = NULL;
7022 GdkScreen *screen = gtk_widget_get_screen (widget);
7024 if (!(file_exists ("Modeller.xpm") &&
7025 file_exists ("FilesQueue.xpm") &&
7026 file_exists ("3DRings.xpm")))
7032 modeller = shape_create_icon (screen, "Modeller.xpm",
7033 440, 140, 0,0, GTK_WINDOW_POPUP);
7035 g_signal_connect (modeller, "destroy",
7036 G_CALLBACK (gtk_widget_destroyed),
7040 gtk_widget_destroy (modeller);
7044 sheets = shape_create_icon (screen, "FilesQueue.xpm",
7045 580, 170, 0,0, GTK_WINDOW_POPUP);
7047 g_signal_connect (sheets, "destroy",
7048 G_CALLBACK (gtk_widget_destroyed),
7053 gtk_widget_destroy (sheets);
7057 rings = shape_create_icon (screen, "3DRings.xpm",
7058 460, 270, 25,25, GTK_WINDOW_TOPLEVEL);
7060 g_signal_connect (rings, "destroy",
7061 G_CALLBACK (gtk_widget_destroyed),
7065 gtk_widget_destroy (rings);
7069 cairo_region_t *region;
7072 with_region = shape_create_icon (screen, "3DRings.xpm",
7073 460, 270, 25,25, GTK_WINDOW_TOPLEVEL);
7075 gtk_window_set_decorated (GTK_WINDOW (with_region), FALSE);
7077 g_signal_connect (with_region, "destroy",
7078 G_CALLBACK (gtk_widget_destroyed),
7081 /* reset shape from mask to a region */
7084 region = cairo_region_create ();
7096 cairo_region_union_rectangle (region, &rect);
7104 gdk_window_shape_combine_region (gtk_widget_get_window (with_region),
7109 gtk_widget_destroy (with_region);
7117 create_wmhints (GtkWidget *widget)
7119 static GtkWidget *window = NULL;
7121 GtkWidget *separator;
7125 GdkWindow *gdk_window;
7131 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
7133 gtk_window_set_screen (GTK_WINDOW (window),
7134 gtk_widget_get_screen (widget));
7136 g_signal_connect (window, "destroy",
7137 G_CALLBACK (gtk_widget_destroyed),
7140 gtk_window_set_title (GTK_WINDOW (window), "WM Hints");
7141 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
7143 gtk_widget_realize (window);
7145 gdk_window = gtk_widget_get_window (window);
7147 pixbuf = gdk_pixbuf_new_from_xpm_data ((const char **) openfile);
7148 list = g_list_prepend (NULL, pixbuf);
7150 gdk_window_set_icon_list (gdk_window, list);
7153 g_object_unref (pixbuf);
7155 gdk_window_set_icon_name (gdk_window, "WMHints Test Icon");
7157 gdk_window_set_decorations (gdk_window, GDK_DECOR_ALL | GDK_DECOR_MENU);
7158 gdk_window_set_functions (gdk_window, GDK_FUNC_ALL | GDK_FUNC_RESIZE);
7160 box1 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
7161 gtk_container_add (GTK_CONTAINER (window), box1);
7162 gtk_widget_show (box1);
7164 label = gtk_label_new ("Try iconizing me!");
7165 gtk_widget_set_size_request (label, 150, 50);
7166 gtk_box_pack_start (GTK_BOX (box1), label, TRUE, TRUE, 0);
7167 gtk_widget_show (label);
7170 separator = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
7171 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
7172 gtk_widget_show (separator);
7175 box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10);
7176 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
7177 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
7178 gtk_widget_show (box2);
7181 button = gtk_button_new_with_label ("close");
7183 g_signal_connect_swapped (button, "clicked",
7184 G_CALLBACK (gtk_widget_destroy),
7187 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
7188 gtk_widget_set_can_default (button, TRUE);
7189 gtk_widget_grab_default (button);
7190 gtk_widget_show (button);
7193 if (!gtk_widget_get_visible (window))
7194 gtk_widget_show (window);
7196 gtk_widget_destroy (window);
7201 * Window state tracking
7205 window_state_callback (GtkWidget *widget,
7206 GdkEventWindowState *event,
7209 GtkWidget *label = data;
7212 msg = g_strconcat (gtk_window_get_title (GTK_WINDOW (widget)), ": ",
7213 (event->new_window_state & GDK_WINDOW_STATE_WITHDRAWN) ?
7214 "withdrawn" : "not withdrawn", ", ",
7215 (event->new_window_state & GDK_WINDOW_STATE_ICONIFIED) ?
7216 "iconified" : "not iconified", ", ",
7217 (event->new_window_state & GDK_WINDOW_STATE_STICKY) ?
7218 "sticky" : "not sticky", ", ",
7219 (event->new_window_state & GDK_WINDOW_STATE_MAXIMIZED) ?
7220 "maximized" : "not maximized", ", ",
7221 (event->new_window_state & GDK_WINDOW_STATE_FULLSCREEN) ?
7222 "fullscreen" : "not fullscreen",
7223 (event->new_window_state & GDK_WINDOW_STATE_ABOVE) ?
7224 "above" : "not above", ", ",
7225 (event->new_window_state & GDK_WINDOW_STATE_BELOW) ?
7226 "below" : "not below", ", ",
7229 gtk_label_set_text (GTK_LABEL (label), msg);
7237 tracking_label (GtkWidget *window)
7243 hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 5);
7245 g_signal_connect_object (hbox,
7247 G_CALLBACK (gtk_widget_destroy),
7251 label = gtk_label_new ("<no window state events received>");
7252 gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
7253 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
7255 g_signal_connect (window,
7256 "window_state_event",
7257 G_CALLBACK (window_state_callback),
7260 button = gtk_button_new_with_label ("Deiconify");
7261 g_signal_connect_object (button,
7263 G_CALLBACK (gtk_window_deiconify),
7266 gtk_box_pack_end (GTK_BOX (hbox), button, FALSE, FALSE, 0);
7268 button = gtk_button_new_with_label ("Iconify");
7269 g_signal_connect_object (button,
7271 G_CALLBACK (gtk_window_iconify),
7274 gtk_box_pack_end (GTK_BOX (hbox), button, FALSE, FALSE, 0);
7276 button = gtk_button_new_with_label ("Fullscreen");
7277 g_signal_connect_object (button,
7279 G_CALLBACK (gtk_window_fullscreen),
7282 gtk_box_pack_end (GTK_BOX (hbox), button, FALSE, FALSE, 0);
7284 button = gtk_button_new_with_label ("Unfullscreen");
7285 g_signal_connect_object (button,
7287 G_CALLBACK (gtk_window_unfullscreen),
7290 gtk_box_pack_end (GTK_BOX (hbox), button, FALSE, FALSE, 0);
7292 button = gtk_button_new_with_label ("Present");
7293 g_signal_connect_object (button,
7295 G_CALLBACK (gtk_window_present),
7298 gtk_box_pack_end (GTK_BOX (hbox), button, FALSE, FALSE, 0);
7300 button = gtk_button_new_with_label ("Show");
7301 g_signal_connect_object (button,
7303 G_CALLBACK (gtk_widget_show),
7306 gtk_box_pack_end (GTK_BOX (hbox), button, FALSE, FALSE, 0);
7308 gtk_widget_show_all (hbox);
7314 keep_window_above (GtkToggleButton *togglebutton, gpointer data)
7316 GtkWidget *button = g_object_get_data (G_OBJECT (togglebutton), "radio");
7318 gtk_window_set_keep_above (GTK_WINDOW (data),
7319 gtk_toggle_button_get_active (togglebutton));
7321 if (gtk_toggle_button_get_active (togglebutton))
7322 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), FALSE);
7326 keep_window_below (GtkToggleButton *togglebutton, gpointer data)
7328 GtkWidget *button = g_object_get_data (G_OBJECT (togglebutton), "radio");
7330 gtk_window_set_keep_below (GTK_WINDOW (data),
7331 gtk_toggle_button_get_active (togglebutton));
7333 if (gtk_toggle_button_get_active (togglebutton))
7334 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), FALSE);
7339 get_state_controls (GtkWidget *window)
7343 GtkWidget *button_above;
7344 GtkWidget *button_below;
7346 vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
7348 button = gtk_button_new_with_label ("Stick");
7349 g_signal_connect_object (button,
7351 G_CALLBACK (gtk_window_stick),
7354 gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
7356 button = gtk_button_new_with_label ("Unstick");
7357 g_signal_connect_object (button,
7359 G_CALLBACK (gtk_window_unstick),
7362 gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
7364 button = gtk_button_new_with_label ("Maximize");
7365 g_signal_connect_object (button,
7367 G_CALLBACK (gtk_window_maximize),
7370 gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
7372 button = gtk_button_new_with_label ("Unmaximize");
7373 g_signal_connect_object (button,
7375 G_CALLBACK (gtk_window_unmaximize),
7378 gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
7380 button = gtk_button_new_with_label ("Iconify");
7381 g_signal_connect_object (button,
7383 G_CALLBACK (gtk_window_iconify),
7386 gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
7388 button = gtk_button_new_with_label ("Fullscreen");
7389 g_signal_connect_object (button,
7391 G_CALLBACK (gtk_window_fullscreen),
7394 gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
7396 button = gtk_button_new_with_label ("Unfullscreen");
7397 g_signal_connect_object (button,
7399 G_CALLBACK (gtk_window_unfullscreen),
7402 gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
7404 button_above = gtk_toggle_button_new_with_label ("Keep above");
7405 g_signal_connect (button_above,
7407 G_CALLBACK (keep_window_above),
7409 gtk_box_pack_start (GTK_BOX (vbox), button_above, FALSE, FALSE, 0);
7411 button_below = gtk_toggle_button_new_with_label ("Keep below");
7412 g_signal_connect (button_below,
7414 G_CALLBACK (keep_window_below),
7416 gtk_box_pack_start (GTK_BOX (vbox), button_below, FALSE, FALSE, 0);
7418 g_object_set_data (G_OBJECT (button_above), "radio", button_below);
7419 g_object_set_data (G_OBJECT (button_below), "radio", button_above);
7421 button = gtk_button_new_with_label ("Hide (withdraw)");
7422 g_signal_connect_object (button,
7424 G_CALLBACK (gtk_widget_hide),
7427 gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
7429 gtk_widget_show_all (vbox);
7435 create_window_states (GtkWidget *widget)
7437 static GtkWidget *window = NULL;
7440 GtkWidget *iconified;
7442 GtkWidget *controls;
7446 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
7447 gtk_window_set_screen (GTK_WINDOW (window),
7448 gtk_widget_get_screen (widget));
7450 g_signal_connect (window, "destroy",
7451 G_CALLBACK (gtk_widget_destroyed),
7454 gtk_window_set_title (GTK_WINDOW (window), "Window states");
7456 box1 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
7457 gtk_container_add (GTK_CONTAINER (window), box1);
7459 iconified = gtk_window_new (GTK_WINDOW_TOPLEVEL);
7461 gtk_window_set_screen (GTK_WINDOW (iconified),
7462 gtk_widget_get_screen (widget));
7464 g_signal_connect_object (iconified, "destroy",
7465 G_CALLBACK (gtk_widget_destroy),
7468 gtk_window_iconify (GTK_WINDOW (iconified));
7469 gtk_window_set_title (GTK_WINDOW (iconified), "Iconified initially");
7470 controls = get_state_controls (iconified);
7471 gtk_container_add (GTK_CONTAINER (iconified), controls);
7473 normal = gtk_window_new (GTK_WINDOW_TOPLEVEL);
7475 gtk_window_set_screen (GTK_WINDOW (normal),
7476 gtk_widget_get_screen (widget));
7478 g_signal_connect_object (normal, "destroy",
7479 G_CALLBACK (gtk_widget_destroy),
7483 gtk_window_set_title (GTK_WINDOW (normal), "Deiconified initially");
7484 controls = get_state_controls (normal);
7485 gtk_container_add (GTK_CONTAINER (normal), controls);
7487 label = tracking_label (iconified);
7488 gtk_container_add (GTK_CONTAINER (box1), label);
7490 label = tracking_label (normal);
7491 gtk_container_add (GTK_CONTAINER (box1), label);
7493 gtk_widget_show_all (iconified);
7494 gtk_widget_show_all (normal);
7495 gtk_widget_show_all (box1);
7498 if (!gtk_widget_get_visible (window))
7499 gtk_widget_show (window);
7501 gtk_widget_destroy (window);
7509 configure_event_callback (GtkWidget *widget,
7510 GdkEventConfigure *event,
7513 GtkWidget *label = data;
7517 gtk_window_get_position (GTK_WINDOW (widget), &x, &y);
7519 msg = g_strdup_printf ("event: %d,%d %d x %d\n"
7521 event->x, event->y, event->width, event->height,
7524 gtk_label_set_text (GTK_LABEL (label), msg);
7532 get_ints (GtkWidget *window,
7539 spin1 = g_object_get_data (G_OBJECT (window), "spin1");
7540 spin2 = g_object_get_data (G_OBJECT (window), "spin2");
7542 *a = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (spin1));
7543 *b = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (spin2));
7547 set_size_callback (GtkWidget *widget,
7552 get_ints (data, &w, &h);
7554 gtk_window_resize (GTK_WINDOW (g_object_get_data (data, "target")), w, h);
7558 unset_default_size_callback (GtkWidget *widget,
7561 gtk_window_set_default_size (g_object_get_data (data, "target"),
7566 set_default_size_callback (GtkWidget *widget,
7571 get_ints (data, &w, &h);
7573 gtk_window_set_default_size (g_object_get_data (data, "target"),
7578 unset_size_request_callback (GtkWidget *widget,
7581 gtk_widget_set_size_request (g_object_get_data (data, "target"),
7586 set_size_request_callback (GtkWidget *widget,
7591 get_ints (data, &w, &h);
7593 gtk_widget_set_size_request (g_object_get_data (data, "target"),
7598 set_location_callback (GtkWidget *widget,
7603 get_ints (data, &x, &y);
7605 gtk_window_move (g_object_get_data (data, "target"), x, y);
7609 move_to_position_callback (GtkWidget *widget,
7615 window = g_object_get_data (data, "target");
7617 gtk_window_get_position (window, &x, &y);
7619 gtk_window_move (window, x, y);
7623 set_geometry_callback (GtkWidget *entry,
7629 target = GTK_WINDOW (g_object_get_data (G_OBJECT (data), "target"));
7631 text = gtk_editable_get_chars (GTK_EDITABLE (entry), 0, -1);
7633 if (!gtk_window_parse_geometry (target, text))
7634 g_print ("Bad geometry string '%s'\n", text);
7640 resizable_callback (GtkWidget *widget,
7643 g_object_set (g_object_get_data (data, "target"),
7644 "resizable", gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget)),
7649 gravity_selected (GtkWidget *widget,
7652 gtk_window_set_gravity (GTK_WINDOW (g_object_get_data (data, "target")),
7653 gtk_combo_box_get_active (GTK_COMBO_BOX (widget)) + GDK_GRAVITY_NORTH_WEST);
7657 pos_selected (GtkWidget *widget,
7660 gtk_window_set_position (GTK_WINDOW (g_object_get_data (data, "target")),
7661 gtk_combo_box_get_active (GTK_COMBO_BOX (widget)) + GTK_WIN_POS_NONE);
7665 move_gravity_window_to_current_position (GtkWidget *widget,
7671 window = GTK_WINDOW (data);
7673 gtk_window_get_position (window, &x, &y);
7675 gtk_window_move (window, x, y);
7679 get_screen_corner (GtkWindow *window,
7684 GdkScreen * screen = gtk_window_get_screen (window);
7686 gtk_window_get_size (GTK_WINDOW (window), &w, &h);
7688 switch (gtk_window_get_gravity (window))
7690 case GDK_GRAVITY_SOUTH_EAST:
7691 *x = gdk_screen_get_width (screen) - w;
7692 *y = gdk_screen_get_height (screen) - h;
7695 case GDK_GRAVITY_NORTH_EAST:
7696 *x = gdk_screen_get_width (screen) - w;
7700 case GDK_GRAVITY_SOUTH_WEST:
7702 *y = gdk_screen_get_height (screen) - h;
7705 case GDK_GRAVITY_NORTH_WEST:
7710 case GDK_GRAVITY_SOUTH:
7711 *x = (gdk_screen_get_width (screen) - w) / 2;
7712 *y = gdk_screen_get_height (screen) - h;
7715 case GDK_GRAVITY_NORTH:
7716 *x = (gdk_screen_get_width (screen) - w) / 2;
7720 case GDK_GRAVITY_WEST:
7722 *y = (gdk_screen_get_height (screen) - h) / 2;
7725 case GDK_GRAVITY_EAST:
7726 *x = gdk_screen_get_width (screen) - w;
7727 *y = (gdk_screen_get_height (screen) - h) / 2;
7730 case GDK_GRAVITY_CENTER:
7731 *x = (gdk_screen_get_width (screen) - w) / 2;
7732 *y = (gdk_screen_get_height (screen) - h) / 2;
7735 case GDK_GRAVITY_STATIC:
7736 /* pick some random numbers */
7742 g_assert_not_reached ();
7748 move_gravity_window_to_starting_position (GtkWidget *widget,
7754 window = GTK_WINDOW (data);
7756 get_screen_corner (window,
7759 gtk_window_move (window, x, y);
7763 make_gravity_window (GtkWidget *destroy_with,
7772 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
7774 gtk_window_set_screen (GTK_WINDOW (window),
7775 gtk_widget_get_screen (destroy_with));
7777 vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
7778 gtk_widget_show (vbox);
7780 gtk_container_add (GTK_CONTAINER (window), vbox);
7781 gtk_window_set_title (GTK_WINDOW (window), title);
7782 gtk_window_set_gravity (GTK_WINDOW (window), gravity);
7784 g_signal_connect_object (destroy_with,
7786 G_CALLBACK (gtk_widget_destroy),
7791 button = gtk_button_new_with_mnemonic ("_Move to current position");
7793 g_signal_connect (button, "clicked",
7794 G_CALLBACK (move_gravity_window_to_current_position),
7797 gtk_container_add (GTK_CONTAINER (vbox), button);
7798 gtk_widget_show (button);
7800 button = gtk_button_new_with_mnemonic ("Move to _starting position");
7802 g_signal_connect (button, "clicked",
7803 G_CALLBACK (move_gravity_window_to_starting_position),
7806 gtk_container_add (GTK_CONTAINER (vbox), button);
7807 gtk_widget_show (button);
7809 /* Pretend this is the result of --geometry.
7810 * DO NOT COPY THIS CODE unless you are setting --geometry results,
7811 * and in that case you probably should just use gtk_window_parse_geometry().
7812 * AGAIN, DO NOT SET GDK_HINT_USER_POS! It violates the ICCCM unless
7813 * you are parsing --geometry or equivalent.
7815 gtk_window_set_geometry_hints (GTK_WINDOW (window),
7819 gtk_window_set_default_size (GTK_WINDOW (window),
7822 get_screen_corner (GTK_WINDOW (window), &x, &y);
7824 gtk_window_move (GTK_WINDOW (window),
7831 do_gravity_test (GtkWidget *widget,
7834 GtkWidget *destroy_with = data;
7837 /* We put a window at each gravity point on the screen. */
7838 window = make_gravity_window (destroy_with, GDK_GRAVITY_NORTH_WEST,
7840 gtk_widget_show (window);
7842 window = make_gravity_window (destroy_with, GDK_GRAVITY_SOUTH_EAST,
7844 gtk_widget_show (window);
7846 window = make_gravity_window (destroy_with, GDK_GRAVITY_NORTH_EAST,
7848 gtk_widget_show (window);
7850 window = make_gravity_window (destroy_with, GDK_GRAVITY_SOUTH_WEST,
7852 gtk_widget_show (window);
7854 window = make_gravity_window (destroy_with, GDK_GRAVITY_SOUTH,
7856 gtk_widget_show (window);
7858 window = make_gravity_window (destroy_with, GDK_GRAVITY_NORTH,
7860 gtk_widget_show (window);
7863 window = make_gravity_window (destroy_with, GDK_GRAVITY_WEST,
7865 gtk_widget_show (window);
7868 window = make_gravity_window (destroy_with, GDK_GRAVITY_EAST,
7870 gtk_widget_show (window);
7872 window = make_gravity_window (destroy_with, GDK_GRAVITY_CENTER,
7874 gtk_widget_show (window);
7876 window = make_gravity_window (destroy_with, GDK_GRAVITY_STATIC,
7878 gtk_widget_show (window);
7882 window_controls (GtkWidget *window)
7884 GtkWidget *control_window;
7894 control_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
7896 gtk_window_set_screen (GTK_WINDOW (control_window),
7897 gtk_widget_get_screen (window));
7899 gtk_window_set_title (GTK_WINDOW (control_window), "Size controls");
7901 g_object_set_data (G_OBJECT (control_window),
7905 g_signal_connect_object (control_window,
7907 G_CALLBACK (gtk_widget_destroy),
7911 vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
7913 gtk_container_add (GTK_CONTAINER (control_window), vbox);
7915 label = gtk_label_new ("<no configure events>");
7916 gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
7918 g_signal_connect (window,
7920 G_CALLBACK (configure_event_callback),
7923 adj = gtk_adjustment_new (10.0, -2000.0, 2000.0, 1.0, 5.0, 0.0);
7924 spin = gtk_spin_button_new (adj, 0, 0);
7926 gtk_box_pack_start (GTK_BOX (vbox), spin, FALSE, FALSE, 0);
7928 g_object_set_data (G_OBJECT (control_window), "spin1", spin);
7930 adj = gtk_adjustment_new (10.0, -2000.0, 2000.0, 1.0, 5.0, 0.0);
7931 spin = gtk_spin_button_new (adj, 0, 0);
7933 gtk_box_pack_start (GTK_BOX (vbox), spin, FALSE, FALSE, 0);
7935 g_object_set_data (G_OBJECT (control_window), "spin2", spin);
7937 entry = gtk_entry_new ();
7938 gtk_box_pack_start (GTK_BOX (vbox), entry, FALSE, FALSE, 0);
7940 g_signal_connect (entry, "changed",
7941 G_CALLBACK (set_geometry_callback),
7944 button = gtk_button_new_with_label ("Show gravity test windows");
7945 g_signal_connect_swapped (button,
7947 G_CALLBACK (do_gravity_test),
7949 gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
7951 button = gtk_button_new_with_label ("Reshow with initial size");
7952 g_signal_connect_object (button,
7954 G_CALLBACK (gtk_window_reshow_with_initial_size),
7957 gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
7959 button = gtk_button_new_with_label ("Queue resize");
7960 g_signal_connect_object (button,
7962 G_CALLBACK (gtk_widget_queue_resize),
7965 gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
7967 button = gtk_button_new_with_label ("Resize");
7968 g_signal_connect (button,
7970 G_CALLBACK (set_size_callback),
7972 gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
7974 button = gtk_button_new_with_label ("Set default size");
7975 g_signal_connect (button,
7977 G_CALLBACK (set_default_size_callback),
7979 gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
7981 button = gtk_button_new_with_label ("Unset default size");
7982 g_signal_connect (button,
7984 G_CALLBACK (unset_default_size_callback),
7986 gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
7988 button = gtk_button_new_with_label ("Set size request");
7989 g_signal_connect (button,
7991 G_CALLBACK (set_size_request_callback),
7993 gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
7995 button = gtk_button_new_with_label ("Unset size request");
7996 g_signal_connect (button,
7998 G_CALLBACK (unset_size_request_callback),
8000 gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
8002 button = gtk_button_new_with_label ("Move");
8003 g_signal_connect (button,
8005 G_CALLBACK (set_location_callback),
8007 gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
8009 button = gtk_button_new_with_label ("Move to current position");
8010 g_signal_connect (button,
8012 G_CALLBACK (move_to_position_callback),
8014 gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
8016 button = gtk_check_button_new_with_label ("Allow resize");
8017 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
8018 g_signal_connect (button,
8020 G_CALLBACK (resizable_callback),
8022 gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
8024 button = gtk_button_new_with_mnemonic ("_Show");
8025 g_signal_connect_object (button,
8027 G_CALLBACK (gtk_widget_show),
8030 gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
8032 button = gtk_button_new_with_mnemonic ("_Hide");
8033 g_signal_connect_object (button,
8035 G_CALLBACK (gtk_widget_hide),
8038 gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
8040 om = gtk_combo_box_text_new ();
8044 static gchar *names[] = {
8045 "GDK_GRAVITY_NORTH_WEST",
8046 "GDK_GRAVITY_NORTH",
8047 "GDK_GRAVITY_NORTH_EAST",
8049 "GDK_GRAVITY_CENTER",
8051 "GDK_GRAVITY_SOUTH_WEST",
8052 "GDK_GRAVITY_SOUTH",
8053 "GDK_GRAVITY_SOUTH_EAST",
8054 "GDK_GRAVITY_STATIC",
8058 g_assert (names[i]);
8059 gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (om), names[i]);
8064 g_signal_connect (om,
8066 G_CALLBACK (gravity_selected),
8069 gtk_box_pack_end (GTK_BOX (vbox), om, FALSE, FALSE, 0);
8072 om = gtk_combo_box_text_new ();
8076 static gchar *names[] = {
8078 "GTK_WIN_POS_CENTER",
8079 "GTK_WIN_POS_MOUSE",
8080 "GTK_WIN_POS_CENTER_ALWAYS",
8081 "GTK_WIN_POS_CENTER_ON_PARENT",
8085 g_assert (names[i]);
8086 gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (om), names[i]);
8091 g_signal_connect (om,
8093 G_CALLBACK (pos_selected),
8096 gtk_box_pack_end (GTK_BOX (vbox), om, FALSE, FALSE, 0);
8098 gtk_widget_show_all (vbox);
8100 return control_window;
8104 create_window_sizing (GtkWidget *widget)
8106 static GtkWidget *window = NULL;
8107 static GtkWidget *target_window = NULL;
8113 target_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
8114 gtk_window_set_screen (GTK_WINDOW (target_window),
8115 gtk_widget_get_screen (widget));
8116 label = gtk_label_new (NULL);
8117 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");
8118 gtk_container_add (GTK_CONTAINER (target_window), label);
8119 gtk_widget_show (label);
8121 g_signal_connect (target_window, "destroy",
8122 G_CALLBACK (gtk_widget_destroyed),
8125 window = window_controls (target_window);
8127 g_signal_connect (window, "destroy",
8128 G_CALLBACK (gtk_widget_destroyed),
8131 gtk_window_set_title (GTK_WINDOW (target_window), "Window to size");
8134 /* don't show target window by default, we want to allow testing
8135 * of behavior on first show.
8138 if (!gtk_widget_get_visible (window))
8139 gtk_widget_show (window);
8141 gtk_widget_destroy (window);
8148 typedef struct _ProgressData {
8151 GtkWidget *block_spin;
8152 GtkWidget *x_align_spin;
8153 GtkWidget *y_align_spin;
8154 GtkWidget *step_spin;
8155 GtkWidget *act_blocks_spin;
8166 progress_timeout (gpointer data)
8168 ProgressData *pdata = data;
8172 if (pdata->activity)
8174 gtk_progress_bar_pulse (GTK_PROGRESS_BAR (pdata->pbar));
8176 text = g_strdup_printf ("%s", "???");
8180 new_val = gtk_progress_bar_get_fraction (GTK_PROGRESS_BAR (pdata->pbar)) + 0.01;
8183 gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR (pdata->pbar), new_val);
8185 text = g_strdup_printf ("%.0f%%", 100 * new_val);
8188 gtk_label_set_text (GTK_LABEL (pdata->label), text);
8195 destroy_progress (GtkWidget *widget,
8196 ProgressData **pdata)
8198 g_source_remove ((*pdata)->timer);
8199 (*pdata)->timer = 0;
8200 (*pdata)->window = NULL;
8206 progressbar_toggle_orientation (GtkWidget *widget, gpointer data)
8208 ProgressData *pdata;
8211 pdata = (ProgressData *) data;
8213 if (!gtk_widget_get_mapped (widget))
8216 i = gtk_combo_box_get_active (GTK_COMBO_BOX (widget));
8218 if (i == 0 || i == 1)
8219 gtk_orientable_set_orientation (GTK_ORIENTABLE (pdata->pbar), GTK_ORIENTATION_HORIZONTAL);
8221 gtk_orientable_set_orientation (GTK_ORIENTABLE (pdata->pbar), GTK_ORIENTATION_VERTICAL);
8223 if (i == 1 || i == 2)
8224 gtk_progress_bar_set_inverted (GTK_PROGRESS_BAR (pdata->pbar), TRUE);
8226 gtk_progress_bar_set_inverted (GTK_PROGRESS_BAR (pdata->pbar), FALSE);
8230 toggle_show_text (GtkWidget *widget, ProgressData *pdata)
8234 active = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget));
8235 gtk_progress_bar_set_show_text (GTK_PROGRESS_BAR (pdata->pbar), active);
8239 progressbar_toggle_ellipsize (GtkWidget *widget,
8242 ProgressData *pdata = data;
8243 if (gtk_widget_is_drawable (widget))
8245 gint i = gtk_combo_box_get_active (GTK_COMBO_BOX (widget));
8246 gtk_progress_bar_set_ellipsize (GTK_PROGRESS_BAR (pdata->pbar), i);
8251 toggle_activity_mode (GtkWidget *widget, ProgressData *pdata)
8253 pdata->activity = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget));
8257 entry_changed (GtkWidget *widget, ProgressData *pdata)
8259 gtk_progress_bar_set_text (GTK_PROGRESS_BAR (pdata->pbar),
8260 gtk_entry_get_text (GTK_ENTRY (pdata->entry)));
8264 create_progress_bar (GtkWidget *widget)
8266 GtkWidget *action_area, *content_area;
8276 static ProgressData *pdata = NULL;
8278 static gchar *items1[] =
8286 static char *ellipsize_items[] = {
8287 "None", // PANGO_ELLIPSIZE_NONE,
8288 "Start", // PANGO_ELLIPSIZE_START,
8289 "Middle", // PANGO_ELLIPSIZE_MIDDLE,
8290 "End", // PANGO_ELLIPSIZE_END
8294 pdata = g_new0 (ProgressData, 1);
8298 pdata->window = gtk_dialog_new ();
8300 gtk_window_set_screen (GTK_WINDOW (pdata->window),
8301 gtk_widget_get_screen (widget));
8303 gtk_window_set_resizable (GTK_WINDOW (pdata->window), TRUE);
8305 g_signal_connect (pdata->window, "destroy",
8306 G_CALLBACK (destroy_progress),
8310 content_area = gtk_dialog_get_content_area (GTK_DIALOG (pdata->window));
8311 action_area = gtk_dialog_get_action_area (GTK_DIALOG (pdata->window));
8313 gtk_window_set_title (GTK_WINDOW (pdata->window), "GtkProgressBar");
8314 gtk_container_set_border_width (GTK_CONTAINER (pdata->window), 0);
8316 vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
8317 gtk_container_set_border_width (GTK_CONTAINER (vbox), 10);
8318 gtk_box_pack_start (GTK_BOX (content_area), vbox, FALSE, TRUE, 0);
8320 frame = gtk_frame_new ("Progress");
8321 gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, TRUE, 0);
8323 vbox2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
8324 gtk_container_add (GTK_CONTAINER (frame), vbox2);
8326 align = gtk_alignment_new (0.5, 0.5, 0, 0);
8327 gtk_box_pack_start (GTK_BOX (vbox2), align, FALSE, FALSE, 5);
8329 pdata->pbar = gtk_progress_bar_new ();
8330 gtk_progress_bar_set_ellipsize (GTK_PROGRESS_BAR (pdata->pbar),
8331 PANGO_ELLIPSIZE_MIDDLE);
8333 gtk_container_add (GTK_CONTAINER (align), pdata->pbar);
8334 pdata->timer = g_timeout_add (100, (GSourceFunc)progress_timeout, pdata);
8336 align = gtk_alignment_new (0.5, 0.5, 0, 0);
8337 gtk_box_pack_start (GTK_BOX (vbox2), align, FALSE, FALSE, 5);
8339 hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 5);
8340 gtk_container_add (GTK_CONTAINER (align), hbox);
8341 label = gtk_label_new ("Label updated by user :");
8342 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
8343 pdata->label = gtk_label_new ("");
8344 gtk_box_pack_start (GTK_BOX (hbox), pdata->label, FALSE, TRUE, 0);
8346 frame = gtk_frame_new ("Options");
8347 gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, TRUE, 0);
8349 vbox2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
8350 gtk_container_add (GTK_CONTAINER (frame), vbox2);
8352 tab = gtk_table_new (7, 2, FALSE);
8353 gtk_box_pack_start (GTK_BOX (vbox2), tab, FALSE, TRUE, 0);
8355 label = gtk_label_new ("Orientation :");
8356 gtk_table_attach (GTK_TABLE (tab), label, 0, 1, 0, 1,
8357 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
8359 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
8361 pdata->omenu1 = build_option_menu (items1, 4, 0,
8362 progressbar_toggle_orientation,
8364 hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
8365 gtk_table_attach (GTK_TABLE (tab), hbox, 1, 2, 0, 1,
8366 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
8368 gtk_box_pack_start (GTK_BOX (hbox), pdata->omenu1, TRUE, TRUE, 0);
8370 check = gtk_check_button_new_with_label ("Show text");
8371 g_signal_connect (check, "clicked",
8372 G_CALLBACK (toggle_show_text),
8374 gtk_table_attach (GTK_TABLE (tab), check, 0, 1, 1, 2,
8375 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
8378 hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
8379 gtk_table_attach (GTK_TABLE (tab), hbox, 1, 2, 1, 2,
8380 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
8383 label = gtk_label_new ("Text: ");
8384 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
8386 pdata->entry = gtk_entry_new ();
8387 g_signal_connect (pdata->entry, "changed",
8388 G_CALLBACK (entry_changed),
8390 gtk_box_pack_start (GTK_BOX (hbox), pdata->entry, TRUE, TRUE, 0);
8391 gtk_widget_set_size_request (pdata->entry, 100, -1);
8393 label = gtk_label_new ("Ellipsize text :");
8394 gtk_table_attach (GTK_TABLE (tab), label, 0, 1, 10, 11,
8395 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
8397 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
8398 pdata->elmenu = build_option_menu (ellipsize_items,
8399 sizeof (ellipsize_items) / sizeof (ellipsize_items[0]),
8400 2, // PANGO_ELLIPSIZE_MIDDLE
8401 progressbar_toggle_ellipsize,
8403 hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
8404 gtk_table_attach (GTK_TABLE (tab), hbox, 1, 2, 10, 11,
8405 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
8407 gtk_box_pack_start (GTK_BOX (hbox), pdata->elmenu, TRUE, TRUE, 0);
8409 check = gtk_check_button_new_with_label ("Activity mode");
8410 g_signal_connect (check, "clicked",
8411 G_CALLBACK (toggle_activity_mode), pdata);
8412 gtk_table_attach (GTK_TABLE (tab), check, 0, 1, 15, 16,
8413 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
8416 button = gtk_button_new_with_label ("close");
8417 g_signal_connect_swapped (button, "clicked",
8418 G_CALLBACK (gtk_widget_destroy),
8420 gtk_widget_set_can_default (button, TRUE);
8421 gtk_box_pack_start (GTK_BOX (action_area), button, TRUE, TRUE, 0);
8422 gtk_widget_grab_default (button);
8425 if (!gtk_widget_get_visible (pdata->window))
8426 gtk_widget_show_all (pdata->window);
8428 gtk_widget_destroy (pdata->window);
8440 GtkWidget *res_widget;
8444 find_widget (GtkWidget *widget, FindWidgetData *data)
8446 GtkAllocation new_allocation;
8450 gtk_widget_get_allocation (widget, &new_allocation);
8452 if (data->found || !gtk_widget_get_mapped (widget))
8455 /* Note that in the following code, we only count the
8456 * position as being inside a WINDOW widget if it is inside
8457 * widget->window; points that are outside of widget->window
8458 * but within the allocation are not counted. This is consistent
8459 * with the way we highlight drag targets.
8461 if (gtk_widget_get_has_window (widget))
8463 new_allocation.x = 0;
8464 new_allocation.y = 0;
8467 if (gtk_widget_get_parent (widget) && !data->first)
8469 GdkWindow *window = gtk_widget_get_window (widget);
8470 while (window != gtk_widget_get_window (gtk_widget_get_parent (widget)))
8472 gint tx, ty, twidth, theight;
8474 twidth = gdk_window_get_width (window);
8475 theight = gdk_window_get_height (window);
8477 if (new_allocation.x < 0)
8479 new_allocation.width += new_allocation.x;
8480 new_allocation.x = 0;
8482 if (new_allocation.y < 0)
8484 new_allocation.height += new_allocation.y;
8485 new_allocation.y = 0;
8487 if (new_allocation.x + new_allocation.width > twidth)
8488 new_allocation.width = twidth - new_allocation.x;
8489 if (new_allocation.y + new_allocation.height > theight)
8490 new_allocation.height = theight - new_allocation.y;
8492 gdk_window_get_position (window, &tx, &ty);
8493 new_allocation.x += tx;
8495 new_allocation.y += ty;
8498 window = gdk_window_get_parent (window);
8502 if ((data->x >= new_allocation.x) && (data->y >= new_allocation.y) &&
8503 (data->x < new_allocation.x + new_allocation.width) &&
8504 (data->y < new_allocation.y + new_allocation.height))
8506 /* First, check if the drag is in a valid drop site in
8507 * one of our children
8509 if (GTK_IS_CONTAINER (widget))
8511 FindWidgetData new_data = *data;
8513 new_data.x -= x_offset;
8514 new_data.y -= y_offset;
8515 new_data.found = FALSE;
8516 new_data.first = FALSE;
8518 gtk_container_forall (GTK_CONTAINER (widget),
8519 (GtkCallback)find_widget,
8522 data->found = new_data.found;
8524 data->res_widget = new_data.res_widget;
8527 /* If not, and this widget is registered as a drop site, check to
8528 * emit "drag_motion" to check if we are actually in
8534 data->res_widget = widget;
8540 find_widget_at_pointer (GdkDisplay *display)
8542 GtkWidget *widget = NULL;
8543 GdkWindow *pointer_window;
8545 FindWidgetData data;
8547 pointer_window = gdk_display_get_window_at_pointer (display, NULL, NULL);
8551 gpointer widget_ptr;
8553 gdk_window_get_user_data (pointer_window, &widget_ptr);
8554 widget = widget_ptr;
8559 gdk_window_get_pointer (gtk_widget_get_window (widget),
8567 find_widget (widget, &data);
8569 return data.res_widget;
8575 struct PropertiesData {
8583 destroy_properties (GtkWidget *widget,
8584 struct PropertiesData *data)
8588 *data->window = NULL;
8589 data->window = NULL;
8594 gdk_cursor_unref (data->cursor);
8595 data->cursor = NULL;
8600 g_signal_handler_disconnect (widget, data->handler);
8608 property_query_event (GtkWidget *widget,
8610 struct PropertiesData *data)
8612 GtkWidget *res_widget = NULL;
8614 if (!data->in_query)
8617 if (event->type == GDK_BUTTON_RELEASE)
8619 gtk_grab_remove (widget);
8620 gdk_display_pointer_ungrab (gtk_widget_get_display (widget),
8623 res_widget = find_widget_at_pointer (gtk_widget_get_display (widget));
8626 g_object_set_data (G_OBJECT (res_widget), "prop-editor-screen",
8627 gtk_widget_get_screen (widget));
8628 create_prop_editor (G_OBJECT (res_widget), 0);
8631 data->in_query = FALSE;
8638 query_properties (GtkButton *button,
8639 struct PropertiesData *data)
8641 GtkWidget *widget = GTK_WIDGET (button);
8644 g_signal_connect (button, "event",
8645 G_CALLBACK (property_query_event), data);
8649 data->cursor = gdk_cursor_new_for_display (gtk_widget_get_display (widget),
8652 failure = gdk_pointer_grab (gtk_widget_get_window (widget),
8654 GDK_BUTTON_RELEASE_MASK,
8659 gtk_grab_add (widget);
8661 data->in_query = TRUE;
8665 create_properties (GtkWidget *widget)
8667 static GtkWidget *window = NULL;
8671 struct PropertiesData *data;
8673 data = g_new (struct PropertiesData, 1);
8674 data->window = &window;
8675 data->in_query = FALSE;
8676 data->cursor = NULL;
8681 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
8683 gtk_window_set_screen (GTK_WINDOW (window),
8684 gtk_widget_get_screen (widget));
8686 data->handler = g_signal_connect (window, "destroy",
8687 G_CALLBACK (destroy_properties),
8690 gtk_window_set_title (GTK_WINDOW (window), "test properties");
8691 gtk_container_set_border_width (GTK_CONTAINER (window), 10);
8693 vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 1);
8694 gtk_container_add (GTK_CONTAINER (window), vbox);
8696 label = gtk_label_new ("This is just a dumb test to test properties.\nIf you need a generic module, get GLE.");
8697 gtk_box_pack_start (GTK_BOX (vbox), label, TRUE, TRUE, 0);
8699 button = gtk_button_new_with_label ("Query properties");
8700 gtk_box_pack_start (GTK_BOX (vbox), button, TRUE, TRUE, 0);
8701 g_signal_connect (button, "clicked",
8702 G_CALLBACK (query_properties),
8706 if (!gtk_widget_get_visible (window))
8707 gtk_widget_show_all (window);
8709 gtk_widget_destroy (window);
8713 struct SnapshotData {
8714 GtkWidget *toplevel_button;
8718 gboolean is_toplevel;
8723 destroy_snapshot_data (GtkWidget *widget,
8724 struct SnapshotData *data)
8727 *data->window = NULL;
8731 gdk_cursor_unref (data->cursor);
8732 data->cursor = NULL;
8737 g_signal_handler_disconnect (widget, data->handler);
8745 snapshot_widget_event (GtkWidget *widget,
8747 struct SnapshotData *data)
8749 GtkWidget *res_widget = NULL;
8751 if (!data->in_query)
8754 if (event->type == GDK_BUTTON_RELEASE)
8756 gtk_grab_remove (widget);
8757 gdk_display_pointer_ungrab (gtk_widget_get_display (widget),
8760 res_widget = find_widget_at_pointer (gtk_widget_get_display (widget));
8761 if (data->is_toplevel && res_widget)
8762 res_widget = gtk_widget_get_toplevel (res_widget);
8765 cairo_surface_t *surface;
8766 GtkWidget *window, *image;
8771 width = gtk_widget_get_allocated_width (res_widget);
8772 height = gtk_widget_get_allocated_height (res_widget);
8774 surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, width, height);
8776 cr = cairo_create (surface);
8777 gtk_widget_draw (res_widget, cr);
8780 pixbuf = gdk_pixbuf_get_from_surface (surface,
8783 cairo_surface_destroy (surface);
8785 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
8786 image = gtk_image_new_from_pixbuf (pixbuf);
8787 g_object_unref (pixbuf);
8789 gtk_container_add (GTK_CONTAINER (window), image);
8790 gtk_widget_show_all (window);
8793 data->in_query = FALSE;
8800 snapshot_widget (GtkButton *button,
8801 struct SnapshotData *data)
8803 GtkWidget *widget = GTK_WIDGET (button);
8806 g_signal_connect (button, "event",
8807 G_CALLBACK (snapshot_widget_event), data);
8809 data->is_toplevel = widget == data->toplevel_button;
8812 data->cursor = gdk_cursor_new_for_display (gtk_widget_get_display (widget),
8815 failure = gdk_pointer_grab (gtk_widget_get_window (widget),
8817 GDK_BUTTON_RELEASE_MASK,
8822 gtk_grab_add (widget);
8824 data->in_query = TRUE;
8828 create_snapshot (GtkWidget *widget)
8830 static GtkWidget *window = NULL;
8833 struct SnapshotData *data;
8835 data = g_new (struct SnapshotData, 1);
8836 data->window = &window;
8837 data->in_query = FALSE;
8838 data->cursor = NULL;
8843 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
8845 gtk_window_set_screen (GTK_WINDOW (window),
8846 gtk_widget_get_screen (widget));
8848 data->handler = g_signal_connect (window, "destroy",
8849 G_CALLBACK (destroy_snapshot_data),
8852 gtk_window_set_title (GTK_WINDOW (window), "test snapshot");
8853 gtk_container_set_border_width (GTK_CONTAINER (window), 10);
8855 vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 1);
8856 gtk_container_add (GTK_CONTAINER (window), vbox);
8858 button = gtk_button_new_with_label ("Snapshot widget");
8859 gtk_box_pack_start (GTK_BOX (vbox), button, TRUE, TRUE, 0);
8860 g_signal_connect (button, "clicked",
8861 G_CALLBACK (snapshot_widget),
8864 button = gtk_button_new_with_label ("Snapshot toplevel");
8865 data->toplevel_button = button;
8866 gtk_box_pack_start (GTK_BOX (vbox), button, TRUE, TRUE, 0);
8867 g_signal_connect (button, "clicked",
8868 G_CALLBACK (snapshot_widget),
8872 if (!gtk_widget_get_visible (window))
8873 gtk_widget_show_all (window);
8875 gtk_widget_destroy (window);
8884 selection_test_received (GtkWidget *tree_view,
8885 GtkSelectionData *data)
8887 GtkTreeModel *model;
8888 GtkListStore *store;
8892 if (data->length < 0)
8894 g_print ("Selection retrieval failed\n");
8897 if (data->type != GDK_SELECTION_TYPE_ATOM)
8899 g_print ("Selection \"TARGETS\" was not returned as atoms!\n");
8903 /* Clear out any current list items */
8905 model = gtk_tree_view_get_model (GTK_TREE_VIEW (tree_view));
8906 store = GTK_LIST_STORE (model);
8907 gtk_list_store_clear (store);
8909 /* Add new items to list */
8911 atoms = (GdkAtom *)data->data;
8913 l = data->length / sizeof (GdkAtom);
8914 for (i = 0; i < l; i++)
8919 name = gdk_atom_name (atoms[i]);
8922 gtk_list_store_insert_with_values (store, &iter, i, 0, name, -1);
8926 gtk_list_store_insert_with_values (store, &iter, i, 0, "(bad atom)", -1);
8933 selection_test_get_targets (GtkWidget *widget, GtkWidget *tree_view)
8935 static GdkAtom targets_atom = GDK_NONE;
8937 if (targets_atom == GDK_NONE)
8938 targets_atom = gdk_atom_intern ("TARGETS", FALSE);
8940 gtk_selection_convert (tree_view, GDK_SELECTION_PRIMARY, targets_atom,
8945 create_selection_test (GtkWidget *widget)
8947 static GtkWidget *window = NULL;
8948 GtkWidget *action_area, *content_area;
8951 GtkWidget *scrolled_win;
8952 GtkListStore* store;
8953 GtkWidget *tree_view;
8954 GtkTreeViewColumn *column;
8955 GtkCellRenderer *renderer;
8960 window = gtk_dialog_new ();
8962 gtk_window_set_screen (GTK_WINDOW (window),
8963 gtk_widget_get_screen (widget));
8965 g_signal_connect (window, "destroy",
8966 G_CALLBACK (gtk_widget_destroyed),
8969 content_area = gtk_dialog_get_content_area (GTK_DIALOG (window));
8970 action_area = gtk_dialog_get_action_area (GTK_DIALOG (window));
8972 gtk_window_set_title (GTK_WINDOW (window), "Selection Test");
8973 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
8975 /* Create the list */
8977 vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
8978 gtk_container_set_border_width (GTK_CONTAINER (vbox), 10);
8979 gtk_box_pack_start (GTK_BOX (content_area), vbox, TRUE, TRUE, 0);
8981 label = gtk_label_new ("Gets available targets for current selection");
8982 gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
8984 scrolled_win = gtk_scrolled_window_new (NULL, NULL);
8985 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
8986 GTK_POLICY_AUTOMATIC,
8987 GTK_POLICY_AUTOMATIC);
8988 gtk_box_pack_start (GTK_BOX (vbox), scrolled_win, TRUE, TRUE, 0);
8989 gtk_widget_set_size_request (scrolled_win, 100, 200);
8991 store = gtk_list_store_new (1, G_TYPE_STRING);
8992 tree_view = gtk_tree_view_new_with_model (GTK_TREE_MODEL (store));
8993 gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (scrolled_win), tree_view);
8995 renderer = gtk_cell_renderer_text_new ();
8996 column = gtk_tree_view_column_new_with_attributes ("Target", renderer,
8998 gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), column);
9000 g_signal_connect (tree_view, "selection_received",
9001 G_CALLBACK (selection_test_received), NULL);
9003 /* .. And create some buttons */
9004 button = gtk_button_new_with_label ("Get Targets");
9005 gtk_box_pack_start (GTK_BOX (action_area), button, TRUE, TRUE, 0);
9007 g_signal_connect (button, "clicked",
9008 G_CALLBACK (selection_test_get_targets), tree_view);
9010 button = gtk_button_new_with_label ("Quit");
9011 gtk_box_pack_start (GTK_BOX (action_area), button, TRUE, TRUE, 0);
9013 g_signal_connect_swapped (button, "clicked",
9014 G_CALLBACK (gtk_widget_destroy),
9018 if (!gtk_widget_get_visible (window))
9019 gtk_widget_show_all (window);
9021 gtk_widget_destroy (window);
9028 static int scroll_test_pos = 0.0;
9031 scroll_test_draw (GtkWidget *widget,
9036 gint imin, imax, jmin, jmax;
9039 gdk_cairo_get_clip_rectangle (cr, &clip);
9041 imin = (clip.x) / 10;
9042 imax = (clip.x + clip.width + 9) / 10;
9044 jmin = ((int)adj->value + clip.y) / 10;
9045 jmax = ((int)adj->value + clip.y + clip.height + 9) / 10;
9047 for (i=imin; i<imax; i++)
9048 for (j=jmin; j<jmax; j++)
9050 cairo_rectangle (cr, 10*i, 10*j - (int)adj->value, 1+i%10, 1+j%10);
9058 scroll_test_scroll (GtkWidget *widget, GdkEventScroll *event,
9061 gdouble new_value = adj->value + ((event->direction == GDK_SCROLL_UP) ?
9062 -adj->page_increment / 2:
9063 adj->page_increment / 2);
9064 new_value = CLAMP (new_value, adj->lower, adj->upper - adj->page_size);
9065 gtk_adjustment_set_value (adj, new_value);
9071 scroll_test_configure (GtkWidget *widget, GdkEventConfigure *event,
9074 GtkAllocation allocation;
9076 gtk_widget_get_allocation (widget, &allocation);
9077 adj->page_increment = 0.9 * allocation.height;
9078 adj->page_size = allocation.height;
9080 g_signal_emit_by_name (adj, "changed");
9084 scroll_test_adjustment_changed (GtkAdjustment *adj, GtkWidget *widget)
9089 dy = scroll_test_pos - (int)adj->value;
9090 scroll_test_pos = adj->value;
9092 if (!gtk_widget_is_drawable (widget))
9095 window = gtk_widget_get_window (widget);
9096 gdk_window_scroll (window, 0, dy);
9097 gdk_window_process_updates (window, FALSE);
9102 create_scroll_test (GtkWidget *widget)
9104 static GtkWidget *window = NULL;
9105 GtkWidget *action_area, *content_area;
9107 GtkWidget *drawing_area;
9108 GtkWidget *scrollbar;
9111 GdkGeometry geometry;
9112 GdkWindowHints geometry_mask;
9116 window = gtk_dialog_new ();
9118 gtk_window_set_screen (GTK_WINDOW (window),
9119 gtk_widget_get_screen (widget));
9121 g_signal_connect (window, "destroy",
9122 G_CALLBACK (gtk_widget_destroyed),
9125 content_area = gtk_dialog_get_content_area (GTK_DIALOG (window));
9126 action_area = gtk_dialog_get_action_area (GTK_DIALOG (window));
9128 gtk_window_set_title (GTK_WINDOW (window), "Scroll Test");
9129 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
9131 hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
9132 gtk_box_pack_start (GTK_BOX (content_area), hbox, TRUE, TRUE, 0);
9133 gtk_widget_show (hbox);
9135 drawing_area = gtk_drawing_area_new ();
9136 gtk_widget_set_size_request (drawing_area, 200, 200);
9137 gtk_box_pack_start (GTK_BOX (hbox), drawing_area, TRUE, TRUE, 0);
9138 gtk_widget_show (drawing_area);
9140 gtk_widget_set_events (drawing_area, GDK_EXPOSURE_MASK | GDK_SCROLL_MASK);
9142 adj = gtk_adjustment_new (0.0, 0.0, 1000.0, 1.0, 180.0, 200.0);
9143 scroll_test_pos = 0.0;
9145 scrollbar = gtk_scrollbar_new (GTK_ORIENTATION_VERTICAL, adj);
9146 gtk_box_pack_start (GTK_BOX (hbox), scrollbar, FALSE, FALSE, 0);
9147 gtk_widget_show (scrollbar);
9149 g_signal_connect (drawing_area, "draw",
9150 G_CALLBACK (scroll_test_draw), adj);
9151 g_signal_connect (drawing_area, "configure_event",
9152 G_CALLBACK (scroll_test_configure), adj);
9153 g_signal_connect (drawing_area, "scroll_event",
9154 G_CALLBACK (scroll_test_scroll), adj);
9156 g_signal_connect (adj, "value_changed",
9157 G_CALLBACK (scroll_test_adjustment_changed),
9160 /* .. And create some buttons */
9162 button = gtk_button_new_with_label ("Quit");
9163 gtk_box_pack_start (GTK_BOX (action_area), button, TRUE, TRUE, 0);
9165 g_signal_connect_swapped (button, "clicked",
9166 G_CALLBACK (gtk_widget_destroy),
9168 gtk_widget_show (button);
9170 /* Set up gridded geometry */
9172 geometry_mask = GDK_HINT_MIN_SIZE |
9173 GDK_HINT_BASE_SIZE |
9174 GDK_HINT_RESIZE_INC;
9176 geometry.min_width = 20;
9177 geometry.min_height = 20;
9178 geometry.base_width = 0;
9179 geometry.base_height = 0;
9180 geometry.width_inc = 10;
9181 geometry.height_inc = 10;
9183 gtk_window_set_geometry_hints (GTK_WINDOW (window),
9184 drawing_area, &geometry, geometry_mask);
9187 if (!gtk_widget_get_visible (window))
9188 gtk_widget_show (window);
9190 gtk_widget_destroy (window);
9197 static int timer = 0;
9200 timeout_test (GtkWidget *label)
9202 static int count = 0;
9203 static char buffer[32];
9205 sprintf (buffer, "count: %d", ++count);
9206 gtk_label_set_text (GTK_LABEL (label), buffer);
9212 start_timeout_test (GtkWidget *widget,
9217 timer = g_timeout_add (100, (GSourceFunc)timeout_test, label);
9222 stop_timeout_test (GtkWidget *widget,
9227 g_source_remove (timer);
9233 destroy_timeout_test (GtkWidget *widget,
9236 stop_timeout_test (NULL, NULL);
9242 create_timeout_test (GtkWidget *widget)
9244 static GtkWidget *window = NULL;
9245 GtkWidget *action_area, *content_area;
9251 window = gtk_dialog_new ();
9253 gtk_window_set_screen (GTK_WINDOW (window),
9254 gtk_widget_get_screen (widget));
9256 g_signal_connect (window, "destroy",
9257 G_CALLBACK (destroy_timeout_test),
9260 content_area = gtk_dialog_get_content_area (GTK_DIALOG (window));
9261 action_area = gtk_dialog_get_content_area (GTK_DIALOG (window));
9263 gtk_window_set_title (GTK_WINDOW (window), "Timeout Test");
9264 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
9266 label = gtk_label_new ("count: 0");
9267 gtk_misc_set_padding (GTK_MISC (label), 10, 10);
9268 gtk_box_pack_start (GTK_BOX (content_area), label, TRUE, TRUE, 0);
9269 gtk_widget_show (label);
9271 button = gtk_button_new_with_label ("close");
9272 g_signal_connect_swapped (button, "clicked",
9273 G_CALLBACK (gtk_widget_destroy),
9275 gtk_widget_set_can_default (button, TRUE);
9276 gtk_box_pack_start (GTK_BOX (action_area), button, TRUE, TRUE, 0);
9277 gtk_widget_grab_default (button);
9278 gtk_widget_show (button);
9280 button = gtk_button_new_with_label ("start");
9281 g_signal_connect (button, "clicked",
9282 G_CALLBACK(start_timeout_test),
9284 gtk_widget_set_can_default (button, TRUE);
9285 gtk_box_pack_start (GTK_BOX (action_area), button, TRUE, TRUE, 0);
9286 gtk_widget_show (button);
9288 button = gtk_button_new_with_label ("stop");
9289 g_signal_connect (button, "clicked",
9290 G_CALLBACK (stop_timeout_test),
9292 gtk_widget_set_can_default (button, TRUE);
9293 gtk_box_pack_start (GTK_BOX (action_area), button, TRUE, TRUE, 0);
9294 gtk_widget_show (button);
9297 if (!gtk_widget_get_visible (window))
9298 gtk_widget_show (window);
9300 gtk_widget_destroy (window);
9307 static int idle_id = 0;
9310 idle_test (GtkWidget *label)
9312 static int count = 0;
9313 static char buffer[32];
9315 sprintf (buffer, "count: %d", ++count);
9316 gtk_label_set_text (GTK_LABEL (label), buffer);
9322 start_idle_test (GtkWidget *widget,
9327 idle_id = g_idle_add ((GSourceFunc) idle_test, label);
9332 stop_idle_test (GtkWidget *widget,
9337 g_source_remove (idle_id);
9343 destroy_idle_test (GtkWidget *widget,
9346 stop_idle_test (NULL, NULL);
9352 toggle_idle_container (GObject *button,
9353 GtkContainer *container)
9355 gtk_container_set_resize_mode (container, GPOINTER_TO_INT (g_object_get_data (button, "user_data")));
9359 create_idle_test (GtkWidget *widget)
9361 static GtkWidget *window = NULL;
9364 GtkWidget *container;
9368 GtkWidget *action_area, *content_area;
9373 window = gtk_dialog_new ();
9375 gtk_window_set_screen (GTK_WINDOW (window),
9376 gtk_widget_get_screen (widget));
9378 g_signal_connect (window, "destroy",
9379 G_CALLBACK (destroy_idle_test),
9382 content_area = gtk_dialog_get_content_area (GTK_DIALOG (window));
9383 action_area = gtk_dialog_get_action_area (GTK_DIALOG (window));
9385 gtk_window_set_title (GTK_WINDOW (window), "Idle Test");
9386 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
9388 label = gtk_label_new ("count: 0");
9389 gtk_misc_set_padding (GTK_MISC (label), 10, 10);
9390 gtk_widget_show (label);
9393 g_object_new (GTK_TYPE_HBOX,
9395 /* "GtkContainer::child", g_object_new (GTK_TYPE_HBOX,
9396 * "GtkWidget::visible", TRUE,
9401 gtk_box_pack_start (GTK_BOX (content_area), container, TRUE, TRUE, 0);
9404 g_object_new (GTK_TYPE_FRAME,
9406 "label", "Label Container",
9408 "parent", content_area,
9411 g_object_new (GTK_TYPE_VBOX,
9416 g_object_connect (g_object_new (GTK_TYPE_RADIO_BUTTON,
9417 "label", "Resize-Parent",
9418 "user_data", (void*)GTK_RESIZE_PARENT,
9422 "signal::clicked", toggle_idle_container, container,
9424 button = g_object_new (GTK_TYPE_RADIO_BUTTON,
9425 "label", "Resize-Queue",
9426 "user_data", (void*)GTK_RESIZE_QUEUE,
9431 g_object_connect (button,
9432 "signal::clicked", toggle_idle_container, container,
9434 button2 = g_object_new (GTK_TYPE_RADIO_BUTTON,
9435 "label", "Resize-Immediate",
9436 "user_data", (void*)GTK_RESIZE_IMMEDIATE,
9438 g_object_connect (button2,
9439 "signal::clicked", toggle_idle_container, container,
9441 g_object_set (button2,
9447 button = gtk_button_new_with_label ("close");
9448 g_signal_connect_swapped (button, "clicked",
9449 G_CALLBACK (gtk_widget_destroy),
9451 gtk_widget_set_can_default (button, TRUE);
9452 gtk_box_pack_start (GTK_BOX (action_area), button, TRUE, TRUE, 0);
9453 gtk_widget_grab_default (button);
9454 gtk_widget_show (button);
9456 button = gtk_button_new_with_label ("start");
9457 g_signal_connect (button, "clicked",
9458 G_CALLBACK (start_idle_test),
9460 gtk_widget_set_can_default (button, TRUE);
9461 gtk_box_pack_start (GTK_BOX (action_area), button, TRUE, TRUE, 0);
9462 gtk_widget_show (button);
9464 button = gtk_button_new_with_label ("stop");
9465 g_signal_connect (button, "clicked",
9466 G_CALLBACK (stop_idle_test),
9468 gtk_widget_set_can_default (button, TRUE);
9469 gtk_box_pack_start (GTK_BOX (action_area), button, TRUE, TRUE, 0);
9470 gtk_widget_show (button);
9473 if (!gtk_widget_get_visible (window))
9474 gtk_widget_show (window);
9476 gtk_widget_destroy (window);
9484 reload_all_rc_files (void)
9486 static GdkAtom atom_rcfiles = GDK_NONE;
9488 GdkEvent *send_event = gdk_event_new (GDK_CLIENT_EVENT);
9492 atom_rcfiles = gdk_atom_intern("_GTK_READ_RCFILES", FALSE);
9494 for(i = 0; i < 5; i++)
9495 send_event->client.data.l[i] = 0;
9496 send_event->client.data_format = 32;
9497 send_event->client.message_type = atom_rcfiles;
9498 gdk_event_send_clientmessage_toall (send_event);
9500 gdk_event_free (send_event);
9504 create_rc_file (GtkWidget *widget)
9506 static GtkWidget *window = NULL;
9507 GtkWidget *action_area, *content_area;
9515 window = gtk_dialog_new ();
9517 gtk_window_set_screen (GTK_WINDOW (window),
9518 gtk_widget_get_screen (widget));
9520 g_signal_connect (window, "destroy",
9521 G_CALLBACK (gtk_widget_destroyed),
9524 content_area = gtk_dialog_get_content_area (GTK_DIALOG (window));
9525 action_area = gtk_dialog_get_action_area (GTK_DIALOG (window));
9527 frame = gtk_aspect_frame_new ("Testing RC file prioritization", 0.5, 0.5, 0.0, TRUE);
9528 gtk_box_pack_start (GTK_BOX (content_area), frame, FALSE, FALSE, 0);
9530 vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
9531 gtk_container_add (GTK_CONTAINER (frame), vbox);
9533 label = gtk_label_new ("This label should be red");
9534 gtk_widget_set_name (label, "testgtk-red-label");
9535 gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
9537 label = gtk_label_new ("This label should be green");
9538 gtk_widget_set_name (label, "testgtk-green-label");
9539 gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
9541 label = gtk_label_new ("This label should be blue");
9542 gtk_widget_set_name (label, "testgtk-blue-label");
9543 gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
9545 gtk_window_set_title (GTK_WINDOW (window), "Reload Rc file");
9546 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
9548 button = gtk_button_new_with_label ("Reload");
9549 g_signal_connect (button, "clicked",
9550 G_CALLBACK (gtk_rc_reparse_all), NULL);
9551 gtk_widget_set_can_default (button, TRUE);
9552 gtk_box_pack_start (GTK_BOX (action_area), button, TRUE, TRUE, 0);
9553 gtk_widget_grab_default (button);
9555 button = gtk_button_new_with_label ("Reload All");
9556 g_signal_connect (button, "clicked",
9557 G_CALLBACK (reload_all_rc_files), NULL);
9558 gtk_widget_set_can_default (button, TRUE);
9559 gtk_box_pack_start (GTK_BOX (action_area), button, TRUE, TRUE, 0);
9561 button = gtk_button_new_with_label ("Close");
9562 g_signal_connect_swapped (button, "clicked",
9563 G_CALLBACK (gtk_widget_destroy),
9565 gtk_widget_set_can_default (button, TRUE);
9566 gtk_box_pack_start (GTK_BOX (action_area), button, TRUE, TRUE, 0);
9569 if (!gtk_widget_get_visible (window))
9570 gtk_widget_show_all (window);
9572 gtk_widget_destroy (window);
9576 * Test of recursive mainloop
9580 mainloop_destroyed (GtkWidget *w, GtkWidget **window)
9587 create_mainloop (GtkWidget *widget)
9589 static GtkWidget *window = NULL;
9590 GtkWidget *action_area, *content_area;
9596 window = gtk_dialog_new ();
9598 gtk_window_set_screen (GTK_WINDOW (window),
9599 gtk_widget_get_screen (widget));
9601 gtk_window_set_title (GTK_WINDOW (window), "Test Main Loop");
9603 g_signal_connect (window, "destroy",
9604 G_CALLBACK (mainloop_destroyed),
9607 content_area = gtk_dialog_get_content_area (GTK_DIALOG (window));
9608 action_area = gtk_dialog_get_action_area (GTK_DIALOG (window));
9610 label = gtk_label_new ("In recursive main loop...");
9611 gtk_misc_set_padding (GTK_MISC(label), 20, 20);
9613 gtk_box_pack_start (GTK_BOX (content_area), label, TRUE, TRUE, 0);
9614 gtk_widget_show (label);
9616 button = gtk_button_new_with_label ("Leave");
9617 gtk_box_pack_start (GTK_BOX (action_area), button, FALSE, TRUE, 0);
9619 g_signal_connect_swapped (button, "clicked",
9620 G_CALLBACK (gtk_widget_destroy),
9623 gtk_widget_set_can_default (button, TRUE);
9624 gtk_widget_grab_default (button);
9626 gtk_widget_show (button);
9629 if (!gtk_widget_get_visible (window))
9631 gtk_widget_show (window);
9633 g_print ("create_mainloop: start\n");
9635 g_print ("create_mainloop: done\n");
9638 gtk_widget_destroy (window);
9642 layout_draw_handler (GtkWidget *widget, cairo_t *cr)
9645 GdkWindow *bin_window;
9648 gint imin, imax, jmin, jmax;
9650 layout = GTK_LAYOUT (widget);
9651 bin_window = gtk_layout_get_bin_window (layout);
9653 if (!gtk_cairo_should_draw_window (cr, bin_window))
9656 gdk_window_get_position (bin_window, &x, &y);
9657 cairo_translate (cr, x, y);
9659 gdk_cairo_get_clip_rectangle (cr, &clip);
9661 imin = (clip.x) / 10;
9662 imax = (clip.x + clip.width + 9) / 10;
9664 jmin = (clip.y) / 10;
9665 jmax = (clip.y + clip.height + 9) / 10;
9667 for (i=imin; i<imax; i++)
9668 for (j=jmin; j<jmax; j++)
9670 cairo_rectangle (cr,
9679 void create_layout (GtkWidget *widget)
9681 GtkAdjustment *hadjustment, *vadjustment;
9683 static GtkWidget *window = NULL;
9684 GtkWidget *layout_widget;
9685 GtkWidget *scrolledwindow;
9694 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
9695 gtk_window_set_screen (GTK_WINDOW (window),
9696 gtk_widget_get_screen (widget));
9698 g_signal_connect (window, "destroy",
9699 G_CALLBACK (gtk_widget_destroyed),
9702 gtk_window_set_title (GTK_WINDOW (window), "Layout");
9703 gtk_widget_set_size_request (window, 200, 200);
9705 scrolledwindow = gtk_scrolled_window_new (NULL, NULL);
9706 gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolledwindow),
9708 gtk_scrolled_window_set_placement (GTK_SCROLLED_WINDOW (scrolledwindow),
9709 GTK_CORNER_TOP_RIGHT);
9711 gtk_container_add (GTK_CONTAINER (window), scrolledwindow);
9713 layout_widget = gtk_layout_new (NULL, NULL);
9714 layout = GTK_LAYOUT (layout_widget);
9715 gtk_container_add (GTK_CONTAINER (scrolledwindow), layout_widget);
9717 /* We set step sizes here since GtkLayout does not set
9720 hadjustment = gtk_scrollable_get_hadjustment (GTK_SCROLLABLE (layout));
9721 vadjustment = gtk_scrollable_get_vadjustment (GTK_SCROLLABLE (layout));
9722 gtk_adjustment_set_step_increment (hadjustment, 10.0);
9723 gtk_adjustment_set_step_increment (vadjustment, 10.0);
9724 gtk_scrollable_set_hadjustment (GTK_SCROLLABLE (layout), hadjustment);
9725 gtk_scrollable_set_vadjustment (GTK_SCROLLABLE (layout), vadjustment);
9727 gtk_widget_set_events (layout_widget, GDK_EXPOSURE_MASK);
9728 g_signal_connect (layout, "draw",
9729 G_CALLBACK (layout_draw_handler), NULL);
9731 gtk_layout_set_size (layout, 1600, 128000);
9733 for (i=0 ; i < 16 ; i++)
9734 for (j=0 ; j < 16 ; j++)
9736 sprintf(buf, "Button %d, %d", i, j);
9738 button = gtk_button_new_with_label (buf);
9740 button = gtk_label_new (buf);
9742 gtk_layout_put (layout, button, j*100, i*100);
9745 for (i=16; i < 1280; i++)
9747 sprintf(buf, "Button %d, %d", i, 0);
9749 button = gtk_button_new_with_label (buf);
9751 button = gtk_label_new (buf);
9753 gtk_layout_put (layout, button, 0, i*100);
9757 if (!gtk_widget_get_visible (window))
9758 gtk_widget_show_all (window);
9760 gtk_widget_destroy (window);
9764 create_styles (GtkWidget *widget)
9766 static GtkWidget *window = NULL;
9767 GtkWidget *content_area, *action_area;
9772 static GdkColor red = { 0, 0xffff, 0, 0 };
9773 static GdkColor green = { 0, 0, 0xffff, 0 };
9774 static GdkColor blue = { 0, 0, 0, 0xffff };
9775 static GdkColor yellow = { 0, 0xffff, 0xffff, 0 };
9776 static GdkColor cyan = { 0, 0 , 0xffff, 0xffff };
9777 PangoFontDescription *font_desc;
9779 GtkRcStyle *rc_style;
9783 window = gtk_dialog_new ();
9784 gtk_window_set_screen (GTK_WINDOW (window),
9785 gtk_widget_get_screen (widget));
9787 g_signal_connect (window, "destroy",
9788 G_CALLBACK (gtk_widget_destroyed),
9791 content_area = gtk_dialog_get_content_area (GTK_DIALOG (window));
9792 action_area = gtk_dialog_get_action_area (GTK_DIALOG (window));
9794 button = gtk_button_new_with_label ("Close");
9795 g_signal_connect_swapped (button, "clicked",
9796 G_CALLBACK (gtk_widget_destroy),
9798 gtk_widget_set_can_default (button, TRUE);
9799 gtk_box_pack_start (GTK_BOX (action_area), button, TRUE, TRUE, 0);
9800 gtk_widget_show (button);
9802 vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
9803 gtk_container_set_border_width (GTK_CONTAINER (vbox), 10);
9804 gtk_box_pack_start (GTK_BOX (content_area), vbox, FALSE, FALSE, 0);
9806 label = gtk_label_new ("Font:");
9807 gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
9808 gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
9810 font_desc = pango_font_description_from_string ("Helvetica,Sans Oblique 18");
9812 button = gtk_button_new_with_label ("Some Text");
9813 gtk_widget_modify_font (gtk_bin_get_child (GTK_BIN (button)),
9815 gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
9817 label = gtk_label_new ("Foreground:");
9818 gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
9819 gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
9821 button = gtk_button_new_with_label ("Some Text");
9822 gtk_widget_modify_fg (gtk_bin_get_child (GTK_BIN (button)),
9823 GTK_STATE_NORMAL, &red);
9824 gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
9826 label = gtk_label_new ("Background:");
9827 gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
9828 gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
9830 button = gtk_button_new_with_label ("Some Text");
9831 gtk_widget_modify_bg (button, GTK_STATE_NORMAL, &green);
9832 gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
9834 label = gtk_label_new ("Text:");
9835 gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
9836 gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
9838 entry = gtk_entry_new ();
9839 gtk_entry_set_text (GTK_ENTRY (entry), "Some Text");
9840 gtk_widget_modify_text (entry, GTK_STATE_NORMAL, &blue);
9841 gtk_box_pack_start (GTK_BOX (vbox), entry, FALSE, FALSE, 0);
9843 label = gtk_label_new ("Base:");
9844 gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
9845 gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
9847 entry = gtk_entry_new ();
9848 gtk_entry_set_text (GTK_ENTRY (entry), "Some Text");
9849 gtk_widget_modify_base (entry, GTK_STATE_NORMAL, &yellow);
9850 gtk_box_pack_start (GTK_BOX (vbox), entry, FALSE, FALSE, 0);
9852 label = gtk_label_new ("Cursor:");
9853 gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
9854 gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
9856 entry = gtk_entry_new ();
9857 gtk_entry_set_text (GTK_ENTRY (entry), "Some Text");
9858 gtk_widget_modify_cursor (entry, &red, &red);
9859 gtk_box_pack_start (GTK_BOX (vbox), entry, FALSE, FALSE, 0);
9861 label = gtk_label_new ("Multiple:");
9862 gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
9863 gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
9865 button = gtk_button_new_with_label ("Some Text");
9867 rc_style = gtk_rc_style_new ();
9869 rc_style->font_desc = pango_font_description_copy (font_desc);
9870 rc_style->color_flags[GTK_STATE_NORMAL] = GTK_RC_FG | GTK_RC_BG;
9871 rc_style->color_flags[GTK_STATE_PRELIGHT] = GTK_RC_FG | GTK_RC_BG;
9872 rc_style->color_flags[GTK_STATE_ACTIVE] = GTK_RC_FG | GTK_RC_BG;
9873 rc_style->fg[GTK_STATE_NORMAL] = yellow;
9874 rc_style->bg[GTK_STATE_NORMAL] = blue;
9875 rc_style->fg[GTK_STATE_PRELIGHT] = blue;
9876 rc_style->bg[GTK_STATE_PRELIGHT] = yellow;
9877 rc_style->fg[GTK_STATE_ACTIVE] = red;
9878 rc_style->bg[GTK_STATE_ACTIVE] = cyan;
9879 rc_style->xthickness = 5;
9880 rc_style->ythickness = 5;
9882 gtk_widget_modify_style (button, rc_style);
9883 gtk_widget_modify_style (gtk_bin_get_child (GTK_BIN (button)), rc_style);
9885 g_object_unref (rc_style);
9887 gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
9890 if (!gtk_widget_get_visible (window))
9891 gtk_widget_show_all (window);
9893 gtk_widget_destroy (window);
9897 * Main Window and Exit
9901 do_exit (GtkWidget *widget, GtkWidget *window)
9903 gtk_widget_destroy (window);
9909 void (*func) (GtkWidget *widget);
9910 gboolean do_not_benchmark;
9913 { "alpha window", create_alpha_window },
9914 { "big windows", create_big_windows },
9915 { "button box", create_button_box },
9916 { "buttons", create_buttons },
9917 { "check buttons", create_check_buttons },
9918 { "color selection", create_color_selection },
9919 { "composited window", create_composited_window },
9920 { "cursors", create_cursors },
9921 { "dialog", create_dialog },
9922 { "display & screen", create_display_screen, TRUE },
9923 { "entry", create_entry },
9924 { "event box", create_event_box },
9925 { "event watcher", create_event_watcher },
9926 { "expander", create_expander },
9927 { "flipping", create_flipping },
9928 { "focus", create_focus },
9929 { "font selection", create_font_selection },
9930 { "handle box", create_handle_box },
9931 { "image", create_image },
9932 { "key lookup", create_key_lookup },
9933 { "labels", create_labels },
9934 { "layout", create_layout },
9935 { "menus", create_menus },
9936 { "message dialog", create_message_dialog },
9937 { "modal window", create_modal_window, TRUE },
9938 { "notebook", create_notebook },
9939 { "panes", create_panes },
9940 { "paned keyboard", create_paned_keyboard_navigation },
9941 { "pixbuf", create_pixbuf },
9942 { "progress bar", create_progress_bar },
9943 { "properties", create_properties },
9944 { "radio buttons", create_radio_buttons },
9945 { "range controls", create_range_controls },
9946 { "rc file", create_rc_file },
9947 { "reparent", create_reparent },
9948 { "resize grips", create_resize_grips },
9949 { "rotated label", create_rotated_label },
9950 { "rotated text", create_rotated_text },
9951 { "saved position", create_saved_position },
9952 { "scrolled windows", create_scrolled_windows },
9953 { "shapes", create_shapes },
9954 { "size groups", create_size_groups },
9955 { "snapshot", create_snapshot },
9956 { "spinbutton", create_spins },
9957 { "statusbar", create_statusbar },
9958 { "styles", create_styles },
9959 { "test idle", create_idle_test },
9960 { "test mainloop", create_mainloop, TRUE },
9961 { "test scrolling", create_scroll_test },
9962 { "test selection", create_selection_test },
9963 { "test timeout", create_timeout_test },
9964 { "toggle buttons", create_toggle_buttons },
9965 { "toolbar", create_toolbar },
9966 { "tooltips", create_tooltips },
9967 { "WM hints", create_wmhints },
9968 { "window sizing", create_window_sizing },
9969 { "window states", create_window_states }
9971 int nbuttons = sizeof (buttons) / sizeof (buttons[0]);
9974 create_main_window (void)
9979 GtkWidget *scrolled_window;
9983 GtkWidget *separator;
9984 GdkGeometry geometry;
9987 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
9988 gtk_widget_set_name (window, "main_window");
9989 gtk_window_move (GTK_WINDOW (window), 50, 20);
9990 gtk_window_set_default_size (GTK_WINDOW (window), -1, 400);
9992 geometry.min_width = -1;
9993 geometry.min_height = -1;
9994 geometry.max_width = -1;
9995 geometry.max_height = G_MAXSHORT;
9996 gtk_window_set_geometry_hints (GTK_WINDOW (window), NULL,
9998 GDK_HINT_MIN_SIZE | GDK_HINT_MAX_SIZE);
10000 g_signal_connect (window, "destroy",
10001 G_CALLBACK (gtk_main_quit),
10003 g_signal_connect (window, "delete-event",
10004 G_CALLBACK (gtk_false),
10007 box1 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
10008 gtk_container_add (GTK_CONTAINER (window), box1);
10010 if (gtk_micro_version > 0)
10013 gtk_get_major_version (),
10014 gtk_get_minor_version (),
10015 gtk_get_micro_version ());
10019 gtk_get_major_version (),
10020 gtk_get_minor_version ());
10022 label = gtk_label_new (buffer);
10023 gtk_box_pack_start (GTK_BOX (box1), label, FALSE, FALSE, 0);
10024 gtk_widget_set_name (label, "testgtk-version-label");
10026 scrolled_window = gtk_scrolled_window_new (NULL, NULL);
10027 gtk_container_set_border_width (GTK_CONTAINER (scrolled_window), 10);
10028 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
10030 GTK_POLICY_AUTOMATIC);
10031 gtk_box_pack_start (GTK_BOX (box1), scrolled_window, TRUE, TRUE, 0);
10033 box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
10034 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
10035 gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (scrolled_window), box2);
10036 gtk_container_set_focus_vadjustment (GTK_CONTAINER (box2),
10037 gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (scrolled_window)));
10038 gtk_widget_show (box2);
10040 for (i = 0; i < nbuttons; i++)
10042 button = gtk_button_new_with_label (buttons[i].label);
10043 if (buttons[i].func)
10044 g_signal_connect (button,
10046 G_CALLBACK(buttons[i].func),
10049 gtk_widget_set_sensitive (button, FALSE);
10050 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
10053 separator = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
10054 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
10056 box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10);
10057 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
10058 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
10060 button = gtk_button_new_with_mnemonic ("_Close");
10061 g_signal_connect (button, "clicked",
10062 G_CALLBACK (do_exit),
10064 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
10065 gtk_widget_set_can_default (button, TRUE);
10066 gtk_widget_grab_default (button);
10068 gtk_widget_show_all (window);
10074 if (g_file_test ("../gdk-pixbuf/libpixbufloader-pnm.la",
10075 G_FILE_TEST_EXISTS))
10077 g_setenv ("GDK_PIXBUF_MODULE_FILE", "../gdk-pixbuf/loaders.cache", TRUE);
10078 g_setenv ("GTK_IM_MODULE_FILE", "../modules/input/immodules.cache", TRUE);
10083 pad (const char *str, int to)
10085 static char buf[256];
10086 int len = strlen (str);
10089 for (i = 0; i < to; i++)
10094 memcpy (buf, str, len);
10100 bench_iteration (GtkWidget *widget, void (* fn) (GtkWidget *widget))
10102 fn (widget); /* on */
10103 while (g_main_context_iteration (NULL, FALSE));
10104 fn (widget); /* off */
10105 while (g_main_context_iteration (NULL, FALSE));
10109 do_real_bench (GtkWidget *widget, void (* fn) (GtkWidget *widget), char *name, int num)
10115 static gboolean printed_headers = FALSE;
10117 if (!printed_headers) {
10118 g_print ("Test Iters First Other\n");
10119 g_print ("-------------------- ----- ---------- ----------\n");
10120 printed_headers = TRUE;
10123 g_get_current_time (&tv0);
10124 bench_iteration (widget, fn);
10125 g_get_current_time (&tv1);
10127 dt_first = ((double)tv1.tv_sec - tv0.tv_sec) * 1000.0
10128 + (tv1.tv_usec - tv0.tv_usec) / 1000.0;
10130 g_get_current_time (&tv0);
10131 for (n = 0; n < num - 1; n++)
10132 bench_iteration (widget, fn);
10133 g_get_current_time (&tv1);
10134 dt = ((double)tv1.tv_sec - tv0.tv_sec) * 1000.0
10135 + (tv1.tv_usec - tv0.tv_usec) / 1000.0;
10137 g_print ("%s %5d ", pad (name, 20), num);
10139 g_print ("%10.1f %10.1f\n", dt_first, dt/(num-1));
10141 g_print ("%10.1f\n", dt_first);
10145 do_bench (char* what, int num)
10149 void (* fn) (GtkWidget *widget);
10151 widget = gtk_window_new (GTK_WINDOW_TOPLEVEL);
10153 if (g_ascii_strcasecmp (what, "ALL") == 0)
10155 for (i = 0; i < nbuttons; i++)
10157 if (!buttons[i].do_not_benchmark)
10158 do_real_bench (widget, buttons[i].func, buttons[i].label, num);
10165 for (i = 0; i < nbuttons; i++)
10167 if (strcmp (buttons[i].label, what) == 0)
10169 fn = buttons[i].func;
10175 g_print ("Can't bench: \"%s\" not found.\n", what);
10177 do_real_bench (widget, fn, buttons[i].label, num);
10184 fprintf (stderr, "Usage: testgtk [--bench ALL|<bench>[:<count>]]\n");
10189 main (int argc, char *argv[])
10191 GtkCssProvider *provider, *memory_provider;
10192 GdkDisplay *display;
10194 GtkBindingSet *binding_set;
10196 gboolean done_benchmarks = FALSE;
10198 srand (time (NULL));
10202 g_set_application_name ("GTK+ Test Program");
10204 gtk_init (&argc, &argv);
10206 provider = gtk_css_provider_new ();
10208 /* Check to see if we are being run from the correct
10211 if (file_exists ("testgtk.css"))
10212 gtk_css_provider_load_from_path (provider, "testgtk.css", NULL);
10213 else if (file_exists ("tests/testgtk.css"))
10214 gtk_css_provider_load_from_path (provider, "tests/testgtk.css", NULL);
10216 g_warning ("Couldn't find file \"testgtk.css\".");
10218 display = gdk_display_get_default ();
10219 screen = gdk_display_get_default_screen (display);
10221 gtk_style_context_add_provider_for_screen (screen, GTK_STYLE_PROVIDER (provider),
10222 GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
10223 g_object_unref (provider);
10225 gtk_accelerator_set_default_mod_mask (GDK_SHIFT_MASK |
10234 for (i = 1; i < argc; i++)
10236 if (strncmp (argv[i], "--bench", strlen("--bench")) == 0)
10243 nextarg = strchr (argv[i], '=');
10254 count = strchr (nextarg, ':');
10257 what = g_strndup (nextarg, count - nextarg);
10259 num = atoi (count);
10264 what = g_strdup (nextarg);
10266 do_bench (what, num ? num : 1);
10267 done_benchmarks = TRUE;
10272 if (done_benchmarks)
10277 binding_set = gtk_binding_set_by_class (g_type_class_ref (GTK_TYPE_WIDGET));
10278 gtk_binding_entry_add_signal (binding_set,
10279 '9', GDK_CONTROL_MASK | GDK_RELEASE_MASK,
10282 G_TYPE_STRING, "GtkWidgetClass <ctrl><release>9 test");
10284 memory_provider = gtk_css_provider_new ();
10285 gtk_css_provider_load_from_data (memory_provider,
10286 "#testgtk-version-label {\n"
10288 " font: Sans 18;\n"
10291 gtk_style_context_add_provider_for_screen (screen, GTK_STYLE_PROVIDER (memory_provider),
10292 GTK_STYLE_PROVIDER_PRIORITY_APPLICATION + 1);
10294 create_main_window ();
10300 while (g_main_context_pending (NULL))
10301 g_main_context_iteration (NULL, FALSE);
10304 while (g_main_context_pending (NULL))
10305 g_main_context_iteration (NULL, FALSE);