1 /* GTK - The GIMP Toolkit
2 * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation; either
7 * version 2 of the License, or (at your option) any later version.
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Lesser General Public License for more details.
14 * You should have received a copy of the GNU Lesser General Public
15 * License along with this library; if not, write to the
16 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
17 * Boston, MA 02111-1307, USA.
21 * Modified by the GTK+ Team and others 1997-2000. See the AUTHORS
22 * file for a list of people on the GTK+ Team. See the ChangeLog
23 * files for a list of changes. These files are distributed with
24 * GTK+ at ftp://ftp.gtk.org/pub/gtk/.
44 #include "gdk/gdkkeysyms.h"
47 #define sleep(n) _sleep(n)
50 #include "prop-editor.h"
55 file_exists (const char *filename)
59 return stat (filename, &statbuf) == 0;
63 shape_create_icon (GdkScreen *screen,
72 build_option_menu (gchar *items[],
75 void (*func) (GtkWidget *widget, gpointer data),
78 /* macro, structure and variables used by tree window demos */
79 #define DEFAULT_NUMBER_OF_ITEM 3
80 #define DEFAULT_RECURSION_LEVEL 3
83 GSList* selection_mode_group;
84 GtkWidget* single_button;
85 GtkWidget* browse_button;
86 GtkWidget* multiple_button;
87 GtkWidget* draw_line_button;
88 GtkWidget* view_line_button;
89 GtkWidget* no_root_item_button;
90 GtkWidget* nb_item_spinner;
91 GtkWidget* recursion_spinner;
92 } sTreeSampleSelection;
94 typedef struct sTreeButtons {
96 GtkWidget* add_button;
97 GtkWidget* remove_button;
98 GtkWidget* subtree_button;
100 /* end of tree section */
103 build_option_menu (gchar *items[],
106 void (*func)(GtkWidget *widget, gpointer data),
112 omenu = gtk_combo_box_text_new ();
113 g_signal_connect (omenu, "changed",
114 G_CALLBACK (func), data);
116 for (i = 0; i < num_items; i++)
117 gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (omenu), items[i]);
119 gtk_combo_box_set_active (GTK_COMBO_BOX (omenu), history);
125 * Windows with an alpha channel
130 on_alpha_window_draw (GtkWidget *widget,
133 cairo_pattern_t *pattern;
134 int radius, width, height;
136 width = gtk_widget_get_allocated_width (widget);
137 height = gtk_widget_get_allocated_height (widget);
138 radius = MIN (width, height) / 2;
139 pattern = cairo_pattern_create_radial (width / 2,
146 if (gdk_screen_get_rgba_visual (gtk_widget_get_screen (widget)) &&
147 gtk_widget_is_composited (widget))
148 cairo_set_source_rgba (cr, 1.0, 1.0, 1.0, 0.0); /* transparent */
150 cairo_set_source_rgb (cr, 1.0, 1.0, 1.0); /* opaque white */
152 cairo_set_operator (cr, CAIRO_OPERATOR_SOURCE);
155 cairo_pattern_add_color_stop_rgba (pattern, 0.0,
156 1.0, 0.75, 0.0, 1.0); /* solid orange */
157 cairo_pattern_add_color_stop_rgba (pattern, 1.0,
158 1.0, 0.75, 0.0, 0.0); /* transparent orange */
160 cairo_set_source (cr, pattern);
161 cairo_pattern_destroy (pattern);
163 cairo_set_operator (cr, CAIRO_OPERATOR_OVER);
170 build_alpha_widgets (void)
173 GtkWidget *radio_button;
178 table = gtk_table_new (1, 1, FALSE);
180 radio_button = gtk_radio_button_new_with_label (NULL, "Red");
181 gtk_table_attach (GTK_TABLE (table),
184 GTK_EXPAND | GTK_FILL, 0,
187 radio_button = gtk_radio_button_new_with_label_from_widget (GTK_RADIO_BUTTON (radio_button), "Green");
188 gtk_table_attach (GTK_TABLE (table),
191 GTK_EXPAND | GTK_FILL, 0,
194 radio_button = gtk_radio_button_new_with_label_from_widget (GTK_RADIO_BUTTON (radio_button), "Blue"),
195 gtk_table_attach (GTK_TABLE (table),
198 GTK_EXPAND | GTK_FILL, 0,
201 gtk_table_attach (GTK_TABLE (table),
202 gtk_check_button_new_with_label ("Sedentary"),
204 GTK_EXPAND | GTK_FILL, 0,
206 gtk_table_attach (GTK_TABLE (table),
207 gtk_check_button_new_with_label ("Nocturnal"),
209 GTK_EXPAND | GTK_FILL, 0,
211 gtk_table_attach (GTK_TABLE (table),
212 gtk_check_button_new_with_label ("Compulsive"),
214 GTK_EXPAND | GTK_FILL, 0,
217 radio_button = gtk_radio_button_new_with_label_from_widget (GTK_RADIO_BUTTON (radio_button), "Green");
218 gtk_table_attach (GTK_TABLE (table),
221 GTK_EXPAND | GTK_FILL, 0,
224 radio_button = gtk_radio_button_new_with_label_from_widget (GTK_RADIO_BUTTON (radio_button), "Blue"),
225 gtk_table_attach (GTK_TABLE (table),
228 GTK_EXPAND | GTK_FILL, 0,
231 hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
232 label = gtk_label_new (NULL);
233 gtk_label_set_markup (GTK_LABEL (label), "<i>Entry: </i>");
234 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
235 entry = gtk_entry_new ();
236 gtk_box_pack_start (GTK_BOX (hbox), entry, TRUE, TRUE, 0);
237 gtk_table_attach (GTK_TABLE (table),
240 GTK_EXPAND | GTK_FILL, 0,
247 on_alpha_screen_changed (GtkWindow *window,
248 GdkScreen *old_screen,
251 GdkScreen *screen = gtk_widget_get_screen (GTK_WIDGET (window));
252 GdkVisual *visual = gdk_screen_get_rgba_visual (screen);
256 visual = gdk_screen_get_system_visual (screen);
257 gtk_label_set_markup (GTK_LABEL (label), "<b>Screen doesn't support alpha</b>");
261 gtk_label_set_markup (GTK_LABEL (label), "<b>Screen supports alpha</b>");
264 gtk_widget_set_visual (GTK_WIDGET (window), visual);
268 on_composited_changed (GtkWidget *window,
271 gboolean is_composited = gtk_widget_is_composited (window);
274 gtk_label_set_text (label, "Composited");
276 gtk_label_set_text (label, "Not composited");
280 create_alpha_window (GtkWidget *widget)
282 static GtkWidget *window;
286 GtkWidget *content_area;
290 window = gtk_dialog_new_with_buttons ("Alpha Window",
291 GTK_WINDOW (gtk_widget_get_toplevel (widget)), 0,
295 gtk_widget_set_app_paintable (window, TRUE);
296 g_signal_connect (window, "draw",
297 G_CALLBACK (on_alpha_window_draw), NULL);
299 content_area = gtk_dialog_get_content_area (GTK_DIALOG (window));
301 vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 8);
302 gtk_container_set_border_width (GTK_CONTAINER (vbox), 12);
303 gtk_box_pack_start (GTK_BOX (content_area), vbox,
306 label = gtk_label_new (NULL);
307 gtk_box_pack_start (GTK_BOX (vbox), label, TRUE, TRUE, 0);
308 on_alpha_screen_changed (GTK_WINDOW (window), NULL, label);
309 g_signal_connect (window, "screen-changed",
310 G_CALLBACK (on_alpha_screen_changed), label);
312 label = gtk_label_new (NULL);
313 gtk_box_pack_start (GTK_BOX (vbox), label, TRUE, TRUE, 0);
314 on_composited_changed (window, GTK_LABEL (label));
315 g_signal_connect (window, "composited_changed", G_CALLBACK (on_composited_changed), label);
317 gtk_box_pack_start (GTK_BOX (vbox), build_alpha_widgets (), TRUE, TRUE, 0);
319 g_signal_connect (window, "destroy",
320 G_CALLBACK (gtk_widget_destroyed),
323 g_signal_connect (window, "response",
324 G_CALLBACK (gtk_widget_destroy),
328 if (!gtk_widget_get_visible (window))
329 gtk_widget_show_all (window);
331 gtk_widget_destroy (window);
335 * Composited non-toplevel window
338 /* The draw event handler for the event box.
340 * This function simply draws a transparency onto a widget on the area
341 * for which it receives expose events. This is intended to give the
342 * event box a "transparent" background.
344 * In order for this to work properly, the widget must have an RGBA
345 * colourmap. The widget should also be set as app-paintable since it
346 * doesn't make sense for GTK to draw a background if we are drawing it
347 * (and because GTK might actually replace our transparency with its
348 * default background colour).
351 transparent_draw (GtkWidget *widget,
354 cairo_set_operator (cr, CAIRO_OPERATOR_CLEAR);
360 /* The expose event handler for the window.
362 * This function performs the actual compositing of the event box onto
363 * the already-existing background of the window at 50% normal opacity.
365 * In this case we do not want app-paintable to be set on the widget
366 * since we want it to draw its own (red) background. Because of this,
367 * however, we must ensure that we use g_signal_register_after so that
368 * this handler is called after the red has been drawn. If it was
369 * called before then GTK would just blindly paint over our work.
372 window_draw (GtkWidget *widget,
375 GtkAllocation allocation;
378 /* get our child (in this case, the event box) */
379 child = gtk_bin_get_child (GTK_BIN (widget));
381 gtk_widget_get_allocation (child, &allocation);
383 /* the source data is the (composited) event box */
384 gdk_cairo_set_source_window (cr, gtk_widget_get_window (child),
388 /* composite, with a 50% opacity */
389 cairo_paint_with_alpha (cr, 0.5);
395 create_composited_window (GtkWidget *widget)
397 static GtkWidget *window;
401 GtkWidget *event, *button;
404 /* make the widgets */
405 button = gtk_button_new_with_label ("A Button");
406 event = gtk_event_box_new ();
407 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
409 g_signal_connect (window, "destroy",
410 G_CALLBACK (gtk_widget_destroyed),
413 /* put a red background on the window */
414 gdk_rgba_parse (&red, "red");
415 gtk_widget_override_background_color (window, 0, &red);
417 /* set our event box to have a fully-transparent background
418 * drawn on it. currently there is no way to simply tell gtk
419 * that "transparency" is the background colour for a widget.
421 gtk_widget_set_app_paintable (GTK_WIDGET (event), TRUE);
422 g_signal_connect (event, "draw",
423 G_CALLBACK (transparent_draw), NULL);
425 /* put them inside one another */
426 gtk_container_set_border_width (GTK_CONTAINER (window), 10);
427 gtk_container_add (GTK_CONTAINER (window), event);
428 gtk_container_add (GTK_CONTAINER (event), button);
430 /* realise and show everything */
431 gtk_widget_realize (button);
433 /* set the event box GdkWindow to be composited.
434 * obviously must be performed after event box is realised.
436 gdk_window_set_composited (gtk_widget_get_window (event),
439 /* set up the compositing handler.
440 * note that we do _after so that the normal (red) background is drawn
441 * by gtk before our compositing occurs.
443 g_signal_connect_after (window, "draw",
444 G_CALLBACK (window_draw), NULL);
447 if (!gtk_widget_get_visible (window))
448 gtk_widget_show_all (window);
450 gtk_widget_destroy (window);
454 * Big windows and guffaw scrolling
458 pattern_set_bg (GtkWidget *widget,
462 static const GdkColor colors[] = {
463 { 0, 0x4444, 0x4444, 0xffff },
464 { 0, 0x8888, 0x8888, 0xffff },
465 { 0, 0xaaaa, 0xaaaa, 0xffff }
468 gdk_window_set_user_data (child, widget);
469 gdk_window_set_background (child, &colors[level]);
473 create_pattern (GtkWidget *widget,
484 while (2 * h <= height)
489 while (2 * w <= width)
491 if ((i + j) % 2 == 0)
496 GdkWindowAttr attributes;
498 attributes.window_type = GDK_WINDOW_CHILD;
501 attributes.width = w;
502 attributes.height = h;
503 attributes.wclass = GDK_INPUT_OUTPUT;
504 attributes.event_mask = GDK_EXPOSURE_MASK;
505 attributes.visual = gtk_widget_get_visual (widget);
507 child = gdk_window_new (parent, &attributes,
508 GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL);
510 pattern_set_bg (widget, child, level);
513 create_pattern (widget, child, level + 1, w, h);
515 gdk_window_show (child);
525 #define PATTERN_SIZE (1 << 18)
528 pattern_hadj_changed (GtkAdjustment *adjustment,
531 gint *old_value = g_object_get_data (G_OBJECT (adjustment), "old-value");
532 gint new_value = gtk_adjustment_get_value (adjustment);
534 if (gtk_widget_get_realized (darea))
536 gdk_window_scroll (gtk_widget_get_window (darea),
537 *old_value - new_value, 0);
538 *old_value = new_value;
543 pattern_vadj_changed (GtkAdjustment *adjustment,
546 gint *old_value = g_object_get_data (G_OBJECT (adjustment), "old-value");
547 gint new_value = gtk_adjustment_get_value (adjustment);
549 if (gtk_widget_get_realized (darea))
551 gdk_window_scroll (gtk_widget_get_window (darea),
552 0, *old_value - new_value);
553 *old_value = new_value;
558 pattern_realize (GtkWidget *widget,
563 window = gtk_widget_get_window (widget);
564 pattern_set_bg (widget, window, 0);
565 create_pattern (widget, window, 1, PATTERN_SIZE, PATTERN_SIZE);
569 create_big_windows (GtkWidget *widget)
571 static GtkWidget *window = NULL;
572 GtkWidget *content_area;
573 GtkWidget *darea, *table, *scrollbar;
575 GtkAdjustment *hadjustment;
576 GtkAdjustment *vadjustment;
577 static gint current_x;
578 static gint current_y;
585 window = gtk_dialog_new_with_buttons ("Big Windows",
591 gtk_window_set_screen (GTK_WINDOW (window),
592 gtk_widget_get_screen (widget));
594 gtk_window_set_default_size (GTK_WINDOW (window), 200, 300);
596 g_signal_connect (window, "destroy",
597 G_CALLBACK (gtk_widget_destroyed),
600 g_signal_connect (window, "response",
601 G_CALLBACK (gtk_widget_destroy),
604 content_area = gtk_dialog_get_content_area (GTK_DIALOG (window));
606 table = gtk_table_new (2, 2, FALSE);
607 gtk_box_pack_start (GTK_BOX (content_area), table, TRUE, TRUE, 0);
609 darea = gtk_drawing_area_new ();
611 hadjustment = gtk_adjustment_new (0, 0, PATTERN_SIZE, 10, 100, 100);
612 g_signal_connect (hadjustment, "value_changed",
613 G_CALLBACK (pattern_hadj_changed), darea);
614 g_object_set_data (G_OBJECT (hadjustment), "old-value", ¤t_x);
616 vadjustment = gtk_adjustment_new (0, 0, PATTERN_SIZE, 10, 100, 100);
617 g_signal_connect (vadjustment, "value_changed",
618 G_CALLBACK (pattern_vadj_changed), darea);
619 g_object_set_data (G_OBJECT (vadjustment), "old-value", ¤t_y);
621 g_signal_connect (darea, "realize",
622 G_CALLBACK (pattern_realize),
625 eventbox = gtk_event_box_new ();
626 gtk_table_attach (GTK_TABLE (table), eventbox,
628 GTK_FILL | GTK_EXPAND, GTK_FILL | GTK_EXPAND,
631 gtk_container_add (GTK_CONTAINER (eventbox), darea);
633 scrollbar = gtk_scrollbar_new (GTK_ORIENTATION_HORIZONTAL, hadjustment);
634 gtk_table_attach (GTK_TABLE (table), scrollbar,
636 GTK_FILL | GTK_EXPAND, GTK_FILL,
639 scrollbar = gtk_scrollbar_new (GTK_ORIENTATION_VERTICAL, vadjustment);
640 gtk_table_attach (GTK_TABLE (table), scrollbar,
642 GTK_FILL, GTK_EXPAND | GTK_FILL,
647 if (!gtk_widget_get_visible (window))
648 gtk_widget_show_all (window);
650 gtk_widget_hide (window);
658 button_window (GtkWidget *widget,
661 if (!gtk_widget_get_visible (button))
662 gtk_widget_show (button);
664 gtk_widget_hide (button);
668 create_buttons (GtkWidget *widget)
670 static GtkWidget *window = NULL;
674 GtkWidget *button[10];
675 GtkWidget *separator;
679 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
680 gtk_window_set_screen (GTK_WINDOW (window),
681 gtk_widget_get_screen (widget));
683 g_signal_connect (window, "destroy",
684 G_CALLBACK (gtk_widget_destroyed),
687 gtk_window_set_title (GTK_WINDOW (window), "GtkButton");
688 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
690 box1 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
691 gtk_container_add (GTK_CONTAINER (window), box1);
693 table = gtk_table_new (3, 3, FALSE);
694 gtk_table_set_row_spacings (GTK_TABLE (table), 5);
695 gtk_table_set_col_spacings (GTK_TABLE (table), 5);
696 gtk_container_set_border_width (GTK_CONTAINER (table), 10);
697 gtk_box_pack_start (GTK_BOX (box1), table, TRUE, TRUE, 0);
699 button[0] = gtk_button_new_with_label ("button1");
700 button[1] = gtk_button_new_with_mnemonic ("_button2");
701 button[2] = gtk_button_new_with_mnemonic ("_button3");
702 button[3] = gtk_button_new_from_stock (GTK_STOCK_OK);
703 button[4] = gtk_button_new_with_label ("button5");
704 button[5] = gtk_button_new_with_label ("button6");
705 button[6] = gtk_button_new_with_label ("button7");
706 button[7] = gtk_button_new_from_stock (GTK_STOCK_CLOSE);
707 button[8] = gtk_button_new_with_label ("button9");
709 g_signal_connect (button[0], "clicked",
710 G_CALLBACK (button_window),
713 gtk_table_attach (GTK_TABLE (table), button[0], 0, 1, 0, 1,
714 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
716 g_signal_connect (button[1], "clicked",
717 G_CALLBACK (button_window),
720 gtk_table_attach (GTK_TABLE (table), button[1], 1, 2, 1, 2,
721 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
723 g_signal_connect (button[2], "clicked",
724 G_CALLBACK (button_window),
726 gtk_table_attach (GTK_TABLE (table), button[2], 2, 3, 2, 3,
727 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
729 g_signal_connect (button[3], "clicked",
730 G_CALLBACK (button_window),
732 gtk_table_attach (GTK_TABLE (table), button[3], 0, 1, 2, 3,
733 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
735 g_signal_connect (button[4], "clicked",
736 G_CALLBACK (button_window),
738 gtk_table_attach (GTK_TABLE (table), button[4], 2, 3, 0, 1,
739 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
741 g_signal_connect (button[5], "clicked",
742 G_CALLBACK (button_window),
744 gtk_table_attach (GTK_TABLE (table), button[5], 1, 2, 2, 3,
745 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
747 g_signal_connect (button[6], "clicked",
748 G_CALLBACK (button_window),
750 gtk_table_attach (GTK_TABLE (table), button[6], 1, 2, 0, 1,
751 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
753 g_signal_connect (button[7], "clicked",
754 G_CALLBACK (button_window),
756 gtk_table_attach (GTK_TABLE (table), button[7], 2, 3, 1, 2,
757 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
759 g_signal_connect (button[8], "clicked",
760 G_CALLBACK (button_window),
762 gtk_table_attach (GTK_TABLE (table), button[8], 0, 1, 1, 2,
763 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
765 separator = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
766 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
768 box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10);
769 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
770 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
772 button[9] = gtk_button_new_with_label ("close");
773 g_signal_connect_swapped (button[9], "clicked",
774 G_CALLBACK (gtk_widget_destroy),
776 gtk_box_pack_start (GTK_BOX (box2), button[9], TRUE, TRUE, 0);
777 gtk_widget_set_can_default (button[9], TRUE);
778 gtk_widget_grab_default (button[9]);
781 if (!gtk_widget_get_visible (window))
782 gtk_widget_show_all (window);
784 gtk_widget_destroy (window);
792 create_toggle_buttons (GtkWidget *widget)
794 static GtkWidget *window = NULL;
798 GtkWidget *separator;
802 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
803 gtk_window_set_screen (GTK_WINDOW (window),
804 gtk_widget_get_screen (widget));
806 g_signal_connect (window, "destroy",
807 G_CALLBACK (gtk_widget_destroyed),
810 gtk_window_set_title (GTK_WINDOW (window), "GtkToggleButton");
811 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
813 box1 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
814 gtk_container_add (GTK_CONTAINER (window), box1);
816 box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10);
817 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
818 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
820 button = gtk_toggle_button_new_with_label ("button1");
821 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
823 button = gtk_toggle_button_new_with_label ("button2");
824 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
826 button = gtk_toggle_button_new_with_label ("button3");
827 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
829 button = gtk_toggle_button_new_with_label ("inconsistent");
830 gtk_toggle_button_set_inconsistent (GTK_TOGGLE_BUTTON (button), TRUE);
831 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
833 separator = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
834 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
836 box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10);
837 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
838 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
840 button = gtk_button_new_with_label ("close");
841 g_signal_connect_swapped (button, "clicked",
842 G_CALLBACK (gtk_widget_destroy),
844 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
845 gtk_widget_set_can_default (button, TRUE);
846 gtk_widget_grab_default (button);
849 if (!gtk_widget_get_visible (window))
850 gtk_widget_show_all (window);
852 gtk_widget_destroy (window);
856 create_widget_grid (GType widget_type)
859 GtkWidget *group_widget = NULL;
862 table = gtk_table_new (FALSE, 3, 3);
864 for (i = 0; i < 5; i++)
866 for (j = 0; j < 5; j++)
871 if (i == 0 && j == 0)
877 tmp = g_strdup_printf ("%d", j);
878 widget = gtk_label_new (tmp);
883 tmp = g_strdup_printf ("%c", 'A' + i - 1);
884 widget = gtk_label_new (tmp);
889 widget = g_object_new (widget_type, NULL);
891 if (g_type_is_a (widget_type, GTK_TYPE_RADIO_BUTTON))
894 group_widget = widget;
896 g_object_set (widget, "group", group_widget, NULL);
901 gtk_table_attach (GTK_TABLE (table), widget,
916 create_check_buttons (GtkWidget *widget)
918 static GtkWidget *window = NULL;
922 GtkWidget *separator;
927 window = gtk_dialog_new_with_buttons ("Check Buttons",
933 gtk_window_set_screen (GTK_WINDOW (window),
934 gtk_widget_get_screen (widget));
936 g_signal_connect (window, "destroy",
937 G_CALLBACK (gtk_widget_destroyed),
939 g_signal_connect (window, "response",
940 G_CALLBACK (gtk_widget_destroy),
943 box1 = gtk_dialog_get_content_area (GTK_DIALOG (window));
945 box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10);
946 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
947 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
949 button = gtk_check_button_new_with_mnemonic ("_button1");
950 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
952 button = gtk_check_button_new_with_label ("button2");
953 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
955 button = gtk_check_button_new_with_label ("button3");
956 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
958 button = gtk_check_button_new_with_label ("inconsistent");
959 gtk_toggle_button_set_inconsistent (GTK_TOGGLE_BUTTON (button), TRUE);
960 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
962 separator = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
963 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
965 table = create_widget_grid (GTK_TYPE_CHECK_BUTTON);
966 gtk_container_set_border_width (GTK_CONTAINER (table), 10);
967 gtk_box_pack_start (GTK_BOX (box1), table, TRUE, TRUE, 0);
970 if (!gtk_widget_get_visible (window))
971 gtk_widget_show_all (window);
973 gtk_widget_destroy (window);
981 create_radio_buttons (GtkWidget *widget)
983 static GtkWidget *window = NULL;
987 GtkWidget *separator;
992 window = gtk_dialog_new_with_buttons ("Radio Buttons",
998 gtk_window_set_screen (GTK_WINDOW (window),
999 gtk_widget_get_screen (widget));
1001 g_signal_connect (window, "destroy",
1002 G_CALLBACK (gtk_widget_destroyed),
1004 g_signal_connect (window, "response",
1005 G_CALLBACK (gtk_widget_destroy),
1008 box1 = gtk_dialog_get_content_area (GTK_DIALOG (window));
1010 box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10);
1011 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
1012 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
1014 button = gtk_radio_button_new_with_label (NULL, "button1");
1015 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
1017 button = gtk_radio_button_new_with_label (
1018 gtk_radio_button_get_group (GTK_RADIO_BUTTON (button)),
1020 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
1021 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
1023 button = gtk_radio_button_new_with_label (
1024 gtk_radio_button_get_group (GTK_RADIO_BUTTON (button)),
1026 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
1028 button = gtk_radio_button_new_with_label (
1029 gtk_radio_button_get_group (GTK_RADIO_BUTTON (button)),
1031 gtk_toggle_button_set_inconsistent (GTK_TOGGLE_BUTTON (button), TRUE);
1032 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
1034 separator = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
1035 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
1037 box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10);
1038 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
1039 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
1041 button = gtk_radio_button_new_with_label (NULL, "button4");
1042 gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (button), FALSE);
1043 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
1045 button = gtk_radio_button_new_with_label (
1046 gtk_radio_button_get_group (GTK_RADIO_BUTTON (button)),
1048 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
1049 gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (button), FALSE);
1050 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
1052 button = gtk_radio_button_new_with_label (
1053 gtk_radio_button_get_group (GTK_RADIO_BUTTON (button)),
1055 gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (button), FALSE);
1056 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
1058 separator = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
1059 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
1061 table = create_widget_grid (GTK_TYPE_RADIO_BUTTON);
1062 gtk_container_set_border_width (GTK_CONTAINER (table), 10);
1063 gtk_box_pack_start (GTK_BOX (box1), table, TRUE, TRUE, 0);
1066 if (!gtk_widget_get_visible (window))
1067 gtk_widget_show_all (window);
1069 gtk_widget_destroy (window);
1077 create_bbox (gint horizontal,
1088 frame = gtk_frame_new (title);
1091 bbox = gtk_button_box_new (GTK_ORIENTATION_HORIZONTAL);
1093 bbox = gtk_button_box_new (GTK_ORIENTATION_VERTICAL);
1095 gtk_container_set_border_width (GTK_CONTAINER (bbox), 5);
1096 gtk_container_add (GTK_CONTAINER (frame), bbox);
1098 gtk_button_box_set_layout (GTK_BUTTON_BOX (bbox), layout);
1099 gtk_box_set_spacing (GTK_BOX (bbox), spacing);
1101 button = gtk_button_new_with_label ("OK");
1102 gtk_container_add (GTK_CONTAINER (bbox), button);
1104 button = gtk_button_new_with_label ("Cancel");
1105 gtk_container_add (GTK_CONTAINER (bbox), button);
1107 button = gtk_button_new_with_label ("Help");
1108 gtk_container_add (GTK_CONTAINER (bbox), button);
1114 create_button_box (GtkWidget *widget)
1116 static GtkWidget* window = NULL;
1117 GtkWidget *main_vbox;
1120 GtkWidget *frame_horz;
1121 GtkWidget *frame_vert;
1125 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
1126 gtk_window_set_screen (GTK_WINDOW (window), gtk_widget_get_screen (widget));
1127 gtk_window_set_title (GTK_WINDOW (window), "Button Boxes");
1129 g_signal_connect (window, "destroy",
1130 G_CALLBACK (gtk_widget_destroyed),
1133 gtk_container_set_border_width (GTK_CONTAINER (window), 10);
1135 main_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
1136 gtk_container_add (GTK_CONTAINER (window), main_vbox);
1138 frame_horz = gtk_frame_new ("Horizontal Button Boxes");
1139 gtk_box_pack_start (GTK_BOX (main_vbox), frame_horz, TRUE, TRUE, 10);
1141 vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
1142 gtk_container_set_border_width (GTK_CONTAINER (vbox), 10);
1143 gtk_container_add (GTK_CONTAINER (frame_horz), vbox);
1145 gtk_box_pack_start (GTK_BOX (vbox),
1146 create_bbox (TRUE, "Spread", 40, 85, 20, GTK_BUTTONBOX_SPREAD),
1149 gtk_box_pack_start (GTK_BOX (vbox),
1150 create_bbox (TRUE, "Edge", 40, 85, 20, GTK_BUTTONBOX_EDGE),
1153 gtk_box_pack_start (GTK_BOX (vbox),
1154 create_bbox (TRUE, "Start", 40, 85, 20, GTK_BUTTONBOX_START),
1157 gtk_box_pack_start (GTK_BOX (vbox),
1158 create_bbox (TRUE, "End", 40, 85, 20, GTK_BUTTONBOX_END),
1161 gtk_box_pack_start (GTK_BOX (vbox),
1162 create_bbox (TRUE, "Center", 40, 85, 20, GTK_BUTTONBOX_CENTER),
1165 frame_vert = gtk_frame_new ("Vertical Button Boxes");
1166 gtk_box_pack_start (GTK_BOX (main_vbox), frame_vert, TRUE, TRUE, 10);
1168 hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
1169 gtk_container_set_border_width (GTK_CONTAINER (hbox), 10);
1170 gtk_container_add (GTK_CONTAINER (frame_vert), hbox);
1172 gtk_box_pack_start (GTK_BOX (hbox),
1173 create_bbox (FALSE, "Spread", 30, 85, 20, GTK_BUTTONBOX_SPREAD),
1176 gtk_box_pack_start (GTK_BOX (hbox),
1177 create_bbox (FALSE, "Edge", 30, 85, 20, GTK_BUTTONBOX_EDGE),
1180 gtk_box_pack_start (GTK_BOX (hbox),
1181 create_bbox (FALSE, "Start", 30, 85, 20, GTK_BUTTONBOX_START),
1184 gtk_box_pack_start (GTK_BOX (hbox),
1185 create_bbox (FALSE, "End", 30, 85, 20, GTK_BUTTONBOX_END),
1188 gtk_box_pack_start (GTK_BOX (hbox),
1189 create_bbox (FALSE, "Center", 30, 85, 20, GTK_BUTTONBOX_CENTER),
1193 if (!gtk_widget_get_visible (window))
1194 gtk_widget_show_all (window);
1196 gtk_widget_destroy (window);
1204 new_pixbuf (char *filename,
1210 if (strcmp (filename, "test.xpm") == 0)
1213 pixbuf = gdk_pixbuf_new_from_file (filename, NULL);
1216 pixbuf = gdk_pixbuf_new_from_xpm_data ((const char **) openfile);
1218 widget = gtk_image_new_from_pixbuf (pixbuf);
1220 g_object_unref (pixbuf);
1227 set_toolbar_small_stock (GtkWidget *widget,
1230 gtk_toolbar_set_icon_size (GTK_TOOLBAR (data), GTK_ICON_SIZE_SMALL_TOOLBAR);
1234 set_toolbar_large_stock (GtkWidget *widget,
1237 gtk_toolbar_set_icon_size (GTK_TOOLBAR (data), GTK_ICON_SIZE_LARGE_TOOLBAR);
1241 set_toolbar_horizontal (GtkWidget *widget,
1244 gtk_orientable_set_orientation (GTK_ORIENTABLE (data), GTK_ORIENTATION_HORIZONTAL);
1248 set_toolbar_vertical (GtkWidget *widget,
1251 gtk_orientable_set_orientation (GTK_ORIENTABLE (data), GTK_ORIENTATION_VERTICAL);
1255 set_toolbar_icons (GtkWidget *widget,
1258 gtk_toolbar_set_style (GTK_TOOLBAR (data), GTK_TOOLBAR_ICONS);
1262 set_toolbar_text (GtkWidget *widget,
1265 gtk_toolbar_set_style (GTK_TOOLBAR (data), GTK_TOOLBAR_TEXT);
1269 set_toolbar_both (GtkWidget *widget,
1272 gtk_toolbar_set_style (GTK_TOOLBAR (data), GTK_TOOLBAR_BOTH);
1276 set_toolbar_both_horiz (GtkWidget *widget,
1279 gtk_toolbar_set_style (GTK_TOOLBAR (data), GTK_TOOLBAR_BOTH_HORIZ);
1283 set_toolbar_enable (GtkWidget *widget,
1286 GtkSettings *settings = gtk_widget_get_settings (widget);
1287 g_object_set (settings, "gtk-enable-tooltips", TRUE, NULL);
1291 set_toolbar_disable (GtkWidget *widget,
1294 GtkSettings *settings = gtk_widget_get_settings (widget);
1295 g_object_set (settings, "gtk-enable-tooltips", FALSE, NULL);
1298 static GtkActionEntry create_toolbar_items[] = {
1299 { NULL, GTK_STOCK_NEW, NULL, NULL, "Stock icon: New",
1300 G_CALLBACK (set_toolbar_small_stock) },
1301 { NULL, GTK_STOCK_OPEN, NULL, NULL, "Stock icon: Open",
1302 G_CALLBACK (set_toolbar_large_stock) },
1303 { NULL, NULL, "Horizontal", NULL, "Horizontal toolbar layout",
1304 G_CALLBACK (set_toolbar_horizontal) },
1305 { NULL, NULL, "Vertical", NULL, "Vertical toolbar layout",
1306 G_CALLBACK (set_toolbar_vertical) },
1308 { NULL, NULL, "Icons", NULL, "Only show toolbar icons",
1309 G_CALLBACK (set_toolbar_icons) },
1310 { NULL, NULL, "Text", NULL, "Only show toolbar text",
1311 G_CALLBACK (set_toolbar_text) },
1312 { NULL, NULL, "Both", NULL, "Show toolbar icons and text",
1313 G_CALLBACK (set_toolbar_both) },
1314 { NULL, NULL, "Both (horizontal)", NULL, "Show toolbar icons and text in a horizontal fashion",
1315 G_CALLBACK (set_toolbar_both_horiz) },
1317 { "entry", NULL, NULL, "This is an unusable GtkEntry ;)",
1321 { NULL, NULL, "Enable", NULL, "Enable tooltips",
1322 G_CALLBACK (set_toolbar_enable) },
1323 { NULL, NULL, "Disable", NULL, "Disable tooltips",
1324 G_CALLBACK (set_toolbar_disable) },
1326 { NULL, NULL, "Frobate", NULL, "Frobate tooltip",
1328 { NULL, NULL, "Baz", NULL, "Baz tooltip",
1331 { NULL, NULL, "Blah", NULL, "Blash tooltip",
1333 { NULL, NULL, "Bar", NULL, "Bar tooltip",
1338 create_toolbar (GtkWidget *widget)
1340 static GtkWidget *window = NULL;
1347 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
1348 gtk_window_set_screen (GTK_WINDOW (window),
1349 gtk_widget_get_screen (widget));
1351 gtk_window_set_title (GTK_WINDOW (window), "Toolbar test");
1353 g_signal_connect (window, "destroy",
1354 G_CALLBACK (gtk_widget_destroyed),
1357 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
1358 gtk_widget_realize (window);
1360 toolbar = gtk_toolbar_new ();
1361 for (i = 0; i < G_N_ELEMENTS (create_toolbar_items); i++)
1363 GtkToolItem *toolitem;
1365 if (create_toolbar_items[i].tooltip == NULL)
1366 toolitem = gtk_separator_tool_item_new ();
1367 else if (g_strcmp0 (create_toolbar_items[i].name, "entry") == 0)
1371 toolitem = gtk_tool_item_new ();
1372 entry = gtk_entry_new ();
1373 gtk_container_add (GTK_CONTAINER (toolitem), entry);
1375 else if (create_toolbar_items[i].stock_id)
1376 toolitem = gtk_tool_button_new_from_stock (create_toolbar_items[i].stock_id);
1381 icon = new_pixbuf ("test.xpm", gtk_widget_get_window (window));
1382 toolitem = gtk_tool_button_new (icon, create_toolbar_items[i].label);
1384 if (create_toolbar_items[i].callback)
1385 g_signal_connect (toolitem, "clicked",
1386 create_toolbar_items[i].callback, toolbar);
1387 gtk_tool_item_set_tooltip_text (toolitem, create_toolbar_items[i].tooltip);
1388 gtk_toolbar_insert (GTK_TOOLBAR (toolbar), toolitem, -1);
1391 gtk_container_add (GTK_CONTAINER (window), toolbar);
1393 gtk_widget_set_size_request (toolbar, 200, -1);
1396 if (!gtk_widget_get_visible (window))
1397 gtk_widget_show_all (window);
1399 gtk_widget_destroy (window);
1402 static GtkActionEntry make_toolbar_items[] = {
1403 { NULL, NULL, "Horizontal", NULL, "Horizontal toolbar layout",
1404 G_CALLBACK (set_toolbar_horizontal) },
1405 { NULL, NULL, "Vertical", NULL, "Vertical toolbar layout",
1406 G_CALLBACK (set_toolbar_vertical) },
1408 { NULL, NULL, "Icons", NULL, "Only show toolbar icons",
1409 G_CALLBACK (set_toolbar_icons) },
1410 { NULL, NULL, "Text", NULL, "Only show toolbar text",
1411 G_CALLBACK (set_toolbar_text) },
1412 { NULL, NULL, "Both", NULL, "Show toolbar icons and text",
1413 G_CALLBACK (set_toolbar_both) },
1415 { NULL, NULL, "Woot", NULL, "Woot woot woot",
1417 { NULL, NULL, "Blah", NULL, "Blah blah blah",
1420 { NULL, NULL, "Enable", NULL, "Enable tooltips",
1421 G_CALLBACK (set_toolbar_enable) },
1422 { NULL, NULL, "Disable", NULL, "Disable tooltips",
1423 G_CALLBACK (set_toolbar_disable) },
1425 { NULL, NULL, "Hoo", NULL, "Hoo tooltip",
1427 { NULL, NULL, "Woo", NULL, "Woo tooltip",
1432 make_toolbar (GtkWidget *window)
1437 if (!gtk_widget_get_realized (window))
1438 gtk_widget_realize (window);
1440 toolbar = gtk_toolbar_new ();
1441 for (i = 0; i < G_N_ELEMENTS (make_toolbar_items); i++)
1444 GtkToolItem *toolitem;
1446 if (make_toolbar_items[i].label == NULL)
1448 toolitem = gtk_separator_tool_item_new ();
1452 icon = new_pixbuf ("test.xpm", gtk_widget_get_window (window));
1453 toolitem = gtk_tool_button_new (icon, make_toolbar_items[i].label);
1454 gtk_tool_item_set_tooltip_text (toolitem, make_toolbar_items[i].tooltip);
1455 if (make_toolbar_items[i].callback != NULL)
1456 g_signal_connect (toolitem, "clicked", make_toolbar_items[i].callback, toolbar);
1458 gtk_toolbar_insert (GTK_TOOLBAR (toolbar), toolitem, -1);
1468 static guint statusbar_counter = 1;
1471 statusbar_push (GtkWidget *button,
1472 GtkStatusbar *statusbar)
1476 sprintf (text, "something %d", statusbar_counter++);
1478 gtk_statusbar_push (statusbar, 1, text);
1482 statusbar_push_long (GtkWidget *button,
1483 GtkStatusbar *statusbar)
1487 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\").");
1489 gtk_statusbar_push (statusbar, 1, text);
1493 statusbar_pop (GtkWidget *button,
1494 GtkStatusbar *statusbar)
1496 gtk_statusbar_pop (statusbar, 1);
1500 statusbar_steal (GtkWidget *button,
1501 GtkStatusbar *statusbar)
1503 gtk_statusbar_remove (statusbar, 1, 4);
1507 statusbar_popped (GtkStatusbar *statusbar,
1512 statusbar_counter = 1;
1516 statusbar_contexts (GtkStatusbar *statusbar)
1520 string = "any context";
1521 g_print ("GtkStatusBar: context=\"%s\", context_id=%d\n",
1523 gtk_statusbar_get_context_id (statusbar, string));
1525 string = "idle messages";
1526 g_print ("GtkStatusBar: context=\"%s\", context_id=%d\n",
1528 gtk_statusbar_get_context_id (statusbar, string));
1530 string = "some text";
1531 g_print ("GtkStatusBar: context=\"%s\", context_id=%d\n",
1533 gtk_statusbar_get_context_id (statusbar, string));
1535 string = "hit the mouse";
1536 g_print ("GtkStatusBar: context=\"%s\", context_id=%d\n",
1538 gtk_statusbar_get_context_id (statusbar, string));
1540 string = "hit the mouse2";
1541 g_print ("GtkStatusBar: context=\"%s\", context_id=%d\n",
1543 gtk_statusbar_get_context_id (statusbar, string));
1547 create_statusbar (GtkWidget *widget)
1549 static GtkWidget *window = NULL;
1553 GtkWidget *separator;
1554 GtkWidget *statusbar;
1558 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
1559 gtk_window_set_screen (GTK_WINDOW (window),
1560 gtk_widget_get_screen (widget));
1562 g_signal_connect (window, "destroy",
1563 G_CALLBACK (gtk_widget_destroyed),
1566 gtk_window_set_title (GTK_WINDOW (window), "statusbar");
1567 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
1569 box1 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
1570 gtk_container_add (GTK_CONTAINER (window), box1);
1572 box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10);
1573 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
1574 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
1576 statusbar = gtk_statusbar_new ();
1577 gtk_box_pack_end (GTK_BOX (box1), statusbar, TRUE, TRUE, 0);
1578 g_signal_connect (statusbar,
1580 G_CALLBACK (statusbar_popped),
1583 button = g_object_new (gtk_button_get_type (),
1584 "label", "push something",
1588 g_object_connect (button,
1589 "signal::clicked", statusbar_push, statusbar,
1592 button = g_object_connect (g_object_new (gtk_button_get_type (),
1597 "signal_after::clicked", statusbar_pop, statusbar,
1600 button = g_object_connect (g_object_new (gtk_button_get_type (),
1601 "label", "steal #4",
1605 "signal_after::clicked", statusbar_steal, statusbar,
1608 button = g_object_connect (g_object_new (gtk_button_get_type (),
1609 "label", "test contexts",
1613 "swapped_signal_after::clicked", statusbar_contexts, statusbar,
1616 button = g_object_connect (g_object_new (gtk_button_get_type (),
1617 "label", "push something long",
1621 "signal_after::clicked", statusbar_push_long, statusbar,
1624 separator = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
1625 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
1627 box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10);
1628 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
1629 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
1631 button = gtk_button_new_with_label ("close");
1632 g_signal_connect_swapped (button, "clicked",
1633 G_CALLBACK (gtk_widget_destroy),
1635 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
1636 gtk_widget_set_can_default (button, TRUE);
1637 gtk_widget_grab_default (button);
1640 if (!gtk_widget_get_visible (window))
1641 gtk_widget_show_all (window);
1643 gtk_widget_destroy (window);
1651 handle_box_child_signal (GtkHandleBox *hb,
1653 const gchar *action)
1655 printf ("%s: child <%s> %sed\n",
1656 g_type_name (G_OBJECT_TYPE (hb)),
1657 g_type_name (G_OBJECT_TYPE (child)),
1662 create_handle_box (GtkWidget *widget)
1664 static GtkWidget* window = NULL;
1665 GtkWidget *handle_box;
1666 GtkWidget *handle_box2;
1671 GtkWidget *separator;
1675 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
1677 gtk_window_set_screen (GTK_WINDOW (window),
1678 gtk_widget_get_screen (widget));
1679 gtk_window_set_modal (GTK_WINDOW (window), FALSE);
1680 gtk_window_set_title (GTK_WINDOW (window),
1682 gtk_window_set_resizable (GTK_WINDOW (window), TRUE);
1684 g_signal_connect (window, "destroy",
1685 G_CALLBACK (gtk_widget_destroyed),
1688 gtk_container_set_border_width (GTK_CONTAINER (window), 20);
1690 vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
1691 gtk_container_add (GTK_CONTAINER (window), vbox);
1692 gtk_widget_show (vbox);
1694 label = gtk_label_new ("Above");
1695 gtk_container_add (GTK_CONTAINER (vbox), label);
1696 gtk_widget_show (label);
1698 separator = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
1699 gtk_container_add (GTK_CONTAINER (vbox), separator);
1700 gtk_widget_show (separator);
1702 hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 10);
1703 gtk_container_add (GTK_CONTAINER (vbox), hbox);
1704 gtk_widget_show (hbox);
1706 separator = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
1707 gtk_container_add (GTK_CONTAINER (vbox), separator);
1708 gtk_widget_show (separator);
1710 label = gtk_label_new ("Below");
1711 gtk_container_add (GTK_CONTAINER (vbox), label);
1712 gtk_widget_show (label);
1714 handle_box = gtk_handle_box_new ();
1715 gtk_box_pack_start (GTK_BOX (hbox), handle_box, FALSE, FALSE, 0);
1716 g_signal_connect (handle_box,
1718 G_CALLBACK (handle_box_child_signal),
1720 g_signal_connect (handle_box,
1722 G_CALLBACK (handle_box_child_signal),
1724 gtk_widget_show (handle_box);
1726 toolbar = make_toolbar (window);
1728 gtk_container_add (GTK_CONTAINER (handle_box), toolbar);
1729 gtk_widget_show (toolbar);
1731 handle_box = gtk_handle_box_new ();
1732 gtk_box_pack_start (GTK_BOX (hbox), handle_box, FALSE, FALSE, 0);
1733 g_signal_connect (handle_box,
1735 G_CALLBACK (handle_box_child_signal),
1737 g_signal_connect (handle_box,
1739 G_CALLBACK (handle_box_child_signal),
1741 gtk_widget_show (handle_box);
1743 handle_box2 = gtk_handle_box_new ();
1744 gtk_container_add (GTK_CONTAINER (handle_box), handle_box2);
1745 g_signal_connect (handle_box2,
1747 G_CALLBACK (handle_box_child_signal),
1749 g_signal_connect (handle_box2,
1751 G_CALLBACK (handle_box_child_signal),
1753 gtk_widget_show (handle_box2);
1755 hbox = g_object_new (GTK_TYPE_BOX, "visible", 1, "parent", handle_box2, NULL);
1756 label = gtk_label_new ("Fooo!");
1757 gtk_container_add (GTK_CONTAINER (hbox), label);
1758 gtk_widget_show (label);
1759 g_object_new (GTK_TYPE_ARROW, "visible", 1, "parent", hbox, NULL);
1762 if (!gtk_widget_get_visible (window))
1763 gtk_widget_show (window);
1765 gtk_widget_destroy (window);
1772 sensitivity_toggled (GtkWidget *toggle,
1775 gtk_widget_set_sensitive (widget,
1776 gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (toggle)));
1780 create_sensitivity_control (GtkWidget *widget)
1784 button = gtk_toggle_button_new_with_label ("Sensitive");
1786 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button),
1787 gtk_widget_is_sensitive (widget));
1789 g_signal_connect (button,
1791 G_CALLBACK (sensitivity_toggled),
1794 gtk_widget_show_all (button);
1800 set_selectable_recursive (GtkWidget *widget,
1803 if (GTK_IS_CONTAINER (widget))
1808 children = gtk_container_get_children (GTK_CONTAINER (widget));
1812 set_selectable_recursive (tmp->data, setting);
1816 g_list_free (children);
1818 else if (GTK_IS_LABEL (widget))
1820 gtk_label_set_selectable (GTK_LABEL (widget), setting);
1825 selectable_toggled (GtkWidget *toggle,
1828 set_selectable_recursive (widget,
1829 gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (toggle)));
1833 create_selectable_control (GtkWidget *widget)
1837 button = gtk_toggle_button_new_with_label ("Selectable");
1839 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button),
1842 g_signal_connect (button,
1844 G_CALLBACK (selectable_toggled),
1847 gtk_widget_show_all (button);
1853 dialog_response (GtkWidget *dialog, gint response_id, GtkLabel *label)
1857 gtk_widget_destroy (dialog);
1859 text = "Some <a href=\"http://en.wikipedia.org/wiki/Text\" title=\"plain text\">text</a> may be marked up\n"
1860 "as hyperlinks, which can be clicked\n"
1861 "or activated via <a href=\"keynav\">keynav</a>.\n"
1862 "The links remain the same.";
1863 gtk_label_set_markup (label, text);
1867 activate_link (GtkWidget *label, const gchar *uri, gpointer data)
1869 if (g_strcmp0 (uri, "keynav") == 0)
1873 dialog = gtk_message_dialog_new_with_markup (GTK_WINDOW (gtk_widget_get_toplevel (label)),
1874 GTK_DIALOG_DESTROY_WITH_PARENT,
1877 "The term <i>keynav</i> is a shorthand for "
1878 "keyboard navigation and refers to the process of using a program "
1879 "(exclusively) via keyboard input.");
1881 gtk_window_present (GTK_WINDOW (dialog));
1883 g_signal_connect (dialog, "response", G_CALLBACK (dialog_response), label);
1891 void create_labels (GtkWidget *widget)
1893 static GtkWidget *window = NULL;
1902 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
1904 gtk_window_set_screen (GTK_WINDOW (window),
1905 gtk_widget_get_screen (widget));
1907 g_signal_connect (window, "destroy",
1908 G_CALLBACK (gtk_widget_destroyed),
1911 gtk_window_set_title (GTK_WINDOW (window), "Label");
1913 vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
1915 hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 5);
1916 gtk_container_add (GTK_CONTAINER (window), vbox);
1918 gtk_box_pack_end (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
1920 button = create_sensitivity_control (hbox);
1922 gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
1924 button = create_selectable_control (hbox);
1926 gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
1928 vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
1930 gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 0);
1931 gtk_container_set_border_width (GTK_CONTAINER (window), 5);
1933 frame = gtk_frame_new ("Normal Label");
1934 label = gtk_label_new ("This is a Normal label");
1935 gtk_label_set_ellipsize (GTK_LABEL (label), PANGO_ELLIPSIZE_START);
1936 gtk_container_add (GTK_CONTAINER (frame), label);
1937 gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
1939 frame = gtk_frame_new ("Multi-line Label");
1940 label = gtk_label_new ("This is a Multi-line label.\nSecond line\nThird line");
1941 gtk_label_set_ellipsize (GTK_LABEL (label), PANGO_ELLIPSIZE_END);
1942 gtk_container_add (GTK_CONTAINER (frame), label);
1943 gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
1945 frame = gtk_frame_new ("Left Justified Label");
1946 label = gtk_label_new ("This is a Left-Justified\nMulti-line label.\nThird line");
1947 gtk_label_set_ellipsize (GTK_LABEL (label), PANGO_ELLIPSIZE_MIDDLE);
1948 gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
1949 gtk_container_add (GTK_CONTAINER (frame), label);
1950 gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
1952 frame = gtk_frame_new ("Right Justified Label");
1953 gtk_label_set_ellipsize (GTK_LABEL (label), PANGO_ELLIPSIZE_START);
1954 label = gtk_label_new ("This is a Right-Justified\nMulti-line label.\nFourth line, (j/k)");
1955 gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_RIGHT);
1956 gtk_container_add (GTK_CONTAINER (frame), label);
1957 gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
1959 frame = gtk_frame_new ("Internationalized Label");
1960 label = gtk_label_new (NULL);
1961 gtk_label_set_markup (GTK_LABEL (label),
1962 "French (Fran\303\247ais) Bonjour, Salut\n"
1963 "Korean (\355\225\234\352\270\200) \354\225\210\353\205\225\355\225\230\354\204\270\354\232\224, \354\225\210\353\205\225\355\225\230\354\213\255\353\213\210\352\271\214\n"
1964 "Russian (\320\240\321\203\321\201\321\201\320\272\320\270\320\271) \320\227\320\264\321\200\320\260\320\262\321\201\321\202\320\262\321\203\320\271\321\202\320\265!\n"
1965 "Chinese (Simplified) <span lang=\"zh-cn\">\345\205\203\346\260\224 \345\274\200\345\217\221</span>\n"
1966 "Chinese (Traditional) <span lang=\"zh-tw\">\345\205\203\346\260\243 \351\226\213\347\231\274</span>\n"
1967 "Japanese <span lang=\"ja\">\345\205\203\346\260\227 \351\226\213\347\231\272</span>");
1968 gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
1969 gtk_container_add (GTK_CONTAINER (frame), label);
1970 gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
1972 frame = gtk_frame_new ("Bidirection Label");
1973 label = gtk_label_new ("\342\200\217Arabic \330\247\331\204\330\263\331\204\330\247\331\205 \330\271\331\204\331\212\331\203\331\205\n"
1974 "\342\200\217Hebrew \327\251\327\234\327\225\327\235");
1975 gtk_container_add (GTK_CONTAINER (frame), label);
1976 gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
1978 frame = gtk_frame_new ("Links in a label");
1979 label = gtk_label_new ("Some <a href=\"http://en.wikipedia.org/wiki/Text\" title=\"plain text\">text</a> may be marked up\n"
1980 "as hyperlinks, which can be clicked\n"
1981 "or activated via <a href=\"keynav\">keynav</a>");
1982 gtk_label_set_use_markup (GTK_LABEL (label), TRUE);
1983 gtk_container_add (GTK_CONTAINER (frame), label);
1984 gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
1985 g_signal_connect (label, "activate-link", G_CALLBACK (activate_link), NULL);
1987 vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
1988 gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 0);
1989 frame = gtk_frame_new ("Line wrapped label");
1990 label = gtk_label_new ("This is an example of a line-wrapped label. It should not be taking "\
1991 "up the entire "/* big space to test spacing */\
1992 "width allocated to it, but automatically wraps the words to fit. "\
1993 "The time has come, for all good men, to come to the aid of their party. "\
1994 "The sixth sheik's six sheep's sick.\n"\
1995 " It supports multiple paragraphs correctly, and correctly adds "\
1996 "many extra spaces. ");
1998 gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
1999 gtk_container_add (GTK_CONTAINER (frame), label);
2000 gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
2002 frame = gtk_frame_new ("Filled, wrapped label");
2003 label = gtk_label_new ("This is an example of a line-wrapped, filled label. It should be taking "\
2004 "up the entire width allocated to it. Here is a seneance to prove "\
2005 "my point. Here is another sentence. "\
2006 "Here comes the sun, do de do de do.\n"\
2007 " This is a new paragraph.\n"\
2008 " This is another newer, longer, better paragraph. It is coming to an end, "\
2010 gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_FILL);
2011 gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
2012 gtk_container_add (GTK_CONTAINER (frame), label);
2013 gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
2015 frame = gtk_frame_new ("Underlined label");
2016 label = gtk_label_new ("This label is underlined!\n"
2017 "This one is underlined (\343\201\223\343\202\223\343\201\253\343\201\241\343\201\257) in quite a funky fashion");
2018 gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
2019 gtk_label_set_pattern (GTK_LABEL (label), "_________________________ _ _________ _ _____ _ __ __ ___ ____ _____");
2020 gtk_container_add (GTK_CONTAINER (frame), label);
2021 gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
2023 frame = gtk_frame_new ("Markup label");
2024 label = gtk_label_new (NULL);
2026 /* There's also a gtk_label_set_markup() without accel if you
2027 * don't have an accelerator key
2029 gtk_label_set_markup_with_mnemonic (GTK_LABEL (label),
2030 "This <span foreground=\"blue\" background=\"orange\">label</span> has "
2031 "<b>markup</b> _such as "
2032 "<big><i>Big Italics</i></big>\n"
2033 "<tt>Monospace font</tt>\n"
2034 "<u>Underline!</u>\n"
2036 "<span foreground=\"green\" background=\"red\">Ugly colors</span>\n"
2037 "and nothing on this line,\n"
2040 "or even on this one\n"
2041 "la <big>la <big>la <big>la <big>la</big></big></big></big>\n"
2042 "but this _word is <span foreground=\"purple\"><big>purple</big></span>\n"
2043 "<span underline=\"double\">We like <sup>superscript</sup> and <sub>subscript</sub> too</span>");
2045 g_assert (gtk_label_get_mnemonic_keyval (GTK_LABEL (label)) == GDK_KEY_s);
2047 gtk_container_add (GTK_CONTAINER (frame), label);
2048 gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
2051 if (!gtk_widget_get_visible (window))
2052 gtk_widget_show_all (window);
2054 gtk_widget_destroy (window);
2058 on_angle_scale_changed (GtkRange *range,
2061 gtk_label_set_angle (GTK_LABEL (label), gtk_range_get_value (range));
2065 create_rotated_label (GtkWidget *widget)
2067 static GtkWidget *window = NULL;
2068 GtkWidget *content_area;
2072 GtkWidget *scale_label;
2073 GtkWidget *scale_hbox;
2077 window = gtk_dialog_new_with_buttons ("Rotated Label",
2078 GTK_WINDOW (gtk_widget_get_toplevel (widget)), 0,
2079 GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE,
2082 gtk_window_set_resizable (GTK_WINDOW (window), TRUE);
2084 gtk_window_set_screen (GTK_WINDOW (window),
2085 gtk_widget_get_screen (widget));
2087 g_signal_connect (window, "response",
2088 G_CALLBACK (gtk_widget_destroy), NULL);
2089 g_signal_connect (window, "destroy",
2090 G_CALLBACK (gtk_widget_destroyed), &window);
2092 content_area = gtk_dialog_get_content_area (GTK_DIALOG (window));
2094 vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
2095 gtk_box_pack_start (GTK_BOX (content_area), vbox, TRUE, TRUE, 0);
2096 gtk_container_set_border_width (GTK_CONTAINER (vbox), 10);
2098 label = gtk_label_new (NULL);
2099 gtk_label_set_markup (GTK_LABEL (label), "Hello World\n<i>Rotate</i> <span underline='single' foreground='blue'>me</span>");
2100 gtk_box_pack_start (GTK_BOX (vbox), label, TRUE, TRUE, 0);
2102 scale_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
2103 gtk_box_pack_start (GTK_BOX (vbox), scale_hbox, FALSE, FALSE, 0);
2105 scale_label = gtk_label_new (NULL);
2106 gtk_label_set_markup (GTK_LABEL (scale_label), "<i>Angle: </i>");
2107 gtk_box_pack_start (GTK_BOX (scale_hbox), scale_label, FALSE, FALSE, 0);
2109 hscale = gtk_scale_new_with_range (GTK_ORIENTATION_HORIZONTAL,
2111 g_signal_connect (hscale, "value-changed",
2112 G_CALLBACK (on_angle_scale_changed), label);
2114 gtk_range_set_value (GTK_RANGE (hscale), 45);
2115 gtk_widget_set_size_request (hscale, 200, -1);
2116 gtk_box_pack_start (GTK_BOX (scale_hbox), hscale, TRUE, TRUE, 0);
2119 if (!gtk_widget_get_visible (window))
2120 gtk_widget_show_all (window);
2122 gtk_widget_destroy (window);
2125 #define DEFAULT_TEXT_RADIUS 200
2128 on_rotated_text_unrealize (GtkWidget *widget)
2130 g_object_set_data (G_OBJECT (widget), "text-gc", NULL);
2134 on_rotated_text_draw (GtkWidget *widget,
2136 GdkPixbuf *tile_pixbuf)
2138 static const gchar *words[] = { "The", "grand", "old", "Duke", "of", "York",
2139 "had", "10,000", "men" };
2144 PangoLayout *layout;
2145 PangoContext *context;
2146 PangoFontDescription *desc;
2150 gdk_cairo_set_source_pixbuf (cr, tile_pixbuf, 0, 0);
2151 cairo_pattern_set_extend (cairo_get_source (cr), CAIRO_EXTEND_REPEAT);
2154 cairo_set_source_rgb (cr, 0, 0, 0);
2156 width = gtk_widget_get_allocated_width (widget);
2157 height = gtk_widget_get_allocated_height (widget);
2158 radius = MIN (width, height) / 2.;
2160 cairo_translate (cr,
2161 radius + (width - 2 * radius) / 2,
2162 radius + (height - 2 * radius) / 2);
2163 cairo_scale (cr, radius / DEFAULT_TEXT_RADIUS, radius / DEFAULT_TEXT_RADIUS);
2165 context = gtk_widget_get_pango_context (widget);
2166 layout = pango_layout_new (context);
2167 desc = pango_font_description_from_string ("Sans Bold 30");
2168 pango_layout_set_font_description (layout, desc);
2169 pango_font_description_free (desc);
2171 n_words = G_N_ELEMENTS (words);
2172 for (i = 0; i < n_words; i++)
2178 cairo_rotate (cr, 2 * G_PI * i / n_words);
2179 pango_cairo_update_layout (cr, layout);
2181 pango_layout_set_text (layout, words[i], -1);
2182 pango_layout_get_size (layout, &width, &height);
2184 cairo_move_to (cr, - width / 2 / PANGO_SCALE, - DEFAULT_TEXT_RADIUS);
2185 pango_cairo_show_layout (cr, layout);
2190 g_object_unref (layout);
2196 create_rotated_text (GtkWidget *widget)
2198 static GtkWidget *window = NULL;
2202 const GdkRGBA white = { 1.0, 1.0, 1.0, 1.0 };
2203 GtkRequisition requisition;
2204 GtkWidget *content_area;
2205 GtkWidget *drawing_area;
2206 GdkPixbuf *tile_pixbuf;
2208 window = gtk_dialog_new_with_buttons ("Rotated Text",
2209 GTK_WINDOW (gtk_widget_get_toplevel (widget)), 0,
2210 GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE,
2213 gtk_window_set_resizable (GTK_WINDOW (window), TRUE);
2215 gtk_window_set_screen (GTK_WINDOW (window),
2216 gtk_widget_get_screen (widget));
2218 g_signal_connect (window, "response",
2219 G_CALLBACK (gtk_widget_destroy), NULL);
2220 g_signal_connect (window, "destroy",
2221 G_CALLBACK (gtk_widget_destroyed), &window);
2223 content_area = gtk_dialog_get_content_area (GTK_DIALOG (window));
2225 drawing_area = gtk_drawing_area_new ();
2226 gtk_box_pack_start (GTK_BOX (content_area), drawing_area, TRUE, TRUE, 0);
2227 gtk_widget_override_background_color (drawing_area, 0, &white);
2229 tile_pixbuf = gdk_pixbuf_new_from_file ("marble.xpm", NULL);
2231 g_signal_connect (drawing_area, "draw",
2232 G_CALLBACK (on_rotated_text_draw), tile_pixbuf);
2233 g_signal_connect (drawing_area, "unrealize",
2234 G_CALLBACK (on_rotated_text_unrealize), NULL);
2236 gtk_widget_show_all (gtk_bin_get_child (GTK_BIN (window)));
2238 gtk_widget_set_size_request (drawing_area, DEFAULT_TEXT_RADIUS * 2, DEFAULT_TEXT_RADIUS * 2);
2239 gtk_widget_get_preferred_size ( (window),
2240 &requisition, NULL);
2241 gtk_widget_set_size_request (drawing_area, -1, -1);
2242 gtk_window_resize (GTK_WINDOW (window), requisition.width, requisition.height);
2245 if (!gtk_widget_get_visible (window))
2246 gtk_widget_show (window);
2248 gtk_widget_destroy (window);
2256 reparent_label (GtkWidget *widget,
2257 GtkWidget *new_parent)
2261 label = g_object_get_data (G_OBJECT (widget), "user_data");
2263 gtk_widget_reparent (label, new_parent);
2267 set_parent_signal (GtkWidget *child,
2268 GtkWidget *old_parent,
2273 parent = gtk_widget_get_parent (child);
2274 g_message ("set_parent for \"%s\": new parent: \"%s\", old parent: \"%s\", data: %d\n",
2275 g_type_name (G_OBJECT_TYPE (child)),
2276 parent ? g_type_name (G_OBJECT_TYPE (parent)) : "NULL",
2277 old_parent ? g_type_name (G_OBJECT_TYPE (old_parent)) : "NULL",
2278 GPOINTER_TO_INT (func_data));
2282 create_reparent (GtkWidget *widget)
2284 static GtkWidget *window = NULL;
2291 GtkWidget *separator;
2292 GtkWidget *event_box;
2296 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
2298 gtk_window_set_screen (GTK_WINDOW (window),
2299 gtk_widget_get_screen (widget));
2301 g_signal_connect (window, "destroy",
2302 G_CALLBACK (gtk_widget_destroyed),
2305 gtk_window_set_title (GTK_WINDOW (window), "reparent");
2306 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
2308 box1 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
2309 gtk_container_add (GTK_CONTAINER (window), box1);
2311 box2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 5);
2312 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
2313 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
2315 label = gtk_label_new ("Hello World");
2317 frame = gtk_frame_new ("Frame 1");
2318 gtk_box_pack_start (GTK_BOX (box2), frame, TRUE, TRUE, 0);
2320 box3 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
2321 gtk_container_set_border_width (GTK_CONTAINER (box3), 5);
2322 gtk_container_add (GTK_CONTAINER (frame), box3);
2324 button = gtk_button_new_with_label ("switch");
2325 g_object_set_data (G_OBJECT (button), "user_data", label);
2326 gtk_box_pack_start (GTK_BOX (box3), button, FALSE, TRUE, 0);
2328 event_box = gtk_event_box_new ();
2329 gtk_box_pack_start (GTK_BOX (box3), event_box, FALSE, TRUE, 0);
2330 gtk_container_add (GTK_CONTAINER (event_box), label);
2332 g_signal_connect (button, "clicked",
2333 G_CALLBACK (reparent_label),
2336 g_signal_connect (label, "parent_set",
2337 G_CALLBACK (set_parent_signal),
2338 GINT_TO_POINTER (42));
2340 frame = gtk_frame_new ("Frame 2");
2341 gtk_box_pack_start (GTK_BOX (box2), frame, TRUE, TRUE, 0);
2343 box3 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
2344 gtk_container_set_border_width (GTK_CONTAINER (box3), 5);
2345 gtk_container_add (GTK_CONTAINER (frame), box3);
2347 button = gtk_button_new_with_label ("switch");
2348 g_object_set_data (G_OBJECT (button), "user_data", label);
2349 gtk_box_pack_start (GTK_BOX (box3), button, FALSE, TRUE, 0);
2351 event_box = gtk_event_box_new ();
2352 gtk_box_pack_start (GTK_BOX (box3), event_box, FALSE, TRUE, 0);
2354 g_signal_connect (button, "clicked",
2355 G_CALLBACK (reparent_label),
2358 separator = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
2359 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
2361 box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10);
2362 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
2363 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
2365 button = gtk_button_new_with_label ("close");
2366 g_signal_connect_swapped (button, "clicked",
2367 G_CALLBACK (gtk_widget_destroy), window);
2368 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
2369 gtk_widget_set_can_default (button, TRUE);
2370 gtk_widget_grab_default (button);
2373 if (!gtk_widget_get_visible (window))
2374 gtk_widget_show_all (window);
2376 gtk_widget_destroy (window);
2383 grippy_button_press (GtkWidget *area, GdkEventButton *event, GdkWindowEdge edge)
2385 if (event->type == GDK_BUTTON_PRESS)
2387 if (event->button == 1)
2388 gtk_window_begin_resize_drag (GTK_WINDOW (gtk_widget_get_toplevel (area)), edge,
2389 event->button, event->x_root, event->y_root,
2391 else if (event->button == 2)
2392 gtk_window_begin_move_drag (GTK_WINDOW (gtk_widget_get_toplevel (area)),
2393 event->button, event->x_root, event->y_root,
2400 grippy_draw (GtkWidget *area, cairo_t *cr, GdkWindowEdge edge)
2402 GtkStyleContext *context;
2403 GtkJunctionSides sides;
2407 case GDK_WINDOW_EDGE_NORTH_WEST:
2408 sides = GTK_JUNCTION_CORNER_TOPLEFT;
2410 case GDK_WINDOW_EDGE_NORTH:
2411 sides = GTK_JUNCTION_TOP;
2413 case GDK_WINDOW_EDGE_NORTH_EAST:
2414 sides = GTK_JUNCTION_CORNER_TOPRIGHT;
2416 case GDK_WINDOW_EDGE_WEST:
2417 sides = GTK_JUNCTION_LEFT;
2419 case GDK_WINDOW_EDGE_EAST:
2420 sides = GTK_JUNCTION_RIGHT;
2422 case GDK_WINDOW_EDGE_SOUTH_WEST:
2423 sides = GTK_JUNCTION_CORNER_BOTTOMLEFT;
2425 case GDK_WINDOW_EDGE_SOUTH:
2426 sides = GTK_JUNCTION_BOTTOM;
2428 case GDK_WINDOW_EDGE_SOUTH_EAST:
2429 sides = GTK_JUNCTION_CORNER_BOTTOMRIGHT;
2432 g_assert_not_reached();
2435 context = gtk_widget_get_style_context (area);
2436 gtk_style_context_save (context);
2437 gtk_style_context_add_class (context, "grip");
2438 gtk_style_context_set_junction_sides (context, sides);
2439 gtk_render_handle (context, cr,
2441 gtk_widget_get_allocated_width (area),
2442 gtk_widget_get_allocated_height (area));
2444 gtk_style_context_restore (context);
2450 create_resize_grips (GtkWidget *widget)
2452 static GtkWidget *window = NULL;
2454 GtkWidget *hbox, *vbox;
2457 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
2459 gtk_window_set_screen (GTK_WINDOW (window),
2460 gtk_widget_get_screen (widget));
2462 gtk_window_set_title (GTK_WINDOW (window), "resize grips");
2464 g_signal_connect (window, "destroy",
2465 G_CALLBACK (gtk_widget_destroyed),
2468 vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
2469 gtk_container_add (GTK_CONTAINER (window), vbox);
2471 hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
2472 gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 0);
2475 area = gtk_drawing_area_new ();
2476 gtk_widget_add_events (area, GDK_BUTTON_PRESS_MASK);
2477 gtk_box_pack_start (GTK_BOX (hbox), area, TRUE, TRUE, 0);
2478 g_signal_connect (area, "draw", G_CALLBACK (grippy_draw),
2479 GINT_TO_POINTER (GDK_WINDOW_EDGE_NORTH_WEST));
2480 g_signal_connect (area, "button_press_event", G_CALLBACK (grippy_button_press),
2481 GINT_TO_POINTER (GDK_WINDOW_EDGE_NORTH_WEST));
2484 area = gtk_drawing_area_new ();
2485 gtk_widget_add_events (area, GDK_BUTTON_PRESS_MASK);
2486 gtk_box_pack_start (GTK_BOX (hbox), area, TRUE, TRUE, 0);
2487 g_signal_connect (area, "draw", G_CALLBACK (grippy_draw),
2488 GINT_TO_POINTER (GDK_WINDOW_EDGE_NORTH));
2489 g_signal_connect (area, "button_press_event", G_CALLBACK (grippy_button_press),
2490 GINT_TO_POINTER (GDK_WINDOW_EDGE_NORTH));
2493 area = gtk_drawing_area_new ();
2494 gtk_widget_add_events (area, GDK_BUTTON_PRESS_MASK);
2495 gtk_box_pack_start (GTK_BOX (hbox), area, TRUE, TRUE, 0);
2496 g_signal_connect (area, "draw", G_CALLBACK (grippy_draw),
2497 GINT_TO_POINTER (GDK_WINDOW_EDGE_NORTH_EAST));
2498 g_signal_connect (area, "button_press_event", G_CALLBACK (grippy_button_press),
2499 GINT_TO_POINTER (GDK_WINDOW_EDGE_NORTH_EAST));
2501 hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
2502 gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 0);
2505 area = gtk_drawing_area_new ();
2506 gtk_widget_add_events (area, GDK_BUTTON_PRESS_MASK);
2507 gtk_box_pack_start (GTK_BOX (hbox), area, TRUE, TRUE, 0);
2508 g_signal_connect (area, "draw", G_CALLBACK (grippy_draw),
2509 GINT_TO_POINTER (GDK_WINDOW_EDGE_WEST));
2510 g_signal_connect (area, "button_press_event", G_CALLBACK (grippy_button_press),
2511 GINT_TO_POINTER (GDK_WINDOW_EDGE_WEST));
2514 area = gtk_drawing_area_new ();
2515 gtk_box_pack_start (GTK_BOX (hbox), area, TRUE, TRUE, 0);
2518 area = gtk_drawing_area_new ();
2519 gtk_widget_add_events (area, GDK_BUTTON_PRESS_MASK);
2520 gtk_box_pack_start (GTK_BOX (hbox), area, TRUE, TRUE, 0);
2521 g_signal_connect (area, "draw", G_CALLBACK (grippy_draw),
2522 GINT_TO_POINTER (GDK_WINDOW_EDGE_EAST));
2523 g_signal_connect (area, "button_press_event", G_CALLBACK (grippy_button_press),
2524 GINT_TO_POINTER (GDK_WINDOW_EDGE_EAST));
2527 hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
2528 gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 0);
2531 area = gtk_drawing_area_new ();
2532 gtk_widget_add_events (area, GDK_BUTTON_PRESS_MASK);
2533 gtk_box_pack_start (GTK_BOX (hbox), area, TRUE, TRUE, 0);
2534 g_signal_connect (area, "draw", G_CALLBACK (grippy_draw),
2535 GINT_TO_POINTER (GDK_WINDOW_EDGE_SOUTH_WEST));
2536 g_signal_connect (area, "button_press_event", G_CALLBACK (grippy_button_press),
2537 GINT_TO_POINTER (GDK_WINDOW_EDGE_SOUTH_WEST));
2539 area = gtk_drawing_area_new ();
2540 gtk_widget_add_events (area, GDK_BUTTON_PRESS_MASK);
2541 gtk_box_pack_start (GTK_BOX (hbox), area, TRUE, TRUE, 0);
2542 g_signal_connect (area, "draw", G_CALLBACK (grippy_draw),
2543 GINT_TO_POINTER (GDK_WINDOW_EDGE_SOUTH));
2544 g_signal_connect (area, "button_press_event", G_CALLBACK (grippy_button_press),
2545 GINT_TO_POINTER (GDK_WINDOW_EDGE_SOUTH));
2548 area = gtk_drawing_area_new ();
2549 gtk_widget_add_events (area, GDK_BUTTON_PRESS_MASK);
2550 gtk_box_pack_start (GTK_BOX (hbox), area, TRUE, TRUE, 0);
2551 g_signal_connect (area, "draw", G_CALLBACK (grippy_draw),
2552 GINT_TO_POINTER (GDK_WINDOW_EDGE_SOUTH_EAST));
2553 g_signal_connect (area, "button_press_event", G_CALLBACK (grippy_button_press),
2554 GINT_TO_POINTER (GDK_WINDOW_EDGE_SOUTH_EAST));
2557 if (!gtk_widget_get_visible (window))
2558 gtk_widget_show_all (window);
2560 gtk_widget_destroy (window);
2566 gint upositionx = 0;
2567 gint upositiony = 0;
2570 uposition_configure (GtkWidget *window)
2576 lx = g_object_get_data (G_OBJECT (window), "x");
2577 ly = g_object_get_data (G_OBJECT (window), "y");
2579 gdk_window_get_root_origin (gtk_widget_get_window (window),
2580 &upositionx, &upositiony);
2581 sprintf (buffer, "%d", upositionx);
2582 gtk_label_set_text (lx, buffer);
2583 sprintf (buffer, "%d", upositiony);
2584 gtk_label_set_text (ly, buffer);
2590 uposition_stop_configure (GtkToggleButton *toggle,
2593 if (gtk_toggle_button_get_active (toggle))
2594 g_signal_handlers_block_by_func (window, G_CALLBACK (uposition_configure), NULL);
2596 g_signal_handlers_unblock_by_func (window, G_CALLBACK (uposition_configure), NULL);
2600 create_saved_position (GtkWidget *widget)
2602 static GtkWidget *window = NULL;
2607 GtkWidget *main_vbox;
2615 window = g_object_connect (g_object_new (GTK_TYPE_WINDOW,
2616 "type", GTK_WINDOW_TOPLEVEL,
2617 "title", "Saved Position",
2619 "signal::configure_event", uposition_configure, NULL,
2622 gtk_window_move (GTK_WINDOW (window), upositionx, upositiony);
2624 gtk_window_set_screen (GTK_WINDOW (window),
2625 gtk_widget_get_screen (widget));
2628 g_signal_connect (window, "destroy",
2629 G_CALLBACK (gtk_widget_destroyed),
2632 main_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
2633 gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 0);
2634 gtk_container_add (GTK_CONTAINER (window), main_vbox);
2637 g_object_new (GTK_TYPE_BOX,
2638 "orientation", GTK_ORIENTATION_VERTICAL,
2639 "GtkBox::homogeneous", FALSE,
2640 "GtkBox::spacing", 5,
2641 "GtkContainer::border_width", 10,
2642 "GtkWidget::parent", main_vbox,
2643 "GtkWidget::visible", TRUE,
2644 "child", g_object_connect (g_object_new (GTK_TYPE_TOGGLE_BUTTON,
2645 "label", "Stop Events",
2649 "signal::clicked", uposition_stop_configure, window,
2653 hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
2654 gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
2655 gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0);
2657 label = gtk_label_new ("X Origin : ");
2658 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
2659 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
2661 x_label = gtk_label_new ("");
2662 gtk_box_pack_start (GTK_BOX (hbox), x_label, TRUE, TRUE, 0);
2663 g_object_set_data (G_OBJECT (window), "x", x_label);
2665 hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
2666 gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
2667 gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0);
2669 label = gtk_label_new ("Y Origin : ");
2670 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
2671 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
2673 y_label = gtk_label_new ("");
2674 gtk_box_pack_start (GTK_BOX (hbox), y_label, TRUE, TRUE, 0);
2675 g_object_set_data (G_OBJECT (window), "y", y_label);
2678 g_object_new (gtk_separator_get_type (),
2679 "GtkWidget::visible", TRUE,
2681 gtk_box_pack_start (GTK_BOX (main_vbox), any, FALSE, TRUE, 0);
2683 hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
2684 gtk_container_set_border_width (GTK_CONTAINER (hbox), 10);
2685 gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, TRUE, 0);
2687 button = gtk_button_new_with_label ("Close");
2688 g_signal_connect_swapped (button, "clicked",
2689 G_CALLBACK (gtk_widget_destroy),
2691 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
2692 gtk_widget_set_can_default (button, TRUE);
2693 gtk_widget_grab_default (button);
2695 gtk_widget_show_all (window);
2698 gtk_widget_destroy (window);
2706 create_pixbuf (GtkWidget *widget)
2708 static GtkWidget *window = NULL;
2714 GtkWidget *separator;
2715 GtkWidget *pixbufwid;
2716 GdkWindow *gdk_window;
2720 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
2722 gtk_window_set_screen (GTK_WINDOW (window),
2723 gtk_widget_get_screen (widget));
2725 g_signal_connect (window, "destroy",
2726 G_CALLBACK (gtk_widget_destroyed),
2729 gtk_window_set_title (GTK_WINDOW (window), "GtkPixmap");
2730 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
2731 gtk_widget_realize(window);
2733 box1 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
2734 gtk_container_add (GTK_CONTAINER (window), box1);
2736 box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10);
2737 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
2738 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
2740 button = gtk_button_new ();
2741 gtk_box_pack_start (GTK_BOX (box2), button, FALSE, FALSE, 0);
2743 gdk_window = gtk_widget_get_window (window);
2745 pixbufwid = new_pixbuf ("test.xpm", gdk_window);
2747 label = gtk_label_new ("Pixbuf\ntest");
2748 box3 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
2749 gtk_container_set_border_width (GTK_CONTAINER (box3), 2);
2750 gtk_container_add (GTK_CONTAINER (box3), pixbufwid);
2751 gtk_container_add (GTK_CONTAINER (box3), label);
2752 gtk_container_add (GTK_CONTAINER (button), box3);
2754 button = gtk_button_new ();
2755 gtk_box_pack_start (GTK_BOX (box2), button, FALSE, FALSE, 0);
2757 pixbufwid = new_pixbuf ("test.xpm", gdk_window);
2759 label = gtk_label_new ("Pixbuf\ntest");
2760 box3 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
2761 gtk_container_set_border_width (GTK_CONTAINER (box3), 2);
2762 gtk_container_add (GTK_CONTAINER (box3), pixbufwid);
2763 gtk_container_add (GTK_CONTAINER (box3), label);
2764 gtk_container_add (GTK_CONTAINER (button), box3);
2766 gtk_widget_set_sensitive (button, FALSE);
2768 separator = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
2769 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
2771 box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10);
2772 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
2773 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
2775 button = gtk_button_new_with_label ("close");
2776 g_signal_connect_swapped (button, "clicked",
2777 G_CALLBACK (gtk_widget_destroy),
2779 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
2780 gtk_widget_set_can_default (button, TRUE);
2781 gtk_widget_grab_default (button);
2784 if (!gtk_widget_get_visible (window))
2785 gtk_widget_show_all (window);
2787 gtk_widget_destroy (window);
2791 create_tooltips (GtkWidget *widget)
2793 static GtkWidget *window = NULL;
2800 GtkWidget *separator;
2805 g_object_new (gtk_window_get_type (),
2806 "GtkWindow::type", GTK_WINDOW_TOPLEVEL,
2807 "GtkContainer::border_width", 0,
2808 "GtkWindow::title", "Tooltips",
2809 "GtkWindow::resizable", FALSE,
2812 gtk_window_set_screen (GTK_WINDOW (window),
2813 gtk_widget_get_screen (widget));
2815 box1 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
2816 gtk_container_add (GTK_CONTAINER (window), box1);
2818 box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10);
2819 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
2820 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
2822 button = gtk_toggle_button_new_with_label ("button1");
2823 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
2825 gtk_widget_set_tooltip_text (button, "This is button 1");
2827 button = gtk_toggle_button_new_with_label ("button2");
2828 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
2830 gtk_widget_set_tooltip_text (button,
2831 "This is button 2. This is also a really long tooltip which probably "
2832 "won't fit on a single line and will therefore need to be wrapped. "
2833 "Hopefully the wrapping will work correctly.");
2835 toggle = gtk_toggle_button_new_with_label ("Override TipsQuery Label");
2836 gtk_box_pack_start (GTK_BOX (box2), toggle, TRUE, TRUE, 0);
2838 gtk_widget_set_tooltip_text (toggle, "Toggle TipsQuery view.");
2841 g_object_new (GTK_TYPE_BOX,
2842 "orientation", GTK_ORIENTATION_VERTICAL,
2843 "homogeneous", FALSE,
2850 g_object_new (gtk_button_get_type (),
2855 gtk_box_set_child_packing (GTK_BOX (box3), button, FALSE, FALSE, 0, GTK_PACK_START);
2856 gtk_widget_set_tooltip_text (button, "Start the Tooltips Inspector");
2858 frame = g_object_new (gtk_frame_get_type (),
2859 "label", "ToolTips Inspector",
2860 "label_xalign", (double) 0.5,
2866 gtk_box_set_child_packing (GTK_BOX (box2), frame, TRUE, TRUE, 10, GTK_PACK_START);
2868 separator = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
2869 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
2871 box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10);
2872 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
2873 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
2875 button = gtk_button_new_with_label ("close");
2876 g_signal_connect_swapped (button, "clicked",
2877 G_CALLBACK (gtk_widget_destroy),
2879 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
2880 gtk_widget_set_can_default (button, TRUE);
2881 gtk_widget_grab_default (button);
2883 gtk_widget_set_tooltip_text (button, "Push this button to close window");
2886 if (!gtk_widget_get_visible (window))
2887 gtk_widget_show_all (window);
2889 gtk_widget_destroy (window);
2897 pack_image (GtkWidget *box,
2901 gtk_box_pack_start (GTK_BOX (box),
2902 gtk_label_new (text),
2905 gtk_box_pack_start (GTK_BOX (box),
2911 create_image (GtkWidget *widget)
2913 static GtkWidget *window = NULL;
2920 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
2922 gtk_window_set_screen (GTK_WINDOW (window),
2923 gtk_widget_get_screen (widget));
2925 /* this is bogus for testing drawing when allocation < request,
2926 * don't copy into real code
2928 gtk_window_set_resizable (GTK_WINDOW (window), TRUE);
2930 g_signal_connect (window, "destroy",
2931 G_CALLBACK (gtk_widget_destroyed),
2934 vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
2936 gtk_container_add (GTK_CONTAINER (window), vbox);
2938 pack_image (vbox, "Stock Warning Dialog",
2939 gtk_image_new_from_stock (GTK_STOCK_DIALOG_WARNING,
2940 GTK_ICON_SIZE_DIALOG));
2942 pixbuf = gdk_pixbuf_new_from_xpm_data ((const char **) openfile);
2944 pack_image (vbox, "Pixbuf",
2945 gtk_image_new_from_pixbuf (pixbuf));
2947 g_object_unref (pixbuf);
2950 if (!gtk_widget_get_visible (window))
2951 gtk_widget_show_all (window);
2953 gtk_widget_destroy (window);
2961 create_menu (GdkScreen *screen, gint depth, gint length, gboolean tearoff)
2964 GtkWidget *menuitem;
2973 menu = gtk_menu_new ();
2974 gtk_menu_set_screen (GTK_MENU (menu), screen);
2980 menuitem = gtk_tearoff_menu_item_new ();
2981 gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
2982 gtk_widget_show (menuitem);
2985 image = gtk_image_new_from_stock (GTK_STOCK_OPEN,
2986 GTK_ICON_SIZE_MENU);
2987 gtk_widget_show (image);
2988 menuitem = gtk_image_menu_item_new_with_label ("Image item");
2989 gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menuitem), image);
2990 gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
2991 gtk_widget_show (menuitem);
2993 for (i = 0, j = 1; i < length; i++, j++)
2995 sprintf (buf, "item %2d - %d", depth, j);
2997 menuitem = gtk_radio_menu_item_new_with_label (group, buf);
2998 group = gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (menuitem));
3000 gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
3001 gtk_widget_show (menuitem);
3003 gtk_widget_set_sensitive (menuitem, FALSE);
3006 gtk_check_menu_item_set_inconsistent (GTK_CHECK_MENU_ITEM (menuitem),
3010 gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem),
3011 create_menu (screen, depth - 1, 5, TRUE));
3018 create_table_menu (GdkScreen *screen, gint cols, gint rows, gboolean tearoff)
3021 GtkWidget *menuitem;
3027 menu = gtk_menu_new ();
3028 gtk_menu_set_screen (GTK_MENU (menu), screen);
3033 menuitem = gtk_tearoff_menu_item_new ();
3034 gtk_menu_attach (GTK_MENU (menu), menuitem, 0, cols, j, j + 1);
3035 gtk_widget_show (menuitem);
3039 menuitem = gtk_menu_item_new_with_label ("items");
3040 gtk_menu_attach (GTK_MENU (menu), menuitem, 0, cols, j, j + 1);
3042 submenu = gtk_menu_new ();
3043 gtk_menu_set_screen (GTK_MENU (submenu), screen);
3044 gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), submenu);
3045 gtk_widget_show (menuitem);
3048 /* now fill the items submenu */
3049 image = gtk_image_new_from_stock (GTK_STOCK_HELP,
3050 GTK_ICON_SIZE_MENU);
3051 gtk_widget_show (image);
3052 menuitem = gtk_image_menu_item_new_with_label ("Image");
3053 gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menuitem), image);
3054 gtk_menu_attach (GTK_MENU (submenu), menuitem, 0, 1, 0, 1);
3055 gtk_widget_show (menuitem);
3057 menuitem = gtk_menu_item_new_with_label ("x");
3058 gtk_menu_attach (GTK_MENU (submenu), menuitem, 1, 2, 0, 1);
3059 gtk_widget_show (menuitem);
3061 menuitem = gtk_menu_item_new_with_label ("x");
3062 gtk_menu_attach (GTK_MENU (submenu), menuitem, 0, 1, 1, 2);
3063 gtk_widget_show (menuitem);
3065 image = gtk_image_new_from_stock (GTK_STOCK_HELP,
3066 GTK_ICON_SIZE_MENU);
3067 gtk_widget_show (image);
3068 menuitem = gtk_image_menu_item_new_with_label ("Image");
3069 gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menuitem), image);
3070 gtk_menu_attach (GTK_MENU (submenu), menuitem, 1, 2, 1, 2);
3071 gtk_widget_show (menuitem);
3073 menuitem = gtk_radio_menu_item_new_with_label (NULL, "Radio");
3074 gtk_menu_attach (GTK_MENU (submenu), menuitem, 0, 1, 2, 3);
3075 gtk_widget_show (menuitem);
3077 menuitem = gtk_menu_item_new_with_label ("x");
3078 gtk_menu_attach (GTK_MENU (submenu), menuitem, 1, 2, 2, 3);
3079 gtk_widget_show (menuitem);
3081 menuitem = gtk_menu_item_new_with_label ("x");
3082 gtk_menu_attach (GTK_MENU (submenu), menuitem, 0, 1, 3, 4);
3083 gtk_widget_show (menuitem);
3085 menuitem = gtk_radio_menu_item_new_with_label (NULL, "Radio");
3086 gtk_menu_attach (GTK_MENU (submenu), menuitem, 1, 2, 3, 4);
3087 gtk_widget_show (menuitem);
3089 menuitem = gtk_check_menu_item_new_with_label ("Check");
3090 gtk_menu_attach (GTK_MENU (submenu), menuitem, 0, 1, 4, 5);
3091 gtk_widget_show (menuitem);
3093 menuitem = gtk_menu_item_new_with_label ("x");
3094 gtk_menu_attach (GTK_MENU (submenu), menuitem, 1, 2, 4, 5);
3095 gtk_widget_show (menuitem);
3097 menuitem = gtk_menu_item_new_with_label ("x");
3098 gtk_menu_attach (GTK_MENU (submenu), menuitem, 0, 1, 5, 6);
3099 gtk_widget_show (menuitem);
3101 menuitem = gtk_check_menu_item_new_with_label ("Check");
3102 gtk_menu_attach (GTK_MENU (submenu), menuitem, 1, 2, 5, 6);
3103 gtk_widget_show (menuitem);
3105 menuitem = gtk_menu_item_new_with_label ("1. Inserted normally (8)");
3106 gtk_widget_show (menuitem);
3107 gtk_menu_shell_insert (GTK_MENU_SHELL (submenu), menuitem, 8);
3109 menuitem = gtk_menu_item_new_with_label ("2. Inserted normally (2)");
3110 gtk_widget_show (menuitem);
3111 gtk_menu_shell_insert (GTK_MENU_SHELL (submenu), menuitem, 2);
3113 menuitem = gtk_menu_item_new_with_label ("3. Inserted normally (0)");
3114 gtk_widget_show (menuitem);
3115 gtk_menu_shell_insert (GTK_MENU_SHELL (submenu), menuitem, 0);
3117 menuitem = gtk_menu_item_new_with_label ("4. Inserted normally (-1)");
3118 gtk_widget_show (menuitem);
3119 gtk_menu_shell_insert (GTK_MENU_SHELL (submenu), menuitem, -1);
3121 /* end of items submenu */
3123 menuitem = gtk_menu_item_new_with_label ("spanning");
3124 gtk_menu_attach (GTK_MENU (menu), menuitem, 0, cols, j, j + 1);
3126 submenu = gtk_menu_new ();
3127 gtk_menu_set_screen (GTK_MENU (submenu), screen);
3128 gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), submenu);
3129 gtk_widget_show (menuitem);
3132 /* now fill the spanning submenu */
3133 menuitem = gtk_menu_item_new_with_label ("a");
3134 gtk_menu_attach (GTK_MENU (submenu), menuitem, 0, 2, 0, 1);
3135 gtk_widget_show (menuitem);
3137 menuitem = gtk_menu_item_new_with_label ("b");
3138 gtk_menu_attach (GTK_MENU (submenu), menuitem, 2, 3, 0, 2);
3139 gtk_widget_show (menuitem);
3141 menuitem = gtk_menu_item_new_with_label ("c");
3142 gtk_menu_attach (GTK_MENU (submenu), menuitem, 0, 1, 1, 3);
3143 gtk_widget_show (menuitem);
3145 menuitem = gtk_menu_item_new_with_label ("d");
3146 gtk_menu_attach (GTK_MENU (submenu), menuitem, 1, 2, 1, 2);
3147 gtk_widget_show (menuitem);
3149 menuitem = gtk_menu_item_new_with_label ("e");
3150 gtk_menu_attach (GTK_MENU (submenu), menuitem, 1, 3, 2, 3);
3151 gtk_widget_show (menuitem);
3152 /* end of spanning submenu */
3154 menuitem = gtk_menu_item_new_with_label ("left");
3155 gtk_menu_attach (GTK_MENU (menu), menuitem, 0, 1, j, j + 1);
3156 submenu = gtk_menu_new ();
3157 gtk_menu_set_screen (GTK_MENU (submenu), screen);
3158 gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), submenu);
3159 gtk_widget_show (menuitem);
3161 menuitem = gtk_menu_item_new_with_label ("Empty");
3162 gtk_menu_attach (GTK_MENU (submenu), menuitem, 0, 1, 0, 1);
3163 submenu = gtk_menu_new ();
3164 gtk_menu_set_screen (GTK_MENU (submenu), screen);
3165 gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), submenu);
3166 gtk_widget_show (menuitem);
3168 menuitem = gtk_menu_item_new_with_label ("right");
3169 gtk_menu_attach (GTK_MENU (menu), menuitem, 1, 2, j, j + 1);
3170 submenu = gtk_menu_new ();
3171 gtk_menu_set_screen (GTK_MENU (submenu), screen);
3172 gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), submenu);
3173 gtk_widget_show (menuitem);
3175 menuitem = gtk_menu_item_new_with_label ("Empty");
3176 gtk_menu_attach (GTK_MENU (submenu), menuitem, 0, 1, 0, 1);
3177 gtk_widget_show (menuitem);
3181 for (; j < rows; j++)
3182 for (i = 0; i < cols; i++)
3184 sprintf (buf, "(%d %d)", i, j);
3185 menuitem = gtk_menu_item_new_with_label (buf);
3186 gtk_menu_attach (GTK_MENU (menu), menuitem, i, i + 1, j, j + 1);
3187 gtk_widget_show (menuitem);
3190 menuitem = gtk_menu_item_new_with_label ("1. Inserted normally (8)");
3191 gtk_menu_shell_insert (GTK_MENU_SHELL (menu), menuitem, 8);
3192 gtk_widget_show (menuitem);
3193 menuitem = gtk_menu_item_new_with_label ("2. Inserted normally (2)");
3194 gtk_menu_shell_insert (GTK_MENU_SHELL (menu), menuitem, 2);
3195 gtk_widget_show (menuitem);
3196 menuitem = gtk_menu_item_new_with_label ("3. Inserted normally (0)");
3197 gtk_menu_shell_insert (GTK_MENU_SHELL (menu), menuitem, 0);
3198 gtk_widget_show (menuitem);
3199 menuitem = gtk_menu_item_new_with_label ("4. Inserted normally (-1)");
3200 gtk_menu_shell_insert (GTK_MENU_SHELL (menu), menuitem, -1);
3201 gtk_widget_show (menuitem);
3207 create_menus (GtkWidget *widget)
3209 static GtkWidget *window = NULL;
3213 GtkWidget *optionmenu;
3214 GtkWidget *separator;
3220 GtkWidget *menuitem;
3221 GtkAccelGroup *accel_group;
3223 GdkScreen *screen = gtk_widget_get_screen (widget);
3225 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
3227 gtk_window_set_screen (GTK_WINDOW (window), screen);
3229 g_signal_connect (window, "destroy",
3230 G_CALLBACK (gtk_widget_destroyed),
3232 g_signal_connect (window, "delete-event",
3233 G_CALLBACK (gtk_true),
3236 accel_group = gtk_accel_group_new ();
3237 gtk_window_add_accel_group (GTK_WINDOW (window), accel_group);
3239 gtk_window_set_title (GTK_WINDOW (window), "menus");
3240 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
3243 box1 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
3244 gtk_container_add (GTK_CONTAINER (window), box1);
3245 gtk_widget_show (box1);
3247 menubar = gtk_menu_bar_new ();
3248 gtk_box_pack_start (GTK_BOX (box1), menubar, FALSE, TRUE, 0);
3249 gtk_widget_show (menubar);
3251 menu = create_menu (screen, 2, 50, TRUE);
3253 menuitem = gtk_menu_item_new_with_label ("test\nline2");
3254 gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), menu);
3255 gtk_menu_shell_append (GTK_MENU_SHELL (menubar), menuitem);
3256 gtk_widget_show (menuitem);
3258 menu = create_table_menu (screen, 2, 50, TRUE);
3260 menuitem = gtk_menu_item_new_with_label ("table");
3261 gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), menu);
3262 gtk_menu_shell_append (GTK_MENU_SHELL (menubar), menuitem);
3263 gtk_widget_show (menuitem);
3265 menuitem = gtk_menu_item_new_with_label ("foo");
3266 gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), create_menu (screen, 3, 5, TRUE));
3267 gtk_menu_shell_append (GTK_MENU_SHELL (menubar), menuitem);
3268 gtk_widget_show (menuitem);
3270 image = gtk_image_new_from_stock (GTK_STOCK_HELP,
3271 GTK_ICON_SIZE_MENU);
3272 gtk_widget_show (image);
3273 menuitem = gtk_image_menu_item_new_with_label ("Help");
3274 gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menuitem), image);
3275 gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), create_menu (screen, 4, 5, TRUE));
3276 gtk_widget_set_hexpand (menuitem, TRUE);
3277 gtk_widget_set_halign (menuitem, GTK_ALIGN_END);
3278 gtk_menu_shell_append (GTK_MENU_SHELL (menubar), menuitem);
3279 gtk_widget_show (menuitem);
3281 menubar = gtk_menu_bar_new ();
3282 gtk_box_pack_start (GTK_BOX (box1), menubar, FALSE, TRUE, 0);
3283 gtk_widget_show (menubar);
3285 menu = create_menu (screen, 2, 10, TRUE);
3287 menuitem = gtk_menu_item_new_with_label ("Second menu bar");
3288 gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), menu);
3289 gtk_menu_shell_append (GTK_MENU_SHELL (menubar), menuitem);
3290 gtk_widget_show (menuitem);
3292 box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10);
3293 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
3294 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
3295 gtk_widget_show (box2);
3297 menu = create_menu (screen, 1, 5, FALSE);
3298 gtk_menu_set_accel_group (GTK_MENU (menu), accel_group);
3300 menuitem = gtk_image_menu_item_new_from_stock (GTK_STOCK_NEW, accel_group);
3301 gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
3302 gtk_widget_show (menuitem);
3304 menuitem = gtk_check_menu_item_new_with_label ("Accelerate Me");
3305 gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
3306 gtk_widget_show (menuitem);
3307 gtk_widget_add_accelerator (menuitem,
3313 menuitem = gtk_check_menu_item_new_with_label ("Accelerator Locked");
3314 gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
3315 gtk_widget_show (menuitem);
3316 gtk_widget_add_accelerator (menuitem,
3321 GTK_ACCEL_VISIBLE | GTK_ACCEL_LOCKED);
3322 menuitem = gtk_check_menu_item_new_with_label ("Accelerators Frozen");
3323 gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
3324 gtk_widget_show (menuitem);
3325 gtk_widget_add_accelerator (menuitem,
3331 gtk_widget_add_accelerator (menuitem,
3338 optionmenu = gtk_combo_box_text_new ();
3339 gtk_combo_box_set_active (GTK_COMBO_BOX (optionmenu), 3);
3340 gtk_box_pack_start (GTK_BOX (box2), optionmenu, TRUE, TRUE, 0);
3341 gtk_widget_show (optionmenu);
3343 separator = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
3344 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
3345 gtk_widget_show (separator);
3347 box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10);
3348 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
3349 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
3350 gtk_widget_show (box2);
3352 button = gtk_button_new_with_label ("close");
3353 g_signal_connect_swapped (button, "clicked",
3354 G_CALLBACK (gtk_widget_destroy),
3356 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
3357 gtk_widget_set_can_default (button, TRUE);
3358 gtk_widget_grab_default (button);
3359 gtk_widget_show (button);
3362 if (!gtk_widget_get_visible (window))
3363 gtk_widget_show (window);
3365 gtk_widget_destroy (window);
3368 /* GdkPixbuf RGBA C-Source image dump */
3370 static const guint8 apple[] =
3372 /* Pixbuf magic (0x47646b50) */
3374 /* length: header (24) + pixel_data (2304) */
3376 /* pixdata_type (0x1010002) */
3378 /* rowstride (96) */
3385 "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
3386 "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
3387 "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
3388 "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
3389 "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
3390 "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
3391 "\0\0\0\0\0\0\0\0\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"
3392 "\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"
3393 "\0\0\0\0\0\0\0\0\0\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"
3394 "[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"
3395 "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
3396 "\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"
3397 "\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"
3398 "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
3399 "\0\0\0\0\0\0`l\\\20iw_\356y\211h\373x\207g\364~\216i\364u\204e\366gt"
3400 "_\374^jX\241A;-_\0\0\0~\0\0\0\0SM4)SM21B9&\22\320\270\204\1\320\270\204"
3401 "\0\0\0\0\0\0\0\0\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"
3402 "]\212r\200c\366v\205f\371jx_\323_kY\232_kZH^jY\26]iW\211@G9\272:6%j\220"
3403 "\211]\320\221\211`\377\212\203Z\377~xP\377mkE\331]^;|/0\37\21\0\0\0\0"
3404 "\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["
3405 "eT<\216\200Z\203\227\211_\354\234\217c\377\232\217b\362\232\220c\337"
3406 "\243\233k\377\252\241p\377\250\236p\377\241\225h\377\231\214_\377\210"
3407 "\202U\377srI\377[]:\355KO0U\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0i"
3408 "v^\200`lY\211^jY\"\0\0\0\0\221\204\\\273\250\233r\377\302\267\224\377"
3409 "\311\300\237\377\272\256\204\377\271\256\177\377\271\257\200\377\267"
3410 "\260\177\377\260\251x\377\250\236l\377\242\225e\377\226\213]\377~zP\377"
3411 "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"
3412 "\0\213\203[v\253\240t\377\334\326\301\377\344\340\317\377\321\312\253"
3413 "\377\303\271\217\377\300\270\213\377\277\267\210\377\272\264\203\377"
3414 "\261\255z\377\250\242n\377\243\232h\377\232\220`\377\210\202V\377nnE"
3415 "\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"
3416 "\234\222e\362\304\274\232\377\337\333\306\377\332\325\273\377\311\302"
3417 "\232\377\312\303\236\377\301\273\216\377\300\271\212\377\270\264\200"
3418 "\377\256\253v\377\246\243n\377\236\232h\377\230\220`\377\213\203V\377"
3419 "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"
3420 "\203Zl\242\234l\377\321\315\260\377\331\324\271\377\320\313\251\377\307"
3421 "\301\232\377\303\276\224\377\300\272\214\377\274\267\206\377\264\260"
3422 "|\377\253\251s\377\244\243n\377\232\230e\377\223\216^\377\207\200U\377"
3423 "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"
3424 "\210\204Y\240\245\237o\377\316\310\253\377\310\303\237\377\304\300\230"
3425 "\377\303\277\225\377\277\272\216\377\274\270\210\377\266\263\200\377"
3426 "\256\254v\377\247\246p\377\237\236j\377\227\226d\377\215\212[\377\203"
3427 "\177T\377qsH\377X]8\377FN.\377DK-\200\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
3428 "\0\0\0\0\207\204X\257\244\240o\377\300\275\231\377\301\275\226\377\274"
3429 "\270\213\377\274\270\214\377\267\264\205\377\264\262\200\377\260\256"
3430 "z\377\251\251s\377\243\244n\377\231\232g\377\220\222`\377\210\211Y\377"
3431 "|}Q\377hlC\377PU3\377CK,\377DL/Y\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
3432 "\0\0\205\204X\220\232\230h\377\261\260\204\377\266\264\212\377\261\260"
3433 "\201\377\263\260\200\377\260\257}\377\256\256x\377\253\254t\377\244\246"
3434 "o\377\233\236i\377\221\224b\377\211\214\\\377\202\204V\377txM\377]b>"
3435 "\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>"
3436 "\215\215_\377\237\237r\377\247\247x\377\247\247t\377\252\252w\377\252"
3437 "\252u\377\252\253t\377\243\246o\377\235\240j\377\223\230c\377\213\217"
3438 "]\377\201\206V\377x}P\377gkD\377RY5\377BI,\377AI,\262\0\0\0\0\0\0\0\0"
3439 "\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"
3440 "\232g\377\234\236i\377\236\241l\377\241\244n\377\240\244m\377\232\237"
3441 "i\377\223\230c\377\212\221]\377\200\210W\377v|P\377jnG\377Za>\377HP2"
3442 "\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"
3443 "\0wzQ6\177\201U\371\206\211Z\377\216\222`\377\220\225a\377\220\225b\377"
3444 "\220\226a\377\213\221_\377\204\213Z\377{\203R\377ryN\377iqH\377^fA\377"
3445 "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"
3446 "\0\0\0\0\0\0\0\0\0\0\0\0ptJTw|Q\371z\177R\377}\202T\377|\203T\377z\200"
3447 "R\377v|O\377pwL\377jpF\377dlB\377`hB\377Yb@\377LT6\377<C*\377\11\12\6"
3448 "\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"
3449 "\0\0\0\0\0\0\0\0\0\0\\`=UgnE\370hnG\377gmE\377djB\377]d>\377[c<\377Y"
3450 "b<\377Zc>\377V_>\377OW8\377BK/\377\16\20\12\377\0\0\0\377\0\0\0\377\0"
3451 "\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"
3452 "\0\1\0\0\0\40\22\24\15\260@D+\377W`;\377OV5\377.3\36\377.3\37\377IP0"
3453 "\377RZ7\377PZ8\3776=&\377\14\15\10\377\0\0\0\377\0\0\0\377\0\0\0\377"
3454 "\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"
3455 "\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"
3456 "\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"
3457 "\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"
3458 "\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"
3459 "\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"
3460 "\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"
3461 "\0\0\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"
3462 "\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"
3463 "\0\0\5\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"};
3467 accel_button_new (GtkAccelGroup *accel_group,
3472 GdkModifierType modifiers;
3476 gtk_accelerator_parse (accel, &keyval, &modifiers);
3479 button = gtk_button_new ();
3480 gtk_widget_add_accelerator (button, "activate", accel_group,
3481 keyval, modifiers, GTK_ACCEL_VISIBLE | GTK_ACCEL_LOCKED);
3483 label = gtk_accel_label_new (text);
3484 gtk_accel_label_set_accel_widget (GTK_ACCEL_LABEL (label), button);
3485 gtk_widget_show (label);
3487 gtk_container_add (GTK_CONTAINER (button), label);
3493 create_key_lookup (GtkWidget *widget)
3495 static GtkWidget *window = NULL;
3496 gpointer window_ptr;
3500 GtkAccelGroup *accel_group = gtk_accel_group_new ();
3502 GtkWidget *content_area;
3504 window = gtk_dialog_new_with_buttons ("Key Lookup", NULL, 0,
3505 GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE,
3508 gtk_window_set_screen (GTK_WINDOW (window),
3509 gtk_widget_get_screen (widget));
3511 /* We have to expand it so the accel labels will draw their labels
3513 gtk_window_set_default_size (GTK_WINDOW (window), 300, -1);
3515 gtk_window_add_accel_group (GTK_WINDOW (window), accel_group);
3517 content_area = gtk_dialog_get_content_area (GTK_DIALOG (window));
3519 button = gtk_button_new_with_mnemonic ("Button 1 (_a)");
3520 gtk_box_pack_start (GTK_BOX (content_area), button, FALSE, FALSE, 0);
3521 button = gtk_button_new_with_mnemonic ("Button 2 (_A)");
3522 gtk_box_pack_start (GTK_BOX (content_area), button, FALSE, FALSE, 0);
3523 button = gtk_button_new_with_mnemonic ("Button 3 (_\321\204)");
3524 gtk_box_pack_start (GTK_BOX (content_area), button, FALSE, FALSE, 0);
3525 button = gtk_button_new_with_mnemonic ("Button 4 (_\320\244)");
3526 gtk_box_pack_start (GTK_BOX (content_area), button, FALSE, FALSE, 0);
3527 button = gtk_button_new_with_mnemonic ("Button 6 (_b)");
3528 gtk_box_pack_start (GTK_BOX (content_area), button, FALSE, FALSE, 0);
3529 button = accel_button_new (accel_group, "Button 7", "<Alt><Shift>b");
3530 gtk_box_pack_start (GTK_BOX (content_area), button, FALSE, FALSE, 0);
3531 button = accel_button_new (accel_group, "Button 8", "<Alt>d");
3532 gtk_box_pack_start (GTK_BOX (content_area), button, FALSE, FALSE, 0);
3533 button = accel_button_new (accel_group, "Button 9", "<Alt>Cyrillic_ve");
3534 gtk_box_pack_start (GTK_BOX (content_area), button, FALSE, FALSE, 0);
3535 button = gtk_button_new_with_mnemonic ("Button 10 (_1)");
3536 gtk_box_pack_start (GTK_BOX (content_area), button, FALSE, FALSE, 0);
3537 button = gtk_button_new_with_mnemonic ("Button 11 (_!)");
3538 gtk_box_pack_start (GTK_BOX (content_area), button, FALSE, FALSE, 0);
3539 button = accel_button_new (accel_group, "Button 12", "<Super>a");
3540 gtk_box_pack_start (GTK_BOX (content_area), button, FALSE, FALSE, 0);
3541 button = accel_button_new (accel_group, "Button 13", "<Hyper>a");
3542 gtk_box_pack_start (GTK_BOX (content_area), button, FALSE, FALSE, 0);
3543 button = accel_button_new (accel_group, "Button 14", "<Meta>a");
3544 gtk_box_pack_start (GTK_BOX (content_area), button, FALSE, FALSE, 0);
3545 button = accel_button_new (accel_group, "Button 15", "<Shift><Mod4>b");
3546 gtk_box_pack_start (GTK_BOX (content_area), button, FALSE, FALSE, 0);
3548 window_ptr = &window;
3549 g_object_add_weak_pointer (G_OBJECT (window), window_ptr);
3550 g_signal_connect (window, "response", G_CALLBACK (gtk_widget_destroy), NULL);
3552 gtk_widget_show_all (window);
3555 gtk_widget_destroy (window);
3564 cmw_destroy_cb(GtkWidget *widget)
3566 /* This is needed to get out of gtk_main */
3573 cmw_color (GtkWidget *widget, GtkWidget *parent)
3576 GtkWidget *colorsel;
3577 GtkWidget *ok_button, *cancel_button;
3579 csd = gtk_color_selection_dialog_new ("This is a modal color selection dialog");
3581 gtk_window_set_screen (GTK_WINDOW (csd), gtk_widget_get_screen (parent));
3583 colorsel = gtk_color_selection_dialog_get_color_selection (GTK_COLOR_SELECTION_DIALOG (csd));
3584 gtk_color_selection_set_has_palette (GTK_COLOR_SELECTION (colorsel),
3588 gtk_window_set_modal (GTK_WINDOW(csd),TRUE);
3590 /* And mark it as a transient dialog */
3591 gtk_window_set_transient_for (GTK_WINDOW (csd), GTK_WINDOW (parent));
3593 g_signal_connect (csd, "destroy",
3594 G_CALLBACK (cmw_destroy_cb), NULL);
3597 "ok-button", &ok_button,
3598 "cancel-button", &cancel_button,
3601 g_signal_connect_swapped (ok_button,
3602 "clicked", G_CALLBACK (gtk_widget_destroy), csd);
3603 g_signal_connect_swapped (cancel_button,
3604 "clicked", G_CALLBACK (gtk_widget_destroy), csd);
3606 /* wait until destroy calls gtk_main_quit */
3607 gtk_widget_show (csd);
3612 cmw_file (GtkWidget *widget, GtkWidget *parent)
3616 fs = gtk_file_chooser_dialog_new ("This is a modal file selection dialog",
3617 GTK_WINDOW (parent), GTK_FILE_CHOOSER_ACTION_OPEN,
3618 GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
3619 GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
3621 gtk_window_set_screen (GTK_WINDOW (fs), gtk_widget_get_screen (parent));
3622 gtk_window_set_modal (GTK_WINDOW (fs), TRUE);
3624 g_signal_connect (fs, "destroy",
3625 G_CALLBACK (cmw_destroy_cb), NULL);
3626 g_signal_connect_swapped (fs, "response",
3627 G_CALLBACK (gtk_widget_destroy), fs);
3629 /* wait until destroy calls gtk_main_quit */
3630 gtk_widget_show (fs);
3636 create_modal_window (GtkWidget *widget)
3638 GtkWidget *window = NULL;
3639 GtkWidget *box1,*box2;
3641 GtkWidget *btnColor,*btnFile,*btnClose;
3643 /* Create modal window (Here you can use any window descendent )*/
3644 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
3645 gtk_window_set_screen (GTK_WINDOW (window),
3646 gtk_widget_get_screen (widget));
3648 gtk_window_set_title (GTK_WINDOW(window),"This window is modal");
3650 /* Set window as modal */
3651 gtk_window_set_modal (GTK_WINDOW(window),TRUE);
3653 /* Create widgets */
3654 box1 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
3655 frame1 = gtk_frame_new ("Standard dialogs in modal form");
3656 box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
3657 gtk_box_set_homogeneous (GTK_BOX (box2), TRUE);
3658 btnColor = gtk_button_new_with_label ("Color");
3659 btnFile = gtk_button_new_with_label ("File Selection");
3660 btnClose = gtk_button_new_with_label ("Close");
3663 gtk_container_set_border_width (GTK_CONTAINER (box1), 3);
3664 gtk_container_set_border_width (GTK_CONTAINER (box2), 3);
3667 gtk_container_add (GTK_CONTAINER (window), box1);
3668 gtk_box_pack_start (GTK_BOX (box1), frame1, TRUE, TRUE, 4);
3669 gtk_container_add (GTK_CONTAINER (frame1), box2);
3670 gtk_box_pack_start (GTK_BOX (box2), btnColor, FALSE, FALSE, 4);
3671 gtk_box_pack_start (GTK_BOX (box2), btnFile, FALSE, FALSE, 4);
3672 gtk_box_pack_start (GTK_BOX (box1), gtk_separator_new (GTK_ORIENTATION_HORIZONTAL), FALSE, FALSE, 4);
3673 gtk_box_pack_start (GTK_BOX (box1), btnClose, FALSE, FALSE, 4);
3675 /* connect signals */
3676 g_signal_connect_swapped (btnClose, "clicked",
3677 G_CALLBACK (gtk_widget_destroy), window);
3679 g_signal_connect (window, "destroy",
3680 G_CALLBACK (cmw_destroy_cb), NULL);
3682 g_signal_connect (btnColor, "clicked",
3683 G_CALLBACK (cmw_color), window);
3684 g_signal_connect (btnFile, "clicked",
3685 G_CALLBACK (cmw_file), window);
3688 gtk_widget_show_all (window);
3690 /* wait until dialog get destroyed */
3699 make_message_dialog (GdkScreen *screen,
3701 GtkMessageType type,
3702 GtkButtonsType buttons,
3703 guint default_response)
3707 gtk_widget_destroy (*dialog);
3712 *dialog = gtk_message_dialog_new (NULL, 0, type, buttons,
3713 "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.)");
3715 gtk_window_set_screen (GTK_WINDOW (*dialog), screen);
3717 g_signal_connect_swapped (*dialog,
3719 G_CALLBACK (gtk_widget_destroy),
3722 g_signal_connect (*dialog,
3724 G_CALLBACK (gtk_widget_destroyed),
3727 gtk_dialog_set_default_response (GTK_DIALOG (*dialog), default_response);
3729 gtk_widget_show (*dialog);
3733 create_message_dialog (GtkWidget *widget)
3735 static GtkWidget *info = NULL;
3736 static GtkWidget *warning = NULL;
3737 static GtkWidget *error = NULL;
3738 static GtkWidget *question = NULL;
3739 GdkScreen *screen = gtk_widget_get_screen (widget);
3741 make_message_dialog (screen, &info, GTK_MESSAGE_INFO, GTK_BUTTONS_OK, GTK_RESPONSE_OK);
3742 make_message_dialog (screen, &warning, GTK_MESSAGE_WARNING, GTK_BUTTONS_CLOSE, GTK_RESPONSE_CLOSE);
3743 make_message_dialog (screen, &error, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK_CANCEL, GTK_RESPONSE_OK);
3744 make_message_dialog (screen, &question, GTK_MESSAGE_QUESTION, GTK_BUTTONS_YES_NO, GTK_RESPONSE_NO);
3751 static GtkWidget *sw_parent = NULL;
3752 static GtkWidget *sw_float_parent;
3753 static gulong sw_destroyed_handler = 0;
3756 scrolled_windows_delete_cb (GtkWidget *widget, GdkEventAny *event, GtkWidget *scrollwin)
3758 gtk_widget_reparent (scrollwin, sw_parent);
3760 g_signal_handler_disconnect (sw_parent, sw_destroyed_handler);
3761 sw_float_parent = NULL;
3763 sw_destroyed_handler = 0;
3769 scrolled_windows_destroy_cb (GtkWidget *widget, GtkWidget *scrollwin)
3771 gtk_widget_destroy (sw_float_parent);
3773 sw_float_parent = NULL;
3775 sw_destroyed_handler = 0;
3779 scrolled_windows_remove (GtkWidget *widget, GtkWidget *scrollwin)
3783 gtk_widget_reparent (scrollwin, sw_parent);
3784 gtk_widget_destroy (sw_float_parent);
3786 g_signal_handler_disconnect (sw_parent, sw_destroyed_handler);
3787 sw_float_parent = NULL;
3789 sw_destroyed_handler = 0;
3793 sw_parent = gtk_widget_get_parent (scrollwin);
3794 sw_float_parent = gtk_window_new (GTK_WINDOW_TOPLEVEL);
3795 gtk_window_set_screen (GTK_WINDOW (sw_float_parent),
3796 gtk_widget_get_screen (widget));
3798 gtk_window_set_default_size (GTK_WINDOW (sw_float_parent), 200, 200);
3800 gtk_widget_reparent (scrollwin, sw_float_parent);
3801 gtk_widget_show (sw_float_parent);
3803 sw_destroyed_handler =
3804 g_signal_connect (sw_parent, "destroy",
3805 G_CALLBACK (scrolled_windows_destroy_cb), scrollwin);
3806 g_signal_connect (sw_float_parent, "delete_event",
3807 G_CALLBACK (scrolled_windows_delete_cb), scrollwin);
3812 create_scrolled_windows (GtkWidget *widget)
3814 static GtkWidget *window;
3815 GtkWidget *content_area, *action_area;
3816 GtkWidget *scrolled_window;
3824 window = gtk_dialog_new ();
3826 gtk_window_set_screen (GTK_WINDOW (window),
3827 gtk_widget_get_screen (widget));
3829 g_signal_connect (window, "destroy",
3830 G_CALLBACK (gtk_widget_destroyed),
3833 content_area = gtk_dialog_get_content_area (GTK_DIALOG (window));
3834 action_area = gtk_dialog_get_action_area (GTK_DIALOG (window));
3836 gtk_window_set_title (GTK_WINDOW (window), "dialog");
3837 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
3839 scrolled_window = gtk_scrolled_window_new (NULL, NULL);
3840 gtk_container_set_border_width (GTK_CONTAINER (scrolled_window), 10);
3841 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
3842 GTK_POLICY_AUTOMATIC,
3843 GTK_POLICY_AUTOMATIC);
3844 gtk_box_pack_start (GTK_BOX (content_area), scrolled_window, TRUE, TRUE, 0);
3845 gtk_widget_show (scrolled_window);
3847 table = gtk_table_new (20, 20, FALSE);
3848 gtk_table_set_row_spacings (GTK_TABLE (table), 10);
3849 gtk_table_set_col_spacings (GTK_TABLE (table), 10);
3850 gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (scrolled_window), table);
3851 gtk_container_set_focus_hadjustment (GTK_CONTAINER (table),
3852 gtk_scrolled_window_get_hadjustment (GTK_SCROLLED_WINDOW (scrolled_window)));
3853 gtk_container_set_focus_vadjustment (GTK_CONTAINER (table),
3854 gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (scrolled_window)));
3855 gtk_widget_show (table);
3857 for (i = 0; i < 20; i++)
3858 for (j = 0; j < 20; j++)
3860 sprintf (buffer, "button (%d,%d)\n", i, j);
3861 button = gtk_toggle_button_new_with_label (buffer);
3862 gtk_table_attach_defaults (GTK_TABLE (table), button,
3864 gtk_widget_show (button);
3868 button = gtk_button_new_with_label ("Close");
3869 g_signal_connect_swapped (button, "clicked",
3870 G_CALLBACK (gtk_widget_destroy),
3872 gtk_widget_set_can_default (button, TRUE);
3873 gtk_box_pack_start (GTK_BOX (action_area), button, TRUE, TRUE, 0);
3874 gtk_widget_grab_default (button);
3875 gtk_widget_show (button);
3877 button = gtk_button_new_with_label ("Reparent Out");
3878 g_signal_connect (button, "clicked",
3879 G_CALLBACK (scrolled_windows_remove),
3881 gtk_widget_set_can_default (button, TRUE);
3882 gtk_box_pack_start (GTK_BOX (action_area), button, TRUE, TRUE, 0);
3883 gtk_widget_grab_default (button);
3884 gtk_widget_show (button);
3886 gtk_window_set_default_size (GTK_WINDOW (window), 300, 300);
3889 if (!gtk_widget_get_visible (window))
3890 gtk_widget_show (window);
3892 gtk_widget_destroy (window);
3900 entry_toggle_frame (GtkWidget *checkbutton,
3903 gtk_entry_set_has_frame (GTK_ENTRY(entry),
3904 gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (checkbutton)));
3908 entry_toggle_sensitive (GtkWidget *checkbutton,
3911 gtk_widget_set_sensitive (entry,
3912 gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON(checkbutton)));
3916 entry_progress_timeout (gpointer data)
3918 if (GPOINTER_TO_INT (g_object_get_data (G_OBJECT (data), "progress-pulse")))
3920 gtk_entry_progress_pulse (GTK_ENTRY (data));
3926 fraction = gtk_entry_get_progress_fraction (GTK_ENTRY (data));
3929 if (fraction > 1.0001)
3932 gtk_entry_set_progress_fraction (GTK_ENTRY (data), fraction);
3939 entry_remove_timeout (gpointer data)
3941 g_source_remove (GPOINTER_TO_UINT (data));
3945 entry_toggle_progress (GtkWidget *checkbutton,
3948 if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (checkbutton)))
3950 guint timeout = gdk_threads_add_timeout (100,
3951 entry_progress_timeout,
3953 g_object_set_data_full (G_OBJECT (entry), "timeout-id",
3954 GUINT_TO_POINTER (timeout),
3955 entry_remove_timeout);
3959 g_object_set_data (G_OBJECT (entry), "timeout-id",
3960 GUINT_TO_POINTER (0));
3962 gtk_entry_set_progress_fraction (GTK_ENTRY (entry), 0.0);
3967 entry_toggle_pulse (GtkWidget *checkbutton,
3970 g_object_set_data (G_OBJECT (entry), "progress-pulse",
3971 GUINT_TO_POINTER ((guint) gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (checkbutton))));
3975 props_clicked (GtkWidget *button,
3978 GtkWidget *window = create_prop_editor (object, 0);
3980 gtk_window_set_title (GTK_WINDOW (window), "Object Properties");
3984 create_entry (GtkWidget *widget)
3986 static GtkWidget *window = NULL;
3990 GtkWidget *has_frame_check;
3991 GtkWidget *sensitive_check;
3992 GtkWidget *progress_check;
3994 GtkComboBoxText *cb;
3995 GtkWidget *cb_entry;
3997 GtkWidget *separator;
4001 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
4002 gtk_window_set_screen (GTK_WINDOW (window),
4003 gtk_widget_get_screen (widget));
4005 g_signal_connect (window, "destroy",
4006 G_CALLBACK (gtk_widget_destroyed),
4009 gtk_window_set_title (GTK_WINDOW (window), "entry");
4010 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
4013 box1 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
4014 gtk_container_add (GTK_CONTAINER (window), box1);
4017 box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10);
4018 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
4019 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
4021 hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 5);
4022 gtk_box_pack_start (GTK_BOX (box2), hbox, TRUE, TRUE, 0);
4024 entry = gtk_entry_new ();
4025 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");
4026 gtk_editable_select_region (GTK_EDITABLE (entry), 0, 5);
4027 gtk_box_pack_start (GTK_BOX (hbox), entry, TRUE, TRUE, 0);
4029 button = gtk_button_new_with_mnemonic ("_Props");
4030 gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0);
4031 g_signal_connect (button, "clicked",
4032 G_CALLBACK (props_clicked),
4035 cb = GTK_COMBO_BOX_TEXT (gtk_combo_box_text_new_with_entry ());
4037 gtk_combo_box_text_append_text (cb, "item0");
4038 gtk_combo_box_text_append_text (cb, "item0");
4039 gtk_combo_box_text_append_text (cb, "item1 item1");
4040 gtk_combo_box_text_append_text (cb, "item2 item2 item2");
4041 gtk_combo_box_text_append_text (cb, "item3 item3 item3 item3");
4042 gtk_combo_box_text_append_text (cb, "item4 item4 item4 item4 item4");
4043 gtk_combo_box_text_append_text (cb, "item5 item5 item5 item5 item5 item5");
4044 gtk_combo_box_text_append_text (cb, "item6 item6 item6 item6 item6");
4045 gtk_combo_box_text_append_text (cb, "item7 item7 item7 item7");
4046 gtk_combo_box_text_append_text (cb, "item8 item8 item8");
4047 gtk_combo_box_text_append_text (cb, "item9 item9");
4049 cb_entry = gtk_bin_get_child (GTK_BIN (cb));
4050 gtk_entry_set_text (GTK_ENTRY (cb_entry), "hello world \n\n\n foo");
4051 gtk_editable_select_region (GTK_EDITABLE (cb_entry), 0, -1);
4052 gtk_box_pack_start (GTK_BOX (box2), GTK_WIDGET (cb), TRUE, TRUE, 0);
4054 sensitive_check = gtk_check_button_new_with_label("Sensitive");
4055 gtk_box_pack_start (GTK_BOX (box2), sensitive_check, FALSE, TRUE, 0);
4056 g_signal_connect (sensitive_check, "toggled",
4057 G_CALLBACK (entry_toggle_sensitive), entry);
4058 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (sensitive_check), TRUE);
4060 has_frame_check = gtk_check_button_new_with_label("Has Frame");
4061 gtk_box_pack_start (GTK_BOX (box2), has_frame_check, FALSE, TRUE, 0);
4062 g_signal_connect (has_frame_check, "toggled",
4063 G_CALLBACK (entry_toggle_frame), entry);
4064 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (has_frame_check), TRUE);
4066 progress_check = gtk_check_button_new_with_label("Show Progress");
4067 gtk_box_pack_start (GTK_BOX (box2), progress_check, FALSE, TRUE, 0);
4068 g_signal_connect (progress_check, "toggled",
4069 G_CALLBACK (entry_toggle_progress), entry);
4071 progress_check = gtk_check_button_new_with_label("Pulse Progress");
4072 gtk_box_pack_start (GTK_BOX (box2), progress_check, FALSE, TRUE, 0);
4073 g_signal_connect (progress_check, "toggled",
4074 G_CALLBACK (entry_toggle_pulse), entry);
4076 separator = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
4077 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
4079 box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10);
4080 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
4081 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
4083 button = gtk_button_new_with_label ("close");
4084 g_signal_connect_swapped (button, "clicked",
4085 G_CALLBACK (gtk_widget_destroy),
4087 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
4088 gtk_widget_set_can_default (button, TRUE);
4089 gtk_widget_grab_default (button);
4092 if (!gtk_widget_get_visible (window))
4093 gtk_widget_show_all (window);
4095 gtk_widget_destroy (window);
4099 create_expander (GtkWidget *widget)
4102 GtkWidget *expander;
4104 static GtkWidget *window = NULL;
4108 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
4109 gtk_window_set_screen (GTK_WINDOW (window),
4110 gtk_widget_get_screen (widget));
4112 g_signal_connect (window, "destroy",
4113 G_CALLBACK (gtk_widget_destroyed),
4116 gtk_window_set_title (GTK_WINDOW (window), "expander");
4117 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
4119 box1 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
4120 gtk_container_add (GTK_CONTAINER (window), box1);
4122 expander = gtk_expander_new ("The Hidden");
4124 gtk_box_pack_start (GTK_BOX (box1), expander, TRUE, TRUE, 0);
4126 hidden = gtk_label_new ("Revealed!");
4128 gtk_container_add (GTK_CONTAINER (expander), hidden);
4131 if (!gtk_widget_get_visible (window))
4132 gtk_widget_show_all (window);
4134 gtk_widget_destroy (window);
4142 event_box_label_pressed (GtkWidget *widget,
4143 GdkEventButton *event,
4146 g_print ("clicked on event box\n");
4150 event_box_button_clicked (GtkWidget *widget,
4154 g_print ("pushed button\n");
4158 event_box_toggle_visible_window (GtkWidget *checkbutton,
4159 GtkEventBox *event_box)
4161 gtk_event_box_set_visible_window (event_box,
4162 gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (checkbutton)));
4166 event_box_toggle_above_child (GtkWidget *checkbutton,
4167 GtkEventBox *event_box)
4169 gtk_event_box_set_above_child (event_box,
4170 gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (checkbutton)));
4174 create_event_box (GtkWidget *widget)
4176 static GtkWidget *window = NULL;
4182 GtkWidget *separator;
4183 GtkWidget *event_box;
4185 GtkWidget *visible_window_check;
4186 GtkWidget *above_child_check;
4196 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
4197 gtk_window_set_screen (GTK_WINDOW (window),
4198 gtk_widget_get_screen (widget));
4200 g_signal_connect (window, "destroy",
4201 G_CALLBACK (gtk_widget_destroyed),
4204 gtk_window_set_title (GTK_WINDOW (window), "event box");
4205 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
4207 box1 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
4208 gtk_container_add (GTK_CONTAINER (window), box1);
4209 gtk_widget_override_background_color (window, 0, &color);
4211 hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
4212 gtk_box_pack_start (GTK_BOX (box1), hbox, TRUE, FALSE, 0);
4214 event_box = gtk_event_box_new ();
4215 gtk_box_pack_start (GTK_BOX (hbox), event_box, TRUE, FALSE, 0);
4217 vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
4218 gtk_container_add (GTK_CONTAINER (event_box), vbox);
4219 g_signal_connect (event_box, "button_press_event",
4220 G_CALLBACK (event_box_label_pressed),
4223 label = gtk_label_new ("Click on this label");
4224 gtk_box_pack_start (GTK_BOX (vbox), label, TRUE, FALSE, 0);
4226 button = gtk_button_new_with_label ("button in eventbox");
4227 gtk_box_pack_start (GTK_BOX (vbox), button, TRUE, FALSE, 0);
4228 g_signal_connect (button, "clicked",
4229 G_CALLBACK (event_box_button_clicked),
4233 visible_window_check = gtk_check_button_new_with_label("Visible Window");
4234 gtk_box_pack_start (GTK_BOX (box1), visible_window_check, FALSE, TRUE, 0);
4235 g_signal_connect (visible_window_check, "toggled",
4236 G_CALLBACK (event_box_toggle_visible_window), event_box);
4237 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (visible_window_check), FALSE);
4239 above_child_check = gtk_check_button_new_with_label("Above Child");
4240 gtk_box_pack_start (GTK_BOX (box1), above_child_check, FALSE, TRUE, 0);
4241 g_signal_connect (above_child_check, "toggled",
4242 G_CALLBACK (event_box_toggle_above_child), event_box);
4243 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (above_child_check), FALSE);
4245 separator = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
4246 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
4248 box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10);
4249 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
4250 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
4252 button = gtk_button_new_with_label ("close");
4253 g_signal_connect_swapped (button, "clicked",
4254 G_CALLBACK (gtk_widget_destroy),
4256 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
4257 gtk_widget_set_can_default (button, TRUE);
4258 gtk_widget_grab_default (button);
4261 if (!gtk_widget_get_visible (window))
4262 gtk_widget_show_all (window);
4264 gtk_widget_destroy (window);
4272 #define SIZE_GROUP_INITIAL_SIZE 50
4275 size_group_hsize_changed (GtkSpinButton *spin_button,
4278 gtk_widget_set_size_request (gtk_bin_get_child (GTK_BIN (button)),
4279 gtk_spin_button_get_value_as_int (spin_button),
4284 size_group_vsize_changed (GtkSpinButton *spin_button,
4287 gtk_widget_set_size_request (gtk_bin_get_child (GTK_BIN (button)),
4289 gtk_spin_button_get_value_as_int (spin_button));
4293 create_size_group_window (GdkScreen *screen,
4294 GtkSizeGroup *master_size_group)
4296 GtkWidget *content_area;
4299 GtkWidget *main_button;
4301 GtkWidget *spin_button;
4303 GtkSizeGroup *hgroup1;
4304 GtkSizeGroup *hgroup2;
4305 GtkSizeGroup *vgroup1;
4306 GtkSizeGroup *vgroup2;
4308 window = gtk_dialog_new_with_buttons ("GtkSizeGroup",
4314 gtk_window_set_screen (GTK_WINDOW (window), screen);
4316 gtk_window_set_resizable (GTK_WINDOW (window), TRUE);
4318 g_signal_connect (window, "response",
4319 G_CALLBACK (gtk_widget_destroy),
4322 content_area = gtk_dialog_get_content_area (GTK_DIALOG (window));
4324 table = gtk_table_new (2, 2, FALSE);
4325 gtk_box_pack_start (GTK_BOX (content_area), table, TRUE, TRUE, 0);
4327 gtk_table_set_row_spacings (GTK_TABLE (table), 5);
4328 gtk_table_set_col_spacings (GTK_TABLE (table), 5);
4329 gtk_container_set_border_width (GTK_CONTAINER (table), 5);
4330 gtk_widget_set_size_request (table, 250, 250);
4332 hgroup1 = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
4333 hgroup2 = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
4334 vgroup1 = gtk_size_group_new (GTK_SIZE_GROUP_VERTICAL);
4335 vgroup2 = gtk_size_group_new (GTK_SIZE_GROUP_VERTICAL);
4337 main_button = gtk_button_new_with_label ("X");
4339 gtk_table_attach (GTK_TABLE (table), main_button,
4341 GTK_EXPAND, GTK_EXPAND,
4343 gtk_size_group_add_widget (master_size_group, main_button);
4344 gtk_size_group_add_widget (hgroup1, main_button);
4345 gtk_size_group_add_widget (vgroup1, main_button);
4346 gtk_widget_set_size_request (gtk_bin_get_child (GTK_BIN (main_button)),
4347 SIZE_GROUP_INITIAL_SIZE,
4348 SIZE_GROUP_INITIAL_SIZE);
4350 button = gtk_button_new ();
4351 gtk_table_attach (GTK_TABLE (table), button,
4353 GTK_EXPAND, GTK_EXPAND,
4355 gtk_size_group_add_widget (vgroup1, button);
4356 gtk_size_group_add_widget (vgroup2, button);
4358 button = gtk_button_new ();
4359 gtk_table_attach (GTK_TABLE (table), button,
4361 GTK_EXPAND, GTK_EXPAND,
4363 gtk_size_group_add_widget (hgroup1, button);
4364 gtk_size_group_add_widget (hgroup2, button);
4366 button = gtk_button_new ();
4367 gtk_table_attach (GTK_TABLE (table), button,
4369 GTK_EXPAND, GTK_EXPAND,
4371 gtk_size_group_add_widget (hgroup2, button);
4372 gtk_size_group_add_widget (vgroup2, button);
4374 g_object_unref (hgroup1);
4375 g_object_unref (hgroup2);
4376 g_object_unref (vgroup1);
4377 g_object_unref (vgroup2);
4379 hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 5);
4380 gtk_box_pack_start (GTK_BOX (content_area), hbox, FALSE, FALSE, 0);
4382 spin_button = gtk_spin_button_new_with_range (1, 100, 1);
4383 gtk_spin_button_set_value (GTK_SPIN_BUTTON (spin_button), SIZE_GROUP_INITIAL_SIZE);
4384 gtk_box_pack_start (GTK_BOX (hbox), spin_button, TRUE, TRUE, 0);
4385 g_signal_connect (spin_button, "value_changed",
4386 G_CALLBACK (size_group_hsize_changed), main_button);
4388 spin_button = gtk_spin_button_new_with_range (1, 100, 1);
4389 gtk_spin_button_set_value (GTK_SPIN_BUTTON (spin_button), SIZE_GROUP_INITIAL_SIZE);
4390 gtk_box_pack_start (GTK_BOX (hbox), spin_button, TRUE, TRUE, 0);
4391 g_signal_connect (spin_button, "value_changed",
4392 G_CALLBACK (size_group_vsize_changed), main_button);
4398 create_size_groups (GtkWidget *widget)
4400 static GtkWidget *window1 = NULL;
4401 static GtkWidget *window2 = NULL;
4402 static GtkSizeGroup *master_size_group;
4404 if (!master_size_group)
4405 master_size_group = gtk_size_group_new (GTK_SIZE_GROUP_BOTH);
4409 window1 = create_size_group_window (gtk_widget_get_screen (widget),
4412 g_signal_connect (window1, "destroy",
4413 G_CALLBACK (gtk_widget_destroyed),
4419 window2 = create_size_group_window (gtk_widget_get_screen (widget),
4422 g_signal_connect (window2, "destroy",
4423 G_CALLBACK (gtk_widget_destroyed),
4427 if (gtk_widget_get_visible (window1) && gtk_widget_get_visible (window2))
4429 gtk_widget_destroy (window1);
4430 gtk_widget_destroy (window2);
4434 if (!gtk_widget_get_visible (window1))
4435 gtk_widget_show_all (window1);
4436 if (!gtk_widget_get_visible (window2))
4437 gtk_widget_show_all (window2);
4445 static GtkWidget *spinner1;
4448 toggle_snap (GtkWidget *widget, GtkSpinButton *spin)
4450 gtk_spin_button_set_snap_to_ticks (spin,
4451 gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget)));
4455 toggle_numeric (GtkWidget *widget, GtkSpinButton *spin)
4457 gtk_spin_button_set_numeric (spin,
4458 gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget)));
4462 change_digits (GtkWidget *widget, GtkSpinButton *spin)
4464 gtk_spin_button_set_digits (GTK_SPIN_BUTTON (spinner1),
4465 gtk_spin_button_get_value_as_int (spin));
4469 get_value (GtkWidget *widget, gpointer data)
4473 GtkSpinButton *spin;
4475 spin = GTK_SPIN_BUTTON (spinner1);
4476 label = GTK_LABEL (g_object_get_data (G_OBJECT (widget), "user_data"));
4477 if (GPOINTER_TO_INT (data) == 1)
4478 sprintf (buf, "%d", gtk_spin_button_get_value_as_int (spin));
4480 sprintf (buf, "%0.*f",
4481 gtk_spin_button_get_digits (spin),
4482 gtk_spin_button_get_value (spin));
4484 gtk_label_set_text (label, buf);
4488 get_spin_value (GtkWidget *widget, gpointer data)
4492 GtkSpinButton *spin;
4494 spin = GTK_SPIN_BUTTON (widget);
4495 label = GTK_LABEL (data);
4497 buffer = g_strdup_printf ("%0.*f",
4498 gtk_spin_button_get_digits (spin),
4499 gtk_spin_button_get_value (spin));
4500 gtk_label_set_text (label, buffer);
4506 spin_button_time_output_func (GtkSpinButton *spin_button)
4508 GtkAdjustment *adjustment;
4509 static gchar buf[6];
4513 adjustment = gtk_spin_button_get_adjustment (spin_button);
4514 hours = gtk_adjustment_get_value (adjustment) / 60.0;
4515 minutes = (fabs(floor (hours) - hours) < 1e-5) ? 0.0 : 30;
4516 sprintf (buf, "%02.0f:%02.0f", floor (hours), minutes);
4517 if (strcmp (buf, gtk_entry_get_text (GTK_ENTRY (spin_button))))
4518 gtk_entry_set_text (GTK_ENTRY (spin_button), buf);
4523 spin_button_month_input_func (GtkSpinButton *spin_button,
4527 static gchar *month[12] = { "January", "February", "March", "April",
4528 "May", "June", "July", "August",
4529 "September", "October", "November", "December" };
4531 gboolean found = FALSE;
4533 for (i = 1; i <= 12; i++)
4535 tmp1 = g_ascii_strup (month[i - 1], -1);
4536 tmp2 = g_ascii_strup (gtk_entry_get_text (GTK_ENTRY (spin_button)), -1);
4537 if (strstr (tmp1, tmp2) == tmp1)
4547 return GTK_INPUT_ERROR;
4549 *new_val = (gdouble) i;
4554 spin_button_month_output_func (GtkSpinButton *spin_button)
4556 GtkAdjustment *adjustment;
4559 static gchar *month[12] = { "January", "February", "March", "April",
4560 "May", "June", "July", "August", "September",
4561 "October", "November", "December" };
4563 adjustment = gtk_spin_button_get_adjustment (spin_button);
4564 value = gtk_adjustment_get_value (adjustment);
4565 for (i = 1; i <= 12; i++)
4566 if (fabs (value - (double)i) < 1e-5)
4568 if (strcmp (month[i-1], gtk_entry_get_text (GTK_ENTRY (spin_button))))
4569 gtk_entry_set_text (GTK_ENTRY (spin_button), month[i-1]);
4575 spin_button_hex_input_func (GtkSpinButton *spin_button,
4582 buf = gtk_entry_get_text (GTK_ENTRY (spin_button));
4583 res = strtol(buf, &err, 16);
4586 return GTK_INPUT_ERROR;
4592 spin_button_hex_output_func (GtkSpinButton *spin_button)
4594 GtkAdjustment *adjustment;
4595 static gchar buf[7];
4598 adjustment = gtk_spin_button_get_adjustment (spin_button);
4599 val = (gint) gtk_adjustment_get_value (adjustment);
4600 if (fabs (val) < 1e-5)
4601 sprintf (buf, "0x00");
4603 sprintf (buf, "0x%.2X", val);
4604 if (strcmp (buf, gtk_entry_get_text (GTK_ENTRY (spin_button))))
4605 gtk_entry_set_text (GTK_ENTRY (spin_button), buf);
4610 create_spins (GtkWidget *widget)
4612 static GtkWidget *window = NULL;
4615 GtkWidget *main_vbox;
4618 GtkWidget *spinner2;
4622 GtkWidget *val_label;
4623 GtkAdjustment *adjustment;
4627 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
4628 gtk_window_set_screen (GTK_WINDOW (window),
4629 gtk_widget_get_screen (widget));
4631 g_signal_connect (window, "destroy",
4632 G_CALLBACK (gtk_widget_destroyed),
4635 gtk_window_set_title (GTK_WINDOW (window), "GtkSpinButton");
4637 main_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
4638 gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 10);
4639 gtk_container_add (GTK_CONTAINER (window), main_vbox);
4641 frame = gtk_frame_new ("Not accelerated");
4642 gtk_box_pack_start (GTK_BOX (main_vbox), frame, TRUE, TRUE, 0);
4644 vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
4645 gtk_container_set_border_width (GTK_CONTAINER (vbox), 5);
4646 gtk_container_add (GTK_CONTAINER (frame), vbox);
4648 /* Time, month, hex spinners */
4650 hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
4651 gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 5);
4653 vbox2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
4654 gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 5);
4656 label = gtk_label_new ("Time :");
4657 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
4658 gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, TRUE, 0);
4660 adjustment = gtk_adjustment_new (0, 0, 1410, 30, 60, 0);
4661 spinner = gtk_spin_button_new (adjustment, 0, 0);
4662 gtk_editable_set_editable (GTK_EDITABLE (spinner), FALSE);
4663 g_signal_connect (spinner,
4665 G_CALLBACK (spin_button_time_output_func),
4667 gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spinner), TRUE);
4668 gtk_entry_set_width_chars (GTK_ENTRY (spinner), 5);
4669 gtk_box_pack_start (GTK_BOX (vbox2), spinner, FALSE, TRUE, 0);
4671 vbox2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
4672 gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 5);
4674 label = gtk_label_new ("Month :");
4675 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
4676 gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, TRUE, 0);
4678 adjustment = gtk_adjustment_new (1.0, 1.0, 12.0, 1.0,
4680 spinner = gtk_spin_button_new (adjustment, 0, 0);
4681 gtk_spin_button_set_update_policy (GTK_SPIN_BUTTON (spinner),
4682 GTK_UPDATE_IF_VALID);
4683 g_signal_connect (spinner,
4685 G_CALLBACK (spin_button_month_input_func),
4687 g_signal_connect (spinner,
4689 G_CALLBACK (spin_button_month_output_func),
4691 gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spinner), TRUE);
4692 gtk_entry_set_width_chars (GTK_ENTRY (spinner), 9);
4693 gtk_box_pack_start (GTK_BOX (vbox2), spinner, FALSE, TRUE, 0);
4695 vbox2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
4696 gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 5);
4698 label = gtk_label_new ("Hex :");
4699 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
4700 gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, TRUE, 0);
4702 adjustment = gtk_adjustment_new (0, 0, 255, 1, 16, 0);
4703 spinner = gtk_spin_button_new (adjustment, 0, 0);
4704 gtk_editable_set_editable (GTK_EDITABLE (spinner), TRUE);
4705 g_signal_connect (spinner,
4707 G_CALLBACK (spin_button_hex_input_func),
4709 g_signal_connect (spinner,
4711 G_CALLBACK (spin_button_hex_output_func),
4713 gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spinner), TRUE);
4714 gtk_entry_set_width_chars (GTK_ENTRY (spinner), 4);
4715 gtk_box_pack_start (GTK_BOX (vbox2), spinner, FALSE, TRUE, 0);
4717 frame = gtk_frame_new ("Accelerated");
4718 gtk_box_pack_start (GTK_BOX (main_vbox), frame, TRUE, TRUE, 0);
4720 vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
4721 gtk_container_set_border_width (GTK_CONTAINER (vbox), 5);
4722 gtk_container_add (GTK_CONTAINER (frame), vbox);
4724 hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
4725 gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 5);
4727 vbox2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
4728 gtk_box_pack_start (GTK_BOX (hbox), vbox2, FALSE, FALSE, 5);
4730 label = gtk_label_new ("Value :");
4731 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
4732 gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, TRUE, 0);
4734 adjustment = gtk_adjustment_new (0.0, -10000.0, 10000.0,
4736 spinner1 = gtk_spin_button_new (adjustment, 1.0, 2);
4737 gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spinner1), TRUE);
4738 gtk_box_pack_start (GTK_BOX (vbox2), spinner1, FALSE, TRUE, 0);
4740 vbox2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
4741 gtk_box_pack_start (GTK_BOX (hbox), vbox2, FALSE, FALSE, 5);
4743 label = gtk_label_new ("Digits :");
4744 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
4745 gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, TRUE, 0);
4747 adjustment = gtk_adjustment_new (2, 1, 15, 1, 1, 0);
4748 spinner2 = gtk_spin_button_new (adjustment, 0.0, 0);
4749 g_signal_connect (adjustment, "value_changed",
4750 G_CALLBACK (change_digits),
4752 gtk_box_pack_start (GTK_BOX (vbox2), spinner2, FALSE, TRUE, 0);
4754 hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
4755 gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 5);
4757 button = gtk_check_button_new_with_label ("Snap to 0.5-ticks");
4758 g_signal_connect (button, "clicked",
4759 G_CALLBACK (toggle_snap),
4761 gtk_box_pack_start (GTK_BOX (vbox), button, TRUE, TRUE, 0);
4762 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
4764 button = gtk_check_button_new_with_label ("Numeric only input mode");
4765 g_signal_connect (button, "clicked",
4766 G_CALLBACK (toggle_numeric),
4768 gtk_box_pack_start (GTK_BOX (vbox), button, TRUE, TRUE, 0);
4769 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
4771 val_label = gtk_label_new ("");
4773 hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
4774 gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 5);
4776 button = gtk_button_new_with_label ("Value as Int");
4777 g_object_set_data (G_OBJECT (button), "user_data", val_label);
4778 g_signal_connect (button, "clicked",
4779 G_CALLBACK (get_value),
4780 GINT_TO_POINTER (1));
4781 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
4783 button = gtk_button_new_with_label ("Value as Float");
4784 g_object_set_data (G_OBJECT (button), "user_data", val_label);
4785 g_signal_connect (button, "clicked",
4786 G_CALLBACK (get_value),
4787 GINT_TO_POINTER (2));
4788 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
4790 gtk_box_pack_start (GTK_BOX (vbox), val_label, TRUE, TRUE, 0);
4791 gtk_label_set_text (GTK_LABEL (val_label), "0");
4793 frame = gtk_frame_new ("Using Convenience Constructor");
4794 gtk_box_pack_start (GTK_BOX (main_vbox), frame, TRUE, TRUE, 0);
4796 hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
4797 gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
4798 gtk_container_add (GTK_CONTAINER (frame), hbox);
4800 val_label = gtk_label_new ("0.0");
4802 spinner = gtk_spin_button_new_with_range (0.0, 10.0, 0.009);
4803 gtk_spin_button_set_value (GTK_SPIN_BUTTON (spinner), 0.0);
4804 g_signal_connect (spinner, "value_changed",
4805 G_CALLBACK (get_spin_value), val_label);
4806 gtk_box_pack_start (GTK_BOX (hbox), spinner, TRUE, TRUE, 5);
4807 gtk_box_pack_start (GTK_BOX (hbox), val_label, TRUE, TRUE, 5);
4809 hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
4810 gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, TRUE, 0);
4812 button = gtk_button_new_with_label ("Close");
4813 g_signal_connect_swapped (button, "clicked",
4814 G_CALLBACK (gtk_widget_destroy),
4816 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
4819 if (!gtk_widget_get_visible (window))
4820 gtk_widget_show_all (window);
4822 gtk_widget_destroy (window);
4831 cursor_draw (GtkWidget *widget,
4836 GtkStyleContext *context;
4839 width = gtk_widget_get_allocated_width (widget);
4840 height = gtk_widget_get_allocated_height (widget);
4842 cairo_set_source_rgb (cr, 1, 1, 1);
4843 cairo_rectangle (cr, 0, 0, width, height / 2);
4846 cairo_set_source_rgb (cr, 0, 0, 0);
4847 cairo_rectangle (cr, 0, height / 2, width, height / 2);
4850 context = gtk_widget_get_style_context (widget);
4851 gtk_style_context_get_background_color (context, GTK_STATE_FLAG_NORMAL, &bg);
4852 gdk_cairo_set_source_rgba (cr, &bg);
4853 cairo_rectangle (cr, width / 3, height / 3, width / 3, height / 3);
4860 set_cursor (GtkWidget *spinner,
4869 c = CLAMP (gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (spinner)), 0, 152);
4872 label = g_object_get_data (G_OBJECT (spinner), "user_data");
4874 class = g_type_class_ref (GDK_TYPE_CURSOR_TYPE);
4875 vals = class->values;
4877 while (vals && vals->value != c)
4880 gtk_label_set_text (GTK_LABEL (label), vals->value_nick);
4882 gtk_label_set_text (GTK_LABEL (label), "<unknown>");
4884 g_type_class_unref (class);
4886 cursor = gdk_cursor_new_for_display (gtk_widget_get_display (widget), c);
4887 gdk_window_set_cursor (gtk_widget_get_window (widget),
4889 g_object_unref (cursor);
4893 cursor_event (GtkWidget *widget,
4895 GtkSpinButton *spinner)
4897 if ((event->type == GDK_BUTTON_PRESS) &&
4898 ((event->button.button == 1) ||
4899 (event->button.button == 3)))
4901 gtk_spin_button_spin (spinner, event->button.button == 1 ?
4902 GTK_SPIN_STEP_FORWARD : GTK_SPIN_STEP_BACKWARD, 0);
4909 #ifdef GDK_WINDOWING_X11
4910 #include "x11/gdkx.h"
4913 change_cursor_theme (GtkWidget *widget,
4920 children = gtk_container_get_children (GTK_CONTAINER (data));
4922 theme = gtk_entry_get_text (GTK_ENTRY (children->next->data));
4923 size = (gint) gtk_spin_button_get_value (GTK_SPIN_BUTTON (children->next->next->data));
4925 g_list_free (children);
4927 gdk_x11_display_set_cursor_theme (gtk_widget_get_display (widget),
4934 create_cursors (GtkWidget *widget)
4936 static GtkWidget *window = NULL;
4939 GtkWidget *main_vbox;
4946 GtkAdjustment *adjustment;
4952 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
4953 gtk_window_set_screen (GTK_WINDOW (window),
4954 gtk_widget_get_screen (widget));
4956 g_signal_connect (window, "destroy",
4957 G_CALLBACK (gtk_widget_destroyed),
4960 gtk_window_set_title (GTK_WINDOW (window), "Cursors");
4962 main_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
4963 gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 0);
4964 gtk_container_add (GTK_CONTAINER (window), main_vbox);
4967 g_object_new (GTK_TYPE_BOX,
4968 "orientation", GTK_ORIENTATION_VERTICAL,
4969 "GtkBox::homogeneous", FALSE,
4970 "GtkBox::spacing", 5,
4971 "GtkContainer::border_width", 10,
4972 "GtkWidget::parent", main_vbox,
4973 "GtkWidget::visible", TRUE,
4976 #ifdef GDK_WINDOWING_X11
4977 hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
4978 gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
4979 gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0);
4981 label = gtk_label_new ("Cursor Theme : ");
4982 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
4983 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
4985 entry = gtk_entry_new ();
4986 gtk_entry_set_text (GTK_ENTRY (entry), "default");
4987 gtk_box_pack_start (GTK_BOX (hbox), entry, FALSE, TRUE, 0);
4989 size = gtk_spin_button_new_with_range (1.0, 64.0, 1.0);
4990 gtk_spin_button_set_value (GTK_SPIN_BUTTON (size), 24.0);
4991 gtk_box_pack_start (GTK_BOX (hbox), size, TRUE, TRUE, 0);
4993 g_signal_connect (entry, "changed",
4994 G_CALLBACK (change_cursor_theme), hbox);
4995 g_signal_connect (size, "changed",
4996 G_CALLBACK (change_cursor_theme), hbox);
4999 hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
5000 gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
5001 gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0);
5003 label = gtk_label_new ("Cursor Value : ");
5004 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
5005 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
5007 adjustment = gtk_adjustment_new (0,
5011 spinner = gtk_spin_button_new (adjustment, 0, 0);
5012 gtk_box_pack_start (GTK_BOX (hbox), spinner, TRUE, TRUE, 0);
5015 g_object_new (gtk_frame_get_type (),
5016 "GtkFrame::label_xalign", 0.5,
5017 "GtkFrame::label", "Cursor Area",
5018 "GtkContainer::border_width", 10,
5019 "GtkWidget::parent", vbox,
5020 "GtkWidget::visible", TRUE,
5023 darea = gtk_drawing_area_new ();
5024 gtk_widget_set_size_request (darea, 80, 80);
5025 gtk_container_add (GTK_CONTAINER (frame), darea);
5026 g_signal_connect (darea,
5028 G_CALLBACK (cursor_draw),
5030 gtk_widget_set_events (darea, GDK_EXPOSURE_MASK | GDK_BUTTON_PRESS_MASK);
5031 g_signal_connect (darea,
5032 "button_press_event",
5033 G_CALLBACK (cursor_event),
5035 gtk_widget_show (darea);
5037 g_signal_connect (spinner, "changed",
5038 G_CALLBACK (set_cursor),
5041 label = g_object_new (GTK_TYPE_LABEL,
5046 gtk_container_child_set (GTK_CONTAINER (vbox), label,
5049 g_object_set_data (G_OBJECT (spinner), "user_data", label);
5051 any = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
5052 gtk_box_pack_start (GTK_BOX (main_vbox), any, FALSE, TRUE, 0);
5054 hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
5055 gtk_container_set_border_width (GTK_CONTAINER (hbox), 10);
5056 gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, TRUE, 0);
5058 button = gtk_button_new_with_label ("Close");
5059 g_signal_connect_swapped (button, "clicked",
5060 G_CALLBACK (gtk_widget_destroy),
5062 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
5064 gtk_widget_show_all (window);
5066 set_cursor (spinner, darea);
5069 gtk_widget_destroy (window);
5077 color_selection_ok (GtkWidget *w,
5078 GtkColorSelectionDialog *cs)
5080 GtkWidget *colorsel;
5083 colorsel = gtk_color_selection_dialog_get_color_selection (cs);
5085 gtk_color_selection_get_current_color (GTK_COLOR_SELECTION (colorsel), &color);
5086 gtk_color_selection_set_current_color (GTK_COLOR_SELECTION (colorsel), &color);
5090 color_selection_changed (GtkWidget *w,
5091 GtkColorSelectionDialog *cs)
5093 GtkWidget *colorsel;
5096 colorsel = gtk_color_selection_dialog_get_color_selection (cs);
5097 gtk_color_selection_get_current_color (GTK_COLOR_SELECTION (colorsel), &color);
5098 gtk_color_selection_set_current_color (GTK_COLOR_SELECTION (colorsel), &color);
5103 opacity_toggled_cb (GtkWidget *w,
5104 GtkColorSelectionDialog *cs)
5106 GtkColorSelection *colorsel;
5108 colorsel = GTK_COLOR_SELECTION (cs->colorsel);
5109 gtk_color_selection_set_has_opacity_control (colorsel,
5110 gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (w)));
5114 palette_toggled_cb (GtkWidget *w,
5115 GtkColorSelectionDialog *cs)
5117 GtkColorSelection *colorsel;
5119 colorsel = GTK_COLOR_SELECTION (cs->colorsel);
5120 gtk_color_selection_set_has_palette (colorsel,
5121 gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (w)));
5126 create_color_selection (GtkWidget *widget)
5128 static GtkWidget *window = NULL;
5137 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
5138 gtk_window_set_screen (GTK_WINDOW (window),
5139 gtk_widget_get_screen (widget));
5141 g_signal_connect (window, "destroy",
5142 G_CALLBACK (gtk_widget_destroyed),
5145 gtk_window_set_title (GTK_WINDOW (window), "GtkColorButton");
5146 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
5148 hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 8);
5149 gtk_container_set_border_width (GTK_CONTAINER (hbox), 8);
5150 gtk_container_add (GTK_CONTAINER (window), hbox);
5152 label = gtk_label_new ("Pick a color");
5153 gtk_container_add (GTK_CONTAINER (hbox), label);
5155 picker = gtk_color_button_new ();
5156 gtk_color_button_set_use_alpha (GTK_COLOR_BUTTON (picker), TRUE);
5157 gtk_container_add (GTK_CONTAINER (hbox), picker);
5159 button = gtk_button_new_with_mnemonic ("_Props");
5160 gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0);
5161 g_signal_connect (button, "clicked",
5162 G_CALLBACK (props_clicked),
5166 if (!gtk_widget_get_visible (window))
5167 gtk_widget_show_all (window);
5169 gtk_widget_destroy (window);
5173 flipping_toggled_cb (GtkWidget *widget, gpointer data)
5175 int state = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget));
5176 int new_direction = state ? GTK_TEXT_DIR_RTL : GTK_TEXT_DIR_LTR;
5178 gtk_widget_set_default_direction (new_direction);
5182 orientable_toggle_orientation (GtkOrientable *orientable)
5184 GtkOrientation orientation;
5186 orientation = gtk_orientable_get_orientation (orientable);
5187 gtk_orientable_set_orientation (orientable,
5188 orientation == GTK_ORIENTATION_HORIZONTAL ?
5189 GTK_ORIENTATION_VERTICAL :
5190 GTK_ORIENTATION_HORIZONTAL);
5192 if (GTK_IS_CONTAINER (orientable))
5197 children = gtk_container_get_children (GTK_CONTAINER (orientable));
5199 for (child = children; child; child = child->next)
5201 if (GTK_IS_ORIENTABLE (child->data))
5202 orientable_toggle_orientation (child->data);
5205 g_list_free (children);
5210 flipping_orientation_toggled_cb (GtkWidget *widget, gpointer data)
5212 GtkWidget *content_area;
5213 GtkWidget *toplevel;
5215 toplevel = gtk_widget_get_toplevel (widget);
5216 content_area = gtk_dialog_get_content_area (GTK_DIALOG (toplevel));
5217 orientable_toggle_orientation (GTK_ORIENTABLE (content_area));
5221 set_direction_recurse (GtkWidget *widget,
5224 GtkTextDirection *dir = data;
5226 gtk_widget_set_direction (widget, *dir);
5227 if (GTK_IS_CONTAINER (widget))
5228 gtk_container_foreach (GTK_CONTAINER (widget),
5229 set_direction_recurse,
5234 create_forward_back (const char *title,
5235 GtkTextDirection text_dir)
5237 GtkWidget *frame = gtk_frame_new (title);
5238 GtkWidget *bbox = gtk_button_box_new (GTK_ORIENTATION_HORIZONTAL);
5239 GtkWidget *back_button = gtk_button_new_from_stock (GTK_STOCK_GO_BACK);
5240 GtkWidget *forward_button = gtk_button_new_from_stock (GTK_STOCK_GO_FORWARD);
5242 gtk_container_set_border_width (GTK_CONTAINER (bbox), 5);
5244 gtk_container_add (GTK_CONTAINER (frame), bbox);
5245 gtk_container_add (GTK_CONTAINER (bbox), back_button);
5246 gtk_container_add (GTK_CONTAINER (bbox), forward_button);
5248 set_direction_recurse (frame, &text_dir);
5254 create_flipping (GtkWidget *widget)
5256 static GtkWidget *window = NULL;
5257 GtkWidget *check_button, *button;
5258 GtkWidget *action_area, *content_area;
5262 window = gtk_dialog_new ();
5264 gtk_window_set_screen (GTK_WINDOW (window),
5265 gtk_widget_get_screen (widget));
5267 g_signal_connect (window, "destroy",
5268 G_CALLBACK (gtk_widget_destroyed),
5271 content_area = gtk_dialog_get_content_area (GTK_DIALOG (window));
5272 action_area = gtk_dialog_get_action_area (GTK_DIALOG (window));
5274 gtk_window_set_title (GTK_WINDOW (window), "Bidirectional Flipping");
5276 check_button = gtk_check_button_new_with_label ("Right-to-left global direction");
5277 gtk_container_set_border_width (GTK_CONTAINER (check_button), 10);
5278 gtk_box_pack_start (GTK_BOX (content_area), check_button, TRUE, TRUE, 0);
5280 if (gtk_widget_get_default_direction () == GTK_TEXT_DIR_RTL)
5281 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check_button), TRUE);
5283 g_signal_connect (check_button, "toggled",
5284 G_CALLBACK (flipping_toggled_cb), NULL);
5286 check_button = gtk_check_button_new_with_label ("Toggle orientation of all boxes");
5287 gtk_container_set_border_width (GTK_CONTAINER (check_button), 10);
5288 gtk_box_pack_start (GTK_BOX (content_area), check_button, TRUE, TRUE, 0);
5290 g_signal_connect (check_button, "toggled",
5291 G_CALLBACK (flipping_orientation_toggled_cb), NULL);
5293 gtk_box_pack_start (GTK_BOX (content_area),
5294 create_forward_back ("Default", GTK_TEXT_DIR_NONE),
5297 gtk_box_pack_start (GTK_BOX (content_area),
5298 create_forward_back ("Left-to-Right", GTK_TEXT_DIR_LTR),
5301 gtk_box_pack_start (GTK_BOX (content_area),
5302 create_forward_back ("Right-to-Left", GTK_TEXT_DIR_RTL),
5305 button = gtk_button_new_with_label ("Close");
5306 g_signal_connect_swapped (button, "clicked",
5307 G_CALLBACK (gtk_widget_destroy), window);
5308 gtk_box_pack_start (GTK_BOX (action_area), button, TRUE, TRUE, 0);
5311 if (!gtk_widget_get_visible (window))
5312 gtk_widget_show_all (window);
5314 gtk_widget_destroy (window);
5322 make_focus_table (GList **list)
5327 table = gtk_table_new (5, 5, FALSE);
5340 widget = gtk_entry_new ();
5342 widget = gtk_button_new_with_label ("Foo");
5344 *list = g_list_prepend (*list, widget);
5346 gtk_table_attach (GTK_TABLE (table),
5350 GTK_EXPAND | GTK_FILL,
5351 GTK_EXPAND | GTK_FILL,
5360 *list = g_list_reverse (*list);
5366 create_focus (GtkWidget *widget)
5368 static GtkWidget *window = NULL;
5372 GtkWidget *content_area;
5377 window = gtk_dialog_new_with_buttons ("Keyboard focus navigation",
5383 gtk_window_set_screen (GTK_WINDOW (window),
5384 gtk_widget_get_screen (widget));
5386 g_signal_connect (window, "destroy",
5387 G_CALLBACK (gtk_widget_destroyed),
5390 g_signal_connect (window, "response",
5391 G_CALLBACK (gtk_widget_destroy),
5394 content_area = gtk_dialog_get_content_area (GTK_DIALOG (window));
5396 gtk_window_set_title (GTK_WINDOW (window), "Keyboard Focus Navigation");
5398 frame = gtk_frame_new ("Weird tab focus chain");
5400 gtk_box_pack_start (GTK_BOX (content_area), frame, TRUE, TRUE, 0);
5402 table = make_focus_table (&list);
5404 gtk_container_add (GTK_CONTAINER (frame), table);
5406 gtk_container_set_focus_chain (GTK_CONTAINER (table),
5411 frame = gtk_frame_new ("Default tab focus chain");
5413 gtk_box_pack_start (GTK_BOX (content_area), frame, TRUE, TRUE, 0);
5416 table = make_focus_table (&list);
5420 gtk_container_add (GTK_CONTAINER (frame), table);
5423 if (!gtk_widget_get_visible (window))
5424 gtk_widget_show_all (window);
5426 gtk_widget_destroy (window);
5434 create_font_selection (GtkWidget *widget)
5436 static GtkWidget *window = NULL;
5444 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
5445 gtk_window_set_screen (GTK_WINDOW (window),
5446 gtk_widget_get_screen (widget));
5448 g_signal_connect (window, "destroy",
5449 G_CALLBACK (gtk_widget_destroyed),
5452 gtk_window_set_title (GTK_WINDOW (window), "GtkFontButton");
5453 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
5455 hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 8);
5456 gtk_container_set_border_width (GTK_CONTAINER (hbox), 8);
5457 gtk_container_add (GTK_CONTAINER (window), hbox);
5459 label = gtk_label_new ("Pick a font");
5460 gtk_container_add (GTK_CONTAINER (hbox), label);
5462 picker = gtk_font_button_new ();
5463 gtk_font_button_set_use_font (GTK_FONT_BUTTON (picker), TRUE);
5464 gtk_container_add (GTK_CONTAINER (hbox), picker);
5467 if (!gtk_widget_get_visible (window))
5468 gtk_widget_show_all (window);
5470 gtk_widget_destroy (window);
5477 static GtkWidget *dialog_window = NULL;
5480 label_toggle (GtkWidget *widget,
5485 *label = gtk_label_new ("Dialog Test");
5486 g_signal_connect (*label,
5488 G_CALLBACK (gtk_widget_destroyed),
5490 g_object_set (*label, "margin", 10, NULL);
5491 gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog_window))),
5492 *label, TRUE, TRUE, 0);
5493 gtk_widget_show (*label);
5496 gtk_widget_destroy (*label);
5500 create_dialog (GtkWidget *widget)
5502 static GtkWidget *label;
5503 GtkWidget *action_area;
5508 /* This is a terrible example; it's much simpler to create
5509 * dialogs than this. Don't use testgtk for example code,
5513 dialog_window = gtk_dialog_new ();
5514 gtk_window_set_screen (GTK_WINDOW (dialog_window),
5515 gtk_widget_get_screen (widget));
5517 g_signal_connect (dialog_window, "destroy",
5518 G_CALLBACK (gtk_widget_destroyed),
5521 action_area = gtk_dialog_get_action_area (GTK_DIALOG (dialog_window));
5523 gtk_window_set_title (GTK_WINDOW (dialog_window), "GtkDialog");
5524 gtk_container_set_border_width (GTK_CONTAINER (dialog_window), 0);
5526 button = gtk_button_new_with_label ("OK");
5527 gtk_widget_set_can_default (button, TRUE);
5528 gtk_box_pack_start (GTK_BOX (action_area), button, TRUE, TRUE, 0);
5529 gtk_widget_grab_default (button);
5530 gtk_widget_show (button);
5532 button = gtk_button_new_with_label ("Toggle");
5533 g_signal_connect (button, "clicked",
5534 G_CALLBACK (label_toggle),
5536 gtk_widget_set_can_default (button, TRUE);
5537 gtk_box_pack_start (GTK_BOX (action_area), button, TRUE, TRUE, 0);
5538 gtk_widget_show (button);
5543 if (!gtk_widget_get_visible (dialog_window))
5544 gtk_widget_show (dialog_window);
5546 gtk_widget_destroy (dialog_window);
5549 /* Display & Screen test
5556 GtkWidget *radio_dpy;
5557 GtkWidget *toplevel;
5558 GtkWidget *dialog_window;
5559 } ScreenDisplaySelection;
5562 screen_display_check (GtkWidget *widget, ScreenDisplaySelection *data)
5564 const gchar *display_name;
5565 GdkDisplay *display = gtk_widget_get_display (widget);
5567 GdkScreen *new_screen = NULL;
5568 GdkScreen *current_screen = gtk_widget_get_screen (widget);
5570 if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (data->radio_dpy)))
5572 display_name = gtk_entry_get_text (GTK_ENTRY (data->entry));
5573 display = gdk_display_open (display_name);
5577 dialog = gtk_message_dialog_new (GTK_WINDOW (gtk_widget_get_toplevel (widget)),
5578 GTK_DIALOG_DESTROY_WITH_PARENT,
5581 "The display :\n%s\ncannot be opened",
5583 gtk_window_set_screen (GTK_WINDOW (dialog), current_screen);
5584 gtk_widget_show (dialog);
5585 g_signal_connect (dialog, "response",
5586 G_CALLBACK (gtk_widget_destroy),
5591 GtkTreeModel *model = gtk_combo_box_get_model (GTK_COMBO_BOX (data->combo));
5594 gboolean found = FALSE;
5595 while (gtk_tree_model_iter_nth_child (model, &iter, NULL, i++))
5598 gtk_tree_model_get (model, &iter, 0, &name, -1);
5599 found = !g_ascii_strcasecmp (display_name, name);
5606 gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (data->combo), display_name);
5607 new_screen = gdk_display_get_default_screen (display);
5612 gint number_of_screens = gdk_display_get_n_screens (display);
5613 gint screen_num = gdk_screen_get_number (current_screen);
5614 if ((screen_num +1) < number_of_screens)
5615 new_screen = gdk_display_get_screen (display, screen_num + 1);
5617 new_screen = gdk_display_get_screen (display, 0);
5622 gtk_window_set_screen (GTK_WINDOW (data->toplevel), new_screen);
5623 gtk_widget_destroy (data->dialog_window);
5628 screen_display_destroy_diag (GtkWidget *widget, GtkWidget *data)
5630 gtk_widget_destroy (data);
5634 create_display_screen (GtkWidget *widget)
5636 GtkWidget *table, *frame, *window, *combo_dpy, *vbox;
5637 GtkWidget *radio_dpy, *radio_scr, *applyb, *cancelb;
5639 ScreenDisplaySelection *scr_dpy_data;
5640 GdkScreen *screen = gtk_widget_get_screen (widget);
5641 GdkDisplay *display = gdk_screen_get_display (screen);
5643 window = g_object_new (gtk_window_get_type (),
5646 "type", GTK_WINDOW_TOPLEVEL,
5648 "Screen or Display selection",
5649 "border_width", 10, NULL);
5650 g_signal_connect (window, "destroy",
5651 G_CALLBACK (gtk_widget_destroy), NULL);
5653 vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 3);
5654 gtk_container_add (GTK_CONTAINER (window), vbox);
5656 frame = gtk_frame_new ("Select screen or display");
5657 gtk_container_add (GTK_CONTAINER (vbox), frame);
5659 table = gtk_table_new (2, 2, TRUE);
5660 gtk_table_set_row_spacings (GTK_TABLE (table), 3);
5661 gtk_table_set_col_spacings (GTK_TABLE (table), 3);
5663 gtk_container_add (GTK_CONTAINER (frame), table);
5665 radio_dpy = gtk_radio_button_new_with_label (NULL, "move to another X display");
5666 if (gdk_display_get_n_screens(display) > 1)
5667 radio_scr = gtk_radio_button_new_with_label
5668 (gtk_radio_button_get_group (GTK_RADIO_BUTTON (radio_dpy)), "move to next screen");
5671 radio_scr = gtk_radio_button_new_with_label
5672 (gtk_radio_button_get_group (GTK_RADIO_BUTTON (radio_dpy)),
5673 "only one screen on the current display");
5674 gtk_widget_set_sensitive (radio_scr, FALSE);
5676 combo_dpy = gtk_combo_box_text_new_with_entry ();
5677 gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo_dpy), "diabolo:0.0");
5678 gtk_entry_set_text (GTK_ENTRY (gtk_bin_get_child (GTK_BIN (combo_dpy))),
5679 "<hostname>:<X Server Num>.<Screen Num>");
5681 gtk_table_attach_defaults (GTK_TABLE (table), radio_dpy, 0, 1, 0, 1);
5682 gtk_table_attach_defaults (GTK_TABLE (table), radio_scr, 0, 1, 1, 2);
5683 gtk_table_attach_defaults (GTK_TABLE (table), combo_dpy, 1, 2, 0, 1);
5685 bbox = gtk_button_box_new (GTK_ORIENTATION_HORIZONTAL);
5686 applyb = gtk_button_new_from_stock (GTK_STOCK_APPLY);
5687 cancelb = gtk_button_new_from_stock (GTK_STOCK_CANCEL);
5689 gtk_container_add (GTK_CONTAINER (vbox), bbox);
5691 gtk_container_add (GTK_CONTAINER (bbox), applyb);
5692 gtk_container_add (GTK_CONTAINER (bbox), cancelb);
5694 scr_dpy_data = g_new0 (ScreenDisplaySelection, 1);
5696 scr_dpy_data->entry = gtk_bin_get_child (GTK_BIN (combo_dpy));
5697 scr_dpy_data->radio_dpy = radio_dpy;
5698 scr_dpy_data->toplevel = gtk_widget_get_toplevel (widget);
5699 scr_dpy_data->dialog_window = window;
5701 g_signal_connect (cancelb, "clicked",
5702 G_CALLBACK (screen_display_destroy_diag), window);
5703 g_signal_connect (applyb, "clicked",
5704 G_CALLBACK (screen_display_check), scr_dpy_data);
5705 gtk_widget_show_all (window);
5710 static gulong event_watcher_enter_id = 0;
5711 static gulong event_watcher_leave_id = 0;
5714 event_watcher (GSignalInvocationHint *ihint,
5715 guint n_param_values,
5716 const GValue *param_values,
5719 g_print ("Watch: \"%s\" emitted for %s\n",
5720 g_signal_name (ihint->signal_id),
5721 G_OBJECT_TYPE_NAME (g_value_get_object (param_values + 0)));
5727 event_watcher_down (void)
5729 if (event_watcher_enter_id)
5733 signal_id = g_signal_lookup ("enter_notify_event", GTK_TYPE_WIDGET);
5734 g_signal_remove_emission_hook (signal_id, event_watcher_enter_id);
5735 event_watcher_enter_id = 0;
5736 signal_id = g_signal_lookup ("leave_notify_event", GTK_TYPE_WIDGET);
5737 g_signal_remove_emission_hook (signal_id, event_watcher_leave_id);
5738 event_watcher_leave_id = 0;
5743 event_watcher_toggle (void)
5745 if (event_watcher_enter_id)
5746 event_watcher_down ();
5751 signal_id = g_signal_lookup ("enter_notify_event", GTK_TYPE_WIDGET);
5752 event_watcher_enter_id = g_signal_add_emission_hook (signal_id, 0, event_watcher, NULL, NULL);
5753 signal_id = g_signal_lookup ("leave_notify_event", GTK_TYPE_WIDGET);
5754 event_watcher_leave_id = g_signal_add_emission_hook (signal_id, 0, event_watcher, NULL, NULL);
5759 create_event_watcher (GtkWidget *widget)
5761 GtkWidget *action_area, *content_area;
5766 dialog_window = gtk_dialog_new ();
5767 gtk_window_set_screen (GTK_WINDOW (dialog_window),
5768 gtk_widget_get_screen (widget));
5770 g_signal_connect (dialog_window, "destroy",
5771 G_CALLBACK (gtk_widget_destroyed),
5773 g_signal_connect (dialog_window, "destroy",
5774 G_CALLBACK (event_watcher_down),
5777 content_area = gtk_dialog_get_content_area (GTK_DIALOG (dialog_window));
5778 action_area = gtk_dialog_get_action_area (GTK_DIALOG (dialog_window));
5780 gtk_window_set_title (GTK_WINDOW (dialog_window), "Event Watcher");
5781 gtk_container_set_border_width (GTK_CONTAINER (dialog_window), 0);
5782 gtk_widget_set_size_request (dialog_window, 200, 110);
5784 button = gtk_toggle_button_new_with_label ("Activate Watch");
5785 g_signal_connect (button, "clicked",
5786 G_CALLBACK (event_watcher_toggle),
5788 gtk_container_set_border_width (GTK_CONTAINER (button), 10);
5789 gtk_box_pack_start (GTK_BOX (content_area), button, TRUE, TRUE, 0);
5790 gtk_widget_show (button);
5792 button = gtk_button_new_with_label ("Close");
5793 g_signal_connect_swapped (button, "clicked",
5794 G_CALLBACK (gtk_widget_destroy),
5796 gtk_widget_set_can_default (button, TRUE);
5797 gtk_box_pack_start (GTK_BOX (action_area), button, TRUE, TRUE, 0);
5798 gtk_widget_grab_default (button);
5799 gtk_widget_show (button);
5802 if (!gtk_widget_get_visible (dialog_window))
5803 gtk_widget_show (dialog_window);
5805 gtk_widget_destroy (dialog_window);
5813 reformat_value (GtkScale *scale,
5816 return g_strdup_printf ("-->%0.*g<--",
5817 gtk_scale_get_digits (scale), value);
5821 create_range_controls (GtkWidget *widget)
5823 static GtkWidget *window = NULL;
5827 GtkWidget *scrollbar;
5829 GtkWidget *separator;
5830 GtkAdjustment *adjustment;
5835 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
5837 gtk_window_set_screen (GTK_WINDOW (window),
5838 gtk_widget_get_screen (widget));
5840 g_signal_connect (window, "destroy",
5841 G_CALLBACK (gtk_widget_destroyed),
5844 gtk_window_set_title (GTK_WINDOW (window), "range controls");
5845 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
5848 box1 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
5849 gtk_container_add (GTK_CONTAINER (window), box1);
5850 gtk_widget_show (box1);
5853 box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10);
5854 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
5855 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
5856 gtk_widget_show (box2);
5859 adjustment = gtk_adjustment_new (0.0, 0.0, 101.0, 0.1, 1.0, 1.0);
5861 scale = gtk_scale_new (GTK_ORIENTATION_HORIZONTAL, GTK_ADJUSTMENT (adjustment));
5862 gtk_widget_set_size_request (GTK_WIDGET (scale), 150, -1);
5863 gtk_scale_set_digits (GTK_SCALE (scale), 1);
5864 gtk_scale_set_draw_value (GTK_SCALE (scale), TRUE);
5865 gtk_box_pack_start (GTK_BOX (box2), scale, TRUE, TRUE, 0);
5866 gtk_widget_show (scale);
5868 scrollbar = gtk_scrollbar_new (GTK_ORIENTATION_HORIZONTAL, GTK_ADJUSTMENT (adjustment));
5869 gtk_box_pack_start (GTK_BOX (box2), scrollbar, TRUE, TRUE, 0);
5870 gtk_widget_show (scrollbar);
5872 scale = gtk_scale_new (GTK_ORIENTATION_HORIZONTAL, GTK_ADJUSTMENT (adjustment));
5873 gtk_scale_set_draw_value (GTK_SCALE (scale), TRUE);
5874 g_signal_connect (scale,
5876 G_CALLBACK (reformat_value),
5878 gtk_box_pack_start (GTK_BOX (box2), scale, TRUE, TRUE, 0);
5879 gtk_widget_show (scale);
5881 hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
5883 scale = gtk_scale_new (GTK_ORIENTATION_VERTICAL, GTK_ADJUSTMENT (adjustment));
5884 gtk_widget_set_size_request (scale, -1, 200);
5885 gtk_scale_set_digits (GTK_SCALE (scale), 2);
5886 gtk_scale_set_draw_value (GTK_SCALE (scale), TRUE);
5887 gtk_box_pack_start (GTK_BOX (hbox), scale, TRUE, TRUE, 0);
5888 gtk_widget_show (scale);
5890 scale = gtk_scale_new (GTK_ORIENTATION_VERTICAL, GTK_ADJUSTMENT (adjustment));
5891 gtk_widget_set_size_request (scale, -1, 200);
5892 gtk_scale_set_digits (GTK_SCALE (scale), 2);
5893 gtk_scale_set_draw_value (GTK_SCALE (scale), TRUE);
5894 gtk_range_set_inverted (GTK_RANGE (scale), TRUE);
5895 gtk_box_pack_start (GTK_BOX (hbox), scale, TRUE, TRUE, 0);
5896 gtk_widget_show (scale);
5898 scale = gtk_scale_new (GTK_ORIENTATION_VERTICAL, GTK_ADJUSTMENT (adjustment));
5899 gtk_scale_set_draw_value (GTK_SCALE (scale), TRUE);
5900 g_signal_connect (scale,
5902 G_CALLBACK (reformat_value),
5904 gtk_box_pack_start (GTK_BOX (hbox), scale, TRUE, TRUE, 0);
5905 gtk_widget_show (scale);
5908 gtk_box_pack_start (GTK_BOX (box2), hbox, TRUE, TRUE, 0);
5909 gtk_widget_show (hbox);
5911 separator = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
5912 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
5913 gtk_widget_show (separator);
5916 box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10);
5917 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
5918 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
5919 gtk_widget_show (box2);
5922 button = gtk_button_new_with_label ("close");
5923 g_signal_connect_swapped (button, "clicked",
5924 G_CALLBACK (gtk_widget_destroy),
5926 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
5927 gtk_widget_set_can_default (button, TRUE);
5928 gtk_widget_grab_default (button);
5929 gtk_widget_show (button);
5932 if (!gtk_widget_get_visible (window))
5933 gtk_widget_show (window);
5935 gtk_widget_destroy (window);
5942 { { 0, 0x0000, 0x0000, 0x0000 }, "black" },
5943 { { 0, 0xFFFF, 0xFFFF, 0xFFFF }, "white" },
5944 { { 0, 0xFFFF, 0x0000, 0x0000 }, "red" },
5945 { { 0, 0x0000, 0xFFFF, 0x0000 }, "green" },
5946 { { 0, 0x0000, 0x0000, 0xFFFF }, "blue" },
5947 { { 0, 0x0000, 0xFFFF, 0xFFFF }, "cyan" },
5948 { { 0, 0xFFFF, 0x0000, 0xFFFF }, "magenta" },
5949 { { 0, 0xFFFF, 0xFFFF, 0x0000 }, "yellow" }
5952 int ntext_colors = sizeof(text_colors) / sizeof(text_colors[0]);
5958 static const char * book_open_xpm[] = {
5981 static const char * book_closed_xpm[] = {
6006 GdkPixbuf *book_open;
6007 GdkPixbuf *book_closed;
6008 GtkWidget *sample_notebook;
6011 set_page_image (GtkNotebook *notebook, gint page_num, GdkPixbuf *pixbuf)
6013 GtkWidget *page_widget;
6016 page_widget = gtk_notebook_get_nth_page (notebook, page_num);
6018 pixwid = g_object_get_data (G_OBJECT (page_widget), "tab_pixmap");
6019 gtk_image_set_from_pixbuf (GTK_IMAGE (pixwid), pixbuf);
6021 pixwid = g_object_get_data (G_OBJECT (page_widget), "menu_pixmap");
6022 gtk_image_set_from_pixbuf (GTK_IMAGE (pixwid), pixbuf);
6026 page_switch (GtkWidget *widget, gpointer *page, gint page_num)
6028 GtkNotebook *notebook = GTK_NOTEBOOK (widget);
6029 gint old_page_num = gtk_notebook_get_current_page (notebook);
6031 if (page_num == old_page_num)
6034 set_page_image (notebook, page_num, book_open);
6036 if (old_page_num != -1)
6037 set_page_image (notebook, old_page_num, book_closed);
6041 tab_fill (GtkToggleButton *button, GtkWidget *child)
6043 gtk_container_child_set (GTK_CONTAINER (sample_notebook), child,
6044 "tab-fill", gtk_toggle_button_get_active (button),
6049 tab_expand (GtkToggleButton *button, GtkWidget *child)
6051 gtk_container_child_set (GTK_CONTAINER (sample_notebook), child,
6052 "tab-expand", gtk_toggle_button_get_active (button),
6057 create_pages (GtkNotebook *notebook, gint start, gint end)
6059 GtkWidget *child = NULL;
6064 GtkWidget *label_box;
6065 GtkWidget *menu_box;
6069 char accel_buffer[32];
6071 for (i = start; i <= end; i++)
6073 sprintf (buffer, "Page %d", i);
6074 sprintf (accel_buffer, "Page _%d", i);
6076 child = gtk_frame_new (buffer);
6077 gtk_container_set_border_width (GTK_CONTAINER (child), 10);
6079 vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
6080 gtk_box_set_homogeneous (GTK_BOX (vbox), TRUE);
6081 gtk_container_set_border_width (GTK_CONTAINER (vbox), 10);
6082 gtk_container_add (GTK_CONTAINER (child), vbox);
6084 hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
6085 gtk_box_set_homogeneous (GTK_BOX (hbox), TRUE);
6086 gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 5);
6088 button = gtk_check_button_new_with_label ("Fill Tab");
6089 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
6090 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
6091 g_signal_connect (button, "toggled",
6092 G_CALLBACK (tab_fill), child);
6094 button = gtk_check_button_new_with_label ("Expand Tab");
6095 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
6096 g_signal_connect (button, "toggled",
6097 G_CALLBACK (tab_expand), child);
6099 button = gtk_button_new_with_label ("Hide Page");
6100 gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 5);
6101 g_signal_connect_swapped (button, "clicked",
6102 G_CALLBACK (gtk_widget_hide),
6105 gtk_widget_show_all (child);
6107 label_box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
6108 pixwid = gtk_image_new_from_pixbuf (book_closed);
6109 g_object_set_data (G_OBJECT (child), "tab_pixmap", pixwid);
6111 gtk_box_pack_start (GTK_BOX (label_box), pixwid, FALSE, TRUE, 0);
6112 gtk_widget_set_margin_left (pixwid, 3);
6113 gtk_widget_set_margin_right (pixwid, 3);
6114 gtk_widget_set_margin_bottom (pixwid, 1);
6115 gtk_widget_set_margin_top (pixwid, 1);
6116 label = gtk_label_new_with_mnemonic (accel_buffer);
6117 gtk_box_pack_start (GTK_BOX (label_box), label, FALSE, TRUE, 0);
6118 gtk_widget_show_all (label_box);
6121 menu_box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
6122 pixwid = gtk_image_new_from_pixbuf (book_closed);
6123 g_object_set_data (G_OBJECT (child), "menu_pixmap", pixwid);
6125 gtk_box_pack_start (GTK_BOX (menu_box), pixwid, FALSE, TRUE, 0);
6126 gtk_widget_set_margin_left (pixwid, 3);
6127 gtk_widget_set_margin_right (pixwid, 3);
6128 gtk_widget_set_margin_bottom (pixwid, 1);
6129 gtk_widget_set_margin_top (pixwid, 1);
6130 label = gtk_label_new (buffer);
6131 gtk_box_pack_start (GTK_BOX (menu_box), label, FALSE, TRUE, 0);
6132 gtk_widget_show_all (menu_box);
6134 gtk_notebook_append_page_menu (notebook, child, label_box, menu_box);
6139 rotate_notebook (GtkButton *button,
6140 GtkNotebook *notebook)
6142 gtk_notebook_set_tab_pos (notebook, (gtk_notebook_get_tab_pos (notebook) + 1) % 4);
6146 show_all_pages (GtkButton *button,
6147 GtkNotebook *notebook)
6149 gtk_container_foreach (GTK_CONTAINER (notebook),
6150 (GtkCallback) gtk_widget_show, NULL);
6154 notebook_type_changed (GtkWidget *optionmenu,
6157 GtkNotebook *notebook;
6167 notebook = GTK_NOTEBOOK (data);
6169 c = gtk_combo_box_get_active (GTK_COMBO_BOX (optionmenu));
6174 /* standard notebook */
6175 gtk_notebook_set_show_tabs (notebook, TRUE);
6176 gtk_notebook_set_show_border (notebook, TRUE);
6177 gtk_notebook_set_scrollable (notebook, FALSE);
6181 /* notabs notebook */
6182 gtk_notebook_set_show_tabs (notebook, FALSE);
6183 gtk_notebook_set_show_border (notebook, TRUE);
6188 gtk_notebook_set_show_tabs (notebook, FALSE);
6189 gtk_notebook_set_show_border (notebook, FALSE);
6194 gtk_notebook_set_show_tabs (notebook, TRUE);
6195 gtk_notebook_set_show_border (notebook, TRUE);
6196 gtk_notebook_set_scrollable (notebook, TRUE);
6197 if (gtk_notebook_get_n_pages (notebook) == 5)
6198 create_pages (notebook, 6, 15);
6204 if (gtk_notebook_get_n_pages (notebook) == 15)
6205 for (i = 0; i < 10; i++)
6206 gtk_notebook_remove_page (notebook, 5);
6210 notebook_popup (GtkToggleButton *button,
6211 GtkNotebook *notebook)
6213 if (gtk_toggle_button_get_active (button))
6214 gtk_notebook_popup_enable (notebook);
6216 gtk_notebook_popup_disable (notebook);
6220 create_notebook (GtkWidget *widget)
6222 static GtkWidget *window = NULL;
6226 GtkWidget *separator;
6230 static gchar *items[] =
6240 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
6241 gtk_window_set_screen (GTK_WINDOW (window),
6242 gtk_widget_get_screen (widget));
6244 g_signal_connect (window, "destroy",
6245 G_CALLBACK (gtk_widget_destroyed),
6248 gtk_window_set_title (GTK_WINDOW (window), "notebook");
6249 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
6251 box1 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
6252 gtk_container_add (GTK_CONTAINER (window), box1);
6254 sample_notebook = gtk_notebook_new ();
6255 g_signal_connect (sample_notebook, "switch_page",
6256 G_CALLBACK (page_switch), NULL);
6257 gtk_notebook_set_tab_pos (GTK_NOTEBOOK (sample_notebook), GTK_POS_TOP);
6258 gtk_box_pack_start (GTK_BOX (box1), sample_notebook, TRUE, TRUE, 0);
6259 gtk_container_set_border_width (GTK_CONTAINER (sample_notebook), 10);
6261 gtk_widget_realize (sample_notebook);
6264 book_open = gdk_pixbuf_new_from_xpm_data (book_open_xpm);
6267 book_closed = gdk_pixbuf_new_from_xpm_data (book_closed_xpm);
6269 create_pages (GTK_NOTEBOOK (sample_notebook), 1, 5);
6271 separator = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
6272 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 10);
6274 box2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 5);
6275 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
6276 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
6278 button = gtk_check_button_new_with_label ("popup menu");
6279 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, FALSE, 0);
6280 g_signal_connect (button, "clicked",
6281 G_CALLBACK (notebook_popup),
6284 box2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 5);
6285 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
6286 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
6288 label = gtk_label_new ("Notebook Style :");
6289 gtk_box_pack_start (GTK_BOX (box2), label, FALSE, TRUE, 0);
6291 omenu = build_option_menu (items, G_N_ELEMENTS (items), 0,
6292 notebook_type_changed,
6294 gtk_box_pack_start (GTK_BOX (box2), omenu, FALSE, TRUE, 0);
6296 button = gtk_button_new_with_label ("Show all Pages");
6297 gtk_box_pack_start (GTK_BOX (box2), button, FALSE, TRUE, 0);
6298 g_signal_connect (button, "clicked",
6299 G_CALLBACK (show_all_pages), sample_notebook);
6301 box2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 10);
6302 gtk_box_set_homogeneous (GTK_BOX (box2), TRUE);
6303 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
6304 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
6306 button = gtk_button_new_with_label ("prev");
6307 g_signal_connect_swapped (button, "clicked",
6308 G_CALLBACK (gtk_notebook_prev_page),
6310 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
6312 button = gtk_button_new_with_label ("next");
6313 g_signal_connect_swapped (button, "clicked",
6314 G_CALLBACK (gtk_notebook_next_page),
6316 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
6318 button = gtk_button_new_with_label ("rotate");
6319 g_signal_connect (button, "clicked",
6320 G_CALLBACK (rotate_notebook), sample_notebook);
6321 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
6323 separator = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
6324 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 5);
6326 button = gtk_button_new_with_label ("close");
6327 gtk_container_set_border_width (GTK_CONTAINER (button), 5);
6328 g_signal_connect_swapped (button, "clicked",
6329 G_CALLBACK (gtk_widget_destroy),
6331 gtk_box_pack_start (GTK_BOX (box1), button, FALSE, FALSE, 0);
6332 gtk_widget_set_can_default (button, TRUE);
6333 gtk_widget_grab_default (button);
6336 if (!gtk_widget_get_visible (window))
6337 gtk_widget_show_all (window);
6339 gtk_widget_destroy (window);
6347 toggle_resize (GtkWidget *widget, GtkWidget *child)
6349 GtkContainer *container = GTK_CONTAINER (gtk_widget_get_parent (child));
6350 GValue value = { 0, };
6351 g_value_init (&value, G_TYPE_BOOLEAN);
6352 gtk_container_child_get_property (container, child, "resize", &value);
6353 g_value_set_boolean (&value, !g_value_get_boolean (&value));
6354 gtk_container_child_set_property (container, child, "resize", &value);
6358 toggle_shrink (GtkWidget *widget, GtkWidget *child)
6360 GtkContainer *container = GTK_CONTAINER (gtk_widget_get_parent (child));
6361 GValue value = { 0, };
6362 g_value_init (&value, G_TYPE_BOOLEAN);
6363 gtk_container_child_get_property (container, child, "shrink", &value);
6364 g_value_set_boolean (&value, !g_value_get_boolean (&value));
6365 gtk_container_child_set_property (container, child, "shrink", &value);
6369 paned_props_clicked (GtkWidget *button,
6372 GtkWidget *window = create_prop_editor (paned, GTK_TYPE_PANED);
6374 gtk_window_set_title (GTK_WINDOW (window), "Paned Properties");
6378 create_pane_options (GtkPaned *paned,
6379 const gchar *frame_label,
6380 const gchar *label1,
6381 const gchar *label2)
6383 GtkWidget *child1, *child2;
6388 GtkWidget *check_button;
6390 child1 = gtk_paned_get_child1 (paned);
6391 child2 = gtk_paned_get_child2 (paned);
6393 frame = gtk_frame_new (frame_label);
6394 gtk_container_set_border_width (GTK_CONTAINER (frame), 4);
6396 table = gtk_table_new (4, 2, 4);
6397 gtk_container_add (GTK_CONTAINER (frame), table);
6399 label = gtk_label_new (label1);
6400 gtk_table_attach_defaults (GTK_TABLE (table), label,
6403 check_button = gtk_check_button_new_with_label ("Resize");
6404 gtk_table_attach_defaults (GTK_TABLE (table), check_button,
6406 g_signal_connect (check_button, "toggled",
6407 G_CALLBACK (toggle_resize),
6410 check_button = gtk_check_button_new_with_label ("Shrink");
6411 gtk_table_attach_defaults (GTK_TABLE (table), check_button,
6413 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check_button),
6415 g_signal_connect (check_button, "toggled",
6416 G_CALLBACK (toggle_shrink),
6419 label = gtk_label_new (label2);
6420 gtk_table_attach_defaults (GTK_TABLE (table), label,
6423 check_button = gtk_check_button_new_with_label ("Resize");
6424 gtk_table_attach_defaults (GTK_TABLE (table), check_button,
6426 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check_button),
6428 g_signal_connect (check_button, "toggled",
6429 G_CALLBACK (toggle_resize),
6432 check_button = gtk_check_button_new_with_label ("Shrink");
6433 gtk_table_attach_defaults (GTK_TABLE (table), check_button,
6435 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check_button),
6437 g_signal_connect (check_button, "toggled",
6438 G_CALLBACK (toggle_shrink),
6441 button = gtk_button_new_with_mnemonic ("_Properties");
6442 gtk_table_attach_defaults (GTK_TABLE (table), button,
6444 g_signal_connect (button, "clicked",
6445 G_CALLBACK (paned_props_clicked),
6452 create_panes (GtkWidget *widget)
6454 static GtkWidget *window = NULL;
6463 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
6465 gtk_window_set_screen (GTK_WINDOW (window),
6466 gtk_widget_get_screen (widget));
6468 g_signal_connect (window, "destroy",
6469 G_CALLBACK (gtk_widget_destroyed),
6472 gtk_window_set_title (GTK_WINDOW (window), "Panes");
6473 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
6475 vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
6476 gtk_container_add (GTK_CONTAINER (window), vbox);
6478 vpaned = gtk_paned_new (GTK_ORIENTATION_VERTICAL);
6479 gtk_box_pack_start (GTK_BOX (vbox), vpaned, TRUE, TRUE, 0);
6480 gtk_container_set_border_width (GTK_CONTAINER(vpaned), 5);
6482 hpaned = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL);
6483 gtk_paned_add1 (GTK_PANED (vpaned), hpaned);
6485 frame = gtk_frame_new (NULL);
6486 gtk_frame_set_shadow_type (GTK_FRAME(frame), GTK_SHADOW_IN);
6487 gtk_widget_set_size_request (frame, 60, 60);
6488 gtk_paned_add1 (GTK_PANED (hpaned), frame);
6490 button = gtk_button_new_with_label ("Hi there");
6491 gtk_container_add (GTK_CONTAINER(frame), button);
6493 frame = gtk_frame_new (NULL);
6494 gtk_frame_set_shadow_type (GTK_FRAME(frame), GTK_SHADOW_IN);
6495 gtk_widget_set_size_request (frame, 80, 60);
6496 gtk_paned_add2 (GTK_PANED (hpaned), frame);
6498 frame = gtk_frame_new (NULL);
6499 gtk_frame_set_shadow_type (GTK_FRAME(frame), GTK_SHADOW_IN);
6500 gtk_widget_set_size_request (frame, 60, 80);
6501 gtk_paned_add2 (GTK_PANED (vpaned), frame);
6503 /* Now create toggle buttons to control sizing */
6505 gtk_box_pack_start (GTK_BOX (vbox),
6506 create_pane_options (GTK_PANED (hpaned),
6512 gtk_box_pack_start (GTK_BOX (vbox),
6513 create_pane_options (GTK_PANED (vpaned),
6519 gtk_widget_show_all (vbox);
6522 if (!gtk_widget_get_visible (window))
6523 gtk_widget_show (window);
6525 gtk_widget_destroy (window);
6529 * Paned keyboard navigation
6533 paned_keyboard_window1 (GtkWidget *widget)
6556 window1 = gtk_window_new (GTK_WINDOW_TOPLEVEL);
6557 gtk_window_set_title (GTK_WINDOW (window1), "Basic paned navigation");
6558 gtk_window_set_screen (GTK_WINDOW (window1),
6559 gtk_widget_get_screen (widget));
6561 hpaned1 = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL);
6562 gtk_container_add (GTK_CONTAINER (window1), hpaned1);
6564 frame1 = gtk_frame_new (NULL);
6565 gtk_paned_pack1 (GTK_PANED (hpaned1), frame1, FALSE, TRUE);
6566 gtk_frame_set_shadow_type (GTK_FRAME (frame1), GTK_SHADOW_IN);
6568 vbox1 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
6569 gtk_container_add (GTK_CONTAINER (frame1), vbox1);
6571 button7 = gtk_button_new_with_label ("button7");
6572 gtk_box_pack_start (GTK_BOX (vbox1), button7, FALSE, FALSE, 0);
6574 button8 = gtk_button_new_with_label ("button8");
6575 gtk_box_pack_start (GTK_BOX (vbox1), button8, FALSE, FALSE, 0);
6577 button9 = gtk_button_new_with_label ("button9");
6578 gtk_box_pack_start (GTK_BOX (vbox1), button9, FALSE, FALSE, 0);
6580 vpaned1 = gtk_paned_new (GTK_ORIENTATION_VERTICAL);
6581 gtk_paned_pack2 (GTK_PANED (hpaned1), vpaned1, TRUE, TRUE);
6583 frame2 = gtk_frame_new (NULL);
6584 gtk_paned_pack1 (GTK_PANED (vpaned1), frame2, FALSE, TRUE);
6585 gtk_frame_set_shadow_type (GTK_FRAME (frame2), GTK_SHADOW_IN);
6587 frame5 = gtk_frame_new (NULL);
6588 gtk_container_add (GTK_CONTAINER (frame2), frame5);
6590 hbox1 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
6591 gtk_container_add (GTK_CONTAINER (frame5), hbox1);
6593 button5 = gtk_button_new_with_label ("button5");
6594 gtk_box_pack_start (GTK_BOX (hbox1), button5, FALSE, FALSE, 0);
6596 button6 = gtk_button_new_with_label ("button6");
6597 gtk_box_pack_start (GTK_BOX (hbox1), button6, FALSE, FALSE, 0);
6599 frame3 = gtk_frame_new (NULL);
6600 gtk_paned_pack2 (GTK_PANED (vpaned1), frame3, TRUE, TRUE);
6601 gtk_frame_set_shadow_type (GTK_FRAME (frame3), GTK_SHADOW_IN);
6603 frame4 = gtk_frame_new ("Buttons");
6604 gtk_container_add (GTK_CONTAINER (frame3), frame4);
6605 gtk_container_set_border_width (GTK_CONTAINER (frame4), 15);
6607 table1 = gtk_table_new (2, 2, FALSE);
6608 gtk_container_add (GTK_CONTAINER (frame4), table1);
6609 gtk_container_set_border_width (GTK_CONTAINER (table1), 11);
6611 button1 = gtk_button_new_with_label ("button1");
6612 gtk_table_attach (GTK_TABLE (table1), button1, 0, 1, 0, 1,
6613 (GtkAttachOptions) (GTK_FILL),
6614 (GtkAttachOptions) (0), 0, 0);
6616 button2 = gtk_button_new_with_label ("button2");
6617 gtk_table_attach (GTK_TABLE (table1), button2, 1, 2, 0, 1,
6618 (GtkAttachOptions) (GTK_FILL),
6619 (GtkAttachOptions) (0), 0, 0);
6621 button3 = gtk_button_new_with_label ("button3");
6622 gtk_table_attach (GTK_TABLE (table1), button3, 0, 1, 1, 2,
6623 (GtkAttachOptions) (GTK_FILL),
6624 (GtkAttachOptions) (0), 0, 0);
6626 button4 = gtk_button_new_with_label ("button4");
6627 gtk_table_attach (GTK_TABLE (table1), button4, 1, 2, 1, 2,
6628 (GtkAttachOptions) (GTK_FILL),
6629 (GtkAttachOptions) (0), 0, 0);
6635 paned_keyboard_window2 (GtkWidget *widget)
6640 GtkWidget *button13;
6644 GtkWidget *button12;
6646 GtkWidget *button11;
6647 GtkWidget *button10;
6649 window2 = gtk_window_new (GTK_WINDOW_TOPLEVEL);
6650 gtk_window_set_title (GTK_WINDOW (window2), "\"button 10\" is not inside the horisontal pane");
6652 gtk_window_set_screen (GTK_WINDOW (window2),
6653 gtk_widget_get_screen (widget));
6655 hpaned2 = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL);
6656 gtk_container_add (GTK_CONTAINER (window2), hpaned2);
6658 frame6 = gtk_frame_new (NULL);
6659 gtk_paned_pack1 (GTK_PANED (hpaned2), frame6, FALSE, TRUE);
6660 gtk_frame_set_shadow_type (GTK_FRAME (frame6), GTK_SHADOW_IN);
6662 button13 = gtk_button_new_with_label ("button13");
6663 gtk_container_add (GTK_CONTAINER (frame6), button13);
6665 hbox2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
6666 gtk_paned_pack2 (GTK_PANED (hpaned2), hbox2, TRUE, TRUE);
6668 vpaned2 = gtk_paned_new (GTK_ORIENTATION_VERTICAL);
6669 gtk_box_pack_start (GTK_BOX (hbox2), vpaned2, TRUE, TRUE, 0);
6671 frame7 = gtk_frame_new (NULL);
6672 gtk_paned_pack1 (GTK_PANED (vpaned2), frame7, FALSE, TRUE);
6673 gtk_frame_set_shadow_type (GTK_FRAME (frame7), GTK_SHADOW_IN);
6675 button12 = gtk_button_new_with_label ("button12");
6676 gtk_container_add (GTK_CONTAINER (frame7), button12);
6678 frame8 = gtk_frame_new (NULL);
6679 gtk_paned_pack2 (GTK_PANED (vpaned2), frame8, TRUE, TRUE);
6680 gtk_frame_set_shadow_type (GTK_FRAME (frame8), GTK_SHADOW_IN);
6682 button11 = gtk_button_new_with_label ("button11");
6683 gtk_container_add (GTK_CONTAINER (frame8), button11);
6685 button10 = gtk_button_new_with_label ("button10");
6686 gtk_box_pack_start (GTK_BOX (hbox2), button10, FALSE, FALSE, 0);
6692 paned_keyboard_window3 (GtkWidget *widget)
6699 GtkWidget *button14;
6702 GtkWidget *button15;
6705 GtkWidget *button16;
6707 GtkWidget *button17;
6709 window3 = gtk_window_new (GTK_WINDOW_TOPLEVEL);
6710 g_object_set_data (G_OBJECT (window3), "window3", window3);
6711 gtk_window_set_title (GTK_WINDOW (window3), "Nested panes");
6713 gtk_window_set_screen (GTK_WINDOW (window3),
6714 gtk_widget_get_screen (widget));
6717 vbox2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
6718 gtk_container_add (GTK_CONTAINER (window3), vbox2);
6720 label1 = gtk_label_new ("Three panes nested inside each other");
6721 gtk_box_pack_start (GTK_BOX (vbox2), label1, FALSE, FALSE, 0);
6723 hpaned3 = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL);
6724 gtk_box_pack_start (GTK_BOX (vbox2), hpaned3, TRUE, TRUE, 0);
6726 frame9 = gtk_frame_new (NULL);
6727 gtk_paned_pack1 (GTK_PANED (hpaned3), frame9, FALSE, TRUE);
6728 gtk_frame_set_shadow_type (GTK_FRAME (frame9), GTK_SHADOW_IN);
6730 button14 = gtk_button_new_with_label ("button14");
6731 gtk_container_add (GTK_CONTAINER (frame9), button14);
6733 hpaned4 = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL);
6734 gtk_paned_pack2 (GTK_PANED (hpaned3), hpaned4, TRUE, TRUE);
6736 frame10 = gtk_frame_new (NULL);
6737 gtk_paned_pack1 (GTK_PANED (hpaned4), frame10, FALSE, TRUE);
6738 gtk_frame_set_shadow_type (GTK_FRAME (frame10), GTK_SHADOW_IN);
6740 button15 = gtk_button_new_with_label ("button15");
6741 gtk_container_add (GTK_CONTAINER (frame10), button15);
6743 hpaned5 = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL);
6744 gtk_paned_pack2 (GTK_PANED (hpaned4), hpaned5, TRUE, TRUE);
6746 frame11 = gtk_frame_new (NULL);
6747 gtk_paned_pack1 (GTK_PANED (hpaned5), frame11, FALSE, TRUE);
6748 gtk_frame_set_shadow_type (GTK_FRAME (frame11), GTK_SHADOW_IN);
6750 button16 = gtk_button_new_with_label ("button16");
6751 gtk_container_add (GTK_CONTAINER (frame11), button16);
6753 frame12 = gtk_frame_new (NULL);
6754 gtk_paned_pack2 (GTK_PANED (hpaned5), frame12, TRUE, TRUE);
6755 gtk_frame_set_shadow_type (GTK_FRAME (frame12), GTK_SHADOW_IN);
6757 button17 = gtk_button_new_with_label ("button17");
6758 gtk_container_add (GTK_CONTAINER (frame12), button17);
6764 paned_keyboard_window4 (GtkWidget *widget)
6771 GtkWidget *button19;
6772 GtkWidget *button18;
6775 GtkWidget *button21;
6776 GtkWidget *button20;
6778 GtkWidget *button23;
6779 GtkWidget *button22;
6781 GtkWidget *button25;
6782 GtkWidget *button24;
6784 window4 = gtk_window_new (GTK_WINDOW_TOPLEVEL);
6785 g_object_set_data (G_OBJECT (window4), "window4", window4);
6786 gtk_window_set_title (GTK_WINDOW (window4), "window4");
6788 gtk_window_set_screen (GTK_WINDOW (window4),
6789 gtk_widget_get_screen (widget));
6791 vbox3 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
6792 gtk_container_add (GTK_CONTAINER (window4), vbox3);
6794 label2 = gtk_label_new ("Widget tree:\n\nhpaned \n - vpaned\n - hbox\n - vpaned\n - vpaned\n - vpaned\n");
6795 gtk_box_pack_start (GTK_BOX (vbox3), label2, FALSE, FALSE, 0);
6796 gtk_label_set_justify (GTK_LABEL (label2), GTK_JUSTIFY_LEFT);
6798 hpaned6 = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL);
6799 gtk_box_pack_start (GTK_BOX (vbox3), hpaned6, TRUE, TRUE, 0);
6801 vpaned3 = gtk_paned_new (GTK_ORIENTATION_VERTICAL);
6802 gtk_paned_pack1 (GTK_PANED (hpaned6), vpaned3, FALSE, TRUE);
6804 button19 = gtk_button_new_with_label ("button19");
6805 gtk_paned_pack1 (GTK_PANED (vpaned3), button19, FALSE, TRUE);
6807 button18 = gtk_button_new_with_label ("button18");
6808 gtk_paned_pack2 (GTK_PANED (vpaned3), button18, TRUE, TRUE);
6810 hbox3 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
6811 gtk_paned_pack2 (GTK_PANED (hpaned6), hbox3, TRUE, TRUE);
6813 vpaned4 = gtk_paned_new (GTK_ORIENTATION_VERTICAL);
6814 gtk_box_pack_start (GTK_BOX (hbox3), vpaned4, TRUE, TRUE, 0);
6816 button21 = gtk_button_new_with_label ("button21");
6817 gtk_paned_pack1 (GTK_PANED (vpaned4), button21, FALSE, TRUE);
6819 button20 = gtk_button_new_with_label ("button20");
6820 gtk_paned_pack2 (GTK_PANED (vpaned4), button20, TRUE, TRUE);
6822 vpaned5 = gtk_paned_new (GTK_ORIENTATION_VERTICAL);
6823 gtk_box_pack_start (GTK_BOX (hbox3), vpaned5, TRUE, TRUE, 0);
6825 button23 = gtk_button_new_with_label ("button23");
6826 gtk_paned_pack1 (GTK_PANED (vpaned5), button23, FALSE, TRUE);
6828 button22 = gtk_button_new_with_label ("button22");
6829 gtk_paned_pack2 (GTK_PANED (vpaned5), button22, TRUE, TRUE);
6831 vpaned6 = gtk_paned_new (GTK_ORIENTATION_VERTICAL);
6832 gtk_box_pack_start (GTK_BOX (hbox3), vpaned6, TRUE, TRUE, 0);
6834 button25 = gtk_button_new_with_label ("button25");
6835 gtk_paned_pack1 (GTK_PANED (vpaned6), button25, FALSE, TRUE);
6837 button24 = gtk_button_new_with_label ("button24");
6838 gtk_paned_pack2 (GTK_PANED (vpaned6), button24, TRUE, TRUE);
6844 create_paned_keyboard_navigation (GtkWidget *widget)
6846 static GtkWidget *window1 = NULL;
6847 static GtkWidget *window2 = NULL;
6848 static GtkWidget *window3 = NULL;
6849 static GtkWidget *window4 = NULL;
6852 (gtk_widget_get_screen (window1) != gtk_widget_get_screen (widget)))
6854 gtk_widget_destroy (window1);
6855 gtk_widget_destroy (window2);
6856 gtk_widget_destroy (window3);
6857 gtk_widget_destroy (window4);
6862 window1 = paned_keyboard_window1 (widget);
6863 g_signal_connect (window1, "destroy",
6864 G_CALLBACK (gtk_widget_destroyed),
6870 window2 = paned_keyboard_window2 (widget);
6871 g_signal_connect (window2, "destroy",
6872 G_CALLBACK (gtk_widget_destroyed),
6878 window3 = paned_keyboard_window3 (widget);
6879 g_signal_connect (window3, "destroy",
6880 G_CALLBACK (gtk_widget_destroyed),
6886 window4 = paned_keyboard_window4 (widget);
6887 g_signal_connect (window4, "destroy",
6888 G_CALLBACK (gtk_widget_destroyed),
6892 if (gtk_widget_get_visible (window1))
6893 gtk_widget_destroy (GTK_WIDGET (window1));
6895 gtk_widget_show_all (GTK_WIDGET (window1));
6897 if (gtk_widget_get_visible (window2))
6898 gtk_widget_destroy (GTK_WIDGET (window2));
6900 gtk_widget_show_all (GTK_WIDGET (window2));
6902 if (gtk_widget_get_visible (window3))
6903 gtk_widget_destroy (GTK_WIDGET (window3));
6905 gtk_widget_show_all (GTK_WIDGET (window3));
6907 if (gtk_widget_get_visible (window4))
6908 gtk_widget_destroy (GTK_WIDGET (window4));
6910 gtk_widget_show_all (GTK_WIDGET (window4));
6918 typedef struct _cursoroffset {gint x,y;} CursorOffset;
6921 shape_pressed (GtkWidget *widget, GdkEventButton *event)
6925 /* ignore double and triple click */
6926 if (event->type != GDK_BUTTON_PRESS)
6929 p = g_object_get_data (G_OBJECT (widget), "cursor_offset");
6930 p->x = (int) event->x;
6931 p->y = (int) event->y;
6933 gtk_grab_add (widget);
6934 gdk_device_grab (gdk_event_get_device ((GdkEvent*)event),
6935 gtk_widget_get_window (widget),
6938 GDK_BUTTON_RELEASE_MASK |
6939 GDK_BUTTON_MOTION_MASK |
6940 GDK_POINTER_MOTION_HINT_MASK,
6946 shape_released (GtkWidget *widget,
6947 GdkEventButton *event)
6949 gtk_grab_remove (widget);
6950 gdk_device_ungrab (gdk_event_get_device ((GdkEvent*)event), event->time);
6954 shape_motion (GtkWidget *widget,
6955 GdkEventMotion *event)
6959 GdkModifierType mask;
6961 p = g_object_get_data (G_OBJECT (widget), "cursor_offset");
6964 * Can't use event->x / event->y here
6965 * because I need absolute coordinates.
6967 gdk_window_get_pointer (NULL, &xp, &yp, &mask);
6968 gtk_window_move (GTK_WINDOW (widget), xp - p->x, yp - p->y);
6972 shape_create_icon (GdkScreen *screen,
6983 CursorOffset* icon_pos;
6984 cairo_surface_t *mask;
6985 cairo_region_t *mask_region;
6990 * GDK_WINDOW_TOPLEVEL works also, giving you a title border
6992 window = gtk_window_new (window_type);
6993 gtk_window_set_screen (GTK_WINDOW (window), screen);
6995 fixed = gtk_fixed_new ();
6996 gtk_widget_set_size_request (fixed, 100, 100);
6997 gtk_container_add (GTK_CONTAINER (window), fixed);
6998 gtk_widget_show (fixed);
7000 gtk_widget_set_events (window,
7001 gtk_widget_get_events (window) |
7002 GDK_BUTTON_MOTION_MASK |
7003 GDK_POINTER_MOTION_HINT_MASK |
7004 GDK_BUTTON_PRESS_MASK);
7006 gtk_widget_realize (window);
7008 pixbuf = gdk_pixbuf_new_from_file (xpm_file, NULL);
7009 g_assert (pixbuf); /* FIXME: error handling */
7011 mask = cairo_image_surface_create (CAIRO_FORMAT_A1,
7012 gdk_pixbuf_get_width (pixbuf),
7013 gdk_pixbuf_get_height (pixbuf));
7014 cr = cairo_create (mask);
7015 gdk_cairo_set_source_pixbuf (cr, pixbuf, 0, 0);
7019 mask_region = gdk_cairo_region_create_from_surface (mask);
7021 cairo_region_translate (mask_region, px, py);
7023 image = gtk_image_new_from_pixbuf (pixbuf);
7024 gtk_fixed_put (GTK_FIXED (fixed), image, px,py);
7025 gtk_widget_show (image);
7027 gtk_widget_shape_combine_region (window, mask_region);
7029 cairo_region_destroy (mask_region);
7030 cairo_surface_destroy (mask);
7031 g_object_unref (pixbuf);
7033 g_signal_connect (window, "button_press_event",
7034 G_CALLBACK (shape_pressed), NULL);
7035 g_signal_connect (window, "button_release_event",
7036 G_CALLBACK (shape_released), NULL);
7037 g_signal_connect (window, "motion_notify_event",
7038 G_CALLBACK (shape_motion), NULL);
7040 icon_pos = g_new (CursorOffset, 1);
7041 g_object_set_data (G_OBJECT (window), "cursor_offset", icon_pos);
7043 gtk_window_move (GTK_WINDOW (window), x, y);
7044 gtk_widget_show (window);
7050 create_shapes (GtkWidget *widget)
7052 /* Variables used by the Drag/Drop and Shape Window demos */
7053 static GtkWidget *modeller = NULL;
7054 static GtkWidget *sheets = NULL;
7055 static GtkWidget *rings = NULL;
7056 static GtkWidget *with_region = NULL;
7057 GdkScreen *screen = gtk_widget_get_screen (widget);
7059 if (!(file_exists ("Modeller.xpm") &&
7060 file_exists ("FilesQueue.xpm") &&
7061 file_exists ("3DRings.xpm")))
7067 modeller = shape_create_icon (screen, "Modeller.xpm",
7068 440, 140, 0,0, GTK_WINDOW_POPUP);
7070 g_signal_connect (modeller, "destroy",
7071 G_CALLBACK (gtk_widget_destroyed),
7075 gtk_widget_destroy (modeller);
7079 sheets = shape_create_icon (screen, "FilesQueue.xpm",
7080 580, 170, 0,0, GTK_WINDOW_POPUP);
7082 g_signal_connect (sheets, "destroy",
7083 G_CALLBACK (gtk_widget_destroyed),
7088 gtk_widget_destroy (sheets);
7092 rings = shape_create_icon (screen, "3DRings.xpm",
7093 460, 270, 25,25, GTK_WINDOW_TOPLEVEL);
7095 g_signal_connect (rings, "destroy",
7096 G_CALLBACK (gtk_widget_destroyed),
7100 gtk_widget_destroy (rings);
7104 cairo_region_t *region;
7107 with_region = shape_create_icon (screen, "3DRings.xpm",
7108 460, 270, 25,25, GTK_WINDOW_TOPLEVEL);
7110 gtk_window_set_decorated (GTK_WINDOW (with_region), FALSE);
7112 g_signal_connect (with_region, "destroy",
7113 G_CALLBACK (gtk_widget_destroyed),
7116 /* reset shape from mask to a region */
7119 region = cairo_region_create ();
7131 cairo_region_union_rectangle (region, &rect);
7139 gdk_window_shape_combine_region (gtk_widget_get_window (with_region),
7144 gtk_widget_destroy (with_region);
7152 create_wmhints (GtkWidget *widget)
7154 static GtkWidget *window = NULL;
7156 GtkWidget *separator;
7160 GdkWindow *gdk_window;
7166 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
7168 gtk_window_set_screen (GTK_WINDOW (window),
7169 gtk_widget_get_screen (widget));
7171 g_signal_connect (window, "destroy",
7172 G_CALLBACK (gtk_widget_destroyed),
7175 gtk_window_set_title (GTK_WINDOW (window), "WM Hints");
7176 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
7178 gtk_widget_realize (window);
7180 gdk_window = gtk_widget_get_window (window);
7182 pixbuf = gdk_pixbuf_new_from_xpm_data ((const char **) openfile);
7183 list = g_list_prepend (NULL, pixbuf);
7185 gdk_window_set_icon_list (gdk_window, list);
7188 g_object_unref (pixbuf);
7190 gdk_window_set_icon_name (gdk_window, "WMHints Test Icon");
7192 gdk_window_set_decorations (gdk_window, GDK_DECOR_ALL | GDK_DECOR_MENU);
7193 gdk_window_set_functions (gdk_window, GDK_FUNC_ALL | GDK_FUNC_RESIZE);
7195 box1 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
7196 gtk_container_add (GTK_CONTAINER (window), box1);
7197 gtk_widget_show (box1);
7199 label = gtk_label_new ("Try iconizing me!");
7200 gtk_widget_set_size_request (label, 150, 50);
7201 gtk_box_pack_start (GTK_BOX (box1), label, TRUE, TRUE, 0);
7202 gtk_widget_show (label);
7205 separator = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
7206 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
7207 gtk_widget_show (separator);
7210 box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10);
7211 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
7212 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
7213 gtk_widget_show (box2);
7216 button = gtk_button_new_with_label ("close");
7218 g_signal_connect_swapped (button, "clicked",
7219 G_CALLBACK (gtk_widget_destroy),
7222 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
7223 gtk_widget_set_can_default (button, TRUE);
7224 gtk_widget_grab_default (button);
7225 gtk_widget_show (button);
7228 if (!gtk_widget_get_visible (window))
7229 gtk_widget_show (window);
7231 gtk_widget_destroy (window);
7236 * Window state tracking
7240 window_state_callback (GtkWidget *widget,
7241 GdkEventWindowState *event,
7244 GtkWidget *label = data;
7247 msg = g_strconcat (gtk_window_get_title (GTK_WINDOW (widget)), ": ",
7248 (event->new_window_state & GDK_WINDOW_STATE_WITHDRAWN) ?
7249 "withdrawn" : "not withdrawn", ", ",
7250 (event->new_window_state & GDK_WINDOW_STATE_ICONIFIED) ?
7251 "iconified" : "not iconified", ", ",
7252 (event->new_window_state & GDK_WINDOW_STATE_STICKY) ?
7253 "sticky" : "not sticky", ", ",
7254 (event->new_window_state & GDK_WINDOW_STATE_MAXIMIZED) ?
7255 "maximized" : "not maximized", ", ",
7256 (event->new_window_state & GDK_WINDOW_STATE_FULLSCREEN) ?
7257 "fullscreen" : "not fullscreen",
7258 (event->new_window_state & GDK_WINDOW_STATE_ABOVE) ?
7259 "above" : "not above", ", ",
7260 (event->new_window_state & GDK_WINDOW_STATE_BELOW) ?
7261 "below" : "not below", ", ",
7264 gtk_label_set_text (GTK_LABEL (label), msg);
7272 tracking_label (GtkWidget *window)
7278 hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 5);
7280 g_signal_connect_object (hbox,
7282 G_CALLBACK (gtk_widget_destroy),
7286 label = gtk_label_new ("<no window state events received>");
7287 gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
7288 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
7290 g_signal_connect (window,
7291 "window_state_event",
7292 G_CALLBACK (window_state_callback),
7295 button = gtk_button_new_with_label ("Deiconify");
7296 g_signal_connect_object (button,
7298 G_CALLBACK (gtk_window_deiconify),
7301 gtk_box_pack_end (GTK_BOX (hbox), button, FALSE, FALSE, 0);
7303 button = gtk_button_new_with_label ("Iconify");
7304 g_signal_connect_object (button,
7306 G_CALLBACK (gtk_window_iconify),
7309 gtk_box_pack_end (GTK_BOX (hbox), button, FALSE, FALSE, 0);
7311 button = gtk_button_new_with_label ("Fullscreen");
7312 g_signal_connect_object (button,
7314 G_CALLBACK (gtk_window_fullscreen),
7317 gtk_box_pack_end (GTK_BOX (hbox), button, FALSE, FALSE, 0);
7319 button = gtk_button_new_with_label ("Unfullscreen");
7320 g_signal_connect_object (button,
7322 G_CALLBACK (gtk_window_unfullscreen),
7325 gtk_box_pack_end (GTK_BOX (hbox), button, FALSE, FALSE, 0);
7327 button = gtk_button_new_with_label ("Present");
7328 g_signal_connect_object (button,
7330 G_CALLBACK (gtk_window_present),
7333 gtk_box_pack_end (GTK_BOX (hbox), button, FALSE, FALSE, 0);
7335 button = gtk_button_new_with_label ("Show");
7336 g_signal_connect_object (button,
7338 G_CALLBACK (gtk_widget_show),
7341 gtk_box_pack_end (GTK_BOX (hbox), button, FALSE, FALSE, 0);
7343 gtk_widget_show_all (hbox);
7349 keep_window_above (GtkToggleButton *togglebutton, gpointer data)
7351 GtkWidget *button = g_object_get_data (G_OBJECT (togglebutton), "radio");
7353 gtk_window_set_keep_above (GTK_WINDOW (data),
7354 gtk_toggle_button_get_active (togglebutton));
7356 if (gtk_toggle_button_get_active (togglebutton))
7357 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), FALSE);
7361 keep_window_below (GtkToggleButton *togglebutton, gpointer data)
7363 GtkWidget *button = g_object_get_data (G_OBJECT (togglebutton), "radio");
7365 gtk_window_set_keep_below (GTK_WINDOW (data),
7366 gtk_toggle_button_get_active (togglebutton));
7368 if (gtk_toggle_button_get_active (togglebutton))
7369 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), FALSE);
7374 get_state_controls (GtkWidget *window)
7378 GtkWidget *button_above;
7379 GtkWidget *button_below;
7381 vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
7383 button = gtk_button_new_with_label ("Stick");
7384 g_signal_connect_object (button,
7386 G_CALLBACK (gtk_window_stick),
7389 gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
7391 button = gtk_button_new_with_label ("Unstick");
7392 g_signal_connect_object (button,
7394 G_CALLBACK (gtk_window_unstick),
7397 gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
7399 button = gtk_button_new_with_label ("Maximize");
7400 g_signal_connect_object (button,
7402 G_CALLBACK (gtk_window_maximize),
7405 gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
7407 button = gtk_button_new_with_label ("Unmaximize");
7408 g_signal_connect_object (button,
7410 G_CALLBACK (gtk_window_unmaximize),
7413 gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
7415 button = gtk_button_new_with_label ("Iconify");
7416 g_signal_connect_object (button,
7418 G_CALLBACK (gtk_window_iconify),
7421 gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
7423 button = gtk_button_new_with_label ("Fullscreen");
7424 g_signal_connect_object (button,
7426 G_CALLBACK (gtk_window_fullscreen),
7429 gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
7431 button = gtk_button_new_with_label ("Unfullscreen");
7432 g_signal_connect_object (button,
7434 G_CALLBACK (gtk_window_unfullscreen),
7437 gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
7439 button_above = gtk_toggle_button_new_with_label ("Keep above");
7440 g_signal_connect (button_above,
7442 G_CALLBACK (keep_window_above),
7444 gtk_box_pack_start (GTK_BOX (vbox), button_above, FALSE, FALSE, 0);
7446 button_below = gtk_toggle_button_new_with_label ("Keep below");
7447 g_signal_connect (button_below,
7449 G_CALLBACK (keep_window_below),
7451 gtk_box_pack_start (GTK_BOX (vbox), button_below, FALSE, FALSE, 0);
7453 g_object_set_data (G_OBJECT (button_above), "radio", button_below);
7454 g_object_set_data (G_OBJECT (button_below), "radio", button_above);
7456 button = gtk_button_new_with_label ("Hide (withdraw)");
7457 g_signal_connect_object (button,
7459 G_CALLBACK (gtk_widget_hide),
7462 gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
7464 gtk_widget_show_all (vbox);
7470 create_window_states (GtkWidget *widget)
7472 static GtkWidget *window = NULL;
7475 GtkWidget *iconified;
7477 GtkWidget *controls;
7481 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
7482 gtk_window_set_screen (GTK_WINDOW (window),
7483 gtk_widget_get_screen (widget));
7485 g_signal_connect (window, "destroy",
7486 G_CALLBACK (gtk_widget_destroyed),
7489 gtk_window_set_title (GTK_WINDOW (window), "Window states");
7491 box1 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
7492 gtk_container_add (GTK_CONTAINER (window), box1);
7494 iconified = gtk_window_new (GTK_WINDOW_TOPLEVEL);
7496 gtk_window_set_screen (GTK_WINDOW (iconified),
7497 gtk_widget_get_screen (widget));
7499 g_signal_connect_object (iconified, "destroy",
7500 G_CALLBACK (gtk_widget_destroy),
7503 gtk_window_iconify (GTK_WINDOW (iconified));
7504 gtk_window_set_title (GTK_WINDOW (iconified), "Iconified initially");
7505 controls = get_state_controls (iconified);
7506 gtk_container_add (GTK_CONTAINER (iconified), controls);
7508 normal = gtk_window_new (GTK_WINDOW_TOPLEVEL);
7510 gtk_window_set_screen (GTK_WINDOW (normal),
7511 gtk_widget_get_screen (widget));
7513 g_signal_connect_object (normal, "destroy",
7514 G_CALLBACK (gtk_widget_destroy),
7518 gtk_window_set_title (GTK_WINDOW (normal), "Deiconified initially");
7519 controls = get_state_controls (normal);
7520 gtk_container_add (GTK_CONTAINER (normal), controls);
7522 label = tracking_label (iconified);
7523 gtk_container_add (GTK_CONTAINER (box1), label);
7525 label = tracking_label (normal);
7526 gtk_container_add (GTK_CONTAINER (box1), label);
7528 gtk_widget_show_all (iconified);
7529 gtk_widget_show_all (normal);
7530 gtk_widget_show_all (box1);
7533 if (!gtk_widget_get_visible (window))
7534 gtk_widget_show (window);
7536 gtk_widget_destroy (window);
7544 configure_event_callback (GtkWidget *widget,
7545 GdkEventConfigure *event,
7548 GtkWidget *label = data;
7552 gtk_window_get_position (GTK_WINDOW (widget), &x, &y);
7554 msg = g_strdup_printf ("event: %d,%d %d x %d\n"
7556 event->x, event->y, event->width, event->height,
7559 gtk_label_set_text (GTK_LABEL (label), msg);
7567 get_ints (GtkWidget *window,
7574 spin1 = g_object_get_data (G_OBJECT (window), "spin1");
7575 spin2 = g_object_get_data (G_OBJECT (window), "spin2");
7577 *a = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (spin1));
7578 *b = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (spin2));
7582 set_size_callback (GtkWidget *widget,
7587 get_ints (data, &w, &h);
7589 gtk_window_resize (GTK_WINDOW (g_object_get_data (data, "target")), w, h);
7593 unset_default_size_callback (GtkWidget *widget,
7596 gtk_window_set_default_size (g_object_get_data (data, "target"),
7601 set_default_size_callback (GtkWidget *widget,
7606 get_ints (data, &w, &h);
7608 gtk_window_set_default_size (g_object_get_data (data, "target"),
7613 unset_size_request_callback (GtkWidget *widget,
7616 gtk_widget_set_size_request (g_object_get_data (data, "target"),
7621 set_size_request_callback (GtkWidget *widget,
7626 get_ints (data, &w, &h);
7628 gtk_widget_set_size_request (g_object_get_data (data, "target"),
7633 set_location_callback (GtkWidget *widget,
7638 get_ints (data, &x, &y);
7640 gtk_window_move (g_object_get_data (data, "target"), x, y);
7644 move_to_position_callback (GtkWidget *widget,
7650 window = g_object_get_data (data, "target");
7652 gtk_window_get_position (window, &x, &y);
7654 gtk_window_move (window, x, y);
7658 set_geometry_callback (GtkWidget *entry,
7664 target = GTK_WINDOW (g_object_get_data (G_OBJECT (data), "target"));
7666 text = gtk_editable_get_chars (GTK_EDITABLE (entry), 0, -1);
7668 if (!gtk_window_parse_geometry (target, text))
7669 g_print ("Bad geometry string '%s'\n", text);
7675 resizable_callback (GtkWidget *widget,
7678 g_object_set (g_object_get_data (data, "target"),
7679 "resizable", gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget)),
7684 gravity_selected (GtkWidget *widget,
7687 gtk_window_set_gravity (GTK_WINDOW (g_object_get_data (data, "target")),
7688 gtk_combo_box_get_active (GTK_COMBO_BOX (widget)) + GDK_GRAVITY_NORTH_WEST);
7692 pos_selected (GtkWidget *widget,
7695 gtk_window_set_position (GTK_WINDOW (g_object_get_data (data, "target")),
7696 gtk_combo_box_get_active (GTK_COMBO_BOX (widget)) + GTK_WIN_POS_NONE);
7700 move_gravity_window_to_current_position (GtkWidget *widget,
7706 window = GTK_WINDOW (data);
7708 gtk_window_get_position (window, &x, &y);
7710 gtk_window_move (window, x, y);
7714 get_screen_corner (GtkWindow *window,
7719 GdkScreen * screen = gtk_window_get_screen (window);
7721 gtk_window_get_size (GTK_WINDOW (window), &w, &h);
7723 switch (gtk_window_get_gravity (window))
7725 case GDK_GRAVITY_SOUTH_EAST:
7726 *x = gdk_screen_get_width (screen) - w;
7727 *y = gdk_screen_get_height (screen) - h;
7730 case GDK_GRAVITY_NORTH_EAST:
7731 *x = gdk_screen_get_width (screen) - w;
7735 case GDK_GRAVITY_SOUTH_WEST:
7737 *y = gdk_screen_get_height (screen) - h;
7740 case GDK_GRAVITY_NORTH_WEST:
7745 case GDK_GRAVITY_SOUTH:
7746 *x = (gdk_screen_get_width (screen) - w) / 2;
7747 *y = gdk_screen_get_height (screen) - h;
7750 case GDK_GRAVITY_NORTH:
7751 *x = (gdk_screen_get_width (screen) - w) / 2;
7755 case GDK_GRAVITY_WEST:
7757 *y = (gdk_screen_get_height (screen) - h) / 2;
7760 case GDK_GRAVITY_EAST:
7761 *x = gdk_screen_get_width (screen) - w;
7762 *y = (gdk_screen_get_height (screen) - h) / 2;
7765 case GDK_GRAVITY_CENTER:
7766 *x = (gdk_screen_get_width (screen) - w) / 2;
7767 *y = (gdk_screen_get_height (screen) - h) / 2;
7770 case GDK_GRAVITY_STATIC:
7771 /* pick some random numbers */
7777 g_assert_not_reached ();
7783 move_gravity_window_to_starting_position (GtkWidget *widget,
7789 window = GTK_WINDOW (data);
7791 get_screen_corner (window,
7794 gtk_window_move (window, x, y);
7798 make_gravity_window (GtkWidget *destroy_with,
7807 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
7809 gtk_window_set_screen (GTK_WINDOW (window),
7810 gtk_widget_get_screen (destroy_with));
7812 vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
7813 gtk_widget_show (vbox);
7815 gtk_container_add (GTK_CONTAINER (window), vbox);
7816 gtk_window_set_title (GTK_WINDOW (window), title);
7817 gtk_window_set_gravity (GTK_WINDOW (window), gravity);
7819 g_signal_connect_object (destroy_with,
7821 G_CALLBACK (gtk_widget_destroy),
7826 button = gtk_button_new_with_mnemonic ("_Move to current position");
7828 g_signal_connect (button, "clicked",
7829 G_CALLBACK (move_gravity_window_to_current_position),
7832 gtk_container_add (GTK_CONTAINER (vbox), button);
7833 gtk_widget_show (button);
7835 button = gtk_button_new_with_mnemonic ("Move to _starting position");
7837 g_signal_connect (button, "clicked",
7838 G_CALLBACK (move_gravity_window_to_starting_position),
7841 gtk_container_add (GTK_CONTAINER (vbox), button);
7842 gtk_widget_show (button);
7844 /* Pretend this is the result of --geometry.
7845 * DO NOT COPY THIS CODE unless you are setting --geometry results,
7846 * and in that case you probably should just use gtk_window_parse_geometry().
7847 * AGAIN, DO NOT SET GDK_HINT_USER_POS! It violates the ICCCM unless
7848 * you are parsing --geometry or equivalent.
7850 gtk_window_set_geometry_hints (GTK_WINDOW (window),
7854 gtk_window_set_default_size (GTK_WINDOW (window),
7857 get_screen_corner (GTK_WINDOW (window), &x, &y);
7859 gtk_window_move (GTK_WINDOW (window),
7866 do_gravity_test (GtkWidget *widget,
7869 GtkWidget *destroy_with = data;
7872 /* We put a window at each gravity point on the screen. */
7873 window = make_gravity_window (destroy_with, GDK_GRAVITY_NORTH_WEST,
7875 gtk_widget_show (window);
7877 window = make_gravity_window (destroy_with, GDK_GRAVITY_SOUTH_EAST,
7879 gtk_widget_show (window);
7881 window = make_gravity_window (destroy_with, GDK_GRAVITY_NORTH_EAST,
7883 gtk_widget_show (window);
7885 window = make_gravity_window (destroy_with, GDK_GRAVITY_SOUTH_WEST,
7887 gtk_widget_show (window);
7889 window = make_gravity_window (destroy_with, GDK_GRAVITY_SOUTH,
7891 gtk_widget_show (window);
7893 window = make_gravity_window (destroy_with, GDK_GRAVITY_NORTH,
7895 gtk_widget_show (window);
7898 window = make_gravity_window (destroy_with, GDK_GRAVITY_WEST,
7900 gtk_widget_show (window);
7903 window = make_gravity_window (destroy_with, GDK_GRAVITY_EAST,
7905 gtk_widget_show (window);
7907 window = make_gravity_window (destroy_with, GDK_GRAVITY_CENTER,
7909 gtk_widget_show (window);
7911 window = make_gravity_window (destroy_with, GDK_GRAVITY_STATIC,
7913 gtk_widget_show (window);
7917 window_controls (GtkWidget *window)
7919 GtkWidget *control_window;
7924 GtkAdjustment *adjustment;
7929 control_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
7931 gtk_window_set_screen (GTK_WINDOW (control_window),
7932 gtk_widget_get_screen (window));
7934 gtk_window_set_title (GTK_WINDOW (control_window), "Size controls");
7936 g_object_set_data (G_OBJECT (control_window),
7940 g_signal_connect_object (control_window,
7942 G_CALLBACK (gtk_widget_destroy),
7946 vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
7948 gtk_container_add (GTK_CONTAINER (control_window), vbox);
7950 label = gtk_label_new ("<no configure events>");
7951 gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
7953 g_signal_connect (window,
7955 G_CALLBACK (configure_event_callback),
7958 adjustment = gtk_adjustment_new (10.0, -2000.0, 2000.0, 1.0, 5.0, 0.0);
7959 spin = gtk_spin_button_new (adjustment, 0, 0);
7961 gtk_box_pack_start (GTK_BOX (vbox), spin, FALSE, FALSE, 0);
7963 g_object_set_data (G_OBJECT (control_window), "spin1", spin);
7965 adjustment = gtk_adjustment_new (10.0, -2000.0, 2000.0, 1.0, 5.0, 0.0);
7966 spin = gtk_spin_button_new (adjustment, 0, 0);
7968 gtk_box_pack_start (GTK_BOX (vbox), spin, FALSE, FALSE, 0);
7970 g_object_set_data (G_OBJECT (control_window), "spin2", spin);
7972 entry = gtk_entry_new ();
7973 gtk_box_pack_start (GTK_BOX (vbox), entry, FALSE, FALSE, 0);
7975 g_signal_connect (entry, "changed",
7976 G_CALLBACK (set_geometry_callback),
7979 button = gtk_button_new_with_label ("Show gravity test windows");
7980 g_signal_connect_swapped (button,
7982 G_CALLBACK (do_gravity_test),
7984 gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
7986 button = gtk_button_new_with_label ("Reshow with initial size");
7987 g_signal_connect_object (button,
7989 G_CALLBACK (gtk_window_reshow_with_initial_size),
7992 gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
7994 button = gtk_button_new_with_label ("Queue resize");
7995 g_signal_connect_object (button,
7997 G_CALLBACK (gtk_widget_queue_resize),
8000 gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
8002 button = gtk_button_new_with_label ("Resize");
8003 g_signal_connect (button,
8005 G_CALLBACK (set_size_callback),
8007 gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
8009 button = gtk_button_new_with_label ("Set default size");
8010 g_signal_connect (button,
8012 G_CALLBACK (set_default_size_callback),
8014 gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
8016 button = gtk_button_new_with_label ("Unset default size");
8017 g_signal_connect (button,
8019 G_CALLBACK (unset_default_size_callback),
8021 gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
8023 button = gtk_button_new_with_label ("Set size request");
8024 g_signal_connect (button,
8026 G_CALLBACK (set_size_request_callback),
8028 gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
8030 button = gtk_button_new_with_label ("Unset size request");
8031 g_signal_connect (button,
8033 G_CALLBACK (unset_size_request_callback),
8035 gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
8037 button = gtk_button_new_with_label ("Move");
8038 g_signal_connect (button,
8040 G_CALLBACK (set_location_callback),
8042 gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
8044 button = gtk_button_new_with_label ("Move to current position");
8045 g_signal_connect (button,
8047 G_CALLBACK (move_to_position_callback),
8049 gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
8051 button = gtk_check_button_new_with_label ("Allow resize");
8052 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
8053 g_signal_connect (button,
8055 G_CALLBACK (resizable_callback),
8057 gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
8059 button = gtk_button_new_with_mnemonic ("_Show");
8060 g_signal_connect_object (button,
8062 G_CALLBACK (gtk_widget_show),
8065 gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
8067 button = gtk_button_new_with_mnemonic ("_Hide");
8068 g_signal_connect_object (button,
8070 G_CALLBACK (gtk_widget_hide),
8073 gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
8075 om = gtk_combo_box_text_new ();
8079 static gchar *names[] = {
8080 "GDK_GRAVITY_NORTH_WEST",
8081 "GDK_GRAVITY_NORTH",
8082 "GDK_GRAVITY_NORTH_EAST",
8084 "GDK_GRAVITY_CENTER",
8086 "GDK_GRAVITY_SOUTH_WEST",
8087 "GDK_GRAVITY_SOUTH",
8088 "GDK_GRAVITY_SOUTH_EAST",
8089 "GDK_GRAVITY_STATIC",
8093 g_assert (names[i]);
8094 gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (om), names[i]);
8099 g_signal_connect (om,
8101 G_CALLBACK (gravity_selected),
8104 gtk_box_pack_end (GTK_BOX (vbox), om, FALSE, FALSE, 0);
8107 om = gtk_combo_box_text_new ();
8111 static gchar *names[] = {
8113 "GTK_WIN_POS_CENTER",
8114 "GTK_WIN_POS_MOUSE",
8115 "GTK_WIN_POS_CENTER_ALWAYS",
8116 "GTK_WIN_POS_CENTER_ON_PARENT",
8120 g_assert (names[i]);
8121 gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (om), names[i]);
8126 g_signal_connect (om,
8128 G_CALLBACK (pos_selected),
8131 gtk_box_pack_end (GTK_BOX (vbox), om, FALSE, FALSE, 0);
8133 gtk_widget_show_all (vbox);
8135 return control_window;
8139 create_window_sizing (GtkWidget *widget)
8141 static GtkWidget *window = NULL;
8142 static GtkWidget *target_window = NULL;
8148 target_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
8149 gtk_window_set_screen (GTK_WINDOW (target_window),
8150 gtk_widget_get_screen (widget));
8151 label = gtk_label_new (NULL);
8152 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");
8153 gtk_container_add (GTK_CONTAINER (target_window), label);
8154 gtk_widget_show (label);
8156 g_signal_connect (target_window, "destroy",
8157 G_CALLBACK (gtk_widget_destroyed),
8160 window = window_controls (target_window);
8162 g_signal_connect (window, "destroy",
8163 G_CALLBACK (gtk_widget_destroyed),
8166 gtk_window_set_title (GTK_WINDOW (target_window), "Window to size");
8169 /* don't show target window by default, we want to allow testing
8170 * of behavior on first show.
8173 if (!gtk_widget_get_visible (window))
8174 gtk_widget_show (window);
8176 gtk_widget_destroy (window);
8183 typedef struct _ProgressData {
8186 GtkWidget *block_spin;
8187 GtkWidget *x_align_spin;
8188 GtkWidget *y_align_spin;
8189 GtkWidget *step_spin;
8190 GtkWidget *act_blocks_spin;
8201 progress_timeout (gpointer data)
8203 ProgressData *pdata = data;
8207 if (pdata->activity)
8209 gtk_progress_bar_pulse (GTK_PROGRESS_BAR (pdata->pbar));
8211 text = g_strdup_printf ("%s", "???");
8215 new_val = gtk_progress_bar_get_fraction (GTK_PROGRESS_BAR (pdata->pbar)) + 0.01;
8218 gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR (pdata->pbar), new_val);
8220 text = g_strdup_printf ("%.0f%%", 100 * new_val);
8223 gtk_label_set_text (GTK_LABEL (pdata->label), text);
8230 destroy_progress (GtkWidget *widget,
8231 ProgressData **pdata)
8233 if ((*pdata)->timer)
8235 g_source_remove ((*pdata)->timer);
8236 (*pdata)->timer = 0;
8238 (*pdata)->window = NULL;
8244 progressbar_toggle_orientation (GtkWidget *widget, gpointer data)
8246 ProgressData *pdata;
8249 pdata = (ProgressData *) data;
8251 if (!gtk_widget_get_mapped (widget))
8254 i = gtk_combo_box_get_active (GTK_COMBO_BOX (widget));
8256 if (i == 0 || i == 1)
8257 gtk_orientable_set_orientation (GTK_ORIENTABLE (pdata->pbar), GTK_ORIENTATION_HORIZONTAL);
8259 gtk_orientable_set_orientation (GTK_ORIENTABLE (pdata->pbar), GTK_ORIENTATION_VERTICAL);
8261 if (i == 1 || i == 2)
8262 gtk_progress_bar_set_inverted (GTK_PROGRESS_BAR (pdata->pbar), TRUE);
8264 gtk_progress_bar_set_inverted (GTK_PROGRESS_BAR (pdata->pbar), FALSE);
8268 toggle_show_text (GtkWidget *widget, ProgressData *pdata)
8272 active = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget));
8273 gtk_progress_bar_set_show_text (GTK_PROGRESS_BAR (pdata->pbar), active);
8277 progressbar_toggle_ellipsize (GtkWidget *widget,
8280 ProgressData *pdata = data;
8281 if (gtk_widget_is_drawable (widget))
8283 gint i = gtk_combo_box_get_active (GTK_COMBO_BOX (widget));
8284 gtk_progress_bar_set_ellipsize (GTK_PROGRESS_BAR (pdata->pbar), i);
8289 toggle_activity_mode (GtkWidget *widget, ProgressData *pdata)
8291 pdata->activity = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget));
8295 toggle_running (GtkWidget *widget, ProgressData *pdata)
8297 if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget)))
8299 if (pdata->timer == 0)
8300 pdata->timer = g_timeout_add (100, (GSourceFunc)progress_timeout, pdata);
8304 if (pdata->timer != 0)
8306 g_source_remove (pdata->timer);
8313 entry_changed (GtkWidget *widget, ProgressData *pdata)
8315 gtk_progress_bar_set_text (GTK_PROGRESS_BAR (pdata->pbar),
8316 gtk_entry_get_text (GTK_ENTRY (pdata->entry)));
8320 create_progress_bar (GtkWidget *widget)
8322 GtkWidget *action_area, *content_area;
8332 static ProgressData *pdata = NULL;
8334 static gchar *items1[] =
8342 static char *ellipsize_items[] = {
8343 "None", // PANGO_ELLIPSIZE_NONE,
8344 "Start", // PANGO_ELLIPSIZE_START,
8345 "Middle", // PANGO_ELLIPSIZE_MIDDLE,
8346 "End", // PANGO_ELLIPSIZE_END
8350 pdata = g_new0 (ProgressData, 1);
8354 pdata->window = gtk_dialog_new ();
8356 gtk_window_set_screen (GTK_WINDOW (pdata->window),
8357 gtk_widget_get_screen (widget));
8359 gtk_window_set_resizable (GTK_WINDOW (pdata->window), TRUE);
8361 g_signal_connect (pdata->window, "destroy",
8362 G_CALLBACK (destroy_progress),
8366 content_area = gtk_dialog_get_content_area (GTK_DIALOG (pdata->window));
8367 action_area = gtk_dialog_get_action_area (GTK_DIALOG (pdata->window));
8369 gtk_window_set_title (GTK_WINDOW (pdata->window), "GtkProgressBar");
8370 gtk_container_set_border_width (GTK_CONTAINER (pdata->window), 0);
8372 vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
8373 gtk_container_set_border_width (GTK_CONTAINER (vbox), 10);
8374 gtk_box_pack_start (GTK_BOX (content_area), vbox, FALSE, TRUE, 0);
8376 frame = gtk_frame_new ("Progress");
8377 gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, TRUE, 0);
8379 vbox2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
8380 gtk_container_add (GTK_CONTAINER (frame), vbox2);
8382 align = gtk_alignment_new (0.5, 0.5, 0, 0);
8383 gtk_box_pack_start (GTK_BOX (vbox2), align, FALSE, FALSE, 5);
8385 pdata->pbar = gtk_progress_bar_new ();
8386 gtk_progress_bar_set_ellipsize (GTK_PROGRESS_BAR (pdata->pbar),
8387 PANGO_ELLIPSIZE_MIDDLE);
8389 gtk_container_add (GTK_CONTAINER (align), pdata->pbar);
8391 align = gtk_alignment_new (0.5, 0.5, 0, 0);
8392 gtk_box_pack_start (GTK_BOX (vbox2), align, FALSE, FALSE, 5);
8394 hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 5);
8395 gtk_container_add (GTK_CONTAINER (align), hbox);
8396 label = gtk_label_new ("Label updated by user :");
8397 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
8398 pdata->label = gtk_label_new ("");
8399 gtk_box_pack_start (GTK_BOX (hbox), pdata->label, FALSE, TRUE, 0);
8401 frame = gtk_frame_new ("Options");
8402 gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, TRUE, 0);
8404 vbox2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
8405 gtk_container_add (GTK_CONTAINER (frame), vbox2);
8407 tab = gtk_table_new (7, 2, FALSE);
8408 gtk_box_pack_start (GTK_BOX (vbox2), tab, FALSE, TRUE, 0);
8410 label = gtk_label_new ("Orientation :");
8411 gtk_table_attach (GTK_TABLE (tab), label, 0, 1, 0, 1,
8412 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
8414 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
8416 pdata->omenu1 = build_option_menu (items1, 4, 0,
8417 progressbar_toggle_orientation,
8419 hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
8420 gtk_table_attach (GTK_TABLE (tab), hbox, 1, 2, 0, 1,
8421 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
8423 gtk_box_pack_start (GTK_BOX (hbox), pdata->omenu1, TRUE, TRUE, 0);
8425 check = gtk_check_button_new_with_label ("Running");
8426 g_signal_connect (check, "toggled",
8427 G_CALLBACK (toggle_running),
8429 gtk_table_attach (GTK_TABLE (tab), check, 0, 2, 1, 2,
8430 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
8432 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check), TRUE);
8434 check = gtk_check_button_new_with_label ("Show text");
8435 g_signal_connect (check, "clicked",
8436 G_CALLBACK (toggle_show_text),
8438 gtk_table_attach (GTK_TABLE (tab), check, 0, 1, 2, 3,
8439 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
8442 hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
8443 gtk_table_attach (GTK_TABLE (tab), hbox, 1, 2, 2, 3,
8444 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
8447 label = gtk_label_new ("Text: ");
8448 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
8450 pdata->entry = gtk_entry_new ();
8451 g_signal_connect (pdata->entry, "changed",
8452 G_CALLBACK (entry_changed),
8454 gtk_box_pack_start (GTK_BOX (hbox), pdata->entry, TRUE, TRUE, 0);
8455 gtk_widget_set_size_request (pdata->entry, 100, -1);
8457 label = gtk_label_new ("Ellipsize text :");
8458 gtk_table_attach (GTK_TABLE (tab), label, 0, 1, 10, 11,
8459 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
8461 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
8462 pdata->elmenu = build_option_menu (ellipsize_items,
8463 sizeof (ellipsize_items) / sizeof (ellipsize_items[0]),
8464 2, // PANGO_ELLIPSIZE_MIDDLE
8465 progressbar_toggle_ellipsize,
8467 hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
8468 gtk_table_attach (GTK_TABLE (tab), hbox, 1, 2, 10, 11,
8469 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
8471 gtk_box_pack_start (GTK_BOX (hbox), pdata->elmenu, TRUE, TRUE, 0);
8473 check = gtk_check_button_new_with_label ("Activity mode");
8474 g_signal_connect (check, "clicked",
8475 G_CALLBACK (toggle_activity_mode), pdata);
8476 gtk_table_attach (GTK_TABLE (tab), check, 0, 1, 15, 16,
8477 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
8480 button = gtk_button_new_with_label ("close");
8481 g_signal_connect_swapped (button, "clicked",
8482 G_CALLBACK (gtk_widget_destroy),
8484 gtk_widget_set_can_default (button, TRUE);
8485 gtk_box_pack_start (GTK_BOX (action_area), button, TRUE, TRUE, 0);
8486 gtk_widget_grab_default (button);
8489 if (!gtk_widget_get_visible (pdata->window))
8490 gtk_widget_show_all (pdata->window);
8492 gtk_widget_destroy (pdata->window);
8504 GtkWidget *res_widget;
8508 find_widget (GtkWidget *widget, FindWidgetData *data)
8510 GtkAllocation new_allocation;
8514 gtk_widget_get_allocation (widget, &new_allocation);
8516 if (data->found || !gtk_widget_get_mapped (widget))
8519 /* Note that in the following code, we only count the
8520 * position as being inside a WINDOW widget if it is inside
8521 * widget->window; points that are outside of widget->window
8522 * but within the allocation are not counted. This is consistent
8523 * with the way we highlight drag targets.
8525 if (gtk_widget_get_has_window (widget))
8527 new_allocation.x = 0;
8528 new_allocation.y = 0;
8531 if (gtk_widget_get_parent (widget) && !data->first)
8533 GdkWindow *window = gtk_widget_get_window (widget);
8534 while (window != gtk_widget_get_window (gtk_widget_get_parent (widget)))
8536 gint tx, ty, twidth, theight;
8538 twidth = gdk_window_get_width (window);
8539 theight = gdk_window_get_height (window);
8541 if (new_allocation.x < 0)
8543 new_allocation.width += new_allocation.x;
8544 new_allocation.x = 0;
8546 if (new_allocation.y < 0)
8548 new_allocation.height += new_allocation.y;
8549 new_allocation.y = 0;
8551 if (new_allocation.x + new_allocation.width > twidth)
8552 new_allocation.width = twidth - new_allocation.x;
8553 if (new_allocation.y + new_allocation.height > theight)
8554 new_allocation.height = theight - new_allocation.y;
8556 gdk_window_get_position (window, &tx, &ty);
8557 new_allocation.x += tx;
8559 new_allocation.y += ty;
8562 window = gdk_window_get_parent (window);
8566 if ((data->x >= new_allocation.x) && (data->y >= new_allocation.y) &&
8567 (data->x < new_allocation.x + new_allocation.width) &&
8568 (data->y < new_allocation.y + new_allocation.height))
8570 /* First, check if the drag is in a valid drop site in
8571 * one of our children
8573 if (GTK_IS_CONTAINER (widget))
8575 FindWidgetData new_data = *data;
8577 new_data.x -= x_offset;
8578 new_data.y -= y_offset;
8579 new_data.found = FALSE;
8580 new_data.first = FALSE;
8582 gtk_container_forall (GTK_CONTAINER (widget),
8583 (GtkCallback)find_widget,
8586 data->found = new_data.found;
8588 data->res_widget = new_data.res_widget;
8591 /* If not, and this widget is registered as a drop site, check to
8592 * emit "drag_motion" to check if we are actually in
8598 data->res_widget = widget;
8604 find_widget_at_pointer (GdkDevice *device)
8606 GtkWidget *widget = NULL;
8607 GdkWindow *pointer_window;
8609 FindWidgetData data;
8611 pointer_window = gdk_device_get_window_at_position (device, NULL, NULL);
8615 gpointer widget_ptr;
8617 gdk_window_get_user_data (pointer_window, &widget_ptr);
8618 widget = widget_ptr;
8623 gdk_window_get_pointer (gtk_widget_get_window (widget),
8631 find_widget (widget, &data);
8633 return data.res_widget;
8639 struct PropertiesData {
8647 destroy_properties (GtkWidget *widget,
8648 struct PropertiesData *data)
8652 *data->window = NULL;
8653 data->window = NULL;
8658 g_object_unref (data->cursor);
8659 data->cursor = NULL;
8664 g_signal_handler_disconnect (widget, data->handler);
8672 property_query_event (GtkWidget *widget,
8674 struct PropertiesData *data)
8676 GtkWidget *res_widget = NULL;
8678 if (!data->in_query)
8681 if (event->type == GDK_BUTTON_RELEASE)
8683 gtk_grab_remove (widget);
8684 gdk_device_ungrab (gdk_event_get_device (event), GDK_CURRENT_TIME);
8686 res_widget = find_widget_at_pointer (gdk_event_get_device (event));
8689 g_object_set_data (G_OBJECT (res_widget), "prop-editor-screen",
8690 gtk_widget_get_screen (widget));
8691 create_prop_editor (G_OBJECT (res_widget), 0);
8694 data->in_query = FALSE;
8701 query_properties (GtkButton *button,
8702 struct PropertiesData *data)
8704 GtkWidget *widget = GTK_WIDGET (button);
8705 GdkDisplay *display;
8706 GdkDeviceManager *device_manager;
8709 g_signal_connect (button, "event",
8710 G_CALLBACK (property_query_event), data);
8712 display = gtk_widget_get_display (widget);
8715 data->cursor = gdk_cursor_new_for_display (display, GDK_TARGET);
8717 device_manager = gdk_display_get_device_manager (display);
8718 device = gdk_device_manager_get_client_pointer (device_manager);
8719 gdk_device_grab (device,
8720 gtk_widget_get_window (widget),
8723 GDK_BUTTON_RELEASE_MASK,
8726 gtk_grab_add (widget);
8728 data->in_query = TRUE;
8732 create_properties (GtkWidget *widget)
8734 static GtkWidget *window = NULL;
8738 struct PropertiesData *data;
8740 data = g_new (struct PropertiesData, 1);
8741 data->window = &window;
8742 data->in_query = FALSE;
8743 data->cursor = NULL;
8748 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
8750 gtk_window_set_screen (GTK_WINDOW (window),
8751 gtk_widget_get_screen (widget));
8753 data->handler = g_signal_connect (window, "destroy",
8754 G_CALLBACK (destroy_properties),
8757 gtk_window_set_title (GTK_WINDOW (window), "test properties");
8758 gtk_container_set_border_width (GTK_CONTAINER (window), 10);
8760 vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 1);
8761 gtk_container_add (GTK_CONTAINER (window), vbox);
8763 label = gtk_label_new ("This is just a dumb test to test properties.\nIf you need a generic module, get GLE.");
8764 gtk_box_pack_start (GTK_BOX (vbox), label, TRUE, TRUE, 0);
8766 button = gtk_button_new_with_label ("Query properties");
8767 gtk_box_pack_start (GTK_BOX (vbox), button, TRUE, TRUE, 0);
8768 g_signal_connect (button, "clicked",
8769 G_CALLBACK (query_properties),
8773 if (!gtk_widget_get_visible (window))
8774 gtk_widget_show_all (window);
8776 gtk_widget_destroy (window);
8780 struct SnapshotData {
8781 GtkWidget *toplevel_button;
8785 gboolean is_toplevel;
8790 destroy_snapshot_data (GtkWidget *widget,
8791 struct SnapshotData *data)
8794 *data->window = NULL;
8798 g_object_unref (data->cursor);
8799 data->cursor = NULL;
8804 g_signal_handler_disconnect (widget, data->handler);
8812 snapshot_widget_event (GtkWidget *widget,
8814 struct SnapshotData *data)
8816 GtkWidget *res_widget = NULL;
8818 if (!data->in_query)
8821 if (event->type == GDK_BUTTON_RELEASE)
8823 gtk_grab_remove (widget);
8824 gdk_device_ungrab (gdk_event_get_device (event),
8827 res_widget = find_widget_at_pointer (gdk_event_get_device (event));
8828 if (data->is_toplevel && res_widget)
8829 res_widget = gtk_widget_get_toplevel (res_widget);
8832 cairo_surface_t *surface;
8833 GtkWidget *window, *image;
8838 width = gtk_widget_get_allocated_width (res_widget);
8839 height = gtk_widget_get_allocated_height (res_widget);
8841 surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, width, height);
8843 cr = cairo_create (surface);
8844 gtk_widget_draw (res_widget, cr);
8847 pixbuf = gdk_pixbuf_get_from_surface (surface,
8850 cairo_surface_destroy (surface);
8852 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
8853 image = gtk_image_new_from_pixbuf (pixbuf);
8854 g_object_unref (pixbuf);
8856 gtk_container_add (GTK_CONTAINER (window), image);
8857 gtk_widget_show_all (window);
8860 data->in_query = FALSE;
8867 snapshot_widget (GtkButton *button,
8868 struct SnapshotData *data)
8870 GtkWidget *widget = GTK_WIDGET (button);
8873 device = gtk_get_current_event_device ();
8877 if (gdk_device_get_source (device) == GDK_SOURCE_KEYBOARD)
8878 device = gdk_device_get_associated_device (device);
8880 data->is_toplevel = widget == data->toplevel_button;
8883 data->cursor = gdk_cursor_new_for_display (gtk_widget_get_display (widget),
8886 gdk_device_grab (device,
8887 gtk_widget_get_window (widget),
8888 GDK_OWNERSHIP_APPLICATION,
8890 GDK_BUTTON_RELEASE_MASK,
8894 g_signal_connect (button, "event",
8895 G_CALLBACK (snapshot_widget_event), data);
8897 gtk_grab_add (widget);
8899 data->in_query = TRUE;
8903 create_snapshot (GtkWidget *widget)
8905 static GtkWidget *window = NULL;
8908 struct SnapshotData *data;
8910 data = g_new (struct SnapshotData, 1);
8911 data->window = &window;
8912 data->in_query = FALSE;
8913 data->cursor = NULL;
8918 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
8920 gtk_window_set_screen (GTK_WINDOW (window),
8921 gtk_widget_get_screen (widget));
8923 data->handler = g_signal_connect (window, "destroy",
8924 G_CALLBACK (destroy_snapshot_data),
8927 gtk_window_set_title (GTK_WINDOW (window), "test snapshot");
8928 gtk_container_set_border_width (GTK_CONTAINER (window), 10);
8930 vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 1);
8931 gtk_container_add (GTK_CONTAINER (window), vbox);
8933 button = gtk_button_new_with_label ("Snapshot widget");
8934 gtk_box_pack_start (GTK_BOX (vbox), button, TRUE, TRUE, 0);
8935 g_signal_connect (button, "clicked",
8936 G_CALLBACK (snapshot_widget),
8939 button = gtk_button_new_with_label ("Snapshot toplevel");
8940 data->toplevel_button = button;
8941 gtk_box_pack_start (GTK_BOX (vbox), button, TRUE, TRUE, 0);
8942 g_signal_connect (button, "clicked",
8943 G_CALLBACK (snapshot_widget),
8947 if (!gtk_widget_get_visible (window))
8948 gtk_widget_show_all (window);
8950 gtk_widget_destroy (window);
8959 selection_test_received (GtkWidget *tree_view,
8960 GtkSelectionData *selection_data)
8962 GtkTreeModel *model;
8963 GtkListStore *store;
8967 if (gtk_selection_data_get_length (selection_data) < 0)
8969 g_print ("Selection retrieval failed\n");
8972 if (gtk_selection_data_get_data_type (selection_data) != GDK_SELECTION_TYPE_ATOM)
8974 g_print ("Selection \"TARGETS\" was not returned as atoms!\n");
8978 /* Clear out any current list items */
8980 model = gtk_tree_view_get_model (GTK_TREE_VIEW (tree_view));
8981 store = GTK_LIST_STORE (model);
8982 gtk_list_store_clear (store);
8984 /* Add new items to list */
8986 gtk_selection_data_get_targets (selection_data,
8989 for (i = 0; i < l; i++)
8994 name = gdk_atom_name (atoms[i]);
8997 gtk_list_store_insert_with_values (store, &iter, i, 0, name, -1);
9001 gtk_list_store_insert_with_values (store, &iter, i, 0, "(bad atom)", -1);
9008 selection_test_get_targets (GtkWidget *widget, GtkWidget *tree_view)
9010 static GdkAtom targets_atom = GDK_NONE;
9012 if (targets_atom == GDK_NONE)
9013 targets_atom = gdk_atom_intern ("TARGETS", FALSE);
9015 gtk_selection_convert (tree_view, GDK_SELECTION_PRIMARY, targets_atom,
9020 create_selection_test (GtkWidget *widget)
9022 static GtkWidget *window = NULL;
9023 GtkWidget *action_area, *content_area;
9026 GtkWidget *scrolled_win;
9027 GtkListStore* store;
9028 GtkWidget *tree_view;
9029 GtkTreeViewColumn *column;
9030 GtkCellRenderer *renderer;
9035 window = gtk_dialog_new ();
9037 gtk_window_set_screen (GTK_WINDOW (window),
9038 gtk_widget_get_screen (widget));
9040 g_signal_connect (window, "destroy",
9041 G_CALLBACK (gtk_widget_destroyed),
9044 content_area = gtk_dialog_get_content_area (GTK_DIALOG (window));
9045 action_area = gtk_dialog_get_action_area (GTK_DIALOG (window));
9047 gtk_window_set_title (GTK_WINDOW (window), "Selection Test");
9048 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
9050 /* Create the list */
9052 vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
9053 gtk_container_set_border_width (GTK_CONTAINER (vbox), 10);
9054 gtk_box_pack_start (GTK_BOX (content_area), vbox, TRUE, TRUE, 0);
9056 label = gtk_label_new ("Gets available targets for current selection");
9057 gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
9059 scrolled_win = gtk_scrolled_window_new (NULL, NULL);
9060 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
9061 GTK_POLICY_AUTOMATIC,
9062 GTK_POLICY_AUTOMATIC);
9063 gtk_box_pack_start (GTK_BOX (vbox), scrolled_win, TRUE, TRUE, 0);
9064 gtk_widget_set_size_request (scrolled_win, 100, 200);
9066 store = gtk_list_store_new (1, G_TYPE_STRING);
9067 tree_view = gtk_tree_view_new_with_model (GTK_TREE_MODEL (store));
9068 gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (scrolled_win), tree_view);
9070 renderer = gtk_cell_renderer_text_new ();
9071 column = gtk_tree_view_column_new_with_attributes ("Target", renderer,
9073 gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), column);
9075 g_signal_connect (tree_view, "selection_received",
9076 G_CALLBACK (selection_test_received), NULL);
9078 /* .. And create some buttons */
9079 button = gtk_button_new_with_label ("Get Targets");
9080 gtk_box_pack_start (GTK_BOX (action_area), button, TRUE, TRUE, 0);
9082 g_signal_connect (button, "clicked",
9083 G_CALLBACK (selection_test_get_targets), tree_view);
9085 button = gtk_button_new_with_label ("Quit");
9086 gtk_box_pack_start (GTK_BOX (action_area), button, TRUE, TRUE, 0);
9088 g_signal_connect_swapped (button, "clicked",
9089 G_CALLBACK (gtk_widget_destroy),
9093 if (!gtk_widget_get_visible (window))
9094 gtk_widget_show_all (window);
9096 gtk_widget_destroy (window);
9103 static int scroll_test_pos = 0.0;
9106 scroll_test_draw (GtkWidget *widget,
9108 GtkAdjustment *adjustment)
9111 gint imin, imax, jmin, jmax;
9114 gdk_cairo_get_clip_rectangle (cr, &clip);
9116 imin = (clip.x) / 10;
9117 imax = (clip.x + clip.width + 9) / 10;
9119 jmin = ((int)gtk_adjustment_get_value (adjustment) + clip.y) / 10;
9120 jmax = ((int)gtk_adjustment_get_value (adjustment) + clip.y + clip.height + 9) / 10;
9122 for (i=imin; i<imax; i++)
9123 for (j=jmin; j<jmax; j++)
9125 cairo_rectangle (cr, 10*i, 10*j - (int)gtk_adjustment_get_value (adjustment), 1+i%10, 1+j%10);
9133 scroll_test_scroll (GtkWidget *widget, GdkEventScroll *event,
9134 GtkAdjustment *adjustment)
9136 gdouble new_value = gtk_adjustment_get_value (adjustment) + ((event->direction == GDK_SCROLL_UP) ?
9137 -gtk_adjustment_get_page_increment (adjustment) / 2:
9138 gtk_adjustment_get_page_increment (adjustment) / 2);
9139 new_value = CLAMP (new_value, gtk_adjustment_get_lower (adjustment), gtk_adjustment_get_upper (adjustment) - gtk_adjustment_get_page_size (adjustment));
9140 gtk_adjustment_set_value (adjustment, new_value);
9146 scroll_test_configure (GtkWidget *widget, GdkEventConfigure *event,
9147 GtkAdjustment *adjustment)
9149 GtkAllocation allocation;
9151 gtk_widget_get_allocation (widget, &allocation);
9152 gtk_adjustment_configure (adjustment,
9153 gtk_adjustment_get_value (adjustment),
9154 gtk_adjustment_get_lower (adjustment),
9155 gtk_adjustment_get_upper (adjustment),
9156 0.1 * allocation.height,
9157 0.9 * allocation.height,
9162 scroll_test_adjustment_changed (GtkAdjustment *adjustment, GtkWidget *widget)
9167 dy = scroll_test_pos - (int)gtk_adjustment_get_value (adjustment);
9168 scroll_test_pos = gtk_adjustment_get_value (adjustment);
9170 if (!gtk_widget_is_drawable (widget))
9173 window = gtk_widget_get_window (widget);
9174 gdk_window_scroll (window, 0, dy);
9175 gdk_window_process_updates (window, FALSE);
9180 create_scroll_test (GtkWidget *widget)
9182 static GtkWidget *window = NULL;
9183 GtkWidget *action_area, *content_area;
9185 GtkWidget *drawing_area;
9186 GtkWidget *scrollbar;
9188 GtkAdjustment *adjustment;
9189 GdkGeometry geometry;
9190 GdkWindowHints geometry_mask;
9194 window = gtk_dialog_new ();
9196 gtk_window_set_screen (GTK_WINDOW (window),
9197 gtk_widget_get_screen (widget));
9199 g_signal_connect (window, "destroy",
9200 G_CALLBACK (gtk_widget_destroyed),
9203 content_area = gtk_dialog_get_content_area (GTK_DIALOG (window));
9204 action_area = gtk_dialog_get_action_area (GTK_DIALOG (window));
9206 gtk_window_set_title (GTK_WINDOW (window), "Scroll Test");
9207 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
9209 hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
9210 gtk_box_pack_start (GTK_BOX (content_area), hbox, TRUE, TRUE, 0);
9211 gtk_widget_show (hbox);
9213 drawing_area = gtk_drawing_area_new ();
9214 gtk_widget_set_size_request (drawing_area, 200, 200);
9215 gtk_box_pack_start (GTK_BOX (hbox), drawing_area, TRUE, TRUE, 0);
9216 gtk_widget_show (drawing_area);
9218 gtk_widget_set_events (drawing_area, GDK_EXPOSURE_MASK | GDK_SCROLL_MASK);
9220 adjustment = gtk_adjustment_new (0.0, 0.0, 1000.0, 1.0, 180.0, 200.0);
9221 scroll_test_pos = 0.0;
9223 scrollbar = gtk_scrollbar_new (GTK_ORIENTATION_VERTICAL, adjustment);
9224 gtk_box_pack_start (GTK_BOX (hbox), scrollbar, FALSE, FALSE, 0);
9225 gtk_widget_show (scrollbar);
9227 g_signal_connect (drawing_area, "draw",
9228 G_CALLBACK (scroll_test_draw), adjustment);
9229 g_signal_connect (drawing_area, "configure_event",
9230 G_CALLBACK (scroll_test_configure), adjustment);
9231 g_signal_connect (drawing_area, "scroll_event",
9232 G_CALLBACK (scroll_test_scroll), adjustment);
9234 g_signal_connect (adjustment, "value_changed",
9235 G_CALLBACK (scroll_test_adjustment_changed),
9238 /* .. And create some buttons */
9240 button = gtk_button_new_with_label ("Quit");
9241 gtk_box_pack_start (GTK_BOX (action_area), button, TRUE, TRUE, 0);
9243 g_signal_connect_swapped (button, "clicked",
9244 G_CALLBACK (gtk_widget_destroy),
9246 gtk_widget_show (button);
9248 /* Set up gridded geometry */
9250 geometry_mask = GDK_HINT_MIN_SIZE |
9251 GDK_HINT_BASE_SIZE |
9252 GDK_HINT_RESIZE_INC;
9254 geometry.min_width = 20;
9255 geometry.min_height = 20;
9256 geometry.base_width = 0;
9257 geometry.base_height = 0;
9258 geometry.width_inc = 10;
9259 geometry.height_inc = 10;
9261 gtk_window_set_geometry_hints (GTK_WINDOW (window),
9262 drawing_area, &geometry, geometry_mask);
9265 if (!gtk_widget_get_visible (window))
9266 gtk_widget_show (window);
9268 gtk_widget_destroy (window);
9275 static int timer = 0;
9278 timeout_test (GtkWidget *label)
9280 static int count = 0;
9281 static char buffer[32];
9283 sprintf (buffer, "count: %d", ++count);
9284 gtk_label_set_text (GTK_LABEL (label), buffer);
9290 start_timeout_test (GtkWidget *widget,
9295 timer = g_timeout_add (100, (GSourceFunc)timeout_test, label);
9300 stop_timeout_test (GtkWidget *widget,
9305 g_source_remove (timer);
9311 destroy_timeout_test (GtkWidget *widget,
9314 stop_timeout_test (NULL, NULL);
9320 create_timeout_test (GtkWidget *widget)
9322 static GtkWidget *window = NULL;
9323 GtkWidget *action_area, *content_area;
9329 window = gtk_dialog_new ();
9331 gtk_window_set_screen (GTK_WINDOW (window),
9332 gtk_widget_get_screen (widget));
9334 g_signal_connect (window, "destroy",
9335 G_CALLBACK (destroy_timeout_test),
9338 content_area = gtk_dialog_get_content_area (GTK_DIALOG (window));
9339 action_area = gtk_dialog_get_content_area (GTK_DIALOG (window));
9341 gtk_window_set_title (GTK_WINDOW (window), "Timeout Test");
9342 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
9344 label = gtk_label_new ("count: 0");
9345 g_object_set (label, "margin", 10, NULL);
9346 gtk_box_pack_start (GTK_BOX (content_area), label, TRUE, TRUE, 0);
9347 gtk_widget_show (label);
9349 button = gtk_button_new_with_label ("close");
9350 g_signal_connect_swapped (button, "clicked",
9351 G_CALLBACK (gtk_widget_destroy),
9353 gtk_widget_set_can_default (button, TRUE);
9354 gtk_box_pack_start (GTK_BOX (action_area), button, TRUE, TRUE, 0);
9355 gtk_widget_grab_default (button);
9356 gtk_widget_show (button);
9358 button = gtk_button_new_with_label ("start");
9359 g_signal_connect (button, "clicked",
9360 G_CALLBACK(start_timeout_test),
9362 gtk_widget_set_can_default (button, TRUE);
9363 gtk_box_pack_start (GTK_BOX (action_area), button, TRUE, TRUE, 0);
9364 gtk_widget_show (button);
9366 button = gtk_button_new_with_label ("stop");
9367 g_signal_connect (button, "clicked",
9368 G_CALLBACK (stop_timeout_test),
9370 gtk_widget_set_can_default (button, TRUE);
9371 gtk_box_pack_start (GTK_BOX (action_area), button, TRUE, TRUE, 0);
9372 gtk_widget_show (button);
9375 if (!gtk_widget_get_visible (window))
9376 gtk_widget_show (window);
9378 gtk_widget_destroy (window);
9385 static int idle_id = 0;
9388 idle_test (GtkWidget *label)
9390 static int count = 0;
9391 static char buffer[32];
9393 sprintf (buffer, "count: %d", ++count);
9394 gtk_label_set_text (GTK_LABEL (label), buffer);
9400 start_idle_test (GtkWidget *widget,
9405 idle_id = g_idle_add ((GSourceFunc) idle_test, label);
9410 stop_idle_test (GtkWidget *widget,
9415 g_source_remove (idle_id);
9421 destroy_idle_test (GtkWidget *widget,
9424 stop_idle_test (NULL, NULL);
9430 toggle_idle_container (GObject *button,
9431 GtkContainer *container)
9433 gtk_container_set_resize_mode (container, GPOINTER_TO_INT (g_object_get_data (button, "user_data")));
9437 create_idle_test (GtkWidget *widget)
9439 static GtkWidget *window = NULL;
9442 GtkWidget *container;
9446 GtkWidget *action_area, *content_area;
9451 window = gtk_dialog_new ();
9453 gtk_window_set_screen (GTK_WINDOW (window),
9454 gtk_widget_get_screen (widget));
9456 g_signal_connect (window, "destroy",
9457 G_CALLBACK (destroy_idle_test),
9460 content_area = gtk_dialog_get_content_area (GTK_DIALOG (window));
9461 action_area = gtk_dialog_get_action_area (GTK_DIALOG (window));
9463 gtk_window_set_title (GTK_WINDOW (window), "Idle Test");
9464 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
9466 label = gtk_label_new ("count: 0");
9467 g_object_set (label, "margin", 10, NULL);
9468 gtk_widget_show (label);
9471 g_object_new (GTK_TYPE_BOX,
9473 /* "GtkContainer::child", g_object_new (GTK_TYPE_HBOX,
9474 * "GtkWidget::visible", TRUE,
9479 gtk_box_pack_start (GTK_BOX (content_area), container, TRUE, TRUE, 0);
9482 g_object_new (GTK_TYPE_FRAME,
9484 "label", "Label Container",
9486 "parent", content_area,
9489 g_object_new (GTK_TYPE_BOX,
9492 "orientation", GTK_ORIENTATION_VERTICAL,
9495 g_object_connect (g_object_new (GTK_TYPE_RADIO_BUTTON,
9496 "label", "Resize-Parent",
9497 "user_data", (void*)GTK_RESIZE_PARENT,
9501 "signal::clicked", toggle_idle_container, container,
9503 button = g_object_new (GTK_TYPE_RADIO_BUTTON,
9504 "label", "Resize-Queue",
9505 "user_data", (void*)GTK_RESIZE_QUEUE,
9510 g_object_connect (button,
9511 "signal::clicked", toggle_idle_container, container,
9513 button2 = g_object_new (GTK_TYPE_RADIO_BUTTON,
9514 "label", "Resize-Immediate",
9515 "user_data", (void*)GTK_RESIZE_IMMEDIATE,
9517 g_object_connect (button2,
9518 "signal::clicked", toggle_idle_container, container,
9520 g_object_set (button2,
9526 button = gtk_button_new_with_label ("close");
9527 g_signal_connect_swapped (button, "clicked",
9528 G_CALLBACK (gtk_widget_destroy),
9530 gtk_widget_set_can_default (button, TRUE);
9531 gtk_box_pack_start (GTK_BOX (action_area), button, TRUE, TRUE, 0);
9532 gtk_widget_grab_default (button);
9533 gtk_widget_show (button);
9535 button = gtk_button_new_with_label ("start");
9536 g_signal_connect (button, "clicked",
9537 G_CALLBACK (start_idle_test),
9539 gtk_widget_set_can_default (button, TRUE);
9540 gtk_box_pack_start (GTK_BOX (action_area), button, TRUE, TRUE, 0);
9541 gtk_widget_show (button);
9543 button = gtk_button_new_with_label ("stop");
9544 g_signal_connect (button, "clicked",
9545 G_CALLBACK (stop_idle_test),
9547 gtk_widget_set_can_default (button, TRUE);
9548 gtk_box_pack_start (GTK_BOX (action_area), button, TRUE, TRUE, 0);
9549 gtk_widget_show (button);
9552 if (!gtk_widget_get_visible (window))
9553 gtk_widget_show (window);
9555 gtk_widget_destroy (window);
9563 create_rc_file (GtkWidget *widget)
9565 static GtkWidget *window = NULL;
9566 GtkWidget *action_area, *content_area;
9574 window = gtk_dialog_new ();
9576 gtk_window_set_screen (GTK_WINDOW (window),
9577 gtk_widget_get_screen (widget));
9579 g_signal_connect (window, "destroy",
9580 G_CALLBACK (gtk_widget_destroyed),
9583 content_area = gtk_dialog_get_content_area (GTK_DIALOG (window));
9584 action_area = gtk_dialog_get_action_area (GTK_DIALOG (window));
9586 frame = gtk_aspect_frame_new ("Testing RC file prioritization", 0.5, 0.5, 0.0, TRUE);
9587 gtk_box_pack_start (GTK_BOX (content_area), frame, FALSE, FALSE, 0);
9589 vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
9590 gtk_container_add (GTK_CONTAINER (frame), vbox);
9592 label = gtk_label_new ("This label should be red");
9593 gtk_widget_set_name (label, "testgtk-red-label");
9594 gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
9596 label = gtk_label_new ("This label should be green");
9597 gtk_widget_set_name (label, "testgtk-green-label");
9598 gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
9600 label = gtk_label_new ("This label should be blue");
9601 gtk_widget_set_name (label, "testgtk-blue-label");
9602 gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
9604 gtk_window_set_title (GTK_WINDOW (window), "Reload Rc file");
9605 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
9607 button = gtk_button_new_with_label ("Reload");
9608 g_signal_connect_swapped (button, "clicked",
9609 G_CALLBACK (gtk_style_context_reset_widgets),
9610 gtk_widget_get_screen (button));
9611 gtk_widget_set_can_default (button, TRUE);
9612 gtk_box_pack_start (GTK_BOX (action_area), button, TRUE, TRUE, 0);
9613 gtk_widget_grab_default (button);
9615 button = gtk_button_new_with_label ("Close");
9616 g_signal_connect_swapped (button, "clicked",
9617 G_CALLBACK (gtk_widget_destroy),
9619 gtk_widget_set_can_default (button, TRUE);
9620 gtk_box_pack_start (GTK_BOX (action_area), button, TRUE, TRUE, 0);
9623 if (!gtk_widget_get_visible (window))
9624 gtk_widget_show_all (window);
9626 gtk_widget_destroy (window);
9630 * Test of recursive mainloop
9634 mainloop_destroyed (GtkWidget *w, GtkWidget **window)
9641 create_mainloop (GtkWidget *widget)
9643 static GtkWidget *window = NULL;
9644 GtkWidget *action_area, *content_area;
9650 window = gtk_dialog_new ();
9652 gtk_window_set_screen (GTK_WINDOW (window),
9653 gtk_widget_get_screen (widget));
9655 gtk_window_set_title (GTK_WINDOW (window), "Test Main Loop");
9657 g_signal_connect (window, "destroy",
9658 G_CALLBACK (mainloop_destroyed),
9661 content_area = gtk_dialog_get_content_area (GTK_DIALOG (window));
9662 action_area = gtk_dialog_get_action_area (GTK_DIALOG (window));
9664 label = gtk_label_new ("In recursive main loop...");
9665 g_object_set (label, "margin", 20, NULL);
9667 gtk_box_pack_start (GTK_BOX (content_area), label, TRUE, TRUE, 0);
9668 gtk_widget_show (label);
9670 button = gtk_button_new_with_label ("Leave");
9671 gtk_box_pack_start (GTK_BOX (action_area), button, FALSE, TRUE, 0);
9673 g_signal_connect_swapped (button, "clicked",
9674 G_CALLBACK (gtk_widget_destroy),
9677 gtk_widget_set_can_default (button, TRUE);
9678 gtk_widget_grab_default (button);
9680 gtk_widget_show (button);
9683 if (!gtk_widget_get_visible (window))
9685 gtk_widget_show (window);
9687 g_print ("create_mainloop: start\n");
9689 g_print ("create_mainloop: done\n");
9692 gtk_widget_destroy (window);
9696 layout_draw_handler (GtkWidget *widget, cairo_t *cr)
9699 GdkWindow *bin_window;
9702 gint imin, imax, jmin, jmax;
9704 layout = GTK_LAYOUT (widget);
9705 bin_window = gtk_layout_get_bin_window (layout);
9707 if (!gtk_cairo_should_draw_window (cr, bin_window))
9710 gdk_window_get_position (bin_window, &x, &y);
9711 cairo_translate (cr, x, y);
9713 gdk_cairo_get_clip_rectangle (cr, &clip);
9715 imin = (clip.x) / 10;
9716 imax = (clip.x + clip.width + 9) / 10;
9718 jmin = (clip.y) / 10;
9719 jmax = (clip.y + clip.height + 9) / 10;
9721 for (i=imin; i<imax; i++)
9722 for (j=jmin; j<jmax; j++)
9724 cairo_rectangle (cr,
9733 void create_layout (GtkWidget *widget)
9735 GtkAdjustment *hadjustment, *vadjustment;
9737 static GtkWidget *window = NULL;
9738 GtkWidget *layout_widget;
9739 GtkWidget *scrolledwindow;
9748 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
9749 gtk_window_set_screen (GTK_WINDOW (window),
9750 gtk_widget_get_screen (widget));
9752 g_signal_connect (window, "destroy",
9753 G_CALLBACK (gtk_widget_destroyed),
9756 gtk_window_set_title (GTK_WINDOW (window), "Layout");
9757 gtk_widget_set_size_request (window, 200, 200);
9759 scrolledwindow = gtk_scrolled_window_new (NULL, NULL);
9760 gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolledwindow),
9762 gtk_scrolled_window_set_placement (GTK_SCROLLED_WINDOW (scrolledwindow),
9763 GTK_CORNER_TOP_RIGHT);
9765 gtk_container_add (GTK_CONTAINER (window), scrolledwindow);
9767 layout_widget = gtk_layout_new (NULL, NULL);
9768 layout = GTK_LAYOUT (layout_widget);
9769 gtk_container_add (GTK_CONTAINER (scrolledwindow), layout_widget);
9771 /* We set step sizes here since GtkLayout does not set
9774 hadjustment = gtk_scrollable_get_hadjustment (GTK_SCROLLABLE (layout));
9775 vadjustment = gtk_scrollable_get_vadjustment (GTK_SCROLLABLE (layout));
9776 gtk_adjustment_set_step_increment (hadjustment, 10.0);
9777 gtk_adjustment_set_step_increment (vadjustment, 10.0);
9778 gtk_scrollable_set_hadjustment (GTK_SCROLLABLE (layout), hadjustment);
9779 gtk_scrollable_set_vadjustment (GTK_SCROLLABLE (layout), vadjustment);
9781 gtk_widget_set_events (layout_widget, GDK_EXPOSURE_MASK);
9782 g_signal_connect (layout, "draw",
9783 G_CALLBACK (layout_draw_handler), NULL);
9785 gtk_layout_set_size (layout, 1600, 128000);
9787 for (i=0 ; i < 16 ; i++)
9788 for (j=0 ; j < 16 ; j++)
9790 sprintf(buf, "Button %d, %d", i, j);
9792 button = gtk_button_new_with_label (buf);
9794 button = gtk_label_new (buf);
9796 gtk_layout_put (layout, button, j*100, i*100);
9799 for (i=16; i < 1280; i++)
9801 sprintf(buf, "Button %d, %d", i, 0);
9803 button = gtk_button_new_with_label (buf);
9805 button = gtk_label_new (buf);
9807 gtk_layout_put (layout, button, 0, i*100);
9811 if (!gtk_widget_get_visible (window))
9812 gtk_widget_show_all (window);
9814 gtk_widget_destroy (window);
9818 /* FIXME: need to completely redo this for GtkStyleContext */
9820 create_styles (GtkWidget *widget)
9822 static GtkWidget *window = NULL;
9823 GtkWidget *content_area, *action_area;
9828 static GdkRGBA red = { 1,0,0,1 };
9829 static GdkRGBA green = { 0,1,0,1 };
9830 static GdkRGBA blue = { 0,0,1,1 };
9831 static GdkRGBA yellow = { 1,1,0,1 };
9832 static GdkRGBA cyan = { 0,1,1,1 };
9833 PangoFontDescription *font_desc;
9835 GtkRcStyle *rc_style;
9839 window = gtk_dialog_new ();
9840 gtk_window_set_screen (GTK_WINDOW (window),
9841 gtk_widget_get_screen (widget));
9843 g_signal_connect (window, "destroy",
9844 G_CALLBACK (gtk_widget_destroyed),
9847 content_area = gtk_dialog_get_content_area (GTK_DIALOG (window));
9848 action_area = gtk_dialog_get_action_area (GTK_DIALOG (window));
9850 button = gtk_button_new_with_label ("Close");
9851 g_signal_connect_swapped (button, "clicked",
9852 G_CALLBACK (gtk_widget_destroy),
9854 gtk_widget_set_can_default (button, TRUE);
9855 gtk_box_pack_start (GTK_BOX (action_area), button, TRUE, TRUE, 0);
9856 gtk_widget_show (button);
9858 vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
9859 gtk_container_set_border_width (GTK_CONTAINER (vbox), 10);
9860 gtk_box_pack_start (GTK_BOX (content_area), vbox, FALSE, FALSE, 0);
9862 label = gtk_label_new ("Font:");
9863 gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
9864 gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
9866 font_desc = pango_font_description_from_string ("Helvetica,Sans Oblique 18");
9868 button = gtk_button_new_with_label ("Some Text");
9869 gtk_widget_override_font (gtk_bin_get_child (GTK_BIN (button)), font_desc);
9870 gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
9872 label = gtk_label_new ("Foreground:");
9873 gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
9874 gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
9876 button = gtk_button_new_with_label ("Some Text");
9877 gtk_widget_override_color (gtk_bin_get_child (GTK_BIN (button)), 0, &red);
9878 gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
9880 label = gtk_label_new ("Background:");
9881 gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
9882 gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
9884 button = gtk_button_new_with_label ("Some Text");
9885 gtk_widget_override_background_color (button, 0, &green);
9886 gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
9888 label = gtk_label_new ("Text:");
9889 gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
9890 gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
9892 entry = gtk_entry_new ();
9893 gtk_entry_set_text (GTK_ENTRY (entry), "Some Text");
9894 gtk_widget_override_color (entry, 0, &blue);
9895 gtk_box_pack_start (GTK_BOX (vbox), entry, FALSE, FALSE, 0);
9897 label = gtk_label_new ("Base:");
9898 gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
9899 gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
9901 entry = gtk_entry_new ();
9902 gtk_entry_set_text (GTK_ENTRY (entry), "Some Text");
9903 gtk_widget_override_background_color (entry, 0, &yellow);
9904 gtk_box_pack_start (GTK_BOX (vbox), entry, FALSE, FALSE, 0);
9906 label = gtk_label_new ("Cursor:");
9907 gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
9908 gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
9910 entry = gtk_entry_new ();
9911 gtk_entry_set_text (GTK_ENTRY (entry), "Some Text");
9912 gtk_widget_modify_cursor (entry, &red, &red);
9913 gtk_box_pack_start (GTK_BOX (vbox), entry, FALSE, FALSE, 0);
9915 label = gtk_label_new ("Multiple:");
9916 gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
9917 gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
9919 button = gtk_button_new_with_label ("Some Text");
9921 rc_style = gtk_rc_style_new ();
9923 rc_style->font_desc = pango_font_description_copy (font_desc);
9924 rc_style->color_flags[GTK_STATE_NORMAL] = GTK_RC_FG | GTK_RC_BG;
9925 rc_style->color_flags[GTK_STATE_PRELIGHT] = GTK_RC_FG | GTK_RC_BG;
9926 rc_style->color_flags[GTK_STATE_ACTIVE] = GTK_RC_FG | GTK_RC_BG;
9927 rc_style->fg[GTK_STATE_NORMAL] = yellow;
9928 rc_style->bg[GTK_STATE_NORMAL] = blue;
9929 rc_style->fg[GTK_STATE_PRELIGHT] = blue;
9930 rc_style->bg[GTK_STATE_PRELIGHT] = yellow;
9931 rc_style->fg[GTK_STATE_ACTIVE] = red;
9932 rc_style->bg[GTK_STATE_ACTIVE] = cyan;
9933 rc_style->xthickness = 5;
9934 rc_style->ythickness = 5;
9936 gtk_widget_modify_style (button, rc_style);
9937 gtk_widget_modify_style (gtk_bin_get_child (GTK_BIN (button)), rc_style);
9939 g_object_unref (rc_style);
9941 gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
9944 if (!gtk_widget_get_visible (window))
9945 gtk_widget_show_all (window);
9947 gtk_widget_destroy (window);
9952 * Main Window and Exit
9956 do_exit (GtkWidget *widget, GtkWidget *window)
9958 gtk_widget_destroy (window);
9964 void (*func) (GtkWidget *widget);
9965 gboolean do_not_benchmark;
9968 { "alpha window", create_alpha_window },
9969 { "big windows", create_big_windows },
9970 { "button box", create_button_box },
9971 { "buttons", create_buttons },
9972 { "check buttons", create_check_buttons },
9973 { "color selection", create_color_selection },
9974 { "composited window", create_composited_window },
9975 { "cursors", create_cursors },
9976 { "dialog", create_dialog },
9977 { "display & screen", create_display_screen, TRUE },
9978 { "entry", create_entry },
9979 { "event box", create_event_box },
9980 { "event watcher", create_event_watcher },
9981 { "expander", create_expander },
9982 { "flipping", create_flipping },
9983 { "focus", create_focus },
9984 { "font selection", create_font_selection },
9985 { "handle box", create_handle_box },
9986 { "image", create_image },
9987 { "key lookup", create_key_lookup },
9988 { "labels", create_labels },
9989 { "layout", create_layout },
9990 { "menus", create_menus },
9991 { "message dialog", create_message_dialog },
9992 { "modal window", create_modal_window, TRUE },
9993 { "notebook", create_notebook },
9994 { "panes", create_panes },
9995 { "paned keyboard", create_paned_keyboard_navigation },
9996 { "pixbuf", create_pixbuf },
9997 { "progress bar", create_progress_bar },
9998 { "properties", create_properties },
9999 { "radio buttons", create_radio_buttons },
10000 { "range controls", create_range_controls },
10001 { "rc file", create_rc_file },
10002 { "reparent", create_reparent },
10003 { "resize grips", create_resize_grips },
10004 { "rotated label", create_rotated_label },
10005 { "rotated text", create_rotated_text },
10006 { "saved position", create_saved_position },
10007 { "scrolled windows", create_scrolled_windows },
10008 { "shapes", create_shapes },
10009 { "size groups", create_size_groups },
10010 { "snapshot", create_snapshot },
10011 { "spinbutton", create_spins },
10012 { "statusbar", create_statusbar },
10014 { "styles", create_styles },
10016 { "test idle", create_idle_test },
10017 { "test mainloop", create_mainloop, TRUE },
10018 { "test scrolling", create_scroll_test },
10019 { "test selection", create_selection_test },
10020 { "test timeout", create_timeout_test },
10021 { "toggle buttons", create_toggle_buttons },
10022 { "toolbar", create_toolbar },
10023 { "tooltips", create_tooltips },
10024 { "WM hints", create_wmhints },
10025 { "window sizing", create_window_sizing },
10026 { "window states", create_window_states }
10028 int nbuttons = sizeof (buttons) / sizeof (buttons[0]);
10031 create_main_window (void)
10036 GtkWidget *scrolled_window;
10040 GtkWidget *separator;
10041 GdkGeometry geometry;
10044 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
10045 gtk_widget_set_name (window, "main_window");
10046 gtk_window_move (GTK_WINDOW (window), 50, 20);
10047 gtk_window_set_default_size (GTK_WINDOW (window), -1, 400);
10049 geometry.min_width = -1;
10050 geometry.min_height = -1;
10051 geometry.max_width = -1;
10052 geometry.max_height = G_MAXSHORT;
10053 gtk_window_set_geometry_hints (GTK_WINDOW (window), NULL,
10055 GDK_HINT_MIN_SIZE | GDK_HINT_MAX_SIZE);
10057 g_signal_connect (window, "destroy",
10058 G_CALLBACK (gtk_main_quit),
10060 g_signal_connect (window, "delete-event",
10061 G_CALLBACK (gtk_false),
10064 box1 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
10065 gtk_container_add (GTK_CONTAINER (window), box1);
10067 if (gtk_micro_version > 0)
10070 gtk_get_major_version (),
10071 gtk_get_minor_version (),
10072 gtk_get_micro_version ());
10076 gtk_get_major_version (),
10077 gtk_get_minor_version ());
10079 label = gtk_label_new (buffer);
10080 gtk_box_pack_start (GTK_BOX (box1), label, FALSE, FALSE, 0);
10081 gtk_widget_set_name (label, "testgtk-version-label");
10083 scrolled_window = gtk_scrolled_window_new (NULL, NULL);
10084 gtk_container_set_border_width (GTK_CONTAINER (scrolled_window), 10);
10085 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
10087 GTK_POLICY_AUTOMATIC);
10088 gtk_box_pack_start (GTK_BOX (box1), scrolled_window, TRUE, TRUE, 0);
10090 box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
10091 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
10092 gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (scrolled_window), box2);
10093 gtk_container_set_focus_vadjustment (GTK_CONTAINER (box2),
10094 gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (scrolled_window)));
10095 gtk_widget_show (box2);
10097 for (i = 0; i < nbuttons; i++)
10099 button = gtk_button_new_with_label (buttons[i].label);
10100 if (buttons[i].func)
10101 g_signal_connect (button,
10103 G_CALLBACK(buttons[i].func),
10106 gtk_widget_set_sensitive (button, FALSE);
10107 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
10110 separator = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
10111 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
10113 box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10);
10114 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
10115 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
10117 button = gtk_button_new_with_mnemonic ("_Close");
10118 g_signal_connect (button, "clicked",
10119 G_CALLBACK (do_exit),
10121 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
10122 gtk_widget_set_can_default (button, TRUE);
10123 gtk_widget_grab_default (button);
10125 gtk_widget_show_all (window);
10131 if (g_file_test ("../modules/input/immodules.cache", G_FILE_TEST_EXISTS))
10132 g_setenv ("GTK_IM_MODULE_FILE", "../modules/input/immodules.cache", TRUE);
10136 pad (const char *str, int to)
10138 static char buf[256];
10139 int len = strlen (str);
10142 for (i = 0; i < to; i++)
10147 memcpy (buf, str, len);
10153 bench_iteration (GtkWidget *widget, void (* fn) (GtkWidget *widget))
10155 fn (widget); /* on */
10156 while (g_main_context_iteration (NULL, FALSE));
10157 fn (widget); /* off */
10158 while (g_main_context_iteration (NULL, FALSE));
10162 do_real_bench (GtkWidget *widget, void (* fn) (GtkWidget *widget), char *name, int num)
10168 static gboolean printed_headers = FALSE;
10170 if (!printed_headers) {
10171 g_print ("Test Iters First Other\n");
10172 g_print ("-------------------- ----- ---------- ----------\n");
10173 printed_headers = TRUE;
10176 g_get_current_time (&tv0);
10177 bench_iteration (widget, fn);
10178 g_get_current_time (&tv1);
10180 dt_first = ((double)tv1.tv_sec - tv0.tv_sec) * 1000.0
10181 + (tv1.tv_usec - tv0.tv_usec) / 1000.0;
10183 g_get_current_time (&tv0);
10184 for (n = 0; n < num - 1; n++)
10185 bench_iteration (widget, fn);
10186 g_get_current_time (&tv1);
10187 dt = ((double)tv1.tv_sec - tv0.tv_sec) * 1000.0
10188 + (tv1.tv_usec - tv0.tv_usec) / 1000.0;
10190 g_print ("%s %5d ", pad (name, 20), num);
10192 g_print ("%10.1f %10.1f\n", dt_first, dt/(num-1));
10194 g_print ("%10.1f\n", dt_first);
10198 do_bench (char* what, int num)
10202 void (* fn) (GtkWidget *widget);
10204 widget = gtk_window_new (GTK_WINDOW_TOPLEVEL);
10206 if (g_ascii_strcasecmp (what, "ALL") == 0)
10208 for (i = 0; i < nbuttons; i++)
10210 if (!buttons[i].do_not_benchmark)
10211 do_real_bench (widget, buttons[i].func, buttons[i].label, num);
10218 for (i = 0; i < nbuttons; i++)
10220 if (strcmp (buttons[i].label, what) == 0)
10222 fn = buttons[i].func;
10228 g_print ("Can't bench: \"%s\" not found.\n", what);
10230 do_real_bench (widget, fn, buttons[i].label, num);
10237 fprintf (stderr, "Usage: testgtk [--bench ALL|<bench>[:<count>]]\n");
10242 main (int argc, char *argv[])
10244 GtkCssProvider *provider, *memory_provider;
10245 GdkDisplay *display;
10247 GtkBindingSet *binding_set;
10249 gboolean done_benchmarks = FALSE;
10251 srand (time (NULL));
10255 g_set_application_name ("GTK+ Test Program");
10257 gtk_init (&argc, &argv);
10259 provider = gtk_css_provider_new ();
10261 /* Check to see if we are being run from the correct
10264 if (file_exists ("testgtk.css"))
10265 gtk_css_provider_load_from_path (provider, "testgtk.css", NULL);
10266 else if (file_exists ("tests/testgtk.css"))
10267 gtk_css_provider_load_from_path (provider, "tests/testgtk.css", NULL);
10269 g_warning ("Couldn't find file \"testgtk.css\".");
10271 display = gdk_display_get_default ();
10272 screen = gdk_display_get_default_screen (display);
10274 gtk_style_context_add_provider_for_screen (screen, GTK_STYLE_PROVIDER (provider),
10275 GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
10276 g_object_unref (provider);
10278 gtk_accelerator_set_default_mod_mask (GDK_SHIFT_MASK |
10287 for (i = 1; i < argc; i++)
10289 if (strncmp (argv[i], "--bench", strlen("--bench")) == 0)
10296 nextarg = strchr (argv[i], '=');
10307 count = strchr (nextarg, ':');
10310 what = g_strndup (nextarg, count - nextarg);
10312 num = atoi (count);
10317 what = g_strdup (nextarg);
10319 do_bench (what, num ? num : 1);
10320 done_benchmarks = TRUE;
10325 if (done_benchmarks)
10330 binding_set = gtk_binding_set_by_class (g_type_class_ref (GTK_TYPE_WIDGET));
10331 gtk_binding_entry_add_signal (binding_set,
10332 '9', GDK_CONTROL_MASK | GDK_RELEASE_MASK,
10335 G_TYPE_STRING, "GtkWidgetClass <ctrl><release>9 test");
10337 memory_provider = gtk_css_provider_new ();
10338 gtk_css_provider_load_from_data (memory_provider,
10339 "#testgtk-version-label {\n"
10341 " font: Sans 18;\n"
10344 gtk_style_context_add_provider_for_screen (screen, GTK_STYLE_PROVIDER (memory_provider),
10345 GTK_STYLE_PROVIDER_PRIORITY_APPLICATION + 1);
10347 create_main_window ();
10353 while (g_main_context_pending (NULL))
10354 g_main_context_iteration (NULL, FALSE);
10357 while (g_main_context_pending (NULL))
10358 g_main_context_iteration (NULL, FALSE);