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/.
27 #undef GTK_DISABLE_DEPRECATED
43 #define GTK_ENABLE_BROKEN
46 #include "gdk/gdkkeysyms.h"
49 #define sleep(n) _sleep(n)
52 #include "prop-editor.h"
54 #include "circles.xbm"
58 file_exists (const char *filename)
62 return stat (filename, &statbuf) == 0;
66 shape_create_icon (GdkScreen *screen,
75 build_option_menu (gchar *items[],
78 void (*func) (GtkWidget *widget, gpointer data),
81 /* macro, structure and variables used by tree window demos */
82 #define DEFAULT_NUMBER_OF_ITEM 3
83 #define DEFAULT_RECURSION_LEVEL 3
86 GSList* selection_mode_group;
87 GtkWidget* single_button;
88 GtkWidget* browse_button;
89 GtkWidget* multiple_button;
90 GtkWidget* draw_line_button;
91 GtkWidget* view_line_button;
92 GtkWidget* no_root_item_button;
93 GtkWidget* nb_item_spinner;
94 GtkWidget* recursion_spinner;
95 } sTreeSampleSelection;
97 typedef struct sTreeButtons {
99 GtkWidget* add_button;
100 GtkWidget* remove_button;
101 GtkWidget* subtree_button;
103 /* end of tree section */
106 build_option_menu (gchar *items[],
109 void (*func)(GtkWidget *widget, gpointer data),
114 GtkWidget *menu_item;
118 omenu = gtk_option_menu_new ();
119 g_signal_connect (omenu, "changed",
120 G_CALLBACK (func), data);
122 menu = gtk_menu_new ();
125 for (i = 0; i < num_items; i++)
127 menu_item = gtk_radio_menu_item_new_with_label (group, items[i]);
128 group = gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (menu_item));
129 gtk_menu_shell_append (GTK_MENU_SHELL (menu), menu_item);
131 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (menu_item), TRUE);
132 gtk_widget_show (menu_item);
135 gtk_option_menu_set_menu (GTK_OPTION_MENU (omenu), menu);
136 gtk_option_menu_set_history (GTK_OPTION_MENU (omenu), history);
142 destroy_tooltips (GtkWidget *widget, GtkWindow **window)
144 GtkTooltips *tt = g_object_get_data (G_OBJECT (*window), "tooltips");
151 * Windows with an alpha channel
156 on_alpha_window_expose (GtkWidget *widget,
157 GdkEventExpose *expose)
160 cairo_pattern_t *pattern;
163 cr = gdk_cairo_create (widget->window);
165 radius = MIN (widget->allocation.width, widget->allocation.height) / 2;
166 pattern = cairo_pattern_create_radial (widget->allocation.width / 2,
167 widget->allocation.height / 2,
169 widget->allocation.width / 2,
170 widget->allocation.height / 2,
173 if (gdk_screen_get_rgba_colormap (gtk_widget_get_screen (widget)) &&
174 gtk_widget_is_composited (widget))
175 cairo_set_source_rgba (cr, 1.0, 1.0, 1.0, 0.0); /* transparent */
177 cairo_set_source_rgb (cr, 1.0, 1.0, 1.0); /* opaque white */
179 cairo_set_operator (cr, CAIRO_OPERATOR_SOURCE);
182 cairo_pattern_add_color_stop_rgba (pattern, 0.0,
183 1.0, 0.75, 0.0, 1.0); /* solid orange */
184 cairo_pattern_add_color_stop_rgba (pattern, 1.0,
185 1.0, 0.75, 0.0, 0.0); /* transparent orange */
187 cairo_set_source (cr, pattern);
188 cairo_pattern_destroy (pattern);
190 cairo_set_operator (cr, CAIRO_OPERATOR_OVER);
199 build_alpha_widgets (void)
202 GtkWidget *radio_button;
207 table = gtk_table_new (1, 1, FALSE);
209 radio_button = gtk_radio_button_new_with_label (NULL, "Red");
210 gtk_table_attach (GTK_TABLE (table),
213 GTK_EXPAND | GTK_FILL, 0,
216 radio_button = gtk_radio_button_new_with_label_from_widget (GTK_RADIO_BUTTON (radio_button), "Green");
217 gtk_table_attach (GTK_TABLE (table),
220 GTK_EXPAND | GTK_FILL, 0,
223 radio_button = gtk_radio_button_new_with_label_from_widget (GTK_RADIO_BUTTON (radio_button), "Blue"),
224 gtk_table_attach (GTK_TABLE (table),
227 GTK_EXPAND | GTK_FILL, 0,
230 gtk_table_attach (GTK_TABLE (table),
231 gtk_check_button_new_with_label ("Sedentary"),
233 GTK_EXPAND | GTK_FILL, 0,
235 gtk_table_attach (GTK_TABLE (table),
236 gtk_check_button_new_with_label ("Nocturnal"),
238 GTK_EXPAND | GTK_FILL, 0,
240 gtk_table_attach (GTK_TABLE (table),
241 gtk_check_button_new_with_label ("Compulsive"),
243 GTK_EXPAND | GTK_FILL, 0,
246 radio_button = gtk_radio_button_new_with_label_from_widget (GTK_RADIO_BUTTON (radio_button), "Green");
247 gtk_table_attach (GTK_TABLE (table),
250 GTK_EXPAND | GTK_FILL, 0,
253 radio_button = gtk_radio_button_new_with_label_from_widget (GTK_RADIO_BUTTON (radio_button), "Blue"),
254 gtk_table_attach (GTK_TABLE (table),
257 GTK_EXPAND | GTK_FILL, 0,
260 hbox = gtk_hbox_new (FALSE, 0);
261 label = gtk_label_new (NULL);
262 gtk_label_set_markup (GTK_LABEL (label), "<i>Entry: </i>");
263 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
264 entry = gtk_entry_new ();
265 gtk_box_pack_start (GTK_BOX (hbox), entry, TRUE, TRUE, 0);
266 gtk_table_attach (GTK_TABLE (table),
269 GTK_EXPAND | GTK_FILL, 0,
276 on_alpha_drawing_expose (GtkWidget *widget,
277 GdkEventExpose *expose)
279 int x = widget->allocation.x;
280 int y = widget->allocation.y;
281 int width = widget->allocation.width;
282 int height = widget->allocation.height;
288 buffer = g_malloc (64 * 64 * 4);
290 gdk_draw_rectangle (widget->window, widget->style->black_gc, FALSE,
292 width - 1, height - 1);
295 for (i = 0; i < 64; i++) {
296 for (j = 0; j < 64; j++) {
300 *(p++) = MIN (255, ((32 - i) * (32 - i) + (32 - j) * (32 - j)) / 8);
305 gdk_draw_rgb_32_image (widget->window, widget->style->black_gc,
306 x + 18, y + (height - 64) /2,
307 64, 64, GDK_RGB_DITHER_NORMAL, buffer, 64 * 4);
309 pixbuf = gdk_pixbuf_new_from_data (buffer, GDK_COLORSPACE_RGB, TRUE,
310 8, 64, 64, 4 * 64, NULL, NULL);
312 gdk_draw_pixbuf (widget->window, widget->style->black_gc, pixbuf,
313 0, 0, x + width - 18 - 64, y + (height - 64) /2,
314 64, 64, GDK_RGB_DITHER_NORMAL, 0, 0);
316 g_object_unref (pixbuf);
324 build_alpha_drawing ()
328 hbox = gtk_hbox_new (FALSE, 0);
329 gtk_widget_set_size_request (hbox, 100, 100);
331 g_signal_connect (hbox, "expose-event",
332 G_CALLBACK (on_alpha_drawing_expose), NULL);
338 on_alpha_screen_changed (GtkWidget *widget,
339 GdkScreen *old_screen,
342 GdkScreen *screen = gtk_widget_get_screen (widget);
343 GdkColormap *colormap = gdk_screen_get_rgba_colormap (screen);
347 colormap = gdk_screen_get_rgb_colormap (screen);
348 gtk_label_set_markup (GTK_LABEL (label), "<b>Screen doesn't support alpha</b>");
352 gtk_label_set_markup (GTK_LABEL (label), "<b>Screen supports alpha</b>");
355 gtk_widget_set_colormap (widget, colormap);
359 on_composited_changed (GtkWidget *window,
362 gboolean is_composited = gtk_widget_is_composited (window);
365 gtk_label_set_text (label, "Composited");
367 gtk_label_set_text (label, "Not composited");
371 create_alpha_window (GtkWidget *widget)
373 static GtkWidget *window;
380 window = gtk_dialog_new_with_buttons ("Alpha Window",
381 GTK_WINDOW (gtk_widget_get_toplevel (widget)), 0,
385 gtk_widget_set_app_paintable (window, TRUE);
386 g_signal_connect (window, "expose-event",
387 G_CALLBACK (on_alpha_window_expose), NULL);
389 vbox = gtk_vbox_new (FALSE, 8);
390 gtk_container_set_border_width (GTK_CONTAINER (vbox), 12);
391 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), vbox,
394 label = gtk_label_new (NULL);
395 gtk_box_pack_start (GTK_BOX (vbox), label, TRUE, TRUE, 0);
396 on_alpha_screen_changed (window, NULL, label);
397 g_signal_connect (window, "screen-changed",
398 G_CALLBACK (on_alpha_screen_changed), label);
400 label = gtk_label_new (NULL);
401 gtk_box_pack_start (GTK_BOX (vbox), label, TRUE, TRUE, 0);
402 on_composited_changed (window, GTK_LABEL (label));
403 g_signal_connect (window, "composited_changed", G_CALLBACK (on_composited_changed), label);
405 gtk_box_pack_start (GTK_BOX (vbox), build_alpha_widgets (), TRUE, TRUE, 0);
406 gtk_box_pack_start (GTK_BOX (vbox), build_alpha_drawing (), TRUE, TRUE, 0);
408 g_signal_connect (window, "destroy",
409 G_CALLBACK (gtk_widget_destroyed),
412 g_signal_connect (window, "response",
413 G_CALLBACK (gtk_widget_destroy),
417 if (!GTK_WIDGET_VISIBLE (window))
418 gtk_widget_show_all (window);
420 gtk_widget_destroy (window);
424 * Composited non-toplevel window
427 /* The expose event handler for the event box.
429 * This function simply draws a transparency onto a widget on the area
430 * for which it receives expose events. This is intended to give the
431 * event box a "transparent" background.
433 * In order for this to work properly, the widget must have an RGBA
434 * colourmap. The widget should also be set as app-paintable since it
435 * doesn't make sense for GTK to draw a background if we are drawing it
436 * (and because GTK might actually replace our transparency with its
437 * default background colour).
440 transparent_expose (GtkWidget *widget,
441 GdkEventExpose *event)
445 cr = gdk_cairo_create (widget->window);
446 cairo_set_operator (cr, CAIRO_OPERATOR_CLEAR);
447 gdk_cairo_region (cr, event->region);
454 /* The expose event handler for the window.
456 * This function performs the actual compositing of the event box onto
457 * the already-existing background of the window at 50% normal opacity.
459 * In this case we do not want app-paintable to be set on the widget
460 * since we want it to draw its own (red) background. Because of this,
461 * however, we must ensure that we use g_signal_register_after so that
462 * this handler is called after the red has been drawn. If it was
463 * called before then GTK would just blindly paint over our work.
466 window_expose_event (GtkWidget *widget,
467 GdkEventExpose *event)
473 /* get our child (in this case, the event box) */
474 child = gtk_bin_get_child (GTK_BIN (widget));
476 /* create a cairo context to draw to the window */
477 cr = gdk_cairo_create (widget->window);
479 /* the source data is the (composited) event box */
480 gdk_cairo_set_source_pixmap (cr, child->window,
482 child->allocation.y);
484 /* draw no more than our expose event intersects our child */
485 region = gdk_region_rectangle (&child->allocation);
486 gdk_region_intersect (region, event->region);
487 gdk_cairo_region (cr, region);
490 /* composite, with a 50% opacity */
491 cairo_set_operator (cr, CAIRO_OPERATOR_OVER);
492 cairo_paint_with_alpha (cr, 0.5);
501 create_composited_window (GtkWidget *widget)
503 static GtkWidget *window;
507 GtkWidget *event, *button;
512 /* make the widgets */
513 button = gtk_button_new_with_label ("A Button");
514 event = gtk_event_box_new ();
515 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
517 g_signal_connect (window, "destroy",
518 G_CALLBACK (gtk_widget_destroyed),
521 /* put a red background on the window */
522 gdk_color_parse ("red", &red);
523 gtk_widget_modify_bg (window, GTK_STATE_NORMAL, &red);
525 /* set the colourmap for the event box.
526 * must be done before the event box is realised.
528 screen = gtk_widget_get_screen (event);
529 rgba = gdk_screen_get_rgba_colormap (screen);
530 gtk_widget_set_colormap (event, rgba);
532 /* set our event box to have a fully-transparent background
533 * drawn on it. currently there is no way to simply tell gtk
534 * that "transparency" is the background colour for a widget.
536 gtk_widget_set_app_paintable (GTK_WIDGET (event), TRUE);
537 g_signal_connect (event, "expose-event",
538 G_CALLBACK (transparent_expose), NULL);
540 /* put them inside one another */
541 gtk_container_set_border_width (GTK_CONTAINER (window), 10);
542 gtk_container_add (GTK_CONTAINER (window), event);
543 gtk_container_add (GTK_CONTAINER (event), button);
545 /* realise and show everything */
546 gtk_widget_realize (button);
548 /* set the event box GdkWindow to be composited.
549 * obviously must be performed after event box is realised.
551 gdk_window_set_composited (event->window, TRUE);
553 /* set up the compositing handler.
554 * note that we do _after so that the normal (red) background is drawn
555 * by gtk before our compositing occurs.
557 g_signal_connect_after (window, "expose-event",
558 G_CALLBACK (window_expose_event), NULL);
561 if (!GTK_WIDGET_VISIBLE (window))
562 gtk_widget_show_all (window);
564 gtk_widget_destroy (window);
568 * Big windows and guffaw scrolling
572 pattern_expose (GtkWidget *widget,
573 GdkEventExpose *event,
577 GdkWindow *window = event->window;
579 color = g_object_get_data (G_OBJECT (window), "pattern-color");
582 GdkGC *tmp_gc = gdk_gc_new (window);
583 gdk_gc_set_rgb_fg_color (tmp_gc, color);
585 gdk_draw_rectangle (window, tmp_gc, TRUE,
586 event->area.x, event->area.y,
587 event->area.width, event->area.height);
589 g_object_unref (tmp_gc);
596 pattern_set_bg (GtkWidget *widget,
600 static const GdkColor colors[] = {
601 { 0, 0x4444, 0x4444, 0xffff },
602 { 0, 0x8888, 0x8888, 0xffff },
603 { 0, 0xaaaa, 0xaaaa, 0xffff }
606 g_object_set_data (G_OBJECT (child), "pattern-color", (gpointer) &colors[level]);
607 gdk_window_set_user_data (child, widget);
611 create_pattern (GtkWidget *widget,
622 while (2 * h <= height)
627 while (2 * w <= width)
629 if ((i + j) % 2 == 0)
634 GdkWindowAttr attributes;
636 attributes.window_type = GDK_WINDOW_CHILD;
639 attributes.width = w;
640 attributes.height = h;
641 attributes.wclass = GDK_INPUT_OUTPUT;
642 attributes.event_mask = GDK_EXPOSURE_MASK;
643 attributes.visual = gtk_widget_get_visual (widget);
644 attributes.colormap = gtk_widget_get_colormap (widget);
646 child = gdk_window_new (parent, &attributes,
647 GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP);
649 pattern_set_bg (widget, child, level);
652 create_pattern (widget, child, level + 1, w, h);
654 gdk_window_show (child);
664 #define PATTERN_SIZE (1 << 18)
667 pattern_hadj_changed (GtkAdjustment *adj,
670 gint *old_value = g_object_get_data (G_OBJECT (adj), "old-value");
671 gint new_value = adj->value;
673 if (GTK_WIDGET_REALIZED (darea))
675 gdk_window_scroll (darea->window, *old_value - new_value, 0);
676 *old_value = new_value;
681 pattern_vadj_changed (GtkAdjustment *adj,
684 gint *old_value = g_object_get_data (G_OBJECT (adj), "old-value");
685 gint new_value = adj->value;
687 if (GTK_WIDGET_REALIZED (darea))
689 gdk_window_scroll (darea->window, 0, *old_value - new_value);
690 *old_value = new_value;
695 pattern_realize (GtkWidget *widget,
698 pattern_set_bg (widget, widget->window, 0);
699 create_pattern (widget, widget->window, 1, PATTERN_SIZE, PATTERN_SIZE);
703 create_big_windows (GtkWidget *widget)
705 static GtkWidget *window = NULL;
706 GtkWidget *darea, *table, *scrollbar;
710 static gint current_x;
711 static gint current_y;
718 window = gtk_dialog_new_with_buttons ("Big Windows",
724 gtk_window_set_screen (GTK_WINDOW (window),
725 gtk_widget_get_screen (widget));
727 gtk_window_set_default_size (GTK_WINDOW (window), 200, 300);
729 g_signal_connect (window, "destroy",
730 G_CALLBACK (gtk_widget_destroyed),
733 g_signal_connect (window, "response",
734 G_CALLBACK (gtk_widget_destroy),
737 table = gtk_table_new (2, 2, FALSE);
738 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox),
739 table, TRUE, TRUE, 0);
741 darea = gtk_drawing_area_new ();
743 hadj = (GtkAdjustment *)gtk_adjustment_new (0, 0, PATTERN_SIZE, 10, 100, 100);
744 g_signal_connect (hadj, "value_changed",
745 G_CALLBACK (pattern_hadj_changed), darea);
746 g_object_set_data (G_OBJECT (hadj), "old-value", ¤t_x);
748 vadj = (GtkAdjustment *)gtk_adjustment_new (0, 0, PATTERN_SIZE, 10, 100, 100);
749 g_signal_connect (vadj, "value_changed",
750 G_CALLBACK (pattern_vadj_changed), darea);
751 g_object_set_data (G_OBJECT (vadj), "old-value", ¤t_y);
753 g_signal_connect (darea, "realize",
754 G_CALLBACK (pattern_realize),
756 g_signal_connect (darea, "expose_event",
757 G_CALLBACK (pattern_expose),
760 eventbox = gtk_event_box_new ();
761 gtk_table_attach (GTK_TABLE (table), eventbox,
763 GTK_FILL | GTK_EXPAND, GTK_FILL | GTK_EXPAND,
766 gtk_container_add (GTK_CONTAINER (eventbox), darea);
768 scrollbar = gtk_hscrollbar_new (hadj);
769 gtk_table_attach (GTK_TABLE (table), scrollbar,
771 GTK_FILL | GTK_EXPAND, GTK_FILL,
774 scrollbar = gtk_vscrollbar_new (vadj);
775 gtk_table_attach (GTK_TABLE (table), scrollbar,
777 GTK_FILL, GTK_EXPAND | GTK_FILL,
782 if (!GTK_WIDGET_VISIBLE (window))
783 gtk_widget_show_all (window);
785 gtk_widget_hide (window);
793 button_window (GtkWidget *widget,
796 if (!GTK_WIDGET_VISIBLE (button))
797 gtk_widget_show (button);
799 gtk_widget_hide (button);
803 create_buttons (GtkWidget *widget)
805 static GtkWidget *window = NULL;
809 GtkWidget *button[10];
810 GtkWidget *separator;
814 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
815 gtk_window_set_screen (GTK_WINDOW (window),
816 gtk_widget_get_screen (widget));
818 g_signal_connect (window, "destroy",
819 G_CALLBACK (gtk_widget_destroyed),
822 gtk_window_set_title (GTK_WINDOW (window), "GtkButton");
823 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
825 box1 = gtk_vbox_new (FALSE, 0);
826 gtk_container_add (GTK_CONTAINER (window), box1);
828 table = gtk_table_new (3, 3, FALSE);
829 gtk_table_set_row_spacings (GTK_TABLE (table), 5);
830 gtk_table_set_col_spacings (GTK_TABLE (table), 5);
831 gtk_container_set_border_width (GTK_CONTAINER (table), 10);
832 gtk_box_pack_start (GTK_BOX (box1), table, TRUE, TRUE, 0);
834 button[0] = gtk_button_new_with_label ("button1");
835 button[1] = gtk_button_new_with_mnemonic ("_button2");
836 button[2] = gtk_button_new_with_mnemonic ("_button3");
837 button[3] = gtk_button_new_from_stock (GTK_STOCK_OK);
838 button[4] = gtk_button_new_with_label ("button5");
839 button[5] = gtk_button_new_with_label ("button6");
840 button[6] = gtk_button_new_with_label ("button7");
841 button[7] = gtk_button_new_from_stock (GTK_STOCK_CLOSE);
842 button[8] = gtk_button_new_with_label ("button9");
844 g_signal_connect (button[0], "clicked",
845 G_CALLBACK (button_window),
848 gtk_table_attach (GTK_TABLE (table), button[0], 0, 1, 0, 1,
849 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
851 g_signal_connect (button[1], "clicked",
852 G_CALLBACK (button_window),
855 gtk_table_attach (GTK_TABLE (table), button[1], 1, 2, 1, 2,
856 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
858 g_signal_connect (button[2], "clicked",
859 G_CALLBACK (button_window),
861 gtk_table_attach (GTK_TABLE (table), button[2], 2, 3, 2, 3,
862 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
864 g_signal_connect (button[3], "clicked",
865 G_CALLBACK (button_window),
867 gtk_table_attach (GTK_TABLE (table), button[3], 0, 1, 2, 3,
868 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
870 g_signal_connect (button[4], "clicked",
871 G_CALLBACK (button_window),
873 gtk_table_attach (GTK_TABLE (table), button[4], 2, 3, 0, 1,
874 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
876 g_signal_connect (button[5], "clicked",
877 G_CALLBACK (button_window),
879 gtk_table_attach (GTK_TABLE (table), button[5], 1, 2, 2, 3,
880 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
882 g_signal_connect (button[6], "clicked",
883 G_CALLBACK (button_window),
885 gtk_table_attach (GTK_TABLE (table), button[6], 1, 2, 0, 1,
886 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
888 g_signal_connect (button[7], "clicked",
889 G_CALLBACK (button_window),
891 gtk_table_attach (GTK_TABLE (table), button[7], 2, 3, 1, 2,
892 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
894 g_signal_connect (button[8], "clicked",
895 G_CALLBACK (button_window),
897 gtk_table_attach (GTK_TABLE (table), button[8], 0, 1, 1, 2,
898 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
900 separator = gtk_hseparator_new ();
901 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
903 box2 = gtk_vbox_new (FALSE, 10);
904 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
905 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
907 button[9] = gtk_button_new_with_label ("close");
908 g_signal_connect_swapped (button[9], "clicked",
909 G_CALLBACK (gtk_widget_destroy),
911 gtk_box_pack_start (GTK_BOX (box2), button[9], TRUE, TRUE, 0);
912 GTK_WIDGET_SET_FLAGS (button[9], GTK_CAN_DEFAULT);
913 gtk_widget_grab_default (button[9]);
916 if (!GTK_WIDGET_VISIBLE (window))
917 gtk_widget_show_all (window);
919 gtk_widget_destroy (window);
927 create_toggle_buttons (GtkWidget *widget)
929 static GtkWidget *window = NULL;
933 GtkWidget *separator;
937 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
938 gtk_window_set_screen (GTK_WINDOW (window),
939 gtk_widget_get_screen (widget));
941 g_signal_connect (window, "destroy",
942 G_CALLBACK (gtk_widget_destroyed),
945 gtk_window_set_title (GTK_WINDOW (window), "GtkToggleButton");
946 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
948 box1 = gtk_vbox_new (FALSE, 0);
949 gtk_container_add (GTK_CONTAINER (window), box1);
951 box2 = gtk_vbox_new (FALSE, 10);
952 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
953 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
955 button = gtk_toggle_button_new_with_label ("button1");
956 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
958 button = gtk_toggle_button_new_with_label ("button2");
959 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
961 button = gtk_toggle_button_new_with_label ("button3");
962 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
964 button = gtk_toggle_button_new_with_label ("inconsistent");
965 gtk_toggle_button_set_inconsistent (GTK_TOGGLE_BUTTON (button), TRUE);
966 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
968 separator = gtk_hseparator_new ();
969 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
971 box2 = gtk_vbox_new (FALSE, 10);
972 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
973 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
975 button = gtk_button_new_with_label ("close");
976 g_signal_connect_swapped (button, "clicked",
977 G_CALLBACK (gtk_widget_destroy),
979 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
980 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
981 gtk_widget_grab_default (button);
984 if (!GTK_WIDGET_VISIBLE (window))
985 gtk_widget_show_all (window);
987 gtk_widget_destroy (window);
991 create_widget_grid (GType widget_type)
994 GtkWidget *group_widget = NULL;
997 table = gtk_table_new (FALSE, 3, 3);
999 for (i = 0; i < 5; i++)
1001 for (j = 0; j < 5; j++)
1006 if (i == 0 && j == 0)
1012 tmp = g_strdup_printf ("%d", j);
1013 widget = gtk_label_new (tmp);
1018 tmp = g_strdup_printf ("%c", 'A' + i - 1);
1019 widget = gtk_label_new (tmp);
1024 widget = g_object_new (widget_type, NULL);
1026 if (g_type_is_a (widget_type, GTK_TYPE_RADIO_BUTTON))
1029 group_widget = widget;
1031 g_object_set (widget, "group", group_widget, NULL);
1036 gtk_table_attach (GTK_TABLE (table), widget,
1051 create_check_buttons (GtkWidget *widget)
1053 static GtkWidget *window = NULL;
1057 GtkWidget *separator;
1062 window = gtk_dialog_new_with_buttons ("Check Buttons",
1068 gtk_window_set_screen (GTK_WINDOW (window),
1069 gtk_widget_get_screen (widget));
1071 g_signal_connect (window, "destroy",
1072 G_CALLBACK (gtk_widget_destroyed),
1074 g_signal_connect (window, "response",
1075 G_CALLBACK (gtk_widget_destroy),
1078 box1 = GTK_DIALOG (window)->vbox;
1080 box2 = gtk_vbox_new (FALSE, 10);
1081 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
1082 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
1084 button = gtk_check_button_new_with_mnemonic ("_button1");
1085 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
1087 button = gtk_check_button_new_with_label ("button2");
1088 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
1090 button = gtk_check_button_new_with_label ("button3");
1091 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
1093 button = gtk_check_button_new_with_label ("inconsistent");
1094 gtk_toggle_button_set_inconsistent (GTK_TOGGLE_BUTTON (button), TRUE);
1095 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
1097 separator = gtk_hseparator_new ();
1098 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
1100 table = create_widget_grid (GTK_TYPE_CHECK_BUTTON);
1101 gtk_container_set_border_width (GTK_CONTAINER (table), 10);
1102 gtk_box_pack_start (GTK_BOX (box1), table, TRUE, TRUE, 0);
1105 if (!GTK_WIDGET_VISIBLE (window))
1106 gtk_widget_show_all (window);
1108 gtk_widget_destroy (window);
1116 create_radio_buttons (GtkWidget *widget)
1118 static GtkWidget *window = NULL;
1122 GtkWidget *separator;
1127 window = gtk_dialog_new_with_buttons ("Radio Buttons",
1133 gtk_window_set_screen (GTK_WINDOW (window),
1134 gtk_widget_get_screen (widget));
1136 g_signal_connect (window, "destroy",
1137 G_CALLBACK (gtk_widget_destroyed),
1139 g_signal_connect (window, "response",
1140 G_CALLBACK (gtk_widget_destroy),
1143 box1 = GTK_DIALOG (window)->vbox;
1145 box2 = gtk_vbox_new (FALSE, 10);
1146 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
1147 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
1149 button = gtk_radio_button_new_with_label (NULL, "button1");
1150 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
1152 button = gtk_radio_button_new_with_label (
1153 gtk_radio_button_get_group (GTK_RADIO_BUTTON (button)),
1155 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
1156 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
1158 button = gtk_radio_button_new_with_label (
1159 gtk_radio_button_get_group (GTK_RADIO_BUTTON (button)),
1161 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
1163 button = gtk_radio_button_new_with_label (
1164 gtk_radio_button_get_group (GTK_RADIO_BUTTON (button)),
1166 gtk_toggle_button_set_inconsistent (GTK_TOGGLE_BUTTON (button), TRUE);
1167 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
1169 separator = gtk_hseparator_new ();
1170 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
1172 box2 = gtk_vbox_new (FALSE, 10);
1173 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
1174 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
1176 button = gtk_radio_button_new_with_label (NULL, "button4");
1177 gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (button), FALSE);
1178 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
1180 button = gtk_radio_button_new_with_label (
1181 gtk_radio_button_get_group (GTK_RADIO_BUTTON (button)),
1183 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
1184 gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (button), FALSE);
1185 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
1187 button = gtk_radio_button_new_with_label (
1188 gtk_radio_button_get_group (GTK_RADIO_BUTTON (button)),
1190 gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (button), FALSE);
1191 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
1193 separator = gtk_hseparator_new ();
1194 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
1196 table = create_widget_grid (GTK_TYPE_RADIO_BUTTON);
1197 gtk_container_set_border_width (GTK_CONTAINER (table), 10);
1198 gtk_box_pack_start (GTK_BOX (box1), table, TRUE, TRUE, 0);
1201 if (!GTK_WIDGET_VISIBLE (window))
1202 gtk_widget_show_all (window);
1204 gtk_widget_destroy (window);
1212 create_bbox (gint horizontal,
1223 frame = gtk_frame_new (title);
1226 bbox = gtk_hbutton_box_new ();
1228 bbox = gtk_vbutton_box_new ();
1230 gtk_container_set_border_width (GTK_CONTAINER (bbox), 5);
1231 gtk_container_add (GTK_CONTAINER (frame), bbox);
1233 gtk_button_box_set_layout (GTK_BUTTON_BOX (bbox), layout);
1234 gtk_box_set_spacing (GTK_BOX (bbox), spacing);
1235 gtk_button_box_set_child_size (GTK_BUTTON_BOX (bbox), child_w, child_h);
1237 button = gtk_button_new_with_label ("OK");
1238 gtk_container_add (GTK_CONTAINER (bbox), button);
1240 button = gtk_button_new_with_label ("Cancel");
1241 gtk_container_add (GTK_CONTAINER (bbox), button);
1243 button = gtk_button_new_with_label ("Help");
1244 gtk_container_add (GTK_CONTAINER (bbox), button);
1250 create_button_box (GtkWidget *widget)
1252 static GtkWidget* window = NULL;
1253 GtkWidget *main_vbox;
1256 GtkWidget *frame_horz;
1257 GtkWidget *frame_vert;
1261 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
1262 gtk_window_set_screen (GTK_WINDOW (window), gtk_widget_get_screen (widget));
1263 gtk_window_set_title (GTK_WINDOW (window), "Button Boxes");
1265 g_signal_connect (window, "destroy",
1266 G_CALLBACK (gtk_widget_destroyed),
1269 gtk_container_set_border_width (GTK_CONTAINER (window), 10);
1271 main_vbox = gtk_vbox_new (FALSE, 0);
1272 gtk_container_add (GTK_CONTAINER (window), main_vbox);
1274 frame_horz = gtk_frame_new ("Horizontal Button Boxes");
1275 gtk_box_pack_start (GTK_BOX (main_vbox), frame_horz, TRUE, TRUE, 10);
1277 vbox = gtk_vbox_new (FALSE, 0);
1278 gtk_container_set_border_width (GTK_CONTAINER (vbox), 10);
1279 gtk_container_add (GTK_CONTAINER (frame_horz), vbox);
1281 gtk_box_pack_start (GTK_BOX (vbox),
1282 create_bbox (TRUE, "Spread", 40, 85, 20, GTK_BUTTONBOX_SPREAD),
1285 gtk_box_pack_start (GTK_BOX (vbox),
1286 create_bbox (TRUE, "Edge", 40, 85, 20, GTK_BUTTONBOX_EDGE),
1289 gtk_box_pack_start (GTK_BOX (vbox),
1290 create_bbox (TRUE, "Start", 40, 85, 20, GTK_BUTTONBOX_START),
1293 gtk_box_pack_start (GTK_BOX (vbox),
1294 create_bbox (TRUE, "End", 40, 85, 20, GTK_BUTTONBOX_END),
1297 gtk_box_pack_start (GTK_BOX (vbox),
1298 create_bbox (TRUE, "Center", 40, 85, 20, GTK_BUTTONBOX_CENTER),
1301 frame_vert = gtk_frame_new ("Vertical Button Boxes");
1302 gtk_box_pack_start (GTK_BOX (main_vbox), frame_vert, TRUE, TRUE, 10);
1304 hbox = gtk_hbox_new (FALSE, 0);
1305 gtk_container_set_border_width (GTK_CONTAINER (hbox), 10);
1306 gtk_container_add (GTK_CONTAINER (frame_vert), hbox);
1308 gtk_box_pack_start (GTK_BOX (hbox),
1309 create_bbox (FALSE, "Spread", 30, 85, 20, GTK_BUTTONBOX_SPREAD),
1312 gtk_box_pack_start (GTK_BOX (hbox),
1313 create_bbox (FALSE, "Edge", 30, 85, 20, GTK_BUTTONBOX_EDGE),
1316 gtk_box_pack_start (GTK_BOX (hbox),
1317 create_bbox (FALSE, "Start", 30, 85, 20, GTK_BUTTONBOX_START),
1320 gtk_box_pack_start (GTK_BOX (hbox),
1321 create_bbox (FALSE, "End", 30, 85, 20, GTK_BUTTONBOX_END),
1324 gtk_box_pack_start (GTK_BOX (hbox),
1325 create_bbox (FALSE, "Center", 30, 85, 20, GTK_BUTTONBOX_CENTER),
1329 if (!GTK_WIDGET_VISIBLE (window))
1330 gtk_widget_show_all (window);
1332 gtk_widget_destroy (window);
1340 new_pixmap (char *filename,
1342 GdkColor *background)
1348 if (strcmp (filename, "test.xpm") == 0 ||
1349 !file_exists (filename))
1351 pixmap = gdk_pixmap_create_from_xpm_d (window, &mask,
1356 pixmap = gdk_pixmap_create_from_xpm (window, &mask,
1360 wpixmap = gtk_image_new_from_pixmap (pixmap, mask);
1367 set_toolbar_small_stock (GtkWidget *widget,
1370 gtk_toolbar_set_icon_size (GTK_TOOLBAR (data), GTK_ICON_SIZE_SMALL_TOOLBAR);
1374 set_toolbar_large_stock (GtkWidget *widget,
1377 gtk_toolbar_set_icon_size (GTK_TOOLBAR (data), GTK_ICON_SIZE_LARGE_TOOLBAR);
1381 set_toolbar_horizontal (GtkWidget *widget,
1384 gtk_toolbar_set_orientation (GTK_TOOLBAR (data), GTK_ORIENTATION_HORIZONTAL);
1388 set_toolbar_vertical (GtkWidget *widget,
1391 gtk_toolbar_set_orientation (GTK_TOOLBAR (data), GTK_ORIENTATION_VERTICAL);
1395 set_toolbar_icons (GtkWidget *widget,
1398 gtk_toolbar_set_style (GTK_TOOLBAR (data), GTK_TOOLBAR_ICONS);
1402 set_toolbar_text (GtkWidget *widget,
1405 gtk_toolbar_set_style (GTK_TOOLBAR (data), GTK_TOOLBAR_TEXT);
1409 set_toolbar_both (GtkWidget *widget,
1412 gtk_toolbar_set_style (GTK_TOOLBAR (data), GTK_TOOLBAR_BOTH);
1416 set_toolbar_both_horiz (GtkWidget *widget,
1419 gtk_toolbar_set_style (GTK_TOOLBAR (data), GTK_TOOLBAR_BOTH_HORIZ);
1423 set_toolbar_enable (GtkWidget *widget,
1426 gtk_toolbar_set_tooltips (GTK_TOOLBAR (data), TRUE);
1430 set_toolbar_disable (GtkWidget *widget,
1433 gtk_toolbar_set_tooltips (GTK_TOOLBAR (data), FALSE);
1437 create_toolbar (GtkWidget *widget)
1439 static GtkWidget *window = NULL;
1445 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
1446 gtk_window_set_screen (GTK_WINDOW (window),
1447 gtk_widget_get_screen (widget));
1449 gtk_window_set_title (GTK_WINDOW (window), "Toolbar test");
1451 g_signal_connect (window, "destroy",
1452 G_CALLBACK (gtk_widget_destroyed),
1455 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
1456 gtk_widget_realize (window);
1458 toolbar = gtk_toolbar_new ();
1460 gtk_toolbar_insert_stock (GTK_TOOLBAR (toolbar),
1462 "Stock icon: New", "Toolbar/New",
1463 G_CALLBACK (set_toolbar_small_stock), toolbar, -1);
1465 gtk_toolbar_insert_stock (GTK_TOOLBAR (toolbar),
1467 "Stock icon: Open", "Toolbar/Open",
1468 G_CALLBACK (set_toolbar_large_stock), toolbar, -1);
1470 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
1471 "Horizontal", "Horizontal toolbar layout", "Toolbar/Horizontal",
1472 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
1473 G_CALLBACK (set_toolbar_horizontal), toolbar);
1474 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
1475 "Vertical", "Vertical toolbar layout", "Toolbar/Vertical",
1476 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
1477 G_CALLBACK (set_toolbar_vertical), toolbar);
1479 gtk_toolbar_append_space (GTK_TOOLBAR(toolbar));
1481 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
1482 "Icons", "Only show toolbar icons", "Toolbar/IconsOnly",
1483 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
1484 G_CALLBACK (set_toolbar_icons), toolbar);
1485 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
1486 "Text", "Only show toolbar text", "Toolbar/TextOnly",
1487 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
1488 G_CALLBACK (set_toolbar_text), toolbar);
1489 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
1490 "Both", "Show toolbar icons and text", "Toolbar/Both",
1491 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
1492 G_CALLBACK (set_toolbar_both), toolbar);
1493 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
1494 "Both (horizontal)",
1495 "Show toolbar icons and text in a horizontal fashion",
1496 "Toolbar/BothHoriz",
1497 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
1498 G_CALLBACK (set_toolbar_both_horiz), toolbar);
1500 gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
1502 entry = gtk_entry_new ();
1504 gtk_toolbar_append_widget (GTK_TOOLBAR (toolbar), entry, "This is an unusable GtkEntry ;)", "Hey don't click me!!!");
1506 gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
1509 gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
1511 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
1512 "Enable", "Enable tooltips", NULL,
1513 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
1514 G_CALLBACK (set_toolbar_enable), toolbar);
1515 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
1516 "Disable", "Disable tooltips", NULL,
1517 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
1518 G_CALLBACK (set_toolbar_disable), toolbar);
1520 gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
1522 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
1523 "Frobate", "Frobate tooltip", NULL,
1524 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
1526 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
1527 "Baz", "Baz tooltip", NULL,
1528 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
1531 gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
1533 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
1534 "Blah", "Blah tooltip", NULL,
1535 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
1537 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
1538 "Bar", "Bar tooltip", NULL,
1539 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
1542 gtk_container_add (GTK_CONTAINER (window), toolbar);
1544 gtk_widget_set_size_request (toolbar, 200, -1);
1547 if (!GTK_WIDGET_VISIBLE (window))
1548 gtk_widget_show_all (window);
1550 gtk_widget_destroy (window);
1554 make_toolbar (GtkWidget *window)
1558 if (!GTK_WIDGET_REALIZED (window))
1559 gtk_widget_realize (window);
1561 toolbar = gtk_toolbar_new ();
1563 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
1564 "Horizontal", "Horizontal toolbar layout", NULL,
1565 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
1566 G_CALLBACK (set_toolbar_horizontal), toolbar);
1567 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
1568 "Vertical", "Vertical toolbar layout", NULL,
1569 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
1570 G_CALLBACK (set_toolbar_vertical), toolbar);
1572 gtk_toolbar_append_space (GTK_TOOLBAR(toolbar));
1574 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
1575 "Icons", "Only show toolbar icons", NULL,
1576 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
1577 G_CALLBACK (set_toolbar_icons), toolbar);
1578 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
1579 "Text", "Only show toolbar text", NULL,
1580 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
1581 G_CALLBACK (set_toolbar_text), toolbar);
1582 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
1583 "Both", "Show toolbar icons and text", NULL,
1584 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
1585 G_CALLBACK (set_toolbar_both), toolbar);
1587 gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
1589 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
1590 "Woot", "Woot woot woot", NULL,
1591 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
1593 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
1594 "Blah", "Blah blah blah", "Toolbar/Big",
1595 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
1598 gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
1600 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
1601 "Enable", "Enable tooltips", NULL,
1602 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
1603 G_CALLBACK (set_toolbar_enable), toolbar);
1604 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
1605 "Disable", "Disable tooltips", NULL,
1606 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
1607 G_CALLBACK (set_toolbar_disable), toolbar);
1609 gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
1611 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
1612 "Hoo", "Hoo tooltip", NULL,
1613 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
1615 gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
1616 "Woo", "Woo tooltip", NULL,
1617 new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
1627 static guint statusbar_counter = 1;
1630 statusbar_push (GtkWidget *button,
1631 GtkStatusbar *statusbar)
1635 sprintf (text, "something %d", statusbar_counter++);
1637 gtk_statusbar_push (statusbar, 1, text);
1641 statusbar_push_long (GtkWidget *button,
1642 GtkStatusbar *statusbar)
1646 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\").");
1648 gtk_statusbar_push (statusbar, 1, text);
1652 statusbar_pop (GtkWidget *button,
1653 GtkStatusbar *statusbar)
1655 gtk_statusbar_pop (statusbar, 1);
1659 statusbar_steal (GtkWidget *button,
1660 GtkStatusbar *statusbar)
1662 gtk_statusbar_remove (statusbar, 1, 4);
1666 statusbar_popped (GtkStatusbar *statusbar,
1670 if (!statusbar->messages)
1671 statusbar_counter = 1;
1675 statusbar_contexts (GtkStatusbar *statusbar)
1679 string = "any context";
1680 g_print ("GtkStatusBar: context=\"%s\", context_id=%d\n",
1682 gtk_statusbar_get_context_id (statusbar, string));
1684 string = "idle messages";
1685 g_print ("GtkStatusBar: context=\"%s\", context_id=%d\n",
1687 gtk_statusbar_get_context_id (statusbar, string));
1689 string = "some text";
1690 g_print ("GtkStatusBar: context=\"%s\", context_id=%d\n",
1692 gtk_statusbar_get_context_id (statusbar, string));
1694 string = "hit the mouse";
1695 g_print ("GtkStatusBar: context=\"%s\", context_id=%d\n",
1697 gtk_statusbar_get_context_id (statusbar, string));
1699 string = "hit the mouse2";
1700 g_print ("GtkStatusBar: context=\"%s\", context_id=%d\n",
1702 gtk_statusbar_get_context_id (statusbar, string));
1706 create_statusbar (GtkWidget *widget)
1708 static GtkWidget *window = NULL;
1712 GtkWidget *separator;
1713 GtkWidget *statusbar;
1717 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
1718 gtk_window_set_screen (GTK_WINDOW (window),
1719 gtk_widget_get_screen (widget));
1721 g_signal_connect (window, "destroy",
1722 G_CALLBACK (gtk_widget_destroyed),
1725 gtk_window_set_title (GTK_WINDOW (window), "statusbar");
1726 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
1728 box1 = gtk_vbox_new (FALSE, 0);
1729 gtk_container_add (GTK_CONTAINER (window), box1);
1731 box2 = gtk_vbox_new (FALSE, 10);
1732 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
1733 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
1735 statusbar = gtk_statusbar_new ();
1736 gtk_box_pack_end (GTK_BOX (box1), statusbar, TRUE, TRUE, 0);
1737 g_signal_connect (statusbar,
1739 G_CALLBACK (statusbar_popped),
1742 button = gtk_widget_new (gtk_button_get_type (),
1743 "label", "push something",
1747 g_object_connect (button,
1748 "signal::clicked", statusbar_push, statusbar,
1751 button = g_object_connect (gtk_widget_new (gtk_button_get_type (),
1756 "signal_after::clicked", statusbar_pop, statusbar,
1759 button = g_object_connect (gtk_widget_new (gtk_button_get_type (),
1760 "label", "steal #4",
1764 "signal_after::clicked", statusbar_steal, statusbar,
1767 button = g_object_connect (gtk_widget_new (gtk_button_get_type (),
1768 "label", "test contexts",
1772 "swapped_signal_after::clicked", statusbar_contexts, statusbar,
1775 button = g_object_connect (gtk_widget_new (gtk_button_get_type (),
1776 "label", "push something long",
1780 "signal_after::clicked", statusbar_push_long, statusbar,
1783 separator = gtk_hseparator_new ();
1784 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
1786 box2 = gtk_vbox_new (FALSE, 10);
1787 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
1788 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
1790 button = gtk_button_new_with_label ("close");
1791 g_signal_connect_swapped (button, "clicked",
1792 G_CALLBACK (gtk_widget_destroy),
1794 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
1795 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
1796 gtk_widget_grab_default (button);
1799 if (!GTK_WIDGET_VISIBLE (window))
1800 gtk_widget_show_all (window);
1802 gtk_widget_destroy (window);
1810 cb_tree_destroy_event(GtkWidget* w)
1812 sTreeButtons* tree_buttons;
1814 /* free buttons structure associate at this tree */
1815 tree_buttons = g_object_get_data (G_OBJECT (w), "user_data");
1816 g_free (tree_buttons);
1820 cb_add_new_item(GtkWidget* w, GtkTree* tree)
1822 sTreeButtons* tree_buttons;
1823 GList* selected_list;
1824 GtkWidget* selected_item;
1826 GtkWidget* item_new;
1829 tree_buttons = g_object_get_data (G_OBJECT (tree), "user_data");
1831 selected_list = GTK_TREE_SELECTION_OLD(tree);
1833 if(selected_list == NULL)
1835 /* there is no item in tree */
1836 subtree = GTK_WIDGET(tree);
1840 /* list can have only one element */
1841 selected_item = GTK_WIDGET(selected_list->data);
1843 subtree = GTK_TREE_ITEM_SUBTREE(selected_item);
1847 /* current selected item have not subtree ... create it */
1848 subtree = gtk_tree_new();
1849 gtk_tree_item_set_subtree(GTK_TREE_ITEM(selected_item),
1854 /* at this point, we know which subtree will be used to add new item */
1855 /* create a new item */
1856 sprintf(buffer, "item add %d", tree_buttons->nb_item_add);
1857 item_new = gtk_tree_item_new_with_label(buffer);
1858 gtk_tree_append(GTK_TREE(subtree), item_new);
1859 gtk_widget_show(item_new);
1861 tree_buttons->nb_item_add++;
1865 cb_remove_item(GtkWidget*w, GtkTree* tree)
1867 GList* selected_list;
1870 selected_list = GTK_TREE_SELECTION_OLD(tree);
1874 while (selected_list)
1876 clear_list = g_list_prepend (clear_list, selected_list->data);
1877 selected_list = selected_list->next;
1880 clear_list = g_list_reverse (clear_list);
1881 gtk_tree_remove_items(tree, clear_list);
1883 g_list_free (clear_list);
1887 cb_remove_subtree(GtkWidget*w, GtkTree* tree)
1889 GList* selected_list;
1892 selected_list = GTK_TREE_SELECTION_OLD(tree);
1896 item = GTK_TREE_ITEM (selected_list->data);
1898 gtk_tree_item_remove_subtree (item);
1903 cb_tree_changed(GtkTree* tree)
1905 sTreeButtons* tree_buttons;
1906 GList* selected_list;
1909 tree_buttons = g_object_get_data (G_OBJECT (tree), "user_data");
1911 selected_list = GTK_TREE_SELECTION_OLD(tree);
1912 nb_selected = g_list_length(selected_list);
1914 if(nb_selected == 0)
1916 if(tree->children == NULL)
1917 gtk_widget_set_sensitive(tree_buttons->add_button, TRUE);
1919 gtk_widget_set_sensitive(tree_buttons->add_button, FALSE);
1920 gtk_widget_set_sensitive(tree_buttons->remove_button, FALSE);
1921 gtk_widget_set_sensitive(tree_buttons->subtree_button, FALSE);
1925 gtk_widget_set_sensitive(tree_buttons->remove_button, TRUE);
1926 gtk_widget_set_sensitive(tree_buttons->add_button, (nb_selected == 1));
1927 gtk_widget_set_sensitive(tree_buttons->subtree_button, (nb_selected == 1));
1932 create_subtree(GtkWidget* item, guint level, guint nb_item_max, guint recursion_level_max)
1934 GtkWidget* item_subtree;
1935 GtkWidget* item_new;
1940 if(level == recursion_level_max) return;
1944 /* query with no root item */
1946 item_subtree = item;
1951 /* query with no root item */
1952 /* create subtree and associate it with current item */
1953 item_subtree = gtk_tree_new();
1957 for(nb_item = 0; nb_item < nb_item_max; nb_item++)
1959 sprintf(buffer, "item %d-%d", level, nb_item);
1960 item_new = gtk_tree_item_new_with_label(buffer);
1961 gtk_tree_append(GTK_TREE(item_subtree), item_new);
1962 create_subtree(item_new, level+1, nb_item_max, recursion_level_max);
1963 gtk_widget_show(item_new);
1967 gtk_tree_item_set_subtree(GTK_TREE_ITEM(item), item_subtree);
1971 create_tree_sample(GdkScreen *screen, guint selection_mode,
1972 guint draw_line, guint view_line, guint no_root_item,
1973 guint nb_item_max, guint recursion_level_max)
1978 GtkWidget* separator;
1980 GtkWidget* scrolled_win;
1981 GtkWidget* root_tree;
1982 GtkWidget* root_item;
1983 sTreeButtons* tree_buttons;
1985 /* create tree buttons struct */
1986 if ((tree_buttons = g_malloc (sizeof (sTreeButtons))) == NULL)
1988 g_error("can't allocate memory for tree structure !\n");
1991 tree_buttons->nb_item_add = 0;
1993 /* create top level window */
1994 window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
1995 gtk_window_set_screen (GTK_WINDOW (window), screen);
1996 gtk_window_set_title(GTK_WINDOW(window), "Tree Sample");
1997 g_signal_connect (window, "destroy",
1998 G_CALLBACK (cb_tree_destroy_event), NULL);
1999 g_object_set_data (G_OBJECT (window), "user_data", tree_buttons);
2001 box1 = gtk_vbox_new(FALSE, 0);
2002 gtk_container_add(GTK_CONTAINER(window), box1);
2003 gtk_widget_show(box1);
2005 /* create tree box */
2006 box2 = gtk_vbox_new(FALSE, 0);
2007 gtk_box_pack_start(GTK_BOX(box1), box2, TRUE, TRUE, 0);
2008 gtk_container_set_border_width(GTK_CONTAINER(box2), 5);
2009 gtk_widget_show(box2);
2011 /* create scrolled window */
2012 scrolled_win = gtk_scrolled_window_new (NULL, NULL);
2013 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
2014 GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
2015 gtk_box_pack_start (GTK_BOX (box2), scrolled_win, TRUE, TRUE, 0);
2016 gtk_widget_set_size_request (scrolled_win, 200, 200);
2017 gtk_widget_show (scrolled_win);
2019 /* create root tree widget */
2020 root_tree = gtk_tree_new();
2021 g_signal_connect (root_tree, "selection_changed",
2022 G_CALLBACK (cb_tree_changed),
2024 g_object_set_data (G_OBJECT (root_tree), "user_data", tree_buttons);
2025 gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (scrolled_win), root_tree);
2026 gtk_tree_set_selection_mode(GTK_TREE(root_tree), selection_mode);
2027 gtk_tree_set_view_lines(GTK_TREE(root_tree), draw_line);
2028 gtk_tree_set_view_mode(GTK_TREE(root_tree), !view_line);
2029 gtk_widget_show(root_tree);
2033 /* set root tree to subtree function with root item variable */
2034 root_item = GTK_WIDGET(root_tree);
2038 /* create root tree item widget */
2039 root_item = gtk_tree_item_new_with_label("root item");
2040 gtk_tree_append(GTK_TREE(root_tree), root_item);
2041 gtk_widget_show(root_item);
2043 create_subtree(root_item, -no_root_item, nb_item_max, recursion_level_max);
2045 box2 = gtk_vbox_new(FALSE, 0);
2046 gtk_box_pack_start(GTK_BOX(box1), box2, FALSE, FALSE, 0);
2047 gtk_container_set_border_width(GTK_CONTAINER(box2), 5);
2048 gtk_widget_show(box2);
2050 button = gtk_button_new_with_label("Add Item");
2051 gtk_widget_set_sensitive(button, FALSE);
2052 g_signal_connect (button, "clicked",
2053 G_CALLBACK (cb_add_new_item),
2055 gtk_box_pack_start(GTK_BOX(box2), button, TRUE, TRUE, 0);
2056 gtk_widget_show(button);
2057 tree_buttons->add_button = button;
2059 button = gtk_button_new_with_label("Remove Item(s)");
2060 gtk_widget_set_sensitive(button, FALSE);
2061 g_signal_connect (button, "clicked",
2062 G_CALLBACK (cb_remove_item),
2064 gtk_box_pack_start(GTK_BOX(box2), button, TRUE, TRUE, 0);
2065 gtk_widget_show(button);
2066 tree_buttons->remove_button = button;
2068 button = gtk_button_new_with_label("Remove Subtree");
2069 gtk_widget_set_sensitive(button, FALSE);
2070 g_signal_connect (button, "clicked",
2071 G_CALLBACK (cb_remove_subtree),
2073 gtk_box_pack_start(GTK_BOX(box2), button, TRUE, TRUE, 0);
2074 gtk_widget_show(button);
2075 tree_buttons->subtree_button = button;
2077 /* create separator */
2078 separator = gtk_hseparator_new();
2079 gtk_box_pack_start(GTK_BOX(box1), separator, FALSE, FALSE, 0);
2080 gtk_widget_show(separator);
2082 /* create button box */
2083 box2 = gtk_vbox_new(FALSE, 0);
2084 gtk_box_pack_start(GTK_BOX(box1), box2, FALSE, FALSE, 0);
2085 gtk_container_set_border_width(GTK_CONTAINER(box2), 5);
2086 gtk_widget_show(box2);
2088 button = gtk_button_new_with_label("Close");
2089 gtk_box_pack_start(GTK_BOX(box2), button, TRUE, TRUE, 0);
2090 g_signal_connect_swapped (button, "clicked",
2091 G_CALLBACK (gtk_widget_destroy),
2093 gtk_widget_show(button);
2095 gtk_widget_show(window);
2099 cb_create_tree(GtkWidget* w)
2101 guint selection_mode = GTK_SELECTION_SINGLE;
2106 guint recursion_level;
2108 /* get selection mode choice */
2109 if(GTK_TOGGLE_BUTTON(sTreeSampleSelection.single_button)->active)
2110 selection_mode = GTK_SELECTION_SINGLE;
2112 if(GTK_TOGGLE_BUTTON(sTreeSampleSelection.browse_button)->active)
2113 selection_mode = GTK_SELECTION_BROWSE;
2115 selection_mode = GTK_SELECTION_MULTIPLE;
2117 /* get options choice */
2118 draw_line = GTK_TOGGLE_BUTTON(sTreeSampleSelection.draw_line_button)->active;
2119 view_line = GTK_TOGGLE_BUTTON(sTreeSampleSelection.view_line_button)->active;
2120 no_root_item = GTK_TOGGLE_BUTTON(sTreeSampleSelection.no_root_item_button)->active;
2123 nb_item = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(sTreeSampleSelection.nb_item_spinner));
2124 recursion_level = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(sTreeSampleSelection.recursion_spinner));
2126 if (pow (nb_item, recursion_level) > 10000)
2128 g_print ("%g total items? That will take a very long time. Try less\n",
2129 pow (nb_item, recursion_level));
2133 create_tree_sample(gtk_widget_get_screen (w),
2134 selection_mode, draw_line,
2135 view_line, no_root_item, nb_item, recursion_level);
2139 create_tree_mode_window(GtkWidget *widget)
2141 static GtkWidget* window;
2149 GtkWidget* separator;
2156 /* create toplevel window */
2157 window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
2158 gtk_window_set_screen (GTK_WINDOW (window),
2159 gtk_widget_get_screen (widget));
2160 gtk_window_set_title(GTK_WINDOW(window), "Set Tree Parameters");
2161 g_signal_connect (window, "destroy",
2162 G_CALLBACK (gtk_widget_destroyed),
2164 box1 = gtk_vbox_new(FALSE, 0);
2165 gtk_container_add(GTK_CONTAINER(window), box1);
2167 /* create upper box - selection box */
2168 box2 = gtk_vbox_new(FALSE, 5);
2169 gtk_box_pack_start(GTK_BOX(box1), box2, TRUE, TRUE, 0);
2170 gtk_container_set_border_width(GTK_CONTAINER(box2), 5);
2172 box3 = gtk_hbox_new(FALSE, 5);
2173 gtk_box_pack_start(GTK_BOX(box2), box3, TRUE, TRUE, 0);
2175 /* create selection mode frame */
2176 frame = gtk_frame_new("Selection Mode");
2177 gtk_box_pack_start(GTK_BOX(box3), frame, TRUE, TRUE, 0);
2179 box4 = gtk_vbox_new(FALSE, 0);
2180 gtk_container_add(GTK_CONTAINER(frame), box4);
2181 gtk_container_set_border_width(GTK_CONTAINER(box4), 5);
2183 /* create radio button */
2184 button = gtk_radio_button_new_with_label(NULL, "SINGLE");
2185 gtk_box_pack_start(GTK_BOX(box4), button, TRUE, TRUE, 0);
2186 sTreeSampleSelection.single_button = button;
2188 button = gtk_radio_button_new_with_label(gtk_radio_button_get_group (GTK_RADIO_BUTTON (button)),
2190 gtk_box_pack_start(GTK_BOX(box4), button, TRUE, TRUE, 0);
2191 sTreeSampleSelection.browse_button = button;
2193 button = gtk_radio_button_new_with_label(gtk_radio_button_get_group (GTK_RADIO_BUTTON (button)),
2195 gtk_box_pack_start(GTK_BOX(box4), button, TRUE, TRUE, 0);
2196 sTreeSampleSelection.multiple_button = button;
2198 sTreeSampleSelection.selection_mode_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (button));
2200 /* create option mode frame */
2201 frame = gtk_frame_new("Options");
2202 gtk_box_pack_start(GTK_BOX(box3), frame, TRUE, TRUE, 0);
2204 box4 = gtk_vbox_new(FALSE, 0);
2205 gtk_container_add(GTK_CONTAINER(frame), box4);
2206 gtk_container_set_border_width(GTK_CONTAINER(box4), 5);
2208 /* create check button */
2209 button = gtk_check_button_new_with_label("Draw line");
2210 gtk_box_pack_start(GTK_BOX(box4), button, TRUE, TRUE, 0);
2211 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), TRUE);
2212 sTreeSampleSelection.draw_line_button = button;
2214 button = gtk_check_button_new_with_label("View Line mode");
2215 gtk_box_pack_start(GTK_BOX(box4), button, TRUE, TRUE, 0);
2216 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), TRUE);
2217 sTreeSampleSelection.view_line_button = button;
2219 button = gtk_check_button_new_with_label("Without Root item");
2220 gtk_box_pack_start(GTK_BOX(box4), button, TRUE, TRUE, 0);
2221 sTreeSampleSelection.no_root_item_button = button;
2223 /* create recursion parameter */
2224 frame = gtk_frame_new("Size Parameters");
2225 gtk_box_pack_start(GTK_BOX(box2), frame, TRUE, TRUE, 0);
2227 box4 = gtk_hbox_new(FALSE, 5);
2228 gtk_container_add(GTK_CONTAINER(frame), box4);
2229 gtk_container_set_border_width(GTK_CONTAINER(box4), 5);
2231 /* create number of item spin button */
2232 box5 = gtk_hbox_new(FALSE, 5);
2233 gtk_box_pack_start(GTK_BOX(box4), box5, FALSE, FALSE, 0);
2235 label = gtk_label_new("Number of items : ");
2236 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
2237 gtk_box_pack_start (GTK_BOX (box5), label, FALSE, TRUE, 0);
2239 adj = (GtkAdjustment *) gtk_adjustment_new (DEFAULT_NUMBER_OF_ITEM, 1.0, 255.0, 1.0,
2241 spinner = gtk_spin_button_new (adj, 0, 0);
2242 gtk_box_pack_start (GTK_BOX (box5), spinner, FALSE, TRUE, 0);
2243 sTreeSampleSelection.nb_item_spinner = spinner;
2245 /* create recursion level spin button */
2246 box5 = gtk_hbox_new(FALSE, 5);
2247 gtk_box_pack_start(GTK_BOX(box4), box5, FALSE, FALSE, 0);
2249 label = gtk_label_new("Depth : ");
2250 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
2251 gtk_box_pack_start (GTK_BOX (box5), label, FALSE, TRUE, 0);
2253 adj = (GtkAdjustment *) gtk_adjustment_new (DEFAULT_RECURSION_LEVEL, 0.0, 255.0, 1.0,
2255 spinner = gtk_spin_button_new (adj, 0, 0);
2256 gtk_box_pack_start (GTK_BOX (box5), spinner, FALSE, TRUE, 0);
2257 sTreeSampleSelection.recursion_spinner = spinner;
2259 /* create horizontal separator */
2260 separator = gtk_hseparator_new();
2261 gtk_box_pack_start(GTK_BOX(box1), separator, FALSE, FALSE, 0);
2263 /* create bottom button box */
2264 box2 = gtk_hbox_new(TRUE, 10);
2265 gtk_box_pack_start(GTK_BOX(box1), box2, FALSE, FALSE, 0);
2266 gtk_container_set_border_width(GTK_CONTAINER(box2), 5);
2268 button = gtk_button_new_with_label("Create Tree");
2269 gtk_box_pack_start(GTK_BOX(box2), button, TRUE, TRUE, 0);
2270 g_signal_connect (button, "clicked",
2271 G_CALLBACK (cb_create_tree), NULL);
2273 button = gtk_button_new_with_label("Close");
2274 gtk_box_pack_start(GTK_BOX(box2), button, TRUE, TRUE, 0);
2275 g_signal_connect_swapped (button, "clicked",
2276 G_CALLBACK (gtk_widget_destroy),
2279 if (!GTK_WIDGET_VISIBLE (window))
2280 gtk_widget_show_all (window);
2282 gtk_widget_destroy (window);
2288 #define GRID_SIZE 20
2289 #define DEFAULT_GEOMETRY "10x10"
2292 gridded_geometry_expose (GtkWidget *widget,
2293 GdkEventExpose *event)
2297 gdk_draw_rectangle (widget->window, widget->style->base_gc[widget->state], TRUE,
2298 0, 0, widget->allocation.width, widget->allocation.height);
2300 for (i = 0 ; i * GRID_SIZE < widget->allocation.width; i++)
2301 for (j = 0 ; j * GRID_SIZE < widget->allocation.height; j++)
2303 if ((i + j) % 2 == 0)
2304 gdk_draw_rectangle (widget->window, widget->style->text_gc[widget->state], TRUE,
2305 i * GRID_SIZE, j * GRID_SIZE, GRID_SIZE, GRID_SIZE);
2312 gridded_geometry_subresponse (GtkDialog *dialog,
2314 gchar *geometry_string)
2316 if (response_id == GTK_RESPONSE_NONE)
2318 gtk_widget_destroy (GTK_WIDGET (dialog));
2322 if (!gtk_window_parse_geometry (GTK_WINDOW (dialog), geometry_string))
2324 g_print ("Can't parse geometry string %s\n", geometry_string);
2325 gtk_window_parse_geometry (GTK_WINDOW (dialog), DEFAULT_GEOMETRY);
2331 gridded_geometry_response (GtkDialog *dialog,
2335 if (response_id == GTK_RESPONSE_NONE)
2337 gtk_widget_destroy (GTK_WIDGET (dialog));
2341 gchar *geometry_string = g_strdup (gtk_entry_get_text (entry));
2342 gchar *title = g_strdup_printf ("Gridded window at: %s", geometry_string);
2344 GtkWidget *drawing_area;
2346 GdkGeometry geometry;
2348 window = gtk_dialog_new_with_buttons (title,
2351 GTK_STOCK_CLOSE, GTK_RESPONSE_NONE,
2354 gtk_window_set_screen (GTK_WINDOW (window),
2355 gtk_widget_get_screen (GTK_WIDGET (dialog)));
2357 g_signal_connect (window, "response",
2358 G_CALLBACK (gridded_geometry_subresponse), geometry_string);
2360 box = gtk_vbox_new (FALSE, 0);
2361 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), box, TRUE, TRUE, 0);
2363 gtk_container_set_border_width (GTK_CONTAINER (box), 7);
2365 drawing_area = gtk_drawing_area_new ();
2366 g_signal_connect (drawing_area, "expose_event",
2367 G_CALLBACK (gridded_geometry_expose), NULL);
2368 gtk_box_pack_start (GTK_BOX (box), drawing_area, TRUE, TRUE, 0);
2370 /* Gross hack to work around bug 68668... if we set the size request
2371 * large enough, then the current
2373 * request_of_window - request_of_geometry_widget
2375 * method of getting the base size works more or less works.
2377 gtk_widget_set_size_request (drawing_area, 2000, 2000);
2379 geometry.base_width = 0;
2380 geometry.base_height = 0;
2381 geometry.min_width = 2 * GRID_SIZE;
2382 geometry.min_height = 2 * GRID_SIZE;
2383 geometry.width_inc = GRID_SIZE;
2384 geometry.height_inc = GRID_SIZE;
2386 gtk_window_set_geometry_hints (GTK_WINDOW (window), drawing_area,
2388 GDK_HINT_BASE_SIZE | GDK_HINT_MIN_SIZE | GDK_HINT_RESIZE_INC);
2390 if (!gtk_window_parse_geometry (GTK_WINDOW (window), geometry_string))
2392 g_print ("Can't parse geometry string %s\n", geometry_string);
2393 gtk_window_parse_geometry (GTK_WINDOW (window), DEFAULT_GEOMETRY);
2396 gtk_widget_show_all (window);
2401 create_gridded_geometry (GtkWidget *widget)
2403 static GtkWidget *window = NULL;
2409 window = gtk_dialog_new_with_buttons ("Gridded Geometry",
2412 GTK_STOCK_CLOSE, GTK_RESPONSE_NONE,
2415 gtk_window_set_screen (GTK_WINDOW (window),
2416 gtk_widget_get_screen (widget));
2418 label = gtk_label_new ("Geometry string:");
2419 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), label, FALSE, FALSE, 0);
2421 entry = gtk_entry_new ();
2422 gtk_entry_set_text (GTK_ENTRY (entry), DEFAULT_GEOMETRY);
2423 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), entry, FALSE, FALSE, 0);
2425 g_signal_connect (window, "response",
2426 G_CALLBACK (gridded_geometry_response), entry);
2427 g_object_add_weak_pointer (G_OBJECT (window), (gpointer) &window);
2429 gtk_widget_show_all (window);
2432 gtk_widget_destroy (window);
2440 handle_box_child_signal (GtkHandleBox *hb,
2442 const gchar *action)
2444 printf ("%s: child <%s> %sed\n",
2445 g_type_name (G_OBJECT_TYPE (hb)),
2446 g_type_name (G_OBJECT_TYPE (child)),
2451 create_handle_box (GtkWidget *widget)
2453 static GtkWidget* window = NULL;
2454 GtkWidget *handle_box;
2455 GtkWidget *handle_box2;
2460 GtkWidget *separator;
2464 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
2466 gtk_window_set_screen (GTK_WINDOW (window),
2467 gtk_widget_get_screen (widget));
2468 gtk_window_set_modal (GTK_WINDOW (window), FALSE);
2469 gtk_window_set_title (GTK_WINDOW (window),
2471 gtk_window_set_resizable (GTK_WINDOW (window), TRUE);
2473 g_signal_connect (window, "destroy",
2474 G_CALLBACK (gtk_widget_destroyed),
2477 gtk_container_set_border_width (GTK_CONTAINER (window), 20);
2479 vbox = gtk_vbox_new (FALSE, 0);
2480 gtk_container_add (GTK_CONTAINER (window), vbox);
2481 gtk_widget_show (vbox);
2483 label = gtk_label_new ("Above");
2484 gtk_container_add (GTK_CONTAINER (vbox), label);
2485 gtk_widget_show (label);
2487 separator = gtk_hseparator_new ();
2488 gtk_container_add (GTK_CONTAINER (vbox), separator);
2489 gtk_widget_show (separator);
2491 hbox = gtk_hbox_new (FALSE, 10);
2492 gtk_container_add (GTK_CONTAINER (vbox), hbox);
2493 gtk_widget_show (hbox);
2495 separator = gtk_hseparator_new ();
2496 gtk_container_add (GTK_CONTAINER (vbox), separator);
2497 gtk_widget_show (separator);
2499 label = gtk_label_new ("Below");
2500 gtk_container_add (GTK_CONTAINER (vbox), label);
2501 gtk_widget_show (label);
2503 handle_box = gtk_handle_box_new ();
2504 gtk_box_pack_start (GTK_BOX (hbox), handle_box, FALSE, FALSE, 0);
2505 g_signal_connect (handle_box,
2507 G_CALLBACK (handle_box_child_signal),
2509 g_signal_connect (handle_box,
2511 G_CALLBACK (handle_box_child_signal),
2513 gtk_widget_show (handle_box);
2515 toolbar = make_toolbar (window);
2517 gtk_container_add (GTK_CONTAINER (handle_box), toolbar);
2518 gtk_widget_show (toolbar);
2520 handle_box = gtk_handle_box_new ();
2521 gtk_box_pack_start (GTK_BOX (hbox), handle_box, FALSE, FALSE, 0);
2522 g_signal_connect (handle_box,
2524 G_CALLBACK (handle_box_child_signal),
2526 g_signal_connect (handle_box,
2528 G_CALLBACK (handle_box_child_signal),
2530 gtk_widget_show (handle_box);
2532 handle_box2 = gtk_handle_box_new ();
2533 gtk_container_add (GTK_CONTAINER (handle_box), handle_box2);
2534 g_signal_connect (handle_box2,
2536 G_CALLBACK (handle_box_child_signal),
2538 g_signal_connect (handle_box2,
2540 G_CALLBACK (handle_box_child_signal),
2542 gtk_widget_show (handle_box2);
2544 hbox = g_object_new (GTK_TYPE_HBOX, "visible", 1, "parent", handle_box2, NULL);
2545 label = gtk_label_new ("Fooo!");
2546 gtk_container_add (GTK_CONTAINER (hbox), label);
2547 gtk_widget_show (label);
2548 g_object_new (GTK_TYPE_ARROW, "visible", 1, "parent", hbox, NULL);
2551 if (!GTK_WIDGET_VISIBLE (window))
2552 gtk_widget_show (window);
2554 gtk_widget_destroy (window);
2558 * Test for getting an image from a drawable
2569 take_snapshot (GtkWidget *button,
2572 struct GetImageData *gid = data;
2573 GdkRectangle visible;
2575 int height_fraction;
2578 GdkColor color = { 0, 30000, 0, 0 };
2579 GdkRectangle target;
2582 /* Do some begin_paint_rect on some random rects, draw some
2583 * distinctive stuff into those rects, then take the snapshot.
2584 * figure out whether any rects were overlapped and report to
2588 visible = gid->sw->allocation;
2590 visible.x = gtk_scrolled_window_get_hadjustment (GTK_SCROLLED_WINDOW (gid->sw))->value;
2591 visible.y = gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (gid->sw))->value;
2593 width_fraction = visible.width / 4;
2594 height_fraction = visible.height / 4;
2596 gc = gdk_gc_new (gid->src->window);
2597 black_gc = gid->src->style->black_gc;
2599 gdk_gc_set_rgb_fg_color (gc, &color);
2602 target.x = visible.x + width_fraction;
2603 target.y = visible.y + height_fraction * 3;
2604 target.width = width_fraction;
2605 target.height = height_fraction / 2;
2607 gdk_window_begin_paint_rect (gid->src->window,
2610 gdk_draw_rectangle (gid->src->window,
2614 target.width, target.height);
2616 gdk_draw_rectangle (gid->src->window,
2619 target.x + 10, target.y + 10,
2620 target.width - 20, target.height - 20);
2622 target.x = visible.x + width_fraction;
2623 target.y = visible.y + height_fraction;
2624 target.width = width_fraction;
2625 target.height = height_fraction;
2627 gdk_window_begin_paint_rect (gid->src->window,
2630 gdk_draw_rectangle (gid->src->window,
2634 target.width, target.height);
2636 gdk_draw_rectangle (gid->src->window,
2639 target.x + 10, target.y + 10,
2640 target.width - 20, target.height - 20);
2642 target.x = visible.x + width_fraction * 3;
2643 target.y = visible.y + height_fraction;
2644 target.width = width_fraction / 2;
2645 target.height = height_fraction;
2647 gdk_window_begin_paint_rect (gid->src->window,
2650 gdk_draw_rectangle (gid->src->window,
2654 target.width, target.height);
2656 gdk_draw_rectangle (gid->src->window,
2659 target.x + 10, target.y + 10,
2660 target.width - 20, target.height - 20);
2662 target.x = visible.x + width_fraction * 2;
2663 target.y = visible.y + height_fraction * 2;
2664 target.width = width_fraction / 4;
2665 target.height = height_fraction / 4;
2667 gdk_window_begin_paint_rect (gid->src->window,
2670 gdk_draw_rectangle (gid->src->window,
2674 target.width, target.height);
2676 gdk_draw_rectangle (gid->src->window,
2679 target.x + 10, target.y + 10,
2680 target.width - 20, target.height - 20);
2682 target.x += target.width / 2;
2683 target.y += target.width / 2;
2685 gdk_window_begin_paint_rect (gid->src->window,
2688 gdk_draw_rectangle (gid->src->window,
2692 target.width, target.height);
2694 gdk_draw_rectangle (gid->src->window,
2697 target.x + 10, target.y + 10,
2698 target.width - 20, target.height - 20);
2700 /* Screen shot area */
2702 target.x = visible.x + width_fraction * 1.5;
2703 target.y = visible.y + height_fraction * 1.5;
2704 target.width = width_fraction * 2;
2705 target.height = height_fraction * 2;
2707 shot = gdk_drawable_get_image (gid->src->window,
2709 target.width, target.height);
2711 gtk_image_set_from_image (GTK_IMAGE (gid->snap),
2714 g_object_unref (shot);
2716 gdk_window_end_paint (gid->src->window);
2717 gdk_window_end_paint (gid->src->window);
2718 gdk_window_end_paint (gid->src->window);
2719 gdk_window_end_paint (gid->src->window);
2720 gdk_window_end_paint (gid->src->window);
2722 gdk_draw_rectangle (gid->src->window,
2723 gid->src->style->black_gc,
2726 target.width, target.height);
2728 g_object_unref (gc);
2732 image_source_expose (GtkWidget *da,
2733 GdkEventExpose *event,
2736 int x = event->area.x;
2737 GdkColor red = { 0, 65535, 0, 0 };
2738 GdkColor green = { 0, 0, 65535, 0 };
2739 GdkColor blue = { 0, 0, 0, 65535 };
2742 gc = gdk_gc_new (event->window);
2744 while (x < (event->area.x + event->area.width))
2751 gdk_gc_set_rgb_fg_color (gc, &red);
2757 gdk_gc_set_rgb_fg_color (gc, &green);
2763 gdk_gc_set_rgb_fg_color (gc, &blue);
2767 g_assert_not_reached ();
2771 gdk_draw_line (event->window,
2774 x, event->area.y + event->area.height);
2779 g_object_unref (gc);
2785 create_get_image (GtkWidget *widget)
2787 static GtkWidget *window = NULL;
2790 gtk_widget_destroy (window);
2799 struct GetImageData *gid;
2801 gid = g_new (struct GetImageData, 1);
2803 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
2805 gtk_window_set_screen (GTK_WINDOW (window),
2806 gtk_widget_get_screen (widget));
2808 g_signal_connect (window,
2810 G_CALLBACK (gtk_widget_destroyed),
2813 g_object_set_data_full (G_OBJECT (window),
2814 "testgtk-get-image-data",
2818 hbox = gtk_hbox_new (FALSE, 0);
2820 gtk_container_add (GTK_CONTAINER (window), hbox);
2822 sw = gtk_scrolled_window_new (NULL, NULL);
2823 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
2824 GTK_POLICY_AUTOMATIC,
2825 GTK_POLICY_AUTOMATIC);
2829 gtk_widget_set_size_request (sw, 400, 400);
2831 src = gtk_drawing_area_new ();
2832 gtk_widget_set_size_request (src, 10000, 10000);
2834 g_signal_connect (src,
2836 G_CALLBACK (image_source_expose),
2841 gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (sw),
2844 gtk_box_pack_start (GTK_BOX (hbox),
2848 vbox = gtk_vbox_new (FALSE, 3);
2850 snap = gtk_widget_new (GTK_TYPE_IMAGE, NULL);
2854 sw = gtk_scrolled_window_new (NULL, NULL);
2855 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
2856 GTK_POLICY_AUTOMATIC,
2857 GTK_POLICY_AUTOMATIC);
2858 gtk_widget_set_size_request (sw, 300, 300);
2860 gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (sw), snap);
2862 gtk_box_pack_end (GTK_BOX (vbox), sw, FALSE, FALSE, 5);
2864 button = gtk_button_new_with_label ("Get image from drawable");
2866 g_signal_connect (button,
2868 G_CALLBACK (take_snapshot),
2871 gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
2873 gtk_box_pack_end (GTK_BOX (hbox), vbox, FALSE, FALSE, 0);
2875 gtk_widget_show_all (window);
2883 sensitivity_toggled (GtkWidget *toggle,
2886 gtk_widget_set_sensitive (widget, GTK_TOGGLE_BUTTON (toggle)->active);
2890 create_sensitivity_control (GtkWidget *widget)
2894 button = gtk_toggle_button_new_with_label ("Sensitive");
2896 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button),
2897 GTK_WIDGET_IS_SENSITIVE (widget));
2899 g_signal_connect (button,
2901 G_CALLBACK (sensitivity_toggled),
2904 gtk_widget_show_all (button);
2910 set_selectable_recursive (GtkWidget *widget,
2913 if (GTK_IS_CONTAINER (widget))
2918 children = gtk_container_get_children (GTK_CONTAINER (widget));
2922 set_selectable_recursive (tmp->data, setting);
2926 g_list_free (children);
2928 else if (GTK_IS_LABEL (widget))
2930 gtk_label_set_selectable (GTK_LABEL (widget), setting);
2935 selectable_toggled (GtkWidget *toggle,
2938 set_selectable_recursive (widget,
2939 GTK_TOGGLE_BUTTON (toggle)->active);
2943 create_selectable_control (GtkWidget *widget)
2947 button = gtk_toggle_button_new_with_label ("Selectable");
2949 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button),
2952 g_signal_connect (button,
2954 G_CALLBACK (selectable_toggled),
2957 gtk_widget_show_all (button);
2962 void create_labels (GtkWidget *widget)
2964 static GtkWidget *window = NULL;
2973 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
2975 gtk_window_set_screen (GTK_WINDOW (window),
2976 gtk_widget_get_screen (widget));
2978 g_signal_connect (window, "destroy",
2979 G_CALLBACK (gtk_widget_destroyed),
2982 gtk_window_set_title (GTK_WINDOW (window), "Label");
2984 vbox = gtk_vbox_new (FALSE, 5);
2986 hbox = gtk_hbox_new (FALSE, 5);
2987 gtk_container_add (GTK_CONTAINER (window), vbox);
2989 gtk_box_pack_end (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
2991 button = create_sensitivity_control (hbox);
2993 gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
2995 button = create_selectable_control (hbox);
2997 gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
2999 vbox = gtk_vbox_new (FALSE, 5);
3001 gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 0);
3002 gtk_container_set_border_width (GTK_CONTAINER (window), 5);
3004 frame = gtk_frame_new ("Normal Label");
3005 label = gtk_label_new ("This is a Normal label");
3006 gtk_label_set_ellipsize (GTK_LABEL (label), PANGO_ELLIPSIZE_START);
3007 gtk_container_add (GTK_CONTAINER (frame), label);
3008 gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
3010 frame = gtk_frame_new ("Multi-line Label");
3011 label = gtk_label_new ("This is a Multi-line label.\nSecond line\nThird line");
3012 gtk_label_set_ellipsize (GTK_LABEL (label), PANGO_ELLIPSIZE_END);
3013 gtk_container_add (GTK_CONTAINER (frame), label);
3014 gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
3016 frame = gtk_frame_new ("Left Justified Label");
3017 label = gtk_label_new ("This is a Left-Justified\nMulti-line label.\nThird line");
3018 gtk_label_set_ellipsize (GTK_LABEL (label), PANGO_ELLIPSIZE_MIDDLE);
3019 gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
3020 gtk_container_add (GTK_CONTAINER (frame), label);
3021 gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
3023 frame = gtk_frame_new ("Right Justified Label");
3024 gtk_label_set_ellipsize (GTK_LABEL (label), PANGO_ELLIPSIZE_START);
3025 label = gtk_label_new ("This is a Right-Justified\nMulti-line label.\nFourth line, (j/k)");
3026 gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_RIGHT);
3027 gtk_container_add (GTK_CONTAINER (frame), label);
3028 gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
3030 frame = gtk_frame_new ("Internationalized Label");
3031 label = gtk_label_new (NULL);
3032 gtk_label_set_markup (GTK_LABEL (label),
3033 "French (Fran\303\247ais) Bonjour, Salut\n"
3034 "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"
3035 "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"
3036 "Chinese (Simplified) <span lang=\"zh-cn\">\345\205\203\346\260\224 \345\274\200\345\217\221</span>\n"
3037 "Chinese (Traditional) <span lang=\"zh-tw\">\345\205\203\346\260\243 \351\226\213\347\231\274</span>\n"
3038 "Japanese <span lang=\"ja\">\345\205\203\346\260\227 \351\226\213\347\231\272</span>");
3039 gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
3040 gtk_container_add (GTK_CONTAINER (frame), label);
3041 gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
3043 frame = gtk_frame_new ("Bidirection Label");
3044 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"
3045 "\342\200\217Hebrew \327\251\327\234\327\225\327\235");
3046 gtk_container_add (GTK_CONTAINER (frame), label);
3047 gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
3049 vbox = gtk_vbox_new (FALSE, 5);
3050 gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 0);
3051 frame = gtk_frame_new ("Line wrapped label");
3052 label = gtk_label_new ("This is an example of a line-wrapped label. It should not be taking "\
3053 "up the entire "/* big space to test spacing */\
3054 "width allocated to it, but automatically wraps the words to fit. "\
3055 "The time has come, for all good men, to come to the aid of their party. "\
3056 "The sixth sheik's six sheep's sick.\n"\
3057 " It supports multiple paragraphs correctly, and correctly adds "\
3058 "many extra spaces. ");
3060 gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
3061 gtk_container_add (GTK_CONTAINER (frame), label);
3062 gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
3064 frame = gtk_frame_new ("Filled, wrapped label");
3065 label = gtk_label_new ("This is an example of a line-wrapped, filled label. It should be taking "\
3066 "up the entire width allocated to it. Here is a seneance to prove "\
3067 "my point. Here is another sentence. "\
3068 "Here comes the sun, do de do de do.\n"\
3069 " This is a new paragraph.\n"\
3070 " This is another newer, longer, better paragraph. It is coming to an end, "\
3072 gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_FILL);
3073 gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
3074 gtk_container_add (GTK_CONTAINER (frame), label);
3075 gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
3077 frame = gtk_frame_new ("Underlined label");
3078 label = gtk_label_new ("This label is underlined!\n"
3079 "This one is underlined (\343\201\223\343\202\223\343\201\253\343\201\241\343\201\257) in quite a funky fashion");
3080 gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
3081 gtk_label_set_pattern (GTK_LABEL (label), "_________________________ _ _________ _ _____ _ __ __ ___ ____ _____");
3082 gtk_container_add (GTK_CONTAINER (frame), label);
3083 gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
3085 frame = gtk_frame_new ("Markup label");
3086 label = gtk_label_new (NULL);
3088 /* There's also a gtk_label_set_markup() without accel if you
3089 * don't have an accelerator key
3091 gtk_label_set_markup_with_mnemonic (GTK_LABEL (label),
3092 "This <span foreground=\"blue\" background=\"orange\">label</span> has "
3093 "<b>markup</b> _such as "
3094 "<big><i>Big Italics</i></big>\n"
3095 "<tt>Monospace font</tt>\n"
3096 "<u>Underline!</u>\n"
3098 "<span foreground=\"green\" background=\"red\">Ugly colors</span>\n"
3099 "and nothing on this line,\n"
3102 "or even on this one\n"
3103 "la <big>la <big>la <big>la <big>la</big></big></big></big>\n"
3104 "but this _word is <span foreground=\"purple\"><big>purple</big></span>\n"
3105 "<span underline=\"double\">We like <sup>superscript</sup> and <sub>subscript</sub> too</span>");
3107 g_assert (gtk_label_get_mnemonic_keyval (GTK_LABEL (label)) == GDK_s);
3109 gtk_container_add (GTK_CONTAINER (frame), label);
3110 gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
3113 if (!GTK_WIDGET_VISIBLE (window))
3114 gtk_widget_show_all (window);
3116 gtk_widget_destroy (window);
3120 on_angle_scale_changed (GtkRange *range,
3123 gtk_label_set_angle (GTK_LABEL (label), gtk_range_get_value (range));
3127 create_rotated_label (GtkWidget *widget)
3129 static GtkWidget *window = NULL;
3133 GtkWidget *scale_label;
3134 GtkWidget *scale_hbox;
3138 window = gtk_dialog_new_with_buttons ("Rotated Label",
3139 GTK_WINDOW (gtk_widget_get_toplevel (widget)), 0,
3140 GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE,
3143 gtk_window_set_resizable (GTK_WINDOW (window), TRUE);
3145 gtk_window_set_screen (GTK_WINDOW (window),
3146 gtk_widget_get_screen (widget));
3148 g_signal_connect (window, "response",
3149 G_CALLBACK (gtk_object_destroy), NULL);
3150 g_signal_connect (window, "destroy",
3151 G_CALLBACK (gtk_widget_destroyed), &window);
3153 vbox = gtk_vbox_new (FALSE, 5);
3154 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), vbox, TRUE, TRUE, 0);
3155 gtk_container_set_border_width (GTK_CONTAINER (vbox), 10);
3157 label = gtk_label_new (NULL);
3158 gtk_label_set_markup (GTK_LABEL (label), "Hello World\n<i>Rotate</i> <span underline='single' foreground='blue'>me</span>");
3159 gtk_box_pack_start (GTK_BOX (vbox), label, TRUE, TRUE, 0);
3161 scale_hbox = gtk_hbox_new (FALSE, 0);
3162 gtk_box_pack_start (GTK_BOX (vbox), scale_hbox, FALSE, FALSE, 0);
3164 scale_label = gtk_label_new (NULL);
3165 gtk_label_set_markup (GTK_LABEL (scale_label), "<i>Angle: </i>");
3166 gtk_box_pack_start (GTK_BOX (scale_hbox), scale_label, FALSE, FALSE, 0);
3168 hscale = gtk_hscale_new_with_range (0, 360, 5);
3169 g_signal_connect (hscale, "value-changed",
3170 G_CALLBACK (on_angle_scale_changed), label);
3172 gtk_range_set_value (GTK_RANGE (hscale), 45);
3173 gtk_widget_set_usize (hscale, 200, -1);
3174 gtk_box_pack_start (GTK_BOX (scale_hbox), hscale, TRUE, TRUE, 0);
3177 if (!GTK_WIDGET_VISIBLE (window))
3178 gtk_widget_show_all (window);
3180 gtk_widget_destroy (window);
3183 #define DEFAULT_TEXT_RADIUS 200
3186 on_rotated_text_unrealize (GtkWidget *widget)
3188 g_object_set_data (G_OBJECT (widget), "text-gc", NULL);
3192 on_rotated_text_expose (GtkWidget *widget,
3193 GdkEventExpose *event,
3194 GdkPixbuf *tile_pixbuf)
3196 static const gchar *words[] = { "The", "grand", "old", "Duke", "of", "York",
3197 "had", "10,000", "men" };
3198 PangoRenderer *renderer;
3203 PangoMatrix matrix = PANGO_MATRIX_INIT;
3204 PangoLayout *layout;
3205 PangoContext *context;
3206 PangoFontDescription *desc;
3208 gc = g_object_get_data (G_OBJECT (widget), "text-gc");
3211 static GdkColor black = { 0, 0, 0, 0 };
3213 gc = gdk_gc_new (widget->window);
3214 gdk_gc_set_rgb_fg_color (gc, &black);
3220 gint width = gdk_pixbuf_get_width (tile_pixbuf);
3221 gint height = gdk_pixbuf_get_height (tile_pixbuf);
3223 tile = gdk_pixmap_new (widget->window, width, height, -1);
3224 gdk_draw_pixbuf (tile, gc, tile_pixbuf,
3225 0, 0, 0, 0, width, height,
3226 GDK_RGB_DITHER_NORMAL, 0, 0);
3228 gdk_gc_set_tile (gc, tile);
3229 gdk_gc_set_fill (gc, GDK_TILED);
3231 g_object_unref (tile);
3234 g_object_set_data_full (G_OBJECT (widget), "text-gc", gc, (GDestroyNotify)g_object_unref);
3237 renderer = gdk_pango_renderer_get_default (gtk_widget_get_screen (widget));
3238 gdk_pango_renderer_set_drawable (GDK_PANGO_RENDERER (renderer), widget->window);
3239 gdk_pango_renderer_set_gc (GDK_PANGO_RENDERER (renderer), gc);
3241 radius = MIN (widget->allocation.width, widget->allocation.height) / 2.;
3243 pango_matrix_translate (&matrix,
3244 radius + (widget->allocation.width - 2 * radius) / 2,
3245 radius + (widget->allocation.height - 2 * radius) / 2);
3246 pango_matrix_scale (&matrix, radius / DEFAULT_TEXT_RADIUS, radius / DEFAULT_TEXT_RADIUS);
3248 context = gtk_widget_get_pango_context (widget);
3249 layout = pango_layout_new (context);
3250 desc = pango_font_description_from_string ("Sans Bold 30");
3251 pango_layout_set_font_description (layout, desc);
3252 pango_font_description_free (desc);
3254 n_words = G_N_ELEMENTS (words);
3255 for (i = 0; i < n_words; i++)
3257 PangoMatrix rotated_matrix = matrix;
3260 pango_matrix_rotate (&rotated_matrix, - (360. * i) / n_words);
3262 pango_context_set_matrix (context, &rotated_matrix);
3263 pango_layout_context_changed (layout);
3264 pango_layout_set_text (layout, words[i], -1);
3266 pango_layout_get_size (layout, &width, &height);
3268 pango_renderer_draw_layout (renderer, layout,
3269 - width / 2, - DEFAULT_TEXT_RADIUS * PANGO_SCALE);
3272 gdk_pango_renderer_set_drawable (GDK_PANGO_RENDERER (renderer), NULL);
3273 gdk_pango_renderer_set_gc (GDK_PANGO_RENDERER (renderer), NULL);
3275 g_object_unref (layout);
3281 create_rotated_text (GtkWidget *widget)
3283 static GtkWidget *window = NULL;
3287 const GdkColor white = { 0, 0xffff, 0xffff, 0xffff };
3288 GtkRequisition requisition;
3289 GtkWidget *drawing_area;
3290 GdkPixbuf *tile_pixbuf;
3292 window = gtk_dialog_new_with_buttons ("Rotated Text",
3293 GTK_WINDOW (gtk_widget_get_toplevel (widget)), 0,
3294 GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE,
3297 gtk_window_set_resizable (GTK_WINDOW (window), TRUE);
3299 gtk_window_set_screen (GTK_WINDOW (window),
3300 gtk_widget_get_screen (widget));
3302 g_signal_connect (window, "response",
3303 G_CALLBACK (gtk_object_destroy), NULL);
3304 g_signal_connect (window, "destroy",
3305 G_CALLBACK (gtk_widget_destroyed), &window);
3307 drawing_area = gtk_drawing_area_new ();
3308 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), drawing_area, TRUE, TRUE, 0);
3309 gtk_widget_modify_bg (drawing_area, GTK_STATE_NORMAL, &white);
3311 tile_pixbuf = gdk_pixbuf_new_from_file ("marble.xpm", NULL);
3313 g_signal_connect (drawing_area, "expose-event",
3314 G_CALLBACK (on_rotated_text_expose), tile_pixbuf);
3315 g_signal_connect (drawing_area, "unrealize",
3316 G_CALLBACK (on_rotated_text_unrealize), NULL);
3318 gtk_widget_show_all (GTK_BIN (window)->child);
3320 gtk_widget_set_size_request (drawing_area, DEFAULT_TEXT_RADIUS * 2, DEFAULT_TEXT_RADIUS * 2);
3321 gtk_widget_size_request (window, &requisition);
3322 gtk_widget_set_size_request (drawing_area, -1, -1);
3323 gtk_window_resize (GTK_WINDOW (window), requisition.width, requisition.height);
3326 if (!GTK_WIDGET_VISIBLE (window))
3327 gtk_widget_show (window);
3329 gtk_widget_destroy (window);
3337 reparent_label (GtkWidget *widget,
3338 GtkWidget *new_parent)
3342 label = g_object_get_data (G_OBJECT (widget), "user_data");
3344 gtk_widget_reparent (label, new_parent);
3348 set_parent_signal (GtkWidget *child,
3349 GtkWidget *old_parent,
3352 g_message ("set_parent for \"%s\": new parent: \"%s\", old parent: \"%s\", data: %d\n",
3353 g_type_name (G_OBJECT_TYPE (child)),
3354 child->parent ? g_type_name (G_OBJECT_TYPE (child->parent)) : "NULL",
3355 old_parent ? g_type_name (G_OBJECT_TYPE (old_parent)) : "NULL",
3356 GPOINTER_TO_INT (func_data));
3360 create_reparent (GtkWidget *widget)
3362 static GtkWidget *window = NULL;
3369 GtkWidget *separator;
3370 GtkWidget *event_box;
3374 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
3376 gtk_window_set_screen (GTK_WINDOW (window),
3377 gtk_widget_get_screen (widget));
3379 g_signal_connect (window, "destroy",
3380 G_CALLBACK (gtk_widget_destroyed),
3383 gtk_window_set_title (GTK_WINDOW (window), "reparent");
3384 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
3386 box1 = gtk_vbox_new (FALSE, 0);
3387 gtk_container_add (GTK_CONTAINER (window), box1);
3389 box2 = gtk_hbox_new (FALSE, 5);
3390 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
3391 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
3393 label = gtk_label_new ("Hello World");
3395 frame = gtk_frame_new ("Frame 1");
3396 gtk_box_pack_start (GTK_BOX (box2), frame, TRUE, TRUE, 0);
3398 box3 = gtk_vbox_new (FALSE, 5);
3399 gtk_container_set_border_width (GTK_CONTAINER (box3), 5);
3400 gtk_container_add (GTK_CONTAINER (frame), box3);
3402 button = gtk_button_new_with_label ("switch");
3403 g_object_set_data (G_OBJECT (button), "user_data", label);
3404 gtk_box_pack_start (GTK_BOX (box3), button, FALSE, TRUE, 0);
3406 event_box = gtk_event_box_new ();
3407 gtk_box_pack_start (GTK_BOX (box3), event_box, FALSE, TRUE, 0);
3408 gtk_container_add (GTK_CONTAINER (event_box), label);
3410 g_signal_connect (button, "clicked",
3411 G_CALLBACK (reparent_label),
3414 g_signal_connect (label, "parent_set",
3415 G_CALLBACK (set_parent_signal),
3416 GINT_TO_POINTER (42));
3418 frame = gtk_frame_new ("Frame 2");
3419 gtk_box_pack_start (GTK_BOX (box2), frame, TRUE, TRUE, 0);
3421 box3 = gtk_vbox_new (FALSE, 5);
3422 gtk_container_set_border_width (GTK_CONTAINER (box3), 5);
3423 gtk_container_add (GTK_CONTAINER (frame), box3);
3425 button = gtk_button_new_with_label ("switch");
3426 g_object_set_data (G_OBJECT (button), "user_data", label);
3427 gtk_box_pack_start (GTK_BOX (box3), button, FALSE, TRUE, 0);
3429 event_box = gtk_event_box_new ();
3430 gtk_box_pack_start (GTK_BOX (box3), event_box, FALSE, TRUE, 0);
3432 g_signal_connect (button, "clicked",
3433 G_CALLBACK (reparent_label),
3436 separator = gtk_hseparator_new ();
3437 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
3439 box2 = gtk_vbox_new (FALSE, 10);
3440 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
3441 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
3443 button = gtk_button_new_with_label ("close");
3444 g_signal_connect_swapped (button, "clicked",
3445 G_CALLBACK (gtk_widget_destroy), window);
3446 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
3447 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
3448 gtk_widget_grab_default (button);
3451 if (!GTK_WIDGET_VISIBLE (window))
3452 gtk_widget_show_all (window);
3454 gtk_widget_destroy (window);
3461 grippy_button_press (GtkWidget *area, GdkEventButton *event, GdkWindowEdge edge)
3463 if (event->type == GDK_BUTTON_PRESS)
3465 if (event->button == 1)
3466 gtk_window_begin_resize_drag (GTK_WINDOW (gtk_widget_get_toplevel (area)), edge,
3467 event->button, event->x_root, event->y_root,
3469 else if (event->button == 2)
3470 gtk_window_begin_move_drag (GTK_WINDOW (gtk_widget_get_toplevel (area)),
3471 event->button, event->x_root, event->y_root,
3478 grippy_expose (GtkWidget *area, GdkEventExpose *event, GdkWindowEdge edge)
3480 gtk_paint_resize_grip (area->style,
3482 GTK_WIDGET_STATE (area),
3488 area->allocation.width,
3489 area->allocation.height);
3495 create_resize_grips (GtkWidget *widget)
3497 static GtkWidget *window = NULL;
3499 GtkWidget *hbox, *vbox;
3502 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
3504 gtk_window_set_screen (GTK_WINDOW (window),
3505 gtk_widget_get_screen (widget));
3507 gtk_window_set_title (GTK_WINDOW (window), "resize grips");
3509 g_signal_connect (window, "destroy",
3510 G_CALLBACK (gtk_widget_destroyed),
3513 vbox = gtk_vbox_new (FALSE, 0);
3514 gtk_container_add (GTK_CONTAINER (window), vbox);
3516 hbox = gtk_hbox_new (FALSE, 0);
3517 gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 0);
3520 area = gtk_drawing_area_new ();
3521 gtk_widget_add_events (area, GDK_BUTTON_PRESS_MASK);
3522 gtk_box_pack_start (GTK_BOX (hbox), area, TRUE, TRUE, 0);
3523 g_signal_connect (area, "expose_event", G_CALLBACK (grippy_expose),
3524 GINT_TO_POINTER (GDK_WINDOW_EDGE_NORTH_WEST));
3525 g_signal_connect (area, "button_press_event", G_CALLBACK (grippy_button_press),
3526 GINT_TO_POINTER (GDK_WINDOW_EDGE_NORTH_WEST));
3529 area = gtk_drawing_area_new ();
3530 gtk_widget_add_events (area, GDK_BUTTON_PRESS_MASK);
3531 gtk_box_pack_start (GTK_BOX (hbox), area, TRUE, TRUE, 0);
3532 g_signal_connect (area, "expose_event", G_CALLBACK (grippy_expose),
3533 GINT_TO_POINTER (GDK_WINDOW_EDGE_NORTH));
3534 g_signal_connect (area, "button_press_event", G_CALLBACK (grippy_button_press),
3535 GINT_TO_POINTER (GDK_WINDOW_EDGE_NORTH));
3538 area = gtk_drawing_area_new ();
3539 gtk_widget_add_events (area, GDK_BUTTON_PRESS_MASK);
3540 gtk_box_pack_start (GTK_BOX (hbox), area, TRUE, TRUE, 0);
3541 g_signal_connect (area, "expose_event", G_CALLBACK (grippy_expose),
3542 GINT_TO_POINTER (GDK_WINDOW_EDGE_NORTH_EAST));
3543 g_signal_connect (area, "button_press_event", G_CALLBACK (grippy_button_press),
3544 GINT_TO_POINTER (GDK_WINDOW_EDGE_NORTH_EAST));
3546 hbox = gtk_hbox_new (FALSE, 0);
3547 gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 0);
3550 area = gtk_drawing_area_new ();
3551 gtk_widget_add_events (area, GDK_BUTTON_PRESS_MASK);
3552 gtk_box_pack_start (GTK_BOX (hbox), area, TRUE, TRUE, 0);
3553 g_signal_connect (area, "expose_event", G_CALLBACK (grippy_expose),
3554 GINT_TO_POINTER (GDK_WINDOW_EDGE_WEST));
3555 g_signal_connect (area, "button_press_event", G_CALLBACK (grippy_button_press),
3556 GINT_TO_POINTER (GDK_WINDOW_EDGE_WEST));
3559 area = gtk_drawing_area_new ();
3560 gtk_box_pack_start (GTK_BOX (hbox), area, TRUE, TRUE, 0);
3563 area = gtk_drawing_area_new ();
3564 gtk_widget_add_events (area, GDK_BUTTON_PRESS_MASK);
3565 gtk_box_pack_start (GTK_BOX (hbox), area, TRUE, TRUE, 0);
3566 g_signal_connect (area, "expose_event", G_CALLBACK (grippy_expose),
3567 GINT_TO_POINTER (GDK_WINDOW_EDGE_EAST));
3568 g_signal_connect (area, "button_press_event", G_CALLBACK (grippy_button_press),
3569 GINT_TO_POINTER (GDK_WINDOW_EDGE_EAST));
3572 hbox = gtk_hbox_new (FALSE, 0);
3573 gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 0);
3576 area = gtk_drawing_area_new ();
3577 gtk_widget_add_events (area, GDK_BUTTON_PRESS_MASK);
3578 gtk_box_pack_start (GTK_BOX (hbox), area, TRUE, TRUE, 0);
3579 g_signal_connect (area, "expose_event", G_CALLBACK (grippy_expose),
3580 GINT_TO_POINTER (GDK_WINDOW_EDGE_SOUTH_WEST));
3581 g_signal_connect (area, "button_press_event", G_CALLBACK (grippy_button_press),
3582 GINT_TO_POINTER (GDK_WINDOW_EDGE_SOUTH_WEST));
3584 area = gtk_drawing_area_new ();
3585 gtk_widget_add_events (area, GDK_BUTTON_PRESS_MASK);
3586 gtk_box_pack_start (GTK_BOX (hbox), area, TRUE, TRUE, 0);
3587 g_signal_connect (area, "expose_event", G_CALLBACK (grippy_expose),
3588 GINT_TO_POINTER (GDK_WINDOW_EDGE_SOUTH));
3589 g_signal_connect (area, "button_press_event", G_CALLBACK (grippy_button_press),
3590 GINT_TO_POINTER (GDK_WINDOW_EDGE_SOUTH));
3593 area = gtk_drawing_area_new ();
3594 gtk_widget_add_events (area, GDK_BUTTON_PRESS_MASK);
3595 gtk_box_pack_start (GTK_BOX (hbox), area, TRUE, TRUE, 0);
3596 g_signal_connect (area, "expose_event", G_CALLBACK (grippy_expose),
3597 GINT_TO_POINTER (GDK_WINDOW_EDGE_SOUTH_EAST));
3598 g_signal_connect (area, "button_press_event", G_CALLBACK (grippy_button_press),
3599 GINT_TO_POINTER (GDK_WINDOW_EDGE_SOUTH_EAST));
3602 if (!GTK_WIDGET_VISIBLE (window))
3603 gtk_widget_show_all (window);
3605 gtk_widget_destroy (window);
3611 gint upositionx = 0;
3612 gint upositiony = 0;
3615 uposition_configure (GtkWidget *window)
3621 lx = g_object_get_data (G_OBJECT (window), "x");
3622 ly = g_object_get_data (G_OBJECT (window), "y");
3624 gdk_window_get_root_origin (window->window, &upositionx, &upositiony);
3625 sprintf (buffer, "%d", upositionx);
3626 gtk_label_set_text (lx, buffer);
3627 sprintf (buffer, "%d", upositiony);
3628 gtk_label_set_text (ly, buffer);
3634 uposition_stop_configure (GtkToggleButton *toggle,
3638 g_signal_handlers_block_by_func (window, G_CALLBACK (uposition_configure), NULL);
3640 g_signal_handlers_unblock_by_func (window, G_CALLBACK (uposition_configure), NULL);
3644 create_saved_position (GtkWidget *widget)
3646 static GtkWidget *window = NULL;
3651 GtkWidget *main_vbox;
3659 window = g_object_connect (gtk_widget_new (GTK_TYPE_WINDOW,
3660 "type", GTK_WINDOW_TOPLEVEL,
3661 "title", "Saved Position",
3663 "signal::configure_event", uposition_configure, NULL,
3666 gtk_window_move (GTK_WINDOW (window), upositionx, upositiony);
3668 gtk_window_set_screen (GTK_WINDOW (window),
3669 gtk_widget_get_screen (widget));
3672 g_signal_connect (window, "destroy",
3673 G_CALLBACK (gtk_widget_destroyed),
3676 main_vbox = gtk_vbox_new (FALSE, 5);
3677 gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 0);
3678 gtk_container_add (GTK_CONTAINER (window), main_vbox);
3681 gtk_widget_new (gtk_vbox_get_type (),
3682 "GtkBox::homogeneous", FALSE,
3683 "GtkBox::spacing", 5,
3684 "GtkContainer::border_width", 10,
3685 "GtkWidget::parent", main_vbox,
3686 "GtkWidget::visible", TRUE,
3687 "child", g_object_connect (gtk_widget_new (GTK_TYPE_TOGGLE_BUTTON,
3688 "label", "Stop Events",
3692 "signal::clicked", uposition_stop_configure, window,
3696 hbox = gtk_hbox_new (FALSE, 0);
3697 gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
3698 gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0);
3700 label = gtk_label_new ("X Origin : ");
3701 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
3702 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
3704 x_label = gtk_label_new ("");
3705 gtk_box_pack_start (GTK_BOX (hbox), x_label, TRUE, TRUE, 0);
3706 g_object_set_data (G_OBJECT (window), "x", x_label);
3708 hbox = gtk_hbox_new (FALSE, 0);
3709 gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
3710 gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0);
3712 label = gtk_label_new ("Y Origin : ");
3713 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
3714 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
3716 y_label = gtk_label_new ("");
3717 gtk_box_pack_start (GTK_BOX (hbox), y_label, TRUE, TRUE, 0);
3718 g_object_set_data (G_OBJECT (window), "y", y_label);
3721 gtk_widget_new (gtk_hseparator_get_type (),
3722 "GtkWidget::visible", TRUE,
3724 gtk_box_pack_start (GTK_BOX (main_vbox), any, FALSE, TRUE, 0);
3726 hbox = gtk_hbox_new (FALSE, 0);
3727 gtk_container_set_border_width (GTK_CONTAINER (hbox), 10);
3728 gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, TRUE, 0);
3730 button = gtk_button_new_with_label ("Close");
3731 g_signal_connect_swapped (button, "clicked",
3732 G_CALLBACK (gtk_widget_destroy),
3734 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
3735 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
3736 gtk_widget_grab_default (button);
3738 gtk_widget_show_all (window);
3741 gtk_widget_destroy (window);
3749 create_pixmap (GtkWidget *widget)
3751 static GtkWidget *window = NULL;
3757 GtkWidget *separator;
3758 GtkWidget *pixmapwid;
3762 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
3764 gtk_window_set_screen (GTK_WINDOW (window),
3765 gtk_widget_get_screen (widget));
3767 g_signal_connect (window, "destroy",
3768 G_CALLBACK (gtk_widget_destroyed),
3771 gtk_window_set_title (GTK_WINDOW (window), "GtkPixmap");
3772 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
3773 gtk_widget_realize(window);
3775 box1 = gtk_vbox_new (FALSE, 0);
3776 gtk_container_add (GTK_CONTAINER (window), box1);
3778 box2 = gtk_vbox_new (FALSE, 10);
3779 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
3780 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
3782 button = gtk_button_new ();
3783 gtk_box_pack_start (GTK_BOX (box2), button, FALSE, FALSE, 0);
3785 pixmapwid = new_pixmap ("test.xpm", window->window, NULL);
3787 label = gtk_label_new ("Pixmap\ntest");
3788 box3 = gtk_hbox_new (FALSE, 0);
3789 gtk_container_set_border_width (GTK_CONTAINER (box3), 2);
3790 gtk_container_add (GTK_CONTAINER (box3), pixmapwid);
3791 gtk_container_add (GTK_CONTAINER (box3), label);
3792 gtk_container_add (GTK_CONTAINER (button), box3);
3794 button = gtk_button_new ();
3795 gtk_box_pack_start (GTK_BOX (box2), button, FALSE, FALSE, 0);
3797 pixmapwid = new_pixmap ("test.xpm", window->window, NULL);
3799 label = gtk_label_new ("Pixmap\ntest");
3800 box3 = gtk_hbox_new (FALSE, 0);
3801 gtk_container_set_border_width (GTK_CONTAINER (box3), 2);
3802 gtk_container_add (GTK_CONTAINER (box3), pixmapwid);
3803 gtk_container_add (GTK_CONTAINER (box3), label);
3804 gtk_container_add (GTK_CONTAINER (button), box3);
3806 gtk_widget_set_sensitive (button, FALSE);
3808 separator = gtk_hseparator_new ();
3809 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
3811 box2 = gtk_vbox_new (FALSE, 10);
3812 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
3813 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
3815 button = gtk_button_new_with_label ("close");
3816 g_signal_connect_swapped (button, "clicked",
3817 G_CALLBACK (gtk_widget_destroy),
3819 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
3820 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
3821 gtk_widget_grab_default (button);
3824 if (!GTK_WIDGET_VISIBLE (window))
3825 gtk_widget_show_all (window);
3827 gtk_widget_destroy (window);
3831 tips_query_widget_entered (GtkTipsQuery *tips_query,
3833 const gchar *tip_text,
3834 const gchar *tip_private,
3837 if (GTK_TOGGLE_BUTTON (toggle)->active)
3839 gtk_label_set_text (GTK_LABEL (tips_query), tip_text ? "There is a Tip!" : "There is no Tip!");
3840 /* don't let GtkTipsQuery reset its label */
3841 g_signal_stop_emission_by_name (tips_query, "widget_entered");
3846 tips_query_widget_selected (GtkWidget *tips_query,
3848 const gchar *tip_text,
3849 const gchar *tip_private,
3850 GdkEventButton *event,
3854 g_print ("Help \"%s\" requested for <%s>\n",
3855 tip_private ? tip_private : "None",
3856 g_type_name (G_OBJECT_TYPE (widget)));
3861 create_tooltips (GtkWidget *widget)
3863 static GtkWidget *window = NULL;
3870 GtkWidget *tips_query;
3871 GtkWidget *separator;
3872 GtkTooltips *tooltips;
3877 gtk_widget_new (gtk_window_get_type (),
3878 "GtkWindow::type", GTK_WINDOW_TOPLEVEL,
3879 "GtkContainer::border_width", 0,
3880 "GtkWindow::title", "Tooltips",
3881 "GtkWindow::allow_shrink", TRUE,
3882 "GtkWindow::allow_grow", FALSE,
3885 gtk_window_set_screen (GTK_WINDOW (window),
3886 gtk_widget_get_screen (widget));
3888 g_signal_connect (window, "destroy",
3889 G_CALLBACK (destroy_tooltips),
3892 tooltips=gtk_tooltips_new();
3893 g_object_ref (tooltips);
3894 gtk_object_sink (GTK_OBJECT (tooltips));
3895 g_object_set_data (G_OBJECT (window), "tooltips", tooltips);
3897 box1 = gtk_vbox_new (FALSE, 0);
3898 gtk_container_add (GTK_CONTAINER (window), box1);
3900 box2 = gtk_vbox_new (FALSE, 10);
3901 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
3902 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
3904 button = gtk_toggle_button_new_with_label ("button1");
3905 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
3907 gtk_tooltips_set_tip (tooltips,
3910 "ContextHelp/buttons/1");
3912 button = gtk_toggle_button_new_with_label ("button2");
3913 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
3915 gtk_tooltips_set_tip (tooltips,
3917 "This is button 2. This is also a really long tooltip which probably won't fit on a single line and will therefore need to be wrapped. Hopefully the wrapping will work correctly.",
3918 "ContextHelp/buttons/2_long");
3920 toggle = gtk_toggle_button_new_with_label ("Override TipsQuery Label");
3921 gtk_box_pack_start (GTK_BOX (box2), toggle, TRUE, TRUE, 0);
3923 gtk_tooltips_set_tip (tooltips,
3925 "Toggle TipsQuery view.",
3929 gtk_widget_new (gtk_vbox_get_type (),
3930 "homogeneous", FALSE,
3936 tips_query = gtk_tips_query_new ();
3939 gtk_widget_new (gtk_button_get_type (),
3944 g_object_connect (button,
3945 "swapped_signal::clicked", gtk_tips_query_start_query, tips_query,
3947 gtk_box_set_child_packing (GTK_BOX (box3), button, FALSE, FALSE, 0, GTK_PACK_START);
3948 gtk_tooltips_set_tip (tooltips,
3950 "Start the Tooltips Inspector",
3951 "ContextHelp/buttons/?");
3954 g_object_set (g_object_connect (tips_query,
3955 "signal::widget_entered", tips_query_widget_entered, toggle,
3956 "signal::widget_selected", tips_query_widget_selected, NULL,
3963 frame = gtk_widget_new (gtk_frame_get_type (),
3964 "label", "ToolTips Inspector",
3965 "label_xalign", (double) 0.5,
3971 gtk_box_set_child_packing (GTK_BOX (box2), frame, TRUE, TRUE, 10, GTK_PACK_START);
3973 separator = gtk_hseparator_new ();
3974 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
3976 box2 = gtk_vbox_new (FALSE, 10);
3977 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
3978 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
3980 button = gtk_button_new_with_label ("close");
3981 g_signal_connect_swapped (button, "clicked",
3982 G_CALLBACK (gtk_widget_destroy),
3984 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
3985 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
3986 gtk_widget_grab_default (button);
3988 gtk_tooltips_set_tip (tooltips, button, "Push this button to close window", "ContextHelp/buttons/Close");
3991 if (!GTK_WIDGET_VISIBLE (window))
3992 gtk_widget_show_all (window);
3994 gtk_widget_destroy (window);
4002 pack_image (GtkWidget *box,
4006 gtk_box_pack_start (GTK_BOX (box),
4007 gtk_label_new (text),
4010 gtk_box_pack_start (GTK_BOX (box),
4016 create_image (GtkWidget *widget)
4018 static GtkWidget *window = NULL;
4026 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
4028 gtk_window_set_screen (GTK_WINDOW (window),
4029 gtk_widget_get_screen (widget));
4031 /* this is bogus for testing drawing when allocation < request,
4032 * don't copy into real code
4034 g_object_set (window, "allow_shrink", TRUE, "allow_grow", TRUE, NULL);
4036 g_signal_connect (window, "destroy",
4037 G_CALLBACK (gtk_widget_destroyed),
4040 vbox = gtk_vbox_new (FALSE, 5);
4042 gtk_container_add (GTK_CONTAINER (window), vbox);
4044 pack_image (vbox, "Stock Warning Dialog",
4045 gtk_image_new_from_stock (GTK_STOCK_DIALOG_WARNING,
4046 GTK_ICON_SIZE_DIALOG));
4048 pixmap = gdk_pixmap_colormap_create_from_xpm_d (NULL,
4049 gtk_widget_get_colormap (window),
4054 pack_image (vbox, "Pixmap",
4055 gtk_image_new_from_pixmap (pixmap, mask));
4058 if (!GTK_WIDGET_VISIBLE (window))
4059 gtk_widget_show_all (window);
4061 gtk_widget_destroy (window);
4069 create_menu (GdkScreen *screen, gint depth, gint length, gboolean tearoff)
4072 GtkWidget *menuitem;
4081 menu = gtk_menu_new ();
4082 gtk_menu_set_screen (GTK_MENU (menu), screen);
4088 menuitem = gtk_tearoff_menu_item_new ();
4089 gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
4090 gtk_widget_show (menuitem);
4093 image = gtk_image_new_from_stock (GTK_STOCK_OPEN,
4094 GTK_ICON_SIZE_MENU);
4095 gtk_widget_show (image);
4096 menuitem = gtk_image_menu_item_new_with_label ("Image item");
4097 gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menuitem), image);
4098 gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
4099 gtk_widget_show (menuitem);
4101 for (i = 0, j = 1; i < length; i++, j++)
4103 sprintf (buf, "item %2d - %d", depth, j);
4105 menuitem = gtk_radio_menu_item_new_with_label (group, buf);
4106 group = gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (menuitem));
4110 gtk_check_menu_item_set_show_toggle (GTK_CHECK_MENU_ITEM (menuitem), TRUE);
4113 gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
4114 gtk_widget_show (menuitem);
4116 gtk_widget_set_sensitive (menuitem, FALSE);
4119 gtk_check_menu_item_set_inconsistent (GTK_CHECK_MENU_ITEM (menuitem),
4123 gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem),
4124 create_menu (screen, depth - 1, 5, TRUE));
4131 create_table_menu (GdkScreen *screen, gint cols, gint rows, gboolean tearoff)
4134 GtkWidget *menuitem;
4140 menu = gtk_menu_new ();
4141 gtk_menu_set_screen (GTK_MENU (menu), screen);
4146 menuitem = gtk_tearoff_menu_item_new ();
4147 gtk_menu_attach (GTK_MENU (menu), menuitem, 0, cols, j, j + 1);
4148 gtk_widget_show (menuitem);
4152 menuitem = gtk_menu_item_new_with_label ("items");
4153 gtk_menu_attach (GTK_MENU (menu), menuitem, 0, cols, j, j + 1);
4155 submenu = gtk_menu_new ();
4156 gtk_menu_set_screen (GTK_MENU (submenu), screen);
4157 gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), submenu);
4158 gtk_widget_show (menuitem);
4161 /* now fill the items submenu */
4162 image = gtk_image_new_from_stock (GTK_STOCK_HELP,
4163 GTK_ICON_SIZE_MENU);
4164 gtk_widget_show (image);
4165 menuitem = gtk_image_menu_item_new_with_label ("Image");
4166 gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menuitem), image);
4167 gtk_menu_attach (GTK_MENU (submenu), menuitem, 0, 1, 0, 1);
4168 gtk_widget_show (menuitem);
4170 menuitem = gtk_menu_item_new_with_label ("x");
4171 gtk_menu_attach (GTK_MENU (submenu), menuitem, 1, 2, 0, 1);
4172 gtk_widget_show (menuitem);
4174 menuitem = gtk_menu_item_new_with_label ("x");
4175 gtk_menu_attach (GTK_MENU (submenu), menuitem, 0, 1, 1, 2);
4176 gtk_widget_show (menuitem);
4178 image = gtk_image_new_from_stock (GTK_STOCK_HELP,
4179 GTK_ICON_SIZE_MENU);
4180 gtk_widget_show (image);
4181 menuitem = gtk_image_menu_item_new_with_label ("Image");
4182 gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menuitem), image);
4183 gtk_menu_attach (GTK_MENU (submenu), menuitem, 1, 2, 1, 2);
4184 gtk_widget_show (menuitem);
4186 menuitem = gtk_radio_menu_item_new_with_label (NULL, "Radio");
4187 gtk_menu_attach (GTK_MENU (submenu), menuitem, 0, 1, 2, 3);
4188 gtk_widget_show (menuitem);
4190 menuitem = gtk_menu_item_new_with_label ("x");
4191 gtk_menu_attach (GTK_MENU (submenu), menuitem, 1, 2, 2, 3);
4192 gtk_widget_show (menuitem);
4194 menuitem = gtk_menu_item_new_with_label ("x");
4195 gtk_menu_attach (GTK_MENU (submenu), menuitem, 0, 1, 3, 4);
4196 gtk_widget_show (menuitem);
4198 menuitem = gtk_radio_menu_item_new_with_label (NULL, "Radio");
4199 gtk_menu_attach (GTK_MENU (submenu), menuitem, 1, 2, 3, 4);
4200 gtk_widget_show (menuitem);
4202 menuitem = gtk_check_menu_item_new_with_label ("Check");
4203 gtk_menu_attach (GTK_MENU (submenu), menuitem, 0, 1, 4, 5);
4204 gtk_widget_show (menuitem);
4206 menuitem = gtk_menu_item_new_with_label ("x");
4207 gtk_menu_attach (GTK_MENU (submenu), menuitem, 1, 2, 4, 5);
4208 gtk_widget_show (menuitem);
4210 menuitem = gtk_menu_item_new_with_label ("x");
4211 gtk_menu_attach (GTK_MENU (submenu), menuitem, 0, 1, 5, 6);
4212 gtk_widget_show (menuitem);
4214 menuitem = gtk_check_menu_item_new_with_label ("Check");
4215 gtk_menu_attach (GTK_MENU (submenu), menuitem, 1, 2, 5, 6);
4216 gtk_widget_show (menuitem);
4218 menuitem = gtk_menu_item_new_with_label ("1. Inserted normally (8)");
4219 gtk_widget_show (menuitem);
4220 gtk_menu_shell_insert (GTK_MENU_SHELL (submenu), menuitem, 8);
4222 menuitem = gtk_menu_item_new_with_label ("2. Inserted normally (2)");
4223 gtk_widget_show (menuitem);
4224 gtk_menu_shell_insert (GTK_MENU_SHELL (submenu), menuitem, 2);
4226 menuitem = gtk_menu_item_new_with_label ("3. Inserted normally (0)");
4227 gtk_widget_show (menuitem);
4228 gtk_menu_shell_insert (GTK_MENU_SHELL (submenu), menuitem, 0);
4230 menuitem = gtk_menu_item_new_with_label ("4. Inserted normally (-1)");
4231 gtk_widget_show (menuitem);
4232 gtk_menu_shell_insert (GTK_MENU_SHELL (submenu), menuitem, -1);
4234 /* end of items submenu */
4236 menuitem = gtk_menu_item_new_with_label ("spanning");
4237 gtk_menu_attach (GTK_MENU (menu), menuitem, 0, cols, j, j + 1);
4239 submenu = gtk_menu_new ();
4240 gtk_menu_set_screen (GTK_MENU (submenu), screen);
4241 gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), submenu);
4242 gtk_widget_show (menuitem);
4245 /* now fill the spanning submenu */
4246 menuitem = gtk_menu_item_new_with_label ("a");
4247 gtk_menu_attach (GTK_MENU (submenu), menuitem, 0, 2, 0, 1);
4248 gtk_widget_show (menuitem);
4250 menuitem = gtk_menu_item_new_with_label ("b");
4251 gtk_menu_attach (GTK_MENU (submenu), menuitem, 2, 3, 0, 2);
4252 gtk_widget_show (menuitem);
4254 menuitem = gtk_menu_item_new_with_label ("c");
4255 gtk_menu_attach (GTK_MENU (submenu), menuitem, 0, 1, 1, 3);
4256 gtk_widget_show (menuitem);
4258 menuitem = gtk_menu_item_new_with_label ("d");
4259 gtk_menu_attach (GTK_MENU (submenu), menuitem, 1, 2, 1, 2);
4260 gtk_widget_show (menuitem);
4262 menuitem = gtk_menu_item_new_with_label ("e");
4263 gtk_menu_attach (GTK_MENU (submenu), menuitem, 1, 3, 2, 3);
4264 gtk_widget_show (menuitem);
4265 /* end of spanning submenu */
4267 menuitem = gtk_menu_item_new_with_label ("left");
4268 gtk_menu_attach (GTK_MENU (menu), menuitem, 0, 1, j, j + 1);
4269 submenu = gtk_menu_new ();
4270 gtk_menu_set_screen (GTK_MENU (submenu), screen);
4271 gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), submenu);
4272 gtk_widget_show (menuitem);
4274 menuitem = gtk_menu_item_new_with_label ("Empty");
4275 gtk_menu_attach (GTK_MENU (submenu), menuitem, 0, 1, 0, 1);
4276 submenu = gtk_menu_new ();
4277 gtk_menu_set_screen (GTK_MENU (submenu), screen);
4278 gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), submenu);
4279 gtk_widget_show (menuitem);
4281 menuitem = gtk_menu_item_new_with_label ("right");
4282 gtk_menu_attach (GTK_MENU (menu), menuitem, 1, 2, j, j + 1);
4283 submenu = gtk_menu_new ();
4284 gtk_menu_set_screen (GTK_MENU (submenu), screen);
4285 gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), submenu);
4286 gtk_widget_show (menuitem);
4288 menuitem = gtk_menu_item_new_with_label ("Empty");
4289 gtk_menu_attach (GTK_MENU (submenu), menuitem, 0, 1, 0, 1);
4290 gtk_widget_show (menuitem);
4294 for (; j < rows; j++)
4295 for (i = 0; i < cols; i++)
4297 sprintf (buf, "(%d %d)", i, j);
4298 menuitem = gtk_menu_item_new_with_label (buf);
4299 gtk_menu_attach (GTK_MENU (menu), menuitem, i, i + 1, j, j + 1);
4300 gtk_widget_show (menuitem);
4303 menuitem = gtk_menu_item_new_with_label ("1. Inserted normally (8)");
4304 gtk_menu_shell_insert (GTK_MENU_SHELL (menu), menuitem, 8);
4305 gtk_widget_show (menuitem);
4306 menuitem = gtk_menu_item_new_with_label ("2. Inserted normally (2)");
4307 gtk_menu_shell_insert (GTK_MENU_SHELL (menu), menuitem, 2);
4308 gtk_widget_show (menuitem);
4309 menuitem = gtk_menu_item_new_with_label ("3. Inserted normally (0)");
4310 gtk_menu_shell_insert (GTK_MENU_SHELL (menu), menuitem, 0);
4311 gtk_widget_show (menuitem);
4312 menuitem = gtk_menu_item_new_with_label ("4. Inserted normally (-1)");
4313 gtk_menu_shell_insert (GTK_MENU_SHELL (menu), menuitem, -1);
4314 gtk_widget_show (menuitem);
4320 create_menus (GtkWidget *widget)
4322 static GtkWidget *window = NULL;
4326 GtkWidget *optionmenu;
4327 GtkWidget *separator;
4333 GtkWidget *menuitem;
4334 GtkAccelGroup *accel_group;
4336 GdkScreen *screen = gtk_widget_get_screen (widget);
4338 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
4340 gtk_window_set_screen (GTK_WINDOW (window), screen);
4342 g_signal_connect (window, "destroy",
4343 G_CALLBACK (gtk_widget_destroyed),
4345 g_signal_connect (window, "delete-event",
4346 G_CALLBACK (gtk_true),
4349 accel_group = gtk_accel_group_new ();
4350 gtk_window_add_accel_group (GTK_WINDOW (window), accel_group);
4352 gtk_window_set_title (GTK_WINDOW (window), "menus");
4353 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
4356 box1 = gtk_vbox_new (FALSE, 0);
4357 gtk_container_add (GTK_CONTAINER (window), box1);
4358 gtk_widget_show (box1);
4360 menubar = gtk_menu_bar_new ();
4361 gtk_box_pack_start (GTK_BOX (box1), menubar, FALSE, TRUE, 0);
4362 gtk_widget_show (menubar);
4364 menu = create_menu (screen, 2, 50, TRUE);
4366 menuitem = gtk_menu_item_new_with_label ("test\nline2");
4367 gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), menu);
4368 gtk_menu_shell_append (GTK_MENU_SHELL (menubar), menuitem);
4369 gtk_widget_show (menuitem);
4371 menu = create_table_menu (screen, 2, 50, TRUE);
4373 menuitem = gtk_menu_item_new_with_label ("table");
4374 gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), menu);
4375 gtk_menu_shell_append (GTK_MENU_SHELL (menubar), menuitem);
4376 gtk_widget_show (menuitem);
4378 menuitem = gtk_menu_item_new_with_label ("foo");
4379 gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), create_menu (screen, 3, 5, TRUE));
4380 gtk_menu_shell_append (GTK_MENU_SHELL (menubar), menuitem);
4381 gtk_widget_show (menuitem);
4383 image = gtk_image_new_from_stock (GTK_STOCK_HELP,
4384 GTK_ICON_SIZE_MENU);
4385 gtk_widget_show (image);
4386 menuitem = gtk_image_menu_item_new_with_label ("Help");
4387 gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menuitem), image);
4388 gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), create_menu (screen, 4, 5, TRUE));
4389 gtk_menu_item_set_right_justified (GTK_MENU_ITEM (menuitem), TRUE);
4390 gtk_menu_shell_append (GTK_MENU_SHELL (menubar), menuitem);
4391 gtk_widget_show (menuitem);
4393 menubar = gtk_menu_bar_new ();
4394 gtk_box_pack_start (GTK_BOX (box1), menubar, FALSE, TRUE, 0);
4395 gtk_widget_show (menubar);
4397 menu = create_menu (screen, 2, 10, TRUE);
4399 menuitem = gtk_menu_item_new_with_label ("Second menu bar");
4400 gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), menu);
4401 gtk_menu_shell_append (GTK_MENU_SHELL (menubar), menuitem);
4402 gtk_widget_show (menuitem);
4404 box2 = gtk_vbox_new (FALSE, 10);
4405 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
4406 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
4407 gtk_widget_show (box2);
4409 menu = create_menu (screen, 1, 5, FALSE);
4410 gtk_menu_set_accel_group (GTK_MENU (menu), accel_group);
4412 menuitem = gtk_image_menu_item_new_from_stock (GTK_STOCK_NEW, accel_group);
4413 gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
4414 gtk_widget_show (menuitem);
4416 menuitem = gtk_check_menu_item_new_with_label ("Accelerate Me");
4417 gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
4418 gtk_widget_show (menuitem);
4419 gtk_widget_add_accelerator (menuitem,
4425 menuitem = gtk_check_menu_item_new_with_label ("Accelerator Locked");
4426 gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
4427 gtk_widget_show (menuitem);
4428 gtk_widget_add_accelerator (menuitem,
4433 GTK_ACCEL_VISIBLE | GTK_ACCEL_LOCKED);
4434 menuitem = gtk_check_menu_item_new_with_label ("Accelerators Frozen");
4435 gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
4436 gtk_widget_show (menuitem);
4437 gtk_widget_add_accelerator (menuitem,
4443 gtk_widget_add_accelerator (menuitem,
4450 optionmenu = gtk_option_menu_new ();
4451 gtk_option_menu_set_menu (GTK_OPTION_MENU (optionmenu), menu);
4452 gtk_option_menu_set_history (GTK_OPTION_MENU (optionmenu), 3);
4453 gtk_box_pack_start (GTK_BOX (box2), optionmenu, TRUE, TRUE, 0);
4454 gtk_widget_show (optionmenu);
4456 separator = gtk_hseparator_new ();
4457 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
4458 gtk_widget_show (separator);
4460 box2 = gtk_vbox_new (FALSE, 10);
4461 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
4462 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
4463 gtk_widget_show (box2);
4465 button = gtk_button_new_with_label ("close");
4466 g_signal_connect_swapped (button, "clicked",
4467 G_CALLBACK (gtk_widget_destroy),
4469 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
4470 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
4471 gtk_widget_grab_default (button);
4472 gtk_widget_show (button);
4475 if (!GTK_WIDGET_VISIBLE (window))
4476 gtk_widget_show (window);
4478 gtk_widget_destroy (window);
4482 gtk_ifactory_cb (gpointer callback_data,
4483 guint callback_action,
4486 g_message ("ItemFactory: activated \"%s\"", gtk_item_factory_path_from_widget (widget));
4489 /* GdkPixbuf RGBA C-Source image dump */
4491 static const guint8 apple[] =
4493 /* Pixbuf magic (0x47646b50) */
4495 /* length: header (24) + pixel_data (2304) */
4497 /* pixdata_type (0x1010002) */
4499 /* rowstride (96) */
4506 "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
4507 "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
4508 "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
4509 "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
4510 "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
4511 "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
4512 "\0\0\0\0\0\0\0\0\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"
4513 "\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"
4514 "\0\0\0\0\0\0\0\0\0\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"
4515 "[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"
4516 "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
4517 "\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"
4518 "\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"
4519 "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
4520 "\0\0\0\0\0\0`l\\\20iw_\356y\211h\373x\207g\364~\216i\364u\204e\366gt"
4521 "_\374^jX\241A;-_\0\0\0~\0\0\0\0SM4)SM21B9&\22\320\270\204\1\320\270\204"
4522 "\0\0\0\0\0\0\0\0\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"
4523 "]\212r\200c\366v\205f\371jx_\323_kY\232_kZH^jY\26]iW\211@G9\272:6%j\220"
4524 "\211]\320\221\211`\377\212\203Z\377~xP\377mkE\331]^;|/0\37\21\0\0\0\0"
4525 "\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["
4526 "eT<\216\200Z\203\227\211_\354\234\217c\377\232\217b\362\232\220c\337"
4527 "\243\233k\377\252\241p\377\250\236p\377\241\225h\377\231\214_\377\210"
4528 "\202U\377srI\377[]:\355KO0U\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0i"
4529 "v^\200`lY\211^jY\"\0\0\0\0\221\204\\\273\250\233r\377\302\267\224\377"
4530 "\311\300\237\377\272\256\204\377\271\256\177\377\271\257\200\377\267"
4531 "\260\177\377\260\251x\377\250\236l\377\242\225e\377\226\213]\377~zP\377"
4532 "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"
4533 "\0\213\203[v\253\240t\377\334\326\301\377\344\340\317\377\321\312\253"
4534 "\377\303\271\217\377\300\270\213\377\277\267\210\377\272\264\203\377"
4535 "\261\255z\377\250\242n\377\243\232h\377\232\220`\377\210\202V\377nnE"
4536 "\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"
4537 "\234\222e\362\304\274\232\377\337\333\306\377\332\325\273\377\311\302"
4538 "\232\377\312\303\236\377\301\273\216\377\300\271\212\377\270\264\200"
4539 "\377\256\253v\377\246\243n\377\236\232h\377\230\220`\377\213\203V\377"
4540 "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"
4541 "\203Zl\242\234l\377\321\315\260\377\331\324\271\377\320\313\251\377\307"
4542 "\301\232\377\303\276\224\377\300\272\214\377\274\267\206\377\264\260"
4543 "|\377\253\251s\377\244\243n\377\232\230e\377\223\216^\377\207\200U\377"
4544 "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"
4545 "\210\204Y\240\245\237o\377\316\310\253\377\310\303\237\377\304\300\230"
4546 "\377\303\277\225\377\277\272\216\377\274\270\210\377\266\263\200\377"
4547 "\256\254v\377\247\246p\377\237\236j\377\227\226d\377\215\212[\377\203"
4548 "\177T\377qsH\377X]8\377FN.\377DK-\200\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
4549 "\0\0\0\0\207\204X\257\244\240o\377\300\275\231\377\301\275\226\377\274"
4550 "\270\213\377\274\270\214\377\267\264\205\377\264\262\200\377\260\256"
4551 "z\377\251\251s\377\243\244n\377\231\232g\377\220\222`\377\210\211Y\377"
4552 "|}Q\377hlC\377PU3\377CK,\377DL/Y\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
4553 "\0\0\205\204X\220\232\230h\377\261\260\204\377\266\264\212\377\261\260"
4554 "\201\377\263\260\200\377\260\257}\377\256\256x\377\253\254t\377\244\246"
4555 "o\377\233\236i\377\221\224b\377\211\214\\\377\202\204V\377txM\377]b>"
4556 "\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>"
4557 "\215\215_\377\237\237r\377\247\247x\377\247\247t\377\252\252w\377\252"
4558 "\252u\377\252\253t\377\243\246o\377\235\240j\377\223\230c\377\213\217"
4559 "]\377\201\206V\377x}P\377gkD\377RY5\377BI,\377AI,\262\0\0\0\0\0\0\0\0"
4560 "\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"
4561 "\232g\377\234\236i\377\236\241l\377\241\244n\377\240\244m\377\232\237"
4562 "i\377\223\230c\377\212\221]\377\200\210W\377v|P\377jnG\377Za>\377HP2"
4563 "\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"
4564 "\0wzQ6\177\201U\371\206\211Z\377\216\222`\377\220\225a\377\220\225b\377"
4565 "\220\226a\377\213\221_\377\204\213Z\377{\203R\377ryN\377iqH\377^fA\377"
4566 "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"
4567 "\0\0\0\0\0\0\0\0\0\0\0\0ptJTw|Q\371z\177R\377}\202T\377|\203T\377z\200"
4568 "R\377v|O\377pwL\377jpF\377dlB\377`hB\377Yb@\377LT6\377<C*\377\11\12\6"
4569 "\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"
4570 "\0\0\0\0\0\0\0\0\0\0\\`=UgnE\370hnG\377gmE\377djB\377]d>\377[c<\377Y"
4571 "b<\377Zc>\377V_>\377OW8\377BK/\377\16\20\12\377\0\0\0\377\0\0\0\377\0"
4572 "\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"
4573 "\0\1\0\0\0\40\22\24\15\260@D+\377W`;\377OV5\377.3\36\377.3\37\377IP0"
4574 "\377RZ7\377PZ8\3776=&\377\14\15\10\377\0\0\0\377\0\0\0\377\0\0\0\377"
4575 "\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"
4576 "\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"
4577 "\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"
4578 "\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"
4579 "\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"
4580 "\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"
4581 "\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"
4582 "\0\0\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"
4583 "\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"
4584 "\0\0\5\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"};
4588 dump_accels (gpointer callback_data,
4589 guint callback_action,
4592 gtk_accel_map_save_fd (1 /* stdout */);
4595 static GtkItemFactoryEntry menu_items[] =
4597 { "/_File", NULL, NULL, 0, "<Branch>" },
4598 { "/File/tearoff1", NULL, gtk_ifactory_cb, 0, "<Tearoff>" },
4599 { "/File/_New", NULL, gtk_ifactory_cb, 0, "<StockItem>", GTK_STOCK_NEW },
4600 { "/File/_Open", NULL, gtk_ifactory_cb, 0, "<StockItem>", GTK_STOCK_OPEN },
4601 { "/File/_Save", NULL, gtk_ifactory_cb, 0, "<StockItem>", GTK_STOCK_SAVE },
4602 { "/File/Save _As...", "<control>A", gtk_ifactory_cb, 0, "<StockItem>", GTK_STOCK_SAVE },
4603 { "/File/_Dump \"_Accels\"", NULL, dump_accels, 0 },
4604 { "/File/\\/Test__Escaping/And\\/\n\tWei\\\\rdly",
4605 NULL, gtk_ifactory_cb, 0 },
4606 { "/File/sep1", NULL, gtk_ifactory_cb, 0, "<Separator>" },
4607 { "/File/_Quit", NULL, gtk_ifactory_cb, 0, "<StockItem>", GTK_STOCK_QUIT },
4609 { "/_Preferences", NULL, 0, 0, "<Branch>" },
4610 { "/_Preferences/_Color", NULL, 0, 0, "<Branch>" },
4611 { "/_Preferences/Color/_Red", NULL, gtk_ifactory_cb, 0, "<RadioItem>" },
4612 { "/_Preferences/Color/_Green", NULL, gtk_ifactory_cb, 0, "/Preferences/Color/Red" },
4613 { "/_Preferences/Color/_Blue", NULL, gtk_ifactory_cb, 0, "/Preferences/Color/Red" },
4614 { "/_Preferences/_Shape", NULL, 0, 0, "<Branch>" },
4615 { "/_Preferences/Shape/_Square", NULL, gtk_ifactory_cb, 0, "<RadioItem>" },
4616 { "/_Preferences/Shape/_Rectangle", NULL, gtk_ifactory_cb, 0, "/Preferences/Shape/Square" },
4617 { "/_Preferences/Shape/_Oval", NULL, gtk_ifactory_cb, 0, "/Preferences/Shape/Rectangle" },
4618 { "/_Preferences/Shape/_Rectangle", NULL, gtk_ifactory_cb, 0, "/Preferences/Shape/Square" },
4619 { "/_Preferences/Shape/_Oval", NULL, gtk_ifactory_cb, 0, "/Preferences/Shape/Rectangle" },
4620 { "/_Preferences/Shape/_Image", NULL, gtk_ifactory_cb, 0, "<ImageItem>", apple },
4621 { "/_Preferences/Coffee", NULL, gtk_ifactory_cb, 0, "<CheckItem>" },
4622 { "/_Preferences/Toast", NULL, gtk_ifactory_cb, 0, "<CheckItem>" },
4623 { "/_Preferences/Marshmallow Froot Loops", NULL, gtk_ifactory_cb, 0, "<CheckItem>" },
4625 /* For testing deletion of menus */
4626 { "/_Preferences/Should_NotAppear", NULL, 0, 0, "<Branch>" },
4627 { "/Preferences/ShouldNotAppear/SubItem1", NULL, gtk_ifactory_cb, 0 },
4628 { "/Preferences/ShouldNotAppear/SubItem2", NULL, gtk_ifactory_cb, 0 },
4630 { "/_Help", NULL, 0, 0, "<LastBranch>" },
4631 { "/Help/_Help", NULL, gtk_ifactory_cb, 0, "<StockItem>", GTK_STOCK_HELP},
4632 { "/Help/_About", NULL, gtk_ifactory_cb, 0 },
4636 static int nmenu_items = sizeof (menu_items) / sizeof (menu_items[0]);
4639 create_item_factory (GtkWidget *widget)
4641 static GtkWidget *window = NULL;
4647 GtkWidget *separator;
4650 GtkAccelGroup *accel_group;
4651 GtkItemFactory *item_factory;
4652 GtkTooltips *tooltips;
4654 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
4656 gtk_window_set_screen (GTK_WINDOW (window),
4657 gtk_widget_get_screen (widget));
4659 g_signal_connect (window, "destroy",
4660 G_CALLBACK(gtk_widget_destroyed),
4662 g_signal_connect (window, "delete-event",
4663 G_CALLBACK (gtk_true),
4666 accel_group = gtk_accel_group_new ();
4667 item_factory = gtk_item_factory_new (GTK_TYPE_MENU_BAR, "<main>", accel_group);
4668 g_object_set_data_full (G_OBJECT (window),
4672 gtk_window_add_accel_group (GTK_WINDOW (window), accel_group);
4673 gtk_window_set_title (GTK_WINDOW (window), "Item Factory");
4674 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
4675 gtk_item_factory_create_items (item_factory, nmenu_items, menu_items, NULL);
4677 /* preselect /Preferences/Shape/Oval over the other radios
4679 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (gtk_item_factory_get_item (item_factory,
4680 "/Preferences/Shape/Oval")),
4683 /* preselect /Preferences/Coffee
4685 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (gtk_item_factory_get_item (item_factory,
4686 "/Preferences/Coffee")),
4689 /* preselect /Preferences/Marshmallow Froot Loops and set it insensitive
4691 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (gtk_item_factory_get_item (item_factory,
4692 "/Preferences/Marshmallow Froot Loops")),
4694 gtk_widget_set_sensitive (GTK_WIDGET (gtk_item_factory_get_item (item_factory,
4695 "/Preferences/Marshmallow Froot Loops")),
4698 /* Test how tooltips (ugh) work on menu items
4700 tooltips = gtk_tooltips_new ();
4701 g_object_ref (tooltips);
4702 gtk_object_sink (GTK_OBJECT (tooltips));
4703 g_object_set_data_full (G_OBJECT (window), "testgtk-tooltips",
4704 tooltips, (GDestroyNotify)g_object_unref);
4706 gtk_tooltips_set_tip (tooltips, gtk_item_factory_get_item (item_factory, "/File/New"),
4707 "Create a new file", NULL);
4708 gtk_tooltips_set_tip (tooltips, gtk_item_factory_get_item (item_factory, "/File/Open"),
4709 "Open a file", NULL);
4710 gtk_tooltips_set_tip (tooltips, gtk_item_factory_get_item (item_factory, "/File/Save"),
4712 gtk_tooltips_set_tip (tooltips, gtk_item_factory_get_item (item_factory, "/Preferences/Color"),
4713 "Modify color", NULL);
4715 box1 = gtk_vbox_new (FALSE, 0);
4716 gtk_container_add (GTK_CONTAINER (window), box1);
4718 gtk_box_pack_start (GTK_BOX (box1),
4719 gtk_item_factory_get_widget (item_factory, "<main>"),
4722 label = gtk_label_new ("Type\n<alt>\nto start");
4723 gtk_widget_set_size_request (label, 200, 200);
4724 gtk_misc_set_alignment (GTK_MISC (label), 0.5, 0.5);
4725 gtk_box_pack_start (GTK_BOX (box1), label, TRUE, TRUE, 0);
4728 separator = gtk_hseparator_new ();
4729 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
4732 box2 = gtk_vbox_new (FALSE, 10);
4733 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
4734 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
4736 button = gtk_button_new_with_label ("close");
4737 g_signal_connect_swapped (button, "clicked",
4738 G_CALLBACK (gtk_widget_destroy),
4740 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
4741 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
4742 gtk_widget_grab_default (button);
4744 gtk_item_factory_delete_item (item_factory, "/Preferences/ShouldNotAppear");
4746 gtk_widget_show_all (window);
4749 gtk_widget_destroy (window);
4753 accel_button_new (GtkAccelGroup *accel_group,
4758 GdkModifierType modifiers;
4762 gtk_accelerator_parse (accel, &keyval, &modifiers);
4765 button = gtk_button_new ();
4766 gtk_widget_add_accelerator (button, "activate", accel_group,
4767 keyval, modifiers, GTK_ACCEL_VISIBLE | GTK_ACCEL_LOCKED);
4769 label = gtk_accel_label_new (text);
4770 gtk_accel_label_set_accel_widget (GTK_ACCEL_LABEL (label), button);
4771 gtk_widget_show (label);
4773 gtk_container_add (GTK_CONTAINER (button), label);
4779 create_key_lookup (GtkWidget *widget)
4781 static GtkWidget *window = NULL;
4785 GtkAccelGroup *accel_group = gtk_accel_group_new ();
4788 window = gtk_dialog_new_with_buttons ("Key Lookup", NULL, 0,
4789 GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE,
4792 gtk_window_set_screen (GTK_WINDOW (window),
4793 gtk_widget_get_screen (widget));
4795 /* We have to expand it so the accel labels will draw their labels
4797 gtk_window_set_default_size (GTK_WINDOW (window), 300, -1);
4799 gtk_window_add_accel_group (GTK_WINDOW (window), accel_group);
4801 button = gtk_button_new_with_mnemonic ("Button 1 (_a)");
4802 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), button, FALSE, FALSE, 0);
4803 button = gtk_button_new_with_mnemonic ("Button 2 (_A)");
4804 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), button, FALSE, FALSE, 0);
4805 button = gtk_button_new_with_mnemonic ("Button 3 (_\321\204)");
4806 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), button, FALSE, FALSE, 0);
4807 button = gtk_button_new_with_mnemonic ("Button 4 (_\320\244)");
4808 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), button, FALSE, FALSE, 0);
4809 button = gtk_button_new_with_mnemonic ("Button 6 (_b)");
4810 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), button, FALSE, FALSE, 0);
4811 button = accel_button_new (accel_group, "Button 7", "<Alt><Shift>b");
4812 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), button, FALSE, FALSE, 0);
4813 button = accel_button_new (accel_group, "Button 8", "<Alt>d");
4814 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), button, FALSE, FALSE, 0);
4815 button = accel_button_new (accel_group, "Button 9", "<Alt>Cyrillic_ve");
4816 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), button, FALSE, FALSE, 0);
4817 button = gtk_button_new_with_mnemonic ("Button 10 (_1)");
4818 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), button, FALSE, FALSE, 0);
4819 button = gtk_button_new_with_mnemonic ("Button 11 (_!)");
4820 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), button, FALSE, FALSE, 0);
4821 button = accel_button_new (accel_group, "Button 12", "<Super>a");
4822 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), button, FALSE, FALSE, 0);
4823 button = accel_button_new (accel_group, "Button 13", "<Hyper>a");
4824 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), button, FALSE, FALSE, 0);
4825 button = accel_button_new (accel_group, "Button 14", "<Meta>a");
4826 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), button, FALSE, FALSE, 0);
4827 button = accel_button_new (accel_group, "Button 15", "<Shift><Mod4>b");
4828 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), button, FALSE, FALSE, 0);
4830 g_object_add_weak_pointer (G_OBJECT (window), (gpointer) &window);
4831 g_signal_connect (window, "response", G_CALLBACK (gtk_object_destroy), NULL);
4833 gtk_widget_show_all (window);
4836 gtk_widget_destroy (window);
4845 cmw_destroy_cb(GtkWidget *widget)
4847 /* This is needed to get out of gtk_main */
4854 cmw_color (GtkWidget *widget, GtkWidget *parent)
4858 csd = gtk_color_selection_dialog_new ("This is a modal color selection dialog");
4860 gtk_window_set_screen (GTK_WINDOW (csd), gtk_widget_get_screen (parent));
4862 gtk_color_selection_set_has_palette (GTK_COLOR_SELECTION (GTK_COLOR_SELECTION_DIALOG (csd)->colorsel),
4866 gtk_window_set_modal (GTK_WINDOW(csd),TRUE);
4868 /* And mark it as a transient dialog */
4869 gtk_window_set_transient_for (GTK_WINDOW (csd), GTK_WINDOW (parent));
4871 g_signal_connect (csd, "destroy",
4872 G_CALLBACK (cmw_destroy_cb), NULL);
4874 g_signal_connect_swapped (GTK_COLOR_SELECTION_DIALOG (csd)->ok_button,
4875 "clicked", G_CALLBACK (gtk_widget_destroy), csd);
4876 g_signal_connect_swapped (GTK_COLOR_SELECTION_DIALOG (csd)->cancel_button,
4877 "clicked", G_CALLBACK (gtk_widget_destroy), csd);
4879 /* wait until destroy calls gtk_main_quit */
4880 gtk_widget_show (csd);
4885 cmw_file (GtkWidget *widget, GtkWidget *parent)
4889 fs = gtk_file_selection_new("This is a modal file selection dialog");
4891 gtk_window_set_screen (GTK_WINDOW (fs), gtk_widget_get_screen (parent));
4894 gtk_window_set_modal (GTK_WINDOW(fs),TRUE);
4896 /* And mark it as a transient dialog */
4897 gtk_window_set_transient_for (GTK_WINDOW (fs), GTK_WINDOW (parent));
4899 g_signal_connect (fs, "destroy",
4900 G_CALLBACK (cmw_destroy_cb), NULL);
4902 g_signal_connect_swapped (GTK_FILE_SELECTION (fs)->ok_button,
4903 "clicked", G_CALLBACK (gtk_widget_destroy), fs);
4904 g_signal_connect_swapped (GTK_FILE_SELECTION (fs)->cancel_button,
4905 "clicked", G_CALLBACK (gtk_widget_destroy), fs);
4907 /* wait until destroy calls gtk_main_quit */
4908 gtk_widget_show (fs);
4915 create_modal_window (GtkWidget *widget)
4917 GtkWidget *window = NULL;
4918 GtkWidget *box1,*box2;
4920 GtkWidget *btnColor,*btnFile,*btnClose;
4922 /* Create modal window (Here you can use any window descendent )*/
4923 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
4924 gtk_window_set_screen (GTK_WINDOW (window),
4925 gtk_widget_get_screen (widget));
4927 gtk_window_set_title (GTK_WINDOW(window),"This window is modal");
4929 /* Set window as modal */
4930 gtk_window_set_modal (GTK_WINDOW(window),TRUE);
4932 /* Create widgets */
4933 box1 = gtk_vbox_new (FALSE,5);
4934 frame1 = gtk_frame_new ("Standard dialogs in modal form");
4935 box2 = gtk_vbox_new (TRUE,5);
4936 btnColor = gtk_button_new_with_label ("Color");
4937 btnFile = gtk_button_new_with_label ("File Selection");
4938 btnClose = gtk_button_new_with_label ("Close");
4941 gtk_container_set_border_width (GTK_CONTAINER (box1), 3);
4942 gtk_container_set_border_width (GTK_CONTAINER (box2), 3);
4945 gtk_container_add (GTK_CONTAINER (window), box1);
4946 gtk_box_pack_start (GTK_BOX (box1), frame1, TRUE, TRUE, 4);
4947 gtk_container_add (GTK_CONTAINER (frame1), box2);
4948 gtk_box_pack_start (GTK_BOX (box2), btnColor, FALSE, FALSE, 4);
4949 gtk_box_pack_start (GTK_BOX (box2), btnFile, FALSE, FALSE, 4);
4950 gtk_box_pack_start (GTK_BOX (box1), gtk_hseparator_new (), FALSE, FALSE, 4);
4951 gtk_box_pack_start (GTK_BOX (box1), btnClose, FALSE, FALSE, 4);
4953 /* connect signals */
4954 g_signal_connect_swapped (btnClose, "clicked",
4955 G_CALLBACK (gtk_widget_destroy), window);
4957 g_signal_connect (window, "destroy",
4958 G_CALLBACK (cmw_destroy_cb), NULL);
4960 g_signal_connect (btnColor, "clicked",
4961 G_CALLBACK (cmw_color), window);
4962 g_signal_connect (btnFile, "clicked",
4963 G_CALLBACK (cmw_file), window);
4966 gtk_widget_show_all (window);
4968 /* wait until dialog get destroyed */
4977 make_message_dialog (GdkScreen *screen,
4979 GtkMessageType type,
4980 GtkButtonsType buttons,
4981 guint default_response)
4985 gtk_widget_destroy (*dialog);
4990 *dialog = gtk_message_dialog_new (NULL, 0, type, buttons,
4991 "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.)");
4993 gtk_window_set_screen (GTK_WINDOW (*dialog), screen);
4995 g_signal_connect_swapped (*dialog,
4997 G_CALLBACK (gtk_widget_destroy),
5000 g_signal_connect (*dialog,
5002 G_CALLBACK (gtk_widget_destroyed),
5005 gtk_dialog_set_default_response (GTK_DIALOG (*dialog), default_response);
5007 gtk_widget_show (*dialog);
5011 create_message_dialog (GtkWidget *widget)
5013 static GtkWidget *info = NULL;
5014 static GtkWidget *warning = NULL;
5015 static GtkWidget *error = NULL;
5016 static GtkWidget *question = NULL;
5017 GdkScreen *screen = gtk_widget_get_screen (widget);
5019 make_message_dialog (screen, &info, GTK_MESSAGE_INFO, GTK_BUTTONS_OK, GTK_RESPONSE_OK);
5020 make_message_dialog (screen, &warning, GTK_MESSAGE_WARNING, GTK_BUTTONS_CLOSE, GTK_RESPONSE_CLOSE);
5021 make_message_dialog (screen, &error, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK_CANCEL, GTK_RESPONSE_OK);
5022 make_message_dialog (screen, &question, GTK_MESSAGE_QUESTION, GTK_BUTTONS_YES_NO, GTK_RESPONSE_NO);
5029 static GtkWidget *sw_parent = NULL;
5030 static GtkWidget *sw_float_parent;
5031 static guint sw_destroyed_handler = 0;
5034 scrolled_windows_delete_cb (GtkWidget *widget, GdkEventAny *event, GtkWidget *scrollwin)
5036 gtk_widget_reparent (scrollwin, sw_parent);
5038 g_signal_handler_disconnect (sw_parent, sw_destroyed_handler);
5039 sw_float_parent = NULL;
5041 sw_destroyed_handler = 0;
5047 scrolled_windows_destroy_cb (GtkWidget *widget, GtkWidget *scrollwin)
5049 gtk_widget_destroy (sw_float_parent);
5051 sw_float_parent = NULL;
5053 sw_destroyed_handler = 0;
5057 scrolled_windows_remove (GtkWidget *widget, GtkWidget *scrollwin)
5061 gtk_widget_reparent (scrollwin, sw_parent);
5062 gtk_widget_destroy (sw_float_parent);
5064 g_signal_handler_disconnect (sw_parent, sw_destroyed_handler);
5065 sw_float_parent = NULL;
5067 sw_destroyed_handler = 0;
5071 sw_parent = scrollwin->parent;
5072 sw_float_parent = gtk_window_new (GTK_WINDOW_TOPLEVEL);
5073 gtk_window_set_screen (GTK_WINDOW (sw_float_parent),
5074 gtk_widget_get_screen (widget));
5076 gtk_window_set_default_size (GTK_WINDOW (sw_float_parent), 200, 200);
5078 gtk_widget_reparent (scrollwin, sw_float_parent);
5079 gtk_widget_show (sw_float_parent);
5081 sw_destroyed_handler =
5082 g_signal_connect (sw_parent, "destroy",
5083 G_CALLBACK (scrolled_windows_destroy_cb), scrollwin);
5084 g_signal_connect (sw_float_parent, "delete_event",
5085 G_CALLBACK (scrolled_windows_delete_cb), scrollwin);
5090 create_scrolled_windows (GtkWidget *widget)
5092 static GtkWidget *window;
5093 GtkWidget *scrolled_window;
5101 window = gtk_dialog_new ();
5103 gtk_window_set_screen (GTK_WINDOW (window),
5104 gtk_widget_get_screen (widget));
5106 g_signal_connect (window, "destroy",
5107 G_CALLBACK (gtk_widget_destroyed),
5110 gtk_window_set_title (GTK_WINDOW (window), "dialog");
5111 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
5114 scrolled_window = gtk_scrolled_window_new (NULL, NULL);
5115 gtk_container_set_border_width (GTK_CONTAINER (scrolled_window), 10);
5116 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
5117 GTK_POLICY_AUTOMATIC,
5118 GTK_POLICY_AUTOMATIC);
5119 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox),
5120 scrolled_window, TRUE, TRUE, 0);
5121 gtk_widget_show (scrolled_window);
5123 table = gtk_table_new (20, 20, FALSE);
5124 gtk_table_set_row_spacings (GTK_TABLE (table), 10);
5125 gtk_table_set_col_spacings (GTK_TABLE (table), 10);
5126 gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (scrolled_window), table);
5127 gtk_container_set_focus_hadjustment (GTK_CONTAINER (table),
5128 gtk_scrolled_window_get_hadjustment (GTK_SCROLLED_WINDOW (scrolled_window)));
5129 gtk_container_set_focus_vadjustment (GTK_CONTAINER (table),
5130 gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (scrolled_window)));
5131 gtk_widget_show (table);
5133 for (i = 0; i < 20; i++)
5134 for (j = 0; j < 20; j++)
5136 sprintf (buffer, "button (%d,%d)\n", i, j);
5137 button = gtk_toggle_button_new_with_label (buffer);
5138 gtk_table_attach_defaults (GTK_TABLE (table), button,
5140 gtk_widget_show (button);
5144 button = gtk_button_new_with_label ("Close");
5145 g_signal_connect_swapped (button, "clicked",
5146 G_CALLBACK (gtk_widget_destroy),
5148 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
5149 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
5150 button, TRUE, TRUE, 0);
5151 gtk_widget_grab_default (button);
5152 gtk_widget_show (button);
5154 button = gtk_button_new_with_label ("Reparent Out");
5155 g_signal_connect (button, "clicked",
5156 G_CALLBACK (scrolled_windows_remove),
5158 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
5159 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
5160 button, TRUE, TRUE, 0);
5161 gtk_widget_grab_default (button);
5162 gtk_widget_show (button);
5164 gtk_window_set_default_size (GTK_WINDOW (window), 300, 300);
5167 if (!GTK_WIDGET_VISIBLE (window))
5168 gtk_widget_show (window);
5170 gtk_widget_destroy (window);
5178 entry_toggle_frame (GtkWidget *checkbutton,
5181 gtk_entry_set_has_frame (GTK_ENTRY(entry),
5182 GTK_TOGGLE_BUTTON(checkbutton)->active);
5186 entry_toggle_sensitive (GtkWidget *checkbutton,
5189 gtk_widget_set_sensitive (entry, GTK_TOGGLE_BUTTON(checkbutton)->active);
5193 entry_props_clicked (GtkWidget *button,
5196 GtkWidget *window = create_prop_editor (entry, 0);
5198 gtk_window_set_title (GTK_WINDOW (window), "Entry Properties");
5202 create_entry (GtkWidget *widget)
5204 static GtkWidget *window = NULL;
5208 GtkWidget *has_frame_check;
5209 GtkWidget *sensitive_check;
5210 GtkWidget *entry, *cb;
5212 GtkWidget *separator;
5213 GList *cbitems = NULL;
5217 cbitems = g_list_append(cbitems, "item0");
5218 cbitems = g_list_append(cbitems, "item1 item1");
5219 cbitems = g_list_append(cbitems, "item2 item2 item2");
5220 cbitems = g_list_append(cbitems, "item3 item3 item3 item3");
5221 cbitems = g_list_append(cbitems, "item4 item4 item4 item4 item4");
5222 cbitems = g_list_append(cbitems, "item5 item5 item5 item5 item5 item5");
5223 cbitems = g_list_append(cbitems, "item6 item6 item6 item6 item6");
5224 cbitems = g_list_append(cbitems, "item7 item7 item7 item7");
5225 cbitems = g_list_append(cbitems, "item8 item8 item8");
5226 cbitems = g_list_append(cbitems, "item9 item9");
5228 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
5229 gtk_window_set_screen (GTK_WINDOW (window),
5230 gtk_widget_get_screen (widget));
5232 g_signal_connect (window, "destroy",
5233 G_CALLBACK (gtk_widget_destroyed),
5236 gtk_window_set_title (GTK_WINDOW (window), "entry");
5237 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
5240 box1 = gtk_vbox_new (FALSE, 0);
5241 gtk_container_add (GTK_CONTAINER (window), box1);
5244 box2 = gtk_vbox_new (FALSE, 10);
5245 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
5246 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
5248 hbox = gtk_hbox_new (FALSE, 5);
5249 gtk_box_pack_start (GTK_BOX (box2), hbox, TRUE, TRUE, 0);
5251 entry = gtk_entry_new ();
5252 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");
5253 gtk_editable_select_region (GTK_EDITABLE (entry), 0, 5);
5254 gtk_box_pack_start (GTK_BOX (hbox), entry, TRUE, TRUE, 0);
5256 button = gtk_button_new_with_mnemonic ("_Props");
5257 gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0);
5258 g_signal_connect (button, "clicked",
5259 G_CALLBACK (entry_props_clicked),
5262 cb = gtk_combo_new ();
5263 gtk_combo_set_popdown_strings (GTK_COMBO (cb), cbitems);
5264 gtk_entry_set_text (GTK_ENTRY (GTK_COMBO(cb)->entry), "hello world \n\n\n foo");
5265 gtk_editable_select_region (GTK_EDITABLE (GTK_COMBO(cb)->entry),
5267 gtk_box_pack_start (GTK_BOX (box2), cb, TRUE, TRUE, 0);
5269 sensitive_check = gtk_check_button_new_with_label("Sensitive");
5270 gtk_box_pack_start (GTK_BOX (box2), sensitive_check, FALSE, TRUE, 0);
5271 g_signal_connect (sensitive_check, "toggled",
5272 G_CALLBACK (entry_toggle_sensitive), entry);
5273 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (sensitive_check), TRUE);
5275 has_frame_check = gtk_check_button_new_with_label("Has Frame");
5276 gtk_box_pack_start (GTK_BOX (box2), has_frame_check, FALSE, TRUE, 0);
5277 g_signal_connect (has_frame_check, "toggled",
5278 G_CALLBACK (entry_toggle_frame), entry);
5279 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (has_frame_check), TRUE);
5281 separator = gtk_hseparator_new ();
5282 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
5284 box2 = gtk_vbox_new (FALSE, 10);
5285 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
5286 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
5288 button = gtk_button_new_with_label ("close");
5289 g_signal_connect_swapped (button, "clicked",
5290 G_CALLBACK (gtk_widget_destroy),
5292 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
5293 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
5294 gtk_widget_grab_default (button);
5297 if (!GTK_WIDGET_VISIBLE (window))
5298 gtk_widget_show_all (window);
5300 gtk_widget_destroy (window);
5304 create_expander (GtkWidget *widget)
5307 GtkWidget *expander;
5309 static GtkWidget *window = NULL;
5313 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
5314 gtk_window_set_screen (GTK_WINDOW (window),
5315 gtk_widget_get_screen (widget));
5317 g_signal_connect (window, "destroy",
5318 G_CALLBACK (gtk_widget_destroyed),
5321 gtk_window_set_title (GTK_WINDOW (window), "expander");
5322 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
5324 box1 = gtk_vbox_new (FALSE, 0);
5325 gtk_container_add (GTK_CONTAINER (window), box1);
5327 expander = gtk_expander_new ("The Hidden");
5329 gtk_box_pack_start (GTK_BOX (box1), expander, TRUE, TRUE, 0);
5331 hidden = gtk_label_new ("Revealed!");
5333 gtk_container_add (GTK_CONTAINER (expander), hidden);
5336 if (!GTK_WIDGET_VISIBLE (window))
5337 gtk_widget_show_all (window);
5339 gtk_widget_destroy (window);
5347 event_box_label_pressed (GtkWidget *widget,
5348 GdkEventButton *event,
5351 g_print ("clicked on event box\n");
5355 event_box_button_clicked (GtkWidget *widget,
5359 g_print ("pushed button\n");
5363 event_box_toggle_visible_window (GtkWidget *checkbutton,
5364 GtkEventBox *event_box)
5366 gtk_event_box_set_visible_window (event_box,
5367 GTK_TOGGLE_BUTTON(checkbutton)->active);
5371 event_box_toggle_above_child (GtkWidget *checkbutton,
5372 GtkEventBox *event_box)
5374 gtk_event_box_set_above_child (event_box,
5375 GTK_TOGGLE_BUTTON(checkbutton)->active);
5379 create_event_box (GtkWidget *widget)
5381 static GtkWidget *window = NULL;
5387 GtkWidget *separator;
5388 GtkWidget *event_box;
5390 GtkWidget *visible_window_check;
5391 GtkWidget *above_child_check;
5400 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
5401 gtk_window_set_screen (GTK_WINDOW (window),
5402 gtk_widget_get_screen (widget));
5404 g_signal_connect (window, "destroy",
5405 G_CALLBACK (gtk_widget_destroyed),
5408 gtk_window_set_title (GTK_WINDOW (window), "event box");
5409 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
5411 box1 = gtk_vbox_new (FALSE, 0);
5412 gtk_container_add (GTK_CONTAINER (window), box1);
5413 gtk_widget_modify_bg (window, GTK_STATE_NORMAL, &color);
5415 hbox = gtk_hbox_new (FALSE, 0);
5416 gtk_box_pack_start (GTK_BOX (box1), hbox, TRUE, FALSE, 0);
5418 event_box = gtk_event_box_new ();
5419 gtk_box_pack_start (GTK_BOX (hbox), event_box, TRUE, FALSE, 0);
5421 vbox = gtk_vbox_new (FALSE, 0);
5422 gtk_container_add (GTK_CONTAINER (event_box), vbox);
5423 g_signal_connect (event_box, "button_press_event",
5424 G_CALLBACK (event_box_label_pressed),
5427 label = gtk_label_new ("Click on this label");
5428 gtk_box_pack_start (GTK_BOX (vbox), label, TRUE, FALSE, 0);
5430 button = gtk_button_new_with_label ("button in eventbox");
5431 gtk_box_pack_start (GTK_BOX (vbox), button, TRUE, FALSE, 0);
5432 g_signal_connect (button, "clicked",
5433 G_CALLBACK (event_box_button_clicked),
5437 visible_window_check = gtk_check_button_new_with_label("Visible Window");
5438 gtk_box_pack_start (GTK_BOX (box1), visible_window_check, FALSE, TRUE, 0);
5439 g_signal_connect (visible_window_check, "toggled",
5440 G_CALLBACK (event_box_toggle_visible_window), event_box);
5441 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (visible_window_check), FALSE);
5443 above_child_check = gtk_check_button_new_with_label("Above Child");
5444 gtk_box_pack_start (GTK_BOX (box1), above_child_check, FALSE, TRUE, 0);
5445 g_signal_connect (above_child_check, "toggled",
5446 G_CALLBACK (event_box_toggle_above_child), event_box);
5447 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (above_child_check), FALSE);
5449 separator = gtk_hseparator_new ();
5450 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
5452 box2 = gtk_vbox_new (FALSE, 10);
5453 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
5454 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
5456 button = gtk_button_new_with_label ("close");
5457 g_signal_connect_swapped (button, "clicked",
5458 G_CALLBACK (gtk_widget_destroy),
5460 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
5461 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
5462 gtk_widget_grab_default (button);
5465 if (!GTK_WIDGET_VISIBLE (window))
5466 gtk_widget_show_all (window);
5468 gtk_widget_destroy (window);
5476 #define SIZE_GROUP_INITIAL_SIZE 50
5479 size_group_hsize_changed (GtkSpinButton *spin_button,
5482 gtk_widget_set_size_request (GTK_BIN (button)->child,
5483 gtk_spin_button_get_value_as_int (spin_button),
5488 size_group_vsize_changed (GtkSpinButton *spin_button,
5491 gtk_widget_set_size_request (GTK_BIN (button)->child,
5493 gtk_spin_button_get_value_as_int (spin_button));
5497 create_size_group_window (GdkScreen *screen,
5498 GtkSizeGroup *master_size_group)
5502 GtkWidget *main_button;
5504 GtkWidget *spin_button;
5506 GtkSizeGroup *hgroup1;
5507 GtkSizeGroup *hgroup2;
5508 GtkSizeGroup *vgroup1;
5509 GtkSizeGroup *vgroup2;
5511 window = gtk_dialog_new_with_buttons ("GtkSizeGroup",
5517 gtk_window_set_screen (GTK_WINDOW (window), screen);
5519 gtk_window_set_resizable (GTK_WINDOW (window), TRUE);
5521 g_signal_connect (window, "response",
5522 G_CALLBACK (gtk_widget_destroy),
5525 table = gtk_table_new (2, 2, FALSE);
5526 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), table, TRUE, TRUE, 0);
5528 gtk_table_set_row_spacings (GTK_TABLE (table), 5);
5529 gtk_table_set_col_spacings (GTK_TABLE (table), 5);
5530 gtk_container_set_border_width (GTK_CONTAINER (table), 5);
5531 gtk_widget_set_size_request (table, 250, 250);
5533 hgroup1 = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
5534 hgroup2 = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
5535 vgroup1 = gtk_size_group_new (GTK_SIZE_GROUP_VERTICAL);
5536 vgroup2 = gtk_size_group_new (GTK_SIZE_GROUP_VERTICAL);
5538 main_button = gtk_button_new_with_label ("X");
5540 gtk_table_attach (GTK_TABLE (table), main_button,
5542 GTK_EXPAND, GTK_EXPAND,
5544 gtk_size_group_add_widget (master_size_group, main_button);
5545 gtk_size_group_add_widget (hgroup1, main_button);
5546 gtk_size_group_add_widget (vgroup1, main_button);
5547 gtk_widget_set_size_request (GTK_BIN (main_button)->child,
5548 SIZE_GROUP_INITIAL_SIZE,
5549 SIZE_GROUP_INITIAL_SIZE);
5551 button = gtk_button_new ();
5552 gtk_table_attach (GTK_TABLE (table), button,
5554 GTK_EXPAND, GTK_EXPAND,
5556 gtk_size_group_add_widget (vgroup1, button);
5557 gtk_size_group_add_widget (vgroup2, button);
5559 button = gtk_button_new ();
5560 gtk_table_attach (GTK_TABLE (table), button,
5562 GTK_EXPAND, GTK_EXPAND,
5564 gtk_size_group_add_widget (hgroup1, button);
5565 gtk_size_group_add_widget (hgroup2, button);
5567 button = gtk_button_new ();
5568 gtk_table_attach (GTK_TABLE (table), button,
5570 GTK_EXPAND, GTK_EXPAND,
5572 gtk_size_group_add_widget (hgroup2, button);
5573 gtk_size_group_add_widget (vgroup2, button);
5575 g_object_unref (hgroup1);
5576 g_object_unref (hgroup2);
5577 g_object_unref (vgroup1);
5578 g_object_unref (vgroup2);
5580 hbox = gtk_hbox_new (FALSE, 5);
5581 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), hbox, FALSE, FALSE, 0);
5583 spin_button = gtk_spin_button_new_with_range (1, 100, 1);
5584 gtk_spin_button_set_value (GTK_SPIN_BUTTON (spin_button), SIZE_GROUP_INITIAL_SIZE);
5585 gtk_box_pack_start (GTK_BOX (hbox), spin_button, TRUE, TRUE, 0);
5586 g_signal_connect (spin_button, "value_changed",
5587 G_CALLBACK (size_group_hsize_changed), main_button);
5589 spin_button = gtk_spin_button_new_with_range (1, 100, 1);
5590 gtk_spin_button_set_value (GTK_SPIN_BUTTON (spin_button), SIZE_GROUP_INITIAL_SIZE);
5591 gtk_box_pack_start (GTK_BOX (hbox), spin_button, TRUE, TRUE, 0);
5592 g_signal_connect (spin_button, "value_changed",
5593 G_CALLBACK (size_group_vsize_changed), main_button);
5599 create_size_groups (GtkWidget *widget)
5601 static GtkWidget *window1 = NULL;
5602 static GtkWidget *window2 = NULL;
5603 static GtkSizeGroup *master_size_group;
5605 if (!master_size_group)
5606 master_size_group = gtk_size_group_new (GTK_SIZE_GROUP_BOTH);
5610 window1 = create_size_group_window (gtk_widget_get_screen (widget),
5613 g_signal_connect (window1, "destroy",
5614 G_CALLBACK (gtk_widget_destroyed),
5620 window2 = create_size_group_window (gtk_widget_get_screen (widget),
5623 g_signal_connect (window2, "destroy",
5624 G_CALLBACK (gtk_widget_destroyed),
5628 if (GTK_WIDGET_VISIBLE (window1) && GTK_WIDGET_VISIBLE (window2))
5630 gtk_widget_destroy (window1);
5631 gtk_widget_destroy (window2);
5635 if (!GTK_WIDGET_VISIBLE (window1))
5636 gtk_widget_show_all (window1);
5637 if (!GTK_WIDGET_VISIBLE (window2))
5638 gtk_widget_show_all (window2);
5646 static GtkWidget *spinner1;
5649 toggle_snap (GtkWidget *widget, GtkSpinButton *spin)
5651 gtk_spin_button_set_snap_to_ticks (spin, GTK_TOGGLE_BUTTON (widget)->active);
5655 toggle_numeric (GtkWidget *widget, GtkSpinButton *spin)
5657 gtk_spin_button_set_numeric (spin, GTK_TOGGLE_BUTTON (widget)->active);
5661 change_digits (GtkWidget *widget, GtkSpinButton *spin)
5663 gtk_spin_button_set_digits (GTK_SPIN_BUTTON (spinner1),
5664 gtk_spin_button_get_value_as_int (spin));
5668 get_value (GtkWidget *widget, gpointer data)
5672 GtkSpinButton *spin;
5674 spin = GTK_SPIN_BUTTON (spinner1);
5675 label = GTK_LABEL (g_object_get_data (G_OBJECT (widget), "user_data"));
5676 if (GPOINTER_TO_INT (data) == 1)
5677 sprintf (buf, "%d", gtk_spin_button_get_value_as_int (spin));
5679 sprintf (buf, "%0.*f", spin->digits, gtk_spin_button_get_value (spin));
5680 gtk_label_set_text (label, buf);
5684 get_spin_value (GtkWidget *widget, gpointer data)
5688 GtkSpinButton *spin;
5690 spin = GTK_SPIN_BUTTON (widget);
5691 label = GTK_LABEL (data);
5693 buffer = g_strdup_printf ("%0.*f", spin->digits,
5694 gtk_spin_button_get_value (spin));
5695 gtk_label_set_text (label, buffer);
5701 spin_button_time_output_func (GtkSpinButton *spin_button)
5703 static gchar buf[6];
5707 hours = spin_button->adjustment->value / 60.0;
5708 minutes = (fabs(floor (hours) - hours) < 1e-5) ? 0.0 : 30;
5709 sprintf (buf, "%02.0f:%02.0f", floor (hours), minutes);
5710 if (strcmp (buf, gtk_entry_get_text (GTK_ENTRY (spin_button))))
5711 gtk_entry_set_text (GTK_ENTRY (spin_button), buf);
5716 spin_button_month_input_func (GtkSpinButton *spin_button,
5720 static gchar *month[12] = { "January", "February", "March", "April",
5721 "May", "June", "July", "August",
5722 "September", "October", "November", "December" };
5724 gboolean found = FALSE;
5726 for (i = 1; i <= 12; i++)
5728 tmp1 = g_ascii_strup (month[i - 1], -1);
5729 tmp2 = g_ascii_strup (gtk_entry_get_text (GTK_ENTRY (spin_button)), -1);
5730 if (strstr (tmp1, tmp2) == tmp1)
5740 return GTK_INPUT_ERROR;
5742 *new_val = (gdouble) i;
5747 spin_button_month_output_func (GtkSpinButton *spin_button)
5750 static gchar *month[12] = { "January", "February", "March", "April",
5751 "May", "June", "July", "August", "September",
5752 "October", "November", "December" };
5754 for (i = 1; i <= 12; i++)
5755 if (fabs (spin_button->adjustment->value - (double)i) < 1e-5)
5757 if (strcmp (month[i-1], gtk_entry_get_text (GTK_ENTRY (spin_button))))
5758 gtk_entry_set_text (GTK_ENTRY (spin_button), month[i-1]);
5764 spin_button_hex_input_func (GtkSpinButton *spin_button,
5771 buf = gtk_entry_get_text (GTK_ENTRY (spin_button));
5772 res = strtol(buf, &err, 16);
5775 return GTK_INPUT_ERROR;
5781 spin_button_hex_output_func (GtkSpinButton *spin_button)
5783 static gchar buf[7];
5786 val = (gint) spin_button->adjustment->value;
5787 if (fabs (val) < 1e-5)
5788 sprintf (buf, "0x00");
5790 sprintf (buf, "0x%.2X", val);
5791 if (strcmp (buf, gtk_entry_get_text (GTK_ENTRY (spin_button))))
5792 gtk_entry_set_text (GTK_ENTRY (spin_button), buf);
5797 create_spins (GtkWidget *widget)
5799 static GtkWidget *window = NULL;
5802 GtkWidget *main_vbox;
5805 GtkWidget *spinner2;
5809 GtkWidget *val_label;
5814 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
5815 gtk_window_set_screen (GTK_WINDOW (window),
5816 gtk_widget_get_screen (widget));
5818 g_signal_connect (window, "destroy",
5819 G_CALLBACK (gtk_widget_destroyed),
5822 gtk_window_set_title (GTK_WINDOW (window), "GtkSpinButton");
5824 main_vbox = gtk_vbox_new (FALSE, 5);
5825 gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 10);
5826 gtk_container_add (GTK_CONTAINER (window), main_vbox);
5828 frame = gtk_frame_new ("Not accelerated");
5829 gtk_box_pack_start (GTK_BOX (main_vbox), frame, TRUE, TRUE, 0);
5831 vbox = gtk_vbox_new (FALSE, 0);
5832 gtk_container_set_border_width (GTK_CONTAINER (vbox), 5);
5833 gtk_container_add (GTK_CONTAINER (frame), vbox);
5835 /* Time, month, hex spinners */
5837 hbox = gtk_hbox_new (FALSE, 0);
5838 gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 5);
5840 vbox2 = gtk_vbox_new (FALSE, 0);
5841 gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 5);
5843 label = gtk_label_new ("Time :");
5844 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
5845 gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, TRUE, 0);
5847 adj = (GtkAdjustment *) gtk_adjustment_new (0, 0, 1410, 30, 60, 0);
5848 spinner = gtk_spin_button_new (adj, 0, 0);
5849 gtk_editable_set_editable (GTK_EDITABLE (spinner), FALSE);
5850 g_signal_connect (spinner,
5852 G_CALLBACK (spin_button_time_output_func),
5854 gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spinner), TRUE);
5855 gtk_entry_set_width_chars (GTK_ENTRY (spinner), 5);
5856 gtk_box_pack_start (GTK_BOX (vbox2), spinner, FALSE, TRUE, 0);
5858 vbox2 = gtk_vbox_new (FALSE, 0);
5859 gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 5);
5861 label = gtk_label_new ("Month :");
5862 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
5863 gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, TRUE, 0);
5865 adj = (GtkAdjustment *) gtk_adjustment_new (1.0, 1.0, 12.0, 1.0,
5867 spinner = gtk_spin_button_new (adj, 0, 0);
5868 gtk_spin_button_set_update_policy (GTK_SPIN_BUTTON (spinner),
5869 GTK_UPDATE_IF_VALID);
5870 g_signal_connect (spinner,
5872 G_CALLBACK (spin_button_month_input_func),
5874 g_signal_connect (spinner,
5876 G_CALLBACK (spin_button_month_output_func),
5878 gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spinner), TRUE);
5879 gtk_entry_set_width_chars (GTK_ENTRY (spinner), 9);
5880 gtk_box_pack_start (GTK_BOX (vbox2), spinner, FALSE, TRUE, 0);
5882 vbox2 = gtk_vbox_new (FALSE, 0);
5883 gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 5);
5885 label = gtk_label_new ("Hex :");
5886 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
5887 gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, TRUE, 0);
5889 adj = (GtkAdjustment *) gtk_adjustment_new (0, 0, 255, 1, 16, 0);
5890 spinner = gtk_spin_button_new (adj, 0, 0);
5891 gtk_editable_set_editable (GTK_EDITABLE (spinner), TRUE);
5892 g_signal_connect (spinner,
5894 G_CALLBACK (spin_button_hex_input_func),
5896 g_signal_connect (spinner,
5898 G_CALLBACK (spin_button_hex_output_func),
5900 gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spinner), TRUE);
5901 gtk_entry_set_width_chars (GTK_ENTRY (spinner), 4);
5902 gtk_box_pack_start (GTK_BOX (vbox2), spinner, FALSE, TRUE, 0);
5904 frame = gtk_frame_new ("Accelerated");
5905 gtk_box_pack_start (GTK_BOX (main_vbox), frame, TRUE, TRUE, 0);
5907 vbox = gtk_vbox_new (FALSE, 0);
5908 gtk_container_set_border_width (GTK_CONTAINER (vbox), 5);
5909 gtk_container_add (GTK_CONTAINER (frame), vbox);
5911 hbox = gtk_hbox_new (FALSE, 0);
5912 gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 5);
5914 vbox2 = gtk_vbox_new (FALSE, 0);
5915 gtk_box_pack_start (GTK_BOX (hbox), vbox2, FALSE, FALSE, 5);
5917 label = gtk_label_new ("Value :");
5918 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
5919 gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, TRUE, 0);
5921 adj = (GtkAdjustment *) gtk_adjustment_new (0.0, -10000.0, 10000.0,
5923 spinner1 = gtk_spin_button_new (adj, 1.0, 2);
5924 gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spinner1), TRUE);
5925 gtk_box_pack_start (GTK_BOX (vbox2), spinner1, FALSE, TRUE, 0);
5927 vbox2 = gtk_vbox_new (FALSE, 0);
5928 gtk_box_pack_start (GTK_BOX (hbox), vbox2, FALSE, FALSE, 5);
5930 label = gtk_label_new ("Digits :");
5931 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
5932 gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, TRUE, 0);
5934 adj = (GtkAdjustment *) gtk_adjustment_new (2, 1, 15, 1, 1, 0);
5935 spinner2 = gtk_spin_button_new (adj, 0.0, 0);
5936 g_signal_connect (adj, "value_changed",
5937 G_CALLBACK (change_digits),
5939 gtk_box_pack_start (GTK_BOX (vbox2), spinner2, FALSE, TRUE, 0);
5941 hbox = gtk_hbox_new (FALSE, 0);
5942 gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 5);
5944 button = gtk_check_button_new_with_label ("Snap to 0.5-ticks");
5945 g_signal_connect (button, "clicked",
5946 G_CALLBACK (toggle_snap),
5948 gtk_box_pack_start (GTK_BOX (vbox), button, TRUE, TRUE, 0);
5949 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
5951 button = gtk_check_button_new_with_label ("Numeric only input mode");
5952 g_signal_connect (button, "clicked",
5953 G_CALLBACK (toggle_numeric),
5955 gtk_box_pack_start (GTK_BOX (vbox), button, TRUE, TRUE, 0);
5956 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
5958 val_label = gtk_label_new ("");
5960 hbox = gtk_hbox_new (FALSE, 0);
5961 gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 5);
5963 button = gtk_button_new_with_label ("Value as Int");
5964 g_object_set_data (G_OBJECT (button), "user_data", val_label);
5965 g_signal_connect (button, "clicked",
5966 G_CALLBACK (get_value),
5967 GINT_TO_POINTER (1));
5968 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
5970 button = gtk_button_new_with_label ("Value as Float");
5971 g_object_set_data (G_OBJECT (button), "user_data", val_label);
5972 g_signal_connect (button, "clicked",
5973 G_CALLBACK (get_value),
5974 GINT_TO_POINTER (2));
5975 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
5977 gtk_box_pack_start (GTK_BOX (vbox), val_label, TRUE, TRUE, 0);
5978 gtk_label_set_text (GTK_LABEL (val_label), "0");
5980 frame = gtk_frame_new ("Using Convenience Constructor");
5981 gtk_box_pack_start (GTK_BOX (main_vbox), frame, TRUE, TRUE, 0);
5983 hbox = gtk_hbox_new (FALSE, 0);
5984 gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
5985 gtk_container_add (GTK_CONTAINER (frame), hbox);
5987 val_label = gtk_label_new ("0.0");
5989 spinner = gtk_spin_button_new_with_range (0.0, 10.0, 0.009);
5990 gtk_spin_button_set_value (GTK_SPIN_BUTTON (spinner), 0.0);
5991 g_signal_connect (spinner, "value_changed",
5992 G_CALLBACK (get_spin_value), val_label);
5993 gtk_box_pack_start (GTK_BOX (hbox), spinner, TRUE, TRUE, 5);
5994 gtk_box_pack_start (GTK_BOX (hbox), val_label, TRUE, TRUE, 5);
5996 hbox = gtk_hbox_new (FALSE, 0);
5997 gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, TRUE, 0);
5999 button = gtk_button_new_with_label ("Close");
6000 g_signal_connect_swapped (button, "clicked",
6001 G_CALLBACK (gtk_widget_destroy),
6003 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
6006 if (!GTK_WIDGET_VISIBLE (window))
6007 gtk_widget_show_all (window);
6009 gtk_widget_destroy (window);
6018 cursor_expose_event (GtkWidget *widget,
6022 GtkDrawingArea *darea;
6023 GdkDrawable *drawable;
6030 g_return_val_if_fail (widget != NULL, TRUE);
6031 g_return_val_if_fail (GTK_IS_DRAWING_AREA (widget), TRUE);
6033 darea = GTK_DRAWING_AREA (widget);
6034 drawable = widget->window;
6035 white_gc = widget->style->white_gc;
6036 gray_gc = widget->style->bg_gc[GTK_STATE_NORMAL];
6037 black_gc = widget->style->black_gc;
6038 max_width = widget->allocation.width;
6039 max_height = widget->allocation.height;
6041 gdk_draw_rectangle (drawable, white_gc,
6048 gdk_draw_rectangle (drawable, black_gc,
6055 gdk_draw_rectangle (drawable, gray_gc,
6066 set_cursor (GtkWidget *spinner,
6075 c = CLAMP (gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (spinner)), 0, 152);
6078 label = g_object_get_data (G_OBJECT (spinner), "user_data");
6080 class = gtk_type_class (GDK_TYPE_CURSOR_TYPE);
6081 vals = class->values;
6083 while (vals && vals->value != c)
6086 gtk_label_set_text (GTK_LABEL (label), vals->value_nick);
6088 gtk_label_set_text (GTK_LABEL (label), "<unknown>");
6090 cursor = gdk_cursor_new_for_display (gtk_widget_get_display (widget), c);
6091 gdk_window_set_cursor (widget->window, cursor);
6092 gdk_cursor_unref (cursor);
6096 cursor_event (GtkWidget *widget,
6098 GtkSpinButton *spinner)
6100 if ((event->type == GDK_BUTTON_PRESS) &&
6101 ((event->button.button == 1) ||
6102 (event->button.button == 3)))
6104 gtk_spin_button_spin (spinner, event->button.button == 1 ?
6105 GTK_SPIN_STEP_FORWARD : GTK_SPIN_STEP_BACKWARD, 0);
6112 #ifdef GDK_WINDOWING_X11
6113 #include "x11/gdkx.h"
6116 change_cursor_theme (GtkWidget *widget,
6123 children = gtk_container_get_children (GTK_CONTAINER (data));
6125 theme = gtk_entry_get_text (GTK_ENTRY (children->next->data));
6126 size = (gint) gtk_spin_button_get_value (GTK_SPIN_BUTTON (children->next->next->data));
6128 g_list_free (children);
6130 gdk_x11_display_set_cursor_theme (gtk_widget_get_display (widget),
6137 create_cursors (GtkWidget *widget)
6139 static GtkWidget *window = NULL;
6142 GtkWidget *main_vbox;
6155 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
6156 gtk_window_set_screen (GTK_WINDOW (window),
6157 gtk_widget_get_screen (widget));
6159 g_signal_connect (window, "destroy",
6160 G_CALLBACK (gtk_widget_destroyed),
6163 gtk_window_set_title (GTK_WINDOW (window), "Cursors");
6165 main_vbox = gtk_vbox_new (FALSE, 5);
6166 gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 0);
6167 gtk_container_add (GTK_CONTAINER (window), main_vbox);
6170 gtk_widget_new (gtk_vbox_get_type (),
6171 "GtkBox::homogeneous", FALSE,
6172 "GtkBox::spacing", 5,
6173 "GtkContainer::border_width", 10,
6174 "GtkWidget::parent", main_vbox,
6175 "GtkWidget::visible", TRUE,
6178 #ifdef GDK_WINDOWING_X11
6179 hbox = gtk_hbox_new (FALSE, 0);
6180 gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
6181 gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0);
6183 label = gtk_label_new ("Cursor Theme : ");
6184 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
6185 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
6187 entry = gtk_entry_new ();
6188 gtk_entry_set_text (GTK_ENTRY (entry), "default");
6189 gtk_box_pack_start (GTK_BOX (hbox), entry, FALSE, TRUE, 0);
6191 size = gtk_spin_button_new_with_range (1.0, 64.0, 1.0);
6192 gtk_spin_button_set_value (GTK_SPIN_BUTTON (size), 24.0);
6193 gtk_box_pack_start (GTK_BOX (hbox), size, TRUE, TRUE, 0);
6195 g_signal_connect (entry, "changed",
6196 G_CALLBACK (change_cursor_theme), hbox);
6197 g_signal_connect (size, "changed",
6198 G_CALLBACK (change_cursor_theme), hbox);
6201 hbox = gtk_hbox_new (FALSE, 0);
6202 gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
6203 gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0);
6205 label = gtk_label_new ("Cursor Value : ");
6206 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
6207 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
6209 adj = (GtkAdjustment *) gtk_adjustment_new (0,
6213 spinner = gtk_spin_button_new (adj, 0, 0);
6214 gtk_box_pack_start (GTK_BOX (hbox), spinner, TRUE, TRUE, 0);
6217 gtk_widget_new (gtk_frame_get_type (),
6218 "GtkFrame::shadow", GTK_SHADOW_ETCHED_IN,
6219 "GtkFrame::label_xalign", 0.5,
6220 "GtkFrame::label", "Cursor Area",
6221 "GtkContainer::border_width", 10,
6222 "GtkWidget::parent", vbox,
6223 "GtkWidget::visible", TRUE,
6226 darea = gtk_drawing_area_new ();
6227 gtk_widget_set_size_request (darea, 80, 80);
6228 gtk_container_add (GTK_CONTAINER (frame), darea);
6229 g_signal_connect (darea,
6231 G_CALLBACK (cursor_expose_event),
6233 gtk_widget_set_events (darea, GDK_EXPOSURE_MASK | GDK_BUTTON_PRESS_MASK);
6234 g_signal_connect (darea,
6235 "button_press_event",
6236 G_CALLBACK (cursor_event),
6238 gtk_widget_show (darea);
6240 g_signal_connect (spinner, "changed",
6241 G_CALLBACK (set_cursor),
6244 label = gtk_widget_new (GTK_TYPE_LABEL,
6249 gtk_container_child_set (GTK_CONTAINER (vbox), label,
6252 g_object_set_data (G_OBJECT (spinner), "user_data", label);
6255 gtk_widget_new (gtk_hseparator_get_type (),
6256 "GtkWidget::visible", TRUE,
6258 gtk_box_pack_start (GTK_BOX (main_vbox), any, FALSE, TRUE, 0);
6260 hbox = gtk_hbox_new (FALSE, 0);
6261 gtk_container_set_border_width (GTK_CONTAINER (hbox), 10);
6262 gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, TRUE, 0);
6264 button = gtk_button_new_with_label ("Close");
6265 g_signal_connect_swapped (button, "clicked",
6266 G_CALLBACK (gtk_widget_destroy),
6268 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
6270 gtk_widget_show_all (window);
6272 set_cursor (spinner, darea);
6275 gtk_widget_destroy (window);
6283 list_add (GtkWidget *widget,
6288 GtkWidget *list_item;
6289 GtkContainer *container;
6291 container = GTK_CONTAINER (list);
6293 sprintf (buffer, "added item %d", i++);
6294 list_item = gtk_list_item_new_with_label (buffer);
6295 gtk_widget_show (list_item);
6297 gtk_container_add (container, list_item);
6301 list_remove (GtkWidget *widget,
6304 GList *clear_list = NULL;
6305 GList *sel_row = NULL;
6308 if (list->selection_mode == GTK_SELECTION_EXTENDED)
6312 item = GTK_CONTAINER (list)->focus_child;
6313 if (!item && list->selection)
6314 item = list->selection->data;
6318 work = g_list_find (list->children, item);
6319 for (sel_row = work; sel_row; sel_row = sel_row->next)
6320 if (GTK_WIDGET (sel_row->data)->state != GTK_STATE_SELECTED)
6325 for (sel_row = work; sel_row; sel_row = sel_row->prev)
6326 if (GTK_WIDGET (sel_row->data)->state != GTK_STATE_SELECTED)
6332 for (work = list->selection; work; work = work->next)
6333 clear_list = g_list_prepend (clear_list, work->data);
6335 clear_list = g_list_reverse (clear_list);
6336 gtk_list_remove_items (GTK_LIST (list), clear_list);
6337 g_list_free (clear_list);
6339 if (list->selection_mode == GTK_SELECTION_EXTENDED && sel_row)
6340 gtk_list_select_child (list, GTK_WIDGET(sel_row->data));
6344 list_clear (GtkWidget *widget,
6347 gtk_list_clear_items (GTK_LIST (list), 0, -1);
6350 static gchar *selection_mode_items[] =
6357 static const GtkSelectionMode selection_modes[] = {
6358 GTK_SELECTION_SINGLE,
6359 GTK_SELECTION_BROWSE,
6360 GTK_SELECTION_MULTIPLE
6363 static GtkWidget *list_omenu;
6366 list_toggle_sel_mode (GtkWidget *widget, gpointer data)
6371 list = GTK_LIST (data);
6373 if (!GTK_WIDGET_MAPPED (widget))
6376 i = gtk_option_menu_get_history (GTK_OPTION_MENU (widget));
6378 gtk_list_set_selection_mode (list, selection_modes[i]);
6382 create_list (GtkWidget *widget)
6384 static GtkWidget *window = NULL;
6392 GtkWidget *scrolled_win;
6395 GtkWidget *separator;
6398 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
6400 gtk_window_set_screen (GTK_WINDOW (window),
6401 gtk_widget_get_screen (widget));
6403 g_signal_connect (window, "destroy",
6404 G_CALLBACK (gtk_widget_destroyed),
6407 gtk_window_set_title (GTK_WINDOW (window), "list");
6408 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
6410 vbox = gtk_vbox_new (FALSE, 0);
6411 gtk_container_add (GTK_CONTAINER (window), vbox);
6413 scrolled_win = gtk_scrolled_window_new (NULL, NULL);
6414 gtk_container_set_border_width (GTK_CONTAINER (scrolled_win), 5);
6415 gtk_widget_set_size_request (scrolled_win, -1, 300);
6416 gtk_box_pack_start (GTK_BOX (vbox), scrolled_win, TRUE, TRUE, 0);
6417 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
6418 GTK_POLICY_AUTOMATIC,
6419 GTK_POLICY_AUTOMATIC);
6421 list = gtk_list_new ();
6422 gtk_list_set_selection_mode (GTK_LIST (list), GTK_SELECTION_SINGLE);
6423 gtk_scrolled_window_add_with_viewport
6424 (GTK_SCROLLED_WINDOW (scrolled_win), list);
6425 gtk_container_set_focus_vadjustment
6426 (GTK_CONTAINER (list),
6427 gtk_scrolled_window_get_vadjustment
6428 (GTK_SCROLLED_WINDOW (scrolled_win)));
6429 gtk_container_set_focus_hadjustment
6430 (GTK_CONTAINER (list),
6431 gtk_scrolled_window_get_hadjustment
6432 (GTK_SCROLLED_WINDOW (scrolled_win)));
6434 if ((infile = fopen("../gtk/gtkenums.h", "r")))
6440 while (fgets (buffer, 256, infile))
6442 if ((pos = strchr (buffer, '\n')))
6444 item = gtk_list_item_new_with_label (buffer);
6445 gtk_container_add (GTK_CONTAINER (list), item);
6452 hbox = gtk_hbox_new (TRUE, 5);
6453 gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
6454 gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0);
6456 button = gtk_button_new_with_label ("Insert Row");
6457 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
6458 g_signal_connect (button, "clicked",
6459 G_CALLBACK (list_add),
6462 button = gtk_button_new_with_label ("Clear List");
6463 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
6464 g_signal_connect (button, "clicked",
6465 G_CALLBACK (list_clear),
6468 button = gtk_button_new_with_label ("Remove Selection");
6469 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
6470 g_signal_connect (button, "clicked",
6471 G_CALLBACK (list_remove),
6474 cbox = gtk_hbox_new (FALSE, 0);
6475 gtk_box_pack_start (GTK_BOX (vbox), cbox, FALSE, TRUE, 0);
6477 hbox = gtk_hbox_new (FALSE, 5);
6478 gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
6479 gtk_box_pack_start (GTK_BOX (cbox), hbox, TRUE, FALSE, 0);
6481 label = gtk_label_new ("Selection Mode :");
6482 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
6484 list_omenu = build_option_menu (selection_mode_items, 3, 3,
6485 list_toggle_sel_mode,
6487 gtk_box_pack_start (GTK_BOX (hbox), list_omenu, FALSE, TRUE, 0);
6489 separator = gtk_hseparator_new ();
6490 gtk_box_pack_start (GTK_BOX (vbox), separator, FALSE, TRUE, 0);
6492 cbox = gtk_hbox_new (FALSE, 0);
6493 gtk_box_pack_start (GTK_BOX (vbox), cbox, FALSE, TRUE, 0);
6495 button = gtk_button_new_with_label ("close");
6496 gtk_container_set_border_width (GTK_CONTAINER (button), 10);
6497 gtk_box_pack_start (GTK_BOX (cbox), button, TRUE, TRUE, 0);
6498 g_signal_connect_swapped (button, "clicked",
6499 G_CALLBACK (gtk_widget_destroy),
6502 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
6503 gtk_widget_grab_default (button);
6506 if (!GTK_WIDGET_VISIBLE (window))
6507 gtk_widget_show_all (window);
6509 gtk_widget_destroy (window);
6516 static char * book_open_xpm[] = {
6539 static char * book_closed_xpm[] = {
6564 static char * mini_page_xpm[] = {
6587 static char * gtk_mini_xpm[] = {
6627 #define TESTGTK_CLIST_COLUMNS 12
6628 static gint clist_rows = 0;
6629 static GtkWidget *clist_omenu;
6632 add1000_clist (GtkWidget *widget, gpointer data)
6635 char text[TESTGTK_CLIST_COLUMNS][50];
6636 char *texts[TESTGTK_CLIST_COLUMNS];
6641 clist = GTK_CLIST (data);
6643 pixmap = gdk_pixmap_create_from_xpm_d (clist->clist_window,
6645 >K_WIDGET (data)->style->white,
6648 for (i = 0; i < TESTGTK_CLIST_COLUMNS; i++)
6651 sprintf (text[i], "Column %d", i);
6655 sprintf (text[1], "Right");
6656 sprintf (text[2], "Center");
6658 gtk_clist_freeze (GTK_CLIST (data));
6659 for (i = 0; i < 1000; i++)
6661 sprintf (text[0], "CListRow %d", rand() % 10000);
6662 row = gtk_clist_append (clist, texts);
6663 gtk_clist_set_pixtext (clist, row, 3, "gtk+", 5, pixmap, mask);
6666 gtk_clist_thaw (GTK_CLIST (data));
6668 g_object_unref (pixmap);
6669 g_object_unref (mask);
6673 add10000_clist (GtkWidget *widget, gpointer data)
6676 char text[TESTGTK_CLIST_COLUMNS][50];
6677 char *texts[TESTGTK_CLIST_COLUMNS];
6679 for (i = 0; i < TESTGTK_CLIST_COLUMNS; i++)
6682 sprintf (text[i], "Column %d", i);
6685 sprintf (text[1], "Right");
6686 sprintf (text[2], "Center");
6688 gtk_clist_freeze (GTK_CLIST (data));
6689 for (i = 0; i < 10000; i++)
6691 sprintf (text[0], "CListRow %d", rand() % 10000);
6692 gtk_clist_append (GTK_CLIST (data), texts);
6694 gtk_clist_thaw (GTK_CLIST (data));
6698 clear_clist (GtkWidget *widget, gpointer data)
6700 gtk_clist_clear (GTK_CLIST (data));
6704 void clist_remove_selection (GtkWidget *widget, GtkCList *clist)
6706 gtk_clist_freeze (clist);
6708 while (clist->selection)
6713 row = GPOINTER_TO_INT (clist->selection->data);
6715 gtk_clist_remove (clist, row);
6717 if (clist->selection_mode == GTK_SELECTION_BROWSE)
6721 if (clist->selection_mode == GTK_SELECTION_EXTENDED && !clist->selection &&
6722 clist->focus_row >= 0)
6723 gtk_clist_select_row (clist, clist->focus_row, -1);
6725 gtk_clist_thaw (clist);
6728 void toggle_title_buttons (GtkWidget *widget, GtkCList *clist)
6730 if (GTK_TOGGLE_BUTTON (widget)->active)
6731 gtk_clist_column_titles_show (clist);
6733 gtk_clist_column_titles_hide (clist);
6736 void toggle_reorderable (GtkWidget *widget, GtkCList *clist)
6738 gtk_clist_set_reorderable (clist, GTK_TOGGLE_BUTTON (widget)->active);
6742 insert_row_clist (GtkWidget *widget, gpointer data)
6744 static char *text[] =
6746 "This", "is an", "inserted", "row.",
6747 "This", "is an", "inserted", "row.",
6748 "This", "is an", "inserted", "row."
6751 static GtkStyle *style1 = NULL;
6752 static GtkStyle *style2 = NULL;
6753 static GtkStyle *style3 = NULL;
6756 if (GTK_CLIST (data)->focus_row >= 0)
6757 row = gtk_clist_insert (GTK_CLIST (data), GTK_CLIST (data)->focus_row,
6760 row = gtk_clist_prepend (GTK_CLIST (data), text);
6764 GdkColor col1 = { 0, };
6765 GdkColor col2 = { 0, };
6774 style1 = gtk_style_copy (GTK_WIDGET (data)->style);
6775 style1->base[GTK_STATE_NORMAL] = col1;
6776 style1->base[GTK_STATE_SELECTED] = col2;
6778 style2 = gtk_style_copy (GTK_WIDGET (data)->style);
6779 style2->fg[GTK_STATE_NORMAL] = col1;
6780 style2->fg[GTK_STATE_SELECTED] = col2;
6782 style3 = gtk_style_copy (GTK_WIDGET (data)->style);
6783 style3->fg[GTK_STATE_NORMAL] = col1;
6784 style3->base[GTK_STATE_NORMAL] = col2;
6785 pango_font_description_free (style3->font_desc);
6786 style3->font_desc = pango_font_description_from_string ("courier 12");
6789 gtk_clist_set_cell_style (GTK_CLIST (data), row, 3, style1);
6790 gtk_clist_set_cell_style (GTK_CLIST (data), row, 4, style2);
6791 gtk_clist_set_cell_style (GTK_CLIST (data), row, 0, style3);
6797 clist_warning_test (GtkWidget *button,
6801 static gboolean add_remove = FALSE;
6803 add_remove = !add_remove;
6805 child = gtk_label_new ("Test");
6806 g_object_ref (child);
6807 gtk_object_sink (GTK_OBJECT (child));
6810 gtk_container_add (GTK_CONTAINER (clist), child);
6813 child->parent = clist;
6814 gtk_container_remove (GTK_CONTAINER (clist), child);
6815 child->parent = NULL;
6818 gtk_widget_destroy (child);
6819 gtk_widget_unref (child);
6823 undo_selection (GtkWidget *button, GtkCList *clist)
6825 gtk_clist_undo_selection (clist);
6829 clist_toggle_sel_mode (GtkWidget *widget, gpointer data)
6834 clist = GTK_CLIST (data);
6836 if (!GTK_WIDGET_MAPPED (widget))
6839 i = gtk_option_menu_get_history (GTK_OPTION_MENU (widget));
6841 gtk_clist_set_selection_mode (clist, selection_modes[i]);
6845 clist_click_column (GtkCList *clist, gint column, gpointer data)
6848 gtk_clist_set_column_visibility (clist, column, FALSE);
6849 else if (column == clist->sort_column)
6851 if (clist->sort_type == GTK_SORT_ASCENDING)
6852 clist->sort_type = GTK_SORT_DESCENDING;
6854 clist->sort_type = GTK_SORT_ASCENDING;
6857 gtk_clist_set_sort_column (clist, column);
6859 gtk_clist_sort (clist);
6863 create_clist (GtkWidget *widget)
6866 static GtkWidget *window = NULL;
6868 static char *titles[] =
6870 "auto resize", "not resizeable", "max width 100", "min width 50",
6871 "hide column", "Title 5", "Title 6", "Title 7",
6872 "Title 8", "Title 9", "Title 10", "Title 11"
6875 char text[TESTGTK_CLIST_COLUMNS][50];
6876 char *texts[TESTGTK_CLIST_COLUMNS];
6882 GtkWidget *separator;
6883 GtkWidget *scrolled_win;
6886 GtkWidget *undo_button;
6890 GdkColor col1 = { 0, };
6891 GdkColor col2 = { 0, };
6896 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
6897 gtk_window_set_screen (GTK_WINDOW (window),
6898 gtk_widget_get_screen (widget));
6900 g_signal_connect (window, "destroy",
6901 G_CALLBACK (gtk_widget_destroyed), &window);
6903 gtk_window_set_title (GTK_WINDOW (window), "clist");
6904 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
6906 vbox = gtk_vbox_new (FALSE, 0);
6907 gtk_container_add (GTK_CONTAINER (window), vbox);
6909 scrolled_win = gtk_scrolled_window_new (NULL, NULL);
6910 gtk_container_set_border_width (GTK_CONTAINER (scrolled_win), 5);
6911 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
6912 GTK_POLICY_AUTOMATIC,
6913 GTK_POLICY_AUTOMATIC);
6915 /* create GtkCList here so we have a pointer to throw at the
6916 * button callbacks -- more is done with it later */
6917 clist = gtk_clist_new_with_titles (TESTGTK_CLIST_COLUMNS, titles);
6918 gtk_container_add (GTK_CONTAINER (scrolled_win), clist);
6919 g_signal_connect (clist, "click_column",
6920 G_CALLBACK (clist_click_column), NULL);
6922 /* control buttons */
6923 hbox = gtk_hbox_new (FALSE, 5);
6924 gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
6925 gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
6927 button = gtk_button_new_with_label ("Insert Row");
6928 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
6929 g_signal_connect (button, "clicked",
6930 G_CALLBACK (insert_row_clist), clist);
6932 button = gtk_button_new_with_label ("Add 1,000 Rows With Pixmaps");
6933 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
6934 g_signal_connect (button, "clicked",
6935 G_CALLBACK (add1000_clist), clist);
6937 button = gtk_button_new_with_label ("Add 10,000 Rows");
6938 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
6939 g_signal_connect (button, "clicked",
6940 G_CALLBACK (add10000_clist), clist);
6942 /* second layer of buttons */
6943 hbox = gtk_hbox_new (FALSE, 5);
6944 gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
6945 gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
6947 button = gtk_button_new_with_label ("Clear List");
6948 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
6949 g_signal_connect (button, "clicked",
6950 G_CALLBACK (clear_clist), clist);
6952 button = gtk_button_new_with_label ("Remove Selection");
6953 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
6954 g_signal_connect (button, "clicked",
6955 G_CALLBACK (clist_remove_selection), clist);
6957 undo_button = gtk_button_new_with_label ("Undo Selection");
6958 gtk_box_pack_start (GTK_BOX (hbox), undo_button, TRUE, TRUE, 0);
6959 g_signal_connect (undo_button, "clicked",
6960 G_CALLBACK (undo_selection), clist);
6962 button = gtk_button_new_with_label ("Warning Test");
6963 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
6964 g_signal_connect (button, "clicked",
6965 G_CALLBACK (clist_warning_test), clist);
6967 /* third layer of buttons */
6968 hbox = gtk_hbox_new (FALSE, 5);
6969 gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
6970 gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
6972 check = gtk_check_button_new_with_label ("Show Title Buttons");
6973 gtk_box_pack_start (GTK_BOX (hbox), check, FALSE, TRUE, 0);
6974 g_signal_connect (check, "clicked",
6975 G_CALLBACK (toggle_title_buttons), clist);
6976 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check), TRUE);
6978 check = gtk_check_button_new_with_label ("Reorderable");
6979 gtk_box_pack_start (GTK_BOX (hbox), check, FALSE, TRUE, 0);
6980 g_signal_connect (check, "clicked",
6981 G_CALLBACK (toggle_reorderable), clist);
6982 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check), TRUE);
6984 label = gtk_label_new ("Selection Mode :");
6985 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
6987 clist_omenu = build_option_menu (selection_mode_items, 3, 3,
6988 clist_toggle_sel_mode,
6990 gtk_box_pack_start (GTK_BOX (hbox), clist_omenu, FALSE, TRUE, 0);
6993 * the rest of the clist configuration
6996 gtk_box_pack_start (GTK_BOX (vbox), scrolled_win, TRUE, TRUE, 0);
6997 gtk_clist_set_row_height (GTK_CLIST (clist), 18);
6998 gtk_widget_set_size_request (clist, -1, 300);
7000 for (i = 1; i < TESTGTK_CLIST_COLUMNS; i++)
7001 gtk_clist_set_column_width (GTK_CLIST (clist), i, 80);
7003 gtk_clist_set_column_auto_resize (GTK_CLIST (clist), 0, TRUE);
7004 gtk_clist_set_column_resizeable (GTK_CLIST (clist), 1, FALSE);
7005 gtk_clist_set_column_max_width (GTK_CLIST (clist), 2, 100);
7006 gtk_clist_set_column_min_width (GTK_CLIST (clist), 3, 50);
7007 gtk_clist_set_selection_mode (GTK_CLIST (clist), GTK_SELECTION_EXTENDED);
7008 gtk_clist_set_column_justification (GTK_CLIST (clist), 1,
7010 gtk_clist_set_column_justification (GTK_CLIST (clist), 2,
7011 GTK_JUSTIFY_CENTER);
7013 for (i = 0; i < TESTGTK_CLIST_COLUMNS; i++)
7016 sprintf (text[i], "Column %d", i);
7019 sprintf (text[1], "Right");
7020 sprintf (text[2], "Center");
7029 style = gtk_style_new ();
7030 style->fg[GTK_STATE_NORMAL] = col1;
7031 style->base[GTK_STATE_NORMAL] = col2;
7033 pango_font_description_set_size (style->font_desc, 14 * PANGO_SCALE);
7034 pango_font_description_set_weight (style->font_desc, PANGO_WEIGHT_BOLD);
7036 for (i = 0; i < 10; i++)
7038 sprintf (text[0], "CListRow %d", clist_rows++);
7039 gtk_clist_append (GTK_CLIST (clist), texts);
7044 gtk_clist_set_row_style (GTK_CLIST (clist), i, style);
7047 gtk_clist_set_cell_style (GTK_CLIST (clist), i, i % 4, style);
7052 gtk_style_unref (style);
7054 separator = gtk_hseparator_new ();
7055 gtk_box_pack_start (GTK_BOX (vbox), separator, FALSE, TRUE, 0);
7057 hbox = gtk_hbox_new (FALSE, 0);
7058 gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0);
7060 button = gtk_button_new_with_label ("close");
7061 gtk_container_set_border_width (GTK_CONTAINER (button), 10);
7062 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
7063 g_signal_connect_swapped (button, "clicked",
7064 G_CALLBACK (gtk_widget_destroy),
7067 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
7068 gtk_widget_grab_default (button);
7071 if (!GTK_WIDGET_VISIBLE (window))
7072 gtk_widget_show_all (window);
7076 gtk_widget_destroy (window);
7094 static gint books = 0;
7095 static gint pages = 0;
7097 static GtkWidget *book_label;
7098 static GtkWidget *page_label;
7099 static GtkWidget *sel_label;
7100 static GtkWidget *vis_label;
7101 static GtkWidget *omenu1;
7102 static GtkWidget *omenu2;
7103 static GtkWidget *omenu3;
7104 static GtkWidget *omenu4;
7105 static GtkWidget *spin1;
7106 static GtkWidget *spin2;
7107 static GtkWidget *spin3;
7108 static gint line_style;
7111 static CTreePixmaps *
7112 get_ctree_pixmaps (GtkCTree *ctree)
7114 GdkScreen *screen = gtk_widget_get_screen (GTK_WIDGET (ctree));
7115 CTreePixmaps *pixmaps = g_object_get_data (G_OBJECT (screen), "ctree-pixmaps");
7119 GdkColormap *colormap = gdk_screen_get_rgb_colormap (screen);
7120 pixmaps = g_new (CTreePixmaps, 1);
7122 pixmaps->pixmap1 = gdk_pixmap_colormap_create_from_xpm_d (NULL, colormap,
7124 NULL, book_closed_xpm);
7125 pixmaps->pixmap2 = gdk_pixmap_colormap_create_from_xpm_d (NULL, colormap,
7127 NULL, book_open_xpm);
7128 pixmaps->pixmap3 = gdk_pixmap_colormap_create_from_xpm_d (NULL, colormap,
7130 NULL, mini_page_xpm);
7132 g_object_set_data (G_OBJECT (screen), "ctree-pixmaps", pixmaps);
7138 void after_press (GtkCTree *ctree, gpointer data)
7142 sprintf (buf, "%d", g_list_length (GTK_CLIST (ctree)->selection));
7143 gtk_label_set_text (GTK_LABEL (sel_label), buf);
7145 sprintf (buf, "%d", g_list_length (GTK_CLIST (ctree)->row_list));
7146 gtk_label_set_text (GTK_LABEL (vis_label), buf);
7148 sprintf (buf, "%d", books);
7149 gtk_label_set_text (GTK_LABEL (book_label), buf);
7151 sprintf (buf, "%d", pages);
7152 gtk_label_set_text (GTK_LABEL (page_label), buf);
7155 void after_move (GtkCTree *ctree, GtkCTreeNode *child, GtkCTreeNode *parent,
7156 GtkCTreeNode *sibling, gpointer data)
7162 gtk_ctree_get_node_info (ctree, child, &source,
7163 NULL, NULL, NULL, NULL, NULL, NULL, NULL);
7165 gtk_ctree_get_node_info (ctree, parent, &target1,
7166 NULL, NULL, NULL, NULL, NULL, NULL, NULL);
7168 gtk_ctree_get_node_info (ctree, sibling, &target2,
7169 NULL, NULL, NULL, NULL, NULL, NULL, NULL);
7171 g_print ("Moving \"%s\" to \"%s\" with sibling \"%s\".\n", source,
7172 (parent) ? target1 : "nil", (sibling) ? target2 : "nil");
7175 void count_items (GtkCTree *ctree, GtkCTreeNode *list)
7177 if (GTK_CTREE_ROW (list)->is_leaf)
7183 void expand_all (GtkWidget *widget, GtkCTree *ctree)
7185 gtk_ctree_expand_recursive (ctree, NULL);
7186 after_press (ctree, NULL);
7189 void collapse_all (GtkWidget *widget, GtkCTree *ctree)
7191 gtk_ctree_collapse_recursive (ctree, NULL);
7192 after_press (ctree, NULL);
7195 void select_all (GtkWidget *widget, GtkCTree *ctree)
7197 gtk_ctree_select_recursive (ctree, NULL);
7198 after_press (ctree, NULL);
7201 void change_style (GtkWidget *widget, GtkCTree *ctree)
7203 static GtkStyle *style1 = NULL;
7204 static GtkStyle *style2 = NULL;
7207 GdkColor col1 = { 0, };
7208 GdkColor col2 = { 0, };
7210 if (GTK_CLIST (ctree)->focus_row >= 0)
7211 node = GTK_CTREE_NODE
7212 (g_list_nth (GTK_CLIST (ctree)->row_list,GTK_CLIST (ctree)->focus_row));
7214 node = GTK_CTREE_NODE (GTK_CLIST (ctree)->row_list);
7228 style1 = gtk_style_new ();
7229 style1->base[GTK_STATE_NORMAL] = col1;
7230 style1->fg[GTK_STATE_SELECTED] = col2;
7232 style2 = gtk_style_new ();
7233 style2->base[GTK_STATE_SELECTED] = col2;
7234 style2->fg[GTK_STATE_NORMAL] = col1;
7235 style2->base[GTK_STATE_NORMAL] = col2;
7236 pango_font_description_free (style2->font_desc);
7237 style2->font_desc = pango_font_description_from_string ("courier 30");
7240 gtk_ctree_node_set_cell_style (ctree, node, 1, style1);
7241 gtk_ctree_node_set_cell_style (ctree, node, 0, style2);
7243 if (GTK_CTREE_ROW (node)->children)
7244 gtk_ctree_node_set_row_style (ctree, GTK_CTREE_ROW (node)->children,
7248 void unselect_all (GtkWidget *widget, GtkCTree *ctree)
7250 gtk_ctree_unselect_recursive (ctree, NULL);
7251 after_press (ctree, NULL);
7254 void remove_selection (GtkWidget *widget, GtkCTree *ctree)
7259 clist = GTK_CLIST (ctree);
7261 gtk_clist_freeze (clist);
7263 while (clist->selection)
7265 node = clist->selection->data;
7267 if (GTK_CTREE_ROW (node)->is_leaf)
7270 gtk_ctree_post_recursive (ctree, node,
7271 (GtkCTreeFunc) count_items, NULL);
7273 gtk_ctree_remove_node (ctree, node);
7275 if (clist->selection_mode == GTK_SELECTION_BROWSE)
7279 if (clist->selection_mode == GTK_SELECTION_EXTENDED && !clist->selection &&
7280 clist->focus_row >= 0)
7282 node = gtk_ctree_node_nth (ctree, clist->focus_row);
7285 gtk_ctree_select (ctree, node);
7288 gtk_clist_thaw (clist);
7289 after_press (ctree, NULL);
7292 struct _ExportStruct {
7298 typedef struct _ExportStruct ExportStruct;
7301 gnode2ctree (GtkCTree *ctree,
7304 GtkCTreeNode *cnode,
7308 GdkPixmap *pixmap_closed;
7309 GdkBitmap *mask_closed;
7310 GdkPixmap *pixmap_opened;
7311 GdkBitmap *mask_opened;
7312 CTreePixmaps *pixmaps;
7314 if (!cnode || !gnode || (!(es = gnode->data)))
7317 pixmaps = get_ctree_pixmaps (ctree);
7321 pixmap_closed = pixmaps->pixmap3;
7322 mask_closed = pixmaps->mask3;
7323 pixmap_opened = NULL;
7328 pixmap_closed = pixmaps->pixmap1;
7329 mask_closed = pixmaps->mask1;
7330 pixmap_opened = pixmaps->pixmap2;
7331 mask_opened = pixmaps->mask2;
7334 gtk_ctree_set_node_info (ctree, cnode, es->tree, 2, pixmap_closed,
7335 mask_closed, pixmap_opened, mask_opened,
7336 es->is_leaf, (depth < 3));
7337 gtk_ctree_node_set_text (ctree, cnode, 1, es->info);
7345 ctree2gnode (GtkCTree *ctree,
7348 GtkCTreeNode *cnode,
7353 if (!cnode || !gnode)
7356 es = g_new (ExportStruct, 1);
7358 es->is_leaf = GTK_CTREE_ROW (cnode)->is_leaf;
7359 es->tree = GTK_CELL_PIXTEXT (GTK_CTREE_ROW (cnode)->row.cell[0])->text;
7360 es->info = GTK_CELL_PIXTEXT (GTK_CTREE_ROW (cnode)->row.cell[1])->text;
7364 void export_ctree (GtkWidget *widget, GtkCTree *ctree)
7366 char *title[] = { "Tree" , "Info" };
7367 static GtkWidget *export_window = NULL;
7368 static GtkCTree *export_ctree;
7370 GtkWidget *scrolled_win;
7378 export_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
7380 gtk_window_set_screen (GTK_WINDOW (export_window),
7381 gtk_widget_get_screen (widget));
7383 g_signal_connect (export_window, "destroy",
7384 G_CALLBACK (gtk_widget_destroyed),
7387 gtk_window_set_title (GTK_WINDOW (export_window), "exported ctree");
7388 gtk_container_set_border_width (GTK_CONTAINER (export_window), 5);
7390 vbox = gtk_vbox_new (FALSE, 0);
7391 gtk_container_add (GTK_CONTAINER (export_window), vbox);
7393 button = gtk_button_new_with_label ("Close");
7394 gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, TRUE, 0);
7396 g_signal_connect_swapped (button, "clicked",
7397 G_CALLBACK (gtk_widget_destroy),
7400 sep = gtk_hseparator_new ();
7401 gtk_box_pack_end (GTK_BOX (vbox), sep, FALSE, TRUE, 10);
7403 export_ctree = GTK_CTREE (gtk_ctree_new_with_titles (2, 0, title));
7404 gtk_ctree_set_line_style (export_ctree, GTK_CTREE_LINES_DOTTED);
7406 scrolled_win = gtk_scrolled_window_new (NULL, NULL);
7407 gtk_container_add (GTK_CONTAINER (scrolled_win),
7408 GTK_WIDGET (export_ctree));
7409 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
7410 GTK_POLICY_AUTOMATIC,
7411 GTK_POLICY_AUTOMATIC);
7412 gtk_box_pack_start (GTK_BOX (vbox), scrolled_win, TRUE, TRUE, 0);
7413 gtk_clist_set_selection_mode (GTK_CLIST (export_ctree),
7414 GTK_SELECTION_EXTENDED);
7415 gtk_clist_set_column_width (GTK_CLIST (export_ctree), 0, 200);
7416 gtk_clist_set_column_width (GTK_CLIST (export_ctree), 1, 200);
7417 gtk_widget_set_size_request (GTK_WIDGET (export_ctree), 300, 200);
7420 if (!GTK_WIDGET_VISIBLE (export_window))
7421 gtk_widget_show_all (export_window);
7423 gtk_clist_clear (GTK_CLIST (export_ctree));
7425 node = GTK_CTREE_NODE (g_list_nth (GTK_CLIST (ctree)->row_list,
7426 GTK_CLIST (ctree)->focus_row));
7430 gnode = gtk_ctree_export_to_gnode (ctree, NULL, NULL, node,
7434 gtk_ctree_insert_gnode (export_ctree, NULL, NULL, gnode,
7436 g_node_destroy (gnode);
7440 void change_indent (GtkWidget *widget, GtkCTree *ctree)
7442 gtk_ctree_set_indent (ctree, GTK_ADJUSTMENT (widget)->value);
7445 void change_spacing (GtkWidget *widget, GtkCTree *ctree)
7447 gtk_ctree_set_spacing (ctree, GTK_ADJUSTMENT (widget)->value);
7450 void change_row_height (GtkWidget *widget, GtkCList *clist)
7452 gtk_clist_set_row_height (clist, GTK_ADJUSTMENT (widget)->value);
7455 void set_background (GtkCTree *ctree, GtkCTreeNode *node, gpointer data)
7457 GtkStyle *style = NULL;
7462 if (ctree->line_style != GTK_CTREE_LINES_TABBED)
7464 if (!GTK_CTREE_ROW (node)->is_leaf)
7465 style = GTK_CTREE_ROW (node)->row.data;
7466 else if (GTK_CTREE_ROW (node)->parent)
7467 style = GTK_CTREE_ROW (GTK_CTREE_ROW (node)->parent)->row.data;
7470 gtk_ctree_node_set_row_style (ctree, node, style);
7474 ctree_toggle_line_style (GtkWidget *widget, gpointer data)
7479 ctree = GTK_CTREE (data);
7481 if (!GTK_WIDGET_MAPPED (widget))
7484 i = gtk_option_menu_get_history (GTK_OPTION_MENU (widget));
7486 if ((ctree->line_style == GTK_CTREE_LINES_TABBED &&
7487 ((GtkCTreeLineStyle) i) != GTK_CTREE_LINES_TABBED) ||
7488 (ctree->line_style != GTK_CTREE_LINES_TABBED &&
7489 ((GtkCTreeLineStyle) i) == GTK_CTREE_LINES_TABBED))
7490 gtk_ctree_pre_recursive (ctree, NULL, set_background, NULL);
7491 gtk_ctree_set_line_style (ctree, i);
7496 ctree_toggle_expander_style (GtkWidget *widget, gpointer data)
7501 ctree = GTK_CTREE (data);
7503 if (!GTK_WIDGET_MAPPED (widget))
7506 i = gtk_option_menu_get_history (GTK_OPTION_MENU (widget));
7508 gtk_ctree_set_expander_style (ctree, (GtkCTreeExpanderStyle) i);
7512 ctree_toggle_justify (GtkWidget *widget, gpointer data)
7517 ctree = GTK_CTREE (data);
7519 if (!GTK_WIDGET_MAPPED (widget))
7522 i = gtk_option_menu_get_history (GTK_OPTION_MENU (widget));
7524 gtk_clist_set_column_justification (GTK_CLIST (ctree), ctree->tree_column,
7525 (GtkJustification) i);
7529 ctree_toggle_sel_mode (GtkWidget *widget, gpointer data)
7534 ctree = GTK_CTREE (data);
7536 if (!GTK_WIDGET_MAPPED (widget))
7539 i = gtk_option_menu_get_history (GTK_OPTION_MENU (widget));
7541 gtk_clist_set_selection_mode (GTK_CLIST (ctree), selection_modes[i]);
7542 after_press (ctree, NULL);
7545 void build_recursive (GtkCTree *ctree, gint cur_depth, gint depth,
7546 gint num_books, gint num_pages, GtkCTreeNode *parent)
7551 GtkCTreeNode *sibling;
7552 CTreePixmaps *pixmaps;
7559 pixmaps = get_ctree_pixmaps (ctree);
7561 for (i = num_pages + num_books; i > num_books; i--)
7564 sprintf (buf1, "Page %02d", (gint) rand() % 100);
7565 sprintf (buf2, "Item %d-%d", cur_depth, i);
7566 sibling = gtk_ctree_insert_node (ctree, parent, sibling, text, 5,
7567 pixmaps->pixmap3, pixmaps->mask3, NULL, NULL,
7570 if (parent && ctree->line_style == GTK_CTREE_LINES_TABBED)
7571 gtk_ctree_node_set_row_style (ctree, sibling,
7572 GTK_CTREE_ROW (parent)->row.style);
7575 if (cur_depth == depth)
7578 for (i = num_books; i > 0; i--)
7583 sprintf (buf1, "Book %02d", (gint) rand() % 100);
7584 sprintf (buf2, "Item %d-%d", cur_depth, i);
7585 sibling = gtk_ctree_insert_node (ctree, parent, sibling, text, 5,
7586 pixmaps->pixmap1, pixmaps->mask1, pixmaps->pixmap2, pixmaps->mask2,
7589 style = gtk_style_new ();
7590 switch (cur_depth % 3)
7593 style->base[GTK_STATE_NORMAL].red = 10000 * (cur_depth % 6);
7594 style->base[GTK_STATE_NORMAL].green = 0;
7595 style->base[GTK_STATE_NORMAL].blue = 65535 - ((i * 10000) % 65535);
7598 style->base[GTK_STATE_NORMAL].red = 10000 * (cur_depth % 6);
7599 style->base[GTK_STATE_NORMAL].green = 65535 - ((i * 10000) % 65535);
7600 style->base[GTK_STATE_NORMAL].blue = 0;
7603 style->base[GTK_STATE_NORMAL].red = 65535 - ((i * 10000) % 65535);
7604 style->base[GTK_STATE_NORMAL].green = 0;
7605 style->base[GTK_STATE_NORMAL].blue = 10000 * (cur_depth % 6);
7608 gtk_ctree_node_set_row_data_full (ctree, sibling, style,
7609 (GtkDestroyNotify) gtk_style_unref);
7611 if (ctree->line_style == GTK_CTREE_LINES_TABBED)
7612 gtk_ctree_node_set_row_style (ctree, sibling, style);
7614 build_recursive (ctree, cur_depth + 1, depth, num_books, num_pages,
7619 void rebuild_tree (GtkWidget *widget, GtkCTree *ctree)
7622 gchar label1[] = "Root";
7623 gchar label2[] = "";
7624 GtkCTreeNode *parent;
7627 CTreePixmaps *pixmaps;
7629 pixmaps = get_ctree_pixmaps (ctree);
7634 d = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (spin1));
7635 b = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (spin2));
7636 p = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (spin3));
7638 n = ((pow (b, d) - 1) / (b - 1)) * (p + 1);
7642 g_print ("%d total items? Try less\n",n);
7646 gtk_clist_freeze (GTK_CLIST (ctree));
7647 gtk_clist_clear (GTK_CLIST (ctree));
7652 parent = gtk_ctree_insert_node (ctree, NULL, NULL, text, 5, pixmaps->pixmap1,
7653 pixmaps->mask1, pixmaps->pixmap2, pixmaps->mask2, FALSE, TRUE);
7655 style = gtk_style_new ();
7656 style->base[GTK_STATE_NORMAL].red = 0;
7657 style->base[GTK_STATE_NORMAL].green = 45000;
7658 style->base[GTK_STATE_NORMAL].blue = 55000;
7659 gtk_ctree_node_set_row_data_full (ctree, parent, style,
7660 (GtkDestroyNotify) gtk_style_unref);
7662 if (ctree->line_style == GTK_CTREE_LINES_TABBED)
7663 gtk_ctree_node_set_row_style (ctree, parent, style);
7665 build_recursive (ctree, 1, d, b, p, parent);
7666 gtk_clist_thaw (GTK_CLIST (ctree));
7667 after_press (ctree, NULL);
7671 ctree_click_column (GtkCTree *ctree, gint column, gpointer data)
7675 clist = GTK_CLIST (ctree);
7677 if (column == clist->sort_column)
7679 if (clist->sort_type == GTK_SORT_ASCENDING)
7680 clist->sort_type = GTK_SORT_DESCENDING;
7682 clist->sort_type = GTK_SORT_ASCENDING;
7685 gtk_clist_set_sort_column (clist, column);
7687 gtk_ctree_sort_recursive (ctree, NULL);
7690 void create_ctree (GtkWidget *widget)
7692 static GtkWidget *window = NULL;
7693 GtkTooltips *tooltips;
7695 GtkWidget *scrolled_win;
7708 char *title[] = { "Tree" , "Info" };
7711 static gchar *items1[] =
7719 static gchar *items2[] =
7727 static gchar *items3[] =
7735 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
7736 gtk_window_set_screen (GTK_WINDOW (window),
7737 gtk_widget_get_screen (widget));
7739 g_signal_connect (window, "destroy",
7740 G_CALLBACK (gtk_widget_destroyed),
7743 gtk_window_set_title (GTK_WINDOW (window), "GtkCTree");
7744 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
7746 tooltips = gtk_tooltips_new ();
7747 g_object_ref (tooltips);
7748 gtk_object_sink (GTK_OBJECT (tooltips));
7750 g_object_set_data_full (G_OBJECT (window), "tooltips", tooltips,
7753 vbox = gtk_vbox_new (FALSE, 0);
7754 gtk_container_add (GTK_CONTAINER (window), vbox);
7756 hbox = gtk_hbox_new (FALSE, 5);
7757 gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
7758 gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0);
7760 label = gtk_label_new ("Depth :");
7761 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
7763 adj = (GtkAdjustment *) gtk_adjustment_new (4, 1, 10, 1, 5, 0);
7764 spin1 = gtk_spin_button_new (adj, 0, 0);
7765 gtk_box_pack_start (GTK_BOX (hbox), spin1, FALSE, TRUE, 5);
7767 label = gtk_label_new ("Books :");
7768 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
7770 adj = (GtkAdjustment *) gtk_adjustment_new (3, 1, 20, 1, 5, 0);
7771 spin2 = gtk_spin_button_new (adj, 0, 0);
7772 gtk_box_pack_start (GTK_BOX (hbox), spin2, FALSE, TRUE, 5);
7774 label = gtk_label_new ("Pages :");
7775 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
7777 adj = (GtkAdjustment *) gtk_adjustment_new (5, 1, 20, 1, 5, 0);
7778 spin3 = gtk_spin_button_new (adj, 0, 0);
7779 gtk_box_pack_start (GTK_BOX (hbox), spin3, FALSE, TRUE, 5);
7781 button = gtk_button_new_with_label ("Close");
7782 gtk_box_pack_end (GTK_BOX (hbox), button, TRUE, TRUE, 0);
7784 g_signal_connect_swapped (button, "clicked",
7785 G_CALLBACK (gtk_widget_destroy),
7788 button = gtk_button_new_with_label ("Rebuild Tree");
7789 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
7791 scrolled_win = gtk_scrolled_window_new (NULL, NULL);
7792 gtk_container_set_border_width (GTK_CONTAINER (scrolled_win), 5);
7793 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
7794 GTK_POLICY_AUTOMATIC,
7796 gtk_box_pack_start (GTK_BOX (vbox), scrolled_win, TRUE, TRUE, 0);
7798 ctree = GTK_CTREE (gtk_ctree_new_with_titles (2, 0, title));
7799 gtk_container_add (GTK_CONTAINER (scrolled_win), GTK_WIDGET (ctree));
7801 gtk_clist_set_column_auto_resize (GTK_CLIST (ctree), 0, TRUE);
7802 gtk_clist_set_column_width (GTK_CLIST (ctree), 1, 200);
7803 gtk_clist_set_selection_mode (GTK_CLIST (ctree), GTK_SELECTION_EXTENDED);
7804 gtk_ctree_set_line_style (ctree, GTK_CTREE_LINES_DOTTED);
7805 line_style = GTK_CTREE_LINES_DOTTED;
7807 g_signal_connect (button, "clicked",
7808 G_CALLBACK (rebuild_tree), ctree);
7809 g_signal_connect (ctree, "click_column",
7810 G_CALLBACK (ctree_click_column), NULL);
7812 g_signal_connect_after (ctree, "button_press_event",
7813 G_CALLBACK (after_press), NULL);
7814 g_signal_connect_after (ctree, "button_release_event",
7815 G_CALLBACK (after_press), NULL);
7816 g_signal_connect_after (ctree, "tree_move",
7817 G_CALLBACK (after_move), NULL);
7818 g_signal_connect_after (ctree, "end_selection",
7819 G_CALLBACK (after_press), NULL);
7820 g_signal_connect_after (ctree, "toggle_focus_row",
7821 G_CALLBACK (after_press), NULL);
7822 g_signal_connect_after (ctree, "select_all",
7823 G_CALLBACK (after_press), NULL);
7824 g_signal_connect_after (ctree, "unselect_all",
7825 G_CALLBACK (after_press), NULL);
7826 g_signal_connect_after (ctree, "scroll_vertical",
7827 G_CALLBACK (after_press), NULL);
7829 bbox = gtk_hbox_new (FALSE, 5);
7830 gtk_container_set_border_width (GTK_CONTAINER (bbox), 5);
7831 gtk_box_pack_start (GTK_BOX (vbox), bbox, FALSE, TRUE, 0);
7833 mbox = gtk_vbox_new (TRUE, 5);
7834 gtk_box_pack_start (GTK_BOX (bbox), mbox, FALSE, TRUE, 0);
7836 label = gtk_label_new ("Row Height :");
7837 gtk_box_pack_start (GTK_BOX (mbox), label, FALSE, FALSE, 0);
7839 label = gtk_label_new ("Indent :");
7840 gtk_box_pack_start (GTK_BOX (mbox), label, FALSE, FALSE, 0);
7842 label = gtk_label_new ("Spacing :");
7843 gtk_box_pack_start (GTK_BOX (mbox), label, FALSE, FALSE, 0);
7845 mbox = gtk_vbox_new (TRUE, 5);
7846 gtk_box_pack_start (GTK_BOX (bbox), mbox, FALSE, TRUE, 0);
7848 adj = (GtkAdjustment *) gtk_adjustment_new (20, 12, 100, 1, 10, 0);
7849 spinner = gtk_spin_button_new (adj, 0, 0);
7850 gtk_box_pack_start (GTK_BOX (mbox), spinner, FALSE, FALSE, 5);
7851 gtk_tooltips_set_tip (tooltips, spinner,
7852 "Row height of list items", NULL);
7853 g_signal_connect (adj, "value_changed",
7854 G_CALLBACK (change_row_height), ctree);
7855 gtk_clist_set_row_height ( GTK_CLIST (ctree), adj->value);
7857 adj = (GtkAdjustment *) gtk_adjustment_new (20, 0, 60, 1, 10, 0);
7858 spinner = gtk_spin_button_new (adj, 0, 0);
7859 gtk_box_pack_start (GTK_BOX (mbox), spinner, FALSE, FALSE, 5);
7860 gtk_tooltips_set_tip (tooltips, spinner, "Tree Indentation.", NULL);
7861 g_signal_connect (adj, "value_changed",
7862 G_CALLBACK (change_indent), ctree);
7864 adj = (GtkAdjustment *) gtk_adjustment_new (5, 0, 60, 1, 10, 0);
7865 spinner = gtk_spin_button_new (adj, 0, 0);
7866 gtk_box_pack_start (GTK_BOX (mbox), spinner, FALSE, FALSE, 5);
7867 gtk_tooltips_set_tip (tooltips, spinner, "Tree Spacing.", NULL);
7868 g_signal_connect (adj, "value_changed",
7869 G_CALLBACK (change_spacing), ctree);
7871 mbox = gtk_vbox_new (TRUE, 5);
7872 gtk_box_pack_start (GTK_BOX (bbox), mbox, FALSE, TRUE, 0);
7874 hbox = gtk_hbox_new (FALSE, 5);
7875 gtk_box_pack_start (GTK_BOX (mbox), hbox, FALSE, FALSE, 0);
7877 button = gtk_button_new_with_label ("Expand All");
7878 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
7879 g_signal_connect (button, "clicked",
7880 G_CALLBACK (expand_all), ctree);
7882 button = gtk_button_new_with_label ("Collapse All");
7883 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
7884 g_signal_connect (button, "clicked",
7885 G_CALLBACK (collapse_all), ctree);
7887 button = gtk_button_new_with_label ("Change Style");
7888 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
7889 g_signal_connect (button, "clicked",
7890 G_CALLBACK (change_style), ctree);
7892 button = gtk_button_new_with_label ("Export Tree");
7893 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
7894 g_signal_connect (button, "clicked",
7895 G_CALLBACK (export_ctree), ctree);
7897 hbox = gtk_hbox_new (FALSE, 5);
7898 gtk_box_pack_start (GTK_BOX (mbox), hbox, FALSE, FALSE, 0);
7900 button = gtk_button_new_with_label ("Select All");
7901 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
7902 g_signal_connect (button, "clicked",
7903 G_CALLBACK (select_all), ctree);
7905 button = gtk_button_new_with_label ("Unselect All");
7906 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
7907 g_signal_connect (button, "clicked",
7908 G_CALLBACK (unselect_all), ctree);
7910 button = gtk_button_new_with_label ("Remove Selection");
7911 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
7912 g_signal_connect (button, "clicked",
7913 G_CALLBACK (remove_selection), ctree);
7915 check = gtk_check_button_new_with_label ("Reorderable");
7916 gtk_box_pack_start (GTK_BOX (hbox), check, FALSE, TRUE, 0);
7917 gtk_tooltips_set_tip (tooltips, check,
7918 "Tree items can be reordered by dragging.", NULL);
7919 g_signal_connect (check, "clicked",
7920 G_CALLBACK (toggle_reorderable), ctree);
7921 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check), TRUE);
7923 hbox = gtk_hbox_new (TRUE, 5);
7924 gtk_box_pack_start (GTK_BOX (mbox), hbox, FALSE, FALSE, 0);
7926 omenu1 = build_option_menu (items1, 4, 2,
7927 ctree_toggle_line_style,
7929 gtk_box_pack_start (GTK_BOX (hbox), omenu1, FALSE, TRUE, 0);
7930 gtk_tooltips_set_tip (tooltips, omenu1, "The tree's line style.", NULL);
7932 omenu2 = build_option_menu (items2, 4, 1,
7933 ctree_toggle_expander_style,
7935 gtk_box_pack_start (GTK_BOX (hbox), omenu2, FALSE, TRUE, 0);
7936 gtk_tooltips_set_tip (tooltips, omenu2, "The tree's expander style.",
7939 omenu3 = build_option_menu (items3, 2, 0,
7940 ctree_toggle_justify, ctree);
7941 gtk_box_pack_start (GTK_BOX (hbox), omenu3, FALSE, TRUE, 0);
7942 gtk_tooltips_set_tip (tooltips, omenu3, "The tree's justification.",
7945 omenu4 = build_option_menu (selection_mode_items, 3, 3,
7946 ctree_toggle_sel_mode, ctree);
7947 gtk_box_pack_start (GTK_BOX (hbox), omenu4, FALSE, TRUE, 0);
7948 gtk_tooltips_set_tip (tooltips, omenu4, "The list's selection mode.",
7951 gtk_widget_realize (window);
7953 gtk_widget_set_size_request (GTK_WIDGET (ctree), -1, 300);
7955 frame = gtk_frame_new (NULL);
7956 gtk_container_set_border_width (GTK_CONTAINER (frame), 0);
7957 gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_OUT);
7958 gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, TRUE, 0);
7960 hbox = gtk_hbox_new (TRUE, 2);
7961 gtk_container_set_border_width (GTK_CONTAINER (hbox), 2);
7962 gtk_container_add (GTK_CONTAINER (frame), hbox);
7964 frame = gtk_frame_new (NULL);
7965 gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
7966 gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, TRUE, 0);
7968 hbox2 = gtk_hbox_new (FALSE, 0);
7969 gtk_container_set_border_width (GTK_CONTAINER (hbox2), 2);
7970 gtk_container_add (GTK_CONTAINER (frame), hbox2);
7972 label = gtk_label_new ("Books :");
7973 gtk_box_pack_start (GTK_BOX (hbox2), label, FALSE, TRUE, 0);
7975 sprintf (buf, "%d", books);
7976 book_label = gtk_label_new (buf);
7977 gtk_box_pack_end (GTK_BOX (hbox2), book_label, FALSE, TRUE, 5);
7979 frame = gtk_frame_new (NULL);
7980 gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
7981 gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, TRUE, 0);
7983 hbox2 = gtk_hbox_new (FALSE, 0);
7984 gtk_container_set_border_width (GTK_CONTAINER (hbox2), 2);
7985 gtk_container_add (GTK_CONTAINER (frame), hbox2);
7987 label = gtk_label_new ("Pages :");
7988 gtk_box_pack_start (GTK_BOX (hbox2), label, FALSE, TRUE, 0);
7990 sprintf (buf, "%d", pages);
7991 page_label = gtk_label_new (buf);
7992 gtk_box_pack_end (GTK_BOX (hbox2), page_label, FALSE, TRUE, 5);
7994 frame = gtk_frame_new (NULL);
7995 gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
7996 gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, TRUE, 0);
7998 hbox2 = gtk_hbox_new (FALSE, 0);
7999 gtk_container_set_border_width (GTK_CONTAINER (hbox2), 2);
8000 gtk_container_add (GTK_CONTAINER (frame), hbox2);
8002 label = gtk_label_new ("Selected :");
8003 gtk_box_pack_start (GTK_BOX (hbox2), label, FALSE, TRUE, 0);
8005 sprintf (buf, "%d", g_list_length (GTK_CLIST (ctree)->selection));
8006 sel_label = gtk_label_new (buf);
8007 gtk_box_pack_end (GTK_BOX (hbox2), sel_label, FALSE, TRUE, 5);
8009 frame = gtk_frame_new (NULL);
8010 gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
8011 gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, TRUE, 0);
8013 hbox2 = gtk_hbox_new (FALSE, 0);
8014 gtk_container_set_border_width (GTK_CONTAINER (hbox2), 2);
8015 gtk_container_add (GTK_CONTAINER (frame), hbox2);
8017 label = gtk_label_new ("Visible :");
8018 gtk_box_pack_start (GTK_BOX (hbox2), label, FALSE, TRUE, 0);
8020 sprintf (buf, "%d", g_list_length (GTK_CLIST (ctree)->row_list));
8021 vis_label = gtk_label_new (buf);
8022 gtk_box_pack_end (GTK_BOX (hbox2), vis_label, FALSE, TRUE, 5);
8024 rebuild_tree (NULL, ctree);
8027 if (!GTK_WIDGET_VISIBLE (window))
8028 gtk_widget_show_all (window);
8030 gtk_widget_destroy (window);
8038 color_selection_ok (GtkWidget *w,
8039 GtkColorSelectionDialog *cs)
8041 GtkColorSelection *colorsel;
8044 colorsel=GTK_COLOR_SELECTION(cs->colorsel);
8046 gtk_color_selection_get_color(colorsel,color);
8047 gtk_color_selection_set_color(colorsel,color);
8051 color_selection_changed (GtkWidget *w,
8052 GtkColorSelectionDialog *cs)
8054 GtkColorSelection *colorsel;
8057 colorsel=GTK_COLOR_SELECTION(cs->colorsel);
8058 gtk_color_selection_get_color(colorsel,color);
8063 opacity_toggled_cb (GtkWidget *w,
8064 GtkColorSelectionDialog *cs)
8066 GtkColorSelection *colorsel;
8068 colorsel = GTK_COLOR_SELECTION (cs->colorsel);
8069 gtk_color_selection_set_has_opacity_control (colorsel,
8070 gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (w)));
8074 palette_toggled_cb (GtkWidget *w,
8075 GtkColorSelectionDialog *cs)
8077 GtkColorSelection *colorsel;
8079 colorsel = GTK_COLOR_SELECTION (cs->colorsel);
8080 gtk_color_selection_set_has_palette (colorsel,
8081 gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (w)));
8086 create_color_selection (GtkWidget *widget)
8088 static GtkWidget *window = NULL;
8096 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
8097 gtk_window_set_screen (GTK_WINDOW (window),
8098 gtk_widget_get_screen (widget));
8100 g_signal_connect (window, "destroy",
8101 G_CALLBACK (gtk_widget_destroyed),
8104 gtk_window_set_title (GTK_WINDOW (window), "GtkColorButton");
8105 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
8107 hbox = gtk_hbox_new (FALSE, 8);
8108 gtk_container_set_border_width (GTK_CONTAINER (hbox), 8);
8109 gtk_container_add (GTK_CONTAINER (window), hbox);
8111 label = gtk_label_new ("Pick a color");
8112 gtk_container_add (GTK_CONTAINER (hbox), label);
8114 picker = gtk_color_button_new ();
8115 gtk_color_button_set_use_alpha (GTK_COLOR_BUTTON (picker), TRUE);
8116 gtk_container_add (GTK_CONTAINER (hbox), picker);
8119 if (!GTK_WIDGET_VISIBLE (window))
8120 gtk_widget_show_all (window);
8122 gtk_widget_destroy (window);
8130 show_fileops (GtkWidget *widget,
8131 GtkFileSelection *fs)
8135 show_ops = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget));
8138 gtk_file_selection_show_fileop_buttons (fs);
8140 gtk_file_selection_hide_fileop_buttons (fs);
8144 select_multiple (GtkWidget *widget,
8145 GtkFileSelection *fs)
8147 gboolean select_multiple;
8149 select_multiple = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget));
8150 gtk_file_selection_set_select_multiple (fs, select_multiple);
8154 file_selection_ok (GtkFileSelection *fs)
8159 selections = gtk_file_selection_get_selections (fs);
8161 for (i = 0; selections[i] != NULL; i++)
8162 g_print ("%s\n", selections[i]);
8164 g_strfreev (selections);
8166 gtk_widget_destroy (GTK_WIDGET (fs));
8170 create_file_selection (GtkWidget *widget)
8172 static GtkWidget *window = NULL;
8177 window = gtk_file_selection_new ("file selection dialog");
8178 gtk_window_set_screen (GTK_WINDOW (window),
8179 gtk_widget_get_screen (widget));
8181 gtk_file_selection_hide_fileop_buttons (GTK_FILE_SELECTION (window));
8183 gtk_window_set_position (GTK_WINDOW (window), GTK_WIN_POS_MOUSE);
8185 g_signal_connect (window, "destroy",
8186 G_CALLBACK (gtk_widget_destroyed),
8189 g_signal_connect_swapped (GTK_FILE_SELECTION (window)->ok_button,
8191 G_CALLBACK (file_selection_ok),
8193 g_signal_connect_swapped (GTK_FILE_SELECTION (window)->cancel_button,
8195 G_CALLBACK (gtk_widget_destroy),
8198 button = gtk_check_button_new_with_label ("Show Fileops");
8199 g_signal_connect (button, "toggled",
8200 G_CALLBACK (show_fileops),
8202 gtk_box_pack_start (GTK_BOX (GTK_FILE_SELECTION (window)->action_area),
8203 button, FALSE, FALSE, 0);
8204 gtk_widget_show (button);
8206 button = gtk_check_button_new_with_label ("Select Multiple");
8207 g_signal_connect (button, "clicked",
8208 G_CALLBACK (select_multiple),
8210 gtk_box_pack_start (GTK_BOX (GTK_FILE_SELECTION (window)->action_area),
8211 button, FALSE, FALSE, 0);
8212 gtk_widget_show (button);
8215 if (!GTK_WIDGET_VISIBLE (window))
8216 gtk_widget_show (window);
8218 gtk_widget_destroy (window);
8222 flipping_toggled_cb (GtkWidget *widget, gpointer data)
8224 int state = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget));
8225 int new_direction = state ? GTK_TEXT_DIR_RTL : GTK_TEXT_DIR_LTR;
8227 gtk_widget_set_default_direction (new_direction);
8231 set_direction_recurse (GtkWidget *widget,
8234 GtkTextDirection *dir = data;
8236 gtk_widget_set_direction (widget, *dir);
8237 if (GTK_IS_CONTAINER (widget))
8238 gtk_container_foreach (GTK_CONTAINER (widget),
8239 set_direction_recurse,
8244 create_forward_back (const char *title,
8245 GtkTextDirection text_dir)
8247 GtkWidget *frame = gtk_frame_new (title);
8248 GtkWidget *bbox = gtk_hbutton_box_new ();
8249 GtkWidget *back_button = gtk_button_new_from_stock (GTK_STOCK_GO_BACK);
8250 GtkWidget *forward_button = gtk_button_new_from_stock (GTK_STOCK_GO_FORWARD);
8252 gtk_container_set_border_width (GTK_CONTAINER (bbox), 5);
8254 gtk_container_add (GTK_CONTAINER (frame), bbox);
8255 gtk_container_add (GTK_CONTAINER (bbox), back_button);
8256 gtk_container_add (GTK_CONTAINER (bbox), forward_button);
8258 set_direction_recurse (frame, &text_dir);
8264 create_flipping (GtkWidget *widget)
8266 static GtkWidget *window = NULL;
8267 GtkWidget *check_button, *button;
8271 window = gtk_dialog_new ();
8273 gtk_window_set_screen (GTK_WINDOW (window),
8274 gtk_widget_get_screen (widget));
8276 g_signal_connect (window, "destroy",
8277 G_CALLBACK (gtk_widget_destroyed),
8280 gtk_window_set_title (GTK_WINDOW (window), "Bidirectional Flipping");
8282 check_button = gtk_check_button_new_with_label ("Right-to-left global direction");
8283 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox),
8284 check_button, TRUE, TRUE, 0);
8286 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox),
8287 create_forward_back ("Default", GTK_TEXT_DIR_NONE),
8290 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox),
8291 create_forward_back ("Left-to-Right", GTK_TEXT_DIR_LTR),
8294 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox),
8295 create_forward_back ("Right-to-Left", GTK_TEXT_DIR_RTL),
8298 if (gtk_widget_get_default_direction () == GTK_TEXT_DIR_RTL)
8299 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check_button), TRUE);
8301 g_signal_connect (check_button, "toggled",
8302 G_CALLBACK (flipping_toggled_cb), NULL);
8304 gtk_container_set_border_width (GTK_CONTAINER (check_button), 10);
8306 button = gtk_button_new_with_label ("Close");
8307 g_signal_connect_swapped (button, "clicked",
8308 G_CALLBACK (gtk_widget_destroy), window);
8309 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
8310 button, TRUE, TRUE, 0);
8313 if (!GTK_WIDGET_VISIBLE (window))
8314 gtk_widget_show_all (window);
8316 gtk_widget_destroy (window);
8324 make_focus_table (GList **list)
8329 table = gtk_table_new (5, 5, FALSE);
8342 widget = gtk_entry_new ();
8344 widget = gtk_button_new_with_label ("Foo");
8346 *list = g_list_prepend (*list, widget);
8348 gtk_table_attach (GTK_TABLE (table),
8352 GTK_EXPAND | GTK_FILL,
8353 GTK_EXPAND | GTK_FILL,
8362 *list = g_list_reverse (*list);
8368 create_focus (GtkWidget *widget)
8370 static GtkWidget *window = NULL;
8378 window = gtk_dialog_new_with_buttons ("Keyboard focus navigation",
8384 gtk_window_set_screen (GTK_WINDOW (window),
8385 gtk_widget_get_screen (widget));
8387 g_signal_connect (window, "destroy",
8388 G_CALLBACK (gtk_widget_destroyed),
8391 g_signal_connect (window, "response",
8392 G_CALLBACK (gtk_widget_destroy),
8395 gtk_window_set_title (GTK_WINDOW (window), "Keyboard Focus Navigation");
8397 frame = gtk_frame_new ("Weird tab focus chain");
8399 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox),
8400 frame, TRUE, TRUE, 0);
8402 table = make_focus_table (&list);
8404 gtk_container_add (GTK_CONTAINER (frame), table);
8406 gtk_container_set_focus_chain (GTK_CONTAINER (table),
8411 frame = gtk_frame_new ("Default tab focus chain");
8413 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox),
8414 frame, TRUE, TRUE, 0);
8417 table = make_focus_table (&list);
8421 gtk_container_add (GTK_CONTAINER (frame), table);
8424 if (!GTK_WIDGET_VISIBLE (window))
8425 gtk_widget_show_all (window);
8427 gtk_widget_destroy (window);
8435 font_selection_ok (GtkWidget *w,
8436 GtkFontSelectionDialog *fs)
8438 gchar *s = gtk_font_selection_dialog_get_font_name (fs);
8440 g_print ("%s\n", s);
8442 gtk_widget_destroy (GTK_WIDGET (fs));
8446 create_font_selection (GtkWidget *widget)
8448 static GtkWidget *window = NULL;
8456 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
8457 gtk_window_set_screen (GTK_WINDOW (window),
8458 gtk_widget_get_screen (widget));
8460 g_signal_connect (window, "destroy",
8461 G_CALLBACK (gtk_widget_destroyed),
8464 gtk_window_set_title (GTK_WINDOW (window), "GtkFontButton");
8465 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
8467 hbox = gtk_hbox_new (FALSE, 8);
8468 gtk_container_set_border_width (GTK_CONTAINER (hbox), 8);
8469 gtk_container_add (GTK_CONTAINER (window), hbox);
8471 label = gtk_label_new ("Pick a font");
8472 gtk_container_add (GTK_CONTAINER (hbox), label);
8474 picker = gtk_font_button_new ();
8475 gtk_font_button_set_use_font (GTK_FONT_BUTTON (picker), TRUE);
8476 gtk_container_add (GTK_CONTAINER (hbox), picker);
8479 if (!GTK_WIDGET_VISIBLE (window))
8480 gtk_widget_show_all (window);
8482 gtk_widget_destroy (window);
8489 static GtkWidget *dialog_window = NULL;
8492 label_toggle (GtkWidget *widget,
8497 *label = gtk_label_new ("Dialog Test");
8498 g_signal_connect (*label,
8500 G_CALLBACK (gtk_widget_destroyed),
8502 gtk_misc_set_padding (GTK_MISC (*label), 10, 10);
8503 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog_window)->vbox),
8504 *label, TRUE, TRUE, 0);
8505 gtk_widget_show (*label);
8508 gtk_widget_destroy (*label);
8511 #define RESPONSE_TOGGLE_SEPARATOR 1
8514 print_response (GtkWidget *dialog,
8518 g_print ("response signal received (%d)\n", response_id);
8520 if (response_id == RESPONSE_TOGGLE_SEPARATOR)
8522 gtk_dialog_set_has_separator (GTK_DIALOG (dialog),
8523 !gtk_dialog_get_has_separator (GTK_DIALOG (dialog)));
8528 create_dialog (GtkWidget *widget)
8530 static GtkWidget *label;
8535 /* This is a terrible example; it's much simpler to create
8536 * dialogs than this. Don't use testgtk for example code,
8540 dialog_window = gtk_dialog_new ();
8541 gtk_window_set_screen (GTK_WINDOW (dialog_window),
8542 gtk_widget_get_screen (widget));
8544 g_signal_connect (dialog_window,
8546 G_CALLBACK (print_response),
8549 g_signal_connect (dialog_window, "destroy",
8550 G_CALLBACK (gtk_widget_destroyed),
8553 gtk_window_set_title (GTK_WINDOW (dialog_window), "GtkDialog");
8554 gtk_container_set_border_width (GTK_CONTAINER (dialog_window), 0);
8556 button = gtk_button_new_with_label ("OK");
8557 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
8558 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog_window)->action_area),
8559 button, TRUE, TRUE, 0);
8560 gtk_widget_grab_default (button);
8561 gtk_widget_show (button);
8563 button = gtk_button_new_with_label ("Toggle");
8564 g_signal_connect (button, "clicked",
8565 G_CALLBACK (label_toggle),
8567 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
8568 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog_window)->action_area),
8569 button, TRUE, TRUE, 0);
8570 gtk_widget_show (button);
8574 button = gtk_button_new_with_label ("Separator");
8576 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
8578 gtk_dialog_add_action_widget (GTK_DIALOG (dialog_window),
8580 RESPONSE_TOGGLE_SEPARATOR);
8581 gtk_widget_show (button);
8584 if (!GTK_WIDGET_VISIBLE (dialog_window))
8585 gtk_widget_show (dialog_window);
8587 gtk_widget_destroy (dialog_window);
8590 /* Display & Screen test
8596 GtkWidget *radio_dpy;
8597 GtkWidget *toplevel;
8598 GtkWidget *dialog_window;
8599 GList *valid_display_list;
8600 } ScreenDisplaySelection;
8603 display_name_cmp (gconstpointer a,
8606 return g_ascii_strcasecmp (a,b);
8610 screen_display_check (GtkWidget *widget, ScreenDisplaySelection *data)
8613 GdkDisplay *display = gtk_widget_get_display (widget);
8615 GdkScreen *new_screen = NULL;
8616 GdkScreen *current_screen = gtk_widget_get_screen (widget);
8618 if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (data->radio_dpy)))
8620 display_name = g_strdup (gtk_entry_get_text (data->entry));
8621 display = gdk_display_open (display_name);
8625 dialog = gtk_message_dialog_new (GTK_WINDOW (gtk_widget_get_toplevel (widget)),
8626 GTK_DIALOG_DESTROY_WITH_PARENT,
8629 "The display :\n%s\ncannot be opened",
8631 gtk_window_set_screen (GTK_WINDOW (dialog), current_screen);
8632 gtk_widget_show (dialog);
8633 g_signal_connect (dialog, "response",
8634 G_CALLBACK (gtk_widget_destroy),
8639 if (!g_list_find_custom (data->valid_display_list,
8642 data->valid_display_list = g_list_append (data->valid_display_list,
8645 new_screen = gdk_display_get_default_screen (display);
8650 gint number_of_screens = gdk_display_get_n_screens (display);
8651 gint screen_num = gdk_screen_get_number (current_screen);
8652 if ((screen_num +1) < number_of_screens)
8653 new_screen = gdk_display_get_screen (display, screen_num + 1);
8655 new_screen = gdk_display_get_screen (display, 0);
8660 gtk_window_set_screen (GTK_WINDOW (data->toplevel), new_screen);
8661 gtk_widget_destroy (data->dialog_window);
8666 screen_display_destroy_diag (GtkWidget *widget, GtkWidget *data)
8668 gtk_widget_destroy (data);
8672 create_display_screen (GtkWidget *widget)
8674 GtkWidget *table, *frame, *window, *combo_dpy, *vbox;
8675 GtkWidget *radio_dpy, *radio_scr, *applyb, *cancelb;
8677 ScreenDisplaySelection *scr_dpy_data;
8678 GdkScreen *screen = gtk_widget_get_screen (widget);
8679 static GList *valid_display_list = NULL;
8681 GdkDisplay *display = gdk_screen_get_display (screen);
8683 window = gtk_widget_new (gtk_window_get_type (),
8686 "type", GTK_WINDOW_TOPLEVEL,
8688 "Screen or Display selection",
8689 "border_width", 10, NULL);
8690 g_signal_connect (window, "destroy",
8691 G_CALLBACK (gtk_widget_destroy), NULL);
8693 vbox = gtk_vbox_new (FALSE, 3);
8694 gtk_container_add (GTK_CONTAINER (window), vbox);
8696 frame = gtk_frame_new ("Select screen or display");
8697 gtk_container_add (GTK_CONTAINER (vbox), frame);
8699 table = gtk_table_new (2, 2, TRUE);
8700 gtk_table_set_row_spacings (GTK_TABLE (table), 3);
8701 gtk_table_set_col_spacings (GTK_TABLE (table), 3);
8703 gtk_container_add (GTK_CONTAINER (frame), table);
8705 radio_dpy = gtk_radio_button_new_with_label (NULL, "move to another X display");
8706 if (gdk_display_get_n_screens(display) > 1)
8707 radio_scr = gtk_radio_button_new_with_label
8708 (gtk_radio_button_get_group (GTK_RADIO_BUTTON (radio_dpy)), "move to next screen");
8711 radio_scr = gtk_radio_button_new_with_label
8712 (gtk_radio_button_get_group (GTK_RADIO_BUTTON (radio_dpy)),
8713 "only one screen on the current display");
8714 gtk_widget_set_sensitive (radio_scr, FALSE);
8716 combo_dpy = gtk_combo_new ();
8717 if (!valid_display_list)
8718 valid_display_list = g_list_append (valid_display_list, "diabolo:0.0");
8720 gtk_combo_set_popdown_strings (GTK_COMBO (combo_dpy), valid_display_list);
8722 gtk_entry_set_text (GTK_ENTRY (GTK_COMBO (combo_dpy)->entry),
8723 "<hostname>:<X Server Num>.<Screen Num>");
8725 gtk_table_attach_defaults (GTK_TABLE (table), radio_dpy, 0, 1, 0, 1);
8726 gtk_table_attach_defaults (GTK_TABLE (table), radio_scr, 0, 1, 1, 2);
8727 gtk_table_attach_defaults (GTK_TABLE (table), combo_dpy, 1, 2, 0, 1);
8729 bbox = gtk_hbutton_box_new ();
8730 applyb = gtk_button_new_from_stock (GTK_STOCK_APPLY);
8731 cancelb = gtk_button_new_from_stock (GTK_STOCK_CANCEL);
8733 gtk_container_add (GTK_CONTAINER (vbox), bbox);
8735 gtk_container_add (GTK_CONTAINER (bbox), applyb);
8736 gtk_container_add (GTK_CONTAINER (bbox), cancelb);
8738 scr_dpy_data = g_new0 (ScreenDisplaySelection, 1);
8740 scr_dpy_data->entry = GTK_ENTRY (GTK_COMBO (combo_dpy)->entry);
8741 scr_dpy_data->radio_dpy = radio_dpy;
8742 scr_dpy_data->toplevel = gtk_widget_get_toplevel (widget);
8743 scr_dpy_data->dialog_window = window;
8744 scr_dpy_data->valid_display_list = valid_display_list;
8746 g_signal_connect (cancelb, "clicked",
8747 G_CALLBACK (screen_display_destroy_diag), window);
8748 g_signal_connect (applyb, "clicked",
8749 G_CALLBACK (screen_display_check), scr_dpy_data);
8750 gtk_widget_show_all (window);
8755 static gboolean event_watcher_enter_id = 0;
8756 static gboolean event_watcher_leave_id = 0;
8759 event_watcher (GSignalInvocationHint *ihint,
8760 guint n_param_values,
8761 const GValue *param_values,
8764 g_print ("Watch: \"%s\" emitted for %s\n",
8765 g_signal_name (ihint->signal_id),
8766 G_OBJECT_TYPE_NAME (g_value_get_object (param_values + 0)));
8772 event_watcher_down (void)
8774 if (event_watcher_enter_id)
8778 signal_id = g_signal_lookup ("enter_notify_event", GTK_TYPE_WIDGET);
8779 g_signal_remove_emission_hook (signal_id, event_watcher_enter_id);
8780 event_watcher_enter_id = 0;
8781 signal_id = g_signal_lookup ("leave_notify_event", GTK_TYPE_WIDGET);
8782 g_signal_remove_emission_hook (signal_id, event_watcher_leave_id);
8783 event_watcher_leave_id = 0;
8788 event_watcher_toggle (void)
8790 if (event_watcher_enter_id)
8791 event_watcher_down ();
8796 signal_id = g_signal_lookup ("enter_notify_event", GTK_TYPE_WIDGET);
8797 event_watcher_enter_id = g_signal_add_emission_hook (signal_id, 0, event_watcher, NULL, NULL);
8798 signal_id = g_signal_lookup ("leave_notify_event", GTK_TYPE_WIDGET);
8799 event_watcher_leave_id = g_signal_add_emission_hook (signal_id, 0, event_watcher, NULL, NULL);
8804 create_event_watcher (GtkWidget *widget)
8810 dialog_window = gtk_dialog_new ();
8811 gtk_window_set_screen (GTK_WINDOW (dialog_window),
8812 gtk_widget_get_screen (widget));
8814 g_signal_connect (dialog_window, "destroy",
8815 G_CALLBACK (gtk_widget_destroyed),
8817 g_signal_connect (dialog_window, "destroy",
8818 G_CALLBACK (event_watcher_down),
8821 gtk_window_set_title (GTK_WINDOW (dialog_window), "Event Watcher");
8822 gtk_container_set_border_width (GTK_CONTAINER (dialog_window), 0);
8823 gtk_widget_set_size_request (dialog_window, 200, 110);
8825 button = gtk_toggle_button_new_with_label ("Activate Watch");
8826 g_signal_connect (button, "clicked",
8827 G_CALLBACK (event_watcher_toggle),
8829 gtk_container_set_border_width (GTK_CONTAINER (button), 10);
8830 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog_window)->vbox),
8831 button, TRUE, TRUE, 0);
8832 gtk_widget_show (button);
8834 button = gtk_button_new_with_label ("Close");
8835 g_signal_connect_swapped (button, "clicked",
8836 G_CALLBACK (gtk_widget_destroy),
8838 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
8839 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog_window)->action_area),
8840 button, TRUE, TRUE, 0);
8841 gtk_widget_grab_default (button);
8842 gtk_widget_show (button);
8845 if (!GTK_WIDGET_VISIBLE (dialog_window))
8846 gtk_widget_show (dialog_window);
8848 gtk_widget_destroy (dialog_window);
8856 reformat_value (GtkScale *scale,
8859 return g_strdup_printf ("-->%0.*g<--",
8860 gtk_scale_get_digits (scale), value);
8864 create_range_controls (GtkWidget *widget)
8866 static GtkWidget *window = NULL;
8870 GtkWidget *scrollbar;
8872 GtkWidget *separator;
8873 GtkObject *adjustment;
8878 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
8880 gtk_window_set_screen (GTK_WINDOW (window),
8881 gtk_widget_get_screen (widget));
8883 g_signal_connect (window, "destroy",
8884 G_CALLBACK (gtk_widget_destroyed),
8887 gtk_window_set_title (GTK_WINDOW (window), "range controls");
8888 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
8891 box1 = gtk_vbox_new (FALSE, 0);
8892 gtk_container_add (GTK_CONTAINER (window), box1);
8893 gtk_widget_show (box1);
8896 box2 = gtk_vbox_new (FALSE, 10);
8897 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
8898 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
8899 gtk_widget_show (box2);
8902 adjustment = gtk_adjustment_new (0.0, 0.0, 101.0, 0.1, 1.0, 1.0);
8904 scale = gtk_hscale_new (GTK_ADJUSTMENT (adjustment));
8905 gtk_widget_set_size_request (GTK_WIDGET (scale), 150, -1);
8906 gtk_range_set_update_policy (GTK_RANGE (scale), GTK_UPDATE_DELAYED);
8907 gtk_scale_set_digits (GTK_SCALE (scale), 1);
8908 gtk_scale_set_draw_value (GTK_SCALE (scale), TRUE);
8909 gtk_box_pack_start (GTK_BOX (box2), scale, TRUE, TRUE, 0);
8910 gtk_widget_show (scale);
8912 scrollbar = gtk_hscrollbar_new (GTK_ADJUSTMENT (adjustment));
8913 gtk_range_set_update_policy (GTK_RANGE (scrollbar),
8914 GTK_UPDATE_CONTINUOUS);
8915 gtk_box_pack_start (GTK_BOX (box2), scrollbar, TRUE, TRUE, 0);
8916 gtk_widget_show (scrollbar);
8918 scale = gtk_hscale_new (GTK_ADJUSTMENT (adjustment));
8919 gtk_scale_set_draw_value (GTK_SCALE (scale), TRUE);
8920 g_signal_connect (scale,
8922 G_CALLBACK (reformat_value),
8924 gtk_box_pack_start (GTK_BOX (box2), scale, TRUE, TRUE, 0);
8925 gtk_widget_show (scale);
8927 hbox = gtk_hbox_new (FALSE, 0);
8929 scale = gtk_vscale_new (GTK_ADJUSTMENT (adjustment));
8930 gtk_widget_set_size_request (scale, -1, 200);
8931 gtk_scale_set_digits (GTK_SCALE (scale), 2);
8932 gtk_scale_set_draw_value (GTK_SCALE (scale), TRUE);
8933 gtk_box_pack_start (GTK_BOX (hbox), scale, TRUE, TRUE, 0);
8934 gtk_widget_show (scale);
8936 scale = gtk_vscale_new (GTK_ADJUSTMENT (adjustment));
8937 gtk_widget_set_size_request (scale, -1, 200);
8938 gtk_scale_set_digits (GTK_SCALE (scale), 2);
8939 gtk_scale_set_draw_value (GTK_SCALE (scale), TRUE);
8940 gtk_range_set_inverted (GTK_RANGE (scale), TRUE);
8941 gtk_box_pack_start (GTK_BOX (hbox), scale, TRUE, TRUE, 0);
8942 gtk_widget_show (scale);
8944 scale = gtk_vscale_new (GTK_ADJUSTMENT (adjustment));
8945 gtk_scale_set_draw_value (GTK_SCALE (scale), TRUE);
8946 g_signal_connect (scale,
8948 G_CALLBACK (reformat_value),
8950 gtk_box_pack_start (GTK_BOX (hbox), scale, TRUE, TRUE, 0);
8951 gtk_widget_show (scale);
8954 gtk_box_pack_start (GTK_BOX (box2), hbox, TRUE, TRUE, 0);
8955 gtk_widget_show (hbox);
8957 separator = gtk_hseparator_new ();
8958 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
8959 gtk_widget_show (separator);
8962 box2 = gtk_vbox_new (FALSE, 10);
8963 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
8964 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
8965 gtk_widget_show (box2);
8968 button = gtk_button_new_with_label ("close");
8969 g_signal_connect_swapped (button, "clicked",
8970 G_CALLBACK (gtk_widget_destroy),
8972 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
8973 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
8974 gtk_widget_grab_default (button);
8975 gtk_widget_show (button);
8978 if (!GTK_WIDGET_VISIBLE (window))
8979 gtk_widget_show (window);
8981 gtk_widget_destroy (window);
8989 create_rulers (GtkWidget *widget)
8991 static GtkWidget *window = NULL;
8997 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
8999 gtk_window_set_screen (GTK_WINDOW (window),
9000 gtk_widget_get_screen (widget));
9002 g_object_set (window, "allow_shrink", TRUE, "allow_grow", TRUE, NULL);
9004 g_signal_connect (window, "destroy",
9005 G_CALLBACK (gtk_widget_destroyed),
9008 gtk_window_set_title (GTK_WINDOW (window), "rulers");
9009 gtk_widget_set_size_request (window, 300, 300);
9010 gtk_widget_set_events (window,
9011 GDK_POINTER_MOTION_MASK
9012 | GDK_POINTER_MOTION_HINT_MASK);
9013 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
9015 table = gtk_table_new (2, 2, FALSE);
9016 gtk_container_add (GTK_CONTAINER (window), table);
9017 gtk_widget_show (table);
9019 ruler = gtk_hruler_new ();
9020 gtk_ruler_set_metric (GTK_RULER (ruler), GTK_CENTIMETERS);
9021 gtk_ruler_set_range (GTK_RULER (ruler), 100, 0, 0, 20);
9023 g_signal_connect_swapped (window,
9024 "motion_notify_event",
9025 G_CALLBACK (GTK_WIDGET_GET_CLASS (ruler)->motion_notify_event),
9028 gtk_table_attach (GTK_TABLE (table), ruler, 1, 2, 0, 1,
9029 GTK_EXPAND | GTK_FILL, GTK_FILL, 0, 0);
9030 gtk_widget_show (ruler);
9033 ruler = gtk_vruler_new ();
9034 gtk_ruler_set_range (GTK_RULER (ruler), 5, 15, 0, 20);
9036 g_signal_connect_swapped (window,
9037 "motion_notify_event",
9038 G_CALLBACK (GTK_WIDGET_GET_CLASS (ruler)->motion_notify_event),
9041 gtk_table_attach (GTK_TABLE (table), ruler, 0, 1, 1, 2,
9042 GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
9043 gtk_widget_show (ruler);
9046 if (!GTK_WIDGET_VISIBLE (window))
9047 gtk_widget_show (window);
9049 gtk_widget_destroy (window);
9053 text_toggle_editable (GtkWidget *checkbutton,
9056 gtk_text_set_editable(GTK_TEXT(text),
9057 GTK_TOGGLE_BUTTON(checkbutton)->active);
9061 text_toggle_word_wrap (GtkWidget *checkbutton,
9064 gtk_text_set_word_wrap(GTK_TEXT(text),
9065 GTK_TOGGLE_BUTTON(checkbutton)->active);
9072 { { 0, 0x0000, 0x0000, 0x0000 }, "black" },
9073 { { 0, 0xFFFF, 0xFFFF, 0xFFFF }, "white" },
9074 { { 0, 0xFFFF, 0x0000, 0x0000 }, "red" },
9075 { { 0, 0x0000, 0xFFFF, 0x0000 }, "green" },
9076 { { 0, 0x0000, 0x0000, 0xFFFF }, "blue" },
9077 { { 0, 0x0000, 0xFFFF, 0xFFFF }, "cyan" },
9078 { { 0, 0xFFFF, 0x0000, 0xFFFF }, "magenta" },
9079 { { 0, 0xFFFF, 0xFFFF, 0x0000 }, "yellow" }
9082 int ntext_colors = sizeof(text_colors) / sizeof(text_colors[0]);
9088 text_insert_random (GtkWidget *w, GtkText *text)
9092 for (i=0; i<10; i++)
9094 c = 'A' + rand() % ('Z' - 'A');
9095 gtk_text_set_point (text, rand() % gtk_text_get_length (text));
9096 gtk_text_insert (text, NULL, NULL, NULL, &c, 1);
9101 create_text (GtkWidget *widget)
9105 static GtkWidget *window = NULL;
9111 GtkWidget *separator;
9112 GtkWidget *scrolled_window;
9119 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
9120 gtk_window_set_screen (GTK_WINDOW (window),
9121 gtk_widget_get_screen (widget));
9123 gtk_widget_set_name (window, "text window");
9124 g_object_set (window, "allow_shrink", TRUE, "allow_grow", TRUE, NULL);
9125 gtk_widget_set_size_request (window, 500, 500);
9127 g_signal_connect (window, "destroy",
9128 G_CALLBACK (gtk_widget_destroyed),
9131 gtk_window_set_title (GTK_WINDOW (window), "test");
9132 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
9135 box1 = gtk_vbox_new (FALSE, 0);
9136 gtk_container_add (GTK_CONTAINER (window), box1);
9137 gtk_widget_show (box1);
9140 box2 = gtk_vbox_new (FALSE, 10);
9141 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
9142 gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
9143 gtk_widget_show (box2);
9146 scrolled_window = gtk_scrolled_window_new (NULL, NULL);
9147 gtk_box_pack_start (GTK_BOX (box2), scrolled_window, TRUE, TRUE, 0);
9148 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
9151 gtk_widget_show (scrolled_window);
9153 text = gtk_text_new (NULL, NULL);
9154 gtk_text_set_editable (GTK_TEXT (text), TRUE);
9155 gtk_container_add (GTK_CONTAINER (scrolled_window), text);
9156 gtk_widget_grab_focus (text);
9157 gtk_widget_show (text);
9160 gtk_text_freeze (GTK_TEXT (text));
9162 for (i=0; i<ntext_colors; i++)
9164 gtk_text_insert (GTK_TEXT (text), NULL, NULL, NULL,
9165 text_colors[i].name, -1);
9166 gtk_text_insert (GTK_TEXT (text), NULL, NULL, NULL, "\t", -1);
9168 for (j=0; j<ntext_colors; j++)
9170 gtk_text_insert (GTK_TEXT (text), NULL,
9171 &text_colors[j].color, &text_colors[i].color,
9174 gtk_text_insert (GTK_TEXT (text), NULL, NULL, NULL, "\n", -1);
9177 infile = fopen("testgtk.c", "r");
9182 int nbytes_read, nbytes_alloc;
9185 nbytes_alloc = 1024;
9186 buffer = g_new (char, nbytes_alloc);
9190 if (nbytes_alloc < nbytes_read + 1024)
9193 buffer = g_realloc (buffer, nbytes_alloc);
9195 len = fread (buffer + nbytes_read, 1, 1024, infile);
9201 gtk_text_insert (GTK_TEXT (text), NULL, NULL,
9202 NULL, buffer, nbytes_read);
9207 gtk_text_thaw (GTK_TEXT (text));
9209 hbox = gtk_hbutton_box_new ();
9210 gtk_box_pack_start (GTK_BOX (box2), hbox, FALSE, FALSE, 0);
9211 gtk_widget_show (hbox);
9213 check = gtk_check_button_new_with_label("Editable");
9214 gtk_box_pack_start (GTK_BOX (hbox), check, FALSE, FALSE, 0);
9215 g_signal_connect (check, "toggled",
9216 G_CALLBACK (text_toggle_editable), text);
9217 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check), TRUE);
9218 gtk_widget_show (check);
9220 check = gtk_check_button_new_with_label("Wrap Words");
9221 gtk_box_pack_start (GTK_BOX (hbox), check, FALSE, TRUE, 0);
9222 g_signal_connect (check, "toggled",
9223 G_CALLBACK (text_toggle_word_wrap), text);
9224 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check), FALSE);
9225 gtk_widget_show (check);
9227 separator = gtk_hseparator_new ();
9228 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
9229 gtk_widget_show (separator);
9232 box2 = gtk_vbox_new (FALSE, 10);
9233 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
9234 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
9235 gtk_widget_show (box2);
9238 button = gtk_button_new_with_label ("insert random");
9239 g_signal_connect (button, "clicked",
9240 G_CALLBACK (text_insert_random),
9242 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
9243 gtk_widget_show (button);
9245 button = gtk_button_new_with_label ("close");
9246 g_signal_connect_swapped (button, "clicked",
9247 G_CALLBACK (gtk_widget_destroy),
9249 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
9250 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
9251 gtk_widget_grab_default (button);
9252 gtk_widget_show (button);
9255 if (!GTK_WIDGET_VISIBLE (window))
9256 gtk_widget_show (window);
9258 gtk_widget_destroy (window);
9265 GdkPixbuf *book_open;
9266 GdkPixbuf *book_closed;
9267 GtkWidget *sample_notebook;
9270 set_page_image (GtkNotebook *notebook, gint page_num, GdkPixbuf *pixbuf)
9272 GtkWidget *page_widget;
9275 page_widget = gtk_notebook_get_nth_page (notebook, page_num);
9277 pixwid = g_object_get_data (G_OBJECT (page_widget), "tab_pixmap");
9278 gtk_image_set_from_pixbuf (GTK_IMAGE (pixwid), pixbuf);
9280 pixwid = g_object_get_data (G_OBJECT (page_widget), "menu_pixmap");
9281 gtk_image_set_from_pixbuf (GTK_IMAGE (pixwid), pixbuf);
9285 page_switch (GtkWidget *widget, GtkNotebookPage *page, gint page_num)
9287 GtkNotebook *notebook = GTK_NOTEBOOK (widget);
9288 gint old_page_num = gtk_notebook_get_current_page (notebook);
9290 if (page_num == old_page_num)
9293 set_page_image (notebook, page_num, book_open);
9295 if (old_page_num != -1)
9296 set_page_image (notebook, old_page_num, book_closed);
9300 tab_fill (GtkToggleButton *button, GtkWidget *child)
9303 GtkPackType pack_type;
9305 gtk_notebook_query_tab_label_packing (GTK_NOTEBOOK (sample_notebook), child,
9306 &expand, NULL, &pack_type);
9307 gtk_notebook_set_tab_label_packing (GTK_NOTEBOOK (sample_notebook), child,
9308 expand, button->active, pack_type);
9312 tab_expand (GtkToggleButton *button, GtkWidget *child)
9315 GtkPackType pack_type;
9317 gtk_notebook_query_tab_label_packing (GTK_NOTEBOOK (sample_notebook), child,
9318 NULL, &fill, &pack_type);
9319 gtk_notebook_set_tab_label_packing (GTK_NOTEBOOK (sample_notebook), child,
9320 button->active, fill, pack_type);
9324 tab_pack (GtkToggleButton *button, GtkWidget *child)
9330 gtk_notebook_query_tab_label_packing (GTK_NOTEBOOK (sample_notebook), child,
9331 &expand, &fill, NULL);
9332 gtk_notebook_set_tab_label_packing (GTK_NOTEBOOK (sample_notebook), child,
9333 expand, fill, button->active);
9337 create_pages (GtkNotebook *notebook, gint start, gint end)
9339 GtkWidget *child = NULL;
9344 GtkWidget *label_box;
9345 GtkWidget *menu_box;
9349 char accel_buffer[32];
9351 for (i = start; i <= end; i++)
9353 sprintf (buffer, "Page %d", i);
9354 sprintf (accel_buffer, "Page _%d", i);
9356 child = gtk_frame_new (buffer);
9357 gtk_container_set_border_width (GTK_CONTAINER (child), 10);
9359 vbox = gtk_vbox_new (TRUE,0);
9360 gtk_container_set_border_width (GTK_CONTAINER (vbox), 10);
9361 gtk_container_add (GTK_CONTAINER (child), vbox);
9363 hbox = gtk_hbox_new (TRUE,0);
9364 gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 5);
9366 button = gtk_check_button_new_with_label ("Fill Tab");
9367 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
9368 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
9369 g_signal_connect (button, "toggled",
9370 G_CALLBACK (tab_fill), child);
9372 button = gtk_check_button_new_with_label ("Expand Tab");
9373 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
9374 g_signal_connect (button, "toggled",
9375 G_CALLBACK (tab_expand), child);
9377 button = gtk_check_button_new_with_label ("Pack end");
9378 gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
9379 g_signal_connect (button, "toggled",
9380 G_CALLBACK (tab_pack), child);
9382 button = gtk_button_new_with_label ("Hide Page");
9383 gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 5);
9384 g_signal_connect_swapped (button, "clicked",
9385 G_CALLBACK (gtk_widget_hide),
9388 gtk_widget_show_all (child);
9390 label_box = gtk_hbox_new (FALSE, 0);
9391 pixwid = gtk_image_new_from_pixbuf (book_closed);
9392 g_object_set_data (G_OBJECT (child), "tab_pixmap", pixwid);
9394 gtk_box_pack_start (GTK_BOX (label_box), pixwid, FALSE, TRUE, 0);
9395 gtk_misc_set_padding (GTK_MISC (pixwid), 3, 1);
9396 label = gtk_label_new_with_mnemonic (accel_buffer);
9397 gtk_box_pack_start (GTK_BOX (label_box), label, FALSE, TRUE, 0);
9398 gtk_widget_show_all (label_box);
9401 menu_box = gtk_hbox_new (FALSE, 0);
9402 pixwid = gtk_image_new_from_pixbuf (book_closed);
9403 g_object_set_data (G_OBJECT (child), "menu_pixmap", pixwid);
9405 gtk_box_pack_start (GTK_BOX (menu_box), pixwid, FALSE, TRUE, 0);
9406 gtk_misc_set_padding (GTK_MISC (pixwid), 3, 1);
9407 label = gtk_label_new (buffer);
9408 gtk_box_pack_start (GTK_BOX (menu_box), label, FALSE, TRUE, 0);
9409 gtk_widget_show_all (menu_box);
9411 gtk_notebook_append_page_menu (notebook, child, label_box, menu_box);
9416 rotate_notebook (GtkButton *button,
9417 GtkNotebook *notebook)
9419 gtk_notebook_set_tab_pos (notebook, (notebook->tab_pos + 1) % 4);
9423 show_all_pages (GtkButton *button,
9424 GtkNotebook *notebook)
9426 gtk_container_foreach (GTK_CONTAINER (notebook),
9427 (GtkCallback) gtk_widget_show, NULL);
9431 notebook_type_changed (GtkWidget *optionmenu,
9434 GtkNotebook *notebook;
9444 notebook = GTK_NOTEBOOK (data);
9446 c = gtk_option_menu_get_history (GTK_OPTION_MENU (optionmenu));
9451 /* standard notebook */
9452 gtk_notebook_set_show_tabs (notebook, TRUE);
9453 gtk_notebook_set_show_border (notebook, TRUE);
9454 gtk_notebook_set_scrollable (notebook, FALSE);
9458 /* notabs notebook */
9459 gtk_notebook_set_show_tabs (notebook, FALSE);
9460 gtk_notebook_set_show_border (notebook, TRUE);
9465 gtk_notebook_set_show_tabs (notebook, FALSE);
9466 gtk_notebook_set_show_border (notebook, FALSE);
9471 gtk_notebook_set_show_tabs (notebook, TRUE);
9472 gtk_notebook_set_show_border (notebook, TRUE);
9473 gtk_notebook_set_scrollable (notebook, TRUE);
9474 if (g_list_length (notebook->children) == 5)
9475 create_pages (notebook, 6, 15);
9481 if (g_list_length (notebook->children) == 15)
9482 for (i = 0; i < 10; i++)
9483 gtk_notebook_remove_page (notebook, 5);
9487 notebook_popup (GtkToggleButton *button,
9488 GtkNotebook *notebook)
9491 gtk_notebook_popup_enable (notebook);
9493 gtk_notebook_popup_disable (notebook);
9497 notebook_homogeneous (GtkToggleButton *button,
9498 GtkNotebook *notebook)
9500 g_object_set (notebook, "homogeneous", button->active, NULL);
9504 create_notebook (GtkWidget *widget)
9506 static GtkWidget *window = NULL;
9510 GtkWidget *separator;
9514 static gchar *items[] =
9524 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
9525 gtk_window_set_screen (GTK_WINDOW (window),
9526 gtk_widget_get_screen (widget));
9528 g_signal_connect (window, "destroy",
9529 G_CALLBACK (gtk_widget_destroyed),
9532 gtk_window_set_title (GTK_WINDOW (window), "notebook");
9533 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
9535 box1 = gtk_vbox_new (FALSE, 0);
9536 gtk_container_add (GTK_CONTAINER (window), box1);
9538 sample_notebook = gtk_notebook_new ();
9539 g_signal_connect (sample_notebook, "switch_page",
9540 G_CALLBACK (page_switch), NULL);
9541 gtk_notebook_set_tab_pos (GTK_NOTEBOOK (sample_notebook), GTK_POS_TOP);
9542 gtk_box_pack_start (GTK_BOX (box1), sample_notebook, TRUE, TRUE, 0);
9543 gtk_container_set_border_width (GTK_CONTAINER (sample_notebook), 10);
9545 gtk_widget_realize (sample_notebook);
9548 book_open = gdk_pixbuf_new_from_xpm_data ((const char **)book_open_xpm);
9551 book_closed = gdk_pixbuf_new_from_xpm_data ((const char **)book_closed_xpm);
9553 create_pages (GTK_NOTEBOOK (sample_notebook), 1, 5);
9555 separator = gtk_hseparator_new ();
9556 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 10);
9558 box2 = gtk_hbox_new (FALSE, 5);
9559 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
9560 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
9562 button = gtk_check_button_new_with_label ("popup menu");
9563 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, FALSE, 0);
9564 g_signal_connect (button, "clicked",
9565 G_CALLBACK (notebook_popup),
9568 button = gtk_check_button_new_with_label ("homogeneous tabs");
9569 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, FALSE, 0);
9570 g_signal_connect (button, "clicked",
9571 G_CALLBACK (notebook_homogeneous),
9574 box2 = gtk_hbox_new (FALSE, 5);
9575 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
9576 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
9578 label = gtk_label_new ("Notebook Style :");
9579 gtk_box_pack_start (GTK_BOX (box2), label, FALSE, TRUE, 0);
9581 omenu = build_option_menu (items, G_N_ELEMENTS (items), 0,
9582 notebook_type_changed,
9584 gtk_box_pack_start (GTK_BOX (box2), omenu, FALSE, TRUE, 0);
9586 button = gtk_button_new_with_label ("Show all Pages");
9587 gtk_box_pack_start (GTK_BOX (box2), button, FALSE, TRUE, 0);
9588 g_signal_connect (button, "clicked",
9589 G_CALLBACK (show_all_pages), sample_notebook);
9591 box2 = gtk_hbox_new (TRUE, 10);
9592 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
9593 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
9595 button = gtk_button_new_with_label ("prev");
9596 g_signal_connect_swapped (button, "clicked",
9597 G_CALLBACK (gtk_notebook_prev_page),
9599 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
9601 button = gtk_button_new_with_label ("next");
9602 g_signal_connect_swapped (button, "clicked",
9603 G_CALLBACK (gtk_notebook_next_page),
9605 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
9607 button = gtk_button_new_with_label ("rotate");
9608 g_signal_connect (button, "clicked",
9609 G_CALLBACK (rotate_notebook), sample_notebook);
9610 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
9612 separator = gtk_hseparator_new ();
9613 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 5);
9615 button = gtk_button_new_with_label ("close");
9616 gtk_container_set_border_width (GTK_CONTAINER (button), 5);
9617 g_signal_connect_swapped (button, "clicked",
9618 G_CALLBACK (gtk_widget_destroy),
9620 gtk_box_pack_start (GTK_BOX (box1), button, FALSE, FALSE, 0);
9621 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
9622 gtk_widget_grab_default (button);
9625 if (!GTK_WIDGET_VISIBLE (window))
9626 gtk_widget_show_all (window);
9628 gtk_widget_destroy (window);
9636 toggle_resize (GtkWidget *widget, GtkWidget *child)
9638 GtkContainer *container = GTK_CONTAINER (gtk_widget_get_parent (child));
9639 GValue value = { 0, };
9640 g_value_init (&value, G_TYPE_BOOLEAN);
9641 gtk_container_child_get_property (container, child, "resize", &value);
9642 g_value_set_boolean (&value, !g_value_get_boolean (&value));
9643 gtk_container_child_set_property (container, child, "resize", &value);
9647 toggle_shrink (GtkWidget *widget, GtkWidget *child)
9649 GtkContainer *container = GTK_CONTAINER (gtk_widget_get_parent (child));
9650 GValue value = { 0, };
9651 g_value_init (&value, G_TYPE_BOOLEAN);
9652 gtk_container_child_get_property (container, child, "shrink", &value);
9653 g_value_set_boolean (&value, !g_value_get_boolean (&value));
9654 gtk_container_child_set_property (container, child, "shrink", &value);
9658 paned_props_clicked (GtkWidget *button,
9661 GtkWidget *window = create_prop_editor (paned, GTK_TYPE_PANED);
9663 gtk_window_set_title (GTK_WINDOW (window), "Paned Properties");
9667 create_pane_options (GtkPaned *paned,
9668 const gchar *frame_label,
9669 const gchar *label1,
9670 const gchar *label2)
9676 GtkWidget *check_button;
9678 frame = gtk_frame_new (frame_label);
9679 gtk_container_set_border_width (GTK_CONTAINER (frame), 4);
9681 table = gtk_table_new (4, 2, 4);
9682 gtk_container_add (GTK_CONTAINER (frame), table);
9684 label = gtk_label_new (label1);
9685 gtk_table_attach_defaults (GTK_TABLE (table), label,
9688 check_button = gtk_check_button_new_with_label ("Resize");
9689 gtk_table_attach_defaults (GTK_TABLE (table), check_button,
9691 g_signal_connect (check_button, "toggled",
9692 G_CALLBACK (toggle_resize),
9695 check_button = gtk_check_button_new_with_label ("Shrink");
9696 gtk_table_attach_defaults (GTK_TABLE (table), check_button,
9698 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check_button),
9700 g_signal_connect (check_button, "toggled",
9701 G_CALLBACK (toggle_shrink),
9704 label = gtk_label_new (label2);
9705 gtk_table_attach_defaults (GTK_TABLE (table), label,
9708 check_button = gtk_check_button_new_with_label ("Resize");
9709 gtk_table_attach_defaults (GTK_TABLE (table), check_button,
9711 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check_button),
9713 g_signal_connect (check_button, "toggled",
9714 G_CALLBACK (toggle_resize),
9717 check_button = gtk_check_button_new_with_label ("Shrink");
9718 gtk_table_attach_defaults (GTK_TABLE (table), check_button,
9720 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check_button),
9722 g_signal_connect (check_button, "toggled",
9723 G_CALLBACK (toggle_shrink),
9726 button = gtk_button_new_with_mnemonic ("_Properties");
9727 gtk_table_attach_defaults (GTK_TABLE (table), button,
9729 g_signal_connect (button, "clicked",
9730 G_CALLBACK (paned_props_clicked),
9737 create_panes (GtkWidget *widget)
9739 static GtkWidget *window = NULL;
9748 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
9750 gtk_window_set_screen (GTK_WINDOW (window),
9751 gtk_widget_get_screen (widget));
9753 g_signal_connect (window, "destroy",
9754 G_CALLBACK (gtk_widget_destroyed),
9757 gtk_window_set_title (GTK_WINDOW (window), "Panes");
9758 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
9760 vbox = gtk_vbox_new (FALSE, 0);
9761 gtk_container_add (GTK_CONTAINER (window), vbox);
9763 vpaned = gtk_vpaned_new ();
9764 gtk_box_pack_start (GTK_BOX (vbox), vpaned, TRUE, TRUE, 0);
9765 gtk_container_set_border_width (GTK_CONTAINER(vpaned), 5);
9767 hpaned = gtk_hpaned_new ();
9768 gtk_paned_add1 (GTK_PANED (vpaned), hpaned);
9770 frame = gtk_frame_new (NULL);
9771 gtk_frame_set_shadow_type (GTK_FRAME(frame), GTK_SHADOW_IN);
9772 gtk_widget_set_size_request (frame, 60, 60);
9773 gtk_paned_add1 (GTK_PANED (hpaned), frame);
9775 button = gtk_button_new_with_label ("Hi there");
9776 gtk_container_add (GTK_CONTAINER(frame), button);
9778 frame = gtk_frame_new (NULL);
9779 gtk_frame_set_shadow_type (GTK_FRAME(frame), GTK_SHADOW_IN);
9780 gtk_widget_set_size_request (frame, 80, 60);
9781 gtk_paned_add2 (GTK_PANED (hpaned), frame);
9783 frame = gtk_frame_new (NULL);
9784 gtk_frame_set_shadow_type (GTK_FRAME(frame), GTK_SHADOW_IN);
9785 gtk_widget_set_size_request (frame, 60, 80);
9786 gtk_paned_add2 (GTK_PANED (vpaned), frame);
9788 /* Now create toggle buttons to control sizing */
9790 gtk_box_pack_start (GTK_BOX (vbox),
9791 create_pane_options (GTK_PANED (hpaned),
9797 gtk_box_pack_start (GTK_BOX (vbox),
9798 create_pane_options (GTK_PANED (vpaned),
9804 gtk_widget_show_all (vbox);
9807 if (!GTK_WIDGET_VISIBLE (window))
9808 gtk_widget_show (window);
9810 gtk_widget_destroy (window);
9814 * Paned keyboard navigation
9818 paned_keyboard_window1 (GtkWidget *widget)
9841 window1 = gtk_window_new (GTK_WINDOW_TOPLEVEL);
9842 gtk_window_set_title (GTK_WINDOW (window1), "Basic paned navigation");
9843 gtk_window_set_screen (GTK_WINDOW (window1),
9844 gtk_widget_get_screen (widget));
9846 hpaned1 = gtk_hpaned_new ();
9847 gtk_container_add (GTK_CONTAINER (window1), hpaned1);
9849 frame1 = gtk_frame_new (NULL);
9850 gtk_paned_pack1 (GTK_PANED (hpaned1), frame1, FALSE, TRUE);
9851 gtk_frame_set_shadow_type (GTK_FRAME (frame1), GTK_SHADOW_IN);
9853 vbox1 = gtk_vbox_new (FALSE, 0);
9854 gtk_container_add (GTK_CONTAINER (frame1), vbox1);
9856 button7 = gtk_button_new_with_label ("button7");
9857 gtk_box_pack_start (GTK_BOX (vbox1), button7, FALSE, FALSE, 0);
9859 button8 = gtk_button_new_with_label ("button8");
9860 gtk_box_pack_start (GTK_BOX (vbox1), button8, FALSE, FALSE, 0);
9862 button9 = gtk_button_new_with_label ("button9");
9863 gtk_box_pack_start (GTK_BOX (vbox1), button9, FALSE, FALSE, 0);
9865 vpaned1 = gtk_vpaned_new ();
9866 gtk_paned_pack2 (GTK_PANED (hpaned1), vpaned1, TRUE, TRUE);
9868 frame2 = gtk_frame_new (NULL);
9869 gtk_paned_pack1 (GTK_PANED (vpaned1), frame2, FALSE, TRUE);
9870 gtk_frame_set_shadow_type (GTK_FRAME (frame2), GTK_SHADOW_IN);
9872 frame5 = gtk_frame_new (NULL);
9873 gtk_container_add (GTK_CONTAINER (frame2), frame5);
9875 hbox1 = gtk_hbox_new (FALSE, 0);
9876 gtk_container_add (GTK_CONTAINER (frame5), hbox1);
9878 button5 = gtk_button_new_with_label ("button5");
9879 gtk_box_pack_start (GTK_BOX (hbox1), button5, FALSE, FALSE, 0);
9881 button6 = gtk_button_new_with_label ("button6");
9882 gtk_box_pack_start (GTK_BOX (hbox1), button6, FALSE, FALSE, 0);
9884 frame3 = gtk_frame_new (NULL);
9885 gtk_paned_pack2 (GTK_PANED (vpaned1), frame3, TRUE, TRUE);
9886 gtk_frame_set_shadow_type (GTK_FRAME (frame3), GTK_SHADOW_IN);
9888 frame4 = gtk_frame_new ("Buttons");
9889 gtk_container_add (GTK_CONTAINER (frame3), frame4);
9890 gtk_container_set_border_width (GTK_CONTAINER (frame4), 15);
9892 table1 = gtk_table_new (2, 2, FALSE);
9893 gtk_container_add (GTK_CONTAINER (frame4), table1);
9894 gtk_container_set_border_width (GTK_CONTAINER (table1), 11);
9896 button1 = gtk_button_new_with_label ("button1");
9897 gtk_table_attach (GTK_TABLE (table1), button1, 0, 1, 0, 1,
9898 (GtkAttachOptions) (GTK_FILL),
9899 (GtkAttachOptions) (0), 0, 0);
9901 button2 = gtk_button_new_with_label ("button2");
9902 gtk_table_attach (GTK_TABLE (table1), button2, 1, 2, 0, 1,
9903 (GtkAttachOptions) (GTK_FILL),
9904 (GtkAttachOptions) (0), 0, 0);
9906 button3 = gtk_button_new_with_label ("button3");
9907 gtk_table_attach (GTK_TABLE (table1), button3, 0, 1, 1, 2,
9908 (GtkAttachOptions) (GTK_FILL),
9909 (GtkAttachOptions) (0), 0, 0);
9911 button4 = gtk_button_new_with_label ("button4");
9912 gtk_table_attach (GTK_TABLE (table1), button4, 1, 2, 1, 2,
9913 (GtkAttachOptions) (GTK_FILL),
9914 (GtkAttachOptions) (0), 0, 0);
9920 paned_keyboard_window2 (GtkWidget *widget)
9925 GtkWidget *button13;
9929 GtkWidget *button12;
9931 GtkWidget *button11;
9932 GtkWidget *button10;
9934 window2 = gtk_window_new (GTK_WINDOW_TOPLEVEL);
9935 gtk_window_set_title (GTK_WINDOW (window2), "\"button 10\" is not inside the horisontal pane");
9937 gtk_window_set_screen (GTK_WINDOW (window2),
9938 gtk_widget_get_screen (widget));
9940 hpaned2 = gtk_hpaned_new ();
9941 gtk_container_add (GTK_CONTAINER (window2), hpaned2);
9943 frame6 = gtk_frame_new (NULL);
9944 gtk_paned_pack1 (GTK_PANED (hpaned2), frame6, FALSE, TRUE);
9945 gtk_frame_set_shadow_type (GTK_FRAME (frame6), GTK_SHADOW_IN);
9947 button13 = gtk_button_new_with_label ("button13");
9948 gtk_container_add (GTK_CONTAINER (frame6), button13);
9950 hbox2 = gtk_hbox_new (FALSE, 0);
9951 gtk_paned_pack2 (GTK_PANED (hpaned2), hbox2, TRUE, TRUE);
9953 vpaned2 = gtk_vpaned_new ();
9954 gtk_box_pack_start (GTK_BOX (hbox2), vpaned2, TRUE, TRUE, 0);
9956 frame7 = gtk_frame_new (NULL);
9957 gtk_paned_pack1 (GTK_PANED (vpaned2), frame7, FALSE, TRUE);
9958 gtk_frame_set_shadow_type (GTK_FRAME (frame7), GTK_SHADOW_IN);
9960 button12 = gtk_button_new_with_label ("button12");
9961 gtk_container_add (GTK_CONTAINER (frame7), button12);
9963 frame8 = gtk_frame_new (NULL);
9964 gtk_paned_pack2 (GTK_PANED (vpaned2), frame8, TRUE, TRUE);
9965 gtk_frame_set_shadow_type (GTK_FRAME (frame8), GTK_SHADOW_IN);
9967 button11 = gtk_button_new_with_label ("button11");
9968 gtk_container_add (GTK_CONTAINER (frame8), button11);
9970 button10 = gtk_button_new_with_label ("button10");
9971 gtk_box_pack_start (GTK_BOX (hbox2), button10, FALSE, FALSE, 0);
9977 paned_keyboard_window3 (GtkWidget *widget)
9984 GtkWidget *button14;
9987 GtkWidget *button15;
9990 GtkWidget *button16;
9992 GtkWidget *button17;
9994 window3 = gtk_window_new (GTK_WINDOW_TOPLEVEL);
9995 g_object_set_data (G_OBJECT (window3), "window3", window3);
9996 gtk_window_set_title (GTK_WINDOW (window3), "Nested panes");
9998 gtk_window_set_screen (GTK_WINDOW (window3),
9999 gtk_widget_get_screen (widget));
10002 vbox2 = gtk_vbox_new (FALSE, 0);
10003 gtk_container_add (GTK_CONTAINER (window3), vbox2);
10005 label1 = gtk_label_new ("Three panes nested inside each other");
10006 gtk_box_pack_start (GTK_BOX (vbox2), label1, FALSE, FALSE, 0);
10008 hpaned3 = gtk_hpaned_new ();
10009 gtk_box_pack_start (GTK_BOX (vbox2), hpaned3, TRUE, TRUE, 0);
10011 frame9 = gtk_frame_new (NULL);
10012 gtk_paned_pack1 (GTK_PANED (hpaned3), frame9, FALSE, TRUE);
10013 gtk_frame_set_shadow_type (GTK_FRAME (frame9), GTK_SHADOW_IN);
10015 button14 = gtk_button_new_with_label ("button14");
10016 gtk_container_add (GTK_CONTAINER (frame9), button14);
10018 hpaned4 = gtk_hpaned_new ();
10019 gtk_paned_pack2 (GTK_PANED (hpaned3), hpaned4, TRUE, TRUE);
10021 frame10 = gtk_frame_new (NULL);
10022 gtk_paned_pack1 (GTK_PANED (hpaned4), frame10, FALSE, TRUE);
10023 gtk_frame_set_shadow_type (GTK_FRAME (frame10), GTK_SHADOW_IN);
10025 button15 = gtk_button_new_with_label ("button15");
10026 gtk_container_add (GTK_CONTAINER (frame10), button15);
10028 hpaned5 = gtk_hpaned_new ();
10029 gtk_paned_pack2 (GTK_PANED (hpaned4), hpaned5, TRUE, TRUE);
10031 frame11 = gtk_frame_new (NULL);
10032 gtk_paned_pack1 (GTK_PANED (hpaned5), frame11, FALSE, TRUE);
10033 gtk_frame_set_shadow_type (GTK_FRAME (frame11), GTK_SHADOW_IN);
10035 button16 = gtk_button_new_with_label ("button16");
10036 gtk_container_add (GTK_CONTAINER (frame11), button16);
10038 frame12 = gtk_frame_new (NULL);
10039 gtk_paned_pack2 (GTK_PANED (hpaned5), frame12, TRUE, TRUE);
10040 gtk_frame_set_shadow_type (GTK_FRAME (frame12), GTK_SHADOW_IN);
10042 button17 = gtk_button_new_with_label ("button17");
10043 gtk_container_add (GTK_CONTAINER (frame12), button17);
10049 paned_keyboard_window4 (GtkWidget *widget)
10051 GtkWidget *window4;
10054 GtkWidget *hpaned6;
10055 GtkWidget *vpaned3;
10056 GtkWidget *button19;
10057 GtkWidget *button18;
10059 GtkWidget *vpaned4;
10060 GtkWidget *button21;
10061 GtkWidget *button20;
10062 GtkWidget *vpaned5;
10063 GtkWidget *button23;
10064 GtkWidget *button22;
10065 GtkWidget *vpaned6;
10066 GtkWidget *button25;
10067 GtkWidget *button24;
10069 window4 = gtk_window_new (GTK_WINDOW_TOPLEVEL);
10070 g_object_set_data (G_OBJECT (window4), "window4", window4);
10071 gtk_window_set_title (GTK_WINDOW (window4), "window4");
10073 gtk_window_set_screen (GTK_WINDOW (window4),
10074 gtk_widget_get_screen (widget));
10076 vbox3 = gtk_vbox_new (FALSE, 0);
10077 gtk_container_add (GTK_CONTAINER (window4), vbox3);
10079 label2 = gtk_label_new ("Widget tree:\n\nhpaned \n - vpaned\n - hbox\n - vpaned\n - vpaned\n - vpaned\n");
10080 gtk_box_pack_start (GTK_BOX (vbox3), label2, FALSE, FALSE, 0);
10081 gtk_label_set_justify (GTK_LABEL (label2), GTK_JUSTIFY_LEFT);
10083 hpaned6 = gtk_hpaned_new ();
10084 gtk_box_pack_start (GTK_BOX (vbox3), hpaned6, TRUE, TRUE, 0);
10086 vpaned3 = gtk_vpaned_new ();
10087 gtk_paned_pack1 (GTK_PANED (hpaned6), vpaned3, FALSE, TRUE);
10089 button19 = gtk_button_new_with_label ("button19");
10090 gtk_paned_pack1 (GTK_PANED (vpaned3), button19, FALSE, TRUE);
10092 button18 = gtk_button_new_with_label ("button18");
10093 gtk_paned_pack2 (GTK_PANED (vpaned3), button18, TRUE, TRUE);
10095 hbox3 = gtk_hbox_new (FALSE, 0);
10096 gtk_paned_pack2 (GTK_PANED (hpaned6), hbox3, TRUE, TRUE);
10098 vpaned4 = gtk_vpaned_new ();
10099 gtk_box_pack_start (GTK_BOX (hbox3), vpaned4, TRUE, TRUE, 0);
10101 button21 = gtk_button_new_with_label ("button21");
10102 gtk_paned_pack1 (GTK_PANED (vpaned4), button21, FALSE, TRUE);
10104 button20 = gtk_button_new_with_label ("button20");
10105 gtk_paned_pack2 (GTK_PANED (vpaned4), button20, TRUE, TRUE);
10107 vpaned5 = gtk_vpaned_new ();
10108 gtk_box_pack_start (GTK_BOX (hbox3), vpaned5, TRUE, TRUE, 0);
10110 button23 = gtk_button_new_with_label ("button23");
10111 gtk_paned_pack1 (GTK_PANED (vpaned5), button23, FALSE, TRUE);
10113 button22 = gtk_button_new_with_label ("button22");
10114 gtk_paned_pack2 (GTK_PANED (vpaned5), button22, TRUE, TRUE);
10116 vpaned6 = gtk_vpaned_new ();
10117 gtk_box_pack_start (GTK_BOX (hbox3), vpaned6, TRUE, TRUE, 0);
10119 button25 = gtk_button_new_with_label ("button25");
10120 gtk_paned_pack1 (GTK_PANED (vpaned6), button25, FALSE, TRUE);
10122 button24 = gtk_button_new_with_label ("button24");
10123 gtk_paned_pack2 (GTK_PANED (vpaned6), button24, TRUE, TRUE);
10129 create_paned_keyboard_navigation (GtkWidget *widget)
10131 static GtkWidget *window1 = NULL;
10132 static GtkWidget *window2 = NULL;
10133 static GtkWidget *window3 = NULL;
10134 static GtkWidget *window4 = NULL;
10137 (gtk_widget_get_screen (window1) != gtk_widget_get_screen (widget)))
10139 gtk_widget_destroy (window1);
10140 gtk_widget_destroy (window2);
10141 gtk_widget_destroy (window3);
10142 gtk_widget_destroy (window4);
10147 window1 = paned_keyboard_window1 (widget);
10148 g_signal_connect (window1, "destroy",
10149 G_CALLBACK (gtk_widget_destroyed),
10155 window2 = paned_keyboard_window2 (widget);
10156 g_signal_connect (window2, "destroy",
10157 G_CALLBACK (gtk_widget_destroyed),
10163 window3 = paned_keyboard_window3 (widget);
10164 g_signal_connect (window3, "destroy",
10165 G_CALLBACK (gtk_widget_destroyed),
10171 window4 = paned_keyboard_window4 (widget);
10172 g_signal_connect (window4, "destroy",
10173 G_CALLBACK (gtk_widget_destroyed),
10177 if (GTK_WIDGET_VISIBLE (window1))
10178 gtk_widget_destroy (GTK_WIDGET (window1));
10180 gtk_widget_show_all (GTK_WIDGET (window1));
10182 if (GTK_WIDGET_VISIBLE (window2))
10183 gtk_widget_destroy (GTK_WIDGET (window2));
10185 gtk_widget_show_all (GTK_WIDGET (window2));
10187 if (GTK_WIDGET_VISIBLE (window3))
10188 gtk_widget_destroy (GTK_WIDGET (window3));
10190 gtk_widget_show_all (GTK_WIDGET (window3));
10192 if (GTK_WIDGET_VISIBLE (window4))
10193 gtk_widget_destroy (GTK_WIDGET (window4));
10195 gtk_widget_show_all (GTK_WIDGET (window4));
10203 typedef struct _cursoroffset {gint x,y;} CursorOffset;
10206 shape_pressed (GtkWidget *widget, GdkEventButton *event)
10210 /* ignore double and triple click */
10211 if (event->type != GDK_BUTTON_PRESS)
10214 p = g_object_get_data (G_OBJECT (widget), "cursor_offset");
10215 p->x = (int) event->x;
10216 p->y = (int) event->y;
10218 gtk_grab_add (widget);
10219 gdk_pointer_grab (widget->window, TRUE,
10220 GDK_BUTTON_RELEASE_MASK |
10221 GDK_BUTTON_MOTION_MASK |
10222 GDK_POINTER_MOTION_HINT_MASK,
10227 shape_released (GtkWidget *widget)
10229 gtk_grab_remove (widget);
10230 gdk_display_pointer_ungrab (gtk_widget_get_display (widget),
10235 shape_motion (GtkWidget *widget,
10236 GdkEventMotion *event)
10240 GdkModifierType mask;
10242 p = g_object_get_data (G_OBJECT (widget), "cursor_offset");
10245 * Can't use event->x / event->y here
10246 * because I need absolute coordinates.
10248 gdk_window_get_pointer (NULL, &xp, &yp, &mask);
10249 gtk_widget_set_uposition (widget, xp - p->x, yp - p->y);
10253 shape_create_icon (GdkScreen *screen,
10264 CursorOffset* icon_pos;
10266 GdkBitmap *gdk_pixmap_mask;
10267 GdkPixmap *gdk_pixmap;
10270 style = gtk_widget_get_default_style ();
10271 gc = style->black_gc;
10274 * GDK_WINDOW_TOPLEVEL works also, giving you a title border
10276 window = gtk_window_new (window_type);
10277 gtk_window_set_screen (GTK_WINDOW (window), screen);
10279 fixed = gtk_fixed_new ();
10280 gtk_widget_set_size_request (fixed, 100, 100);
10281 gtk_container_add (GTK_CONTAINER (window), fixed);
10282 gtk_widget_show (fixed);
10284 gtk_widget_set_events (window,
10285 gtk_widget_get_events (window) |
10286 GDK_BUTTON_MOTION_MASK |
10287 GDK_POINTER_MOTION_HINT_MASK |
10288 GDK_BUTTON_PRESS_MASK);
10290 gtk_widget_realize (window);
10291 gdk_pixmap = gdk_pixmap_create_from_xpm (window->window, &gdk_pixmap_mask,
10292 &style->bg[GTK_STATE_NORMAL],
10295 pixmap = gtk_image_new_from_pixmap (gdk_pixmap, gdk_pixmap_mask);
10296 gtk_fixed_put (GTK_FIXED (fixed), pixmap, px,py);
10297 gtk_widget_show (pixmap);
10299 gtk_widget_shape_combine_mask (window, gdk_pixmap_mask, px, py);
10301 g_object_unref (gdk_pixmap_mask);
10302 g_object_unref (gdk_pixmap);
10304 g_signal_connect (window, "button_press_event",
10305 G_CALLBACK (shape_pressed), NULL);
10306 g_signal_connect (window, "button_release_event",
10307 G_CALLBACK (shape_released), NULL);
10308 g_signal_connect (window, "motion_notify_event",
10309 G_CALLBACK (shape_motion), NULL);
10311 icon_pos = g_new (CursorOffset, 1);
10312 g_object_set_data (G_OBJECT (window), "cursor_offset", icon_pos);
10314 gtk_widget_set_uposition (window, x, y);
10315 gtk_widget_show (window);
10321 create_shapes (GtkWidget *widget)
10323 /* Variables used by the Drag/Drop and Shape Window demos */
10324 static GtkWidget *modeller = NULL;
10325 static GtkWidget *sheets = NULL;
10326 static GtkWidget *rings = NULL;
10327 static GtkWidget *with_region = NULL;
10328 GdkScreen *screen = gtk_widget_get_screen (widget);
10330 if (!(file_exists ("Modeller.xpm") &&
10331 file_exists ("FilesQueue.xpm") &&
10332 file_exists ("3DRings.xpm")))
10338 modeller = shape_create_icon (screen, "Modeller.xpm",
10339 440, 140, 0,0, GTK_WINDOW_POPUP);
10341 g_signal_connect (modeller, "destroy",
10342 G_CALLBACK (gtk_widget_destroyed),
10346 gtk_widget_destroy (modeller);
10350 sheets = shape_create_icon (screen, "FilesQueue.xpm",
10351 580, 170, 0,0, GTK_WINDOW_POPUP);
10353 g_signal_connect (sheets, "destroy",
10354 G_CALLBACK (gtk_widget_destroyed),
10359 gtk_widget_destroy (sheets);
10363 rings = shape_create_icon (screen, "3DRings.xpm",
10364 460, 270, 25,25, GTK_WINDOW_TOPLEVEL);
10366 g_signal_connect (rings, "destroy",
10367 G_CALLBACK (gtk_widget_destroyed),
10371 gtk_widget_destroy (rings);
10378 with_region = shape_create_icon (screen, "3DRings.xpm",
10379 460, 270, 25,25, GTK_WINDOW_TOPLEVEL);
10381 gtk_window_set_decorated (GTK_WINDOW (with_region), FALSE);
10383 g_signal_connect (with_region, "destroy",
10384 G_CALLBACK (gtk_widget_destroyed),
10387 /* reset shape from mask to a region */
10390 region = gdk_region_new ();
10402 gdk_region_union_with_rect (region, &rect);
10410 gdk_window_shape_combine_region (with_region->window,
10415 gtk_widget_destroy (with_region);
10423 create_wmhints (GtkWidget *widget)
10425 static GtkWidget *window = NULL;
10427 GtkWidget *separator;
10432 GdkBitmap *circles;
10436 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
10438 gtk_window_set_screen (GTK_WINDOW (window),
10439 gtk_widget_get_screen (widget));
10441 g_signal_connect (window, "destroy",
10442 G_CALLBACK (gtk_widget_destroyed),
10445 gtk_window_set_title (GTK_WINDOW (window), "WM Hints");
10446 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
10448 gtk_widget_realize (window);
10450 circles = gdk_bitmap_create_from_data (window->window,
10454 gdk_window_set_icon (window->window, NULL,
10457 gdk_window_set_icon_name (window->window, "WMHints Test Icon");
10459 gdk_window_set_decorations (window->window, GDK_DECOR_ALL | GDK_DECOR_MENU);
10460 gdk_window_set_functions (window->window, GDK_FUNC_ALL | GDK_FUNC_RESIZE);
10462 box1 = gtk_vbox_new (FALSE, 0);
10463 gtk_container_add (GTK_CONTAINER (window), box1);
10464 gtk_widget_show (box1);
10466 label = gtk_label_new ("Try iconizing me!");
10467 gtk_widget_set_size_request (label, 150, 50);
10468 gtk_box_pack_start (GTK_BOX (box1), label, TRUE, TRUE, 0);
10469 gtk_widget_show (label);
10472 separator = gtk_hseparator_new ();
10473 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
10474 gtk_widget_show (separator);
10477 box2 = gtk_vbox_new (FALSE, 10);
10478 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
10479 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
10480 gtk_widget_show (box2);
10483 button = gtk_button_new_with_label ("close");
10485 g_signal_connect_swapped (button, "clicked",
10486 G_CALLBACK (gtk_widget_destroy),
10489 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
10490 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
10491 gtk_widget_grab_default (button);
10492 gtk_widget_show (button);
10495 if (!GTK_WIDGET_VISIBLE (window))
10496 gtk_widget_show (window);
10498 gtk_widget_destroy (window);
10503 * Window state tracking
10507 window_state_callback (GtkWidget *widget,
10508 GdkEventWindowState *event,
10511 GtkWidget *label = data;
10514 msg = g_strconcat (GTK_WINDOW (widget)->title, ": ",
10515 (event->new_window_state & GDK_WINDOW_STATE_WITHDRAWN) ?
10516 "withdrawn" : "not withdrawn", ", ",
10517 (event->new_window_state & GDK_WINDOW_STATE_ICONIFIED) ?
10518 "iconified" : "not iconified", ", ",
10519 (event->new_window_state & GDK_WINDOW_STATE_STICKY) ?
10520 "sticky" : "not sticky", ", ",
10521 (event->new_window_state & GDK_WINDOW_STATE_MAXIMIZED) ?
10522 "maximized" : "not maximized", ", ",
10523 (event->new_window_state & GDK_WINDOW_STATE_FULLSCREEN) ?
10524 "fullscreen" : "not fullscreen",
10525 (event->new_window_state & GDK_WINDOW_STATE_ABOVE) ?
10526 "above" : "not above", ", ",
10527 (event->new_window_state & GDK_WINDOW_STATE_BELOW) ?
10528 "below" : "not below", ", ",
10531 gtk_label_set_text (GTK_LABEL (label), msg);
10539 tracking_label (GtkWidget *window)
10545 hbox = gtk_hbox_new (FALSE, 5);
10547 g_signal_connect_object (hbox,
10549 G_CALLBACK (gtk_widget_destroy),
10551 G_CONNECT_SWAPPED);
10553 label = gtk_label_new ("<no window state events received>");
10554 gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
10555 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
10557 g_signal_connect (window,
10558 "window_state_event",
10559 G_CALLBACK (window_state_callback),
10562 button = gtk_button_new_with_label ("Deiconify");
10563 g_signal_connect_object (button,
10565 G_CALLBACK (gtk_window_deiconify),
10567 G_CONNECT_SWAPPED);
10568 gtk_box_pack_end (GTK_BOX (hbox), button, FALSE, FALSE, 0);
10570 button = gtk_button_new_with_label ("Iconify");
10571 g_signal_connect_object (button,
10573 G_CALLBACK (gtk_window_iconify),
10575 G_CONNECT_SWAPPED);
10576 gtk_box_pack_end (GTK_BOX (hbox), button, FALSE, FALSE, 0);
10578 button = gtk_button_new_with_label ("Fullscreen");
10579 g_signal_connect_object (button,
10581 G_CALLBACK (gtk_window_fullscreen),
10583 G_CONNECT_SWAPPED);
10584 gtk_box_pack_end (GTK_BOX (hbox), button, FALSE, FALSE, 0);
10586 button = gtk_button_new_with_label ("Unfullscreen");
10587 g_signal_connect_object (button,
10589 G_CALLBACK (gtk_window_unfullscreen),
10591 G_CONNECT_SWAPPED);
10592 gtk_box_pack_end (GTK_BOX (hbox), button, FALSE, FALSE, 0);
10594 button = gtk_button_new_with_label ("Present");
10595 g_signal_connect_object (button,
10597 G_CALLBACK (gtk_window_present),
10599 G_CONNECT_SWAPPED);
10600 gtk_box_pack_end (GTK_BOX (hbox), button, FALSE, FALSE, 0);
10602 button = gtk_button_new_with_label ("Show");
10603 g_signal_connect_object (button,
10605 G_CALLBACK (gtk_widget_show),
10607 G_CONNECT_SWAPPED);
10608 gtk_box_pack_end (GTK_BOX (hbox), button, FALSE, FALSE, 0);
10610 gtk_widget_show_all (hbox);
10616 keep_window_above (GtkToggleButton *togglebutton, gpointer data)
10618 GtkWidget *button = g_object_get_data (G_OBJECT (togglebutton), "radio");
10620 gtk_window_set_keep_above (GTK_WINDOW (data),
10621 gtk_toggle_button_get_active (togglebutton));
10623 if (gtk_toggle_button_get_active (togglebutton))
10624 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), FALSE);
10628 keep_window_below (GtkToggleButton *togglebutton, gpointer data)
10630 GtkWidget *button = g_object_get_data (G_OBJECT (togglebutton), "radio");
10632 gtk_window_set_keep_below (GTK_WINDOW (data),
10633 gtk_toggle_button_get_active (togglebutton));
10635 if (gtk_toggle_button_get_active (togglebutton))
10636 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), FALSE);
10641 get_state_controls (GtkWidget *window)
10645 GtkWidget *button_above;
10646 GtkWidget *button_below;
10648 vbox = gtk_vbox_new (FALSE, 0);
10650 button = gtk_button_new_with_label ("Stick");
10651 g_signal_connect_object (button,
10653 G_CALLBACK (gtk_window_stick),
10655 G_CONNECT_SWAPPED);
10656 gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
10658 button = gtk_button_new_with_label ("Unstick");
10659 g_signal_connect_object (button,
10661 G_CALLBACK (gtk_window_unstick),
10663 G_CONNECT_SWAPPED);
10664 gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
10666 button = gtk_button_new_with_label ("Maximize");
10667 g_signal_connect_object (button,
10669 G_CALLBACK (gtk_window_maximize),
10671 G_CONNECT_SWAPPED);
10672 gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
10674 button = gtk_button_new_with_label ("Unmaximize");
10675 g_signal_connect_object (button,
10677 G_CALLBACK (gtk_window_unmaximize),
10679 G_CONNECT_SWAPPED);
10680 gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
10682 button = gtk_button_new_with_label ("Iconify");
10683 g_signal_connect_object (button,
10685 G_CALLBACK (gtk_window_iconify),
10687 G_CONNECT_SWAPPED);
10688 gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
10690 button = gtk_button_new_with_label ("Fullscreen");
10691 g_signal_connect_object (button,
10693 G_CALLBACK (gtk_window_fullscreen),
10695 G_CONNECT_SWAPPED);
10696 gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
10698 button = gtk_button_new_with_label ("Unfullscreen");
10699 g_signal_connect_object (button,
10701 G_CALLBACK (gtk_window_unfullscreen),
10703 G_CONNECT_SWAPPED);
10704 gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
10706 button_above = gtk_toggle_button_new_with_label ("Keep above");
10707 g_signal_connect (button_above,
10709 G_CALLBACK (keep_window_above),
10711 gtk_box_pack_start (GTK_BOX (vbox), button_above, FALSE, FALSE, 0);
10713 button_below = gtk_toggle_button_new_with_label ("Keep below");
10714 g_signal_connect (button_below,
10716 G_CALLBACK (keep_window_below),
10718 gtk_box_pack_start (GTK_BOX (vbox), button_below, FALSE, FALSE, 0);
10720 g_object_set_data (G_OBJECT (button_above), "radio", button_below);
10721 g_object_set_data (G_OBJECT (button_below), "radio", button_above);
10723 button = gtk_button_new_with_label ("Hide (withdraw)");
10724 g_signal_connect_object (button,
10726 G_CALLBACK (gtk_widget_hide),
10728 G_CONNECT_SWAPPED);
10729 gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
10731 gtk_widget_show_all (vbox);
10737 create_window_states (GtkWidget *widget)
10739 static GtkWidget *window = NULL;
10742 GtkWidget *iconified;
10744 GtkWidget *controls;
10748 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
10749 gtk_window_set_screen (GTK_WINDOW (window),
10750 gtk_widget_get_screen (widget));
10752 g_signal_connect (window, "destroy",
10753 G_CALLBACK (gtk_widget_destroyed),
10756 gtk_window_set_title (GTK_WINDOW (window), "Window states");
10758 box1 = gtk_vbox_new (FALSE, 0);
10759 gtk_container_add (GTK_CONTAINER (window), box1);
10761 iconified = gtk_window_new (GTK_WINDOW_TOPLEVEL);
10763 gtk_window_set_screen (GTK_WINDOW (iconified),
10764 gtk_widget_get_screen (widget));
10766 g_signal_connect_object (iconified, "destroy",
10767 G_CALLBACK (gtk_widget_destroy),
10769 G_CONNECT_SWAPPED);
10770 gtk_window_iconify (GTK_WINDOW (iconified));
10771 gtk_window_set_title (GTK_WINDOW (iconified), "Iconified initially");
10772 controls = get_state_controls (iconified);
10773 gtk_container_add (GTK_CONTAINER (iconified), controls);
10775 normal = gtk_window_new (GTK_WINDOW_TOPLEVEL);
10777 gtk_window_set_screen (GTK_WINDOW (normal),
10778 gtk_widget_get_screen (widget));
10780 g_signal_connect_object (normal, "destroy",
10781 G_CALLBACK (gtk_widget_destroy),
10783 G_CONNECT_SWAPPED);
10785 gtk_window_set_title (GTK_WINDOW (normal), "Deiconified initially");
10786 controls = get_state_controls (normal);
10787 gtk_container_add (GTK_CONTAINER (normal), controls);
10789 label = tracking_label (iconified);
10790 gtk_container_add (GTK_CONTAINER (box1), label);
10792 label = tracking_label (normal);
10793 gtk_container_add (GTK_CONTAINER (box1), label);
10795 gtk_widget_show_all (iconified);
10796 gtk_widget_show_all (normal);
10797 gtk_widget_show_all (box1);
10800 if (!GTK_WIDGET_VISIBLE (window))
10801 gtk_widget_show (window);
10803 gtk_widget_destroy (window);
10811 configure_event_callback (GtkWidget *widget,
10812 GdkEventConfigure *event,
10815 GtkWidget *label = data;
10819 gtk_window_get_position (GTK_WINDOW (widget), &x, &y);
10821 msg = g_strdup_printf ("event: %d,%d %d x %d\n"
10822 "position: %d, %d",
10823 event->x, event->y, event->width, event->height,
10826 gtk_label_set_text (GTK_LABEL (label), msg);
10834 get_ints (GtkWidget *window,
10841 spin1 = g_object_get_data (G_OBJECT (window), "spin1");
10842 spin2 = g_object_get_data (G_OBJECT (window), "spin2");
10844 *a = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (spin1));
10845 *b = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (spin2));
10849 set_size_callback (GtkWidget *widget,
10854 get_ints (data, &w, &h);
10856 gtk_window_resize (GTK_WINDOW (g_object_get_data (data, "target")), w, h);
10860 unset_default_size_callback (GtkWidget *widget,
10863 gtk_window_set_default_size (g_object_get_data (data, "target"),
10868 set_default_size_callback (GtkWidget *widget,
10873 get_ints (data, &w, &h);
10875 gtk_window_set_default_size (g_object_get_data (data, "target"),
10880 unset_size_request_callback (GtkWidget *widget,
10883 gtk_widget_set_size_request (g_object_get_data (data, "target"),
10888 set_size_request_callback (GtkWidget *widget,
10893 get_ints (data, &w, &h);
10895 gtk_widget_set_size_request (g_object_get_data (data, "target"),
10900 set_location_callback (GtkWidget *widget,
10905 get_ints (data, &x, &y);
10907 gtk_window_move (g_object_get_data (data, "target"), x, y);
10911 move_to_position_callback (GtkWidget *widget,
10917 window = g_object_get_data (data, "target");
10919 gtk_window_get_position (window, &x, &y);
10921 gtk_window_move (window, x, y);
10925 set_geometry_callback (GtkWidget *entry,
10931 target = GTK_WINDOW (g_object_get_data (G_OBJECT (data), "target"));
10933 text = gtk_editable_get_chars (GTK_EDITABLE (entry), 0, -1);
10935 if (!gtk_window_parse_geometry (target, text))
10936 g_print ("Bad geometry string '%s'\n", text);
10942 allow_shrink_callback (GtkWidget *widget,
10945 g_object_set (g_object_get_data (data, "target"),
10947 GTK_TOGGLE_BUTTON (widget)->active,
10952 allow_grow_callback (GtkWidget *widget,
10955 g_object_set (g_object_get_data (data, "target"),
10957 GTK_TOGGLE_BUTTON (widget)->active,
10962 gravity_selected (GtkWidget *widget,
10965 gtk_window_set_gravity (GTK_WINDOW (g_object_get_data (data, "target")),
10966 gtk_option_menu_get_history (GTK_OPTION_MENU (widget)) + GDK_GRAVITY_NORTH_WEST);
10970 pos_selected (GtkWidget *widget,
10973 gtk_window_set_position (GTK_WINDOW (g_object_get_data (data, "target")),
10974 gtk_option_menu_get_history (GTK_OPTION_MENU (widget)) + GTK_WIN_POS_NONE);
10978 move_gravity_window_to_current_position (GtkWidget *widget,
10984 window = GTK_WINDOW (data);
10986 gtk_window_get_position (window, &x, &y);
10988 gtk_window_move (window, x, y);
10992 get_screen_corner (GtkWindow *window,
10997 GdkScreen * screen = gtk_window_get_screen (window);
10999 gtk_window_get_size (GTK_WINDOW (window), &w, &h);
11001 switch (gtk_window_get_gravity (window))
11003 case GDK_GRAVITY_SOUTH_EAST:
11004 *x = gdk_screen_get_width (screen) - w;
11005 *y = gdk_screen_get_height (screen) - h;
11008 case GDK_GRAVITY_NORTH_EAST:
11009 *x = gdk_screen_get_width (screen) - w;
11013 case GDK_GRAVITY_SOUTH_WEST:
11015 *y = gdk_screen_get_height (screen) - h;
11018 case GDK_GRAVITY_NORTH_WEST:
11023 case GDK_GRAVITY_SOUTH:
11024 *x = (gdk_screen_get_width (screen) - w) / 2;
11025 *y = gdk_screen_get_height (screen) - h;
11028 case GDK_GRAVITY_NORTH:
11029 *x = (gdk_screen_get_width (screen) - w) / 2;
11033 case GDK_GRAVITY_WEST:
11035 *y = (gdk_screen_get_height (screen) - h) / 2;
11038 case GDK_GRAVITY_EAST:
11039 *x = gdk_screen_get_width (screen) - w;
11040 *y = (gdk_screen_get_height (screen) - h) / 2;
11043 case GDK_GRAVITY_CENTER:
11044 *x = (gdk_screen_get_width (screen) - w) / 2;
11045 *y = (gdk_screen_get_height (screen) - h) / 2;
11048 case GDK_GRAVITY_STATIC:
11049 /* pick some random numbers */
11055 g_assert_not_reached ();
11061 move_gravity_window_to_starting_position (GtkWidget *widget,
11067 window = GTK_WINDOW (data);
11069 get_screen_corner (window,
11072 gtk_window_move (window, x, y);
11076 make_gravity_window (GtkWidget *destroy_with,
11077 GdkGravity gravity,
11078 const gchar *title)
11085 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
11087 gtk_window_set_screen (GTK_WINDOW (window),
11088 gtk_widget_get_screen (destroy_with));
11090 vbox = gtk_vbox_new (FALSE, 0);
11091 gtk_widget_show (vbox);
11093 gtk_container_add (GTK_CONTAINER (window), vbox);
11094 gtk_window_set_title (GTK_WINDOW (window), title);
11095 gtk_window_set_gravity (GTK_WINDOW (window), gravity);
11097 g_signal_connect_object (destroy_with,
11099 G_CALLBACK (gtk_widget_destroy),
11101 G_CONNECT_SWAPPED);
11104 button = gtk_button_new_with_mnemonic ("_Move to current position");
11106 g_signal_connect (button, "clicked",
11107 G_CALLBACK (move_gravity_window_to_current_position),
11110 gtk_container_add (GTK_CONTAINER (vbox), button);
11111 gtk_widget_show (button);
11113 button = gtk_button_new_with_mnemonic ("Move to _starting position");
11115 g_signal_connect (button, "clicked",
11116 G_CALLBACK (move_gravity_window_to_starting_position),
11119 gtk_container_add (GTK_CONTAINER (vbox), button);
11120 gtk_widget_show (button);
11122 /* Pretend this is the result of --geometry.
11123 * DO NOT COPY THIS CODE unless you are setting --geometry results,
11124 * and in that case you probably should just use gtk_window_parse_geometry().
11125 * AGAIN, DO NOT SET GDK_HINT_USER_POS! It violates the ICCCM unless
11126 * you are parsing --geometry or equivalent.
11128 gtk_window_set_geometry_hints (GTK_WINDOW (window),
11130 GDK_HINT_USER_POS);
11132 gtk_window_set_default_size (GTK_WINDOW (window),
11135 get_screen_corner (GTK_WINDOW (window), &x, &y);
11137 gtk_window_move (GTK_WINDOW (window),
11144 do_gravity_test (GtkWidget *widget,
11147 GtkWidget *destroy_with = data;
11150 /* We put a window at each gravity point on the screen. */
11151 window = make_gravity_window (destroy_with, GDK_GRAVITY_NORTH_WEST,
11153 gtk_widget_show (window);
11155 window = make_gravity_window (destroy_with, GDK_GRAVITY_SOUTH_EAST,
11157 gtk_widget_show (window);
11159 window = make_gravity_window (destroy_with, GDK_GRAVITY_NORTH_EAST,
11161 gtk_widget_show (window);
11163 window = make_gravity_window (destroy_with, GDK_GRAVITY_SOUTH_WEST,
11165 gtk_widget_show (window);
11167 window = make_gravity_window (destroy_with, GDK_GRAVITY_SOUTH,
11169 gtk_widget_show (window);
11171 window = make_gravity_window (destroy_with, GDK_GRAVITY_NORTH,
11173 gtk_widget_show (window);
11176 window = make_gravity_window (destroy_with, GDK_GRAVITY_WEST,
11178 gtk_widget_show (window);
11181 window = make_gravity_window (destroy_with, GDK_GRAVITY_EAST,
11183 gtk_widget_show (window);
11185 window = make_gravity_window (destroy_with, GDK_GRAVITY_CENTER,
11187 gtk_widget_show (window);
11189 window = make_gravity_window (destroy_with, GDK_GRAVITY_STATIC,
11191 gtk_widget_show (window);
11195 window_controls (GtkWidget *window)
11197 GtkWidget *control_window;
11202 GtkAdjustment *adj;
11208 control_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
11210 gtk_window_set_screen (GTK_WINDOW (control_window),
11211 gtk_widget_get_screen (window));
11213 gtk_window_set_title (GTK_WINDOW (control_window), "Size controls");
11215 g_object_set_data (G_OBJECT (control_window),
11219 g_signal_connect_object (control_window,
11221 G_CALLBACK (gtk_widget_destroy),
11223 G_CONNECT_SWAPPED);
11225 vbox = gtk_vbox_new (FALSE, 5);
11227 gtk_container_add (GTK_CONTAINER (control_window), vbox);
11229 label = gtk_label_new ("<no configure events>");
11230 gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
11232 g_signal_connect (window,
11234 G_CALLBACK (configure_event_callback),
11237 adj = (GtkAdjustment *) gtk_adjustment_new (10.0, -2000.0, 2000.0, 1.0,
11239 spin = gtk_spin_button_new (adj, 0, 0);
11241 gtk_box_pack_start (GTK_BOX (vbox), spin, FALSE, FALSE, 0);
11243 g_object_set_data (G_OBJECT (control_window), "spin1", spin);
11245 adj = (GtkAdjustment *) gtk_adjustment_new (10.0, -2000.0, 2000.0, 1.0,
11247 spin = gtk_spin_button_new (adj, 0, 0);
11249 gtk_box_pack_start (GTK_BOX (vbox), spin, FALSE, FALSE, 0);
11251 g_object_set_data (G_OBJECT (control_window), "spin2", spin);
11253 entry = gtk_entry_new ();
11254 gtk_box_pack_start (GTK_BOX (vbox), entry, FALSE, FALSE, 0);
11256 g_signal_connect (entry, "changed",
11257 G_CALLBACK (set_geometry_callback),
11260 button = gtk_button_new_with_label ("Show gravity test windows");
11261 g_signal_connect_swapped (button,
11263 G_CALLBACK (do_gravity_test),
11265 gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
11267 button = gtk_button_new_with_label ("Reshow with initial size");
11268 g_signal_connect_object (button,
11270 G_CALLBACK (gtk_window_reshow_with_initial_size),
11272 G_CONNECT_SWAPPED);
11273 gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
11275 button = gtk_button_new_with_label ("Queue resize");
11276 g_signal_connect_object (button,
11278 G_CALLBACK (gtk_widget_queue_resize),
11280 G_CONNECT_SWAPPED);
11281 gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
11283 button = gtk_button_new_with_label ("Resize");
11284 g_signal_connect (button,
11286 G_CALLBACK (set_size_callback),
11288 gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
11290 button = gtk_button_new_with_label ("Set default size");
11291 g_signal_connect (button,
11293 G_CALLBACK (set_default_size_callback),
11295 gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
11297 button = gtk_button_new_with_label ("Unset default size");
11298 g_signal_connect (button,
11300 G_CALLBACK (unset_default_size_callback),
11302 gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
11304 button = gtk_button_new_with_label ("Set size request");
11305 g_signal_connect (button,
11307 G_CALLBACK (set_size_request_callback),
11309 gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
11311 button = gtk_button_new_with_label ("Unset size request");
11312 g_signal_connect (button,
11314 G_CALLBACK (unset_size_request_callback),
11316 gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
11318 button = gtk_button_new_with_label ("Move");
11319 g_signal_connect (button,
11321 G_CALLBACK (set_location_callback),
11323 gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
11325 button = gtk_button_new_with_label ("Move to current position");
11326 g_signal_connect (button,
11328 G_CALLBACK (move_to_position_callback),
11330 gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
11332 button = gtk_check_button_new_with_label ("Allow shrink");
11333 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), FALSE);
11334 g_signal_connect (button,
11336 G_CALLBACK (allow_shrink_callback),
11338 gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
11340 button = gtk_check_button_new_with_label ("Allow grow");
11341 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
11342 g_signal_connect (button,
11344 G_CALLBACK (allow_grow_callback),
11346 gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
11348 button = gtk_button_new_with_mnemonic ("_Show");
11349 g_signal_connect_object (button,
11351 G_CALLBACK (gtk_widget_show),
11353 G_CONNECT_SWAPPED);
11354 gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
11356 button = gtk_button_new_with_mnemonic ("_Hide");
11357 g_signal_connect_object (button,
11359 G_CALLBACK (gtk_widget_hide),
11361 G_CONNECT_SWAPPED);
11362 gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
11364 menu = gtk_menu_new ();
11370 static gchar *names[] = {
11371 "GDK_GRAVITY_NORTH_WEST",
11372 "GDK_GRAVITY_NORTH",
11373 "GDK_GRAVITY_NORTH_EAST",
11374 "GDK_GRAVITY_WEST",
11375 "GDK_GRAVITY_CENTER",
11376 "GDK_GRAVITY_EAST",
11377 "GDK_GRAVITY_SOUTH_WEST",
11378 "GDK_GRAVITY_SOUTH",
11379 "GDK_GRAVITY_SOUTH_EAST",
11380 "GDK_GRAVITY_STATIC",
11384 g_assert (names[i]);
11386 mi = gtk_menu_item_new_with_label (names[i]);
11388 gtk_menu_shell_append (GTK_MENU_SHELL (menu), mi);
11393 gtk_widget_show_all (menu);
11395 om = gtk_option_menu_new ();
11396 gtk_option_menu_set_menu (GTK_OPTION_MENU (om), menu);
11399 g_signal_connect (om,
11401 G_CALLBACK (gravity_selected),
11404 gtk_box_pack_end (GTK_BOX (vbox), om, FALSE, FALSE, 0);
11407 menu = gtk_menu_new ();
11413 static gchar *names[] = {
11414 "GTK_WIN_POS_NONE",
11415 "GTK_WIN_POS_CENTER",
11416 "GTK_WIN_POS_MOUSE",
11417 "GTK_WIN_POS_CENTER_ALWAYS",
11418 "GTK_WIN_POS_CENTER_ON_PARENT",
11422 g_assert (names[i]);
11424 mi = gtk_menu_item_new_with_label (names[i]);
11426 gtk_menu_shell_append (GTK_MENU_SHELL (menu), mi);
11431 gtk_widget_show_all (menu);
11433 om = gtk_option_menu_new ();
11434 gtk_option_menu_set_menu (GTK_OPTION_MENU (om), menu);
11437 g_signal_connect (om,
11439 G_CALLBACK (pos_selected),
11442 gtk_box_pack_end (GTK_BOX (vbox), om, FALSE, FALSE, 0);
11444 gtk_widget_show_all (vbox);
11446 return control_window;
11450 create_window_sizing (GtkWidget *widget)
11452 static GtkWidget *window = NULL;
11453 static GtkWidget *target_window = NULL;
11455 if (!target_window)
11459 target_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
11460 gtk_window_set_screen (GTK_WINDOW (target_window),
11461 gtk_widget_get_screen (widget));
11462 label = gtk_label_new (NULL);
11463 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");
11464 gtk_container_add (GTK_CONTAINER (target_window), label);
11465 gtk_widget_show (label);
11467 g_signal_connect (target_window, "destroy",
11468 G_CALLBACK (gtk_widget_destroyed),
11471 window = window_controls (target_window);
11473 g_signal_connect (window, "destroy",
11474 G_CALLBACK (gtk_widget_destroyed),
11477 gtk_window_set_title (GTK_WINDOW (target_window), "Window to size");
11480 /* don't show target window by default, we want to allow testing
11481 * of behavior on first show.
11484 if (!GTK_WIDGET_VISIBLE (window))
11485 gtk_widget_show (window);
11487 gtk_widget_destroy (window);
11494 typedef struct _ProgressData {
11497 GtkWidget *block_spin;
11498 GtkWidget *x_align_spin;
11499 GtkWidget *y_align_spin;
11500 GtkWidget *step_spin;
11501 GtkWidget *act_blocks_spin;
11511 progress_timeout (gpointer data)
11514 GtkAdjustment *adj;
11516 adj = GTK_PROGRESS (data)->adjustment;
11518 new_val = adj->value + 1;
11519 if (new_val > adj->upper)
11520 new_val = adj->lower;
11522 gtk_progress_set_value (GTK_PROGRESS (data), new_val);
11528 destroy_progress (GtkWidget *widget,
11529 ProgressData **pdata)
11531 gtk_timeout_remove ((*pdata)->timer);
11532 (*pdata)->timer = 0;
11533 (*pdata)->window = NULL;
11539 progressbar_toggle_orientation (GtkWidget *widget, gpointer data)
11541 ProgressData *pdata;
11544 pdata = (ProgressData *) data;
11546 if (!GTK_WIDGET_MAPPED (widget))
11549 i = gtk_option_menu_get_history (GTK_OPTION_MENU (widget));
11551 gtk_progress_bar_set_orientation (GTK_PROGRESS_BAR (pdata->pbar),
11552 (GtkProgressBarOrientation) i);
11556 toggle_show_text (GtkWidget *widget, ProgressData *pdata)
11558 gtk_progress_set_show_text (GTK_PROGRESS (pdata->pbar),
11559 GTK_TOGGLE_BUTTON (widget)->active);
11560 gtk_widget_set_sensitive (pdata->entry, GTK_TOGGLE_BUTTON (widget)->active);
11561 gtk_widget_set_sensitive (pdata->x_align_spin,
11562 GTK_TOGGLE_BUTTON (widget)->active);
11563 gtk_widget_set_sensitive (pdata->y_align_spin,
11564 GTK_TOGGLE_BUTTON (widget)->active);
11568 progressbar_toggle_ellipsize (GtkWidget *widget,
11571 ProgressData *pdata = data;
11572 if (GTK_WIDGET_DRAWABLE (widget))
11574 gint i = gtk_option_menu_get_history (GTK_OPTION_MENU (widget));
11575 gtk_progress_bar_set_ellipsize (GTK_PROGRESS_BAR (pdata->pbar), i);
11580 progressbar_toggle_bar_style (GtkWidget *widget, gpointer data)
11582 ProgressData *pdata;
11585 pdata = (ProgressData *) data;
11587 if (!GTK_WIDGET_MAPPED (widget))
11590 i = gtk_option_menu_get_history (GTK_OPTION_MENU (widget));
11593 gtk_widget_set_sensitive (pdata->block_spin, TRUE);
11595 gtk_widget_set_sensitive (pdata->block_spin, FALSE);
11597 gtk_progress_bar_set_bar_style (GTK_PROGRESS_BAR (pdata->pbar),
11598 (GtkProgressBarStyle) i);
11602 progress_value_changed (GtkAdjustment *adj, ProgressData *pdata)
11606 if (GTK_PROGRESS (pdata->pbar)->activity_mode)
11607 sprintf (buf, "???");
11609 sprintf (buf, "%.0f%%", 100 *
11610 gtk_progress_get_current_percentage (GTK_PROGRESS (pdata->pbar)));
11611 gtk_label_set_text (GTK_LABEL (pdata->label), buf);
11615 adjust_blocks (GtkAdjustment *adj, ProgressData *pdata)
11617 gtk_progress_set_percentage (GTK_PROGRESS (pdata->pbar), 0);
11618 gtk_progress_bar_set_discrete_blocks (GTK_PROGRESS_BAR (pdata->pbar),
11619 gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (pdata->block_spin)));
11623 adjust_step (GtkAdjustment *adj, ProgressData *pdata)
11625 gtk_progress_bar_set_activity_step (GTK_PROGRESS_BAR (pdata->pbar),
11626 gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (pdata->step_spin)));
11630 adjust_act_blocks (GtkAdjustment *adj, ProgressData *pdata)
11632 gtk_progress_bar_set_activity_blocks (GTK_PROGRESS_BAR (pdata->pbar),
11633 gtk_spin_button_get_value_as_int
11634 (GTK_SPIN_BUTTON (pdata->act_blocks_spin)));
11638 adjust_align (GtkAdjustment *adj, ProgressData *pdata)
11640 gtk_progress_set_text_alignment (GTK_PROGRESS (pdata->pbar),
11641 gtk_spin_button_get_value (GTK_SPIN_BUTTON (pdata->x_align_spin)),
11642 gtk_spin_button_get_value (GTK_SPIN_BUTTON (pdata->y_align_spin)));
11646 toggle_activity_mode (GtkWidget *widget, ProgressData *pdata)
11648 gtk_progress_set_activity_mode (GTK_PROGRESS (pdata->pbar),
11649 GTK_TOGGLE_BUTTON (widget)->active);
11650 gtk_widget_set_sensitive (pdata->step_spin,
11651 GTK_TOGGLE_BUTTON (widget)->active);
11652 gtk_widget_set_sensitive (pdata->act_blocks_spin,
11653 GTK_TOGGLE_BUTTON (widget)->active);
11657 entry_changed (GtkWidget *widget, ProgressData *pdata)
11659 gtk_progress_set_format_string (GTK_PROGRESS (pdata->pbar),
11660 gtk_entry_get_text (GTK_ENTRY (pdata->entry)));
11664 create_progress_bar (GtkWidget *widget)
11675 GtkAdjustment *adj;
11676 static ProgressData *pdata = NULL;
11678 static gchar *items1[] =
11686 static gchar *items2[] =
11692 static char *ellipsize_items[] = {
11693 "None", // PANGO_ELLIPSIZE_NONE,
11694 "Start", // PANGO_ELLIPSIZE_START,
11695 "Middle", // PANGO_ELLIPSIZE_MIDDLE,
11696 "End", // PANGO_ELLIPSIZE_END
11700 pdata = g_new0 (ProgressData, 1);
11702 if (!pdata->window)
11704 pdata->window = gtk_dialog_new ();
11706 gtk_window_set_screen (GTK_WINDOW (pdata->window),
11707 gtk_widget_get_screen (widget));
11709 gtk_window_set_resizable (GTK_WINDOW (pdata->window), TRUE);
11711 g_signal_connect (pdata->window, "destroy",
11712 G_CALLBACK (destroy_progress),
11717 gtk_window_set_title (GTK_WINDOW (pdata->window), "GtkProgressBar");
11718 gtk_container_set_border_width (GTK_CONTAINER (pdata->window), 0);
11720 vbox = gtk_vbox_new (FALSE, 5);
11721 gtk_container_set_border_width (GTK_CONTAINER (vbox), 10);
11722 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (pdata->window)->vbox),
11723 vbox, FALSE, TRUE, 0);
11725 frame = gtk_frame_new ("Progress");
11726 gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, TRUE, 0);
11728 vbox2 = gtk_vbox_new (FALSE, 5);
11729 gtk_container_add (GTK_CONTAINER (frame), vbox2);
11731 align = gtk_alignment_new (0.5, 0.5, 0, 0);
11732 gtk_box_pack_start (GTK_BOX (vbox2), align, FALSE, FALSE, 5);
11734 adj = (GtkAdjustment *) gtk_adjustment_new (0, 1, 300, 0, 0, 0);
11735 g_signal_connect (adj, "value_changed",
11736 G_CALLBACK (progress_value_changed), pdata);
11738 pdata->pbar = gtk_widget_new (GTK_TYPE_PROGRESS_BAR,
11740 "ellipsize", PANGO_ELLIPSIZE_MIDDLE,
11742 gtk_progress_set_format_string (GTK_PROGRESS (pdata->pbar),
11743 "%v from [%l,%u] (=%p%%)");
11744 gtk_container_add (GTK_CONTAINER (align), pdata->pbar);
11745 pdata->timer = gtk_timeout_add (100, progress_timeout, pdata->pbar);
11747 align = gtk_alignment_new (0.5, 0.5, 0, 0);
11748 gtk_box_pack_start (GTK_BOX (vbox2), align, FALSE, FALSE, 5);
11750 hbox = gtk_hbox_new (FALSE, 5);
11751 gtk_container_add (GTK_CONTAINER (align), hbox);
11752 label = gtk_label_new ("Label updated by user :");
11753 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
11754 pdata->label = gtk_label_new ("");
11755 gtk_box_pack_start (GTK_BOX (hbox), pdata->label, FALSE, TRUE, 0);
11757 frame = gtk_frame_new ("Options");
11758 gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, TRUE, 0);
11760 vbox2 = gtk_vbox_new (FALSE, 5);
11761 gtk_container_add (GTK_CONTAINER (frame), vbox2);
11763 tab = gtk_table_new (7, 2, FALSE);
11764 gtk_box_pack_start (GTK_BOX (vbox2), tab, FALSE, TRUE, 0);
11766 label = gtk_label_new ("Orientation :");
11767 gtk_table_attach (GTK_TABLE (tab), label, 0, 1, 0, 1,
11768 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
11770 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
11772 pdata->omenu1 = build_option_menu (items1, 4, 0,
11773 progressbar_toggle_orientation,
11775 hbox = gtk_hbox_new (FALSE, 0);
11776 gtk_table_attach (GTK_TABLE (tab), hbox, 1, 2, 0, 1,
11777 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
11779 gtk_box_pack_start (GTK_BOX (hbox), pdata->omenu1, TRUE, TRUE, 0);
11781 check = gtk_check_button_new_with_label ("Show text");
11782 g_signal_connect (check, "clicked",
11783 G_CALLBACK (toggle_show_text),
11785 gtk_table_attach (GTK_TABLE (tab), check, 0, 1, 1, 2,
11786 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
11789 hbox = gtk_hbox_new (FALSE, 0);
11790 gtk_table_attach (GTK_TABLE (tab), hbox, 1, 2, 1, 2,
11791 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
11794 label = gtk_label_new ("Format : ");
11795 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
11797 pdata->entry = gtk_entry_new ();
11798 g_signal_connect (pdata->entry, "changed",
11799 G_CALLBACK (entry_changed),
11801 gtk_box_pack_start (GTK_BOX (hbox), pdata->entry, TRUE, TRUE, 0);
11802 gtk_entry_set_text (GTK_ENTRY (pdata->entry), "%v from [%l,%u] (=%p%%)");
11803 gtk_widget_set_size_request (pdata->entry, 100, -1);
11804 gtk_widget_set_sensitive (pdata->entry, FALSE);
11806 label = gtk_label_new ("Text align :");
11807 gtk_table_attach (GTK_TABLE (tab), label, 0, 1, 2, 3,
11808 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
11810 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
11812 hbox = gtk_hbox_new (FALSE, 0);
11813 gtk_table_attach (GTK_TABLE (tab), hbox, 1, 2, 2, 3,
11814 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
11817 label = gtk_label_new ("x :");
11818 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 5);
11820 adj = (GtkAdjustment *) gtk_adjustment_new (0.5, 0, 1, 0.1, 0.1, 0);
11821 pdata->x_align_spin = gtk_spin_button_new (adj, 0, 1);
11822 g_signal_connect (adj, "value_changed",
11823 G_CALLBACK (adjust_align), pdata);
11824 gtk_box_pack_start (GTK_BOX (hbox), pdata->x_align_spin, FALSE, TRUE, 0);
11825 gtk_widget_set_sensitive (pdata->x_align_spin, FALSE);
11827 label = gtk_label_new ("y :");
11828 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 5);
11830 adj = (GtkAdjustment *) gtk_adjustment_new (0.5, 0, 1, 0.1, 0.1, 0);
11831 pdata->y_align_spin = gtk_spin_button_new (adj, 0, 1);
11832 g_signal_connect (adj, "value_changed",
11833 G_CALLBACK (adjust_align), pdata);
11834 gtk_box_pack_start (GTK_BOX (hbox), pdata->y_align_spin, FALSE, TRUE, 0);
11835 gtk_widget_set_sensitive (pdata->y_align_spin, FALSE);
11837 label = gtk_label_new ("Ellipsize text :");
11838 gtk_table_attach (GTK_TABLE (tab), label, 0, 1, 10, 11,
11839 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
11841 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
11842 pdata->elmenu = build_option_menu (ellipsize_items,
11843 sizeof (ellipsize_items) / sizeof (ellipsize_items[0]),
11844 2, // PANGO_ELLIPSIZE_MIDDLE
11845 progressbar_toggle_ellipsize,
11847 hbox = gtk_hbox_new (FALSE, 0);
11848 gtk_table_attach (GTK_TABLE (tab), hbox, 1, 2, 10, 11,
11849 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
11851 gtk_box_pack_start (GTK_BOX (hbox), pdata->elmenu, TRUE, TRUE, 0);
11853 label = gtk_label_new ("Bar Style :");
11854 gtk_table_attach (GTK_TABLE (tab), label, 0, 1, 13, 14,
11855 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
11857 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
11859 pdata->omenu2 = build_option_menu (items2, 2, 0,
11860 progressbar_toggle_bar_style,
11862 hbox = gtk_hbox_new (FALSE, 0);
11863 gtk_table_attach (GTK_TABLE (tab), hbox, 1, 2, 13, 14,
11864 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
11866 gtk_box_pack_start (GTK_BOX (hbox), pdata->omenu2, TRUE, TRUE, 0);
11868 label = gtk_label_new ("Block count :");
11869 gtk_table_attach (GTK_TABLE (tab), label, 0, 1, 14, 15,
11870 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
11872 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
11874 hbox = gtk_hbox_new (FALSE, 0);
11875 gtk_table_attach (GTK_TABLE (tab), hbox, 1, 2, 14, 15,
11876 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
11878 adj = (GtkAdjustment *) gtk_adjustment_new (10, 2, 20, 1, 5, 0);
11879 pdata->block_spin = gtk_spin_button_new (adj, 0, 0);
11880 g_signal_connect (adj, "value_changed",
11881 G_CALLBACK (adjust_blocks), pdata);
11882 gtk_box_pack_start (GTK_BOX (hbox), pdata->block_spin, FALSE, TRUE, 0);
11883 gtk_widget_set_sensitive (pdata->block_spin, FALSE);
11885 check = gtk_check_button_new_with_label ("Activity mode");
11886 g_signal_connect (check, "clicked",
11887 G_CALLBACK (toggle_activity_mode), pdata);
11888 gtk_table_attach (GTK_TABLE (tab), check, 0, 1, 15, 16,
11889 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
11892 hbox = gtk_hbox_new (FALSE, 0);
11893 gtk_table_attach (GTK_TABLE (tab), hbox, 1, 2, 15, 16,
11894 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
11896 label = gtk_label_new ("Step size : ");
11897 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
11898 adj = (GtkAdjustment *) gtk_adjustment_new (3, 1, 20, 1, 5, 0);
11899 pdata->step_spin = gtk_spin_button_new (adj, 0, 0);
11900 g_signal_connect (adj, "value_changed",
11901 G_CALLBACK (adjust_step), pdata);
11902 gtk_box_pack_start (GTK_BOX (hbox), pdata->step_spin, FALSE, TRUE, 0);
11903 gtk_widget_set_sensitive (pdata->step_spin, FALSE);
11905 hbox = gtk_hbox_new (FALSE, 0);
11906 gtk_table_attach (GTK_TABLE (tab), hbox, 1, 2, 16, 17,
11907 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
11909 label = gtk_label_new ("Blocks : ");
11910 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
11911 adj = (GtkAdjustment *) gtk_adjustment_new (5, 2, 10, 1, 5, 0);
11912 pdata->act_blocks_spin = gtk_spin_button_new (adj, 0, 0);
11913 g_signal_connect (adj, "value_changed",
11914 G_CALLBACK (adjust_act_blocks), pdata);
11915 gtk_box_pack_start (GTK_BOX (hbox), pdata->act_blocks_spin, FALSE, TRUE,
11917 gtk_widget_set_sensitive (pdata->act_blocks_spin, FALSE);
11919 button = gtk_button_new_with_label ("close");
11920 g_signal_connect_swapped (button, "clicked",
11921 G_CALLBACK (gtk_widget_destroy),
11923 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
11924 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (pdata->window)->action_area),
11925 button, TRUE, TRUE, 0);
11926 gtk_widget_grab_default (button);
11929 if (!GTK_WIDGET_VISIBLE (pdata->window))
11930 gtk_widget_show_all (pdata->window);
11932 gtk_widget_destroy (pdata->window);
11944 GtkWidget *res_widget;
11948 find_widget (GtkWidget *widget, FindWidgetData *data)
11950 GtkAllocation new_allocation;
11954 new_allocation = widget->allocation;
11956 if (data->found || !GTK_WIDGET_MAPPED (widget))
11959 /* Note that in the following code, we only count the
11960 * position as being inside a WINDOW widget if it is inside
11961 * widget->window; points that are outside of widget->window
11962 * but within the allocation are not counted. This is consistent
11963 * with the way we highlight drag targets.
11965 if (!GTK_WIDGET_NO_WINDOW (widget))
11967 new_allocation.x = 0;
11968 new_allocation.y = 0;
11971 if (widget->parent && !data->first)
11973 GdkWindow *window = widget->window;
11974 while (window != widget->parent->window)
11976 gint tx, ty, twidth, theight;
11977 gdk_drawable_get_size (window, &twidth, &theight);
11979 if (new_allocation.x < 0)
11981 new_allocation.width += new_allocation.x;
11982 new_allocation.x = 0;
11984 if (new_allocation.y < 0)
11986 new_allocation.height += new_allocation.y;
11987 new_allocation.y = 0;
11989 if (new_allocation.x + new_allocation.width > twidth)
11990 new_allocation.width = twidth - new_allocation.x;
11991 if (new_allocation.y + new_allocation.height > theight)
11992 new_allocation.height = theight - new_allocation.y;
11994 gdk_window_get_position (window, &tx, &ty);
11995 new_allocation.x += tx;
11997 new_allocation.y += ty;
12000 window = gdk_window_get_parent (window);
12004 if ((data->x >= new_allocation.x) && (data->y >= new_allocation.y) &&
12005 (data->x < new_allocation.x + new_allocation.width) &&
12006 (data->y < new_allocation.y + new_allocation.height))
12008 /* First, check if the drag is in a valid drop site in
12009 * one of our children
12011 if (GTK_IS_CONTAINER (widget))
12013 FindWidgetData new_data = *data;
12015 new_data.x -= x_offset;
12016 new_data.y -= y_offset;
12017 new_data.found = FALSE;
12018 new_data.first = FALSE;
12020 gtk_container_forall (GTK_CONTAINER (widget),
12021 (GtkCallback)find_widget,
12024 data->found = new_data.found;
12026 data->res_widget = new_data.res_widget;
12029 /* If not, and this widget is registered as a drop site, check to
12030 * emit "drag_motion" to check if we are actually in
12035 data->found = TRUE;
12036 data->res_widget = widget;
12042 find_widget_at_pointer (GdkDisplay *display)
12044 GtkWidget *widget = NULL;
12045 GdkWindow *pointer_window;
12047 FindWidgetData data;
12049 pointer_window = gdk_display_get_window_at_pointer (display, NULL, NULL);
12051 if (pointer_window)
12052 gdk_window_get_user_data (pointer_window, (gpointer) &widget);
12056 gdk_window_get_pointer (widget->window,
12061 data.found = FALSE;
12064 find_widget (widget, &data);
12066 return data.res_widget;
12072 struct PropertiesData {
12073 GtkWidget **window;
12080 destroy_properties (GtkWidget *widget,
12081 struct PropertiesData *data)
12085 *data->window = NULL;
12086 data->window = NULL;
12091 gdk_cursor_unref (data->cursor);
12092 data->cursor = NULL;
12097 g_signal_handler_disconnect (widget, data->handler);
12105 property_query_event (GtkWidget *widget,
12107 struct PropertiesData *data)
12109 GtkWidget *res_widget = NULL;
12111 if (!data->in_query)
12114 if (event->type == GDK_BUTTON_RELEASE)
12116 gtk_grab_remove (widget);
12117 gdk_display_pointer_ungrab (gtk_widget_get_display (widget),
12120 res_widget = find_widget_at_pointer (gtk_widget_get_display (widget));
12123 g_object_set_data (G_OBJECT (res_widget), "prop-editor-screen",
12124 gtk_widget_get_screen (widget));
12125 create_prop_editor (G_OBJECT (res_widget), 0);
12128 data->in_query = FALSE;
12135 query_properties (GtkButton *button,
12136 struct PropertiesData *data)
12140 g_signal_connect (button, "event",
12141 G_CALLBACK (property_query_event), data);
12145 data->cursor = gdk_cursor_new_for_display (gtk_widget_get_display (GTK_WIDGET (button)),
12148 failure = gdk_pointer_grab (GTK_WIDGET (button)->window,
12150 GDK_BUTTON_RELEASE_MASK,
12155 gtk_grab_add (GTK_WIDGET (button));
12157 data->in_query = TRUE;
12161 create_properties (GtkWidget *widget)
12163 static GtkWidget *window = NULL;
12167 struct PropertiesData *data;
12169 data = g_new (struct PropertiesData, 1);
12170 data->window = &window;
12171 data->in_query = FALSE;
12172 data->cursor = NULL;
12177 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
12179 gtk_window_set_screen (GTK_WINDOW (window),
12180 gtk_widget_get_screen (widget));
12182 data->handler = g_signal_connect (window, "destroy",
12183 G_CALLBACK (destroy_properties),
12186 gtk_window_set_title (GTK_WINDOW (window), "test properties");
12187 gtk_container_set_border_width (GTK_CONTAINER (window), 10);
12189 vbox = gtk_vbox_new (FALSE, 1);
12190 gtk_container_add (GTK_CONTAINER (window), vbox);
12192 label = gtk_label_new ("This is just a dumb test to test properties.\nIf you need a generic module, get GLE.");
12193 gtk_box_pack_start (GTK_BOX (vbox), label, TRUE, TRUE, 0);
12195 button = gtk_button_new_with_label ("Query properties");
12196 gtk_box_pack_start (GTK_BOX (vbox), button, TRUE, TRUE, 0);
12197 g_signal_connect (button, "clicked",
12198 G_CALLBACK (query_properties),
12202 if (!GTK_WIDGET_VISIBLE (window))
12203 gtk_widget_show_all (window);
12205 gtk_widget_destroy (window);
12214 static int color_idle = 0;
12217 color_idle_func (GtkWidget *preview)
12219 static int count = 1;
12223 for (i = 0; i < 256; i++)
12225 for (j = 0, k = 0; j < 256; j++)
12227 buf[k+0] = i + count;
12229 buf[k+2] = j + count;
12233 gtk_preview_draw_row (GTK_PREVIEW (preview), buf, 0, i, 256);
12238 gtk_widget_queue_draw (preview);
12239 gdk_window_process_updates (preview->window, TRUE);
12245 color_preview_destroy (GtkWidget *widget,
12246 GtkWidget **window)
12248 gtk_idle_remove (color_idle);
12255 create_color_preview (GtkWidget *widget)
12257 static GtkWidget *window = NULL;
12258 GtkWidget *preview;
12264 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
12266 gtk_window_set_screen (GTK_WINDOW (window),
12267 gtk_widget_get_screen (widget));
12269 g_signal_connect (window, "destroy",
12270 G_CALLBACK (color_preview_destroy),
12273 gtk_window_set_title (GTK_WINDOW (window), "test");
12274 gtk_container_set_border_width (GTK_CONTAINER (window), 10);
12276 preview = gtk_preview_new (GTK_PREVIEW_COLOR);
12277 gtk_preview_size (GTK_PREVIEW (preview), 256, 256);
12278 gtk_container_add (GTK_CONTAINER (window), preview);
12280 for (i = 0; i < 256; i++)
12282 for (j = 0, k = 0; j < 256; j++)
12290 gtk_preview_draw_row (GTK_PREVIEW (preview), buf, 0, i, 256);
12293 color_idle = gtk_idle_add ((GtkFunction) color_idle_func, preview);
12296 if (!GTK_WIDGET_VISIBLE (window))
12297 gtk_widget_show_all (window);
12299 gtk_widget_destroy (window);
12306 static int gray_idle = 0;
12309 gray_idle_func (GtkWidget *preview)
12311 static int count = 1;
12315 for (i = 0; i < 256; i++)
12317 for (j = 0; j < 256; j++)
12318 buf[j] = i + j + count;
12320 gtk_preview_draw_row (GTK_PREVIEW (preview), buf, 0, i, 256);
12325 gtk_widget_draw (preview, NULL);
12331 gray_preview_destroy (GtkWidget *widget,
12332 GtkWidget **window)
12334 gtk_idle_remove (gray_idle);
12341 create_gray_preview (GtkWidget *widget)
12343 static GtkWidget *window = NULL;
12344 GtkWidget *preview;
12350 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
12352 gtk_window_set_screen (GTK_WINDOW (window),
12353 gtk_widget_get_screen (widget));
12355 g_signal_connect (window, "destroy",
12356 G_CALLBACK (gray_preview_destroy),
12359 gtk_window_set_title (GTK_WINDOW (window), "test");
12360 gtk_container_set_border_width (GTK_CONTAINER (window), 10);
12362 preview = gtk_preview_new (GTK_PREVIEW_GRAYSCALE);
12363 gtk_preview_size (GTK_PREVIEW (preview), 256, 256);
12364 gtk_container_add (GTK_CONTAINER (window), preview);
12366 for (i = 0; i < 256; i++)
12368 for (j = 0; j < 256; j++)
12371 gtk_preview_draw_row (GTK_PREVIEW (preview), buf, 0, i, 256);
12374 gray_idle = gtk_idle_add ((GtkFunction) gray_idle_func, preview);
12377 if (!GTK_WIDGET_VISIBLE (window))
12378 gtk_widget_show_all (window);
12380 gtk_widget_destroy (window);
12389 selection_test_received (GtkWidget *list, GtkSelectionData *data)
12392 GtkWidget *list_item;
12396 if (data->length < 0)
12398 g_print ("Selection retrieval failed\n");
12401 if (data->type != GDK_SELECTION_TYPE_ATOM)
12403 g_print ("Selection \"TARGETS\" was not returned as atoms!\n");
12407 /* Clear out any current list items */
12409 gtk_list_clear_items (GTK_LIST(list), 0, -1);
12411 /* Add new items to list */
12413 atoms = (GdkAtom *)data->data;
12416 l = data->length / sizeof (GdkAtom);
12417 for (i = 0; i < l; i++)
12420 name = gdk_atom_name (atoms[i]);
12423 list_item = gtk_list_item_new_with_label (name);
12427 list_item = gtk_list_item_new_with_label ("(bad atom)");
12429 gtk_widget_show (list_item);
12430 item_list = g_list_append (item_list, list_item);
12433 gtk_list_append_items (GTK_LIST (list), item_list);
12439 selection_test_get_targets (GtkWidget *widget, GtkWidget *list)
12441 static GdkAtom targets_atom = GDK_NONE;
12443 if (targets_atom == GDK_NONE)
12444 targets_atom = gdk_atom_intern ("TARGETS", FALSE);
12446 gtk_selection_convert (list, GDK_SELECTION_PRIMARY, targets_atom,
12451 create_selection_test (GtkWidget *widget)
12453 static GtkWidget *window = NULL;
12456 GtkWidget *scrolled_win;
12462 window = gtk_dialog_new ();
12464 gtk_window_set_screen (GTK_WINDOW (window),
12465 gtk_widget_get_screen (widget));
12467 g_signal_connect (window, "destroy",
12468 G_CALLBACK (gtk_widget_destroyed),
12471 gtk_window_set_title (GTK_WINDOW (window), "Selection Test");
12472 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
12474 /* Create the list */
12476 vbox = gtk_vbox_new (FALSE, 5);
12477 gtk_container_set_border_width (GTK_CONTAINER (vbox), 10);
12478 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), vbox,
12481 label = gtk_label_new ("Gets available targets for current selection");
12482 gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
12484 scrolled_win = gtk_scrolled_window_new (NULL, NULL);
12485 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
12486 GTK_POLICY_AUTOMATIC,
12487 GTK_POLICY_AUTOMATIC);
12488 gtk_box_pack_start (GTK_BOX (vbox), scrolled_win, TRUE, TRUE, 0);
12489 gtk_widget_set_size_request (scrolled_win, 100, 200);
12491 list = gtk_list_new ();
12492 gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (scrolled_win), list);
12494 g_signal_connect (list, "selection_received",
12495 G_CALLBACK (selection_test_received), NULL);
12497 /* .. And create some buttons */
12498 button = gtk_button_new_with_label ("Get Targets");
12499 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
12500 button, TRUE, TRUE, 0);
12502 g_signal_connect (button, "clicked",
12503 G_CALLBACK (selection_test_get_targets), list);
12505 button = gtk_button_new_with_label ("Quit");
12506 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
12507 button, TRUE, TRUE, 0);
12509 g_signal_connect_swapped (button, "clicked",
12510 G_CALLBACK (gtk_widget_destroy),
12514 if (!GTK_WIDGET_VISIBLE (window))
12515 gtk_widget_show_all (window);
12517 gtk_widget_destroy (window);
12525 create_gamma_curve (GtkWidget *widget)
12527 static GtkWidget *window = NULL, *curve;
12528 static int count = 0;
12535 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
12536 gtk_window_set_screen (GTK_WINDOW (window),
12537 gtk_widget_get_screen (widget));
12539 gtk_window_set_title (GTK_WINDOW (window), "test");
12540 gtk_container_set_border_width (GTK_CONTAINER (window), 10);
12542 g_signal_connect (window, "destroy",
12543 G_CALLBACK(gtk_widget_destroyed),
12546 curve = gtk_gamma_curve_new ();
12547 gtk_container_add (GTK_CONTAINER (window), curve);
12548 gtk_widget_show (curve);
12551 max = 127 + (count % 2)*128;
12552 gtk_curve_set_range (GTK_CURVE (GTK_GAMMA_CURVE (curve)->curve),
12554 for (i = 0; i < max; ++i)
12555 vec[i] = (127 / sqrt (max)) * sqrt (i);
12556 gtk_curve_set_vector (GTK_CURVE (GTK_GAMMA_CURVE (curve)->curve),
12559 if (!GTK_WIDGET_VISIBLE (window))
12560 gtk_widget_show (window);
12561 else if (count % 4 == 3)
12563 gtk_widget_destroy (window);
12574 static int scroll_test_pos = 0.0;
12577 scroll_test_expose (GtkWidget *widget, GdkEventExpose *event,
12578 GtkAdjustment *adj)
12581 gint imin, imax, jmin, jmax;
12583 imin = (event->area.x) / 10;
12584 imax = (event->area.x + event->area.width + 9) / 10;
12586 jmin = ((int)adj->value + event->area.y) / 10;
12587 jmax = ((int)adj->value + event->area.y + event->area.height + 9) / 10;
12589 gdk_window_clear_area (widget->window,
12590 event->area.x, event->area.y,
12591 event->area.width, event->area.height);
12593 for (i=imin; i<imax; i++)
12594 for (j=jmin; j<jmax; j++)
12596 gdk_draw_rectangle (widget->window,
12597 widget->style->black_gc,
12599 10*i, 10*j - (int)adj->value, 1+i%10, 1+j%10);
12605 scroll_test_scroll (GtkWidget *widget, GdkEventScroll *event,
12606 GtkAdjustment *adj)
12608 gdouble new_value = adj->value + ((event->direction == GDK_SCROLL_UP) ?
12609 -adj->page_increment / 2:
12610 adj->page_increment / 2);
12611 new_value = CLAMP (new_value, adj->lower, adj->upper - adj->page_size);
12612 gtk_adjustment_set_value (adj, new_value);
12618 scroll_test_configure (GtkWidget *widget, GdkEventConfigure *event,
12619 GtkAdjustment *adj)
12621 adj->page_increment = 0.9 * widget->allocation.height;
12622 adj->page_size = widget->allocation.height;
12624 g_signal_emit_by_name (adj, "changed");
12628 scroll_test_adjustment_changed (GtkAdjustment *adj, GtkWidget *widget)
12630 /* gint source_min = (int)adj->value - scroll_test_pos; */
12633 dy = scroll_test_pos - (int)adj->value;
12634 scroll_test_pos = adj->value;
12636 if (!GTK_WIDGET_DRAWABLE (widget))
12638 gdk_window_scroll (widget->window, 0, dy);
12639 gdk_window_process_updates (widget->window, FALSE);
12644 create_scroll_test (GtkWidget *widget)
12646 static GtkWidget *window = NULL;
12648 GtkWidget *drawing_area;
12649 GtkWidget *scrollbar;
12651 GtkAdjustment *adj;
12652 GdkGeometry geometry;
12653 GdkWindowHints geometry_mask;
12657 window = gtk_dialog_new ();
12659 gtk_window_set_screen (GTK_WINDOW (window),
12660 gtk_widget_get_screen (widget));
12662 g_signal_connect (window, "destroy",
12663 G_CALLBACK (gtk_widget_destroyed),
12666 gtk_window_set_title (GTK_WINDOW (window), "Scroll Test");
12667 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
12669 hbox = gtk_hbox_new (FALSE, 0);
12670 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), hbox,
12672 gtk_widget_show (hbox);
12674 drawing_area = gtk_drawing_area_new ();
12675 gtk_widget_set_size_request (drawing_area, 200, 200);
12676 gtk_box_pack_start (GTK_BOX (hbox), drawing_area, TRUE, TRUE, 0);
12677 gtk_widget_show (drawing_area);
12679 gtk_widget_set_events (drawing_area, GDK_EXPOSURE_MASK | GDK_SCROLL_MASK);
12681 adj = GTK_ADJUSTMENT (gtk_adjustment_new (0.0, 0.0, 1000.0, 1.0, 180.0, 200.0));
12682 scroll_test_pos = 0.0;
12684 scrollbar = gtk_vscrollbar_new (adj);
12685 gtk_box_pack_start (GTK_BOX (hbox), scrollbar, FALSE, FALSE, 0);
12686 gtk_widget_show (scrollbar);
12688 g_signal_connect (drawing_area, "expose_event",
12689 G_CALLBACK (scroll_test_expose), adj);
12690 g_signal_connect (drawing_area, "configure_event",
12691 G_CALLBACK (scroll_test_configure), adj);
12692 g_signal_connect (drawing_area, "scroll_event",
12693 G_CALLBACK (scroll_test_scroll), adj);
12695 g_signal_connect (adj, "value_changed",
12696 G_CALLBACK (scroll_test_adjustment_changed),
12699 /* .. And create some buttons */
12701 button = gtk_button_new_with_label ("Quit");
12702 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
12703 button, TRUE, TRUE, 0);
12705 g_signal_connect_swapped (button, "clicked",
12706 G_CALLBACK (gtk_widget_destroy),
12708 gtk_widget_show (button);
12710 /* Set up gridded geometry */
12712 geometry_mask = GDK_HINT_MIN_SIZE |
12713 GDK_HINT_BASE_SIZE |
12714 GDK_HINT_RESIZE_INC;
12716 geometry.min_width = 20;
12717 geometry.min_height = 20;
12718 geometry.base_width = 0;
12719 geometry.base_height = 0;
12720 geometry.width_inc = 10;
12721 geometry.height_inc = 10;
12723 gtk_window_set_geometry_hints (GTK_WINDOW (window),
12724 drawing_area, &geometry, geometry_mask);
12727 if (!GTK_WIDGET_VISIBLE (window))
12728 gtk_widget_show (window);
12730 gtk_widget_destroy (window);
12737 static int timer = 0;
12740 timeout_test (GtkWidget *label)
12742 static int count = 0;
12743 static char buffer[32];
12745 sprintf (buffer, "count: %d", ++count);
12746 gtk_label_set_text (GTK_LABEL (label), buffer);
12752 start_timeout_test (GtkWidget *widget,
12757 timer = gtk_timeout_add (100, (GtkFunction) timeout_test, label);
12762 stop_timeout_test (GtkWidget *widget,
12767 gtk_timeout_remove (timer);
12773 destroy_timeout_test (GtkWidget *widget,
12774 GtkWidget **window)
12776 stop_timeout_test (NULL, NULL);
12782 create_timeout_test (GtkWidget *widget)
12784 static GtkWidget *window = NULL;
12790 window = gtk_dialog_new ();
12792 gtk_window_set_screen (GTK_WINDOW (window),
12793 gtk_widget_get_screen (widget));
12795 g_signal_connect (window, "destroy",
12796 G_CALLBACK (destroy_timeout_test),
12799 gtk_window_set_title (GTK_WINDOW (window), "Timeout Test");
12800 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
12802 label = gtk_label_new ("count: 0");
12803 gtk_misc_set_padding (GTK_MISC (label), 10, 10);
12804 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox),
12805 label, TRUE, TRUE, 0);
12806 gtk_widget_show (label);
12808 button = gtk_button_new_with_label ("close");
12809 g_signal_connect_swapped (button, "clicked",
12810 G_CALLBACK (gtk_widget_destroy),
12812 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
12813 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
12814 button, TRUE, TRUE, 0);
12815 gtk_widget_grab_default (button);
12816 gtk_widget_show (button);
12818 button = gtk_button_new_with_label ("start");
12819 g_signal_connect (button, "clicked",
12820 G_CALLBACK(start_timeout_test),
12822 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
12823 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
12824 button, TRUE, TRUE, 0);
12825 gtk_widget_show (button);
12827 button = gtk_button_new_with_label ("stop");
12828 g_signal_connect (button, "clicked",
12829 G_CALLBACK (stop_timeout_test),
12831 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
12832 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
12833 button, TRUE, TRUE, 0);
12834 gtk_widget_show (button);
12837 if (!GTK_WIDGET_VISIBLE (window))
12838 gtk_widget_show (window);
12840 gtk_widget_destroy (window);
12847 static int idle_id = 0;
12850 idle_test (GtkWidget *label)
12852 static int count = 0;
12853 static char buffer[32];
12855 sprintf (buffer, "count: %d", ++count);
12856 gtk_label_set_text (GTK_LABEL (label), buffer);
12862 start_idle_test (GtkWidget *widget,
12867 idle_id = gtk_idle_add ((GtkFunction) idle_test, label);
12872 stop_idle_test (GtkWidget *widget,
12877 gtk_idle_remove (idle_id);
12883 destroy_idle_test (GtkWidget *widget,
12884 GtkWidget **window)
12886 stop_idle_test (NULL, NULL);
12892 toggle_idle_container (GObject *button,
12893 GtkContainer *container)
12895 gtk_container_set_resize_mode (container, GPOINTER_TO_INT (g_object_get_data (button, "user_data")));
12899 create_idle_test (GtkWidget *widget)
12901 static GtkWidget *window = NULL;
12904 GtkWidget *container;
12908 GtkWidget *button2;
12912 window = gtk_dialog_new ();
12914 gtk_window_set_screen (GTK_WINDOW (window),
12915 gtk_widget_get_screen (widget));
12917 g_signal_connect (window, "destroy",
12918 G_CALLBACK (destroy_idle_test),
12921 gtk_window_set_title (GTK_WINDOW (window), "Idle Test");
12922 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
12924 label = gtk_label_new ("count: 0");
12925 gtk_misc_set_padding (GTK_MISC (label), 10, 10);
12926 gtk_widget_show (label);
12929 gtk_widget_new (GTK_TYPE_HBOX,
12931 /* "GtkContainer::child", gtk_widget_new (GTK_TYPE_HBOX,
12932 * "GtkWidget::visible", TRUE,
12937 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox),
12938 container, TRUE, TRUE, 0);
12941 gtk_widget_new (GTK_TYPE_FRAME,
12943 "label", "Label Container",
12945 "parent", GTK_DIALOG (window)->vbox,
12948 gtk_widget_new (GTK_TYPE_VBOX,
12953 g_object_connect (gtk_widget_new (GTK_TYPE_RADIO_BUTTON,
12954 "label", "Resize-Parent",
12955 "user_data", (void*)GTK_RESIZE_PARENT,
12959 "signal::clicked", toggle_idle_container, container,
12961 button = gtk_widget_new (GTK_TYPE_RADIO_BUTTON,
12962 "label", "Resize-Queue",
12963 "user_data", (void*)GTK_RESIZE_QUEUE,
12968 g_object_connect (button,
12969 "signal::clicked", toggle_idle_container, container,
12971 button2 = gtk_widget_new (GTK_TYPE_RADIO_BUTTON,
12972 "label", "Resize-Immediate",
12973 "user_data", (void*)GTK_RESIZE_IMMEDIATE,
12975 g_object_connect (button2,
12976 "signal::clicked", toggle_idle_container, container,
12978 g_object_set (button2,
12984 button = gtk_button_new_with_label ("close");
12985 g_signal_connect_swapped (button, "clicked",
12986 G_CALLBACK (gtk_widget_destroy),
12988 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
12989 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
12990 button, TRUE, TRUE, 0);
12991 gtk_widget_grab_default (button);
12992 gtk_widget_show (button);
12994 button = gtk_button_new_with_label ("start");
12995 g_signal_connect (button, "clicked",
12996 G_CALLBACK (start_idle_test),
12998 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
12999 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
13000 button, TRUE, TRUE, 0);
13001 gtk_widget_show (button);
13003 button = gtk_button_new_with_label ("stop");
13004 g_signal_connect (button, "clicked",
13005 G_CALLBACK (stop_idle_test),
13007 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
13008 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
13009 button, TRUE, TRUE, 0);
13010 gtk_widget_show (button);
13013 if (!GTK_WIDGET_VISIBLE (window))
13014 gtk_widget_show (window);
13016 gtk_widget_destroy (window);
13024 reload_all_rc_files (void)
13026 static GdkAtom atom_rcfiles = GDK_NONE;
13028 GdkEvent *send_event = gdk_event_new (GDK_CLIENT_EVENT);
13032 atom_rcfiles = gdk_atom_intern("_GTK_READ_RCFILES", FALSE);
13034 for(i = 0; i < 5; i++)
13035 send_event->client.data.l[i] = 0;
13036 send_event->client.data_format = 32;
13037 send_event->client.message_type = atom_rcfiles;
13038 gdk_event_send_clientmessage_toall (send_event);
13040 gdk_event_free (send_event);
13044 create_rc_file (GtkWidget *widget)
13046 static GtkWidget *window = NULL;
13054 window = gtk_dialog_new ();
13056 gtk_window_set_screen (GTK_WINDOW (window),
13057 gtk_widget_get_screen (widget));
13059 g_signal_connect (window, "destroy",
13060 G_CALLBACK (gtk_widget_destroyed),
13063 frame = gtk_aspect_frame_new ("Testing RC file prioritization", 0.5, 0.5, 0.0, TRUE);
13064 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), frame, FALSE, FALSE, 0);
13066 vbox = gtk_vbox_new (FALSE, 0);
13067 gtk_container_add (GTK_CONTAINER (frame), vbox);
13069 label = gtk_label_new ("This label should be red");
13070 gtk_widget_set_name (label, "testgtk-red-label");
13071 gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
13073 label = gtk_label_new ("This label should be green");
13074 gtk_widget_set_name (label, "testgtk-green-label");
13075 gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
13077 label = gtk_label_new ("This label should be blue");
13078 gtk_widget_set_name (label, "testgtk-blue-label");
13079 gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
13081 gtk_window_set_title (GTK_WINDOW (window), "Reload Rc file");
13082 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
13084 button = gtk_button_new_with_label ("Reload");
13085 g_signal_connect (button, "clicked",
13086 G_CALLBACK (gtk_rc_reparse_all), NULL);
13087 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
13088 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
13089 button, TRUE, TRUE, 0);
13090 gtk_widget_grab_default (button);
13092 button = gtk_button_new_with_label ("Reload All");
13093 g_signal_connect (button, "clicked",
13094 G_CALLBACK (reload_all_rc_files), NULL);
13095 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
13096 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
13097 button, TRUE, TRUE, 0);
13099 button = gtk_button_new_with_label ("Close");
13100 g_signal_connect_swapped (button, "clicked",
13101 G_CALLBACK (gtk_widget_destroy),
13103 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
13104 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
13105 button, TRUE, TRUE, 0);
13108 if (!GTK_WIDGET_VISIBLE (window))
13109 gtk_widget_show_all (window);
13111 gtk_widget_destroy (window);
13115 * Test of recursive mainloop
13119 mainloop_destroyed (GtkWidget *w, GtkWidget **window)
13126 create_mainloop (GtkWidget *widget)
13128 static GtkWidget *window = NULL;
13134 window = gtk_dialog_new ();
13136 gtk_window_set_screen (GTK_WINDOW (window),
13137 gtk_widget_get_screen (widget));
13139 gtk_window_set_title (GTK_WINDOW (window), "Test Main Loop");
13141 g_signal_connect (window, "destroy",
13142 G_CALLBACK (mainloop_destroyed),
13145 label = gtk_label_new ("In recursive main loop...");
13146 gtk_misc_set_padding (GTK_MISC(label), 20, 20);
13148 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), label,
13150 gtk_widget_show (label);
13152 button = gtk_button_new_with_label ("Leave");
13153 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area), button,
13156 g_signal_connect_swapped (button, "clicked",
13157 G_CALLBACK (gtk_widget_destroy),
13160 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
13161 gtk_widget_grab_default (button);
13163 gtk_widget_show (button);
13166 if (!GTK_WIDGET_VISIBLE (window))
13168 gtk_widget_show (window);
13170 g_print ("create_mainloop: start\n");
13172 g_print ("create_mainloop: done\n");
13175 gtk_widget_destroy (window);
13179 layout_expose_handler (GtkWidget *widget, GdkEventExpose *event)
13184 gint imin, imax, jmin, jmax;
13186 layout = GTK_LAYOUT (widget);
13188 if (event->window != layout->bin_window)
13191 imin = (event->area.x) / 10;
13192 imax = (event->area.x + event->area.width + 9) / 10;
13194 jmin = (event->area.y) / 10;
13195 jmax = (event->area.y + event->area.height + 9) / 10;
13197 for (i=imin; i<imax; i++)
13198 for (j=jmin; j<jmax; j++)
13200 gdk_draw_rectangle (layout->bin_window,
13201 widget->style->black_gc,
13209 void create_layout (GtkWidget *widget)
13211 static GtkWidget *window = NULL;
13213 GtkWidget *scrolledwindow;
13222 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
13223 gtk_window_set_screen (GTK_WINDOW (window),
13224 gtk_widget_get_screen (widget));
13226 g_signal_connect (window, "destroy",
13227 G_CALLBACK (gtk_widget_destroyed),
13230 gtk_window_set_title (GTK_WINDOW (window), "Layout");
13231 gtk_widget_set_size_request (window, 200, 200);
13233 scrolledwindow = gtk_scrolled_window_new (NULL, NULL);
13234 gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolledwindow),
13236 gtk_scrolled_window_set_placement (GTK_SCROLLED_WINDOW (scrolledwindow),
13237 GTK_CORNER_TOP_RIGHT);
13239 gtk_container_add (GTK_CONTAINER (window), scrolledwindow);
13241 layout = gtk_layout_new (NULL, NULL);
13242 gtk_container_add (GTK_CONTAINER (scrolledwindow), layout);
13244 /* We set step sizes here since GtkLayout does not set
13247 GTK_LAYOUT (layout)->hadjustment->step_increment = 10.0;
13248 GTK_LAYOUT (layout)->vadjustment->step_increment = 10.0;
13250 gtk_widget_set_events (layout, GDK_EXPOSURE_MASK);
13251 g_signal_connect (layout, "expose_event",
13252 G_CALLBACK (layout_expose_handler), NULL);
13254 gtk_layout_set_size (GTK_LAYOUT (layout), 1600, 128000);
13256 for (i=0 ; i < 16 ; i++)
13257 for (j=0 ; j < 16 ; j++)
13259 sprintf(buf, "Button %d, %d", i, j);
13261 button = gtk_button_new_with_label (buf);
13263 button = gtk_label_new (buf);
13265 gtk_layout_put (GTK_LAYOUT (layout), button,
13269 for (i=16; i < 1280; i++)
13271 sprintf(buf, "Button %d, %d", i, 0);
13273 button = gtk_button_new_with_label (buf);
13275 button = gtk_label_new (buf);
13277 gtk_layout_put (GTK_LAYOUT (layout), button,
13282 if (!GTK_WIDGET_VISIBLE (window))
13283 gtk_widget_show_all (window);
13285 gtk_widget_destroy (window);
13289 create_styles (GtkWidget *widget)
13291 static GtkWidget *window = NULL;
13296 static GdkColor red = { 0, 0xffff, 0, 0 };
13297 static GdkColor green = { 0, 0, 0xffff, 0 };
13298 static GdkColor blue = { 0, 0, 0, 0xffff };
13299 static GdkColor yellow = { 0, 0xffff, 0xffff, 0 };
13300 static GdkColor cyan = { 0, 0 , 0xffff, 0xffff };
13301 PangoFontDescription *font_desc;
13303 GtkRcStyle *rc_style;
13307 window = gtk_dialog_new ();
13308 gtk_window_set_screen (GTK_WINDOW (window),
13309 gtk_widget_get_screen (widget));
13311 g_signal_connect (window, "destroy",
13312 G_CALLBACK (gtk_widget_destroyed),
13316 button = gtk_button_new_with_label ("Close");
13317 g_signal_connect_swapped (button, "clicked",
13318 G_CALLBACK (gtk_widget_destroy),
13320 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
13321 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
13322 button, TRUE, TRUE, 0);
13323 gtk_widget_show (button);
13325 vbox = gtk_vbox_new (FALSE, 5);
13326 gtk_container_set_border_width (GTK_CONTAINER (vbox), 10);
13327 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), vbox, FALSE, FALSE, 0);
13329 label = gtk_label_new ("Font:");
13330 gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
13331 gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
13333 font_desc = pango_font_description_from_string ("Helvetica,Sans Oblique 18");
13335 button = gtk_button_new_with_label ("Some Text");
13336 gtk_widget_modify_font (GTK_BIN (button)->child, font_desc);
13337 gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
13339 label = gtk_label_new ("Foreground:");
13340 gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
13341 gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
13343 button = gtk_button_new_with_label ("Some Text");
13344 gtk_widget_modify_fg (GTK_BIN (button)->child, GTK_STATE_NORMAL, &red);
13345 gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
13347 label = gtk_label_new ("Background:");
13348 gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
13349 gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
13351 button = gtk_button_new_with_label ("Some Text");
13352 gtk_widget_modify_bg (button, GTK_STATE_NORMAL, &green);
13353 gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
13355 label = gtk_label_new ("Text:");
13356 gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
13357 gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
13359 entry = gtk_entry_new ();
13360 gtk_entry_set_text (GTK_ENTRY (entry), "Some Text");
13361 gtk_widget_modify_text (entry, GTK_STATE_NORMAL, &blue);
13362 gtk_box_pack_start (GTK_BOX (vbox), entry, FALSE, FALSE, 0);
13364 label = gtk_label_new ("Base:");
13365 gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
13366 gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
13368 entry = gtk_entry_new ();
13369 gtk_entry_set_text (GTK_ENTRY (entry), "Some Text");
13370 gtk_widget_modify_base (entry, GTK_STATE_NORMAL, &yellow);
13371 gtk_box_pack_start (GTK_BOX (vbox), entry, FALSE, FALSE, 0);
13373 label = gtk_label_new ("Cursor:");
13374 gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
13375 gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
13377 entry = gtk_entry_new ();
13378 gtk_entry_set_text (GTK_ENTRY (entry), "Some Text");
13379 gtk_widget_modify_cursor (entry, &red, &red);
13380 gtk_box_pack_start (GTK_BOX (vbox), entry, FALSE, FALSE, 0);
13382 label = gtk_label_new ("Multiple:");
13383 gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
13384 gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
13386 button = gtk_button_new_with_label ("Some Text");
13388 rc_style = gtk_rc_style_new ();
13390 rc_style->font_desc = pango_font_description_copy (font_desc);
13391 rc_style->color_flags[GTK_STATE_NORMAL] = GTK_RC_FG | GTK_RC_BG;
13392 rc_style->color_flags[GTK_STATE_PRELIGHT] = GTK_RC_FG | GTK_RC_BG;
13393 rc_style->color_flags[GTK_STATE_ACTIVE] = GTK_RC_FG | GTK_RC_BG;
13394 rc_style->fg[GTK_STATE_NORMAL] = yellow;
13395 rc_style->bg[GTK_STATE_NORMAL] = blue;
13396 rc_style->fg[GTK_STATE_PRELIGHT] = blue;
13397 rc_style->bg[GTK_STATE_PRELIGHT] = yellow;
13398 rc_style->fg[GTK_STATE_ACTIVE] = red;
13399 rc_style->bg[GTK_STATE_ACTIVE] = cyan;
13400 rc_style->xthickness = 5;
13401 rc_style->ythickness = 5;
13403 gtk_widget_modify_style (button, rc_style);
13404 gtk_widget_modify_style (GTK_BIN (button)->child, rc_style);
13406 g_object_unref (rc_style);
13408 gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
13411 if (!GTK_WIDGET_VISIBLE (window))
13412 gtk_widget_show_all (window);
13414 gtk_widget_destroy (window);
13418 * Main Window and Exit
13422 do_exit (GtkWidget *widget, GtkWidget *window)
13424 gtk_widget_destroy (window);
13430 void (*func) (GtkWidget *widget);
13431 gboolean do_not_benchmark;
13434 { "alpha window", create_alpha_window },
13436 /* dog slow on NT, no working at all on 9x */
13437 { "big windows", create_big_windows, TRUE },
13439 { "big windows", create_big_windows },
13441 { "button box", create_button_box },
13442 { "buttons", create_buttons },
13443 { "check buttons", create_check_buttons },
13444 { "clist", create_clist},
13445 { "color selection", create_color_selection },
13446 { "composited window", create_composited_window },
13447 { "ctree", create_ctree },
13448 { "cursors", create_cursors },
13449 { "dialog", create_dialog, TRUE },
13450 { "display & screen", create_display_screen, TRUE },
13451 { "entry", create_entry },
13452 { "event box", create_event_box },
13453 { "event watcher", create_event_watcher },
13454 { "expander", create_expander },
13455 { "file selection", create_file_selection },
13456 { "flipping", create_flipping },
13457 { "focus", create_focus },
13458 { "font selection", create_font_selection },
13459 { "gamma curve", create_gamma_curve, TRUE },
13460 { "gridded geometry", create_gridded_geometry },
13461 { "handle box", create_handle_box },
13462 { "image from drawable", create_get_image },
13463 { "image", create_image },
13464 { "item factory", create_item_factory },
13465 { "key lookup", create_key_lookup },
13466 { "labels", create_labels },
13467 { "layout", create_layout },
13468 { "list", create_list },
13469 { "menus", create_menus },
13470 { "message dialog", create_message_dialog },
13471 { "modal window", create_modal_window, TRUE },
13472 { "notebook", create_notebook },
13473 { "panes", create_panes },
13474 { "paned keyboard", create_paned_keyboard_navigation },
13475 { "pixmap", create_pixmap },
13476 { "preview color", create_color_preview, TRUE },
13477 { "preview gray", create_gray_preview, TRUE },
13478 { "progress bar", create_progress_bar },
13479 { "properties", create_properties },
13480 { "radio buttons", create_radio_buttons },
13481 { "range controls", create_range_controls },
13482 { "rc file", create_rc_file },
13483 { "reparent", create_reparent },
13484 { "resize grips", create_resize_grips },
13485 { "rotated label", create_rotated_label },
13486 { "rotated text", create_rotated_text },
13487 { "rulers", create_rulers },
13488 { "saved position", create_saved_position },
13489 { "scrolled windows", create_scrolled_windows },
13490 { "shapes", create_shapes },
13491 { "size groups", create_size_groups },
13492 { "spinbutton", create_spins },
13493 { "statusbar", create_statusbar },
13494 { "styles", create_styles },
13495 { "test idle", create_idle_test },
13496 { "test mainloop", create_mainloop, TRUE },
13497 { "test scrolling", create_scroll_test },
13498 { "test selection", create_selection_test },
13499 { "test timeout", create_timeout_test },
13500 { "text", create_text },
13501 { "toggle buttons", create_toggle_buttons },
13502 { "toolbar", create_toolbar },
13503 { "tooltips", create_tooltips },
13504 { "tree", create_tree_mode_window},
13505 { "WM hints", create_wmhints },
13506 { "window sizing", create_window_sizing },
13507 { "window states", create_window_states }
13509 int nbuttons = sizeof (buttons) / sizeof (buttons[0]);
13512 create_main_window (void)
13517 GtkWidget *scrolled_window;
13521 GtkWidget *separator;
13522 GdkGeometry geometry;
13525 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
13526 gtk_widget_set_name (window, "main window");
13527 gtk_widget_set_uposition (window, 20, 20);
13528 gtk_window_set_default_size (GTK_WINDOW (window), -1, 400);
13530 geometry.min_width = -1;
13531 geometry.min_height = -1;
13532 geometry.max_width = -1;
13533 geometry.max_height = G_MAXSHORT;
13534 gtk_window_set_geometry_hints (GTK_WINDOW (window), NULL,
13536 GDK_HINT_MIN_SIZE | GDK_HINT_MAX_SIZE);
13538 g_signal_connect (window, "destroy",
13539 G_CALLBACK (gtk_main_quit),
13541 g_signal_connect (window, "delete-event",
13542 G_CALLBACK (gtk_false),
13545 box1 = gtk_vbox_new (FALSE, 0);
13546 gtk_container_add (GTK_CONTAINER (window), box1);
13548 if (gtk_micro_version > 0)
13553 gtk_micro_version);
13558 gtk_minor_version);
13560 label = gtk_label_new (buffer);
13561 gtk_box_pack_start (GTK_BOX (box1), label, FALSE, FALSE, 0);
13562 gtk_widget_set_name (label, "testgtk-version-label");
13564 scrolled_window = gtk_scrolled_window_new (NULL, NULL);
13565 gtk_container_set_border_width (GTK_CONTAINER (scrolled_window), 10);
13566 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
13568 GTK_POLICY_AUTOMATIC);
13569 gtk_box_pack_start (GTK_BOX (box1), scrolled_window, TRUE, TRUE, 0);
13571 box2 = gtk_vbox_new (FALSE, 0);
13572 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
13573 gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (scrolled_window), box2);
13574 gtk_container_set_focus_vadjustment (GTK_CONTAINER (box2),
13575 gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (scrolled_window)));
13576 gtk_widget_show (box2);
13578 for (i = 0; i < nbuttons; i++)
13580 button = gtk_button_new_with_label (buttons[i].label);
13581 if (buttons[i].func)
13582 g_signal_connect (button,
13584 G_CALLBACK(buttons[i].func),
13587 gtk_widget_set_sensitive (button, FALSE);
13588 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
13591 separator = gtk_hseparator_new ();
13592 gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
13594 box2 = gtk_vbox_new (FALSE, 10);
13595 gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
13596 gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
13598 button = gtk_button_new_with_mnemonic ("_Close");
13599 g_signal_connect (button, "clicked",
13600 G_CALLBACK (do_exit),
13602 gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
13603 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
13604 gtk_widget_grab_default (button);
13606 gtk_widget_show_all (window);
13612 if (g_file_test ("../gdk-pixbuf/libpixbufloader-pnm.la",
13613 G_FILE_TEST_EXISTS))
13615 g_setenv ("GDK_PIXBUF_MODULE_FILE", "../gdk-pixbuf/gdk-pixbuf.loaders", TRUE);
13616 g_setenv ("GTK_IM_MODULE_FILE", "../modules/input/gtk.immodules", TRUE);
13621 pad (const char *str, int to)
13623 static char buf[256];
13624 int len = strlen (str);
13627 for (i = 0; i < to; i++)
13632 memcpy (buf, str, len);
13638 bench_iteration (GtkWidget *widget, void (* fn) (GtkWidget *widget))
13640 fn (widget); /* on */
13641 while (g_main_context_iteration (NULL, FALSE));
13642 fn (widget); /* off */
13643 while (g_main_context_iteration (NULL, FALSE));
13647 do_real_bench (GtkWidget *widget, void (* fn) (GtkWidget *widget), char *name, int num)
13653 static gboolean printed_headers = FALSE;
13655 if (!printed_headers) {
13656 g_print ("Test Iters First Other\n");
13657 g_print ("-------------------- ----- ---------- ----------\n");
13658 printed_headers = TRUE;
13661 g_get_current_time (&tv0);
13662 bench_iteration (widget, fn);
13663 g_get_current_time (&tv1);
13665 dt_first = ((double)tv1.tv_sec - tv0.tv_sec) * 1000.0
13666 + (tv1.tv_usec - tv0.tv_usec) / 1000.0;
13668 g_get_current_time (&tv0);
13669 for (n = 0; n < num - 1; n++)
13670 bench_iteration (widget, fn);
13671 g_get_current_time (&tv1);
13672 dt = ((double)tv1.tv_sec - tv0.tv_sec) * 1000.0
13673 + (tv1.tv_usec - tv0.tv_usec) / 1000.0;
13675 g_print ("%s %5d ", pad (name, 20), num);
13677 g_print ("%10.1f %10.1f\n", dt_first, dt/(num-1));
13679 g_print ("%10.1f\n", dt_first);
13683 do_bench (char* what, int num)
13687 void (* fn) (GtkWidget *widget);
13689 widget = gtk_window_new (GTK_WINDOW_TOPLEVEL);
13691 if (g_ascii_strcasecmp (what, "ALL") == 0)
13693 for (i = 0; i < nbuttons; i++)
13695 if (!buttons[i].do_not_benchmark)
13696 do_real_bench (widget, buttons[i].func, buttons[i].label, num);
13703 for (i = 0; i < nbuttons; i++)
13705 if (strcmp (buttons[i].label, what) == 0)
13707 fn = buttons[i].func;
13713 g_print ("Can't bench: \"%s\" not found.\n", what);
13715 do_real_bench (widget, fn, buttons[i].label, num);
13722 fprintf (stderr, "Usage: testgtk [--bench ALL|<bench>[:<count>]]\n");
13727 main (int argc, char *argv[])
13729 GtkBindingSet *binding_set;
13731 gboolean done_benchmarks = FALSE;
13733 srand (time (NULL));
13737 /* Check to see if we are being run from the correct
13740 if (file_exists ("testgtkrc"))
13741 gtk_rc_add_default_file ("testgtkrc");
13743 g_set_application_name ("GTK+ Test Program");
13745 gtk_init (&argc, &argv);
13747 gtk_accelerator_set_default_mod_mask (GDK_SHIFT_MASK |
13756 for (i = 1; i < argc; i++)
13758 if (strncmp (argv[i], "--bench", strlen("--bench")) == 0)
13765 nextarg = strchr (argv[i], '=');
13776 count = strchr (nextarg, ':');
13779 what = g_strndup (nextarg, count - nextarg);
13781 num = atoi (count);
13786 what = g_strdup (nextarg);
13788 do_bench (what, num ? num : 1);
13789 done_benchmarks = TRUE;
13794 if (done_benchmarks)
13799 binding_set = gtk_binding_set_by_class (gtk_type_class (GTK_TYPE_WIDGET));
13800 gtk_binding_entry_add_signal (binding_set,
13801 '9', GDK_CONTROL_MASK | GDK_RELEASE_MASK,
13804 G_TYPE_STRING, "GtkWidgetClass <ctrl><release>9 test");
13806 /* We use gtk_rc_parse_string() here so we can make sure it works across theme
13810 gtk_rc_parse_string ("style \"testgtk-version-label\" { "
13811 " fg[NORMAL] = \"#ff0000\"\n"
13812 " font = \"Sans 18\"\n"
13814 "widget \"*.testgtk-version-label\" style \"testgtk-version-label\"");
13816 create_main_window ();
13822 while (g_main_context_pending (NULL))
13823 g_main_context_iteration (NULL, FALSE);
13826 while (g_main_context_pending (NULL))
13827 g_main_context_iteration (NULL, FALSE);