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, see <http://www.gnu.org/licenses/>.
19 * Modified by the GTK+ Team and others 1997-2000. See the AUTHORS
20 * file for a list of people on the GTK+ Team. See the ChangeLog
21 * files for a list of changes. These files are distributed with
22 * GTK+ at ftp://ftp.gtk.org/pub/gtk/.
42 #include "gdk/gdkkeysyms.h"
45 #define sleep(n) _sleep(n)
48 #include "prop-editor.h"
53 file_exists (const char *filename)
57 return stat (filename, &statbuf) == 0;
61 shape_create_icon (GdkScreen *screen,
70 build_option_menu (gchar *items[],
73 void (*func) (GtkWidget *widget, gpointer data),
76 /* macro, structure and variables used by tree window demos */
77 #define DEFAULT_NUMBER_OF_ITEM 3
78 #define DEFAULT_RECURSION_LEVEL 3
81 GSList* selection_mode_group;
82 GtkWidget* single_button;
83 GtkWidget* browse_button;
84 GtkWidget* multiple_button;
85 GtkWidget* draw_line_button;
86 GtkWidget* view_line_button;
87 GtkWidget* no_root_item_button;
88 GtkWidget* nb_item_spinner;
89 GtkWidget* recursion_spinner;
90 } sTreeSampleSelection;
92 typedef struct sTreeButtons {
94 GtkWidget* add_button;
95 GtkWidget* remove_button;
96 GtkWidget* subtree_button;
98 /* end of tree section */
101 build_option_menu (gchar *items[],
104 void (*func)(GtkWidget *widget, gpointer data),
110 omenu = gtk_combo_box_text_new ();
111 g_signal_connect (omenu, "changed",
112 G_CALLBACK (func), data);
114 for (i = 0; i < num_items; i++)
115 gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (omenu), items[i]);
117 gtk_combo_box_set_active (GTK_COMBO_BOX (omenu), history);
123 * Windows with an alpha channel
128 on_alpha_window_draw (GtkWidget *widget,
131 cairo_pattern_t *pattern;
132 int radius, width, height;
134 width = gtk_widget_get_allocated_width (widget);
135 height = gtk_widget_get_allocated_height (widget);
136 radius = MIN (width, height) / 2;
137 pattern = cairo_pattern_create_radial (width / 2,
144 if (gdk_screen_get_rgba_visual (gtk_widget_get_screen (widget)) &&
145 gtk_widget_is_composited (widget))
146 cairo_set_source_rgba (cr, 1.0, 1.0, 1.0, 0.0); /* transparent */
148 cairo_set_source_rgb (cr, 1.0, 1.0, 1.0); /* opaque white */
150 cairo_set_operator (cr, CAIRO_OPERATOR_SOURCE);
153 cairo_pattern_add_color_stop_rgba (pattern, 0.0,
154 1.0, 0.75, 0.0, 1.0); /* solid orange */
155 cairo_pattern_add_color_stop_rgba (pattern, 1.0,
156 1.0, 0.75, 0.0, 0.0); /* transparent orange */
158 cairo_set_source (cr, pattern);
159 cairo_pattern_destroy (pattern);
161 cairo_set_operator (cr, CAIRO_OPERATOR_OVER);
168 build_alpha_widgets (void)
171 GtkWidget *radio_button;
172 GtkWidget *check_button;
177 grid = gtk_grid_new ();
179 radio_button = gtk_radio_button_new_with_label (NULL, "Red");
180 gtk_widget_set_hexpand (radio_button, TRUE);
181 gtk_grid_attach (GTK_GRID (grid), radio_button, 0, 0, 1, 1);
183 radio_button = gtk_radio_button_new_with_label_from_widget (GTK_RADIO_BUTTON (radio_button), "Green");
184 gtk_widget_set_hexpand (radio_button, TRUE);
185 gtk_grid_attach (GTK_GRID (grid), radio_button, 0, 1, 1, 1);
187 radio_button = gtk_radio_button_new_with_label_from_widget (GTK_RADIO_BUTTON (radio_button), "Blue"),
188 gtk_widget_set_hexpand (radio_button, TRUE);
189 gtk_grid_attach (GTK_GRID (grid), radio_button, 0, 2, 1, 1);
191 check_button = gtk_check_button_new_with_label ("Sedentary"),
192 gtk_widget_set_hexpand (check_button, TRUE);
193 gtk_grid_attach (GTK_GRID (grid), check_button, 1, 0, 1, 1);
195 check_button = gtk_check_button_new_with_label ("Nocturnal"),
196 gtk_widget_set_hexpand (check_button, TRUE);
197 gtk_grid_attach (GTK_GRID (grid), check_button, 1, 1, 1, 1);
199 check_button = gtk_check_button_new_with_label ("Compulsive"),
200 gtk_widget_set_hexpand (check_button, TRUE);
201 gtk_grid_attach (GTK_GRID (grid), check_button, 1, 2, 1, 1);
203 hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
204 label = gtk_label_new (NULL);
205 gtk_label_set_markup (GTK_LABEL (label), "<i>Entry: </i>");
206 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
207 entry = gtk_entry_new ();
208 gtk_box_pack_start (GTK_BOX (hbox), entry, TRUE, TRUE, 0);
209 gtk_widget_set_hexpand (hbox, TRUE);
210 gtk_grid_attach (GTK_GRID (grid), hbox, 0, 3, 2, 1);
216 on_alpha_screen_changed (GtkWindow *window,
217 GdkScreen *old_screen,
220 GdkScreen *screen = gtk_widget_get_screen (GTK_WIDGET (window));
221 GdkVisual *visual = gdk_screen_get_rgba_visual (screen);
225 visual = gdk_screen_get_system_visual (screen);
226 gtk_label_set_markup (GTK_LABEL (label), "<b>Screen doesn't support alpha</b>");
230 gtk_label_set_markup (GTK_LABEL (label), "<b>Screen supports alpha</b>");
233 gtk_widget_set_visual (GTK_WIDGET (window), visual);
237 on_composited_changed (GtkWidget *window,
240 gboolean is_composited = gtk_widget_is_composited (window);
243 gtk_label_set_text (label, "Composited");
245 gtk_label_set_text (label, "Not composited");
249 create_alpha_window (GtkWidget *widget)
251 static GtkWidget *window;
255 GtkWidget *content_area;
259 window = gtk_dialog_new_with_buttons ("Alpha Window",
260 GTK_WINDOW (gtk_widget_get_toplevel (widget)), 0,
264 gtk_widget_set_app_paintable (window, TRUE);
265 g_signal_connect (window, "draw",
266 G_CALLBACK (on_alpha_window_draw), NULL);
268 content_area = gtk_dialog_get_content_area (GTK_DIALOG (window));
270 vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 8);
271 gtk_container_set_border_width (GTK_CONTAINER (vbox), 12);
272 gtk_box_pack_start (GTK_BOX (content_area), vbox,
275 label = gtk_label_new (NULL);
276 gtk_box_pack_start (GTK_BOX (vbox), label, TRUE, TRUE, 0);
277 on_alpha_screen_changed (GTK_WINDOW (window), NULL, label);
278 g_signal_connect (window, "screen-changed",
279 G_CALLBACK (on_alpha_screen_changed), label);
281 label = gtk_label_new (NULL);
282 gtk_box_pack_start (GTK_BOX (vbox), label, TRUE, TRUE, 0);
283 on_composited_changed (window, GTK_LABEL (label));
284 g_signal_connect (window, "composited_changed", G_CALLBACK (on_composited_changed), label);
286 gtk_box_pack_start (GTK_BOX (vbox), build_alpha_widgets (), TRUE, TRUE, 0);
288 g_signal_connect (window, "destroy",
289 G_CALLBACK (gtk_widget_destroyed),
292 g_signal_connect (window, "response",
293 G_CALLBACK (gtk_widget_destroy),
297 if (!gtk_widget_get_visible (window))
298 gtk_widget_show_all (window);
300 gtk_widget_destroy (window);
304 * Composited non-toplevel window
307 /* The draw event handler for the event box.
309 * This function simply draws a transparency onto a widget on the area
310 * for which it receives expose events. This is intended to give the
311 * event box a "transparent" background.
313 * In order for this to work properly, the widget must have an RGBA
314 * colourmap. The widget should also be set as app-paintable since it
315 * doesn't make sense for GTK to draw a background if we are drawing it
316 * (and because GTK might actually replace our transparency with its
317 * default background colour).
320 transparent_draw (GtkWidget *widget,
323 cairo_set_operator (cr, CAIRO_OPERATOR_CLEAR);
329 /* The expose event handler for the window.
331 * This function performs the actual compositing of the event box onto
332 * the already-existing background of the window at 50% normal opacity.
334 * In this case we do not want app-paintable to be set on the widget
335 * since we want it to draw its own (red) background. Because of this,
336 * however, we must ensure that we use g_signal_register_after so that
337 * this handler is called after the red has been drawn. If it was
338 * called before then GTK would just blindly paint over our work.
341 window_draw (GtkWidget *widget,
344 GtkAllocation allocation;
347 /* get our child (in this case, the event box) */
348 child = gtk_bin_get_child (GTK_BIN (widget));
350 gtk_widget_get_allocation (child, &allocation);
352 /* the source data is the (composited) event box */
353 gdk_cairo_set_source_window (cr, gtk_widget_get_window (child),
357 /* composite, with a 50% opacity */
358 cairo_paint_with_alpha (cr, 0.5);
364 create_composited_window (GtkWidget *widget)
366 static GtkWidget *window;
370 GtkWidget *event, *button;
373 /* make the widgets */
374 button = gtk_button_new_with_label ("A Button");
375 event = gtk_event_box_new ();
376 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
378 g_signal_connect (window, "destroy",
379 G_CALLBACK (gtk_widget_destroyed),
382 /* put a red background on the window */
383 gdk_rgba_parse (&red, "red");
384 gtk_widget_override_background_color (window, 0, &red);
386 /* set our event box to have a fully-transparent background
387 * drawn on it. currently there is no way to simply tell gtk
388 * that "transparency" is the background colour for a widget.
390 gtk_widget_set_app_paintable (GTK_WIDGET (event), TRUE);
391 g_signal_connect (event, "draw",
392 G_CALLBACK (transparent_draw), NULL);
394 /* put them inside one another */
395 gtk_container_set_border_width (GTK_CONTAINER (window), 10);
396 gtk_container_add (GTK_CONTAINER (window), event);
397 gtk_container_add (GTK_CONTAINER (event), button);
399 /* realise and show everything */
400 gtk_widget_realize (button);
402 /* set the event box GdkWindow to be composited.
403 * obviously must be performed after event box is realised.
405 gdk_window_set_composited (gtk_widget_get_window (event),
408 /* set up the compositing handler.
409 * note that we do _after so that the normal (red) background is drawn
410 * by gtk before our compositing occurs.
412 g_signal_connect_after (window, "draw",
413 G_CALLBACK (window_draw), NULL);
416 if (!gtk_widget_get_visible (window))
417 gtk_widget_show_all (window);
419 gtk_widget_destroy (window);
423 * Big windows and guffaw scrolling
427 pattern_set_bg (GtkWidget *widget,
431 static GdkRGBA colors[] = {
432 { 0.27, 0.27, 1.0, 1.0 },
433 { 0.53, 0.53, 1.0, 1.0},
434 { 0.67, 0.67, 1.0, 1.0 }
437 gdk_window_set_user_data (child, widget);
438 gdk_window_set_background_rgba (child, &colors[level]);
442 create_pattern (GtkWidget *widget,
453 while (2 * h <= height)
458 while (2 * w <= width)
460 if ((i + j) % 2 == 0)
465 GdkWindowAttr attributes;
467 attributes.window_type = GDK_WINDOW_CHILD;
470 attributes.width = w;
471 attributes.height = h;
472 attributes.wclass = GDK_INPUT_OUTPUT;
473 attributes.event_mask = GDK_EXPOSURE_MASK;
474 attributes.visual = gtk_widget_get_visual (widget);
476 child = gdk_window_new (parent, &attributes,
477 GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL);
479 pattern_set_bg (widget, child, level);
482 create_pattern (widget, child, level + 1, w, h);
484 gdk_window_show (child);
494 #define PATTERN_SIZE (1 << 18)
497 pattern_hadj_changed (GtkAdjustment *adjustment,
500 gint *old_value = g_object_get_data (G_OBJECT (adjustment), "old-value");
501 gint new_value = gtk_adjustment_get_value (adjustment);
503 if (gtk_widget_get_realized (darea))
505 gdk_window_scroll (gtk_widget_get_window (darea),
506 *old_value - new_value, 0);
507 *old_value = new_value;
512 pattern_vadj_changed (GtkAdjustment *adjustment,
515 gint *old_value = g_object_get_data (G_OBJECT (adjustment), "old-value");
516 gint new_value = gtk_adjustment_get_value (adjustment);
518 if (gtk_widget_get_realized (darea))
520 gdk_window_scroll (gtk_widget_get_window (darea),
521 0, *old_value - new_value);
522 *old_value = new_value;
527 pattern_realize (GtkWidget *widget,
532 window = gtk_widget_get_window (widget);
533 pattern_set_bg (widget, window, 0);
534 create_pattern (widget, window, 1, PATTERN_SIZE, PATTERN_SIZE);
538 create_big_windows (GtkWidget *widget)
540 static GtkWidget *window = NULL;
541 GtkWidget *content_area;
542 GtkWidget *darea, *grid, *scrollbar;
544 GtkAdjustment *hadjustment;
545 GtkAdjustment *vadjustment;
546 static gint current_x;
547 static gint current_y;
554 window = gtk_dialog_new_with_buttons ("Big Windows",
560 gtk_window_set_screen (GTK_WINDOW (window),
561 gtk_widget_get_screen (widget));
563 gtk_window_set_default_size (GTK_WINDOW (window), 200, 300);
565 g_signal_connect (window, "destroy",
566 G_CALLBACK (gtk_widget_destroyed),
569 g_signal_connect (window, "response",
570 G_CALLBACK (gtk_widget_destroy),
573 content_area = gtk_dialog_get_content_area (GTK_DIALOG (window));
575 grid = gtk_grid_new ();
576 gtk_box_pack_start (GTK_BOX (content_area), grid, TRUE, TRUE, 0);
578 darea = gtk_drawing_area_new ();
580 hadjustment = gtk_adjustment_new (0, 0, PATTERN_SIZE, 10, 100, 100);
581 g_signal_connect (hadjustment, "value_changed",
582 G_CALLBACK (pattern_hadj_changed), darea);
583 g_object_set_data (G_OBJECT (hadjustment), "old-value", ¤t_x);
585 vadjustment = gtk_adjustment_new (0, 0, PATTERN_SIZE, 10, 100, 100);
586 g_signal_connect (vadjustment, "value_changed",
587 G_CALLBACK (pattern_vadj_changed), darea);
588 g_object_set_data (G_OBJECT (vadjustment), "old-value", ¤t_y);
590 g_signal_connect (darea, "realize",
591 G_CALLBACK (pattern_realize),
594 eventbox = gtk_event_box_new ();
595 gtk_widget_set_hexpand (eventbox, TRUE);
596 gtk_widget_set_vexpand (eventbox, TRUE);
597 gtk_grid_attach (GTK_GRID (grid), eventbox, 0, 0, 1, 1);
599 gtk_container_add (GTK_CONTAINER (eventbox), darea);
601 scrollbar = gtk_scrollbar_new (GTK_ORIENTATION_HORIZONTAL, hadjustment);
602 gtk_widget_set_hexpand (scrollbar, TRUE);
603 gtk_grid_attach (GTK_GRID (grid), scrollbar, 0, 1, 1, 1);
605 scrollbar = gtk_scrollbar_new (GTK_ORIENTATION_VERTICAL, vadjustment);
606 gtk_widget_set_vexpand (scrollbar, TRUE);
607 gtk_grid_attach (GTK_GRID (grid), scrollbar, 1, 0, 1, 1);
610 if (!gtk_widget_get_visible (window))
611 gtk_widget_show_all (window);
613 gtk_widget_hide (window);
621 button_window (GtkWidget *widget,
624 if (!gtk_widget_get_visible (button))
625 gtk_widget_show (button);
627 gtk_widget_hide (button);
631 create_buttons (GtkWidget *widget)
633 static GtkWidget *window = NULL;
637 GtkWidget *separator;
638 GtkWidget *button[10];
639 int button_x[9] = { 0, 1, 2, 0, 2, 1, 1, 2, 0 };
640 int button_y[9] = { 0, 1, 2, 2, 0, 2, 0, 1, 1 };
645 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
646 gtk_window_set_screen (GTK_WINDOW (window),
647 gtk_widget_get_screen (widget));
649 g_signal_connect (window, "destroy",
650 G_CALLBACK (gtk_widget_destroyed),
653 gtk_window_set_title (GTK_WINDOW (window), "GtkButton");
654 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
656 box1 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
657 gtk_container_add (GTK_CONTAINER (window), box1);
659 grid = gtk_grid_new ();
660 gtk_grid_set_row_spacing (GTK_GRID (grid), 5);
661 gtk_grid_set_column_spacing (GTK_GRID (grid), 5);
662 gtk_container_set_border_width (GTK_CONTAINER (grid), 10);
663 gtk_box_pack_start (GTK_BOX (box1), grid, TRUE, TRUE, 0);
665 button[0] = gtk_button_new_with_label ("button1");
666 button[1] = gtk_button_new_with_mnemonic ("_button2");
667 button[2] = gtk_button_new_with_mnemonic ("_button3");
668 button[3] = gtk_button_new_from_stock (GTK_STOCK_OK);
669 button[4] = gtk_button_new_with_label ("button5");
670 button[5] = gtk_button_new_with_label ("button6");
671 button[6] = gtk_button_new_with_label ("button7");
672 button[7] = gtk_button_new_from_stock (GTK_STOCK_CLOSE);
673 button[8] = gtk_button_new_with_label ("button9");
675 for (i = 0; i < 9; i++)
677 g_signal_connect (button[i], "clicked",
678 G_CALLBACK (button_window),
679 button[(i + 1) % 9]);
680 gtk_widget_set_hexpand (button[i], TRUE);
681 gtk_widget_set_vexpand (button[i], TRUE);
683 gtk_grid_attach (GTK_GRID (grid), button[i],
684 button_x[i], button_y[i] + 1, 1, 1);
687 separator = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
688 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
690 box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10);
691 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
692 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
694 button[9] = gtk_button_new_with_label ("close");
695 g_signal_connect_swapped (button[9], "clicked",
696 G_CALLBACK (gtk_widget_destroy),
698 gtk_box_pack_start (GTK_BOX (box2), button[9], TRUE, TRUE, 0);
699 gtk_widget_set_can_default (button[9], TRUE);
700 gtk_widget_grab_default (button[9]);
703 if (!gtk_widget_get_visible (window))
704 gtk_widget_show_all (window);
706 gtk_widget_destroy (window);
714 create_toggle_buttons (GtkWidget *widget)
716 static GtkWidget *window = NULL;
720 GtkWidget *separator;
724 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
725 gtk_window_set_screen (GTK_WINDOW (window),
726 gtk_widget_get_screen (widget));
728 g_signal_connect (window, "destroy",
729 G_CALLBACK (gtk_widget_destroyed),
732 gtk_window_set_title (GTK_WINDOW (window), "GtkToggleButton");
733 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
735 box1 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
736 gtk_container_add (GTK_CONTAINER (window), box1);
738 box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10);
739 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
740 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
742 button = gtk_toggle_button_new_with_label ("button1");
743 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
745 button = gtk_toggle_button_new_with_label ("button2");
746 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
748 button = gtk_toggle_button_new_with_label ("button3");
749 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
751 button = gtk_toggle_button_new_with_label ("inconsistent");
752 gtk_toggle_button_set_inconsistent (GTK_TOGGLE_BUTTON (button), TRUE);
753 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
755 separator = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
756 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
758 box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10);
759 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
760 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
762 button = gtk_button_new_with_label ("close");
763 g_signal_connect_swapped (button, "clicked",
764 G_CALLBACK (gtk_widget_destroy),
766 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
767 gtk_widget_set_can_default (button, TRUE);
768 gtk_widget_grab_default (button);
771 if (!gtk_widget_get_visible (window))
772 gtk_widget_show_all (window);
774 gtk_widget_destroy (window);
778 create_widget_grid (GType widget_type)
781 GtkWidget *group_widget = NULL;
784 grid = gtk_grid_new ();
786 for (i = 0; i < 5; i++)
788 for (j = 0; j < 5; j++)
793 if (i == 0 && j == 0)
799 tmp = g_strdup_printf ("%d", j);
800 widget = gtk_label_new (tmp);
805 tmp = g_strdup_printf ("%c", 'A' + i - 1);
806 widget = gtk_label_new (tmp);
811 widget = g_object_new (widget_type, NULL);
813 if (g_type_is_a (widget_type, GTK_TYPE_RADIO_BUTTON))
816 group_widget = widget;
818 g_object_set (widget, "group", group_widget, NULL);
823 gtk_grid_attach (GTK_GRID (grid), widget, i, j, 1, 1);
835 create_check_buttons (GtkWidget *widget)
837 static GtkWidget *window = NULL;
841 GtkWidget *separator;
846 window = gtk_dialog_new_with_buttons ("Check Buttons",
852 gtk_window_set_screen (GTK_WINDOW (window),
853 gtk_widget_get_screen (widget));
855 g_signal_connect (window, "destroy",
856 G_CALLBACK (gtk_widget_destroyed),
858 g_signal_connect (window, "response",
859 G_CALLBACK (gtk_widget_destroy),
862 box1 = gtk_dialog_get_content_area (GTK_DIALOG (window));
864 box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10);
865 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
866 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
868 button = gtk_check_button_new_with_mnemonic ("_button1");
869 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
871 button = gtk_check_button_new_with_label ("button2");
872 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
874 button = gtk_check_button_new_with_label ("button3");
875 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
877 button = gtk_check_button_new_with_label ("inconsistent");
878 gtk_toggle_button_set_inconsistent (GTK_TOGGLE_BUTTON (button), TRUE);
879 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
881 separator = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
882 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
884 table = create_widget_grid (GTK_TYPE_CHECK_BUTTON);
885 gtk_container_set_border_width (GTK_CONTAINER (table), 10);
886 gtk_box_pack_start (GTK_BOX (box1), table, TRUE, TRUE, 0);
889 if (!gtk_widget_get_visible (window))
890 gtk_widget_show_all (window);
892 gtk_widget_destroy (window);
900 create_radio_buttons (GtkWidget *widget)
902 static GtkWidget *window = NULL;
906 GtkWidget *separator;
911 window = gtk_dialog_new_with_buttons ("Radio Buttons",
917 gtk_window_set_screen (GTK_WINDOW (window),
918 gtk_widget_get_screen (widget));
920 g_signal_connect (window, "destroy",
921 G_CALLBACK (gtk_widget_destroyed),
923 g_signal_connect (window, "response",
924 G_CALLBACK (gtk_widget_destroy),
927 box1 = gtk_dialog_get_content_area (GTK_DIALOG (window));
929 box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10);
930 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
931 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
933 button = gtk_radio_button_new_with_label (NULL, "button1");
934 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
936 button = gtk_radio_button_new_with_label (
937 gtk_radio_button_get_group (GTK_RADIO_BUTTON (button)),
939 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
940 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
942 button = gtk_radio_button_new_with_label (
943 gtk_radio_button_get_group (GTK_RADIO_BUTTON (button)),
945 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
947 button = gtk_radio_button_new_with_label (
948 gtk_radio_button_get_group (GTK_RADIO_BUTTON (button)),
950 gtk_toggle_button_set_inconsistent (GTK_TOGGLE_BUTTON (button), TRUE);
951 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
953 separator = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
954 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
956 box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10);
957 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
958 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
960 button = gtk_radio_button_new_with_label (NULL, "button4");
961 gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (button), FALSE);
962 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
964 button = gtk_radio_button_new_with_label (
965 gtk_radio_button_get_group (GTK_RADIO_BUTTON (button)),
967 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
968 gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (button), FALSE);
969 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
971 button = gtk_radio_button_new_with_label (
972 gtk_radio_button_get_group (GTK_RADIO_BUTTON (button)),
974 gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (button), FALSE);
975 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
977 separator = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
978 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
980 table = create_widget_grid (GTK_TYPE_RADIO_BUTTON);
981 gtk_container_set_border_width (GTK_CONTAINER (table), 10);
982 gtk_box_pack_start (GTK_BOX (box1), table, TRUE, TRUE, 0);
985 if (!gtk_widget_get_visible (window))
986 gtk_widget_show_all (window);
988 gtk_widget_destroy (window);
996 create_bbox (gint horizontal,
1007 frame = gtk_frame_new (title);
1010 bbox = gtk_button_box_new (GTK_ORIENTATION_HORIZONTAL);
1012 bbox = gtk_button_box_new (GTK_ORIENTATION_VERTICAL);
1014 gtk_container_set_border_width (GTK_CONTAINER (bbox), 5);
1015 gtk_container_add (GTK_CONTAINER (frame), bbox);
1017 gtk_button_box_set_layout (GTK_BUTTON_BOX (bbox), layout);
1018 gtk_box_set_spacing (GTK_BOX (bbox), spacing);
1020 button = gtk_button_new_with_label ("OK");
1021 gtk_container_add (GTK_CONTAINER (bbox), button);
1023 button = gtk_button_new_with_label ("Cancel");
1024 gtk_container_add (GTK_CONTAINER (bbox), button);
1026 button = gtk_button_new_with_label ("Help");
1027 gtk_container_add (GTK_CONTAINER (bbox), button);
1033 create_button_box (GtkWidget *widget)
1035 static GtkWidget* window = NULL;
1036 GtkWidget *main_vbox;
1039 GtkWidget *frame_horz;
1040 GtkWidget *frame_vert;
1044 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
1045 gtk_window_set_screen (GTK_WINDOW (window), gtk_widget_get_screen (widget));
1046 gtk_window_set_title (GTK_WINDOW (window), "Button Boxes");
1048 g_signal_connect (window, "destroy",
1049 G_CALLBACK (gtk_widget_destroyed),
1052 gtk_container_set_border_width (GTK_CONTAINER (window), 10);
1054 main_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
1055 gtk_container_add (GTK_CONTAINER (window), main_vbox);
1057 frame_horz = gtk_frame_new ("Horizontal Button Boxes");
1058 gtk_box_pack_start (GTK_BOX (main_vbox), frame_horz, TRUE, TRUE, 10);
1060 vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
1061 gtk_container_set_border_width (GTK_CONTAINER (vbox), 10);
1062 gtk_container_add (GTK_CONTAINER (frame_horz), vbox);
1064 gtk_box_pack_start (GTK_BOX (vbox),
1065 create_bbox (TRUE, "Spread", 40, 85, 20, GTK_BUTTONBOX_SPREAD),
1068 gtk_box_pack_start (GTK_BOX (vbox),
1069 create_bbox (TRUE, "Edge", 40, 85, 20, GTK_BUTTONBOX_EDGE),
1072 gtk_box_pack_start (GTK_BOX (vbox),
1073 create_bbox (TRUE, "Start", 40, 85, 20, GTK_BUTTONBOX_START),
1076 gtk_box_pack_start (GTK_BOX (vbox),
1077 create_bbox (TRUE, "End", 40, 85, 20, GTK_BUTTONBOX_END),
1080 gtk_box_pack_start (GTK_BOX (vbox),
1081 create_bbox (TRUE, "Center", 40, 85, 20, GTK_BUTTONBOX_CENTER),
1084 frame_vert = gtk_frame_new ("Vertical Button Boxes");
1085 gtk_box_pack_start (GTK_BOX (main_vbox), frame_vert, TRUE, TRUE, 10);
1087 hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
1088 gtk_container_set_border_width (GTK_CONTAINER (hbox), 10);
1089 gtk_container_add (GTK_CONTAINER (frame_vert), hbox);
1091 gtk_box_pack_start (GTK_BOX (hbox),
1092 create_bbox (FALSE, "Spread", 30, 85, 20, GTK_BUTTONBOX_SPREAD),
1095 gtk_box_pack_start (GTK_BOX (hbox),
1096 create_bbox (FALSE, "Edge", 30, 85, 20, GTK_BUTTONBOX_EDGE),
1099 gtk_box_pack_start (GTK_BOX (hbox),
1100 create_bbox (FALSE, "Start", 30, 85, 20, GTK_BUTTONBOX_START),
1103 gtk_box_pack_start (GTK_BOX (hbox),
1104 create_bbox (FALSE, "End", 30, 85, 20, GTK_BUTTONBOX_END),
1107 gtk_box_pack_start (GTK_BOX (hbox),
1108 create_bbox (FALSE, "Center", 30, 85, 20, GTK_BUTTONBOX_CENTER),
1112 if (!gtk_widget_get_visible (window))
1113 gtk_widget_show_all (window);
1115 gtk_widget_destroy (window);
1123 new_pixbuf (char *filename,
1129 if (strcmp (filename, "test.xpm") == 0)
1132 pixbuf = gdk_pixbuf_new_from_file (filename, NULL);
1135 pixbuf = gdk_pixbuf_new_from_xpm_data ((const char **) openfile);
1137 widget = gtk_image_new_from_pixbuf (pixbuf);
1139 g_object_unref (pixbuf);
1146 set_toolbar_small_stock (GtkWidget *widget,
1149 gtk_toolbar_set_icon_size (GTK_TOOLBAR (data), GTK_ICON_SIZE_SMALL_TOOLBAR);
1153 set_toolbar_large_stock (GtkWidget *widget,
1156 gtk_toolbar_set_icon_size (GTK_TOOLBAR (data), GTK_ICON_SIZE_LARGE_TOOLBAR);
1160 set_toolbar_horizontal (GtkWidget *widget,
1163 gtk_orientable_set_orientation (GTK_ORIENTABLE (data), GTK_ORIENTATION_HORIZONTAL);
1167 set_toolbar_vertical (GtkWidget *widget,
1170 gtk_orientable_set_orientation (GTK_ORIENTABLE (data), GTK_ORIENTATION_VERTICAL);
1174 set_toolbar_icons (GtkWidget *widget,
1177 gtk_toolbar_set_style (GTK_TOOLBAR (data), GTK_TOOLBAR_ICONS);
1181 set_toolbar_text (GtkWidget *widget,
1184 gtk_toolbar_set_style (GTK_TOOLBAR (data), GTK_TOOLBAR_TEXT);
1188 set_toolbar_both (GtkWidget *widget,
1191 gtk_toolbar_set_style (GTK_TOOLBAR (data), GTK_TOOLBAR_BOTH);
1195 set_toolbar_both_horiz (GtkWidget *widget,
1198 gtk_toolbar_set_style (GTK_TOOLBAR (data), GTK_TOOLBAR_BOTH_HORIZ);
1202 set_toolbar_enable (GtkWidget *widget,
1205 GtkSettings *settings = gtk_widget_get_settings (widget);
1206 g_object_set (settings, "gtk-enable-tooltips", TRUE, NULL);
1210 set_toolbar_disable (GtkWidget *widget,
1213 GtkSettings *settings = gtk_widget_get_settings (widget);
1214 g_object_set (settings, "gtk-enable-tooltips", FALSE, NULL);
1217 static GtkActionEntry create_toolbar_items[] = {
1218 { NULL, GTK_STOCK_NEW, NULL, NULL, "Stock icon: New",
1219 G_CALLBACK (set_toolbar_small_stock) },
1220 { NULL, GTK_STOCK_OPEN, NULL, NULL, "Stock icon: Open",
1221 G_CALLBACK (set_toolbar_large_stock) },
1222 { NULL, NULL, "Horizontal", NULL, "Horizontal toolbar layout",
1223 G_CALLBACK (set_toolbar_horizontal) },
1224 { NULL, NULL, "Vertical", NULL, "Vertical toolbar layout",
1225 G_CALLBACK (set_toolbar_vertical) },
1227 { NULL, NULL, "Icons", NULL, "Only show toolbar icons",
1228 G_CALLBACK (set_toolbar_icons) },
1229 { NULL, NULL, "Text", NULL, "Only show toolbar text",
1230 G_CALLBACK (set_toolbar_text) },
1231 { NULL, NULL, "Both", NULL, "Show toolbar icons and text",
1232 G_CALLBACK (set_toolbar_both) },
1233 { NULL, NULL, "Both (horizontal)", NULL, "Show toolbar icons and text in a horizontal fashion",
1234 G_CALLBACK (set_toolbar_both_horiz) },
1236 { "entry", NULL, NULL, "This is an unusable GtkEntry ;)",
1240 { NULL, NULL, "Enable", NULL, "Enable tooltips",
1241 G_CALLBACK (set_toolbar_enable) },
1242 { NULL, NULL, "Disable", NULL, "Disable tooltips",
1243 G_CALLBACK (set_toolbar_disable) },
1245 { NULL, NULL, "Frobate", NULL, "Frobate tooltip",
1247 { NULL, NULL, "Baz", NULL, "Baz tooltip",
1250 { NULL, NULL, "Blah", NULL, "Blash tooltip",
1252 { NULL, NULL, "Bar", NULL, "Bar tooltip",
1257 create_toolbar (GtkWidget *widget)
1259 static GtkWidget *window = NULL;
1266 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
1267 gtk_window_set_screen (GTK_WINDOW (window),
1268 gtk_widget_get_screen (widget));
1270 gtk_window_set_title (GTK_WINDOW (window), "Toolbar test");
1272 g_signal_connect (window, "destroy",
1273 G_CALLBACK (gtk_widget_destroyed),
1276 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
1277 gtk_widget_realize (window);
1279 toolbar = gtk_toolbar_new ();
1280 for (i = 0; i < G_N_ELEMENTS (create_toolbar_items); i++)
1282 GtkToolItem *toolitem;
1284 if (create_toolbar_items[i].tooltip == NULL)
1285 toolitem = gtk_separator_tool_item_new ();
1286 else if (g_strcmp0 (create_toolbar_items[i].name, "entry") == 0)
1290 toolitem = gtk_tool_item_new ();
1291 entry = gtk_entry_new ();
1292 gtk_container_add (GTK_CONTAINER (toolitem), entry);
1294 else if (create_toolbar_items[i].stock_id)
1295 toolitem = gtk_tool_button_new_from_stock (create_toolbar_items[i].stock_id);
1300 icon = new_pixbuf ("test.xpm", gtk_widget_get_window (window));
1301 toolitem = gtk_tool_button_new (icon, create_toolbar_items[i].label);
1303 if (create_toolbar_items[i].callback)
1304 g_signal_connect (toolitem, "clicked",
1305 create_toolbar_items[i].callback, toolbar);
1306 gtk_tool_item_set_tooltip_text (toolitem, create_toolbar_items[i].tooltip);
1307 gtk_toolbar_insert (GTK_TOOLBAR (toolbar), toolitem, -1);
1310 gtk_container_add (GTK_CONTAINER (window), toolbar);
1312 gtk_widget_set_size_request (toolbar, 200, -1);
1315 if (!gtk_widget_get_visible (window))
1316 gtk_widget_show_all (window);
1318 gtk_widget_destroy (window);
1325 static guint statusbar_counter = 1;
1328 statusbar_push (GtkWidget *button,
1329 GtkStatusbar *statusbar)
1333 sprintf (text, "something %d", statusbar_counter++);
1335 gtk_statusbar_push (statusbar, 1, text);
1339 statusbar_push_long (GtkWidget *button,
1340 GtkStatusbar *statusbar)
1344 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\").");
1346 gtk_statusbar_push (statusbar, 1, text);
1350 statusbar_pop (GtkWidget *button,
1351 GtkStatusbar *statusbar)
1353 gtk_statusbar_pop (statusbar, 1);
1357 statusbar_steal (GtkWidget *button,
1358 GtkStatusbar *statusbar)
1360 gtk_statusbar_remove (statusbar, 1, 4);
1364 statusbar_popped (GtkStatusbar *statusbar,
1369 statusbar_counter = 1;
1373 statusbar_contexts (GtkStatusbar *statusbar)
1377 string = "any context";
1378 g_print ("GtkStatusBar: context=\"%s\", context_id=%d\n",
1380 gtk_statusbar_get_context_id (statusbar, string));
1382 string = "idle messages";
1383 g_print ("GtkStatusBar: context=\"%s\", context_id=%d\n",
1385 gtk_statusbar_get_context_id (statusbar, string));
1387 string = "some text";
1388 g_print ("GtkStatusBar: context=\"%s\", context_id=%d\n",
1390 gtk_statusbar_get_context_id (statusbar, string));
1392 string = "hit the mouse";
1393 g_print ("GtkStatusBar: context=\"%s\", context_id=%d\n",
1395 gtk_statusbar_get_context_id (statusbar, string));
1397 string = "hit the mouse2";
1398 g_print ("GtkStatusBar: context=\"%s\", context_id=%d\n",
1400 gtk_statusbar_get_context_id (statusbar, string));
1404 create_statusbar (GtkWidget *widget)
1406 static GtkWidget *window = NULL;
1410 GtkWidget *separator;
1411 GtkWidget *statusbar;
1415 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
1416 gtk_window_set_screen (GTK_WINDOW (window),
1417 gtk_widget_get_screen (widget));
1419 g_signal_connect (window, "destroy",
1420 G_CALLBACK (gtk_widget_destroyed),
1423 gtk_window_set_title (GTK_WINDOW (window), "statusbar");
1424 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
1426 box1 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
1427 gtk_container_add (GTK_CONTAINER (window), box1);
1429 box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10);
1430 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
1431 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
1433 statusbar = gtk_statusbar_new ();
1434 gtk_box_pack_end (GTK_BOX (box1), statusbar, TRUE, TRUE, 0);
1435 g_signal_connect (statusbar,
1437 G_CALLBACK (statusbar_popped),
1440 button = g_object_new (gtk_button_get_type (),
1441 "label", "push something",
1445 g_object_connect (button,
1446 "signal::clicked", statusbar_push, statusbar,
1449 button = g_object_connect (g_object_new (gtk_button_get_type (),
1454 "signal_after::clicked", statusbar_pop, statusbar,
1457 button = g_object_connect (g_object_new (gtk_button_get_type (),
1458 "label", "steal #4",
1462 "signal_after::clicked", statusbar_steal, statusbar,
1465 button = g_object_connect (g_object_new (gtk_button_get_type (),
1466 "label", "test contexts",
1470 "swapped_signal_after::clicked", statusbar_contexts, statusbar,
1473 button = g_object_connect (g_object_new (gtk_button_get_type (),
1474 "label", "push something long",
1478 "signal_after::clicked", statusbar_push_long, statusbar,
1481 separator = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
1482 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
1484 box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10);
1485 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
1486 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
1488 button = gtk_button_new_with_label ("close");
1489 g_signal_connect_swapped (button, "clicked",
1490 G_CALLBACK (gtk_widget_destroy),
1492 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
1493 gtk_widget_set_can_default (button, TRUE);
1494 gtk_widget_grab_default (button);
1497 if (!gtk_widget_get_visible (window))
1498 gtk_widget_show_all (window);
1500 gtk_widget_destroy (window);
1506 alpha_changed (GtkRange *range, GtkWidget *widget)
1510 alpha = gtk_range_get_value (range);
1512 gtk_widget_set_opacity (widget, alpha / 100.0);
1517 create_alpha_widgets (GtkWidget *widget)
1519 static GtkWidget *window = NULL;
1523 GtkWidget *vbox2, *vbox, *main_hbox;
1524 GtkWidget *button, *event_box, *label, *scale;
1525 GtkWidget *alpha1, *alpha2, *alpha3;
1527 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
1528 gtk_window_set_screen (GTK_WINDOW (window),
1529 gtk_widget_get_screen (widget));
1530 gtk_window_set_default_size (GTK_WINDOW (window),
1533 g_signal_connect (window, "destroy",
1534 G_CALLBACK (gtk_widget_destroyed), &window);
1536 gtk_window_set_title (GTK_WINDOW (window), "Alpha");
1537 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
1539 main_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
1540 gtk_container_add (GTK_CONTAINER (window), main_hbox);
1542 vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
1544 gtk_box_pack_start (GTK_BOX (main_hbox), vbox, FALSE, FALSE, 0);
1546 /* Plain button (no gdkwindows */
1548 label = gtk_label_new ("non-window widget");
1549 gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
1551 alpha1 = button = gtk_button_new_with_label ("A Button");
1552 gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
1554 /* windowed container with both windowed and normal button */
1555 label = gtk_label_new ("\nwindow widget");
1556 gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
1558 alpha2 = event_box = gtk_event_box_new ();
1559 gtk_box_pack_start (GTK_BOX (vbox), event_box, FALSE, FALSE, 0);
1561 vbox2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
1562 gtk_container_add (GTK_CONTAINER (event_box), vbox2);
1564 button = gtk_button_new_with_label ("A Button");
1565 gtk_box_pack_start (GTK_BOX (vbox2), button, FALSE, FALSE, 0);
1567 event_box = gtk_event_box_new ();
1568 button = gtk_button_new_with_label ("A Button (in window)");
1569 gtk_container_add (GTK_CONTAINER (event_box), button);
1570 gtk_box_pack_start (GTK_BOX (vbox2), event_box, FALSE, FALSE, 0);
1572 /* non-windowed container with both windowed and normal button */
1573 label = gtk_label_new ("\nnon-window widget with widget child");
1574 gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
1576 alpha3 = vbox2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
1577 gtk_box_pack_start (GTK_BOX (vbox), vbox2, FALSE, FALSE, 0);
1579 button = gtk_button_new_with_label ("A Button");
1580 gtk_box_pack_start (GTK_BOX (vbox2), button, FALSE, FALSE, 0);
1582 event_box = gtk_event_box_new ();
1583 button = gtk_button_new_with_label ("A Button (in window)");
1584 gtk_container_add (GTK_CONTAINER (event_box), button);
1585 gtk_box_pack_start (GTK_BOX (vbox2), event_box, FALSE, FALSE, 0);
1587 scale = gtk_scale_new_with_range (GTK_ORIENTATION_VERTICAL,
1589 gtk_box_pack_start (GTK_BOX (main_hbox), scale, FALSE, FALSE, 0);
1590 g_signal_connect (scale, "value_changed", G_CALLBACK (alpha_changed), alpha1);
1591 gtk_range_set_value (GTK_RANGE (scale), 50);
1593 scale = gtk_scale_new_with_range (GTK_ORIENTATION_VERTICAL,
1595 gtk_box_pack_start (GTK_BOX (main_hbox), scale, FALSE, FALSE, 0);
1596 g_signal_connect (scale, "value_changed", G_CALLBACK (alpha_changed), alpha2);
1597 gtk_range_set_value (GTK_RANGE (scale), 50);
1599 scale = gtk_scale_new_with_range (GTK_ORIENTATION_VERTICAL,
1601 gtk_box_pack_start (GTK_BOX (main_hbox), scale, FALSE, FALSE, 0);
1602 g_signal_connect (scale, "value_changed", G_CALLBACK (alpha_changed), alpha3);
1603 gtk_range_set_value (GTK_RANGE (scale), 50);
1605 gtk_widget_show_all (main_hbox);
1608 if (!gtk_widget_get_visible (window))
1609 gtk_widget_show (window);
1611 gtk_widget_destroy (window);
1619 sensitivity_toggled (GtkWidget *toggle,
1622 gtk_widget_set_sensitive (widget,
1623 gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (toggle)));
1627 create_sensitivity_control (GtkWidget *widget)
1631 button = gtk_toggle_button_new_with_label ("Sensitive");
1633 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button),
1634 gtk_widget_is_sensitive (widget));
1636 g_signal_connect (button,
1638 G_CALLBACK (sensitivity_toggled),
1641 gtk_widget_show_all (button);
1647 set_selectable_recursive (GtkWidget *widget,
1650 if (GTK_IS_CONTAINER (widget))
1655 children = gtk_container_get_children (GTK_CONTAINER (widget));
1659 set_selectable_recursive (tmp->data, setting);
1663 g_list_free (children);
1665 else if (GTK_IS_LABEL (widget))
1667 gtk_label_set_selectable (GTK_LABEL (widget), setting);
1672 selectable_toggled (GtkWidget *toggle,
1675 set_selectable_recursive (widget,
1676 gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (toggle)));
1680 create_selectable_control (GtkWidget *widget)
1684 button = gtk_toggle_button_new_with_label ("Selectable");
1686 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button),
1689 g_signal_connect (button,
1691 G_CALLBACK (selectable_toggled),
1694 gtk_widget_show_all (button);
1700 dialog_response (GtkWidget *dialog, gint response_id, GtkLabel *label)
1704 gtk_widget_destroy (dialog);
1706 text = "Some <a href=\"http://en.wikipedia.org/wiki/Text\" title=\"plain text\">text</a> may be marked up\n"
1707 "as hyperlinks, which can be clicked\n"
1708 "or activated via <a href=\"keynav\">keynav</a>.\n"
1709 "The links remain the same.";
1710 gtk_label_set_markup (label, text);
1714 activate_link (GtkWidget *label, const gchar *uri, gpointer data)
1716 if (g_strcmp0 (uri, "keynav") == 0)
1720 dialog = gtk_message_dialog_new_with_markup (GTK_WINDOW (gtk_widget_get_toplevel (label)),
1721 GTK_DIALOG_DESTROY_WITH_PARENT,
1724 "The term <i>keynav</i> is a shorthand for "
1725 "keyboard navigation and refers to the process of using a program "
1726 "(exclusively) via keyboard input.");
1728 gtk_window_present (GTK_WINDOW (dialog));
1730 g_signal_connect (dialog, "response", G_CALLBACK (dialog_response), label);
1738 void create_labels (GtkWidget *widget)
1740 static GtkWidget *window = NULL;
1749 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
1751 gtk_window_set_screen (GTK_WINDOW (window),
1752 gtk_widget_get_screen (widget));
1754 g_signal_connect (window, "destroy",
1755 G_CALLBACK (gtk_widget_destroyed),
1758 gtk_window_set_title (GTK_WINDOW (window), "Label");
1760 vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
1762 hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 5);
1763 gtk_container_add (GTK_CONTAINER (window), vbox);
1765 gtk_box_pack_end (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
1767 button = create_sensitivity_control (hbox);
1769 gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
1771 button = create_selectable_control (hbox);
1773 gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
1775 vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
1777 gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 0);
1778 gtk_container_set_border_width (GTK_CONTAINER (window), 5);
1780 frame = gtk_frame_new ("Normal Label");
1781 label = gtk_label_new ("This is a Normal label");
1782 gtk_label_set_ellipsize (GTK_LABEL (label), PANGO_ELLIPSIZE_START);
1783 gtk_container_add (GTK_CONTAINER (frame), label);
1784 gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
1786 frame = gtk_frame_new ("Multi-line Label");
1787 label = gtk_label_new ("This is a Multi-line label.\nSecond line\nThird line");
1788 gtk_label_set_ellipsize (GTK_LABEL (label), PANGO_ELLIPSIZE_END);
1789 gtk_container_add (GTK_CONTAINER (frame), label);
1790 gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
1792 frame = gtk_frame_new ("Left Justified Label");
1793 label = gtk_label_new ("This is a Left-Justified\nMulti-line label.\nThird line");
1794 gtk_label_set_ellipsize (GTK_LABEL (label), PANGO_ELLIPSIZE_MIDDLE);
1795 gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
1796 gtk_container_add (GTK_CONTAINER (frame), label);
1797 gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
1799 frame = gtk_frame_new ("Right Justified Label");
1800 gtk_label_set_ellipsize (GTK_LABEL (label), PANGO_ELLIPSIZE_START);
1801 label = gtk_label_new ("This is a Right-Justified\nMulti-line label.\nFourth line, (j/k)");
1802 gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_RIGHT);
1803 gtk_container_add (GTK_CONTAINER (frame), label);
1804 gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
1806 frame = gtk_frame_new ("Internationalized Label");
1807 label = gtk_label_new (NULL);
1808 gtk_label_set_markup (GTK_LABEL (label),
1809 "French (Fran\303\247ais) Bonjour, Salut\n"
1810 "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"
1811 "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"
1812 "Chinese (Simplified) <span lang=\"zh-cn\">\345\205\203\346\260\224 \345\274\200\345\217\221</span>\n"
1813 "Chinese (Traditional) <span lang=\"zh-tw\">\345\205\203\346\260\243 \351\226\213\347\231\274</span>\n"
1814 "Japanese <span lang=\"ja\">\345\205\203\346\260\227 \351\226\213\347\231\272</span>");
1815 gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
1816 gtk_container_add (GTK_CONTAINER (frame), label);
1817 gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
1819 frame = gtk_frame_new ("Bidirection Label");
1820 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"
1821 "\342\200\217Hebrew \327\251\327\234\327\225\327\235");
1822 gtk_container_add (GTK_CONTAINER (frame), label);
1823 gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
1825 frame = gtk_frame_new ("Links in a label");
1826 label = gtk_label_new ("Some <a href=\"http://en.wikipedia.org/wiki/Text\" title=\"plain text\">text</a> may be marked up\n"
1827 "as hyperlinks, which can be clicked\n"
1828 "or activated via <a href=\"keynav\">keynav</a>");
1829 gtk_label_set_use_markup (GTK_LABEL (label), TRUE);
1830 gtk_container_add (GTK_CONTAINER (frame), label);
1831 gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
1832 g_signal_connect (label, "activate-link", G_CALLBACK (activate_link), NULL);
1834 vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
1835 gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 0);
1836 frame = gtk_frame_new ("Line wrapped label");
1837 label = gtk_label_new ("This is an example of a line-wrapped label. It should not be taking "\
1838 "up the entire "/* big space to test spacing */\
1839 "width allocated to it, but automatically wraps the words to fit. "\
1840 "The time has come, for all good men, to come to the aid of their party. "\
1841 "The sixth sheik's six sheep's sick.\n"\
1842 " It supports multiple paragraphs correctly, and correctly adds "\
1843 "many extra spaces. ");
1845 gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
1846 gtk_container_add (GTK_CONTAINER (frame), label);
1847 gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
1849 frame = gtk_frame_new ("Filled, wrapped label");
1850 label = gtk_label_new ("This is an example of a line-wrapped, filled label. It should be taking "\
1851 "up the entire width allocated to it. Here is a seneance to prove "\
1852 "my point. Here is another sentence. "\
1853 "Here comes the sun, do de do de do.\n"\
1854 " This is a new paragraph.\n"\
1855 " This is another newer, longer, better paragraph. It is coming to an end, "\
1857 gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_FILL);
1858 gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
1859 gtk_container_add (GTK_CONTAINER (frame), label);
1860 gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
1862 frame = gtk_frame_new ("Underlined label");
1863 label = gtk_label_new ("This label is underlined!\n"
1864 "This one is underlined (\343\201\223\343\202\223\343\201\253\343\201\241\343\201\257) in quite a funky fashion");
1865 gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
1866 gtk_label_set_pattern (GTK_LABEL (label), "_________________________ _ _________ _ _____ _ __ __ ___ ____ _____");
1867 gtk_container_add (GTK_CONTAINER (frame), label);
1868 gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
1870 frame = gtk_frame_new ("Markup label");
1871 label = gtk_label_new (NULL);
1873 /* There's also a gtk_label_set_markup() without accel if you
1874 * don't have an accelerator key
1876 gtk_label_set_markup_with_mnemonic (GTK_LABEL (label),
1877 "This <span foreground=\"blue\" background=\"orange\">label</span> has "
1878 "<b>markup</b> _such as "
1879 "<big><i>Big Italics</i></big>\n"
1880 "<tt>Monospace font</tt>\n"
1881 "<u>Underline!</u>\n"
1883 "<span foreground=\"green\" background=\"red\">Ugly colors</span>\n"
1884 "and nothing on this line,\n"
1887 "or even on this one\n"
1888 "la <big>la <big>la <big>la <big>la</big></big></big></big>\n"
1889 "but this _word is <span foreground=\"purple\"><big>purple</big></span>\n"
1890 "<span underline=\"double\">We like <sup>superscript</sup> and <sub>subscript</sub> too</span>");
1892 g_assert (gtk_label_get_mnemonic_keyval (GTK_LABEL (label)) == GDK_KEY_s);
1894 gtk_container_add (GTK_CONTAINER (frame), label);
1895 gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
1898 if (!gtk_widget_get_visible (window))
1899 gtk_widget_show_all (window);
1901 gtk_widget_destroy (window);
1905 on_angle_scale_changed (GtkRange *range,
1908 gtk_label_set_angle (GTK_LABEL (label), gtk_range_get_value (range));
1912 create_rotated_label (GtkWidget *widget)
1914 static GtkWidget *window = NULL;
1915 GtkWidget *content_area;
1919 GtkWidget *scale_label;
1920 GtkWidget *scale_hbox;
1924 window = gtk_dialog_new_with_buttons ("Rotated Label",
1925 GTK_WINDOW (gtk_widget_get_toplevel (widget)), 0,
1926 GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE,
1929 gtk_window_set_resizable (GTK_WINDOW (window), TRUE);
1931 gtk_window_set_screen (GTK_WINDOW (window),
1932 gtk_widget_get_screen (widget));
1934 g_signal_connect (window, "response",
1935 G_CALLBACK (gtk_widget_destroy), NULL);
1936 g_signal_connect (window, "destroy",
1937 G_CALLBACK (gtk_widget_destroyed), &window);
1939 content_area = gtk_dialog_get_content_area (GTK_DIALOG (window));
1941 vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
1942 gtk_box_pack_start (GTK_BOX (content_area), vbox, TRUE, TRUE, 0);
1943 gtk_container_set_border_width (GTK_CONTAINER (vbox), 10);
1945 label = gtk_label_new (NULL);
1946 gtk_label_set_markup (GTK_LABEL (label), "Hello World\n<i>Rotate</i> <span underline='single' foreground='blue'>me</span>");
1947 gtk_box_pack_start (GTK_BOX (vbox), label, TRUE, TRUE, 0);
1949 scale_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
1950 gtk_box_pack_start (GTK_BOX (vbox), scale_hbox, FALSE, FALSE, 0);
1952 scale_label = gtk_label_new (NULL);
1953 gtk_label_set_markup (GTK_LABEL (scale_label), "<i>Angle: </i>");
1954 gtk_box_pack_start (GTK_BOX (scale_hbox), scale_label, FALSE, FALSE, 0);
1956 hscale = gtk_scale_new_with_range (GTK_ORIENTATION_HORIZONTAL,
1958 g_signal_connect (hscale, "value-changed",
1959 G_CALLBACK (on_angle_scale_changed), label);
1961 gtk_range_set_value (GTK_RANGE (hscale), 45);
1962 gtk_widget_set_size_request (hscale, 200, -1);
1963 gtk_box_pack_start (GTK_BOX (scale_hbox), hscale, TRUE, TRUE, 0);
1966 if (!gtk_widget_get_visible (window))
1967 gtk_widget_show_all (window);
1969 gtk_widget_destroy (window);
1972 #define DEFAULT_TEXT_RADIUS 200
1975 on_rotated_text_unrealize (GtkWidget *widget)
1977 g_object_set_data (G_OBJECT (widget), "text-gc", NULL);
1981 on_rotated_text_draw (GtkWidget *widget,
1983 GdkPixbuf *tile_pixbuf)
1985 static const gchar *words[] = { "The", "grand", "old", "Duke", "of", "York",
1986 "had", "10,000", "men" };
1991 PangoLayout *layout;
1992 PangoContext *context;
1993 PangoFontDescription *desc;
1997 gdk_cairo_set_source_pixbuf (cr, tile_pixbuf, 0, 0);
1998 cairo_pattern_set_extend (cairo_get_source (cr), CAIRO_EXTEND_REPEAT);
2001 cairo_set_source_rgb (cr, 0, 0, 0);
2003 width = gtk_widget_get_allocated_width (widget);
2004 height = gtk_widget_get_allocated_height (widget);
2005 radius = MIN (width, height) / 2.;
2007 cairo_translate (cr,
2008 radius + (width - 2 * radius) / 2,
2009 radius + (height - 2 * radius) / 2);
2010 cairo_scale (cr, radius / DEFAULT_TEXT_RADIUS, radius / DEFAULT_TEXT_RADIUS);
2012 context = gtk_widget_get_pango_context (widget);
2013 layout = pango_layout_new (context);
2014 desc = pango_font_description_from_string ("Sans Bold 30");
2015 pango_layout_set_font_description (layout, desc);
2016 pango_font_description_free (desc);
2018 n_words = G_N_ELEMENTS (words);
2019 for (i = 0; i < n_words; i++)
2025 cairo_rotate (cr, 2 * G_PI * i / n_words);
2026 pango_cairo_update_layout (cr, layout);
2028 pango_layout_set_text (layout, words[i], -1);
2029 pango_layout_get_size (layout, &width, &height);
2031 cairo_move_to (cr, - width / 2 / PANGO_SCALE, - DEFAULT_TEXT_RADIUS);
2032 pango_cairo_show_layout (cr, layout);
2037 g_object_unref (layout);
2043 create_rotated_text (GtkWidget *widget)
2045 static GtkWidget *window = NULL;
2049 const GdkRGBA white = { 1.0, 1.0, 1.0, 1.0 };
2050 GtkRequisition requisition;
2051 GtkWidget *content_area;
2052 GtkWidget *drawing_area;
2053 GdkPixbuf *tile_pixbuf;
2055 window = gtk_dialog_new_with_buttons ("Rotated Text",
2056 GTK_WINDOW (gtk_widget_get_toplevel (widget)), 0,
2057 GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE,
2060 gtk_window_set_resizable (GTK_WINDOW (window), TRUE);
2062 gtk_window_set_screen (GTK_WINDOW (window),
2063 gtk_widget_get_screen (widget));
2065 g_signal_connect (window, "response",
2066 G_CALLBACK (gtk_widget_destroy), NULL);
2067 g_signal_connect (window, "destroy",
2068 G_CALLBACK (gtk_widget_destroyed), &window);
2070 content_area = gtk_dialog_get_content_area (GTK_DIALOG (window));
2072 drawing_area = gtk_drawing_area_new ();
2073 gtk_box_pack_start (GTK_BOX (content_area), drawing_area, TRUE, TRUE, 0);
2074 gtk_widget_override_background_color (drawing_area, 0, &white);
2076 tile_pixbuf = gdk_pixbuf_new_from_file ("marble.xpm", NULL);
2078 g_signal_connect (drawing_area, "draw",
2079 G_CALLBACK (on_rotated_text_draw), tile_pixbuf);
2080 g_signal_connect (drawing_area, "unrealize",
2081 G_CALLBACK (on_rotated_text_unrealize), NULL);
2083 gtk_widget_show_all (gtk_bin_get_child (GTK_BIN (window)));
2085 gtk_widget_set_size_request (drawing_area, DEFAULT_TEXT_RADIUS * 2, DEFAULT_TEXT_RADIUS * 2);
2086 gtk_widget_get_preferred_size ( (window),
2087 &requisition, NULL);
2088 gtk_widget_set_size_request (drawing_area, -1, -1);
2089 gtk_window_resize (GTK_WINDOW (window), requisition.width, requisition.height);
2092 if (!gtk_widget_get_visible (window))
2093 gtk_widget_show (window);
2095 gtk_widget_destroy (window);
2103 reparent_label (GtkWidget *widget,
2104 GtkWidget *new_parent)
2108 label = g_object_get_data (G_OBJECT (widget), "user_data");
2110 gtk_widget_reparent (label, new_parent);
2114 set_parent_signal (GtkWidget *child,
2115 GtkWidget *old_parent,
2120 parent = gtk_widget_get_parent (child);
2121 g_message ("set_parent for \"%s\": new parent: \"%s\", old parent: \"%s\", data: %d\n",
2122 g_type_name (G_OBJECT_TYPE (child)),
2123 parent ? g_type_name (G_OBJECT_TYPE (parent)) : "NULL",
2124 old_parent ? g_type_name (G_OBJECT_TYPE (old_parent)) : "NULL",
2125 GPOINTER_TO_INT (func_data));
2129 create_reparent (GtkWidget *widget)
2131 static GtkWidget *window = NULL;
2138 GtkWidget *separator;
2139 GtkWidget *event_box;
2143 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
2145 gtk_window_set_screen (GTK_WINDOW (window),
2146 gtk_widget_get_screen (widget));
2148 g_signal_connect (window, "destroy",
2149 G_CALLBACK (gtk_widget_destroyed),
2152 gtk_window_set_title (GTK_WINDOW (window), "reparent");
2153 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
2155 box1 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
2156 gtk_container_add (GTK_CONTAINER (window), box1);
2158 box2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 5);
2159 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
2160 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
2162 label = gtk_label_new ("Hello World");
2164 frame = gtk_frame_new ("Frame 1");
2165 gtk_box_pack_start (GTK_BOX (box2), frame, TRUE, TRUE, 0);
2167 box3 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
2168 gtk_container_set_border_width (GTK_CONTAINER (box3), 5);
2169 gtk_container_add (GTK_CONTAINER (frame), box3);
2171 button = gtk_button_new_with_label ("switch");
2172 g_object_set_data (G_OBJECT (button), "user_data", label);
2173 gtk_box_pack_start (GTK_BOX (box3), button, FALSE, TRUE, 0);
2175 event_box = gtk_event_box_new ();
2176 gtk_box_pack_start (GTK_BOX (box3), event_box, FALSE, TRUE, 0);
2177 gtk_container_add (GTK_CONTAINER (event_box), label);
2179 g_signal_connect (button, "clicked",
2180 G_CALLBACK (reparent_label),
2183 g_signal_connect (label, "parent_set",
2184 G_CALLBACK (set_parent_signal),
2185 GINT_TO_POINTER (42));
2187 frame = gtk_frame_new ("Frame 2");
2188 gtk_box_pack_start (GTK_BOX (box2), frame, TRUE, TRUE, 0);
2190 box3 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
2191 gtk_container_set_border_width (GTK_CONTAINER (box3), 5);
2192 gtk_container_add (GTK_CONTAINER (frame), box3);
2194 button = gtk_button_new_with_label ("switch");
2195 g_object_set_data (G_OBJECT (button), "user_data", label);
2196 gtk_box_pack_start (GTK_BOX (box3), button, FALSE, TRUE, 0);
2198 event_box = gtk_event_box_new ();
2199 gtk_box_pack_start (GTK_BOX (box3), event_box, FALSE, TRUE, 0);
2201 g_signal_connect (button, "clicked",
2202 G_CALLBACK (reparent_label),
2205 separator = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
2206 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
2208 box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10);
2209 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
2210 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
2212 button = gtk_button_new_with_label ("close");
2213 g_signal_connect_swapped (button, "clicked",
2214 G_CALLBACK (gtk_widget_destroy), window);
2215 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
2216 gtk_widget_set_can_default (button, TRUE);
2217 gtk_widget_grab_default (button);
2220 if (!gtk_widget_get_visible (window))
2221 gtk_widget_show_all (window);
2223 gtk_widget_destroy (window);
2230 grippy_button_press (GtkWidget *area, GdkEventButton *event, GdkWindowEdge edge)
2232 if (event->type == GDK_BUTTON_PRESS)
2234 if (event->button == GDK_BUTTON_PRIMARY)
2235 gtk_window_begin_resize_drag (GTK_WINDOW (gtk_widget_get_toplevel (area)), edge,
2236 event->button, event->x_root, event->y_root,
2238 else if (event->button == GDK_BUTTON_MIDDLE)
2239 gtk_window_begin_move_drag (GTK_WINDOW (gtk_widget_get_toplevel (area)),
2240 event->button, event->x_root, event->y_root,
2247 grippy_draw (GtkWidget *area, cairo_t *cr, GdkWindowEdge edge)
2249 GtkStyleContext *context;
2250 GtkJunctionSides sides;
2254 case GDK_WINDOW_EDGE_NORTH_WEST:
2255 sides = GTK_JUNCTION_CORNER_TOPLEFT;
2257 case GDK_WINDOW_EDGE_NORTH:
2258 sides = GTK_JUNCTION_TOP;
2260 case GDK_WINDOW_EDGE_NORTH_EAST:
2261 sides = GTK_JUNCTION_CORNER_TOPRIGHT;
2263 case GDK_WINDOW_EDGE_WEST:
2264 sides = GTK_JUNCTION_LEFT;
2266 case GDK_WINDOW_EDGE_EAST:
2267 sides = GTK_JUNCTION_RIGHT;
2269 case GDK_WINDOW_EDGE_SOUTH_WEST:
2270 sides = GTK_JUNCTION_CORNER_BOTTOMLEFT;
2272 case GDK_WINDOW_EDGE_SOUTH:
2273 sides = GTK_JUNCTION_BOTTOM;
2275 case GDK_WINDOW_EDGE_SOUTH_EAST:
2276 sides = GTK_JUNCTION_CORNER_BOTTOMRIGHT;
2279 g_assert_not_reached();
2282 context = gtk_widget_get_style_context (area);
2283 gtk_style_context_save (context);
2284 gtk_style_context_add_class (context, "grip");
2285 gtk_style_context_set_junction_sides (context, sides);
2286 gtk_render_handle (context, cr,
2288 gtk_widget_get_allocated_width (area),
2289 gtk_widget_get_allocated_height (area));
2291 gtk_style_context_restore (context);
2297 create_resize_grips (GtkWidget *widget)
2299 static GtkWidget *window = NULL;
2301 GtkWidget *hbox, *vbox;
2304 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
2306 gtk_window_set_screen (GTK_WINDOW (window),
2307 gtk_widget_get_screen (widget));
2309 gtk_window_set_title (GTK_WINDOW (window), "resize grips");
2311 g_signal_connect (window, "destroy",
2312 G_CALLBACK (gtk_widget_destroyed),
2315 vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
2316 gtk_container_add (GTK_CONTAINER (window), vbox);
2318 hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
2319 gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 0);
2322 area = gtk_drawing_area_new ();
2323 gtk_widget_add_events (area, GDK_BUTTON_PRESS_MASK);
2324 gtk_box_pack_start (GTK_BOX (hbox), area, TRUE, TRUE, 0);
2325 g_signal_connect (area, "draw", G_CALLBACK (grippy_draw),
2326 GINT_TO_POINTER (GDK_WINDOW_EDGE_NORTH_WEST));
2327 g_signal_connect (area, "button_press_event", G_CALLBACK (grippy_button_press),
2328 GINT_TO_POINTER (GDK_WINDOW_EDGE_NORTH_WEST));
2331 area = gtk_drawing_area_new ();
2332 gtk_widget_add_events (area, GDK_BUTTON_PRESS_MASK);
2333 gtk_box_pack_start (GTK_BOX (hbox), area, TRUE, TRUE, 0);
2334 g_signal_connect (area, "draw", G_CALLBACK (grippy_draw),
2335 GINT_TO_POINTER (GDK_WINDOW_EDGE_NORTH));
2336 g_signal_connect (area, "button_press_event", G_CALLBACK (grippy_button_press),
2337 GINT_TO_POINTER (GDK_WINDOW_EDGE_NORTH));
2340 area = gtk_drawing_area_new ();
2341 gtk_widget_add_events (area, GDK_BUTTON_PRESS_MASK);
2342 gtk_box_pack_start (GTK_BOX (hbox), area, TRUE, TRUE, 0);
2343 g_signal_connect (area, "draw", G_CALLBACK (grippy_draw),
2344 GINT_TO_POINTER (GDK_WINDOW_EDGE_NORTH_EAST));
2345 g_signal_connect (area, "button_press_event", G_CALLBACK (grippy_button_press),
2346 GINT_TO_POINTER (GDK_WINDOW_EDGE_NORTH_EAST));
2348 hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
2349 gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 0);
2352 area = gtk_drawing_area_new ();
2353 gtk_widget_add_events (area, GDK_BUTTON_PRESS_MASK);
2354 gtk_box_pack_start (GTK_BOX (hbox), area, TRUE, TRUE, 0);
2355 g_signal_connect (area, "draw", G_CALLBACK (grippy_draw),
2356 GINT_TO_POINTER (GDK_WINDOW_EDGE_WEST));
2357 g_signal_connect (area, "button_press_event", G_CALLBACK (grippy_button_press),
2358 GINT_TO_POINTER (GDK_WINDOW_EDGE_WEST));
2361 area = gtk_drawing_area_new ();
2362 gtk_box_pack_start (GTK_BOX (hbox), area, TRUE, TRUE, 0);
2365 area = gtk_drawing_area_new ();
2366 gtk_widget_add_events (area, GDK_BUTTON_PRESS_MASK);
2367 gtk_box_pack_start (GTK_BOX (hbox), area, TRUE, TRUE, 0);
2368 g_signal_connect (area, "draw", G_CALLBACK (grippy_draw),
2369 GINT_TO_POINTER (GDK_WINDOW_EDGE_EAST));
2370 g_signal_connect (area, "button_press_event", G_CALLBACK (grippy_button_press),
2371 GINT_TO_POINTER (GDK_WINDOW_EDGE_EAST));
2374 hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
2375 gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 0);
2378 area = gtk_drawing_area_new ();
2379 gtk_widget_add_events (area, GDK_BUTTON_PRESS_MASK);
2380 gtk_box_pack_start (GTK_BOX (hbox), area, TRUE, TRUE, 0);
2381 g_signal_connect (area, "draw", G_CALLBACK (grippy_draw),
2382 GINT_TO_POINTER (GDK_WINDOW_EDGE_SOUTH_WEST));
2383 g_signal_connect (area, "button_press_event", G_CALLBACK (grippy_button_press),
2384 GINT_TO_POINTER (GDK_WINDOW_EDGE_SOUTH_WEST));
2386 area = gtk_drawing_area_new ();
2387 gtk_widget_add_events (area, GDK_BUTTON_PRESS_MASK);
2388 gtk_box_pack_start (GTK_BOX (hbox), area, TRUE, TRUE, 0);
2389 g_signal_connect (area, "draw", G_CALLBACK (grippy_draw),
2390 GINT_TO_POINTER (GDK_WINDOW_EDGE_SOUTH));
2391 g_signal_connect (area, "button_press_event", G_CALLBACK (grippy_button_press),
2392 GINT_TO_POINTER (GDK_WINDOW_EDGE_SOUTH));
2395 area = gtk_drawing_area_new ();
2396 gtk_widget_add_events (area, GDK_BUTTON_PRESS_MASK);
2397 gtk_box_pack_start (GTK_BOX (hbox), area, TRUE, TRUE, 0);
2398 g_signal_connect (area, "draw", G_CALLBACK (grippy_draw),
2399 GINT_TO_POINTER (GDK_WINDOW_EDGE_SOUTH_EAST));
2400 g_signal_connect (area, "button_press_event", G_CALLBACK (grippy_button_press),
2401 GINT_TO_POINTER (GDK_WINDOW_EDGE_SOUTH_EAST));
2404 if (!gtk_widget_get_visible (window))
2405 gtk_widget_show_all (window);
2407 gtk_widget_destroy (window);
2413 gint upositionx = 0;
2414 gint upositiony = 0;
2417 uposition_configure (GtkWidget *window)
2423 lx = g_object_get_data (G_OBJECT (window), "x");
2424 ly = g_object_get_data (G_OBJECT (window), "y");
2426 gdk_window_get_root_origin (gtk_widget_get_window (window),
2427 &upositionx, &upositiony);
2428 sprintf (buffer, "%d", upositionx);
2429 gtk_label_set_text (lx, buffer);
2430 sprintf (buffer, "%d", upositiony);
2431 gtk_label_set_text (ly, buffer);
2437 uposition_stop_configure (GtkToggleButton *toggle,
2440 if (gtk_toggle_button_get_active (toggle))
2441 g_signal_handlers_block_by_func (window, G_CALLBACK (uposition_configure), NULL);
2443 g_signal_handlers_unblock_by_func (window, G_CALLBACK (uposition_configure), NULL);
2447 create_saved_position (GtkWidget *widget)
2449 static GtkWidget *window = NULL;
2454 GtkWidget *main_vbox;
2462 window = g_object_connect (g_object_new (GTK_TYPE_WINDOW,
2463 "type", GTK_WINDOW_TOPLEVEL,
2464 "title", "Saved Position",
2466 "signal::configure_event", uposition_configure, NULL,
2469 gtk_window_move (GTK_WINDOW (window), upositionx, upositiony);
2471 gtk_window_set_screen (GTK_WINDOW (window),
2472 gtk_widget_get_screen (widget));
2475 g_signal_connect (window, "destroy",
2476 G_CALLBACK (gtk_widget_destroyed),
2479 main_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
2480 gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 0);
2481 gtk_container_add (GTK_CONTAINER (window), main_vbox);
2484 g_object_new (GTK_TYPE_BOX,
2485 "orientation", GTK_ORIENTATION_VERTICAL,
2486 "GtkBox::homogeneous", FALSE,
2487 "GtkBox::spacing", 5,
2488 "GtkContainer::border_width", 10,
2489 "GtkWidget::parent", main_vbox,
2490 "GtkWidget::visible", TRUE,
2491 "child", g_object_connect (g_object_new (GTK_TYPE_TOGGLE_BUTTON,
2492 "label", "Stop Events",
2496 "signal::clicked", uposition_stop_configure, window,
2500 hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
2501 gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
2502 gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0);
2504 label = gtk_label_new ("X Origin : ");
2505 gtk_widget_set_halign (label, GTK_ALIGN_START);
2506 gtk_widget_set_valign (label, GTK_ALIGN_CENTER);
2507 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
2509 x_label = gtk_label_new ("");
2510 gtk_box_pack_start (GTK_BOX (hbox), x_label, TRUE, TRUE, 0);
2511 g_object_set_data (G_OBJECT (window), "x", x_label);
2513 hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
2514 gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
2515 gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0);
2517 label = gtk_label_new ("Y Origin : ");
2518 gtk_widget_set_halign (label, GTK_ALIGN_START);
2519 gtk_widget_set_valign (label, GTK_ALIGN_CENTER);
2520 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
2522 y_label = gtk_label_new ("");
2523 gtk_box_pack_start (GTK_BOX (hbox), y_label, TRUE, TRUE, 0);
2524 g_object_set_data (G_OBJECT (window), "y", y_label);
2527 g_object_new (gtk_separator_get_type (),
2528 "GtkWidget::visible", TRUE,
2530 gtk_box_pack_start (GTK_BOX (main_vbox), any, FALSE, TRUE, 0);
2532 hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
2533 gtk_container_set_border_width (GTK_CONTAINER (hbox), 10);
2534 gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, TRUE, 0);
2536 button = gtk_button_new_with_label ("Close");
2537 g_signal_connect_swapped (button, "clicked",
2538 G_CALLBACK (gtk_widget_destroy),
2540 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
2541 gtk_widget_set_can_default (button, TRUE);
2542 gtk_widget_grab_default (button);
2544 gtk_widget_show_all (window);
2547 gtk_widget_destroy (window);
2555 create_pixbuf (GtkWidget *widget)
2557 static GtkWidget *window = NULL;
2563 GtkWidget *separator;
2564 GtkWidget *pixbufwid;
2565 GdkWindow *gdk_window;
2569 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
2571 gtk_window_set_screen (GTK_WINDOW (window),
2572 gtk_widget_get_screen (widget));
2574 g_signal_connect (window, "destroy",
2575 G_CALLBACK (gtk_widget_destroyed),
2578 gtk_window_set_title (GTK_WINDOW (window), "GtkPixmap");
2579 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
2580 gtk_widget_realize(window);
2582 box1 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
2583 gtk_container_add (GTK_CONTAINER (window), box1);
2585 box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10);
2586 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
2587 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
2589 button = gtk_button_new ();
2590 gtk_box_pack_start (GTK_BOX (box2), button, FALSE, FALSE, 0);
2592 gdk_window = gtk_widget_get_window (window);
2594 pixbufwid = new_pixbuf ("test.xpm", gdk_window);
2596 label = gtk_label_new ("Pixbuf\ntest");
2597 box3 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
2598 gtk_container_set_border_width (GTK_CONTAINER (box3), 2);
2599 gtk_container_add (GTK_CONTAINER (box3), pixbufwid);
2600 gtk_container_add (GTK_CONTAINER (box3), label);
2601 gtk_container_add (GTK_CONTAINER (button), box3);
2603 button = gtk_button_new ();
2604 gtk_box_pack_start (GTK_BOX (box2), button, FALSE, FALSE, 0);
2606 pixbufwid = new_pixbuf ("test.xpm", gdk_window);
2608 label = gtk_label_new ("Pixbuf\ntest");
2609 box3 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
2610 gtk_container_set_border_width (GTK_CONTAINER (box3), 2);
2611 gtk_container_add (GTK_CONTAINER (box3), pixbufwid);
2612 gtk_container_add (GTK_CONTAINER (box3), label);
2613 gtk_container_add (GTK_CONTAINER (button), box3);
2615 gtk_widget_set_sensitive (button, FALSE);
2617 separator = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
2618 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
2620 box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10);
2621 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
2622 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
2624 button = gtk_button_new_with_label ("close");
2625 g_signal_connect_swapped (button, "clicked",
2626 G_CALLBACK (gtk_widget_destroy),
2628 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
2629 gtk_widget_set_can_default (button, TRUE);
2630 gtk_widget_grab_default (button);
2633 if (!gtk_widget_get_visible (window))
2634 gtk_widget_show_all (window);
2636 gtk_widget_destroy (window);
2640 create_tooltips (GtkWidget *widget)
2642 static GtkWidget *window = NULL;
2649 GtkWidget *separator;
2654 g_object_new (gtk_window_get_type (),
2655 "GtkWindow::type", GTK_WINDOW_TOPLEVEL,
2656 "GtkContainer::border_width", 0,
2657 "GtkWindow::title", "Tooltips",
2658 "GtkWindow::resizable", FALSE,
2661 gtk_window_set_screen (GTK_WINDOW (window),
2662 gtk_widget_get_screen (widget));
2664 box1 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
2665 gtk_container_add (GTK_CONTAINER (window), box1);
2667 box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10);
2668 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
2669 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
2671 button = gtk_toggle_button_new_with_label ("button1");
2672 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
2674 gtk_widget_set_tooltip_text (button, "This is button 1");
2676 button = gtk_toggle_button_new_with_label ("button2");
2677 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
2679 gtk_widget_set_tooltip_text (button,
2680 "This is button 2. This is also a really long tooltip which probably "
2681 "won't fit on a single line and will therefore need to be wrapped. "
2682 "Hopefully the wrapping will work correctly.");
2684 toggle = gtk_toggle_button_new_with_label ("Override TipsQuery Label");
2685 gtk_box_pack_start (GTK_BOX (box2), toggle, TRUE, TRUE, 0);
2687 gtk_widget_set_tooltip_text (toggle, "Toggle TipsQuery view.");
2690 g_object_new (GTK_TYPE_BOX,
2691 "orientation", GTK_ORIENTATION_VERTICAL,
2692 "homogeneous", FALSE,
2699 g_object_new (gtk_button_get_type (),
2704 gtk_box_set_child_packing (GTK_BOX (box3), button, FALSE, FALSE, 0, GTK_PACK_START);
2705 gtk_widget_set_tooltip_text (button, "Start the Tooltips Inspector");
2707 frame = g_object_new (gtk_frame_get_type (),
2708 "label", "ToolTips Inspector",
2709 "label_xalign", (double) 0.5,
2715 gtk_box_set_child_packing (GTK_BOX (box2), frame, TRUE, TRUE, 10, GTK_PACK_START);
2717 separator = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
2718 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
2720 box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10);
2721 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
2722 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
2724 button = gtk_button_new_with_label ("close");
2725 g_signal_connect_swapped (button, "clicked",
2726 G_CALLBACK (gtk_widget_destroy),
2728 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
2729 gtk_widget_set_can_default (button, TRUE);
2730 gtk_widget_grab_default (button);
2732 gtk_widget_set_tooltip_text (button, "Push this button to close window");
2735 if (!gtk_widget_get_visible (window))
2736 gtk_widget_show_all (window);
2738 gtk_widget_destroy (window);
2746 pack_image (GtkWidget *box,
2750 gtk_box_pack_start (GTK_BOX (box),
2751 gtk_label_new (text),
2754 gtk_box_pack_start (GTK_BOX (box),
2760 create_image (GtkWidget *widget)
2762 static GtkWidget *window = NULL;
2769 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
2771 gtk_window_set_screen (GTK_WINDOW (window),
2772 gtk_widget_get_screen (widget));
2774 /* this is bogus for testing drawing when allocation < request,
2775 * don't copy into real code
2777 gtk_window_set_resizable (GTK_WINDOW (window), TRUE);
2779 g_signal_connect (window, "destroy",
2780 G_CALLBACK (gtk_widget_destroyed),
2783 vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
2785 gtk_container_add (GTK_CONTAINER (window), vbox);
2787 pack_image (vbox, "Stock Warning Dialog",
2788 gtk_image_new_from_stock (GTK_STOCK_DIALOG_WARNING,
2789 GTK_ICON_SIZE_DIALOG));
2791 pixbuf = gdk_pixbuf_new_from_xpm_data ((const char **) openfile);
2793 pack_image (vbox, "Pixbuf",
2794 gtk_image_new_from_pixbuf (pixbuf));
2796 g_object_unref (pixbuf);
2799 if (!gtk_widget_get_visible (window))
2800 gtk_widget_show_all (window);
2802 gtk_widget_destroy (window);
2810 create_menu (GdkScreen *screen, gint depth, gint length)
2813 GtkWidget *menuitem;
2822 menu = gtk_menu_new ();
2823 gtk_menu_set_screen (GTK_MENU (menu), screen);
2827 image = gtk_image_new_from_stock (GTK_STOCK_OPEN,
2828 GTK_ICON_SIZE_MENU);
2829 gtk_widget_show (image);
2830 menuitem = gtk_image_menu_item_new_with_label ("Image item");
2831 gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menuitem), image);
2832 gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
2833 gtk_widget_show (menuitem);
2835 for (i = 0, j = 1; i < length; i++, j++)
2837 sprintf (buf, "item %2d - %d", depth, j);
2839 menuitem = gtk_radio_menu_item_new_with_label (group, buf);
2840 group = gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (menuitem));
2842 gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
2843 gtk_widget_show (menuitem);
2845 gtk_widget_set_sensitive (menuitem, FALSE);
2848 gtk_check_menu_item_set_inconsistent (GTK_CHECK_MENU_ITEM (menuitem),
2852 gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem),
2853 create_menu (screen, depth - 1, 5));
2860 create_table_menu (GdkScreen *screen, gint cols, gint rows)
2863 GtkWidget *menuitem;
2869 menu = gtk_menu_new ();
2870 gtk_menu_set_screen (GTK_MENU (menu), screen);
2874 menuitem = gtk_menu_item_new_with_label ("items");
2875 gtk_menu_attach (GTK_MENU (menu), menuitem, 0, cols, j, j + 1);
2877 submenu = gtk_menu_new ();
2878 gtk_menu_set_screen (GTK_MENU (submenu), screen);
2879 gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), submenu);
2880 gtk_widget_show (menuitem);
2883 /* now fill the items submenu */
2884 image = gtk_image_new_from_stock (GTK_STOCK_HELP,
2885 GTK_ICON_SIZE_MENU);
2886 gtk_widget_show (image);
2887 menuitem = gtk_image_menu_item_new_with_label ("Image");
2888 gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menuitem), image);
2889 gtk_menu_attach (GTK_MENU (submenu), menuitem, 0, 1, 0, 1);
2890 gtk_widget_show (menuitem);
2892 menuitem = gtk_menu_item_new_with_label ("x");
2893 gtk_menu_attach (GTK_MENU (submenu), menuitem, 1, 2, 0, 1);
2894 gtk_widget_show (menuitem);
2896 menuitem = gtk_menu_item_new_with_label ("x");
2897 gtk_menu_attach (GTK_MENU (submenu), menuitem, 0, 1, 1, 2);
2898 gtk_widget_show (menuitem);
2900 image = gtk_image_new_from_stock (GTK_STOCK_HELP,
2901 GTK_ICON_SIZE_MENU);
2902 gtk_widget_show (image);
2903 menuitem = gtk_image_menu_item_new_with_label ("Image");
2904 gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menuitem), image);
2905 gtk_menu_attach (GTK_MENU (submenu), menuitem, 1, 2, 1, 2);
2906 gtk_widget_show (menuitem);
2908 menuitem = gtk_radio_menu_item_new_with_label (NULL, "Radio");
2909 gtk_menu_attach (GTK_MENU (submenu), menuitem, 0, 1, 2, 3);
2910 gtk_widget_show (menuitem);
2912 menuitem = gtk_menu_item_new_with_label ("x");
2913 gtk_menu_attach (GTK_MENU (submenu), menuitem, 1, 2, 2, 3);
2914 gtk_widget_show (menuitem);
2916 menuitem = gtk_menu_item_new_with_label ("x");
2917 gtk_menu_attach (GTK_MENU (submenu), menuitem, 0, 1, 3, 4);
2918 gtk_widget_show (menuitem);
2920 menuitem = gtk_radio_menu_item_new_with_label (NULL, "Radio");
2921 gtk_menu_attach (GTK_MENU (submenu), menuitem, 1, 2, 3, 4);
2922 gtk_widget_show (menuitem);
2924 menuitem = gtk_check_menu_item_new_with_label ("Check");
2925 gtk_menu_attach (GTK_MENU (submenu), menuitem, 0, 1, 4, 5);
2926 gtk_widget_show (menuitem);
2928 menuitem = gtk_menu_item_new_with_label ("x");
2929 gtk_menu_attach (GTK_MENU (submenu), menuitem, 1, 2, 4, 5);
2930 gtk_widget_show (menuitem);
2932 menuitem = gtk_menu_item_new_with_label ("x");
2933 gtk_menu_attach (GTK_MENU (submenu), menuitem, 0, 1, 5, 6);
2934 gtk_widget_show (menuitem);
2936 menuitem = gtk_check_menu_item_new_with_label ("Check");
2937 gtk_menu_attach (GTK_MENU (submenu), menuitem, 1, 2, 5, 6);
2938 gtk_widget_show (menuitem);
2940 menuitem = gtk_menu_item_new_with_label ("1. Inserted normally (8)");
2941 gtk_widget_show (menuitem);
2942 gtk_menu_shell_insert (GTK_MENU_SHELL (submenu), menuitem, 8);
2944 menuitem = gtk_menu_item_new_with_label ("2. Inserted normally (2)");
2945 gtk_widget_show (menuitem);
2946 gtk_menu_shell_insert (GTK_MENU_SHELL (submenu), menuitem, 2);
2948 menuitem = gtk_menu_item_new_with_label ("3. Inserted normally (0)");
2949 gtk_widget_show (menuitem);
2950 gtk_menu_shell_insert (GTK_MENU_SHELL (submenu), menuitem, 0);
2952 menuitem = gtk_menu_item_new_with_label ("4. Inserted normally (-1)");
2953 gtk_widget_show (menuitem);
2954 gtk_menu_shell_insert (GTK_MENU_SHELL (submenu), menuitem, -1);
2956 /* end of items submenu */
2958 menuitem = gtk_menu_item_new_with_label ("spanning");
2959 gtk_menu_attach (GTK_MENU (menu), menuitem, 0, cols, j, j + 1);
2961 submenu = gtk_menu_new ();
2962 gtk_menu_set_screen (GTK_MENU (submenu), screen);
2963 gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), submenu);
2964 gtk_widget_show (menuitem);
2967 /* now fill the spanning submenu */
2968 menuitem = gtk_menu_item_new_with_label ("a");
2969 gtk_menu_attach (GTK_MENU (submenu), menuitem, 0, 2, 0, 1);
2970 gtk_widget_show (menuitem);
2972 menuitem = gtk_menu_item_new_with_label ("b");
2973 gtk_menu_attach (GTK_MENU (submenu), menuitem, 2, 3, 0, 2);
2974 gtk_widget_show (menuitem);
2976 menuitem = gtk_menu_item_new_with_label ("c");
2977 gtk_menu_attach (GTK_MENU (submenu), menuitem, 0, 1, 1, 3);
2978 gtk_widget_show (menuitem);
2980 menuitem = gtk_menu_item_new_with_label ("d");
2981 gtk_menu_attach (GTK_MENU (submenu), menuitem, 1, 2, 1, 2);
2982 gtk_widget_show (menuitem);
2984 menuitem = gtk_menu_item_new_with_label ("e");
2985 gtk_menu_attach (GTK_MENU (submenu), menuitem, 1, 3, 2, 3);
2986 gtk_widget_show (menuitem);
2987 /* end of spanning submenu */
2989 menuitem = gtk_menu_item_new_with_label ("left");
2990 gtk_menu_attach (GTK_MENU (menu), menuitem, 0, 1, j, j + 1);
2991 submenu = gtk_menu_new ();
2992 gtk_menu_set_screen (GTK_MENU (submenu), screen);
2993 gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), submenu);
2994 gtk_widget_show (menuitem);
2996 menuitem = gtk_menu_item_new_with_label ("Empty");
2997 gtk_menu_attach (GTK_MENU (submenu), menuitem, 0, 1, 0, 1);
2998 submenu = gtk_menu_new ();
2999 gtk_menu_set_screen (GTK_MENU (submenu), screen);
3000 gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), submenu);
3001 gtk_widget_show (menuitem);
3003 menuitem = gtk_menu_item_new_with_label ("right");
3004 gtk_menu_attach (GTK_MENU (menu), menuitem, 1, 2, j, j + 1);
3005 submenu = gtk_menu_new ();
3006 gtk_menu_set_screen (GTK_MENU (submenu), screen);
3007 gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), submenu);
3008 gtk_widget_show (menuitem);
3010 menuitem = gtk_menu_item_new_with_label ("Empty");
3011 gtk_menu_attach (GTK_MENU (submenu), menuitem, 0, 1, 0, 1);
3012 gtk_widget_show (menuitem);
3016 for (; j < rows; j++)
3017 for (i = 0; i < cols; i++)
3019 sprintf (buf, "(%d %d)", i, j);
3020 menuitem = gtk_menu_item_new_with_label (buf);
3021 gtk_menu_attach (GTK_MENU (menu), menuitem, i, i + 1, j, j + 1);
3022 gtk_widget_show (menuitem);
3025 menuitem = gtk_menu_item_new_with_label ("1. Inserted normally (8)");
3026 gtk_menu_shell_insert (GTK_MENU_SHELL (menu), menuitem, 8);
3027 gtk_widget_show (menuitem);
3028 menuitem = gtk_menu_item_new_with_label ("2. Inserted normally (2)");
3029 gtk_menu_shell_insert (GTK_MENU_SHELL (menu), menuitem, 2);
3030 gtk_widget_show (menuitem);
3031 menuitem = gtk_menu_item_new_with_label ("3. Inserted normally (0)");
3032 gtk_menu_shell_insert (GTK_MENU_SHELL (menu), menuitem, 0);
3033 gtk_widget_show (menuitem);
3034 menuitem = gtk_menu_item_new_with_label ("4. Inserted normally (-1)");
3035 gtk_menu_shell_insert (GTK_MENU_SHELL (menu), menuitem, -1);
3036 gtk_widget_show (menuitem);
3042 create_menus (GtkWidget *widget)
3044 static GtkWidget *window = NULL;
3048 GtkWidget *optionmenu;
3049 GtkWidget *separator;
3055 GtkWidget *menuitem;
3056 GtkAccelGroup *accel_group;
3058 GdkScreen *screen = gtk_widget_get_screen (widget);
3060 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
3062 gtk_window_set_screen (GTK_WINDOW (window), screen);
3064 g_signal_connect (window, "destroy",
3065 G_CALLBACK (gtk_widget_destroyed),
3067 g_signal_connect (window, "delete-event",
3068 G_CALLBACK (gtk_true),
3071 accel_group = gtk_accel_group_new ();
3072 gtk_window_add_accel_group (GTK_WINDOW (window), accel_group);
3074 gtk_window_set_title (GTK_WINDOW (window), "menus");
3075 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
3078 box1 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
3079 gtk_container_add (GTK_CONTAINER (window), box1);
3080 gtk_widget_show (box1);
3082 menubar = gtk_menu_bar_new ();
3083 gtk_box_pack_start (GTK_BOX (box1), menubar, FALSE, TRUE, 0);
3084 gtk_widget_show (menubar);
3086 menu = create_menu (screen, 2, 50);
3088 menuitem = gtk_menu_item_new_with_label ("test\nline2");
3089 gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), menu);
3090 gtk_menu_shell_append (GTK_MENU_SHELL (menubar), menuitem);
3091 gtk_widget_show (menuitem);
3093 menu = create_table_menu (screen, 2, 50);
3095 menuitem = gtk_menu_item_new_with_label ("table");
3096 gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), menu);
3097 gtk_menu_shell_append (GTK_MENU_SHELL (menubar), menuitem);
3098 gtk_widget_show (menuitem);
3100 menuitem = gtk_menu_item_new_with_label ("foo");
3101 gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), create_menu (screen, 3, 5));
3102 gtk_menu_shell_append (GTK_MENU_SHELL (menubar), menuitem);
3103 gtk_widget_show (menuitem);
3105 image = gtk_image_new_from_stock (GTK_STOCK_HELP,
3106 GTK_ICON_SIZE_MENU);
3107 gtk_widget_show (image);
3108 menuitem = gtk_image_menu_item_new_with_label ("Help");
3109 gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menuitem), image);
3110 gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), create_menu (screen, 4, 5));
3111 gtk_widget_set_hexpand (menuitem, TRUE);
3112 gtk_widget_set_halign (menuitem, GTK_ALIGN_END);
3113 gtk_menu_shell_append (GTK_MENU_SHELL (menubar), menuitem);
3114 gtk_widget_show (menuitem);
3116 menubar = gtk_menu_bar_new ();
3117 gtk_box_pack_start (GTK_BOX (box1), menubar, FALSE, TRUE, 0);
3118 gtk_widget_show (menubar);
3120 menu = create_menu (screen, 2, 10);
3122 menuitem = gtk_menu_item_new_with_label ("Second menu bar");
3123 gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), menu);
3124 gtk_menu_shell_append (GTK_MENU_SHELL (menubar), menuitem);
3125 gtk_widget_show (menuitem);
3127 box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10);
3128 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
3129 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
3130 gtk_widget_show (box2);
3132 menu = create_menu (screen, 1, 5);
3133 gtk_menu_set_accel_group (GTK_MENU (menu), accel_group);
3135 menuitem = gtk_image_menu_item_new_from_stock (GTK_STOCK_NEW, accel_group);
3136 gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
3137 gtk_widget_show (menuitem);
3139 menuitem = gtk_check_menu_item_new_with_label ("Accelerate Me");
3140 gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
3141 gtk_widget_show (menuitem);
3142 gtk_widget_add_accelerator (menuitem,
3148 menuitem = gtk_check_menu_item_new_with_label ("Accelerator Locked");
3149 gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
3150 gtk_widget_show (menuitem);
3151 gtk_widget_add_accelerator (menuitem,
3156 GTK_ACCEL_VISIBLE | GTK_ACCEL_LOCKED);
3157 menuitem = gtk_check_menu_item_new_with_label ("Accelerators Frozen");
3158 gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
3159 gtk_widget_show (menuitem);
3160 gtk_widget_add_accelerator (menuitem,
3166 gtk_widget_add_accelerator (menuitem,
3173 optionmenu = gtk_combo_box_text_new ();
3174 gtk_combo_box_set_active (GTK_COMBO_BOX (optionmenu), 3);
3175 gtk_box_pack_start (GTK_BOX (box2), optionmenu, TRUE, TRUE, 0);
3176 gtk_widget_show (optionmenu);
3178 separator = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
3179 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
3180 gtk_widget_show (separator);
3182 box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10);
3183 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
3184 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
3185 gtk_widget_show (box2);
3187 button = gtk_button_new_with_label ("close");
3188 g_signal_connect_swapped (button, "clicked",
3189 G_CALLBACK (gtk_widget_destroy),
3191 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
3192 gtk_widget_set_can_default (button, TRUE);
3193 gtk_widget_grab_default (button);
3194 gtk_widget_show (button);
3197 if (!gtk_widget_get_visible (window))
3198 gtk_widget_show (window);
3200 gtk_widget_destroy (window);
3203 /* GdkPixbuf RGBA C-Source image dump */
3205 static const guint8 apple[] =
3207 /* Pixbuf magic (0x47646b50) */
3209 /* length: header (24) + pixel_data (2304) */
3211 /* pixdata_type (0x1010002) */
3213 /* rowstride (96) */
3220 "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
3221 "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
3222 "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
3223 "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
3224 "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
3225 "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
3226 "\0\0\0\0\0\0\0\0\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"
3227 "\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"
3228 "\0\0\0\0\0\0\0\0\0\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"
3229 "[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"
3230 "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
3231 "\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"
3232 "\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"
3233 "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
3234 "\0\0\0\0\0\0`l\\\20iw_\356y\211h\373x\207g\364~\216i\364u\204e\366gt"
3235 "_\374^jX\241A;-_\0\0\0~\0\0\0\0SM4)SM21B9&\22\320\270\204\1\320\270\204"
3236 "\0\0\0\0\0\0\0\0\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"
3237 "]\212r\200c\366v\205f\371jx_\323_kY\232_kZH^jY\26]iW\211@G9\272:6%j\220"
3238 "\211]\320\221\211`\377\212\203Z\377~xP\377mkE\331]^;|/0\37\21\0\0\0\0"
3239 "\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["
3240 "eT<\216\200Z\203\227\211_\354\234\217c\377\232\217b\362\232\220c\337"
3241 "\243\233k\377\252\241p\377\250\236p\377\241\225h\377\231\214_\377\210"
3242 "\202U\377srI\377[]:\355KO0U\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0i"
3243 "v^\200`lY\211^jY\"\0\0\0\0\221\204\\\273\250\233r\377\302\267\224\377"
3244 "\311\300\237\377\272\256\204\377\271\256\177\377\271\257\200\377\267"
3245 "\260\177\377\260\251x\377\250\236l\377\242\225e\377\226\213]\377~zP\377"
3246 "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"
3247 "\0\213\203[v\253\240t\377\334\326\301\377\344\340\317\377\321\312\253"
3248 "\377\303\271\217\377\300\270\213\377\277\267\210\377\272\264\203\377"
3249 "\261\255z\377\250\242n\377\243\232h\377\232\220`\377\210\202V\377nnE"
3250 "\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"
3251 "\234\222e\362\304\274\232\377\337\333\306\377\332\325\273\377\311\302"
3252 "\232\377\312\303\236\377\301\273\216\377\300\271\212\377\270\264\200"
3253 "\377\256\253v\377\246\243n\377\236\232h\377\230\220`\377\213\203V\377"
3254 "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"
3255 "\203Zl\242\234l\377\321\315\260\377\331\324\271\377\320\313\251\377\307"
3256 "\301\232\377\303\276\224\377\300\272\214\377\274\267\206\377\264\260"
3257 "|\377\253\251s\377\244\243n\377\232\230e\377\223\216^\377\207\200U\377"
3258 "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"
3259 "\210\204Y\240\245\237o\377\316\310\253\377\310\303\237\377\304\300\230"
3260 "\377\303\277\225\377\277\272\216\377\274\270\210\377\266\263\200\377"
3261 "\256\254v\377\247\246p\377\237\236j\377\227\226d\377\215\212[\377\203"
3262 "\177T\377qsH\377X]8\377FN.\377DK-\200\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
3263 "\0\0\0\0\207\204X\257\244\240o\377\300\275\231\377\301\275\226\377\274"
3264 "\270\213\377\274\270\214\377\267\264\205\377\264\262\200\377\260\256"
3265 "z\377\251\251s\377\243\244n\377\231\232g\377\220\222`\377\210\211Y\377"
3266 "|}Q\377hlC\377PU3\377CK,\377DL/Y\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
3267 "\0\0\205\204X\220\232\230h\377\261\260\204\377\266\264\212\377\261\260"
3268 "\201\377\263\260\200\377\260\257}\377\256\256x\377\253\254t\377\244\246"
3269 "o\377\233\236i\377\221\224b\377\211\214\\\377\202\204V\377txM\377]b>"
3270 "\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>"
3271 "\215\215_\377\237\237r\377\247\247x\377\247\247t\377\252\252w\377\252"
3272 "\252u\377\252\253t\377\243\246o\377\235\240j\377\223\230c\377\213\217"
3273 "]\377\201\206V\377x}P\377gkD\377RY5\377BI,\377AI,\262\0\0\0\0\0\0\0\0"
3274 "\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"
3275 "\232g\377\234\236i\377\236\241l\377\241\244n\377\240\244m\377\232\237"
3276 "i\377\223\230c\377\212\221]\377\200\210W\377v|P\377jnG\377Za>\377HP2"
3277 "\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"
3278 "\0wzQ6\177\201U\371\206\211Z\377\216\222`\377\220\225a\377\220\225b\377"
3279 "\220\226a\377\213\221_\377\204\213Z\377{\203R\377ryN\377iqH\377^fA\377"
3280 "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"
3281 "\0\0\0\0\0\0\0\0\0\0\0\0ptJTw|Q\371z\177R\377}\202T\377|\203T\377z\200"
3282 "R\377v|O\377pwL\377jpF\377dlB\377`hB\377Yb@\377LT6\377<C*\377\11\12\6"
3283 "\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"
3284 "\0\0\0\0\0\0\0\0\0\0\\`=UgnE\370hnG\377gmE\377djB\377]d>\377[c<\377Y"
3285 "b<\377Zc>\377V_>\377OW8\377BK/\377\16\20\12\377\0\0\0\377\0\0\0\377\0"
3286 "\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"
3287 "\0\1\0\0\0\40\22\24\15\260@D+\377W`;\377OV5\377.3\36\377.3\37\377IP0"
3288 "\377RZ7\377PZ8\3776=&\377\14\15\10\377\0\0\0\377\0\0\0\377\0\0\0\377"
3289 "\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"
3290 "\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"
3291 "\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"
3292 "\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"
3293 "\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"
3294 "\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"
3295 "\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"
3296 "\0\0\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"
3297 "\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"
3298 "\0\0\5\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"};
3302 accel_button_new (GtkAccelGroup *accel_group,
3307 GdkModifierType modifiers;
3311 gtk_accelerator_parse (accel, &keyval, &modifiers);
3314 button = gtk_button_new ();
3315 gtk_widget_add_accelerator (button, "activate", accel_group,
3316 keyval, modifiers, GTK_ACCEL_VISIBLE | GTK_ACCEL_LOCKED);
3318 label = gtk_accel_label_new (text);
3319 gtk_accel_label_set_accel_widget (GTK_ACCEL_LABEL (label), button);
3320 gtk_widget_show (label);
3322 gtk_container_add (GTK_CONTAINER (button), label);
3328 create_key_lookup (GtkWidget *widget)
3330 static GtkWidget *window = NULL;
3331 gpointer window_ptr;
3335 GtkAccelGroup *accel_group = gtk_accel_group_new ();
3337 GtkWidget *content_area;
3339 window = gtk_dialog_new_with_buttons ("Key Lookup", NULL, 0,
3340 GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE,
3343 gtk_window_set_screen (GTK_WINDOW (window),
3344 gtk_widget_get_screen (widget));
3346 /* We have to expand it so the accel labels will draw their labels
3348 gtk_window_set_default_size (GTK_WINDOW (window), 300, -1);
3350 gtk_window_add_accel_group (GTK_WINDOW (window), accel_group);
3352 content_area = gtk_dialog_get_content_area (GTK_DIALOG (window));
3354 button = gtk_button_new_with_mnemonic ("Button 1 (_a)");
3355 gtk_box_pack_start (GTK_BOX (content_area), button, FALSE, FALSE, 0);
3356 button = gtk_button_new_with_mnemonic ("Button 2 (_A)");
3357 gtk_box_pack_start (GTK_BOX (content_area), button, FALSE, FALSE, 0);
3358 button = gtk_button_new_with_mnemonic ("Button 3 (_\321\204)");
3359 gtk_box_pack_start (GTK_BOX (content_area), button, FALSE, FALSE, 0);
3360 button = gtk_button_new_with_mnemonic ("Button 4 (_\320\244)");
3361 gtk_box_pack_start (GTK_BOX (content_area), button, FALSE, FALSE, 0);
3362 button = gtk_button_new_with_mnemonic ("Button 6 (_b)");
3363 gtk_box_pack_start (GTK_BOX (content_area), button, FALSE, FALSE, 0);
3364 button = accel_button_new (accel_group, "Button 7", "<Alt><Shift>b");
3365 gtk_box_pack_start (GTK_BOX (content_area), button, FALSE, FALSE, 0);
3366 button = accel_button_new (accel_group, "Button 8", "<Alt>d");
3367 gtk_box_pack_start (GTK_BOX (content_area), button, FALSE, FALSE, 0);
3368 button = accel_button_new (accel_group, "Button 9", "<Alt>Cyrillic_ve");
3369 gtk_box_pack_start (GTK_BOX (content_area), button, FALSE, FALSE, 0);
3370 button = gtk_button_new_with_mnemonic ("Button 10 (_1)");
3371 gtk_box_pack_start (GTK_BOX (content_area), button, FALSE, FALSE, 0);
3372 button = gtk_button_new_with_mnemonic ("Button 11 (_!)");
3373 gtk_box_pack_start (GTK_BOX (content_area), button, FALSE, FALSE, 0);
3374 button = accel_button_new (accel_group, "Button 12", "<Super>a");
3375 gtk_box_pack_start (GTK_BOX (content_area), button, FALSE, FALSE, 0);
3376 button = accel_button_new (accel_group, "Button 13", "<Hyper>a");
3377 gtk_box_pack_start (GTK_BOX (content_area), button, FALSE, FALSE, 0);
3378 button = accel_button_new (accel_group, "Button 14", "<Meta>a");
3379 gtk_box_pack_start (GTK_BOX (content_area), button, FALSE, FALSE, 0);
3380 button = accel_button_new (accel_group, "Button 15", "<Shift><Mod4>b");
3381 gtk_box_pack_start (GTK_BOX (content_area), button, FALSE, FALSE, 0);
3383 window_ptr = &window;
3384 g_object_add_weak_pointer (G_OBJECT (window), window_ptr);
3385 g_signal_connect (window, "response", G_CALLBACK (gtk_widget_destroy), NULL);
3387 gtk_widget_show_all (window);
3390 gtk_widget_destroy (window);
3399 cmw_destroy_cb(GtkWidget *widget)
3401 /* This is needed to get out of gtk_main */
3408 cmw_color (GtkWidget *widget, GtkWidget *parent)
3412 csd = gtk_color_chooser_dialog_new ("This is a modal color selection dialog", GTK_WINDOW (parent));
3415 gtk_window_set_modal (GTK_WINDOW(csd),TRUE);
3417 g_signal_connect (csd, "destroy",
3418 G_CALLBACK (cmw_destroy_cb), NULL);
3419 g_signal_connect (csd, "response",
3420 G_CALLBACK (gtk_widget_destroy), NULL);
3422 /* wait until destroy calls gtk_main_quit */
3423 gtk_widget_show (csd);
3428 cmw_file (GtkWidget *widget, GtkWidget *parent)
3432 fs = gtk_file_chooser_dialog_new ("This is a modal file selection dialog",
3433 GTK_WINDOW (parent), GTK_FILE_CHOOSER_ACTION_OPEN,
3434 GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
3435 GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
3437 gtk_window_set_screen (GTK_WINDOW (fs), gtk_widget_get_screen (parent));
3438 gtk_window_set_modal (GTK_WINDOW (fs), TRUE);
3440 g_signal_connect (fs, "destroy",
3441 G_CALLBACK (cmw_destroy_cb), NULL);
3442 g_signal_connect_swapped (fs, "response",
3443 G_CALLBACK (gtk_widget_destroy), fs);
3445 /* wait until destroy calls gtk_main_quit */
3446 gtk_widget_show (fs);
3452 create_modal_window (GtkWidget *widget)
3454 GtkWidget *window = NULL;
3455 GtkWidget *box1,*box2;
3457 GtkWidget *btnColor,*btnFile,*btnClose;
3459 /* Create modal window (Here you can use any window descendent )*/
3460 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
3461 gtk_window_set_screen (GTK_WINDOW (window),
3462 gtk_widget_get_screen (widget));
3464 gtk_window_set_title (GTK_WINDOW(window),"This window is modal");
3466 /* Set window as modal */
3467 gtk_window_set_modal (GTK_WINDOW(window),TRUE);
3469 /* Create widgets */
3470 box1 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
3471 frame1 = gtk_frame_new ("Standard dialogs in modal form");
3472 box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
3473 gtk_box_set_homogeneous (GTK_BOX (box2), TRUE);
3474 btnColor = gtk_button_new_with_label ("Color");
3475 btnFile = gtk_button_new_with_label ("File Selection");
3476 btnClose = gtk_button_new_with_label ("Close");
3479 gtk_container_set_border_width (GTK_CONTAINER (box1), 3);
3480 gtk_container_set_border_width (GTK_CONTAINER (box2), 3);
3483 gtk_container_add (GTK_CONTAINER (window), box1);
3484 gtk_box_pack_start (GTK_BOX (box1), frame1, TRUE, TRUE, 4);
3485 gtk_container_add (GTK_CONTAINER (frame1), box2);
3486 gtk_box_pack_start (GTK_BOX (box2), btnColor, FALSE, FALSE, 4);
3487 gtk_box_pack_start (GTK_BOX (box2), btnFile, FALSE, FALSE, 4);
3488 gtk_box_pack_start (GTK_BOX (box1), gtk_separator_new (GTK_ORIENTATION_HORIZONTAL), FALSE, FALSE, 4);
3489 gtk_box_pack_start (GTK_BOX (box1), btnClose, FALSE, FALSE, 4);
3491 /* connect signals */
3492 g_signal_connect_swapped (btnClose, "clicked",
3493 G_CALLBACK (gtk_widget_destroy), window);
3495 g_signal_connect (window, "destroy",
3496 G_CALLBACK (cmw_destroy_cb), NULL);
3498 g_signal_connect (btnColor, "clicked",
3499 G_CALLBACK (cmw_color), window);
3500 g_signal_connect (btnFile, "clicked",
3501 G_CALLBACK (cmw_file), window);
3504 gtk_widget_show_all (window);
3506 /* wait until dialog get destroyed */
3515 make_message_dialog (GdkScreen *screen,
3517 GtkMessageType type,
3518 GtkButtonsType buttons,
3519 guint default_response)
3523 gtk_widget_destroy (*dialog);
3528 *dialog = gtk_message_dialog_new (NULL, 0, type, buttons,
3529 "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.)");
3531 gtk_window_set_screen (GTK_WINDOW (*dialog), screen);
3533 g_signal_connect_swapped (*dialog,
3535 G_CALLBACK (gtk_widget_destroy),
3538 g_signal_connect (*dialog,
3540 G_CALLBACK (gtk_widget_destroyed),
3543 gtk_dialog_set_default_response (GTK_DIALOG (*dialog), default_response);
3545 gtk_widget_show (*dialog);
3549 create_message_dialog (GtkWidget *widget)
3551 static GtkWidget *info = NULL;
3552 static GtkWidget *warning = NULL;
3553 static GtkWidget *error = NULL;
3554 static GtkWidget *question = NULL;
3555 GdkScreen *screen = gtk_widget_get_screen (widget);
3557 make_message_dialog (screen, &info, GTK_MESSAGE_INFO, GTK_BUTTONS_OK, GTK_RESPONSE_OK);
3558 make_message_dialog (screen, &warning, GTK_MESSAGE_WARNING, GTK_BUTTONS_CLOSE, GTK_RESPONSE_CLOSE);
3559 make_message_dialog (screen, &error, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK_CANCEL, GTK_RESPONSE_OK);
3560 make_message_dialog (screen, &question, GTK_MESSAGE_QUESTION, GTK_BUTTONS_YES_NO, GTK_RESPONSE_NO);
3567 static GtkWidget *sw_parent = NULL;
3568 static GtkWidget *sw_float_parent;
3569 static gulong sw_destroyed_handler = 0;
3572 scrolled_windows_delete_cb (GtkWidget *widget, GdkEventAny *event, GtkWidget *scrollwin)
3574 gtk_widget_reparent (scrollwin, sw_parent);
3576 g_signal_handler_disconnect (sw_parent, sw_destroyed_handler);
3577 sw_float_parent = NULL;
3579 sw_destroyed_handler = 0;
3585 scrolled_windows_destroy_cb (GtkWidget *widget, GtkWidget *scrollwin)
3587 gtk_widget_destroy (sw_float_parent);
3589 sw_float_parent = NULL;
3591 sw_destroyed_handler = 0;
3595 scrolled_windows_remove (GtkWidget *widget, GtkWidget *scrollwin)
3599 gtk_widget_reparent (scrollwin, sw_parent);
3600 gtk_widget_destroy (sw_float_parent);
3602 g_signal_handler_disconnect (sw_parent, sw_destroyed_handler);
3603 sw_float_parent = NULL;
3605 sw_destroyed_handler = 0;
3609 sw_parent = gtk_widget_get_parent (scrollwin);
3610 sw_float_parent = gtk_window_new (GTK_WINDOW_TOPLEVEL);
3611 gtk_window_set_screen (GTK_WINDOW (sw_float_parent),
3612 gtk_widget_get_screen (widget));
3614 gtk_window_set_default_size (GTK_WINDOW (sw_float_parent), 200, 200);
3616 gtk_widget_reparent (scrollwin, sw_float_parent);
3617 gtk_widget_show (sw_float_parent);
3619 sw_destroyed_handler =
3620 g_signal_connect (sw_parent, "destroy",
3621 G_CALLBACK (scrolled_windows_destroy_cb), scrollwin);
3622 g_signal_connect (sw_float_parent, "delete_event",
3623 G_CALLBACK (scrolled_windows_delete_cb), scrollwin);
3628 create_scrolled_windows (GtkWidget *widget)
3630 static GtkWidget *window;
3631 GtkWidget *content_area, *action_area;
3632 GtkWidget *scrolled_window;
3640 window = gtk_dialog_new ();
3642 gtk_window_set_screen (GTK_WINDOW (window),
3643 gtk_widget_get_screen (widget));
3645 g_signal_connect (window, "destroy",
3646 G_CALLBACK (gtk_widget_destroyed),
3649 content_area = gtk_dialog_get_content_area (GTK_DIALOG (window));
3650 action_area = gtk_dialog_get_action_area (GTK_DIALOG (window));
3652 gtk_window_set_title (GTK_WINDOW (window), "dialog");
3653 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
3655 scrolled_window = gtk_scrolled_window_new (NULL, NULL);
3656 gtk_container_set_border_width (GTK_CONTAINER (scrolled_window), 10);
3657 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
3658 GTK_POLICY_AUTOMATIC,
3659 GTK_POLICY_AUTOMATIC);
3660 gtk_box_pack_start (GTK_BOX (content_area), scrolled_window, TRUE, TRUE, 0);
3661 gtk_widget_show (scrolled_window);
3663 grid = gtk_grid_new ();
3664 gtk_grid_set_row_spacing (GTK_GRID (grid), 10);
3665 gtk_grid_set_column_spacing (GTK_GRID (grid), 10);
3666 gtk_container_add (GTK_CONTAINER (scrolled_window), grid);
3667 gtk_container_set_focus_hadjustment (GTK_CONTAINER (grid),
3668 gtk_scrolled_window_get_hadjustment (GTK_SCROLLED_WINDOW (scrolled_window)));
3669 gtk_container_set_focus_vadjustment (GTK_CONTAINER (grid),
3670 gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (scrolled_window)));
3671 gtk_widget_show (grid);
3673 for (i = 0; i < 20; i++)
3674 for (j = 0; j < 20; j++)
3676 sprintf (buffer, "button (%d,%d)\n", i, j);
3677 button = gtk_toggle_button_new_with_label (buffer);
3678 gtk_grid_attach (GTK_GRID (grid), button, i, j, 1, 1);
3679 gtk_widget_show (button);
3683 button = gtk_button_new_with_label ("Close");
3684 g_signal_connect_swapped (button, "clicked",
3685 G_CALLBACK (gtk_widget_destroy),
3687 gtk_widget_set_can_default (button, TRUE);
3688 gtk_box_pack_start (GTK_BOX (action_area), button, TRUE, TRUE, 0);
3689 gtk_widget_grab_default (button);
3690 gtk_widget_show (button);
3692 button = gtk_button_new_with_label ("Reparent Out");
3693 g_signal_connect (button, "clicked",
3694 G_CALLBACK (scrolled_windows_remove),
3696 gtk_widget_set_can_default (button, TRUE);
3697 gtk_box_pack_start (GTK_BOX (action_area), button, TRUE, TRUE, 0);
3698 gtk_widget_grab_default (button);
3699 gtk_widget_show (button);
3701 gtk_window_set_default_size (GTK_WINDOW (window), 300, 300);
3704 if (!gtk_widget_get_visible (window))
3705 gtk_widget_show (window);
3707 gtk_widget_destroy (window);
3715 entry_toggle_frame (GtkWidget *checkbutton,
3718 gtk_entry_set_has_frame (GTK_ENTRY(entry),
3719 gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (checkbutton)));
3723 entry_toggle_sensitive (GtkWidget *checkbutton,
3726 gtk_widget_set_sensitive (entry,
3727 gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON(checkbutton)));
3731 entry_progress_timeout (gpointer data)
3733 if (GPOINTER_TO_INT (g_object_get_data (G_OBJECT (data), "progress-pulse")))
3735 gtk_entry_progress_pulse (GTK_ENTRY (data));
3741 fraction = gtk_entry_get_progress_fraction (GTK_ENTRY (data));
3744 if (fraction > 1.0001)
3747 gtk_entry_set_progress_fraction (GTK_ENTRY (data), fraction);
3750 return G_SOURCE_CONTINUE;
3754 entry_remove_timeout (gpointer data)
3756 g_source_remove (GPOINTER_TO_UINT (data));
3760 entry_toggle_progress (GtkWidget *checkbutton,
3763 if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (checkbutton)))
3765 guint timeout = gdk_threads_add_timeout (100,
3766 entry_progress_timeout,
3768 g_object_set_data_full (G_OBJECT (entry), "timeout-id",
3769 GUINT_TO_POINTER (timeout),
3770 entry_remove_timeout);
3774 g_object_set_data (G_OBJECT (entry), "timeout-id",
3775 GUINT_TO_POINTER (0));
3777 gtk_entry_set_progress_fraction (GTK_ENTRY (entry), 0.0);
3782 entry_toggle_pulse (GtkWidget *checkbutton,
3785 g_object_set_data (G_OBJECT (entry), "progress-pulse",
3786 GUINT_TO_POINTER ((guint) gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (checkbutton))));
3790 props_clicked (GtkWidget *button,
3793 GtkWidget *window = create_prop_editor (object, 0);
3795 gtk_window_set_title (GTK_WINDOW (window), "Object Properties");
3799 create_entry (GtkWidget *widget)
3801 static GtkWidget *window = NULL;
3805 GtkWidget *has_frame_check;
3806 GtkWidget *sensitive_check;
3807 GtkWidget *progress_check;
3809 GtkComboBoxText *cb;
3810 GtkWidget *cb_entry;
3812 GtkWidget *separator;
3816 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
3817 gtk_window_set_screen (GTK_WINDOW (window),
3818 gtk_widget_get_screen (widget));
3820 g_signal_connect (window, "destroy",
3821 G_CALLBACK (gtk_widget_destroyed),
3824 gtk_window_set_title (GTK_WINDOW (window), "entry");
3825 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
3828 box1 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
3829 gtk_container_add (GTK_CONTAINER (window), box1);
3832 box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10);
3833 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
3834 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
3836 hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 5);
3837 gtk_box_pack_start (GTK_BOX (box2), hbox, TRUE, TRUE, 0);
3839 entry = gtk_entry_new ();
3840 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");
3841 gtk_editable_select_region (GTK_EDITABLE (entry), 0, 5);
3842 gtk_box_pack_start (GTK_BOX (hbox), entry, TRUE, TRUE, 0);
3844 button = gtk_button_new_with_mnemonic ("_Props");
3845 gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0);
3846 g_signal_connect (button, "clicked",
3847 G_CALLBACK (props_clicked),
3850 cb = GTK_COMBO_BOX_TEXT (gtk_combo_box_text_new_with_entry ());
3852 gtk_combo_box_text_append_text (cb, "item0");
3853 gtk_combo_box_text_append_text (cb, "item0");
3854 gtk_combo_box_text_append_text (cb, "item1 item1");
3855 gtk_combo_box_text_append_text (cb, "item2 item2 item2");
3856 gtk_combo_box_text_append_text (cb, "item3 item3 item3 item3");
3857 gtk_combo_box_text_append_text (cb, "item4 item4 item4 item4 item4");
3858 gtk_combo_box_text_append_text (cb, "item5 item5 item5 item5 item5 item5");
3859 gtk_combo_box_text_append_text (cb, "item6 item6 item6 item6 item6");
3860 gtk_combo_box_text_append_text (cb, "item7 item7 item7 item7");
3861 gtk_combo_box_text_append_text (cb, "item8 item8 item8");
3862 gtk_combo_box_text_append_text (cb, "item9 item9");
3864 cb_entry = gtk_bin_get_child (GTK_BIN (cb));
3865 gtk_entry_set_text (GTK_ENTRY (cb_entry), "hello world \n\n\n foo");
3866 gtk_editable_select_region (GTK_EDITABLE (cb_entry), 0, -1);
3867 gtk_box_pack_start (GTK_BOX (box2), GTK_WIDGET (cb), TRUE, TRUE, 0);
3869 sensitive_check = gtk_check_button_new_with_label("Sensitive");
3870 gtk_box_pack_start (GTK_BOX (box2), sensitive_check, FALSE, TRUE, 0);
3871 g_signal_connect (sensitive_check, "toggled",
3872 G_CALLBACK (entry_toggle_sensitive), entry);
3873 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (sensitive_check), TRUE);
3875 has_frame_check = gtk_check_button_new_with_label("Has Frame");
3876 gtk_box_pack_start (GTK_BOX (box2), has_frame_check, FALSE, TRUE, 0);
3877 g_signal_connect (has_frame_check, "toggled",
3878 G_CALLBACK (entry_toggle_frame), entry);
3879 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (has_frame_check), TRUE);
3881 progress_check = gtk_check_button_new_with_label("Show Progress");
3882 gtk_box_pack_start (GTK_BOX (box2), progress_check, FALSE, TRUE, 0);
3883 g_signal_connect (progress_check, "toggled",
3884 G_CALLBACK (entry_toggle_progress), entry);
3886 progress_check = gtk_check_button_new_with_label("Pulse Progress");
3887 gtk_box_pack_start (GTK_BOX (box2), progress_check, FALSE, TRUE, 0);
3888 g_signal_connect (progress_check, "toggled",
3889 G_CALLBACK (entry_toggle_pulse), entry);
3891 separator = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
3892 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
3894 box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10);
3895 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
3896 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
3898 button = gtk_button_new_with_label ("close");
3899 g_signal_connect_swapped (button, "clicked",
3900 G_CALLBACK (gtk_widget_destroy),
3902 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
3903 gtk_widget_set_can_default (button, TRUE);
3904 gtk_widget_grab_default (button);
3907 if (!gtk_widget_get_visible (window))
3908 gtk_widget_show_all (window);
3910 gtk_widget_destroy (window);
3914 create_expander (GtkWidget *widget)
3917 GtkWidget *expander;
3919 static GtkWidget *window = NULL;
3923 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
3924 gtk_window_set_screen (GTK_WINDOW (window),
3925 gtk_widget_get_screen (widget));
3927 g_signal_connect (window, "destroy",
3928 G_CALLBACK (gtk_widget_destroyed),
3931 gtk_window_set_title (GTK_WINDOW (window), "expander");
3932 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
3934 box1 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
3935 gtk_container_add (GTK_CONTAINER (window), box1);
3937 expander = gtk_expander_new ("The Hidden");
3939 gtk_box_pack_start (GTK_BOX (box1), expander, TRUE, TRUE, 0);
3941 hidden = gtk_label_new ("Revealed!");
3943 gtk_container_add (GTK_CONTAINER (expander), hidden);
3946 if (!gtk_widget_get_visible (window))
3947 gtk_widget_show_all (window);
3949 gtk_widget_destroy (window);
3957 event_box_label_pressed (GtkWidget *widget,
3958 GdkEventButton *event,
3961 g_print ("clicked on event box\n");
3965 event_box_button_clicked (GtkWidget *widget,
3969 g_print ("pushed button\n");
3973 event_box_toggle_visible_window (GtkWidget *checkbutton,
3974 GtkEventBox *event_box)
3976 gtk_event_box_set_visible_window (event_box,
3977 gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (checkbutton)));
3981 event_box_toggle_above_child (GtkWidget *checkbutton,
3982 GtkEventBox *event_box)
3984 gtk_event_box_set_above_child (event_box,
3985 gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (checkbutton)));
3989 create_event_box (GtkWidget *widget)
3991 static GtkWidget *window = NULL;
3997 GtkWidget *separator;
3998 GtkWidget *event_box;
4000 GtkWidget *visible_window_check;
4001 GtkWidget *above_child_check;
4011 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
4012 gtk_window_set_screen (GTK_WINDOW (window),
4013 gtk_widget_get_screen (widget));
4015 g_signal_connect (window, "destroy",
4016 G_CALLBACK (gtk_widget_destroyed),
4019 gtk_window_set_title (GTK_WINDOW (window), "event box");
4020 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
4022 box1 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
4023 gtk_container_add (GTK_CONTAINER (window), box1);
4024 gtk_widget_override_background_color (window, 0, &color);
4026 hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
4027 gtk_box_pack_start (GTK_BOX (box1), hbox, TRUE, FALSE, 0);
4029 event_box = gtk_event_box_new ();
4030 gtk_box_pack_start (GTK_BOX (hbox), event_box, TRUE, FALSE, 0);
4032 vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
4033 gtk_container_add (GTK_CONTAINER (event_box), vbox);
4034 g_signal_connect (event_box, "button_press_event",
4035 G_CALLBACK (event_box_label_pressed),
4038 label = gtk_label_new ("Click on this label");
4039 gtk_box_pack_start (GTK_BOX (vbox), label, TRUE, FALSE, 0);
4041 button = gtk_button_new_with_label ("button in eventbox");
4042 gtk_box_pack_start (GTK_BOX (vbox), button, TRUE, FALSE, 0);
4043 g_signal_connect (button, "clicked",
4044 G_CALLBACK (event_box_button_clicked),
4048 visible_window_check = gtk_check_button_new_with_label("Visible Window");
4049 gtk_box_pack_start (GTK_BOX (box1), visible_window_check, FALSE, TRUE, 0);
4050 g_signal_connect (visible_window_check, "toggled",
4051 G_CALLBACK (event_box_toggle_visible_window), event_box);
4052 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (visible_window_check), FALSE);
4054 above_child_check = gtk_check_button_new_with_label("Above Child");
4055 gtk_box_pack_start (GTK_BOX (box1), above_child_check, FALSE, TRUE, 0);
4056 g_signal_connect (above_child_check, "toggled",
4057 G_CALLBACK (event_box_toggle_above_child), event_box);
4058 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (above_child_check), FALSE);
4060 separator = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
4061 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
4063 box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10);
4064 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
4065 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
4067 button = gtk_button_new_with_label ("close");
4068 g_signal_connect_swapped (button, "clicked",
4069 G_CALLBACK (gtk_widget_destroy),
4071 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
4072 gtk_widget_set_can_default (button, TRUE);
4073 gtk_widget_grab_default (button);
4076 if (!gtk_widget_get_visible (window))
4077 gtk_widget_show_all (window);
4079 gtk_widget_destroy (window);
4087 #define SIZE_GROUP_INITIAL_SIZE 50
4090 size_group_hsize_changed (GtkSpinButton *spin_button,
4093 gtk_widget_set_size_request (gtk_bin_get_child (GTK_BIN (button)),
4094 gtk_spin_button_get_value_as_int (spin_button),
4099 size_group_vsize_changed (GtkSpinButton *spin_button,
4102 gtk_widget_set_size_request (gtk_bin_get_child (GTK_BIN (button)),
4104 gtk_spin_button_get_value_as_int (spin_button));
4108 create_size_group_window (GdkScreen *screen,
4109 GtkSizeGroup *master_size_group)
4111 GtkWidget *content_area;
4114 GtkWidget *main_button;
4116 GtkWidget *spin_button;
4118 GtkSizeGroup *hgroup1;
4119 GtkSizeGroup *hgroup2;
4120 GtkSizeGroup *vgroup1;
4121 GtkSizeGroup *vgroup2;
4123 window = gtk_dialog_new_with_buttons ("GtkSizeGroup",
4129 gtk_window_set_screen (GTK_WINDOW (window), screen);
4131 gtk_window_set_resizable (GTK_WINDOW (window), TRUE);
4133 g_signal_connect (window, "response",
4134 G_CALLBACK (gtk_widget_destroy),
4137 content_area = gtk_dialog_get_content_area (GTK_DIALOG (window));
4139 grid = gtk_grid_new ();
4140 gtk_box_pack_start (GTK_BOX (content_area), grid, TRUE, TRUE, 0);
4142 gtk_grid_set_row_spacing (GTK_GRID (grid), 5);
4143 gtk_grid_set_column_spacing (GTK_GRID (grid), 5);
4144 gtk_container_set_border_width (GTK_CONTAINER (grid), 5);
4145 gtk_widget_set_size_request (grid, 250, 250);
4147 hgroup1 = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
4148 hgroup2 = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
4149 vgroup1 = gtk_size_group_new (GTK_SIZE_GROUP_VERTICAL);
4150 vgroup2 = gtk_size_group_new (GTK_SIZE_GROUP_VERTICAL);
4152 main_button = gtk_button_new_with_label ("X");
4153 gtk_widget_set_hexpand (main_button, TRUE);
4154 gtk_widget_set_vexpand (main_button, TRUE);
4155 gtk_widget_set_halign (main_button, GTK_ALIGN_CENTER);
4156 gtk_widget_set_valign (main_button, GTK_ALIGN_CENTER);
4157 gtk_grid_attach (GTK_GRID (grid), main_button, 0, 0, 1, 1);
4159 gtk_size_group_add_widget (master_size_group, main_button);
4160 gtk_size_group_add_widget (hgroup1, main_button);
4161 gtk_size_group_add_widget (vgroup1, main_button);
4162 gtk_widget_set_size_request (gtk_bin_get_child (GTK_BIN (main_button)),
4163 SIZE_GROUP_INITIAL_SIZE,
4164 SIZE_GROUP_INITIAL_SIZE);
4166 button = gtk_button_new ();
4167 gtk_widget_set_hexpand (button, TRUE);
4168 gtk_widget_set_vexpand (button, TRUE);
4169 gtk_widget_set_halign (button, GTK_ALIGN_CENTER);
4170 gtk_widget_set_valign (button, GTK_ALIGN_CENTER);
4171 gtk_grid_attach (GTK_GRID (grid), button, 1, 0, 1, 1);
4173 gtk_size_group_add_widget (vgroup1, button);
4174 gtk_size_group_add_widget (vgroup2, button);
4176 button = gtk_button_new ();
4177 gtk_widget_set_hexpand (button, TRUE);
4178 gtk_widget_set_vexpand (button, TRUE);
4179 gtk_widget_set_halign (button, GTK_ALIGN_CENTER);
4180 gtk_widget_set_valign (button, GTK_ALIGN_CENTER);
4181 gtk_grid_attach (GTK_GRID (grid), button, 0, 1, 1, 1);
4183 gtk_size_group_add_widget (hgroup1, button);
4184 gtk_size_group_add_widget (hgroup2, button);
4186 button = gtk_button_new ();
4187 gtk_widget_set_hexpand (button, TRUE);
4188 gtk_widget_set_vexpand (button, TRUE);
4189 gtk_widget_set_halign (button, GTK_ALIGN_CENTER);
4190 gtk_widget_set_valign (button, GTK_ALIGN_CENTER);
4191 gtk_grid_attach (GTK_GRID (grid), button, 1, 1, 1, 1);
4193 gtk_size_group_add_widget (hgroup2, button);
4194 gtk_size_group_add_widget (vgroup2, button);
4196 g_object_unref (hgroup1);
4197 g_object_unref (hgroup2);
4198 g_object_unref (vgroup1);
4199 g_object_unref (vgroup2);
4201 hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 5);
4202 gtk_box_pack_start (GTK_BOX (content_area), hbox, FALSE, FALSE, 0);
4204 spin_button = gtk_spin_button_new_with_range (1, 100, 1);
4205 gtk_spin_button_set_value (GTK_SPIN_BUTTON (spin_button), SIZE_GROUP_INITIAL_SIZE);
4206 gtk_box_pack_start (GTK_BOX (hbox), spin_button, TRUE, TRUE, 0);
4207 g_signal_connect (spin_button, "value_changed",
4208 G_CALLBACK (size_group_hsize_changed), main_button);
4210 spin_button = gtk_spin_button_new_with_range (1, 100, 1);
4211 gtk_spin_button_set_value (GTK_SPIN_BUTTON (spin_button), SIZE_GROUP_INITIAL_SIZE);
4212 gtk_box_pack_start (GTK_BOX (hbox), spin_button, TRUE, TRUE, 0);
4213 g_signal_connect (spin_button, "value_changed",
4214 G_CALLBACK (size_group_vsize_changed), main_button);
4220 create_size_groups (GtkWidget *widget)
4222 static GtkWidget *window1 = NULL;
4223 static GtkWidget *window2 = NULL;
4224 static GtkSizeGroup *master_size_group;
4226 if (!master_size_group)
4227 master_size_group = gtk_size_group_new (GTK_SIZE_GROUP_BOTH);
4231 window1 = create_size_group_window (gtk_widget_get_screen (widget),
4234 g_signal_connect (window1, "destroy",
4235 G_CALLBACK (gtk_widget_destroyed),
4241 window2 = create_size_group_window (gtk_widget_get_screen (widget),
4244 g_signal_connect (window2, "destroy",
4245 G_CALLBACK (gtk_widget_destroyed),
4249 if (gtk_widget_get_visible (window1) && gtk_widget_get_visible (window2))
4251 gtk_widget_destroy (window1);
4252 gtk_widget_destroy (window2);
4256 if (!gtk_widget_get_visible (window1))
4257 gtk_widget_show_all (window1);
4258 if (!gtk_widget_get_visible (window2))
4259 gtk_widget_show_all (window2);
4267 static GtkWidget *spinner1;
4270 toggle_snap (GtkWidget *widget, GtkSpinButton *spin)
4272 gtk_spin_button_set_snap_to_ticks (spin,
4273 gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget)));
4277 toggle_numeric (GtkWidget *widget, GtkSpinButton *spin)
4279 gtk_spin_button_set_numeric (spin,
4280 gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget)));
4284 change_digits (GtkWidget *widget, GtkSpinButton *spin)
4286 gtk_spin_button_set_digits (GTK_SPIN_BUTTON (spinner1),
4287 gtk_spin_button_get_value_as_int (spin));
4291 get_value (GtkWidget *widget, gpointer data)
4295 GtkSpinButton *spin;
4297 spin = GTK_SPIN_BUTTON (spinner1);
4298 label = GTK_LABEL (g_object_get_data (G_OBJECT (widget), "user_data"));
4299 if (GPOINTER_TO_INT (data) == 1)
4300 sprintf (buf, "%d", gtk_spin_button_get_value_as_int (spin));
4302 sprintf (buf, "%0.*f",
4303 gtk_spin_button_get_digits (spin),
4304 gtk_spin_button_get_value (spin));
4306 gtk_label_set_text (label, buf);
4310 get_spin_value (GtkWidget *widget, gpointer data)
4314 GtkSpinButton *spin;
4316 spin = GTK_SPIN_BUTTON (widget);
4317 label = GTK_LABEL (data);
4319 buffer = g_strdup_printf ("%0.*f",
4320 gtk_spin_button_get_digits (spin),
4321 gtk_spin_button_get_value (spin));
4322 gtk_label_set_text (label, buffer);
4328 spin_button_time_output_func (GtkSpinButton *spin_button)
4330 GtkAdjustment *adjustment;
4331 static gchar buf[6];
4335 adjustment = gtk_spin_button_get_adjustment (spin_button);
4336 hours = gtk_adjustment_get_value (adjustment) / 60.0;
4337 minutes = (fabs(floor (hours) - hours) < 1e-5) ? 0.0 : 30;
4338 sprintf (buf, "%02.0f:%02.0f", floor (hours), minutes);
4339 if (strcmp (buf, gtk_entry_get_text (GTK_ENTRY (spin_button))))
4340 gtk_entry_set_text (GTK_ENTRY (spin_button), buf);
4345 spin_button_month_input_func (GtkSpinButton *spin_button,
4349 static gchar *month[12] = { "January", "February", "March", "April",
4350 "May", "June", "July", "August",
4351 "September", "October", "November", "December" };
4353 gboolean found = FALSE;
4355 for (i = 1; i <= 12; i++)
4357 tmp1 = g_ascii_strup (month[i - 1], -1);
4358 tmp2 = g_ascii_strup (gtk_entry_get_text (GTK_ENTRY (spin_button)), -1);
4359 if (strstr (tmp1, tmp2) == tmp1)
4369 return GTK_INPUT_ERROR;
4371 *new_val = (gdouble) i;
4376 spin_button_month_output_func (GtkSpinButton *spin_button)
4378 GtkAdjustment *adjustment;
4381 static gchar *month[12] = { "January", "February", "March", "April",
4382 "May", "June", "July", "August", "September",
4383 "October", "November", "December" };
4385 adjustment = gtk_spin_button_get_adjustment (spin_button);
4386 value = gtk_adjustment_get_value (adjustment);
4387 for (i = 1; i <= 12; i++)
4388 if (fabs (value - (double)i) < 1e-5)
4390 if (strcmp (month[i-1], gtk_entry_get_text (GTK_ENTRY (spin_button))))
4391 gtk_entry_set_text (GTK_ENTRY (spin_button), month[i-1]);
4397 spin_button_hex_input_func (GtkSpinButton *spin_button,
4404 buf = gtk_entry_get_text (GTK_ENTRY (spin_button));
4405 res = strtol(buf, &err, 16);
4408 return GTK_INPUT_ERROR;
4414 spin_button_hex_output_func (GtkSpinButton *spin_button)
4416 GtkAdjustment *adjustment;
4417 static gchar buf[7];
4420 adjustment = gtk_spin_button_get_adjustment (spin_button);
4421 val = (gint) gtk_adjustment_get_value (adjustment);
4422 if (fabs (val) < 1e-5)
4423 sprintf (buf, "0x00");
4425 sprintf (buf, "0x%.2X", val);
4426 if (strcmp (buf, gtk_entry_get_text (GTK_ENTRY (spin_button))))
4427 gtk_entry_set_text (GTK_ENTRY (spin_button), buf);
4432 create_spins (GtkWidget *widget)
4434 static GtkWidget *window = NULL;
4437 GtkWidget *main_vbox;
4440 GtkWidget *spinner2;
4444 GtkWidget *val_label;
4445 GtkAdjustment *adjustment;
4449 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
4450 gtk_window_set_screen (GTK_WINDOW (window),
4451 gtk_widget_get_screen (widget));
4453 g_signal_connect (window, "destroy",
4454 G_CALLBACK (gtk_widget_destroyed),
4457 gtk_window_set_title (GTK_WINDOW (window), "GtkSpinButton");
4459 main_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
4460 gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 10);
4461 gtk_container_add (GTK_CONTAINER (window), main_vbox);
4463 frame = gtk_frame_new ("Not accelerated");
4464 gtk_box_pack_start (GTK_BOX (main_vbox), frame, TRUE, TRUE, 0);
4466 vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
4467 gtk_container_set_border_width (GTK_CONTAINER (vbox), 5);
4468 gtk_container_add (GTK_CONTAINER (frame), vbox);
4470 /* Time, month, hex spinners */
4472 hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
4473 gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 5);
4475 vbox2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
4476 gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 5);
4478 label = gtk_label_new ("Time :");
4479 gtk_widget_set_halign (label, GTK_ALIGN_START);
4480 gtk_widget_set_valign (label, GTK_ALIGN_CENTER);
4481 gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, TRUE, 0);
4483 adjustment = gtk_adjustment_new (0, 0, 1410, 30, 60, 0);
4484 spinner = gtk_spin_button_new (adjustment, 0, 0);
4485 gtk_editable_set_editable (GTK_EDITABLE (spinner), FALSE);
4486 g_signal_connect (spinner,
4488 G_CALLBACK (spin_button_time_output_func),
4490 gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spinner), TRUE);
4491 gtk_entry_set_width_chars (GTK_ENTRY (spinner), 5);
4492 gtk_box_pack_start (GTK_BOX (vbox2), spinner, FALSE, TRUE, 0);
4494 vbox2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
4495 gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 5);
4497 label = gtk_label_new ("Month :");
4498 gtk_widget_set_halign (label, GTK_ALIGN_START);
4499 gtk_widget_set_valign (label, GTK_ALIGN_CENTER);
4500 gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, TRUE, 0);
4502 adjustment = gtk_adjustment_new (1.0, 1.0, 12.0, 1.0,
4504 spinner = gtk_spin_button_new (adjustment, 0, 0);
4505 gtk_spin_button_set_update_policy (GTK_SPIN_BUTTON (spinner),
4506 GTK_UPDATE_IF_VALID);
4507 g_signal_connect (spinner,
4509 G_CALLBACK (spin_button_month_input_func),
4511 g_signal_connect (spinner,
4513 G_CALLBACK (spin_button_month_output_func),
4515 gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spinner), TRUE);
4516 gtk_entry_set_width_chars (GTK_ENTRY (spinner), 9);
4517 gtk_box_pack_start (GTK_BOX (vbox2), spinner, FALSE, TRUE, 0);
4519 vbox2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
4520 gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 5);
4522 label = gtk_label_new ("Hex :");
4523 gtk_widget_set_halign (label, GTK_ALIGN_START);
4524 gtk_widget_set_valign (label, GTK_ALIGN_CENTER);
4525 gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, TRUE, 0);
4527 adjustment = gtk_adjustment_new (0, 0, 255, 1, 16, 0);
4528 spinner = gtk_spin_button_new (adjustment, 0, 0);
4529 gtk_editable_set_editable (GTK_EDITABLE (spinner), TRUE);
4530 g_signal_connect (spinner,
4532 G_CALLBACK (spin_button_hex_input_func),
4534 g_signal_connect (spinner,
4536 G_CALLBACK (spin_button_hex_output_func),
4538 gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spinner), TRUE);
4539 gtk_entry_set_width_chars (GTK_ENTRY (spinner), 4);
4540 gtk_box_pack_start (GTK_BOX (vbox2), spinner, FALSE, TRUE, 0);
4542 frame = gtk_frame_new ("Accelerated");
4543 gtk_box_pack_start (GTK_BOX (main_vbox), frame, TRUE, TRUE, 0);
4545 vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
4546 gtk_container_set_border_width (GTK_CONTAINER (vbox), 5);
4547 gtk_container_add (GTK_CONTAINER (frame), vbox);
4549 hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
4550 gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 5);
4552 vbox2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
4553 gtk_box_pack_start (GTK_BOX (hbox), vbox2, FALSE, FALSE, 5);
4555 label = gtk_label_new ("Value :");
4556 gtk_widget_set_halign (label, GTK_ALIGN_START);
4557 gtk_widget_set_valign (label, GTK_ALIGN_CENTER);
4558 gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, TRUE, 0);
4560 adjustment = gtk_adjustment_new (0.0, -10000.0, 10000.0,
4562 spinner1 = gtk_spin_button_new (adjustment, 1.0, 2);
4563 gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spinner1), TRUE);
4564 gtk_box_pack_start (GTK_BOX (vbox2), spinner1, FALSE, TRUE, 0);
4566 vbox2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
4567 gtk_box_pack_start (GTK_BOX (hbox), vbox2, FALSE, FALSE, 5);
4569 label = gtk_label_new ("Digits :");
4570 gtk_widget_set_halign (label, GTK_ALIGN_START);
4571 gtk_widget_set_valign (label, GTK_ALIGN_CENTER);
4572 gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, TRUE, 0);
4574 adjustment = gtk_adjustment_new (2, 1, 15, 1, 1, 0);
4575 spinner2 = gtk_spin_button_new (adjustment, 0.0, 0);
4576 g_signal_connect (adjustment, "value_changed",
4577 G_CALLBACK (change_digits),
4579 gtk_box_pack_start (GTK_BOX (vbox2), spinner2, FALSE, TRUE, 0);
4581 hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
4582 gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 5);
4584 button = gtk_check_button_new_with_label ("Snap to 0.5-ticks");
4585 g_signal_connect (button, "clicked",
4586 G_CALLBACK (toggle_snap),
4588 gtk_box_pack_start (GTK_BOX (vbox), button, TRUE, TRUE, 0);
4589 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
4591 button = gtk_check_button_new_with_label ("Numeric only input mode");
4592 g_signal_connect (button, "clicked",
4593 G_CALLBACK (toggle_numeric),
4595 gtk_box_pack_start (GTK_BOX (vbox), button, TRUE, TRUE, 0);
4596 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
4598 val_label = gtk_label_new ("");
4600 hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
4601 gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 5);
4603 button = gtk_button_new_with_label ("Value as Int");
4604 g_object_set_data (G_OBJECT (button), "user_data", val_label);
4605 g_signal_connect (button, "clicked",
4606 G_CALLBACK (get_value),
4607 GINT_TO_POINTER (1));
4608 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
4610 button = gtk_button_new_with_label ("Value as Float");
4611 g_object_set_data (G_OBJECT (button), "user_data", val_label);
4612 g_signal_connect (button, "clicked",
4613 G_CALLBACK (get_value),
4614 GINT_TO_POINTER (2));
4615 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
4617 gtk_box_pack_start (GTK_BOX (vbox), val_label, TRUE, TRUE, 0);
4618 gtk_label_set_text (GTK_LABEL (val_label), "0");
4620 frame = gtk_frame_new ("Using Convenience Constructor");
4621 gtk_box_pack_start (GTK_BOX (main_vbox), frame, TRUE, TRUE, 0);
4623 hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
4624 gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
4625 gtk_container_add (GTK_CONTAINER (frame), hbox);
4627 val_label = gtk_label_new ("0.0");
4629 spinner = gtk_spin_button_new_with_range (0.0, 10.0, 0.009);
4630 gtk_spin_button_set_value (GTK_SPIN_BUTTON (spinner), 0.0);
4631 g_signal_connect (spinner, "value_changed",
4632 G_CALLBACK (get_spin_value), val_label);
4633 gtk_box_pack_start (GTK_BOX (hbox), spinner, TRUE, TRUE, 5);
4634 gtk_box_pack_start (GTK_BOX (hbox), val_label, TRUE, TRUE, 5);
4636 hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
4637 gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, TRUE, 0);
4639 button = gtk_button_new_with_label ("Close");
4640 g_signal_connect_swapped (button, "clicked",
4641 G_CALLBACK (gtk_widget_destroy),
4643 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
4646 if (!gtk_widget_get_visible (window))
4647 gtk_widget_show_all (window);
4649 gtk_widget_destroy (window);
4658 cursor_draw (GtkWidget *widget,
4663 GtkStyleContext *context;
4666 width = gtk_widget_get_allocated_width (widget);
4667 height = gtk_widget_get_allocated_height (widget);
4669 cairo_set_source_rgb (cr, 1, 1, 1);
4670 cairo_rectangle (cr, 0, 0, width, height / 2);
4673 cairo_set_source_rgb (cr, 0, 0, 0);
4674 cairo_rectangle (cr, 0, height / 2, width, height / 2);
4677 context = gtk_widget_get_style_context (widget);
4678 gtk_style_context_get_background_color (context, GTK_STATE_FLAG_NORMAL, &bg);
4679 gdk_cairo_set_source_rgba (cr, &bg);
4680 cairo_rectangle (cr, width / 3, height / 3, width / 3, height / 3);
4687 set_cursor (GtkWidget *spinner,
4696 c = CLAMP (gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (spinner)), 0, 152);
4699 label = g_object_get_data (G_OBJECT (spinner), "user_data");
4701 class = g_type_class_ref (GDK_TYPE_CURSOR_TYPE);
4702 vals = class->values;
4704 while (vals && vals->value != c)
4707 gtk_label_set_text (GTK_LABEL (label), vals->value_nick);
4709 gtk_label_set_text (GTK_LABEL (label), "<unknown>");
4711 g_type_class_unref (class);
4713 cursor = gdk_cursor_new_for_display (gtk_widget_get_display (widget), c);
4714 gdk_window_set_cursor (gtk_widget_get_window (widget),
4716 g_object_unref (cursor);
4720 cursor_event (GtkWidget *widget,
4722 GtkSpinButton *spinner)
4724 if ((event->type == GDK_BUTTON_PRESS) &&
4725 ((event->button.button == GDK_BUTTON_PRIMARY) ||
4726 (event->button.button == GDK_BUTTON_SECONDARY)))
4728 gtk_spin_button_spin (spinner, event->button.button == GDK_BUTTON_PRIMARY ?
4729 GTK_SPIN_STEP_FORWARD : GTK_SPIN_STEP_BACKWARD, 0);
4736 #ifdef GDK_WINDOWING_X11
4737 #include "x11/gdkx.h"
4740 change_cursor_theme (GtkWidget *widget,
4747 children = gtk_container_get_children (GTK_CONTAINER (data));
4749 theme = gtk_entry_get_text (GTK_ENTRY (children->next->data));
4750 size = (gint) gtk_spin_button_get_value (GTK_SPIN_BUTTON (children->next->next->data));
4752 g_list_free (children);
4754 gdk_x11_display_set_cursor_theme (gtk_widget_get_display (widget),
4761 create_cursors (GtkWidget *widget)
4763 static GtkWidget *window = NULL;
4766 GtkWidget *main_vbox;
4773 GtkAdjustment *adjustment;
4779 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
4780 gtk_window_set_screen (GTK_WINDOW (window),
4781 gtk_widget_get_screen (widget));
4783 g_signal_connect (window, "destroy",
4784 G_CALLBACK (gtk_widget_destroyed),
4787 gtk_window_set_title (GTK_WINDOW (window), "Cursors");
4789 main_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
4790 gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 0);
4791 gtk_container_add (GTK_CONTAINER (window), main_vbox);
4794 g_object_new (GTK_TYPE_BOX,
4795 "orientation", GTK_ORIENTATION_VERTICAL,
4796 "GtkBox::homogeneous", FALSE,
4797 "GtkBox::spacing", 5,
4798 "GtkContainer::border_width", 10,
4799 "GtkWidget::parent", main_vbox,
4800 "GtkWidget::visible", TRUE,
4803 #ifdef GDK_WINDOWING_X11
4804 hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
4805 gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
4806 gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0);
4808 label = gtk_label_new ("Cursor Theme : ");
4809 gtk_widget_set_halign (label, GTK_ALIGN_START);
4810 gtk_widget_set_valign (label, GTK_ALIGN_CENTER);
4811 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
4813 entry = gtk_entry_new ();
4814 gtk_entry_set_text (GTK_ENTRY (entry), "default");
4815 gtk_box_pack_start (GTK_BOX (hbox), entry, FALSE, TRUE, 0);
4817 size = gtk_spin_button_new_with_range (1.0, 64.0, 1.0);
4818 gtk_spin_button_set_value (GTK_SPIN_BUTTON (size), 24.0);
4819 gtk_box_pack_start (GTK_BOX (hbox), size, TRUE, TRUE, 0);
4821 g_signal_connect (entry, "changed",
4822 G_CALLBACK (change_cursor_theme), hbox);
4823 g_signal_connect (size, "changed",
4824 G_CALLBACK (change_cursor_theme), hbox);
4827 hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
4828 gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
4829 gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0);
4831 label = gtk_label_new ("Cursor Value : ");
4832 gtk_widget_set_halign (label, GTK_ALIGN_START);
4833 gtk_widget_set_valign (label, GTK_ALIGN_CENTER);
4834 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
4836 adjustment = gtk_adjustment_new (0,
4840 spinner = gtk_spin_button_new (adjustment, 0, 0);
4841 gtk_box_pack_start (GTK_BOX (hbox), spinner, TRUE, TRUE, 0);
4844 g_object_new (gtk_frame_get_type (),
4845 "GtkFrame::label_xalign", 0.5,
4846 "GtkFrame::label", "Cursor Area",
4847 "GtkContainer::border_width", 10,
4848 "GtkWidget::parent", vbox,
4849 "GtkWidget::visible", TRUE,
4852 darea = gtk_drawing_area_new ();
4853 gtk_widget_set_size_request (darea, 80, 80);
4854 gtk_container_add (GTK_CONTAINER (frame), darea);
4855 g_signal_connect (darea,
4857 G_CALLBACK (cursor_draw),
4859 gtk_widget_set_events (darea, GDK_EXPOSURE_MASK | GDK_BUTTON_PRESS_MASK);
4860 g_signal_connect (darea,
4861 "button_press_event",
4862 G_CALLBACK (cursor_event),
4864 gtk_widget_show (darea);
4866 g_signal_connect (spinner, "changed",
4867 G_CALLBACK (set_cursor),
4870 label = g_object_new (GTK_TYPE_LABEL,
4875 gtk_container_child_set (GTK_CONTAINER (vbox), label,
4878 g_object_set_data (G_OBJECT (spinner), "user_data", label);
4880 any = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
4881 gtk_box_pack_start (GTK_BOX (main_vbox), any, FALSE, TRUE, 0);
4883 hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
4884 gtk_container_set_border_width (GTK_CONTAINER (hbox), 10);
4885 gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, TRUE, 0);
4887 button = gtk_button_new_with_label ("Close");
4888 g_signal_connect_swapped (button, "clicked",
4889 G_CALLBACK (gtk_widget_destroy),
4891 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
4893 gtk_widget_show_all (window);
4895 set_cursor (spinner, darea);
4898 gtk_widget_destroy (window);
4906 create_color_selection (GtkWidget *widget)
4908 static GtkWidget *window = NULL;
4917 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
4918 gtk_window_set_screen (GTK_WINDOW (window),
4919 gtk_widget_get_screen (widget));
4921 g_signal_connect (window, "destroy",
4922 G_CALLBACK (gtk_widget_destroyed),
4925 gtk_window_set_title (GTK_WINDOW (window), "GtkColorButton");
4926 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
4928 hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 8);
4929 gtk_container_set_border_width (GTK_CONTAINER (hbox), 8);
4930 gtk_container_add (GTK_CONTAINER (window), hbox);
4932 label = gtk_label_new ("Pick a color");
4933 gtk_container_add (GTK_CONTAINER (hbox), label);
4935 picker = gtk_color_button_new ();
4936 gtk_color_chooser_set_use_alpha (GTK_COLOR_CHOOSER (picker), TRUE);
4937 gtk_container_add (GTK_CONTAINER (hbox), picker);
4939 button = gtk_button_new_with_mnemonic ("_Props");
4940 gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0);
4941 g_signal_connect (button, "clicked",
4942 G_CALLBACK (props_clicked),
4946 if (!gtk_widget_get_visible (window))
4947 gtk_widget_show_all (window);
4949 gtk_widget_destroy (window);
4953 flipping_toggled_cb (GtkWidget *widget, gpointer data)
4955 int state = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget));
4956 int new_direction = state ? GTK_TEXT_DIR_RTL : GTK_TEXT_DIR_LTR;
4958 gtk_widget_set_default_direction (new_direction);
4962 orientable_toggle_orientation (GtkOrientable *orientable)
4964 GtkOrientation orientation;
4966 orientation = gtk_orientable_get_orientation (orientable);
4967 gtk_orientable_set_orientation (orientable,
4968 orientation == GTK_ORIENTATION_HORIZONTAL ?
4969 GTK_ORIENTATION_VERTICAL :
4970 GTK_ORIENTATION_HORIZONTAL);
4972 if (GTK_IS_CONTAINER (orientable))
4977 children = gtk_container_get_children (GTK_CONTAINER (orientable));
4979 for (child = children; child; child = child->next)
4981 if (GTK_IS_ORIENTABLE (child->data))
4982 orientable_toggle_orientation (child->data);
4985 g_list_free (children);
4990 flipping_orientation_toggled_cb (GtkWidget *widget, gpointer data)
4992 GtkWidget *content_area;
4993 GtkWidget *toplevel;
4995 toplevel = gtk_widget_get_toplevel (widget);
4996 content_area = gtk_dialog_get_content_area (GTK_DIALOG (toplevel));
4997 orientable_toggle_orientation (GTK_ORIENTABLE (content_area));
5001 set_direction_recurse (GtkWidget *widget,
5004 GtkTextDirection *dir = data;
5006 gtk_widget_set_direction (widget, *dir);
5007 if (GTK_IS_CONTAINER (widget))
5008 gtk_container_foreach (GTK_CONTAINER (widget),
5009 set_direction_recurse,
5014 create_forward_back (const char *title,
5015 GtkTextDirection text_dir)
5017 GtkWidget *frame = gtk_frame_new (title);
5018 GtkWidget *bbox = gtk_button_box_new (GTK_ORIENTATION_HORIZONTAL);
5019 GtkWidget *back_button = gtk_button_new_from_stock (GTK_STOCK_GO_BACK);
5020 GtkWidget *forward_button = gtk_button_new_from_stock (GTK_STOCK_GO_FORWARD);
5022 gtk_container_set_border_width (GTK_CONTAINER (bbox), 5);
5024 gtk_container_add (GTK_CONTAINER (frame), bbox);
5025 gtk_container_add (GTK_CONTAINER (bbox), back_button);
5026 gtk_container_add (GTK_CONTAINER (bbox), forward_button);
5028 set_direction_recurse (frame, &text_dir);
5034 create_flipping (GtkWidget *widget)
5036 static GtkWidget *window = NULL;
5037 GtkWidget *check_button, *button;
5038 GtkWidget *action_area, *content_area;
5042 window = gtk_dialog_new ();
5044 gtk_window_set_screen (GTK_WINDOW (window),
5045 gtk_widget_get_screen (widget));
5047 g_signal_connect (window, "destroy",
5048 G_CALLBACK (gtk_widget_destroyed),
5051 content_area = gtk_dialog_get_content_area (GTK_DIALOG (window));
5052 action_area = gtk_dialog_get_action_area (GTK_DIALOG (window));
5054 gtk_window_set_title (GTK_WINDOW (window), "Bidirectional Flipping");
5056 check_button = gtk_check_button_new_with_label ("Right-to-left global direction");
5057 gtk_container_set_border_width (GTK_CONTAINER (check_button), 10);
5058 gtk_box_pack_start (GTK_BOX (content_area), check_button, TRUE, TRUE, 0);
5060 if (gtk_widget_get_default_direction () == GTK_TEXT_DIR_RTL)
5061 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check_button), TRUE);
5063 g_signal_connect (check_button, "toggled",
5064 G_CALLBACK (flipping_toggled_cb), NULL);
5066 check_button = gtk_check_button_new_with_label ("Toggle orientation of all boxes");
5067 gtk_container_set_border_width (GTK_CONTAINER (check_button), 10);
5068 gtk_box_pack_start (GTK_BOX (content_area), check_button, TRUE, TRUE, 0);
5070 g_signal_connect (check_button, "toggled",
5071 G_CALLBACK (flipping_orientation_toggled_cb), NULL);
5073 gtk_box_pack_start (GTK_BOX (content_area),
5074 create_forward_back ("Default", GTK_TEXT_DIR_NONE),
5077 gtk_box_pack_start (GTK_BOX (content_area),
5078 create_forward_back ("Left-to-Right", GTK_TEXT_DIR_LTR),
5081 gtk_box_pack_start (GTK_BOX (content_area),
5082 create_forward_back ("Right-to-Left", GTK_TEXT_DIR_RTL),
5085 button = gtk_button_new_with_label ("Close");
5086 g_signal_connect_swapped (button, "clicked",
5087 G_CALLBACK (gtk_widget_destroy), window);
5088 gtk_box_pack_start (GTK_BOX (action_area), button, TRUE, TRUE, 0);
5091 if (!gtk_widget_get_visible (window))
5092 gtk_widget_show_all (window);
5094 gtk_widget_destroy (window);
5102 make_focus_table (GList **list)
5107 grid = gtk_grid_new ();
5109 gtk_grid_set_row_spacing (GTK_GRID (grid), 10);
5110 gtk_grid_set_column_spacing (GTK_GRID (grid), 10);
5112 for (i = 0; i < 5; i++)
5114 for (j = 0; j < 5; j++)
5119 widget = gtk_entry_new ();
5121 widget = gtk_button_new_with_label ("Foo");
5123 *list = g_list_prepend (*list, widget);
5125 gtk_widget_set_hexpand (widget, TRUE);
5126 gtk_widget_set_vexpand (widget, TRUE);
5128 gtk_grid_attach (GTK_GRID (grid), widget, i, j, 1, 1);
5132 *list = g_list_reverse (*list);
5138 create_focus (GtkWidget *widget)
5140 static GtkWidget *window = NULL;
5144 GtkWidget *content_area;
5149 window = gtk_dialog_new_with_buttons ("Keyboard focus navigation",
5155 gtk_window_set_screen (GTK_WINDOW (window),
5156 gtk_widget_get_screen (widget));
5158 g_signal_connect (window, "destroy",
5159 G_CALLBACK (gtk_widget_destroyed),
5162 g_signal_connect (window, "response",
5163 G_CALLBACK (gtk_widget_destroy),
5166 content_area = gtk_dialog_get_content_area (GTK_DIALOG (window));
5168 gtk_window_set_title (GTK_WINDOW (window), "Keyboard Focus Navigation");
5170 frame = gtk_frame_new ("Weird tab focus chain");
5172 gtk_box_pack_start (GTK_BOX (content_area), frame, TRUE, TRUE, 0);
5174 table = make_focus_table (&list);
5176 gtk_container_add (GTK_CONTAINER (frame), table);
5178 gtk_container_set_focus_chain (GTK_CONTAINER (table),
5183 frame = gtk_frame_new ("Default tab focus chain");
5185 gtk_box_pack_start (GTK_BOX (content_area), frame, TRUE, TRUE, 0);
5188 table = make_focus_table (&list);
5192 gtk_container_add (GTK_CONTAINER (frame), table);
5195 if (!gtk_widget_get_visible (window))
5196 gtk_widget_show_all (window);
5198 gtk_widget_destroy (window);
5206 create_font_selection (GtkWidget *widget)
5208 static GtkWidget *window = NULL;
5216 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
5217 gtk_window_set_screen (GTK_WINDOW (window),
5218 gtk_widget_get_screen (widget));
5220 g_signal_connect (window, "destroy",
5221 G_CALLBACK (gtk_widget_destroyed),
5224 gtk_window_set_title (GTK_WINDOW (window), "GtkFontButton");
5225 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
5227 hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 8);
5228 gtk_container_set_border_width (GTK_CONTAINER (hbox), 8);
5229 gtk_container_add (GTK_CONTAINER (window), hbox);
5231 label = gtk_label_new ("Pick a font");
5232 gtk_container_add (GTK_CONTAINER (hbox), label);
5234 picker = gtk_font_button_new ();
5235 gtk_font_button_set_use_font (GTK_FONT_BUTTON (picker), TRUE);
5236 gtk_container_add (GTK_CONTAINER (hbox), picker);
5239 if (!gtk_widget_get_visible (window))
5240 gtk_widget_show_all (window);
5242 gtk_widget_destroy (window);
5249 static GtkWidget *dialog_window = NULL;
5252 label_toggle (GtkWidget *widget,
5257 *label = gtk_label_new ("Dialog Test");
5258 g_signal_connect (*label,
5260 G_CALLBACK (gtk_widget_destroyed),
5262 g_object_set (*label, "margin", 10, NULL);
5263 gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog_window))),
5264 *label, TRUE, TRUE, 0);
5265 gtk_widget_show (*label);
5268 gtk_widget_destroy (*label);
5272 create_dialog (GtkWidget *widget)
5274 static GtkWidget *label;
5275 GtkWidget *action_area;
5280 /* This is a terrible example; it's much simpler to create
5281 * dialogs than this. Don't use testgtk for example code,
5285 dialog_window = gtk_dialog_new ();
5286 gtk_window_set_screen (GTK_WINDOW (dialog_window),
5287 gtk_widget_get_screen (widget));
5289 g_signal_connect (dialog_window, "destroy",
5290 G_CALLBACK (gtk_widget_destroyed),
5293 action_area = gtk_dialog_get_action_area (GTK_DIALOG (dialog_window));
5295 gtk_window_set_title (GTK_WINDOW (dialog_window), "GtkDialog");
5296 gtk_container_set_border_width (GTK_CONTAINER (dialog_window), 0);
5298 button = gtk_button_new_with_label ("OK");
5299 gtk_widget_set_can_default (button, TRUE);
5300 gtk_box_pack_start (GTK_BOX (action_area), button, TRUE, TRUE, 0);
5301 gtk_widget_grab_default (button);
5302 gtk_widget_show (button);
5304 button = gtk_button_new_with_label ("Toggle");
5305 g_signal_connect (button, "clicked",
5306 G_CALLBACK (label_toggle),
5308 gtk_widget_set_can_default (button, TRUE);
5309 gtk_box_pack_start (GTK_BOX (action_area), button, TRUE, TRUE, 0);
5310 gtk_widget_show (button);
5315 if (!gtk_widget_get_visible (dialog_window))
5316 gtk_widget_show (dialog_window);
5318 gtk_widget_destroy (dialog_window);
5321 /* Display & Screen test
5328 GtkWidget *radio_dpy;
5329 GtkWidget *toplevel;
5330 GtkWidget *dialog_window;
5331 } ScreenDisplaySelection;
5334 screen_display_check (GtkWidget *widget, ScreenDisplaySelection *data)
5336 const gchar *display_name;
5337 GdkDisplay *display = gtk_widget_get_display (widget);
5339 GdkScreen *new_screen = NULL;
5340 GdkScreen *current_screen = gtk_widget_get_screen (widget);
5342 if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (data->radio_dpy)))
5344 display_name = gtk_entry_get_text (GTK_ENTRY (data->entry));
5345 display = gdk_display_open (display_name);
5349 dialog = gtk_message_dialog_new (GTK_WINDOW (gtk_widget_get_toplevel (widget)),
5350 GTK_DIALOG_DESTROY_WITH_PARENT,
5353 "The display :\n%s\ncannot be opened",
5355 gtk_window_set_screen (GTK_WINDOW (dialog), current_screen);
5356 gtk_widget_show (dialog);
5357 g_signal_connect (dialog, "response",
5358 G_CALLBACK (gtk_widget_destroy),
5363 GtkTreeModel *model = gtk_combo_box_get_model (GTK_COMBO_BOX (data->combo));
5366 gboolean found = FALSE;
5367 while (gtk_tree_model_iter_nth_child (model, &iter, NULL, i++))
5370 gtk_tree_model_get (model, &iter, 0, &name, -1);
5371 found = !g_ascii_strcasecmp (display_name, name);
5378 gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (data->combo), display_name);
5379 new_screen = gdk_display_get_default_screen (display);
5384 gint number_of_screens = gdk_display_get_n_screens (display);
5385 gint screen_num = gdk_screen_get_number (current_screen);
5386 if ((screen_num +1) < number_of_screens)
5387 new_screen = gdk_display_get_screen (display, screen_num + 1);
5389 new_screen = gdk_display_get_screen (display, 0);
5394 gtk_window_set_screen (GTK_WINDOW (data->toplevel), new_screen);
5395 gtk_widget_destroy (data->dialog_window);
5400 screen_display_destroy_diag (GtkWidget *widget, GtkWidget *data)
5402 gtk_widget_destroy (data);
5406 create_display_screen (GtkWidget *widget)
5408 GtkWidget *grid, *frame, *window, *combo_dpy, *vbox;
5409 GtkWidget *radio_dpy, *radio_scr, *applyb, *cancelb;
5411 ScreenDisplaySelection *scr_dpy_data;
5412 GdkScreen *screen = gtk_widget_get_screen (widget);
5413 GdkDisplay *display = gdk_screen_get_display (screen);
5415 window = g_object_new (gtk_window_get_type (),
5417 "type", GTK_WINDOW_TOPLEVEL,
5418 "title", "Screen or Display selection",
5421 g_signal_connect (window, "destroy",
5422 G_CALLBACK (gtk_widget_destroy), NULL);
5424 vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 3);
5425 gtk_container_add (GTK_CONTAINER (window), vbox);
5427 frame = gtk_frame_new ("Select screen or display");
5428 gtk_container_add (GTK_CONTAINER (vbox), frame);
5430 grid = gtk_grid_new ();
5431 gtk_grid_set_row_spacing (GTK_GRID (grid), 3);
5432 gtk_grid_set_column_spacing (GTK_GRID (grid), 3);
5434 gtk_container_add (GTK_CONTAINER (frame), grid);
5436 radio_dpy = gtk_radio_button_new_with_label (NULL, "move to another X display");
5437 if (gdk_display_get_n_screens(display) > 1)
5438 radio_scr = gtk_radio_button_new_with_label
5439 (gtk_radio_button_get_group (GTK_RADIO_BUTTON (radio_dpy)), "move to next screen");
5442 radio_scr = gtk_radio_button_new_with_label
5443 (gtk_radio_button_get_group (GTK_RADIO_BUTTON (radio_dpy)),
5444 "only one screen on the current display");
5445 gtk_widget_set_sensitive (radio_scr, FALSE);
5447 combo_dpy = gtk_combo_box_text_new_with_entry ();
5448 gtk_widget_set_hexpand (combo_dpy, TRUE);
5449 gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo_dpy), "diabolo:0.0");
5450 gtk_entry_set_text (GTK_ENTRY (gtk_bin_get_child (GTK_BIN (combo_dpy))),
5451 "<hostname>:<X Server Num>.<Screen Num>");
5453 gtk_grid_attach (GTK_GRID (grid), radio_dpy, 0, 0, 1, 1);
5454 gtk_grid_attach (GTK_GRID (grid), radio_scr, 0, 1, 1, 1);
5455 gtk_grid_attach (GTK_GRID (grid), combo_dpy, 1, 0, 1, 1);
5457 bbox = gtk_button_box_new (GTK_ORIENTATION_HORIZONTAL);
5458 applyb = gtk_button_new_from_stock (GTK_STOCK_APPLY);
5459 cancelb = gtk_button_new_from_stock (GTK_STOCK_CANCEL);
5461 gtk_container_add (GTK_CONTAINER (vbox), bbox);
5463 gtk_container_add (GTK_CONTAINER (bbox), applyb);
5464 gtk_container_add (GTK_CONTAINER (bbox), cancelb);
5466 scr_dpy_data = g_new0 (ScreenDisplaySelection, 1);
5468 scr_dpy_data->entry = gtk_bin_get_child (GTK_BIN (combo_dpy));
5469 scr_dpy_data->radio_dpy = radio_dpy;
5470 scr_dpy_data->toplevel = gtk_widget_get_toplevel (widget);
5471 scr_dpy_data->dialog_window = window;
5473 g_signal_connect (cancelb, "clicked",
5474 G_CALLBACK (screen_display_destroy_diag), window);
5475 g_signal_connect (applyb, "clicked",
5476 G_CALLBACK (screen_display_check), scr_dpy_data);
5477 gtk_widget_show_all (window);
5482 static gulong event_watcher_enter_id = 0;
5483 static gulong event_watcher_leave_id = 0;
5486 event_watcher (GSignalInvocationHint *ihint,
5487 guint n_param_values,
5488 const GValue *param_values,
5491 g_print ("Watch: \"%s\" emitted for %s\n",
5492 g_signal_name (ihint->signal_id),
5493 G_OBJECT_TYPE_NAME (g_value_get_object (param_values + 0)));
5499 event_watcher_down (void)
5501 if (event_watcher_enter_id)
5505 signal_id = g_signal_lookup ("enter_notify_event", GTK_TYPE_WIDGET);
5506 g_signal_remove_emission_hook (signal_id, event_watcher_enter_id);
5507 event_watcher_enter_id = 0;
5508 signal_id = g_signal_lookup ("leave_notify_event", GTK_TYPE_WIDGET);
5509 g_signal_remove_emission_hook (signal_id, event_watcher_leave_id);
5510 event_watcher_leave_id = 0;
5515 event_watcher_toggle (void)
5517 if (event_watcher_enter_id)
5518 event_watcher_down ();
5523 signal_id = g_signal_lookup ("enter_notify_event", GTK_TYPE_WIDGET);
5524 event_watcher_enter_id = g_signal_add_emission_hook (signal_id, 0, event_watcher, NULL, NULL);
5525 signal_id = g_signal_lookup ("leave_notify_event", GTK_TYPE_WIDGET);
5526 event_watcher_leave_id = g_signal_add_emission_hook (signal_id, 0, event_watcher, NULL, NULL);
5531 create_event_watcher (GtkWidget *widget)
5533 GtkWidget *action_area, *content_area;
5538 dialog_window = gtk_dialog_new ();
5539 gtk_window_set_screen (GTK_WINDOW (dialog_window),
5540 gtk_widget_get_screen (widget));
5542 g_signal_connect (dialog_window, "destroy",
5543 G_CALLBACK (gtk_widget_destroyed),
5545 g_signal_connect (dialog_window, "destroy",
5546 G_CALLBACK (event_watcher_down),
5549 content_area = gtk_dialog_get_content_area (GTK_DIALOG (dialog_window));
5550 action_area = gtk_dialog_get_action_area (GTK_DIALOG (dialog_window));
5552 gtk_window_set_title (GTK_WINDOW (dialog_window), "Event Watcher");
5553 gtk_container_set_border_width (GTK_CONTAINER (dialog_window), 0);
5554 gtk_widget_set_size_request (dialog_window, 200, 110);
5556 button = gtk_toggle_button_new_with_label ("Activate Watch");
5557 g_signal_connect (button, "clicked",
5558 G_CALLBACK (event_watcher_toggle),
5560 gtk_container_set_border_width (GTK_CONTAINER (button), 10);
5561 gtk_box_pack_start (GTK_BOX (content_area), button, TRUE, TRUE, 0);
5562 gtk_widget_show (button);
5564 button = gtk_button_new_with_label ("Close");
5565 g_signal_connect_swapped (button, "clicked",
5566 G_CALLBACK (gtk_widget_destroy),
5568 gtk_widget_set_can_default (button, TRUE);
5569 gtk_box_pack_start (GTK_BOX (action_area), button, TRUE, TRUE, 0);
5570 gtk_widget_grab_default (button);
5571 gtk_widget_show (button);
5574 if (!gtk_widget_get_visible (dialog_window))
5575 gtk_widget_show (dialog_window);
5577 gtk_widget_destroy (dialog_window);
5585 reformat_value (GtkScale *scale,
5588 return g_strdup_printf ("-->%0.*g<--",
5589 gtk_scale_get_digits (scale), value);
5593 create_range_controls (GtkWidget *widget)
5595 static GtkWidget *window = NULL;
5599 GtkWidget *scrollbar;
5601 GtkWidget *separator;
5602 GtkAdjustment *adjustment;
5607 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
5609 gtk_window_set_screen (GTK_WINDOW (window),
5610 gtk_widget_get_screen (widget));
5612 g_signal_connect (window, "destroy",
5613 G_CALLBACK (gtk_widget_destroyed),
5616 gtk_window_set_title (GTK_WINDOW (window), "range controls");
5617 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
5620 box1 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
5621 gtk_container_add (GTK_CONTAINER (window), box1);
5622 gtk_widget_show (box1);
5625 box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10);
5626 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
5627 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
5628 gtk_widget_show (box2);
5631 adjustment = gtk_adjustment_new (0.0, 0.0, 101.0, 0.1, 1.0, 1.0);
5633 scale = gtk_scale_new (GTK_ORIENTATION_HORIZONTAL, GTK_ADJUSTMENT (adjustment));
5634 gtk_widget_set_size_request (GTK_WIDGET (scale), 150, -1);
5635 gtk_scale_set_digits (GTK_SCALE (scale), 1);
5636 gtk_scale_set_draw_value (GTK_SCALE (scale), TRUE);
5637 gtk_box_pack_start (GTK_BOX (box2), scale, TRUE, TRUE, 0);
5638 gtk_widget_show (scale);
5640 scrollbar = gtk_scrollbar_new (GTK_ORIENTATION_HORIZONTAL, GTK_ADJUSTMENT (adjustment));
5641 gtk_box_pack_start (GTK_BOX (box2), scrollbar, TRUE, TRUE, 0);
5642 gtk_widget_show (scrollbar);
5644 scale = gtk_scale_new (GTK_ORIENTATION_HORIZONTAL, GTK_ADJUSTMENT (adjustment));
5645 gtk_scale_set_draw_value (GTK_SCALE (scale), TRUE);
5646 g_signal_connect (scale,
5648 G_CALLBACK (reformat_value),
5650 gtk_box_pack_start (GTK_BOX (box2), scale, TRUE, TRUE, 0);
5651 gtk_widget_show (scale);
5653 hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
5655 scale = gtk_scale_new (GTK_ORIENTATION_VERTICAL, GTK_ADJUSTMENT (adjustment));
5656 gtk_widget_set_size_request (scale, -1, 200);
5657 gtk_scale_set_digits (GTK_SCALE (scale), 2);
5658 gtk_scale_set_draw_value (GTK_SCALE (scale), TRUE);
5659 gtk_box_pack_start (GTK_BOX (hbox), scale, TRUE, TRUE, 0);
5660 gtk_widget_show (scale);
5662 scale = gtk_scale_new (GTK_ORIENTATION_VERTICAL, GTK_ADJUSTMENT (adjustment));
5663 gtk_widget_set_size_request (scale, -1, 200);
5664 gtk_scale_set_digits (GTK_SCALE (scale), 2);
5665 gtk_scale_set_draw_value (GTK_SCALE (scale), TRUE);
5666 gtk_range_set_inverted (GTK_RANGE (scale), TRUE);
5667 gtk_box_pack_start (GTK_BOX (hbox), scale, TRUE, TRUE, 0);
5668 gtk_widget_show (scale);
5670 scale = gtk_scale_new (GTK_ORIENTATION_VERTICAL, GTK_ADJUSTMENT (adjustment));
5671 gtk_scale_set_draw_value (GTK_SCALE (scale), TRUE);
5672 g_signal_connect (scale,
5674 G_CALLBACK (reformat_value),
5676 gtk_box_pack_start (GTK_BOX (hbox), scale, TRUE, TRUE, 0);
5677 gtk_widget_show (scale);
5680 gtk_box_pack_start (GTK_BOX (box2), hbox, TRUE, TRUE, 0);
5681 gtk_widget_show (hbox);
5683 separator = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
5684 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
5685 gtk_widget_show (separator);
5688 box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10);
5689 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
5690 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
5691 gtk_widget_show (box2);
5694 button = gtk_button_new_with_label ("close");
5695 g_signal_connect_swapped (button, "clicked",
5696 G_CALLBACK (gtk_widget_destroy),
5698 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
5699 gtk_widget_set_can_default (button, TRUE);
5700 gtk_widget_grab_default (button);
5701 gtk_widget_show (button);
5704 if (!gtk_widget_get_visible (window))
5705 gtk_widget_show (window);
5707 gtk_widget_destroy (window);
5714 { { 0, 0x0000, 0x0000, 0x0000 }, "black" },
5715 { { 0, 0xFFFF, 0xFFFF, 0xFFFF }, "white" },
5716 { { 0, 0xFFFF, 0x0000, 0x0000 }, "red" },
5717 { { 0, 0x0000, 0xFFFF, 0x0000 }, "green" },
5718 { { 0, 0x0000, 0x0000, 0xFFFF }, "blue" },
5719 { { 0, 0x0000, 0xFFFF, 0xFFFF }, "cyan" },
5720 { { 0, 0xFFFF, 0x0000, 0xFFFF }, "magenta" },
5721 { { 0, 0xFFFF, 0xFFFF, 0x0000 }, "yellow" }
5724 int ntext_colors = sizeof(text_colors) / sizeof(text_colors[0]);
5730 static const char * book_open_xpm[] = {
5753 static const char * book_closed_xpm[] = {
5778 GdkPixbuf *book_open;
5779 GdkPixbuf *book_closed;
5780 GtkWidget *sample_notebook;
5783 set_page_image (GtkNotebook *notebook, gint page_num, GdkPixbuf *pixbuf)
5785 GtkWidget *page_widget;
5788 page_widget = gtk_notebook_get_nth_page (notebook, page_num);
5790 pixwid = g_object_get_data (G_OBJECT (page_widget), "tab_pixmap");
5791 gtk_image_set_from_pixbuf (GTK_IMAGE (pixwid), pixbuf);
5793 pixwid = g_object_get_data (G_OBJECT (page_widget), "menu_pixmap");
5794 gtk_image_set_from_pixbuf (GTK_IMAGE (pixwid), pixbuf);
5798 page_switch (GtkWidget *widget, gpointer *page, gint page_num)
5800 GtkNotebook *notebook = GTK_NOTEBOOK (widget);
5801 gint old_page_num = gtk_notebook_get_current_page (notebook);
5803 if (page_num == old_page_num)
5806 set_page_image (notebook, page_num, book_open);
5808 if (old_page_num != -1)
5809 set_page_image (notebook, old_page_num, book_closed);
5813 tab_fill (GtkToggleButton *button, GtkWidget *child)
5815 gtk_container_child_set (GTK_CONTAINER (sample_notebook), child,
5816 "tab-fill", gtk_toggle_button_get_active (button),
5821 tab_expand (GtkToggleButton *button, GtkWidget *child)
5823 gtk_container_child_set (GTK_CONTAINER (sample_notebook), child,
5824 "tab-expand", gtk_toggle_button_get_active (button),
5829 create_pages (GtkNotebook *notebook, gint start, gint end)
5831 GtkWidget *child = NULL;
5836 GtkWidget *label_box;
5837 GtkWidget *menu_box;
5841 char accel_buffer[32];
5843 for (i = start; i <= end; i++)
5845 sprintf (buffer, "Page %d", i);
5846 sprintf (accel_buffer, "Page _%d", i);
5848 child = gtk_frame_new (buffer);
5849 gtk_container_set_border_width (GTK_CONTAINER (child), 10);
5851 vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
5852 gtk_box_set_homogeneous (GTK_BOX (vbox), TRUE);
5853 gtk_container_set_border_width (GTK_CONTAINER (vbox), 10);
5854 gtk_container_add (GTK_CONTAINER (child), vbox);
5856 hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
5857 gtk_box_set_homogeneous (GTK_BOX (hbox), TRUE);
5858 gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 5);
5860 button = gtk_check_button_new_with_label ("Fill Tab");
5861 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
5862 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
5863 g_signal_connect (button, "toggled",
5864 G_CALLBACK (tab_fill), child);
5866 button = gtk_check_button_new_with_label ("Expand Tab");
5867 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
5868 g_signal_connect (button, "toggled",
5869 G_CALLBACK (tab_expand), child);
5871 button = gtk_button_new_with_label ("Hide Page");
5872 gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 5);
5873 g_signal_connect_swapped (button, "clicked",
5874 G_CALLBACK (gtk_widget_hide),
5877 gtk_widget_show_all (child);
5879 label_box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
5880 pixwid = gtk_image_new_from_pixbuf (book_closed);
5881 g_object_set_data (G_OBJECT (child), "tab_pixmap", pixwid);
5883 gtk_box_pack_start (GTK_BOX (label_box), pixwid, FALSE, TRUE, 0);
5884 gtk_widget_set_margin_left (pixwid, 3);
5885 gtk_widget_set_margin_right (pixwid, 3);
5886 gtk_widget_set_margin_bottom (pixwid, 1);
5887 gtk_widget_set_margin_top (pixwid, 1);
5888 label = gtk_label_new_with_mnemonic (accel_buffer);
5889 gtk_box_pack_start (GTK_BOX (label_box), label, FALSE, TRUE, 0);
5890 gtk_widget_show_all (label_box);
5893 menu_box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
5894 pixwid = gtk_image_new_from_pixbuf (book_closed);
5895 g_object_set_data (G_OBJECT (child), "menu_pixmap", pixwid);
5897 gtk_box_pack_start (GTK_BOX (menu_box), pixwid, FALSE, TRUE, 0);
5898 gtk_widget_set_margin_left (pixwid, 3);
5899 gtk_widget_set_margin_right (pixwid, 3);
5900 gtk_widget_set_margin_bottom (pixwid, 1);
5901 gtk_widget_set_margin_top (pixwid, 1);
5902 label = gtk_label_new (buffer);
5903 gtk_box_pack_start (GTK_BOX (menu_box), label, FALSE, TRUE, 0);
5904 gtk_widget_show_all (menu_box);
5906 gtk_notebook_append_page_menu (notebook, child, label_box, menu_box);
5911 rotate_notebook (GtkButton *button,
5912 GtkNotebook *notebook)
5914 gtk_notebook_set_tab_pos (notebook, (gtk_notebook_get_tab_pos (notebook) + 1) % 4);
5918 show_all_pages (GtkButton *button,
5919 GtkNotebook *notebook)
5921 gtk_container_foreach (GTK_CONTAINER (notebook),
5922 (GtkCallback) gtk_widget_show, NULL);
5926 notebook_type_changed (GtkWidget *optionmenu,
5929 GtkNotebook *notebook;
5939 notebook = GTK_NOTEBOOK (data);
5941 c = gtk_combo_box_get_active (GTK_COMBO_BOX (optionmenu));
5946 /* standard notebook */
5947 gtk_notebook_set_show_tabs (notebook, TRUE);
5948 gtk_notebook_set_show_border (notebook, TRUE);
5949 gtk_notebook_set_scrollable (notebook, FALSE);
5953 /* notabs notebook */
5954 gtk_notebook_set_show_tabs (notebook, FALSE);
5955 gtk_notebook_set_show_border (notebook, TRUE);
5960 gtk_notebook_set_show_tabs (notebook, FALSE);
5961 gtk_notebook_set_show_border (notebook, FALSE);
5966 gtk_notebook_set_show_tabs (notebook, TRUE);
5967 gtk_notebook_set_show_border (notebook, TRUE);
5968 gtk_notebook_set_scrollable (notebook, TRUE);
5969 if (gtk_notebook_get_n_pages (notebook) == 5)
5970 create_pages (notebook, 6, 15);
5976 if (gtk_notebook_get_n_pages (notebook) == 15)
5977 for (i = 0; i < 10; i++)
5978 gtk_notebook_remove_page (notebook, 5);
5982 notebook_popup (GtkToggleButton *button,
5983 GtkNotebook *notebook)
5985 if (gtk_toggle_button_get_active (button))
5986 gtk_notebook_popup_enable (notebook);
5988 gtk_notebook_popup_disable (notebook);
5992 create_notebook (GtkWidget *widget)
5994 static GtkWidget *window = NULL;
5998 GtkWidget *separator;
6002 static gchar *items[] =
6012 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
6013 gtk_window_set_screen (GTK_WINDOW (window),
6014 gtk_widget_get_screen (widget));
6016 g_signal_connect (window, "destroy",
6017 G_CALLBACK (gtk_widget_destroyed),
6020 gtk_window_set_title (GTK_WINDOW (window), "notebook");
6021 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
6023 box1 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
6024 gtk_container_add (GTK_CONTAINER (window), box1);
6026 sample_notebook = gtk_notebook_new ();
6027 g_signal_connect (sample_notebook, "switch_page",
6028 G_CALLBACK (page_switch), NULL);
6029 gtk_notebook_set_tab_pos (GTK_NOTEBOOK (sample_notebook), GTK_POS_TOP);
6030 gtk_box_pack_start (GTK_BOX (box1), sample_notebook, TRUE, TRUE, 0);
6031 gtk_container_set_border_width (GTK_CONTAINER (sample_notebook), 10);
6033 gtk_widget_realize (sample_notebook);
6036 book_open = gdk_pixbuf_new_from_xpm_data (book_open_xpm);
6039 book_closed = gdk_pixbuf_new_from_xpm_data (book_closed_xpm);
6041 create_pages (GTK_NOTEBOOK (sample_notebook), 1, 5);
6043 separator = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
6044 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 10);
6046 box2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 5);
6047 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
6048 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
6050 button = gtk_check_button_new_with_label ("popup menu");
6051 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, FALSE, 0);
6052 g_signal_connect (button, "clicked",
6053 G_CALLBACK (notebook_popup),
6056 box2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 5);
6057 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
6058 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
6060 label = gtk_label_new ("Notebook Style :");
6061 gtk_box_pack_start (GTK_BOX (box2), label, FALSE, TRUE, 0);
6063 omenu = build_option_menu (items, G_N_ELEMENTS (items), 0,
6064 notebook_type_changed,
6066 gtk_box_pack_start (GTK_BOX (box2), omenu, FALSE, TRUE, 0);
6068 button = gtk_button_new_with_label ("Show all Pages");
6069 gtk_box_pack_start (GTK_BOX (box2), button, FALSE, TRUE, 0);
6070 g_signal_connect (button, "clicked",
6071 G_CALLBACK (show_all_pages), sample_notebook);
6073 box2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 10);
6074 gtk_box_set_homogeneous (GTK_BOX (box2), TRUE);
6075 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
6076 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
6078 button = gtk_button_new_with_label ("prev");
6079 g_signal_connect_swapped (button, "clicked",
6080 G_CALLBACK (gtk_notebook_prev_page),
6082 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
6084 button = gtk_button_new_with_label ("next");
6085 g_signal_connect_swapped (button, "clicked",
6086 G_CALLBACK (gtk_notebook_next_page),
6088 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
6090 button = gtk_button_new_with_label ("rotate");
6091 g_signal_connect (button, "clicked",
6092 G_CALLBACK (rotate_notebook), sample_notebook);
6093 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
6095 separator = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
6096 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 5);
6098 button = gtk_button_new_with_label ("close");
6099 gtk_container_set_border_width (GTK_CONTAINER (button), 5);
6100 g_signal_connect_swapped (button, "clicked",
6101 G_CALLBACK (gtk_widget_destroy),
6103 gtk_box_pack_start (GTK_BOX (box1), button, FALSE, FALSE, 0);
6104 gtk_widget_set_can_default (button, TRUE);
6105 gtk_widget_grab_default (button);
6108 if (!gtk_widget_get_visible (window))
6109 gtk_widget_show_all (window);
6111 gtk_widget_destroy (window);
6115 create_settings (GtkWidget *widget)
6117 static GtkWidget *window = NULL;
6121 window = create_prop_editor (G_OBJECT (gtk_settings_get_default ()), GTK_TYPE_SETTINGS);
6122 gtk_window_set_screen (GTK_WINDOW (window),
6123 gtk_widget_get_screen (widget));
6125 gtk_widget_hide (window);
6126 gtk_window_set_title (GTK_WINDOW (window), "GTK+ Settings");
6128 g_signal_connect (window, "destroy",
6129 G_CALLBACK (gtk_widget_destroyed),
6133 if (!gtk_widget_get_visible (window))
6134 gtk_widget_show (window);
6136 gtk_widget_destroy (window);
6144 toggle_resize (GtkWidget *widget, GtkWidget *child)
6146 GtkContainer *container = GTK_CONTAINER (gtk_widget_get_parent (child));
6147 GValue value = G_VALUE_INIT;
6148 g_value_init (&value, G_TYPE_BOOLEAN);
6149 gtk_container_child_get_property (container, child, "resize", &value);
6150 g_value_set_boolean (&value, !g_value_get_boolean (&value));
6151 gtk_container_child_set_property (container, child, "resize", &value);
6155 toggle_shrink (GtkWidget *widget, GtkWidget *child)
6157 GtkContainer *container = GTK_CONTAINER (gtk_widget_get_parent (child));
6158 GValue value = G_VALUE_INIT;
6159 g_value_init (&value, G_TYPE_BOOLEAN);
6160 gtk_container_child_get_property (container, child, "shrink", &value);
6161 g_value_set_boolean (&value, !g_value_get_boolean (&value));
6162 gtk_container_child_set_property (container, child, "shrink", &value);
6166 paned_props_clicked (GtkWidget *button,
6169 GtkWidget *window = create_prop_editor (paned, GTK_TYPE_PANED);
6171 gtk_window_set_title (GTK_WINDOW (window), "Paned Properties");
6175 create_pane_options (GtkPaned *paned,
6176 const gchar *frame_label,
6177 const gchar *label1,
6178 const gchar *label2)
6180 GtkWidget *child1, *child2;
6185 GtkWidget *check_button;
6187 child1 = gtk_paned_get_child1 (paned);
6188 child2 = gtk_paned_get_child2 (paned);
6190 frame = gtk_frame_new (frame_label);
6191 gtk_container_set_border_width (GTK_CONTAINER (frame), 4);
6193 grid = gtk_grid_new ();
6194 gtk_container_add (GTK_CONTAINER (frame), grid);
6196 label = gtk_label_new (label1);
6197 gtk_grid_attach (GTK_GRID (grid), label, 0, 0, 1, 1);
6199 check_button = gtk_check_button_new_with_label ("Resize");
6200 gtk_grid_attach (GTK_GRID (grid), check_button, 0, 1, 1, 1);
6201 g_signal_connect (check_button, "toggled",
6202 G_CALLBACK (toggle_resize),
6205 check_button = gtk_check_button_new_with_label ("Shrink");
6206 gtk_grid_attach (GTK_GRID (grid), check_button, 0, 2, 1, 1);
6207 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check_button),
6209 g_signal_connect (check_button, "toggled",
6210 G_CALLBACK (toggle_shrink),
6213 label = gtk_label_new (label2);
6214 gtk_grid_attach (GTK_GRID (grid), label, 1, 0, 1, 1);
6216 check_button = gtk_check_button_new_with_label ("Resize");
6217 gtk_grid_attach (GTK_GRID (grid), check_button, 1, 1, 1, 1);
6218 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check_button),
6220 g_signal_connect (check_button, "toggled",
6221 G_CALLBACK (toggle_resize),
6224 check_button = gtk_check_button_new_with_label ("Shrink");
6225 gtk_grid_attach (GTK_GRID (grid), check_button, 1, 2, 1, 1);
6226 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check_button),
6228 g_signal_connect (check_button, "toggled",
6229 G_CALLBACK (toggle_shrink),
6232 button = gtk_button_new_with_mnemonic ("_Properties");
6233 gtk_grid_attach (GTK_GRID (grid), button, 0, 3, 2, 1);
6234 g_signal_connect (button, "clicked",
6235 G_CALLBACK (paned_props_clicked),
6242 create_panes (GtkWidget *widget)
6244 static GtkWidget *window = NULL;
6253 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
6255 gtk_window_set_screen (GTK_WINDOW (window),
6256 gtk_widget_get_screen (widget));
6258 g_signal_connect (window, "destroy",
6259 G_CALLBACK (gtk_widget_destroyed),
6262 gtk_window_set_title (GTK_WINDOW (window), "Panes");
6263 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
6265 vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
6266 gtk_container_add (GTK_CONTAINER (window), vbox);
6268 vpaned = gtk_paned_new (GTK_ORIENTATION_VERTICAL);
6269 gtk_box_pack_start (GTK_BOX (vbox), vpaned, TRUE, TRUE, 0);
6270 gtk_container_set_border_width (GTK_CONTAINER(vpaned), 5);
6272 hpaned = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL);
6273 gtk_paned_add1 (GTK_PANED (vpaned), hpaned);
6275 frame = gtk_frame_new (NULL);
6276 gtk_frame_set_shadow_type (GTK_FRAME(frame), GTK_SHADOW_IN);
6277 gtk_widget_set_size_request (frame, 60, 60);
6278 gtk_paned_add1 (GTK_PANED (hpaned), frame);
6280 button = gtk_button_new_with_label ("Hi there");
6281 gtk_container_add (GTK_CONTAINER(frame), button);
6283 frame = gtk_frame_new (NULL);
6284 gtk_frame_set_shadow_type (GTK_FRAME(frame), GTK_SHADOW_IN);
6285 gtk_widget_set_size_request (frame, 80, 60);
6286 gtk_paned_add2 (GTK_PANED (hpaned), frame);
6288 frame = gtk_frame_new (NULL);
6289 gtk_frame_set_shadow_type (GTK_FRAME(frame), GTK_SHADOW_IN);
6290 gtk_widget_set_size_request (frame, 60, 80);
6291 gtk_paned_add2 (GTK_PANED (vpaned), frame);
6293 /* Now create toggle buttons to control sizing */
6295 gtk_box_pack_start (GTK_BOX (vbox),
6296 create_pane_options (GTK_PANED (hpaned),
6302 gtk_box_pack_start (GTK_BOX (vbox),
6303 create_pane_options (GTK_PANED (vpaned),
6309 gtk_widget_show_all (vbox);
6312 if (!gtk_widget_get_visible (window))
6313 gtk_widget_show (window);
6315 gtk_widget_destroy (window);
6319 * Paned keyboard navigation
6323 paned_keyboard_window1 (GtkWidget *widget)
6346 window1 = gtk_window_new (GTK_WINDOW_TOPLEVEL);
6347 gtk_window_set_title (GTK_WINDOW (window1), "Basic paned navigation");
6348 gtk_window_set_screen (GTK_WINDOW (window1),
6349 gtk_widget_get_screen (widget));
6351 hpaned1 = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL);
6352 gtk_container_add (GTK_CONTAINER (window1), hpaned1);
6354 frame1 = gtk_frame_new (NULL);
6355 gtk_paned_pack1 (GTK_PANED (hpaned1), frame1, FALSE, TRUE);
6356 gtk_frame_set_shadow_type (GTK_FRAME (frame1), GTK_SHADOW_IN);
6358 vbox1 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
6359 gtk_container_add (GTK_CONTAINER (frame1), vbox1);
6361 button7 = gtk_button_new_with_label ("button7");
6362 gtk_box_pack_start (GTK_BOX (vbox1), button7, FALSE, FALSE, 0);
6364 button8 = gtk_button_new_with_label ("button8");
6365 gtk_box_pack_start (GTK_BOX (vbox1), button8, FALSE, FALSE, 0);
6367 button9 = gtk_button_new_with_label ("button9");
6368 gtk_box_pack_start (GTK_BOX (vbox1), button9, FALSE, FALSE, 0);
6370 vpaned1 = gtk_paned_new (GTK_ORIENTATION_VERTICAL);
6371 gtk_paned_pack2 (GTK_PANED (hpaned1), vpaned1, TRUE, TRUE);
6373 frame2 = gtk_frame_new (NULL);
6374 gtk_paned_pack1 (GTK_PANED (vpaned1), frame2, FALSE, TRUE);
6375 gtk_frame_set_shadow_type (GTK_FRAME (frame2), GTK_SHADOW_IN);
6377 frame5 = gtk_frame_new (NULL);
6378 gtk_container_add (GTK_CONTAINER (frame2), frame5);
6380 hbox1 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
6381 gtk_container_add (GTK_CONTAINER (frame5), hbox1);
6383 button5 = gtk_button_new_with_label ("button5");
6384 gtk_box_pack_start (GTK_BOX (hbox1), button5, FALSE, FALSE, 0);
6386 button6 = gtk_button_new_with_label ("button6");
6387 gtk_box_pack_start (GTK_BOX (hbox1), button6, FALSE, FALSE, 0);
6389 frame3 = gtk_frame_new (NULL);
6390 gtk_paned_pack2 (GTK_PANED (vpaned1), frame3, TRUE, TRUE);
6391 gtk_frame_set_shadow_type (GTK_FRAME (frame3), GTK_SHADOW_IN);
6393 frame4 = gtk_frame_new ("Buttons");
6394 gtk_container_add (GTK_CONTAINER (frame3), frame4);
6395 gtk_container_set_border_width (GTK_CONTAINER (frame4), 15);
6397 grid1 = gtk_grid_new ();
6398 gtk_container_add (GTK_CONTAINER (frame4), grid1);
6399 gtk_container_set_border_width (GTK_CONTAINER (grid1), 11);
6401 button1 = gtk_button_new_with_label ("button1");
6402 gtk_grid_attach (GTK_GRID (grid1), button1, 0, 0, 1, 1);
6404 button2 = gtk_button_new_with_label ("button2");
6405 gtk_grid_attach (GTK_GRID (grid1), button2, 1, 0, 1, 1);
6407 button3 = gtk_button_new_with_label ("button3");
6408 gtk_grid_attach (GTK_GRID (grid1), button3, 0, 1, 1, 1);
6410 button4 = gtk_button_new_with_label ("button4");
6411 gtk_grid_attach (GTK_GRID (grid1), button4, 1, 1, 1, 1);
6417 paned_keyboard_window2 (GtkWidget *widget)
6422 GtkWidget *button13;
6426 GtkWidget *button12;
6428 GtkWidget *button11;
6429 GtkWidget *button10;
6431 window2 = gtk_window_new (GTK_WINDOW_TOPLEVEL);
6432 gtk_window_set_title (GTK_WINDOW (window2), "\"button 10\" is not inside the horisontal pane");
6434 gtk_window_set_screen (GTK_WINDOW (window2),
6435 gtk_widget_get_screen (widget));
6437 hpaned2 = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL);
6438 gtk_container_add (GTK_CONTAINER (window2), hpaned2);
6440 frame6 = gtk_frame_new (NULL);
6441 gtk_paned_pack1 (GTK_PANED (hpaned2), frame6, FALSE, TRUE);
6442 gtk_frame_set_shadow_type (GTK_FRAME (frame6), GTK_SHADOW_IN);
6444 button13 = gtk_button_new_with_label ("button13");
6445 gtk_container_add (GTK_CONTAINER (frame6), button13);
6447 hbox2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
6448 gtk_paned_pack2 (GTK_PANED (hpaned2), hbox2, TRUE, TRUE);
6450 vpaned2 = gtk_paned_new (GTK_ORIENTATION_VERTICAL);
6451 gtk_box_pack_start (GTK_BOX (hbox2), vpaned2, TRUE, TRUE, 0);
6453 frame7 = gtk_frame_new (NULL);
6454 gtk_paned_pack1 (GTK_PANED (vpaned2), frame7, FALSE, TRUE);
6455 gtk_frame_set_shadow_type (GTK_FRAME (frame7), GTK_SHADOW_IN);
6457 button12 = gtk_button_new_with_label ("button12");
6458 gtk_container_add (GTK_CONTAINER (frame7), button12);
6460 frame8 = gtk_frame_new (NULL);
6461 gtk_paned_pack2 (GTK_PANED (vpaned2), frame8, TRUE, TRUE);
6462 gtk_frame_set_shadow_type (GTK_FRAME (frame8), GTK_SHADOW_IN);
6464 button11 = gtk_button_new_with_label ("button11");
6465 gtk_container_add (GTK_CONTAINER (frame8), button11);
6467 button10 = gtk_button_new_with_label ("button10");
6468 gtk_box_pack_start (GTK_BOX (hbox2), button10, FALSE, FALSE, 0);
6474 paned_keyboard_window3 (GtkWidget *widget)
6481 GtkWidget *button14;
6484 GtkWidget *button15;
6487 GtkWidget *button16;
6489 GtkWidget *button17;
6491 window3 = gtk_window_new (GTK_WINDOW_TOPLEVEL);
6492 g_object_set_data (G_OBJECT (window3), "window3", window3);
6493 gtk_window_set_title (GTK_WINDOW (window3), "Nested panes");
6495 gtk_window_set_screen (GTK_WINDOW (window3),
6496 gtk_widget_get_screen (widget));
6499 vbox2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
6500 gtk_container_add (GTK_CONTAINER (window3), vbox2);
6502 label1 = gtk_label_new ("Three panes nested inside each other");
6503 gtk_box_pack_start (GTK_BOX (vbox2), label1, FALSE, FALSE, 0);
6505 hpaned3 = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL);
6506 gtk_box_pack_start (GTK_BOX (vbox2), hpaned3, TRUE, TRUE, 0);
6508 frame9 = gtk_frame_new (NULL);
6509 gtk_paned_pack1 (GTK_PANED (hpaned3), frame9, FALSE, TRUE);
6510 gtk_frame_set_shadow_type (GTK_FRAME (frame9), GTK_SHADOW_IN);
6512 button14 = gtk_button_new_with_label ("button14");
6513 gtk_container_add (GTK_CONTAINER (frame9), button14);
6515 hpaned4 = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL);
6516 gtk_paned_pack2 (GTK_PANED (hpaned3), hpaned4, TRUE, TRUE);
6518 frame10 = gtk_frame_new (NULL);
6519 gtk_paned_pack1 (GTK_PANED (hpaned4), frame10, FALSE, TRUE);
6520 gtk_frame_set_shadow_type (GTK_FRAME (frame10), GTK_SHADOW_IN);
6522 button15 = gtk_button_new_with_label ("button15");
6523 gtk_container_add (GTK_CONTAINER (frame10), button15);
6525 hpaned5 = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL);
6526 gtk_paned_pack2 (GTK_PANED (hpaned4), hpaned5, TRUE, TRUE);
6528 frame11 = gtk_frame_new (NULL);
6529 gtk_paned_pack1 (GTK_PANED (hpaned5), frame11, FALSE, TRUE);
6530 gtk_frame_set_shadow_type (GTK_FRAME (frame11), GTK_SHADOW_IN);
6532 button16 = gtk_button_new_with_label ("button16");
6533 gtk_container_add (GTK_CONTAINER (frame11), button16);
6535 frame12 = gtk_frame_new (NULL);
6536 gtk_paned_pack2 (GTK_PANED (hpaned5), frame12, TRUE, TRUE);
6537 gtk_frame_set_shadow_type (GTK_FRAME (frame12), GTK_SHADOW_IN);
6539 button17 = gtk_button_new_with_label ("button17");
6540 gtk_container_add (GTK_CONTAINER (frame12), button17);
6546 paned_keyboard_window4 (GtkWidget *widget)
6553 GtkWidget *button19;
6554 GtkWidget *button18;
6557 GtkWidget *button21;
6558 GtkWidget *button20;
6560 GtkWidget *button23;
6561 GtkWidget *button22;
6563 GtkWidget *button25;
6564 GtkWidget *button24;
6566 window4 = gtk_window_new (GTK_WINDOW_TOPLEVEL);
6567 g_object_set_data (G_OBJECT (window4), "window4", window4);
6568 gtk_window_set_title (GTK_WINDOW (window4), "window4");
6570 gtk_window_set_screen (GTK_WINDOW (window4),
6571 gtk_widget_get_screen (widget));
6573 vbox3 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
6574 gtk_container_add (GTK_CONTAINER (window4), vbox3);
6576 label2 = gtk_label_new ("Widget tree:\n\nhpaned \n - vpaned\n - hbox\n - vpaned\n - vpaned\n - vpaned\n");
6577 gtk_box_pack_start (GTK_BOX (vbox3), label2, FALSE, FALSE, 0);
6578 gtk_label_set_justify (GTK_LABEL (label2), GTK_JUSTIFY_LEFT);
6580 hpaned6 = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL);
6581 gtk_box_pack_start (GTK_BOX (vbox3), hpaned6, TRUE, TRUE, 0);
6583 vpaned3 = gtk_paned_new (GTK_ORIENTATION_VERTICAL);
6584 gtk_paned_pack1 (GTK_PANED (hpaned6), vpaned3, FALSE, TRUE);
6586 button19 = gtk_button_new_with_label ("button19");
6587 gtk_paned_pack1 (GTK_PANED (vpaned3), button19, FALSE, TRUE);
6589 button18 = gtk_button_new_with_label ("button18");
6590 gtk_paned_pack2 (GTK_PANED (vpaned3), button18, TRUE, TRUE);
6592 hbox3 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
6593 gtk_paned_pack2 (GTK_PANED (hpaned6), hbox3, TRUE, TRUE);
6595 vpaned4 = gtk_paned_new (GTK_ORIENTATION_VERTICAL);
6596 gtk_box_pack_start (GTK_BOX (hbox3), vpaned4, TRUE, TRUE, 0);
6598 button21 = gtk_button_new_with_label ("button21");
6599 gtk_paned_pack1 (GTK_PANED (vpaned4), button21, FALSE, TRUE);
6601 button20 = gtk_button_new_with_label ("button20");
6602 gtk_paned_pack2 (GTK_PANED (vpaned4), button20, TRUE, TRUE);
6604 vpaned5 = gtk_paned_new (GTK_ORIENTATION_VERTICAL);
6605 gtk_box_pack_start (GTK_BOX (hbox3), vpaned5, TRUE, TRUE, 0);
6607 button23 = gtk_button_new_with_label ("button23");
6608 gtk_paned_pack1 (GTK_PANED (vpaned5), button23, FALSE, TRUE);
6610 button22 = gtk_button_new_with_label ("button22");
6611 gtk_paned_pack2 (GTK_PANED (vpaned5), button22, TRUE, TRUE);
6613 vpaned6 = gtk_paned_new (GTK_ORIENTATION_VERTICAL);
6614 gtk_box_pack_start (GTK_BOX (hbox3), vpaned6, TRUE, TRUE, 0);
6616 button25 = gtk_button_new_with_label ("button25");
6617 gtk_paned_pack1 (GTK_PANED (vpaned6), button25, FALSE, TRUE);
6619 button24 = gtk_button_new_with_label ("button24");
6620 gtk_paned_pack2 (GTK_PANED (vpaned6), button24, TRUE, TRUE);
6626 create_paned_keyboard_navigation (GtkWidget *widget)
6628 static GtkWidget *window1 = NULL;
6629 static GtkWidget *window2 = NULL;
6630 static GtkWidget *window3 = NULL;
6631 static GtkWidget *window4 = NULL;
6634 (gtk_widget_get_screen (window1) != gtk_widget_get_screen (widget)))
6636 gtk_widget_destroy (window1);
6637 gtk_widget_destroy (window2);
6638 gtk_widget_destroy (window3);
6639 gtk_widget_destroy (window4);
6644 window1 = paned_keyboard_window1 (widget);
6645 g_signal_connect (window1, "destroy",
6646 G_CALLBACK (gtk_widget_destroyed),
6652 window2 = paned_keyboard_window2 (widget);
6653 g_signal_connect (window2, "destroy",
6654 G_CALLBACK (gtk_widget_destroyed),
6660 window3 = paned_keyboard_window3 (widget);
6661 g_signal_connect (window3, "destroy",
6662 G_CALLBACK (gtk_widget_destroyed),
6668 window4 = paned_keyboard_window4 (widget);
6669 g_signal_connect (window4, "destroy",
6670 G_CALLBACK (gtk_widget_destroyed),
6674 if (gtk_widget_get_visible (window1))
6675 gtk_widget_destroy (GTK_WIDGET (window1));
6677 gtk_widget_show_all (GTK_WIDGET (window1));
6679 if (gtk_widget_get_visible (window2))
6680 gtk_widget_destroy (GTK_WIDGET (window2));
6682 gtk_widget_show_all (GTK_WIDGET (window2));
6684 if (gtk_widget_get_visible (window3))
6685 gtk_widget_destroy (GTK_WIDGET (window3));
6687 gtk_widget_show_all (GTK_WIDGET (window3));
6689 if (gtk_widget_get_visible (window4))
6690 gtk_widget_destroy (GTK_WIDGET (window4));
6692 gtk_widget_show_all (GTK_WIDGET (window4));
6700 typedef struct _cursoroffset {gint x,y;} CursorOffset;
6703 shape_pressed (GtkWidget *widget, GdkEventButton *event)
6707 /* ignore double and triple click */
6708 if (event->type != GDK_BUTTON_PRESS)
6711 p = g_object_get_data (G_OBJECT (widget), "cursor_offset");
6712 p->x = (int) event->x;
6713 p->y = (int) event->y;
6715 gtk_grab_add (widget);
6716 gdk_device_grab (gdk_event_get_device ((GdkEvent*)event),
6717 gtk_widget_get_window (widget),
6720 GDK_BUTTON_RELEASE_MASK |
6721 GDK_BUTTON_MOTION_MASK |
6722 GDK_POINTER_MOTION_HINT_MASK,
6728 shape_released (GtkWidget *widget,
6729 GdkEventButton *event)
6731 gtk_grab_remove (widget);
6732 gdk_device_ungrab (gdk_event_get_device ((GdkEvent*)event), event->time);
6736 shape_motion (GtkWidget *widget,
6737 GdkEventMotion *event)
6742 p = g_object_get_data (G_OBJECT (widget), "cursor_offset");
6745 * Can't use event->x / event->y here
6746 * because I need absolute coordinates.
6748 gdk_window_get_device_position (gdk_screen_get_root_window (gtk_widget_get_screen (widget)),
6749 gdk_event_get_device ((GdkEvent *) event),
6751 gtk_window_move (GTK_WINDOW (widget), xp - p->x, yp - p->y);
6755 shape_create_icon (GdkScreen *screen,
6766 CursorOffset* icon_pos;
6767 cairo_surface_t *mask;
6768 cairo_region_t *mask_region;
6773 * GDK_WINDOW_TOPLEVEL works also, giving you a title border
6775 window = gtk_window_new (window_type);
6776 gtk_window_set_screen (GTK_WINDOW (window), screen);
6778 fixed = gtk_fixed_new ();
6779 gtk_widget_set_size_request (fixed, 100, 100);
6780 gtk_container_add (GTK_CONTAINER (window), fixed);
6781 gtk_widget_show (fixed);
6783 gtk_widget_set_events (window,
6784 gtk_widget_get_events (window) |
6785 GDK_BUTTON_MOTION_MASK |
6786 GDK_POINTER_MOTION_HINT_MASK |
6787 GDK_BUTTON_PRESS_MASK);
6789 gtk_widget_realize (window);
6791 pixbuf = gdk_pixbuf_new_from_file (xpm_file, NULL);
6792 g_assert (pixbuf); /* FIXME: error handling */
6794 mask = cairo_image_surface_create (CAIRO_FORMAT_A1,
6795 gdk_pixbuf_get_width (pixbuf),
6796 gdk_pixbuf_get_height (pixbuf));
6797 cr = cairo_create (mask);
6798 gdk_cairo_set_source_pixbuf (cr, pixbuf, 0, 0);
6802 mask_region = gdk_cairo_region_create_from_surface (mask);
6804 cairo_region_translate (mask_region, px, py);
6806 image = gtk_image_new_from_pixbuf (pixbuf);
6807 gtk_fixed_put (GTK_FIXED (fixed), image, px,py);
6808 gtk_widget_show (image);
6810 gtk_widget_shape_combine_region (window, mask_region);
6812 cairo_region_destroy (mask_region);
6813 cairo_surface_destroy (mask);
6814 g_object_unref (pixbuf);
6816 g_signal_connect (window, "button_press_event",
6817 G_CALLBACK (shape_pressed), NULL);
6818 g_signal_connect (window, "button_release_event",
6819 G_CALLBACK (shape_released), NULL);
6820 g_signal_connect (window, "motion_notify_event",
6821 G_CALLBACK (shape_motion), NULL);
6823 icon_pos = g_new (CursorOffset, 1);
6824 g_object_set_data (G_OBJECT (window), "cursor_offset", icon_pos);
6826 gtk_window_move (GTK_WINDOW (window), x, y);
6827 gtk_widget_show (window);
6833 create_shapes (GtkWidget *widget)
6835 /* Variables used by the Drag/Drop and Shape Window demos */
6836 static GtkWidget *modeller = NULL;
6837 static GtkWidget *sheets = NULL;
6838 static GtkWidget *rings = NULL;
6839 static GtkWidget *with_region = NULL;
6840 GdkScreen *screen = gtk_widget_get_screen (widget);
6842 if (!(file_exists ("Modeller.xpm") &&
6843 file_exists ("FilesQueue.xpm") &&
6844 file_exists ("3DRings.xpm")))
6850 modeller = shape_create_icon (screen, "Modeller.xpm",
6851 440, 140, 0,0, GTK_WINDOW_POPUP);
6853 g_signal_connect (modeller, "destroy",
6854 G_CALLBACK (gtk_widget_destroyed),
6858 gtk_widget_destroy (modeller);
6862 sheets = shape_create_icon (screen, "FilesQueue.xpm",
6863 580, 170, 0,0, GTK_WINDOW_POPUP);
6865 g_signal_connect (sheets, "destroy",
6866 G_CALLBACK (gtk_widget_destroyed),
6871 gtk_widget_destroy (sheets);
6875 rings = shape_create_icon (screen, "3DRings.xpm",
6876 460, 270, 25,25, GTK_WINDOW_TOPLEVEL);
6878 g_signal_connect (rings, "destroy",
6879 G_CALLBACK (gtk_widget_destroyed),
6883 gtk_widget_destroy (rings);
6887 cairo_region_t *region;
6890 with_region = shape_create_icon (screen, "3DRings.xpm",
6891 460, 270, 25,25, GTK_WINDOW_TOPLEVEL);
6893 gtk_window_set_decorated (GTK_WINDOW (with_region), FALSE);
6895 g_signal_connect (with_region, "destroy",
6896 G_CALLBACK (gtk_widget_destroyed),
6899 /* reset shape from mask to a region */
6902 region = cairo_region_create ();
6914 cairo_region_union_rectangle (region, &rect);
6922 gdk_window_shape_combine_region (gtk_widget_get_window (with_region),
6927 gtk_widget_destroy (with_region);
6935 create_wmhints (GtkWidget *widget)
6937 static GtkWidget *window = NULL;
6939 GtkWidget *separator;
6943 GdkWindow *gdk_window;
6949 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
6951 gtk_window_set_screen (GTK_WINDOW (window),
6952 gtk_widget_get_screen (widget));
6954 g_signal_connect (window, "destroy",
6955 G_CALLBACK (gtk_widget_destroyed),
6958 gtk_window_set_title (GTK_WINDOW (window), "WM Hints");
6959 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
6961 gtk_widget_realize (window);
6963 gdk_window = gtk_widget_get_window (window);
6965 pixbuf = gdk_pixbuf_new_from_xpm_data ((const char **) openfile);
6966 list = g_list_prepend (NULL, pixbuf);
6968 gdk_window_set_icon_list (gdk_window, list);
6971 g_object_unref (pixbuf);
6973 gdk_window_set_icon_name (gdk_window, "WMHints Test Icon");
6975 gdk_window_set_decorations (gdk_window, GDK_DECOR_ALL | GDK_DECOR_MENU);
6976 gdk_window_set_functions (gdk_window, GDK_FUNC_ALL | GDK_FUNC_RESIZE);
6978 box1 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
6979 gtk_container_add (GTK_CONTAINER (window), box1);
6980 gtk_widget_show (box1);
6982 label = gtk_label_new ("Try iconizing me!");
6983 gtk_widget_set_size_request (label, 150, 50);
6984 gtk_box_pack_start (GTK_BOX (box1), label, TRUE, TRUE, 0);
6985 gtk_widget_show (label);
6988 separator = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
6989 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
6990 gtk_widget_show (separator);
6993 box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10);
6994 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
6995 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
6996 gtk_widget_show (box2);
6999 button = gtk_button_new_with_label ("close");
7001 g_signal_connect_swapped (button, "clicked",
7002 G_CALLBACK (gtk_widget_destroy),
7005 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
7006 gtk_widget_set_can_default (button, TRUE);
7007 gtk_widget_grab_default (button);
7008 gtk_widget_show (button);
7011 if (!gtk_widget_get_visible (window))
7012 gtk_widget_show (window);
7014 gtk_widget_destroy (window);
7019 * Window state tracking
7023 window_state_callback (GtkWidget *widget,
7024 GdkEventWindowState *event,
7027 GtkWidget *label = data;
7030 msg = g_strconcat (gtk_window_get_title (GTK_WINDOW (widget)), ": ",
7031 (event->new_window_state & GDK_WINDOW_STATE_WITHDRAWN) ?
7032 "withdrawn" : "not withdrawn", ", ",
7033 (event->new_window_state & GDK_WINDOW_STATE_ICONIFIED) ?
7034 "iconified" : "not iconified", ", ",
7035 (event->new_window_state & GDK_WINDOW_STATE_STICKY) ?
7036 "sticky" : "not sticky", ", ",
7037 (event->new_window_state & GDK_WINDOW_STATE_MAXIMIZED) ?
7038 "maximized" : "not maximized", ", ",
7039 (event->new_window_state & GDK_WINDOW_STATE_FULLSCREEN) ?
7040 "fullscreen" : "not fullscreen",
7041 (event->new_window_state & GDK_WINDOW_STATE_ABOVE) ?
7042 "above" : "not above", ", ",
7043 (event->new_window_state & GDK_WINDOW_STATE_BELOW) ?
7044 "below" : "not below", ", ",
7047 gtk_label_set_text (GTK_LABEL (label), msg);
7055 tracking_label (GtkWidget *window)
7061 hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 5);
7063 g_signal_connect_object (hbox,
7065 G_CALLBACK (gtk_widget_destroy),
7069 label = gtk_label_new ("<no window state events received>");
7070 gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
7071 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
7073 g_signal_connect (window,
7074 "window_state_event",
7075 G_CALLBACK (window_state_callback),
7078 button = gtk_button_new_with_label ("Deiconify");
7079 g_signal_connect_object (button,
7081 G_CALLBACK (gtk_window_deiconify),
7084 gtk_box_pack_end (GTK_BOX (hbox), button, FALSE, FALSE, 0);
7086 button = gtk_button_new_with_label ("Iconify");
7087 g_signal_connect_object (button,
7089 G_CALLBACK (gtk_window_iconify),
7092 gtk_box_pack_end (GTK_BOX (hbox), button, FALSE, FALSE, 0);
7094 button = gtk_button_new_with_label ("Fullscreen");
7095 g_signal_connect_object (button,
7097 G_CALLBACK (gtk_window_fullscreen),
7100 gtk_box_pack_end (GTK_BOX (hbox), button, FALSE, FALSE, 0);
7102 button = gtk_button_new_with_label ("Unfullscreen");
7103 g_signal_connect_object (button,
7105 G_CALLBACK (gtk_window_unfullscreen),
7108 gtk_box_pack_end (GTK_BOX (hbox), button, FALSE, FALSE, 0);
7110 button = gtk_button_new_with_label ("Present");
7111 g_signal_connect_object (button,
7113 G_CALLBACK (gtk_window_present),
7116 gtk_box_pack_end (GTK_BOX (hbox), button, FALSE, FALSE, 0);
7118 button = gtk_button_new_with_label ("Show");
7119 g_signal_connect_object (button,
7121 G_CALLBACK (gtk_widget_show),
7124 gtk_box_pack_end (GTK_BOX (hbox), button, FALSE, FALSE, 0);
7126 gtk_widget_show_all (hbox);
7132 keep_window_above (GtkToggleButton *togglebutton, gpointer data)
7134 GtkWidget *button = g_object_get_data (G_OBJECT (togglebutton), "radio");
7136 gtk_window_set_keep_above (GTK_WINDOW (data),
7137 gtk_toggle_button_get_active (togglebutton));
7139 if (gtk_toggle_button_get_active (togglebutton))
7140 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), FALSE);
7144 keep_window_below (GtkToggleButton *togglebutton, gpointer data)
7146 GtkWidget *button = g_object_get_data (G_OBJECT (togglebutton), "radio");
7148 gtk_window_set_keep_below (GTK_WINDOW (data),
7149 gtk_toggle_button_get_active (togglebutton));
7151 if (gtk_toggle_button_get_active (togglebutton))
7152 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), FALSE);
7157 get_state_controls (GtkWidget *window)
7161 GtkWidget *button_above;
7162 GtkWidget *button_below;
7164 vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
7166 button = gtk_button_new_with_label ("Stick");
7167 g_signal_connect_object (button,
7169 G_CALLBACK (gtk_window_stick),
7172 gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
7174 button = gtk_button_new_with_label ("Unstick");
7175 g_signal_connect_object (button,
7177 G_CALLBACK (gtk_window_unstick),
7180 gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
7182 button = gtk_button_new_with_label ("Maximize");
7183 g_signal_connect_object (button,
7185 G_CALLBACK (gtk_window_maximize),
7188 gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
7190 button = gtk_button_new_with_label ("Unmaximize");
7191 g_signal_connect_object (button,
7193 G_CALLBACK (gtk_window_unmaximize),
7196 gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
7198 button = gtk_button_new_with_label ("Iconify");
7199 g_signal_connect_object (button,
7201 G_CALLBACK (gtk_window_iconify),
7204 gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
7206 button = gtk_button_new_with_label ("Fullscreen");
7207 g_signal_connect_object (button,
7209 G_CALLBACK (gtk_window_fullscreen),
7212 gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
7214 button = gtk_button_new_with_label ("Unfullscreen");
7215 g_signal_connect_object (button,
7217 G_CALLBACK (gtk_window_unfullscreen),
7220 gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
7222 button_above = gtk_toggle_button_new_with_label ("Keep above");
7223 g_signal_connect (button_above,
7225 G_CALLBACK (keep_window_above),
7227 gtk_box_pack_start (GTK_BOX (vbox), button_above, FALSE, FALSE, 0);
7229 button_below = gtk_toggle_button_new_with_label ("Keep below");
7230 g_signal_connect (button_below,
7232 G_CALLBACK (keep_window_below),
7234 gtk_box_pack_start (GTK_BOX (vbox), button_below, FALSE, FALSE, 0);
7236 g_object_set_data (G_OBJECT (button_above), "radio", button_below);
7237 g_object_set_data (G_OBJECT (button_below), "radio", button_above);
7239 button = gtk_button_new_with_label ("Hide (withdraw)");
7240 g_signal_connect_object (button,
7242 G_CALLBACK (gtk_widget_hide),
7245 gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
7247 gtk_widget_show_all (vbox);
7253 create_window_states (GtkWidget *widget)
7255 static GtkWidget *window = NULL;
7258 GtkWidget *iconified;
7260 GtkWidget *controls;
7264 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
7265 gtk_window_set_screen (GTK_WINDOW (window),
7266 gtk_widget_get_screen (widget));
7268 g_signal_connect (window, "destroy",
7269 G_CALLBACK (gtk_widget_destroyed),
7272 gtk_window_set_title (GTK_WINDOW (window), "Window states");
7274 box1 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
7275 gtk_container_add (GTK_CONTAINER (window), box1);
7277 iconified = gtk_window_new (GTK_WINDOW_TOPLEVEL);
7279 gtk_window_set_screen (GTK_WINDOW (iconified),
7280 gtk_widget_get_screen (widget));
7282 g_signal_connect_object (iconified, "destroy",
7283 G_CALLBACK (gtk_widget_destroy),
7286 gtk_window_iconify (GTK_WINDOW (iconified));
7287 gtk_window_set_title (GTK_WINDOW (iconified), "Iconified initially");
7288 controls = get_state_controls (iconified);
7289 gtk_container_add (GTK_CONTAINER (iconified), controls);
7291 normal = gtk_window_new (GTK_WINDOW_TOPLEVEL);
7293 gtk_window_set_screen (GTK_WINDOW (normal),
7294 gtk_widget_get_screen (widget));
7296 g_signal_connect_object (normal, "destroy",
7297 G_CALLBACK (gtk_widget_destroy),
7301 gtk_window_set_title (GTK_WINDOW (normal), "Deiconified initially");
7302 controls = get_state_controls (normal);
7303 gtk_container_add (GTK_CONTAINER (normal), controls);
7305 label = tracking_label (iconified);
7306 gtk_container_add (GTK_CONTAINER (box1), label);
7308 label = tracking_label (normal);
7309 gtk_container_add (GTK_CONTAINER (box1), label);
7311 gtk_widget_show_all (iconified);
7312 gtk_widget_show_all (normal);
7313 gtk_widget_show_all (box1);
7316 if (!gtk_widget_get_visible (window))
7317 gtk_widget_show (window);
7319 gtk_widget_destroy (window);
7327 configure_event_callback (GtkWidget *widget,
7328 GdkEventConfigure *event,
7331 GtkWidget *label = data;
7335 gtk_window_get_position (GTK_WINDOW (widget), &x, &y);
7337 msg = g_strdup_printf ("event: %d,%d %d x %d\n"
7339 event->x, event->y, event->width, event->height,
7342 gtk_label_set_text (GTK_LABEL (label), msg);
7350 get_ints (GtkWidget *window,
7357 spin1 = g_object_get_data (G_OBJECT (window), "spin1");
7358 spin2 = g_object_get_data (G_OBJECT (window), "spin2");
7360 *a = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (spin1));
7361 *b = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (spin2));
7365 set_size_callback (GtkWidget *widget,
7370 get_ints (data, &w, &h);
7372 gtk_window_resize (GTK_WINDOW (g_object_get_data (data, "target")), w, h);
7376 unset_default_size_callback (GtkWidget *widget,
7379 gtk_window_set_default_size (g_object_get_data (data, "target"),
7384 set_default_size_callback (GtkWidget *widget,
7389 get_ints (data, &w, &h);
7391 gtk_window_set_default_size (g_object_get_data (data, "target"),
7396 unset_size_request_callback (GtkWidget *widget,
7399 gtk_widget_set_size_request (g_object_get_data (data, "target"),
7404 set_size_request_callback (GtkWidget *widget,
7409 get_ints (data, &w, &h);
7411 gtk_widget_set_size_request (g_object_get_data (data, "target"),
7416 set_location_callback (GtkWidget *widget,
7421 get_ints (data, &x, &y);
7423 gtk_window_move (g_object_get_data (data, "target"), x, y);
7427 move_to_position_callback (GtkWidget *widget,
7433 window = g_object_get_data (data, "target");
7435 gtk_window_get_position (window, &x, &y);
7437 gtk_window_move (window, x, y);
7441 set_geometry_callback (GtkWidget *entry,
7447 target = GTK_WINDOW (g_object_get_data (G_OBJECT (data), "target"));
7449 text = gtk_editable_get_chars (GTK_EDITABLE (entry), 0, -1);
7451 if (!gtk_window_parse_geometry (target, text))
7452 g_print ("Bad geometry string '%s'\n", text);
7458 resizable_callback (GtkWidget *widget,
7461 g_object_set (g_object_get_data (data, "target"),
7462 "resizable", gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget)),
7467 gravity_selected (GtkWidget *widget,
7470 gtk_window_set_gravity (GTK_WINDOW (g_object_get_data (data, "target")),
7471 gtk_combo_box_get_active (GTK_COMBO_BOX (widget)) + GDK_GRAVITY_NORTH_WEST);
7475 pos_selected (GtkWidget *widget,
7478 gtk_window_set_position (GTK_WINDOW (g_object_get_data (data, "target")),
7479 gtk_combo_box_get_active (GTK_COMBO_BOX (widget)) + GTK_WIN_POS_NONE);
7483 move_gravity_window_to_current_position (GtkWidget *widget,
7489 window = GTK_WINDOW (data);
7491 gtk_window_get_position (window, &x, &y);
7493 gtk_window_move (window, x, y);
7497 get_screen_corner (GtkWindow *window,
7502 GdkScreen * screen = gtk_window_get_screen (window);
7504 gtk_window_get_size (GTK_WINDOW (window), &w, &h);
7506 switch (gtk_window_get_gravity (window))
7508 case GDK_GRAVITY_SOUTH_EAST:
7509 *x = gdk_screen_get_width (screen) - w;
7510 *y = gdk_screen_get_height (screen) - h;
7513 case GDK_GRAVITY_NORTH_EAST:
7514 *x = gdk_screen_get_width (screen) - w;
7518 case GDK_GRAVITY_SOUTH_WEST:
7520 *y = gdk_screen_get_height (screen) - h;
7523 case GDK_GRAVITY_NORTH_WEST:
7528 case GDK_GRAVITY_SOUTH:
7529 *x = (gdk_screen_get_width (screen) - w) / 2;
7530 *y = gdk_screen_get_height (screen) - h;
7533 case GDK_GRAVITY_NORTH:
7534 *x = (gdk_screen_get_width (screen) - w) / 2;
7538 case GDK_GRAVITY_WEST:
7540 *y = (gdk_screen_get_height (screen) - h) / 2;
7543 case GDK_GRAVITY_EAST:
7544 *x = gdk_screen_get_width (screen) - w;
7545 *y = (gdk_screen_get_height (screen) - h) / 2;
7548 case GDK_GRAVITY_CENTER:
7549 *x = (gdk_screen_get_width (screen) - w) / 2;
7550 *y = (gdk_screen_get_height (screen) - h) / 2;
7553 case GDK_GRAVITY_STATIC:
7554 /* pick some random numbers */
7560 g_assert_not_reached ();
7566 move_gravity_window_to_starting_position (GtkWidget *widget,
7572 window = GTK_WINDOW (data);
7574 get_screen_corner (window,
7577 gtk_window_move (window, x, y);
7581 make_gravity_window (GtkWidget *destroy_with,
7590 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
7592 gtk_window_set_screen (GTK_WINDOW (window),
7593 gtk_widget_get_screen (destroy_with));
7595 vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
7596 gtk_widget_show (vbox);
7598 gtk_container_add (GTK_CONTAINER (window), vbox);
7599 gtk_window_set_title (GTK_WINDOW (window), title);
7600 gtk_window_set_gravity (GTK_WINDOW (window), gravity);
7602 g_signal_connect_object (destroy_with,
7604 G_CALLBACK (gtk_widget_destroy),
7609 button = gtk_button_new_with_mnemonic ("_Move to current position");
7611 g_signal_connect (button, "clicked",
7612 G_CALLBACK (move_gravity_window_to_current_position),
7615 gtk_container_add (GTK_CONTAINER (vbox), button);
7616 gtk_widget_show (button);
7618 button = gtk_button_new_with_mnemonic ("Move to _starting position");
7620 g_signal_connect (button, "clicked",
7621 G_CALLBACK (move_gravity_window_to_starting_position),
7624 gtk_container_add (GTK_CONTAINER (vbox), button);
7625 gtk_widget_show (button);
7627 /* Pretend this is the result of --geometry.
7628 * DO NOT COPY THIS CODE unless you are setting --geometry results,
7629 * and in that case you probably should just use gtk_window_parse_geometry().
7630 * AGAIN, DO NOT SET GDK_HINT_USER_POS! It violates the ICCCM unless
7631 * you are parsing --geometry or equivalent.
7633 gtk_window_set_geometry_hints (GTK_WINDOW (window),
7637 gtk_window_set_default_size (GTK_WINDOW (window),
7640 get_screen_corner (GTK_WINDOW (window), &x, &y);
7642 gtk_window_move (GTK_WINDOW (window),
7649 do_gravity_test (GtkWidget *widget,
7652 GtkWidget *destroy_with = data;
7655 /* We put a window at each gravity point on the screen. */
7656 window = make_gravity_window (destroy_with, GDK_GRAVITY_NORTH_WEST,
7658 gtk_widget_show (window);
7660 window = make_gravity_window (destroy_with, GDK_GRAVITY_SOUTH_EAST,
7662 gtk_widget_show (window);
7664 window = make_gravity_window (destroy_with, GDK_GRAVITY_NORTH_EAST,
7666 gtk_widget_show (window);
7668 window = make_gravity_window (destroy_with, GDK_GRAVITY_SOUTH_WEST,
7670 gtk_widget_show (window);
7672 window = make_gravity_window (destroy_with, GDK_GRAVITY_SOUTH,
7674 gtk_widget_show (window);
7676 window = make_gravity_window (destroy_with, GDK_GRAVITY_NORTH,
7678 gtk_widget_show (window);
7681 window = make_gravity_window (destroy_with, GDK_GRAVITY_WEST,
7683 gtk_widget_show (window);
7686 window = make_gravity_window (destroy_with, GDK_GRAVITY_EAST,
7688 gtk_widget_show (window);
7690 window = make_gravity_window (destroy_with, GDK_GRAVITY_CENTER,
7692 gtk_widget_show (window);
7694 window = make_gravity_window (destroy_with, GDK_GRAVITY_STATIC,
7696 gtk_widget_show (window);
7700 window_controls (GtkWidget *window)
7702 GtkWidget *control_window;
7707 GtkAdjustment *adjustment;
7712 control_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
7714 gtk_window_set_screen (GTK_WINDOW (control_window),
7715 gtk_widget_get_screen (window));
7717 gtk_window_set_title (GTK_WINDOW (control_window), "Size controls");
7719 g_object_set_data (G_OBJECT (control_window),
7723 g_signal_connect_object (control_window,
7725 G_CALLBACK (gtk_widget_destroy),
7729 vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
7731 gtk_container_add (GTK_CONTAINER (control_window), vbox);
7733 label = gtk_label_new ("<no configure events>");
7734 gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
7736 g_signal_connect (window,
7738 G_CALLBACK (configure_event_callback),
7741 adjustment = gtk_adjustment_new (10.0, -2000.0, 2000.0, 1.0, 5.0, 0.0);
7742 spin = gtk_spin_button_new (adjustment, 0, 0);
7744 gtk_box_pack_start (GTK_BOX (vbox), spin, FALSE, FALSE, 0);
7746 g_object_set_data (G_OBJECT (control_window), "spin1", spin);
7748 adjustment = gtk_adjustment_new (10.0, -2000.0, 2000.0, 1.0, 5.0, 0.0);
7749 spin = gtk_spin_button_new (adjustment, 0, 0);
7751 gtk_box_pack_start (GTK_BOX (vbox), spin, FALSE, FALSE, 0);
7753 g_object_set_data (G_OBJECT (control_window), "spin2", spin);
7755 entry = gtk_entry_new ();
7756 gtk_box_pack_start (GTK_BOX (vbox), entry, FALSE, FALSE, 0);
7758 g_signal_connect (entry, "changed",
7759 G_CALLBACK (set_geometry_callback),
7762 button = gtk_button_new_with_label ("Show gravity test windows");
7763 g_signal_connect_swapped (button,
7765 G_CALLBACK (do_gravity_test),
7767 gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
7769 button = gtk_button_new_with_label ("Reshow with initial size");
7770 g_signal_connect_object (button,
7772 G_CALLBACK (gtk_window_reshow_with_initial_size),
7775 gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
7777 button = gtk_button_new_with_label ("Queue resize");
7778 g_signal_connect_object (button,
7780 G_CALLBACK (gtk_widget_queue_resize),
7783 gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
7785 button = gtk_button_new_with_label ("Resize");
7786 g_signal_connect (button,
7788 G_CALLBACK (set_size_callback),
7790 gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
7792 button = gtk_button_new_with_label ("Set default size");
7793 g_signal_connect (button,
7795 G_CALLBACK (set_default_size_callback),
7797 gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
7799 button = gtk_button_new_with_label ("Unset default size");
7800 g_signal_connect (button,
7802 G_CALLBACK (unset_default_size_callback),
7804 gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
7806 button = gtk_button_new_with_label ("Set size request");
7807 g_signal_connect (button,
7809 G_CALLBACK (set_size_request_callback),
7811 gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
7813 button = gtk_button_new_with_label ("Unset size request");
7814 g_signal_connect (button,
7816 G_CALLBACK (unset_size_request_callback),
7818 gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
7820 button = gtk_button_new_with_label ("Move");
7821 g_signal_connect (button,
7823 G_CALLBACK (set_location_callback),
7825 gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
7827 button = gtk_button_new_with_label ("Move to current position");
7828 g_signal_connect (button,
7830 G_CALLBACK (move_to_position_callback),
7832 gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
7834 button = gtk_check_button_new_with_label ("Allow resize");
7835 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
7836 g_signal_connect (button,
7838 G_CALLBACK (resizable_callback),
7840 gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
7842 button = gtk_button_new_with_mnemonic ("_Show");
7843 g_signal_connect_object (button,
7845 G_CALLBACK (gtk_widget_show),
7848 gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
7850 button = gtk_button_new_with_mnemonic ("_Hide");
7851 g_signal_connect_object (button,
7853 G_CALLBACK (gtk_widget_hide),
7856 gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
7858 om = gtk_combo_box_text_new ();
7862 static gchar *names[] = {
7863 "GDK_GRAVITY_NORTH_WEST",
7864 "GDK_GRAVITY_NORTH",
7865 "GDK_GRAVITY_NORTH_EAST",
7867 "GDK_GRAVITY_CENTER",
7869 "GDK_GRAVITY_SOUTH_WEST",
7870 "GDK_GRAVITY_SOUTH",
7871 "GDK_GRAVITY_SOUTH_EAST",
7872 "GDK_GRAVITY_STATIC",
7876 g_assert (names[i]);
7877 gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (om), names[i]);
7882 g_signal_connect (om,
7884 G_CALLBACK (gravity_selected),
7887 gtk_box_pack_end (GTK_BOX (vbox), om, FALSE, FALSE, 0);
7890 om = gtk_combo_box_text_new ();
7894 static gchar *names[] = {
7896 "GTK_WIN_POS_CENTER",
7897 "GTK_WIN_POS_MOUSE",
7898 "GTK_WIN_POS_CENTER_ALWAYS",
7899 "GTK_WIN_POS_CENTER_ON_PARENT",
7903 g_assert (names[i]);
7904 gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (om), names[i]);
7909 g_signal_connect (om,
7911 G_CALLBACK (pos_selected),
7914 gtk_box_pack_end (GTK_BOX (vbox), om, FALSE, FALSE, 0);
7916 gtk_widget_show_all (vbox);
7918 return control_window;
7922 create_window_sizing (GtkWidget *widget)
7924 static GtkWidget *window = NULL;
7925 static GtkWidget *target_window = NULL;
7931 target_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
7932 gtk_window_set_screen (GTK_WINDOW (target_window),
7933 gtk_widget_get_screen (widget));
7934 label = gtk_label_new (NULL);
7935 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");
7936 gtk_container_add (GTK_CONTAINER (target_window), label);
7937 gtk_widget_show (label);
7939 g_signal_connect (target_window, "destroy",
7940 G_CALLBACK (gtk_widget_destroyed),
7943 window = window_controls (target_window);
7945 g_signal_connect (window, "destroy",
7946 G_CALLBACK (gtk_widget_destroyed),
7949 gtk_window_set_title (GTK_WINDOW (target_window), "Window to size");
7952 /* don't show target window by default, we want to allow testing
7953 * of behavior on first show.
7956 if (!gtk_widget_get_visible (window))
7957 gtk_widget_show (window);
7959 gtk_widget_destroy (window);
7966 typedef struct _ProgressData {
7969 GtkWidget *block_spin;
7970 GtkWidget *x_align_spin;
7971 GtkWidget *y_align_spin;
7972 GtkWidget *step_spin;
7973 GtkWidget *act_blocks_spin;
7984 progress_timeout (gpointer data)
7986 ProgressData *pdata = data;
7990 if (pdata->activity)
7992 gtk_progress_bar_pulse (GTK_PROGRESS_BAR (pdata->pbar));
7994 text = g_strdup_printf ("%s", "???");
7998 new_val = gtk_progress_bar_get_fraction (GTK_PROGRESS_BAR (pdata->pbar)) + 0.01;
8001 gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR (pdata->pbar), new_val);
8003 text = g_strdup_printf ("%.0f%%", 100 * new_val);
8006 gtk_label_set_text (GTK_LABEL (pdata->label), text);
8013 destroy_progress (GtkWidget *widget,
8014 ProgressData **pdata)
8016 if ((*pdata)->timer)
8018 g_source_remove ((*pdata)->timer);
8019 (*pdata)->timer = 0;
8021 (*pdata)->window = NULL;
8027 progressbar_toggle_orientation (GtkWidget *widget, gpointer data)
8029 ProgressData *pdata;
8032 pdata = (ProgressData *) data;
8034 if (!gtk_widget_get_mapped (widget))
8037 i = gtk_combo_box_get_active (GTK_COMBO_BOX (widget));
8039 if (i == 0 || i == 1)
8040 gtk_orientable_set_orientation (GTK_ORIENTABLE (pdata->pbar), GTK_ORIENTATION_HORIZONTAL);
8042 gtk_orientable_set_orientation (GTK_ORIENTABLE (pdata->pbar), GTK_ORIENTATION_VERTICAL);
8044 if (i == 1 || i == 2)
8045 gtk_progress_bar_set_inverted (GTK_PROGRESS_BAR (pdata->pbar), TRUE);
8047 gtk_progress_bar_set_inverted (GTK_PROGRESS_BAR (pdata->pbar), FALSE);
8051 toggle_show_text (GtkWidget *widget, ProgressData *pdata)
8055 active = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget));
8056 gtk_progress_bar_set_show_text (GTK_PROGRESS_BAR (pdata->pbar), active);
8060 progressbar_toggle_ellipsize (GtkWidget *widget,
8063 ProgressData *pdata = data;
8064 if (gtk_widget_is_drawable (widget))
8066 gint i = gtk_combo_box_get_active (GTK_COMBO_BOX (widget));
8067 gtk_progress_bar_set_ellipsize (GTK_PROGRESS_BAR (pdata->pbar), i);
8072 toggle_activity_mode (GtkWidget *widget, ProgressData *pdata)
8074 pdata->activity = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget));
8078 toggle_running (GtkWidget *widget, ProgressData *pdata)
8080 if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget)))
8082 if (pdata->timer == 0)
8083 pdata->timer = g_timeout_add (100, (GSourceFunc)progress_timeout, pdata);
8087 if (pdata->timer != 0)
8089 g_source_remove (pdata->timer);
8096 entry_changed (GtkWidget *widget, ProgressData *pdata)
8098 gtk_progress_bar_set_text (GTK_PROGRESS_BAR (pdata->pbar),
8099 gtk_entry_get_text (GTK_ENTRY (pdata->entry)));
8103 create_progress_bar (GtkWidget *widget)
8105 GtkWidget *action_area, *content_area;
8114 static ProgressData *pdata = NULL;
8116 static gchar *items1[] =
8124 static char *ellipsize_items[] = {
8125 "None", // PANGO_ELLIPSIZE_NONE,
8126 "Start", // PANGO_ELLIPSIZE_START,
8127 "Middle", // PANGO_ELLIPSIZE_MIDDLE,
8128 "End", // PANGO_ELLIPSIZE_END
8132 pdata = g_new0 (ProgressData, 1);
8136 pdata->window = gtk_dialog_new ();
8138 gtk_window_set_screen (GTK_WINDOW (pdata->window),
8139 gtk_widget_get_screen (widget));
8141 gtk_window_set_resizable (GTK_WINDOW (pdata->window), TRUE);
8143 g_signal_connect (pdata->window, "destroy",
8144 G_CALLBACK (destroy_progress),
8148 content_area = gtk_dialog_get_content_area (GTK_DIALOG (pdata->window));
8149 action_area = gtk_dialog_get_action_area (GTK_DIALOG (pdata->window));
8151 gtk_window_set_title (GTK_WINDOW (pdata->window), "GtkProgressBar");
8152 gtk_container_set_border_width (GTK_CONTAINER (pdata->window), 0);
8154 vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
8155 gtk_container_set_border_width (GTK_CONTAINER (vbox), 10);
8156 gtk_box_pack_start (GTK_BOX (content_area), vbox, FALSE, TRUE, 0);
8158 frame = gtk_frame_new ("Progress");
8159 gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, TRUE, 0);
8161 vbox2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
8162 gtk_container_add (GTK_CONTAINER (frame), vbox2);
8164 pdata->pbar = gtk_progress_bar_new ();
8165 gtk_progress_bar_set_ellipsize (GTK_PROGRESS_BAR (pdata->pbar),
8166 PANGO_ELLIPSIZE_MIDDLE);
8167 gtk_widget_set_halign (pdata->pbar, GTK_ALIGN_CENTER);
8168 gtk_widget_set_valign (pdata->pbar, GTK_ALIGN_CENTER);
8169 gtk_box_pack_start (GTK_BOX (vbox2), pdata->pbar, FALSE, FALSE, 5);
8171 hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 5);
8172 gtk_widget_set_halign (hbox, GTK_ALIGN_CENTER);
8173 gtk_widget_set_valign (hbox, GTK_ALIGN_CENTER);
8174 gtk_box_pack_start (GTK_BOX (vbox2), hbox, FALSE, FALSE, 5);
8175 label = gtk_label_new ("Label updated by user :");
8176 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
8177 pdata->label = gtk_label_new ("");
8178 gtk_box_pack_start (GTK_BOX (hbox), pdata->label, FALSE, TRUE, 0);
8180 frame = gtk_frame_new ("Options");
8181 gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, TRUE, 0);
8183 vbox2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
8184 gtk_container_add (GTK_CONTAINER (frame), vbox2);
8186 grid = gtk_grid_new ();
8187 gtk_grid_set_row_spacing (GTK_GRID (grid), 10);
8188 gtk_grid_set_column_spacing (GTK_GRID (grid), 10);
8189 gtk_box_pack_start (GTK_BOX (vbox2), grid, FALSE, TRUE, 0);
8191 label = gtk_label_new ("Orientation :");
8192 gtk_grid_attach (GTK_GRID (grid), label, 0, 0, 1, 1);
8193 gtk_widget_set_halign (label, GTK_ALIGN_START);
8194 gtk_widget_set_valign (label, GTK_ALIGN_CENTER);
8196 pdata->omenu1 = build_option_menu (items1, 4, 0,
8197 progressbar_toggle_orientation,
8199 gtk_grid_attach (GTK_GRID (grid), pdata->omenu1, 1, 0, 1, 1);
8201 check = gtk_check_button_new_with_label ("Running");
8202 g_signal_connect (check, "toggled",
8203 G_CALLBACK (toggle_running),
8205 gtk_grid_attach (GTK_GRID (grid), check, 0, 1, 2, 1);
8206 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check), TRUE);
8208 check = gtk_check_button_new_with_label ("Show text");
8209 g_signal_connect (check, "clicked",
8210 G_CALLBACK (toggle_show_text),
8212 gtk_grid_attach (GTK_GRID (grid), check, 0, 2, 1, 1);
8214 hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
8215 gtk_grid_attach (GTK_GRID (grid), hbox, 1, 2, 1, 1);
8217 label = gtk_label_new ("Text: ");
8218 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
8220 pdata->entry = gtk_entry_new ();
8221 gtk_widget_set_hexpand (pdata->entry, TRUE);
8222 g_signal_connect (pdata->entry, "changed",
8223 G_CALLBACK (entry_changed),
8225 gtk_box_pack_start (GTK_BOX (hbox), pdata->entry, TRUE, TRUE, 0);
8226 gtk_widget_set_size_request (pdata->entry, 100, -1);
8228 label = gtk_label_new ("Ellipsize text :");
8229 gtk_grid_attach (GTK_GRID (grid), label, 0, 10, 1, 1);
8231 gtk_widget_set_halign (label, GTK_ALIGN_START);
8232 gtk_widget_set_valign (label, GTK_ALIGN_CENTER);
8233 pdata->elmenu = build_option_menu (ellipsize_items,
8234 sizeof (ellipsize_items) / sizeof (ellipsize_items[0]),
8235 2, // PANGO_ELLIPSIZE_MIDDLE
8236 progressbar_toggle_ellipsize,
8238 gtk_grid_attach (GTK_GRID (grid), pdata->elmenu, 1, 10, 1, 1);
8240 check = gtk_check_button_new_with_label ("Activity mode");
8241 g_signal_connect (check, "clicked",
8242 G_CALLBACK (toggle_activity_mode), pdata);
8243 gtk_grid_attach (GTK_GRID (grid), check, 0, 15, 1, 1);
8245 button = gtk_button_new_with_label ("close");
8246 g_signal_connect_swapped (button, "clicked",
8247 G_CALLBACK (gtk_widget_destroy),
8249 gtk_widget_set_can_default (button, TRUE);
8250 gtk_box_pack_start (GTK_BOX (action_area), button, TRUE, TRUE, 0);
8251 gtk_widget_grab_default (button);
8254 if (!gtk_widget_get_visible (pdata->window))
8255 gtk_widget_show_all (pdata->window);
8257 gtk_widget_destroy (pdata->window);
8269 GtkWidget *res_widget;
8273 find_widget (GtkWidget *widget, FindWidgetData *data)
8275 GtkAllocation new_allocation;
8279 gtk_widget_get_allocation (widget, &new_allocation);
8281 if (data->found || !gtk_widget_get_mapped (widget))
8284 /* Note that in the following code, we only count the
8285 * position as being inside a WINDOW widget if it is inside
8286 * widget->window; points that are outside of widget->window
8287 * but within the allocation are not counted. This is consistent
8288 * with the way we highlight drag targets.
8290 if (gtk_widget_get_has_window (widget))
8292 new_allocation.x = 0;
8293 new_allocation.y = 0;
8296 if (gtk_widget_get_parent (widget) && !data->first)
8298 GdkWindow *window = gtk_widget_get_window (widget);
8299 while (window != gtk_widget_get_window (gtk_widget_get_parent (widget)))
8301 gint tx, ty, twidth, theight;
8303 twidth = gdk_window_get_width (window);
8304 theight = gdk_window_get_height (window);
8306 if (new_allocation.x < 0)
8308 new_allocation.width += new_allocation.x;
8309 new_allocation.x = 0;
8311 if (new_allocation.y < 0)
8313 new_allocation.height += new_allocation.y;
8314 new_allocation.y = 0;
8316 if (new_allocation.x + new_allocation.width > twidth)
8317 new_allocation.width = twidth - new_allocation.x;
8318 if (new_allocation.y + new_allocation.height > theight)
8319 new_allocation.height = theight - new_allocation.y;
8321 gdk_window_get_position (window, &tx, &ty);
8322 new_allocation.x += tx;
8324 new_allocation.y += ty;
8327 window = gdk_window_get_parent (window);
8331 if ((data->x >= new_allocation.x) && (data->y >= new_allocation.y) &&
8332 (data->x < new_allocation.x + new_allocation.width) &&
8333 (data->y < new_allocation.y + new_allocation.height))
8335 /* First, check if the drag is in a valid drop site in
8336 * one of our children
8338 if (GTK_IS_CONTAINER (widget))
8340 FindWidgetData new_data = *data;
8342 new_data.x -= x_offset;
8343 new_data.y -= y_offset;
8344 new_data.found = FALSE;
8345 new_data.first = FALSE;
8347 gtk_container_forall (GTK_CONTAINER (widget),
8348 (GtkCallback)find_widget,
8351 data->found = new_data.found;
8353 data->res_widget = new_data.res_widget;
8356 /* If not, and this widget is registered as a drop site, check to
8357 * emit "drag_motion" to check if we are actually in
8363 data->res_widget = widget;
8369 find_widget_at_pointer (GdkDevice *device)
8371 GtkWidget *widget = NULL;
8372 GdkWindow *pointer_window;
8374 FindWidgetData data;
8376 pointer_window = gdk_device_get_window_at_position (device, NULL, NULL);
8380 gpointer widget_ptr;
8382 gdk_window_get_user_data (pointer_window, &widget_ptr);
8383 widget = widget_ptr;
8388 gdk_window_get_device_position (gtk_widget_get_window (widget),
8397 find_widget (widget, &data);
8399 return data.res_widget;
8405 struct PropertiesData {
8413 destroy_properties (GtkWidget *widget,
8414 struct PropertiesData *data)
8418 *data->window = NULL;
8419 data->window = NULL;
8424 g_object_unref (data->cursor);
8425 data->cursor = NULL;
8430 g_signal_handler_disconnect (widget, data->handler);
8438 property_query_event (GtkWidget *widget,
8440 struct PropertiesData *data)
8442 GtkWidget *res_widget = NULL;
8444 if (!data->in_query)
8447 if (event->type == GDK_BUTTON_RELEASE)
8449 gtk_grab_remove (widget);
8450 gdk_device_ungrab (gdk_event_get_device (event), GDK_CURRENT_TIME);
8452 res_widget = find_widget_at_pointer (gdk_event_get_device (event));
8455 g_object_set_data (G_OBJECT (res_widget), "prop-editor-screen",
8456 gtk_widget_get_screen (widget));
8457 create_prop_editor (G_OBJECT (res_widget), 0);
8460 data->in_query = FALSE;
8467 query_properties (GtkButton *button,
8468 struct PropertiesData *data)
8470 GtkWidget *widget = GTK_WIDGET (button);
8471 GdkDisplay *display;
8472 GdkDeviceManager *device_manager;
8475 g_signal_connect (button, "event",
8476 G_CALLBACK (property_query_event), data);
8478 display = gtk_widget_get_display (widget);
8481 data->cursor = gdk_cursor_new_for_display (display, GDK_TARGET);
8483 device_manager = gdk_display_get_device_manager (display);
8484 device = gdk_device_manager_get_client_pointer (device_manager);
8485 gdk_device_grab (device,
8486 gtk_widget_get_window (widget),
8489 GDK_BUTTON_RELEASE_MASK,
8492 gtk_grab_add (widget);
8494 data->in_query = TRUE;
8498 create_properties (GtkWidget *widget)
8500 static GtkWidget *window = NULL;
8504 struct PropertiesData *data;
8506 data = g_new (struct PropertiesData, 1);
8507 data->window = &window;
8508 data->in_query = FALSE;
8509 data->cursor = NULL;
8514 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
8516 gtk_window_set_screen (GTK_WINDOW (window),
8517 gtk_widget_get_screen (widget));
8519 data->handler = g_signal_connect (window, "destroy",
8520 G_CALLBACK (destroy_properties),
8523 gtk_window_set_title (GTK_WINDOW (window), "test properties");
8524 gtk_container_set_border_width (GTK_CONTAINER (window), 10);
8526 vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 1);
8527 gtk_container_add (GTK_CONTAINER (window), vbox);
8529 label = gtk_label_new ("This is just a dumb test to test properties.\nIf you need a generic module, get GLE.");
8530 gtk_box_pack_start (GTK_BOX (vbox), label, TRUE, TRUE, 0);
8532 button = gtk_button_new_with_label ("Query properties");
8533 gtk_box_pack_start (GTK_BOX (vbox), button, TRUE, TRUE, 0);
8534 g_signal_connect (button, "clicked",
8535 G_CALLBACK (query_properties),
8539 if (!gtk_widget_get_visible (window))
8540 gtk_widget_show_all (window);
8542 gtk_widget_destroy (window);
8546 struct SnapshotData {
8547 GtkWidget *toplevel_button;
8551 gboolean is_toplevel;
8556 destroy_snapshot_data (GtkWidget *widget,
8557 struct SnapshotData *data)
8560 *data->window = NULL;
8564 g_object_unref (data->cursor);
8565 data->cursor = NULL;
8570 g_signal_handler_disconnect (widget, data->handler);
8578 snapshot_widget_event (GtkWidget *widget,
8580 struct SnapshotData *data)
8582 GtkWidget *res_widget = NULL;
8584 if (!data->in_query)
8587 if (event->type == GDK_BUTTON_RELEASE)
8589 gtk_grab_remove (widget);
8590 gdk_device_ungrab (gdk_event_get_device (event),
8593 res_widget = find_widget_at_pointer (gdk_event_get_device (event));
8594 if (data->is_toplevel && res_widget)
8595 res_widget = gtk_widget_get_toplevel (res_widget);
8598 cairo_surface_t *surface;
8599 GtkWidget *window, *image;
8604 width = gtk_widget_get_allocated_width (res_widget);
8605 height = gtk_widget_get_allocated_height (res_widget);
8607 surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, width, height);
8609 cr = cairo_create (surface);
8610 gtk_widget_draw (res_widget, cr);
8613 pixbuf = gdk_pixbuf_get_from_surface (surface,
8616 cairo_surface_destroy (surface);
8618 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
8619 image = gtk_image_new_from_pixbuf (pixbuf);
8620 g_object_unref (pixbuf);
8622 gtk_container_add (GTK_CONTAINER (window), image);
8623 gtk_widget_show_all (window);
8626 data->in_query = FALSE;
8633 snapshot_widget (GtkButton *button,
8634 struct SnapshotData *data)
8636 GtkWidget *widget = GTK_WIDGET (button);
8639 device = gtk_get_current_event_device ();
8643 if (gdk_device_get_source (device) == GDK_SOURCE_KEYBOARD)
8644 device = gdk_device_get_associated_device (device);
8646 data->is_toplevel = widget == data->toplevel_button;
8649 data->cursor = gdk_cursor_new_for_display (gtk_widget_get_display (widget),
8652 gdk_device_grab (device,
8653 gtk_widget_get_window (widget),
8654 GDK_OWNERSHIP_APPLICATION,
8656 GDK_BUTTON_RELEASE_MASK,
8660 g_signal_connect (button, "event",
8661 G_CALLBACK (snapshot_widget_event), data);
8663 gtk_grab_add (widget);
8665 data->in_query = TRUE;
8669 create_snapshot (GtkWidget *widget)
8671 static GtkWidget *window = NULL;
8674 struct SnapshotData *data;
8676 data = g_new (struct SnapshotData, 1);
8677 data->window = &window;
8678 data->in_query = FALSE;
8679 data->cursor = NULL;
8684 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
8686 gtk_window_set_screen (GTK_WINDOW (window),
8687 gtk_widget_get_screen (widget));
8689 data->handler = g_signal_connect (window, "destroy",
8690 G_CALLBACK (destroy_snapshot_data),
8693 gtk_window_set_title (GTK_WINDOW (window), "test snapshot");
8694 gtk_container_set_border_width (GTK_CONTAINER (window), 10);
8696 vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 1);
8697 gtk_container_add (GTK_CONTAINER (window), vbox);
8699 button = gtk_button_new_with_label ("Snapshot widget");
8700 gtk_box_pack_start (GTK_BOX (vbox), button, TRUE, TRUE, 0);
8701 g_signal_connect (button, "clicked",
8702 G_CALLBACK (snapshot_widget),
8705 button = gtk_button_new_with_label ("Snapshot toplevel");
8706 data->toplevel_button = button;
8707 gtk_box_pack_start (GTK_BOX (vbox), button, TRUE, TRUE, 0);
8708 g_signal_connect (button, "clicked",
8709 G_CALLBACK (snapshot_widget),
8713 if (!gtk_widget_get_visible (window))
8714 gtk_widget_show_all (window);
8716 gtk_widget_destroy (window);
8725 selection_test_received (GtkWidget *tree_view,
8726 GtkSelectionData *selection_data)
8728 GtkTreeModel *model;
8729 GtkListStore *store;
8733 if (gtk_selection_data_get_length (selection_data) < 0)
8735 g_print ("Selection retrieval failed\n");
8738 if (gtk_selection_data_get_data_type (selection_data) != GDK_SELECTION_TYPE_ATOM)
8740 g_print ("Selection \"TARGETS\" was not returned as atoms!\n");
8744 /* Clear out any current list items */
8746 model = gtk_tree_view_get_model (GTK_TREE_VIEW (tree_view));
8747 store = GTK_LIST_STORE (model);
8748 gtk_list_store_clear (store);
8750 /* Add new items to list */
8752 gtk_selection_data_get_targets (selection_data,
8755 for (i = 0; i < l; i++)
8760 name = gdk_atom_name (atoms[i]);
8763 gtk_list_store_insert_with_values (store, &iter, i, 0, name, -1);
8767 gtk_list_store_insert_with_values (store, &iter, i, 0, "(bad atom)", -1);
8774 selection_test_get_targets (GtkWidget *widget, GtkWidget *tree_view)
8776 static GdkAtom targets_atom = GDK_NONE;
8778 if (targets_atom == GDK_NONE)
8779 targets_atom = gdk_atom_intern ("TARGETS", FALSE);
8781 gtk_selection_convert (tree_view, GDK_SELECTION_PRIMARY, targets_atom,
8786 create_selection_test (GtkWidget *widget)
8788 static GtkWidget *window = NULL;
8789 GtkWidget *action_area, *content_area;
8792 GtkWidget *scrolled_win;
8793 GtkListStore* store;
8794 GtkWidget *tree_view;
8795 GtkTreeViewColumn *column;
8796 GtkCellRenderer *renderer;
8801 window = gtk_dialog_new ();
8803 gtk_window_set_screen (GTK_WINDOW (window),
8804 gtk_widget_get_screen (widget));
8806 g_signal_connect (window, "destroy",
8807 G_CALLBACK (gtk_widget_destroyed),
8810 content_area = gtk_dialog_get_content_area (GTK_DIALOG (window));
8811 action_area = gtk_dialog_get_action_area (GTK_DIALOG (window));
8813 gtk_window_set_title (GTK_WINDOW (window), "Selection Test");
8814 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
8816 /* Create the list */
8818 vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
8819 gtk_container_set_border_width (GTK_CONTAINER (vbox), 10);
8820 gtk_box_pack_start (GTK_BOX (content_area), vbox, TRUE, TRUE, 0);
8822 label = gtk_label_new ("Gets available targets for current selection");
8823 gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
8825 scrolled_win = gtk_scrolled_window_new (NULL, NULL);
8826 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
8827 GTK_POLICY_AUTOMATIC,
8828 GTK_POLICY_AUTOMATIC);
8829 gtk_box_pack_start (GTK_BOX (vbox), scrolled_win, TRUE, TRUE, 0);
8830 gtk_widget_set_size_request (scrolled_win, 100, 200);
8832 store = gtk_list_store_new (1, G_TYPE_STRING);
8833 tree_view = gtk_tree_view_new_with_model (GTK_TREE_MODEL (store));
8834 gtk_container_add (GTK_CONTAINER (scrolled_win), tree_view);
8836 renderer = gtk_cell_renderer_text_new ();
8837 column = gtk_tree_view_column_new_with_attributes ("Target", renderer,
8839 gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), column);
8841 g_signal_connect (tree_view, "selection_received",
8842 G_CALLBACK (selection_test_received), NULL);
8844 /* .. And create some buttons */
8845 button = gtk_button_new_with_label ("Get Targets");
8846 gtk_box_pack_start (GTK_BOX (action_area), button, TRUE, TRUE, 0);
8848 g_signal_connect (button, "clicked",
8849 G_CALLBACK (selection_test_get_targets), tree_view);
8851 button = gtk_button_new_with_label ("Quit");
8852 gtk_box_pack_start (GTK_BOX (action_area), button, TRUE, TRUE, 0);
8854 g_signal_connect_swapped (button, "clicked",
8855 G_CALLBACK (gtk_widget_destroy),
8859 if (!gtk_widget_get_visible (window))
8860 gtk_widget_show_all (window);
8862 gtk_widget_destroy (window);
8869 static int scroll_test_pos = 0.0;
8872 scroll_test_draw (GtkWidget *widget,
8874 GtkAdjustment *adjustment)
8877 gint imin, imax, jmin, jmax;
8880 gdk_cairo_get_clip_rectangle (cr, &clip);
8882 imin = (clip.x) / 10;
8883 imax = (clip.x + clip.width + 9) / 10;
8885 jmin = ((int)gtk_adjustment_get_value (adjustment) + clip.y) / 10;
8886 jmax = ((int)gtk_adjustment_get_value (adjustment) + clip.y + clip.height + 9) / 10;
8888 for (i=imin; i<imax; i++)
8889 for (j=jmin; j<jmax; j++)
8891 cairo_rectangle (cr, 10*i, 10*j - (int)gtk_adjustment_get_value (adjustment), 1+i%10, 1+j%10);
8899 scroll_test_scroll (GtkWidget *widget, GdkEventScroll *event,
8900 GtkAdjustment *adjustment)
8902 gdouble new_value = gtk_adjustment_get_value (adjustment) + ((event->direction == GDK_SCROLL_UP) ?
8903 -gtk_adjustment_get_page_increment (adjustment) / 2:
8904 gtk_adjustment_get_page_increment (adjustment) / 2);
8905 new_value = CLAMP (new_value, gtk_adjustment_get_lower (adjustment), gtk_adjustment_get_upper (adjustment) - gtk_adjustment_get_page_size (adjustment));
8906 gtk_adjustment_set_value (adjustment, new_value);
8912 scroll_test_configure (GtkWidget *widget, GdkEventConfigure *event,
8913 GtkAdjustment *adjustment)
8915 GtkAllocation allocation;
8917 gtk_widget_get_allocation (widget, &allocation);
8918 gtk_adjustment_configure (adjustment,
8919 gtk_adjustment_get_value (adjustment),
8920 gtk_adjustment_get_lower (adjustment),
8921 gtk_adjustment_get_upper (adjustment),
8922 0.1 * allocation.height,
8923 0.9 * allocation.height,
8928 scroll_test_adjustment_changed (GtkAdjustment *adjustment, GtkWidget *widget)
8933 dy = scroll_test_pos - (int)gtk_adjustment_get_value (adjustment);
8934 scroll_test_pos = gtk_adjustment_get_value (adjustment);
8936 if (!gtk_widget_is_drawable (widget))
8939 window = gtk_widget_get_window (widget);
8940 gdk_window_scroll (window, 0, dy);
8941 gdk_window_process_updates (window, FALSE);
8946 create_scroll_test (GtkWidget *widget)
8948 static GtkWidget *window = NULL;
8949 GtkWidget *action_area, *content_area;
8951 GtkWidget *drawing_area;
8952 GtkWidget *scrollbar;
8954 GtkAdjustment *adjustment;
8955 GdkGeometry geometry;
8956 GdkWindowHints geometry_mask;
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), "Scroll Test");
8973 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
8975 hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
8976 gtk_box_pack_start (GTK_BOX (content_area), hbox, TRUE, TRUE, 0);
8977 gtk_widget_show (hbox);
8979 drawing_area = gtk_drawing_area_new ();
8980 gtk_widget_set_size_request (drawing_area, 200, 200);
8981 gtk_box_pack_start (GTK_BOX (hbox), drawing_area, TRUE, TRUE, 0);
8982 gtk_widget_show (drawing_area);
8984 gtk_widget_set_events (drawing_area, GDK_EXPOSURE_MASK | GDK_SCROLL_MASK);
8986 adjustment = gtk_adjustment_new (0.0, 0.0, 1000.0, 1.0, 180.0, 200.0);
8987 scroll_test_pos = 0.0;
8989 scrollbar = gtk_scrollbar_new (GTK_ORIENTATION_VERTICAL, adjustment);
8990 gtk_box_pack_start (GTK_BOX (hbox), scrollbar, FALSE, FALSE, 0);
8991 gtk_widget_show (scrollbar);
8993 g_signal_connect (drawing_area, "draw",
8994 G_CALLBACK (scroll_test_draw), adjustment);
8995 g_signal_connect (drawing_area, "configure_event",
8996 G_CALLBACK (scroll_test_configure), adjustment);
8997 g_signal_connect (drawing_area, "scroll_event",
8998 G_CALLBACK (scroll_test_scroll), adjustment);
9000 g_signal_connect (adjustment, "value_changed",
9001 G_CALLBACK (scroll_test_adjustment_changed),
9004 /* .. And create some buttons */
9006 button = gtk_button_new_with_label ("Quit");
9007 gtk_box_pack_start (GTK_BOX (action_area), button, TRUE, TRUE, 0);
9009 g_signal_connect_swapped (button, "clicked",
9010 G_CALLBACK (gtk_widget_destroy),
9012 gtk_widget_show (button);
9014 /* Set up gridded geometry */
9016 geometry_mask = GDK_HINT_MIN_SIZE |
9017 GDK_HINT_BASE_SIZE |
9018 GDK_HINT_RESIZE_INC;
9020 geometry.min_width = 20;
9021 geometry.min_height = 20;
9022 geometry.base_width = 0;
9023 geometry.base_height = 0;
9024 geometry.width_inc = 10;
9025 geometry.height_inc = 10;
9027 gtk_window_set_geometry_hints (GTK_WINDOW (window),
9028 drawing_area, &geometry, geometry_mask);
9031 if (!gtk_widget_get_visible (window))
9032 gtk_widget_show (window);
9034 gtk_widget_destroy (window);
9041 static int timer = 0;
9044 timeout_test (GtkWidget *label)
9046 static int count = 0;
9047 static char buffer[32];
9049 sprintf (buffer, "count: %d", ++count);
9050 gtk_label_set_text (GTK_LABEL (label), buffer);
9056 start_timeout_test (GtkWidget *widget,
9061 timer = g_timeout_add (100, (GSourceFunc)timeout_test, label);
9066 stop_timeout_test (GtkWidget *widget,
9071 g_source_remove (timer);
9077 destroy_timeout_test (GtkWidget *widget,
9080 stop_timeout_test (NULL, NULL);
9086 create_timeout_test (GtkWidget *widget)
9088 static GtkWidget *window = NULL;
9089 GtkWidget *action_area, *content_area;
9095 window = gtk_dialog_new ();
9097 gtk_window_set_screen (GTK_WINDOW (window),
9098 gtk_widget_get_screen (widget));
9100 g_signal_connect (window, "destroy",
9101 G_CALLBACK (destroy_timeout_test),
9104 content_area = gtk_dialog_get_content_area (GTK_DIALOG (window));
9105 action_area = gtk_dialog_get_content_area (GTK_DIALOG (window));
9107 gtk_window_set_title (GTK_WINDOW (window), "Timeout Test");
9108 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
9110 label = gtk_label_new ("count: 0");
9111 g_object_set (label, "margin", 10, NULL);
9112 gtk_box_pack_start (GTK_BOX (content_area), label, TRUE, TRUE, 0);
9113 gtk_widget_show (label);
9115 button = gtk_button_new_with_label ("close");
9116 g_signal_connect_swapped (button, "clicked",
9117 G_CALLBACK (gtk_widget_destroy),
9119 gtk_widget_set_can_default (button, TRUE);
9120 gtk_box_pack_start (GTK_BOX (action_area), button, TRUE, TRUE, 0);
9121 gtk_widget_grab_default (button);
9122 gtk_widget_show (button);
9124 button = gtk_button_new_with_label ("start");
9125 g_signal_connect (button, "clicked",
9126 G_CALLBACK(start_timeout_test),
9128 gtk_widget_set_can_default (button, TRUE);
9129 gtk_box_pack_start (GTK_BOX (action_area), button, TRUE, TRUE, 0);
9130 gtk_widget_show (button);
9132 button = gtk_button_new_with_label ("stop");
9133 g_signal_connect (button, "clicked",
9134 G_CALLBACK (stop_timeout_test),
9136 gtk_widget_set_can_default (button, TRUE);
9137 gtk_box_pack_start (GTK_BOX (action_area), button, TRUE, TRUE, 0);
9138 gtk_widget_show (button);
9141 if (!gtk_widget_get_visible (window))
9142 gtk_widget_show (window);
9144 gtk_widget_destroy (window);
9151 static int idle_id = 0;
9154 idle_test (GtkWidget *label)
9156 static int count = 0;
9157 static char buffer[32];
9159 sprintf (buffer, "count: %d", ++count);
9160 gtk_label_set_text (GTK_LABEL (label), buffer);
9162 return G_SOURCE_CONTINUE;
9166 start_idle_test (GtkWidget *widget,
9171 idle_id = g_idle_add ((GSourceFunc) idle_test, label);
9176 stop_idle_test (GtkWidget *widget,
9181 g_source_remove (idle_id);
9187 destroy_idle_test (GtkWidget *widget,
9190 stop_idle_test (NULL, NULL);
9196 toggle_idle_container (GObject *button,
9197 GtkContainer *container)
9199 gtk_container_set_resize_mode (container, GPOINTER_TO_INT (g_object_get_data (button, "user_data")));
9203 create_idle_test (GtkWidget *widget)
9205 static GtkWidget *window = NULL;
9208 GtkWidget *container;
9212 GtkWidget *action_area, *content_area;
9217 window = gtk_dialog_new ();
9219 gtk_window_set_screen (GTK_WINDOW (window),
9220 gtk_widget_get_screen (widget));
9222 g_signal_connect (window, "destroy",
9223 G_CALLBACK (destroy_idle_test),
9226 content_area = gtk_dialog_get_content_area (GTK_DIALOG (window));
9227 action_area = gtk_dialog_get_action_area (GTK_DIALOG (window));
9229 gtk_window_set_title (GTK_WINDOW (window), "Idle Test");
9230 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
9232 label = gtk_label_new ("count: 0");
9233 g_object_set (label, "margin", 10, NULL);
9234 gtk_widget_show (label);
9237 g_object_new (GTK_TYPE_BOX,
9239 /* "GtkContainer::child", g_object_new (GTK_TYPE_HBOX,
9240 * "GtkWidget::visible", TRUE,
9245 gtk_box_pack_start (GTK_BOX (content_area), container, TRUE, TRUE, 0);
9248 g_object_new (GTK_TYPE_FRAME,
9250 "label", "Label Container",
9252 "parent", content_area,
9255 g_object_new (GTK_TYPE_BOX,
9258 "orientation", GTK_ORIENTATION_VERTICAL,
9261 g_object_connect (g_object_new (GTK_TYPE_RADIO_BUTTON,
9262 "label", "Resize-Parent",
9263 "user_data", (void*)GTK_RESIZE_PARENT,
9267 "signal::clicked", toggle_idle_container, container,
9269 button = g_object_new (GTK_TYPE_RADIO_BUTTON,
9270 "label", "Resize-Queue",
9271 "user_data", (void*)GTK_RESIZE_QUEUE,
9276 g_object_connect (button,
9277 "signal::clicked", toggle_idle_container, container,
9279 button2 = g_object_new (GTK_TYPE_RADIO_BUTTON,
9280 "label", "Resize-Immediate",
9281 "user_data", (void*)GTK_RESIZE_IMMEDIATE,
9283 g_object_connect (button2,
9284 "signal::clicked", toggle_idle_container, container,
9286 g_object_set (button2,
9292 button = gtk_button_new_with_label ("close");
9293 g_signal_connect_swapped (button, "clicked",
9294 G_CALLBACK (gtk_widget_destroy),
9296 gtk_widget_set_can_default (button, TRUE);
9297 gtk_box_pack_start (GTK_BOX (action_area), button, TRUE, TRUE, 0);
9298 gtk_widget_grab_default (button);
9299 gtk_widget_show (button);
9301 button = gtk_button_new_with_label ("start");
9302 g_signal_connect (button, "clicked",
9303 G_CALLBACK (start_idle_test),
9305 gtk_widget_set_can_default (button, TRUE);
9306 gtk_box_pack_start (GTK_BOX (action_area), button, TRUE, TRUE, 0);
9307 gtk_widget_show (button);
9309 button = gtk_button_new_with_label ("stop");
9310 g_signal_connect (button, "clicked",
9311 G_CALLBACK (stop_idle_test),
9313 gtk_widget_set_can_default (button, TRUE);
9314 gtk_box_pack_start (GTK_BOX (action_area), button, TRUE, TRUE, 0);
9315 gtk_widget_show (button);
9318 if (!gtk_widget_get_visible (window))
9319 gtk_widget_show (window);
9321 gtk_widget_destroy (window);
9329 create_rc_file (GtkWidget *widget)
9331 static GtkWidget *window = NULL;
9332 GtkWidget *action_area, *content_area;
9340 window = gtk_dialog_new ();
9342 gtk_window_set_screen (GTK_WINDOW (window),
9343 gtk_widget_get_screen (widget));
9345 g_signal_connect (window, "destroy",
9346 G_CALLBACK (gtk_widget_destroyed),
9349 content_area = gtk_dialog_get_content_area (GTK_DIALOG (window));
9350 action_area = gtk_dialog_get_action_area (GTK_DIALOG (window));
9352 frame = gtk_aspect_frame_new ("Testing RC file prioritization", 0.5, 0.5, 0.0, TRUE);
9353 gtk_box_pack_start (GTK_BOX (content_area), frame, FALSE, FALSE, 0);
9355 vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
9356 gtk_container_add (GTK_CONTAINER (frame), vbox);
9358 label = gtk_label_new ("This label should be red");
9359 gtk_widget_set_name (label, "testgtk-red-label");
9360 gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
9362 label = gtk_label_new ("This label should be green");
9363 gtk_widget_set_name (label, "testgtk-green-label");
9364 gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
9366 label = gtk_label_new ("This label should be blue");
9367 gtk_widget_set_name (label, "testgtk-blue-label");
9368 gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
9370 gtk_window_set_title (GTK_WINDOW (window), "Reload Rc file");
9371 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
9373 button = gtk_button_new_with_label ("Reload");
9374 g_signal_connect_swapped (button, "clicked",
9375 G_CALLBACK (gtk_style_context_reset_widgets),
9376 gtk_widget_get_screen (button));
9377 gtk_widget_set_can_default (button, TRUE);
9378 gtk_box_pack_start (GTK_BOX (action_area), button, TRUE, TRUE, 0);
9379 gtk_widget_grab_default (button);
9381 button = gtk_button_new_with_label ("Close");
9382 g_signal_connect_swapped (button, "clicked",
9383 G_CALLBACK (gtk_widget_destroy),
9385 gtk_widget_set_can_default (button, TRUE);
9386 gtk_box_pack_start (GTK_BOX (action_area), button, TRUE, TRUE, 0);
9389 if (!gtk_widget_get_visible (window))
9390 gtk_widget_show_all (window);
9392 gtk_widget_destroy (window);
9396 * Test of recursive mainloop
9400 mainloop_destroyed (GtkWidget *w, GtkWidget **window)
9407 create_mainloop (GtkWidget *widget)
9409 static GtkWidget *window = NULL;
9410 GtkWidget *action_area, *content_area;
9416 window = gtk_dialog_new ();
9418 gtk_window_set_screen (GTK_WINDOW (window),
9419 gtk_widget_get_screen (widget));
9421 gtk_window_set_title (GTK_WINDOW (window), "Test Main Loop");
9423 g_signal_connect (window, "destroy",
9424 G_CALLBACK (mainloop_destroyed),
9427 content_area = gtk_dialog_get_content_area (GTK_DIALOG (window));
9428 action_area = gtk_dialog_get_action_area (GTK_DIALOG (window));
9430 label = gtk_label_new ("In recursive main loop...");
9431 g_object_set (label, "margin", 20, NULL);
9433 gtk_box_pack_start (GTK_BOX (content_area), label, TRUE, TRUE, 0);
9434 gtk_widget_show (label);
9436 button = gtk_button_new_with_label ("Leave");
9437 gtk_box_pack_start (GTK_BOX (action_area), button, FALSE, TRUE, 0);
9439 g_signal_connect_swapped (button, "clicked",
9440 G_CALLBACK (gtk_widget_destroy),
9443 gtk_widget_set_can_default (button, TRUE);
9444 gtk_widget_grab_default (button);
9446 gtk_widget_show (button);
9449 if (!gtk_widget_get_visible (window))
9451 gtk_widget_show (window);
9453 g_print ("create_mainloop: start\n");
9455 g_print ("create_mainloop: done\n");
9458 gtk_widget_destroy (window);
9462 layout_draw_handler (GtkWidget *widget, cairo_t *cr)
9465 GdkWindow *bin_window;
9468 gint imin, imax, jmin, jmax;
9470 layout = GTK_LAYOUT (widget);
9471 bin_window = gtk_layout_get_bin_window (layout);
9473 if (!gtk_cairo_should_draw_window (cr, bin_window))
9476 gdk_window_get_position (bin_window, &x, &y);
9477 cairo_translate (cr, x, y);
9479 gdk_cairo_get_clip_rectangle (cr, &clip);
9481 imin = (clip.x) / 10;
9482 imax = (clip.x + clip.width + 9) / 10;
9484 jmin = (clip.y) / 10;
9485 jmax = (clip.y + clip.height + 9) / 10;
9487 for (i=imin; i<imax; i++)
9488 for (j=jmin; j<jmax; j++)
9490 cairo_rectangle (cr,
9499 void create_layout (GtkWidget *widget)
9501 GtkAdjustment *hadjustment, *vadjustment;
9503 static GtkWidget *window = NULL;
9504 GtkWidget *layout_widget;
9505 GtkWidget *scrolledwindow;
9514 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
9515 gtk_window_set_screen (GTK_WINDOW (window),
9516 gtk_widget_get_screen (widget));
9518 g_signal_connect (window, "destroy",
9519 G_CALLBACK (gtk_widget_destroyed),
9522 gtk_window_set_title (GTK_WINDOW (window), "Layout");
9523 gtk_widget_set_size_request (window, 200, 200);
9525 scrolledwindow = gtk_scrolled_window_new (NULL, NULL);
9526 gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolledwindow),
9528 gtk_scrolled_window_set_placement (GTK_SCROLLED_WINDOW (scrolledwindow),
9529 GTK_CORNER_TOP_RIGHT);
9531 gtk_container_add (GTK_CONTAINER (window), scrolledwindow);
9533 layout_widget = gtk_layout_new (NULL, NULL);
9534 layout = GTK_LAYOUT (layout_widget);
9535 gtk_container_add (GTK_CONTAINER (scrolledwindow), layout_widget);
9537 /* We set step sizes here since GtkLayout does not set
9540 hadjustment = gtk_scrollable_get_hadjustment (GTK_SCROLLABLE (layout));
9541 vadjustment = gtk_scrollable_get_vadjustment (GTK_SCROLLABLE (layout));
9542 gtk_adjustment_set_step_increment (hadjustment, 10.0);
9543 gtk_adjustment_set_step_increment (vadjustment, 10.0);
9544 gtk_scrollable_set_hadjustment (GTK_SCROLLABLE (layout), hadjustment);
9545 gtk_scrollable_set_vadjustment (GTK_SCROLLABLE (layout), vadjustment);
9547 gtk_widget_set_events (layout_widget, GDK_EXPOSURE_MASK);
9548 g_signal_connect (layout, "draw",
9549 G_CALLBACK (layout_draw_handler), NULL);
9551 gtk_layout_set_size (layout, 1600, 128000);
9553 for (i=0 ; i < 16 ; i++)
9554 for (j=0 ; j < 16 ; j++)
9556 sprintf(buf, "Button %d, %d", i, j);
9558 button = gtk_button_new_with_label (buf);
9560 button = gtk_label_new (buf);
9562 gtk_layout_put (layout, button, j*100, i*100);
9565 for (i=16; i < 1280; i++)
9567 sprintf(buf, "Button %d, %d", i, 0);
9569 button = gtk_button_new_with_label (buf);
9571 button = gtk_label_new (buf);
9573 gtk_layout_put (layout, button, 0, i*100);
9577 if (!gtk_widget_get_visible (window))
9578 gtk_widget_show_all (window);
9580 gtk_widget_destroy (window);
9584 /* FIXME: need to completely redo this for GtkStyleContext */
9586 create_styles (GtkWidget *widget)
9588 static GtkWidget *window = NULL;
9589 GtkWidget *content_area, *action_area;
9594 static GdkRGBA red = { 1,0,0,1 };
9595 static GdkRGBA green = { 0,1,0,1 };
9596 static GdkRGBA blue = { 0,0,1,1 };
9597 static GdkRGBA yellow = { 1,1,0,1 };
9598 static GdkRGBA cyan = { 0,1,1,1 };
9599 PangoFontDescription *font_desc;
9601 GtkRcStyle *rc_style;
9605 window = gtk_dialog_new ();
9606 gtk_window_set_screen (GTK_WINDOW (window),
9607 gtk_widget_get_screen (widget));
9609 g_signal_connect (window, "destroy",
9610 G_CALLBACK (gtk_widget_destroyed),
9613 content_area = gtk_dialog_get_content_area (GTK_DIALOG (window));
9614 action_area = gtk_dialog_get_action_area (GTK_DIALOG (window));
9616 button = gtk_button_new_with_label ("Close");
9617 g_signal_connect_swapped (button, "clicked",
9618 G_CALLBACK (gtk_widget_destroy),
9620 gtk_widget_set_can_default (button, TRUE);
9621 gtk_box_pack_start (GTK_BOX (action_area), button, TRUE, TRUE, 0);
9622 gtk_widget_show (button);
9624 vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
9625 gtk_container_set_border_width (GTK_CONTAINER (vbox), 10);
9626 gtk_box_pack_start (GTK_BOX (content_area), vbox, FALSE, FALSE, 0);
9628 label = gtk_label_new ("Font:");
9629 gtk_widget_set_halign (label, GTK_ALIGN_START);
9630 gtk_widget_set_valign (label, GTK_ALIGN_CENTER);
9631 gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
9633 font_desc = pango_font_description_from_string ("Helvetica,Sans Oblique 18");
9635 button = gtk_button_new_with_label ("Some Text");
9636 gtk_widget_override_font (gtk_bin_get_child (GTK_BIN (button)), font_desc);
9637 gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
9639 label = gtk_label_new ("Foreground:");
9640 gtk_widget_set_halign (label, GTK_ALIGN_START);
9641 gtk_widget_set_valign (label, GTK_ALIGN_CENTER);
9642 gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
9644 button = gtk_button_new_with_label ("Some Text");
9645 gtk_widget_override_color (gtk_bin_get_child (GTK_BIN (button)), 0, &red);
9646 gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
9648 label = gtk_label_new ("Background:");
9649 gtk_widget_set_halign (label, GTK_ALIGN_START);
9650 gtk_widget_set_valign (label, GTK_ALIGN_CENTER);
9651 gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
9653 button = gtk_button_new_with_label ("Some Text");
9654 gtk_widget_override_background_color (button, 0, &green);
9655 gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
9657 label = gtk_label_new ("Text:");
9658 gtk_widget_set_halign (label, GTK_ALIGN_START);
9659 gtk_widget_set_valign (label, GTK_ALIGN_CENTER);
9660 gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
9662 entry = gtk_entry_new ();
9663 gtk_entry_set_text (GTK_ENTRY (entry), "Some Text");
9664 gtk_widget_override_color (entry, 0, &blue);
9665 gtk_box_pack_start (GTK_BOX (vbox), entry, FALSE, FALSE, 0);
9667 label = gtk_label_new ("Base:");
9668 gtk_widget_set_halign (label, GTK_ALIGN_START);
9669 gtk_widget_set_valign (label, GTK_ALIGN_CENTER);
9670 gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
9672 entry = gtk_entry_new ();
9673 gtk_entry_set_text (GTK_ENTRY (entry), "Some Text");
9674 gtk_widget_override_background_color (entry, 0, &yellow);
9675 gtk_box_pack_start (GTK_BOX (vbox), entry, FALSE, FALSE, 0);
9677 label = gtk_label_new ("Cursor:");
9678 gtk_widget_set_halign (label, GTK_ALIGN_START);
9679 gtk_widget_set_valign (label, GTK_ALIGN_CENTER);
9680 gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
9682 entry = gtk_entry_new ();
9683 gtk_entry_set_text (GTK_ENTRY (entry), "Some Text");
9684 gtk_widget_modify_cursor (entry, &red, &red);
9685 gtk_box_pack_start (GTK_BOX (vbox), entry, FALSE, FALSE, 0);
9687 label = gtk_label_new ("Multiple:");
9688 gtk_widget_set_halign (label, GTK_ALIGN_START);
9689 gtk_widget_set_valign (label, GTK_ALIGN_CENTER);
9690 gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
9692 button = gtk_button_new_with_label ("Some Text");
9694 rc_style = gtk_rc_style_new ();
9696 rc_style->font_desc = pango_font_description_copy (font_desc);
9697 rc_style->color_flags[GTK_STATE_NORMAL] = GTK_RC_FG | GTK_RC_BG;
9698 rc_style->color_flags[GTK_STATE_PRELIGHT] = GTK_RC_FG | GTK_RC_BG;
9699 rc_style->color_flags[GTK_STATE_ACTIVE] = GTK_RC_FG | GTK_RC_BG;
9700 rc_style->fg[GTK_STATE_NORMAL] = yellow;
9701 rc_style->bg[GTK_STATE_NORMAL] = blue;
9702 rc_style->fg[GTK_STATE_PRELIGHT] = blue;
9703 rc_style->bg[GTK_STATE_PRELIGHT] = yellow;
9704 rc_style->fg[GTK_STATE_ACTIVE] = red;
9705 rc_style->bg[GTK_STATE_ACTIVE] = cyan;
9706 rc_style->xthickness = 5;
9707 rc_style->ythickness = 5;
9709 gtk_widget_modify_style (button, rc_style);
9710 gtk_widget_modify_style (gtk_bin_get_child (GTK_BIN (button)), rc_style);
9712 g_object_unref (rc_style);
9714 gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
9717 if (!gtk_widget_get_visible (window))
9718 gtk_widget_show_all (window);
9720 gtk_widget_destroy (window);
9725 * Main Window and Exit
9729 do_exit (GtkWidget *widget, GtkWidget *window)
9731 gtk_widget_destroy (window);
9737 void (*func) (GtkWidget *widget);
9738 gboolean do_not_benchmark;
9741 { "alpha window", create_alpha_window },
9742 { "alpha widget", create_alpha_widgets },
9743 { "big windows", create_big_windows },
9744 { "button box", create_button_box },
9745 { "buttons", create_buttons },
9746 { "check buttons", create_check_buttons },
9747 { "color selection", create_color_selection },
9748 { "composited window", create_composited_window },
9749 { "cursors", create_cursors },
9750 { "dialog", create_dialog },
9751 { "display & screen", create_display_screen, TRUE },
9752 { "entry", create_entry },
9753 { "event box", create_event_box },
9754 { "event watcher", create_event_watcher },
9755 { "expander", create_expander },
9756 { "flipping", create_flipping },
9757 { "focus", create_focus },
9758 { "font selection", create_font_selection },
9759 { "image", create_image },
9760 { "key lookup", create_key_lookup },
9761 { "labels", create_labels },
9762 { "layout", create_layout },
9763 { "menus", create_menus },
9764 { "message dialog", create_message_dialog },
9765 { "modal window", create_modal_window, TRUE },
9766 { "notebook", create_notebook },
9767 { "panes", create_panes },
9768 { "paned keyboard", create_paned_keyboard_navigation },
9769 { "pixbuf", create_pixbuf },
9770 { "progress bar", create_progress_bar },
9771 { "properties", create_properties },
9772 { "radio buttons", create_radio_buttons },
9773 { "range controls", create_range_controls },
9774 { "rc file", create_rc_file },
9775 { "reparent", create_reparent },
9776 { "resize grips", create_resize_grips },
9777 { "rotated label", create_rotated_label },
9778 { "rotated text", create_rotated_text },
9779 { "saved position", create_saved_position },
9780 { "scrolled windows", create_scrolled_windows },
9781 { "settings", create_settings },
9782 { "shapes", create_shapes },
9783 { "size groups", create_size_groups },
9784 { "snapshot", create_snapshot },
9785 { "spinbutton", create_spins },
9786 { "statusbar", create_statusbar },
9788 { "styles", create_styles },
9790 { "test idle", create_idle_test },
9791 { "test mainloop", create_mainloop, TRUE },
9792 { "test scrolling", create_scroll_test },
9793 { "test selection", create_selection_test },
9794 { "test timeout", create_timeout_test },
9795 { "toggle buttons", create_toggle_buttons },
9796 { "toolbar", create_toolbar },
9797 { "tooltips", create_tooltips },
9798 { "WM hints", create_wmhints },
9799 { "window sizing", create_window_sizing },
9800 { "window states", create_window_states }
9802 int nbuttons = sizeof (buttons) / sizeof (buttons[0]);
9805 create_main_window (void)
9810 GtkWidget *scrolled_window;
9814 GtkWidget *separator;
9815 GdkGeometry geometry;
9818 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
9819 gtk_widget_set_name (window, "main_window");
9820 gtk_window_move (GTK_WINDOW (window), 50, 20);
9821 gtk_window_set_default_size (GTK_WINDOW (window), -1, 400);
9823 geometry.min_width = -1;
9824 geometry.min_height = -1;
9825 geometry.max_width = -1;
9826 geometry.max_height = G_MAXSHORT;
9827 gtk_window_set_geometry_hints (GTK_WINDOW (window), NULL,
9829 GDK_HINT_MIN_SIZE | GDK_HINT_MAX_SIZE);
9831 g_signal_connect (window, "destroy",
9832 G_CALLBACK (gtk_main_quit),
9834 g_signal_connect (window, "delete-event",
9835 G_CALLBACK (gtk_false),
9838 box1 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
9839 gtk_container_add (GTK_CONTAINER (window), box1);
9841 if (gtk_micro_version > 0)
9844 gtk_get_major_version (),
9845 gtk_get_minor_version (),
9846 gtk_get_micro_version ());
9850 gtk_get_major_version (),
9851 gtk_get_minor_version ());
9853 label = gtk_label_new (buffer);
9854 gtk_box_pack_start (GTK_BOX (box1), label, FALSE, FALSE, 0);
9855 gtk_widget_set_name (label, "testgtk-version-label");
9857 scrolled_window = gtk_scrolled_window_new (NULL, NULL);
9858 gtk_container_set_border_width (GTK_CONTAINER (scrolled_window), 10);
9859 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
9861 GTK_POLICY_AUTOMATIC);
9862 gtk_box_pack_start (GTK_BOX (box1), scrolled_window, TRUE, TRUE, 0);
9864 box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
9865 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
9866 gtk_container_add (GTK_CONTAINER (scrolled_window), box2);
9867 gtk_container_set_focus_vadjustment (GTK_CONTAINER (box2),
9868 gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (scrolled_window)));
9869 gtk_widget_show (box2);
9871 for (i = 0; i < nbuttons; i++)
9873 button = gtk_button_new_with_label (buttons[i].label);
9874 if (buttons[i].func)
9875 g_signal_connect (button,
9877 G_CALLBACK(buttons[i].func),
9880 gtk_widget_set_sensitive (button, FALSE);
9881 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
9884 separator = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
9885 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
9887 box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10);
9888 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
9889 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
9891 button = gtk_button_new_with_mnemonic ("_Close");
9892 g_signal_connect (button, "clicked",
9893 G_CALLBACK (do_exit),
9895 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
9896 gtk_widget_set_can_default (button, TRUE);
9897 gtk_widget_grab_default (button);
9899 gtk_widget_show_all (window);
9905 if (g_file_test ("../modules/input/immodules.cache", G_FILE_TEST_EXISTS))
9906 g_setenv ("GTK_IM_MODULE_FILE", "../modules/input/immodules.cache", TRUE);
9910 pad (const char *str, int to)
9912 static char buf[256];
9913 int len = strlen (str);
9916 for (i = 0; i < to; i++)
9921 memcpy (buf, str, len);
9927 bench_iteration (GtkWidget *widget, void (* fn) (GtkWidget *widget))
9929 fn (widget); /* on */
9930 while (g_main_context_iteration (NULL, FALSE));
9931 fn (widget); /* off */
9932 while (g_main_context_iteration (NULL, FALSE));
9936 do_real_bench (GtkWidget *widget, void (* fn) (GtkWidget *widget), char *name, int num)
9942 static gboolean printed_headers = FALSE;
9944 if (!printed_headers) {
9945 g_print ("Test Iters First Other\n");
9946 g_print ("-------------------- ----- ---------- ----------\n");
9947 printed_headers = TRUE;
9950 g_get_current_time (&tv0);
9951 bench_iteration (widget, fn);
9952 g_get_current_time (&tv1);
9954 dt_first = ((double)tv1.tv_sec - tv0.tv_sec) * 1000.0
9955 + (tv1.tv_usec - tv0.tv_usec) / 1000.0;
9957 g_get_current_time (&tv0);
9958 for (n = 0; n < num - 1; n++)
9959 bench_iteration (widget, fn);
9960 g_get_current_time (&tv1);
9961 dt = ((double)tv1.tv_sec - tv0.tv_sec) * 1000.0
9962 + (tv1.tv_usec - tv0.tv_usec) / 1000.0;
9964 g_print ("%s %5d ", pad (name, 20), num);
9966 g_print ("%10.1f %10.1f\n", dt_first, dt/(num-1));
9968 g_print ("%10.1f\n", dt_first);
9972 do_bench (char* what, int num)
9976 void (* fn) (GtkWidget *widget);
9978 widget = gtk_window_new (GTK_WINDOW_TOPLEVEL);
9980 if (g_ascii_strcasecmp (what, "ALL") == 0)
9982 for (i = 0; i < nbuttons; i++)
9984 if (!buttons[i].do_not_benchmark)
9985 do_real_bench (widget, buttons[i].func, buttons[i].label, num);
9992 for (i = 0; i < nbuttons; i++)
9994 if (strcmp (buttons[i].label, what) == 0)
9996 fn = buttons[i].func;
10002 g_print ("Can't bench: \"%s\" not found.\n", what);
10004 do_real_bench (widget, fn, buttons[i].label, num);
10011 fprintf (stderr, "Usage: testgtk [--bench ALL|<bench>[:<count>]]\n");
10016 main (int argc, char *argv[])
10018 GtkCssProvider *provider, *memory_provider;
10019 GdkDisplay *display;
10021 GtkBindingSet *binding_set;
10023 gboolean done_benchmarks = FALSE;
10025 srand (time (NULL));
10029 g_set_application_name ("GTK+ Test Program");
10031 gtk_init (&argc, &argv);
10033 provider = gtk_css_provider_new ();
10035 /* Check to see if we are being run from the correct
10038 if (file_exists ("testgtk.css"))
10039 gtk_css_provider_load_from_path (provider, "testgtk.css", NULL);
10040 else if (file_exists ("tests/testgtk.css"))
10041 gtk_css_provider_load_from_path (provider, "tests/testgtk.css", NULL);
10043 g_warning ("Couldn't find file \"testgtk.css\".");
10045 display = gdk_display_get_default ();
10046 screen = gdk_display_get_default_screen (display);
10048 gtk_style_context_add_provider_for_screen (screen, GTK_STYLE_PROVIDER (provider),
10049 GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
10050 g_object_unref (provider);
10052 gtk_accelerator_set_default_mod_mask (GDK_SHIFT_MASK |
10061 for (i = 1; i < argc; i++)
10063 if (strncmp (argv[i], "--bench", strlen("--bench")) == 0)
10070 nextarg = strchr (argv[i], '=');
10081 count = strchr (nextarg, ':');
10084 what = g_strndup (nextarg, count - nextarg);
10086 num = atoi (count);
10091 what = g_strdup (nextarg);
10093 do_bench (what, num ? num : 1);
10094 done_benchmarks = TRUE;
10099 if (done_benchmarks)
10104 binding_set = gtk_binding_set_by_class (g_type_class_ref (GTK_TYPE_WIDGET));
10105 gtk_binding_entry_add_signal (binding_set,
10106 '9', GDK_CONTROL_MASK | GDK_RELEASE_MASK,
10109 G_TYPE_STRING, "GtkWidgetClass <ctrl><release>9 test");
10111 memory_provider = gtk_css_provider_new ();
10112 gtk_css_provider_load_from_data (memory_provider,
10113 "#testgtk-version-label {\n"
10115 " font: Sans 18;\n"
10118 gtk_style_context_add_provider_for_screen (screen, GTK_STYLE_PROVIDER (memory_provider),
10119 GTK_STYLE_PROVIDER_PRIORITY_APPLICATION + 1);
10121 create_main_window ();
10127 while (g_main_context_pending (NULL))
10128 g_main_context_iteration (NULL, FALSE);
10131 while (g_main_context_pending (NULL))
10132 g_main_context_iteration (NULL, FALSE);