/* GTK - The GIMP Toolkit * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Library General Public * License as published by the Free Software Foundation; either * version 2 of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Library General Public License for more details. * * You should have received a copy of the GNU Library General Public * License along with this library; if not, write to the * Free Software Foundation, Inc., 59 Temple Place - Suite 330, * Boston, MA 02111-1307, USA. */ #include #include #include #include #include "gtk.h" #include "../gdk/gdk.h" #include "../gdk/gdkx.h" #include "../gdk/gdkkeysyms.h" #include "circles.xbm" GtkWidget *shape_create_icon (char *xpm_file, gint x, gint y, gint px, gint py, gint window_type); /* macro, structure and variables used by tree window demos */ #define DEFAULT_NUMBER_OF_ITEM 3 #define DEFAULT_RECURSION_LEVEL 3 struct { GSList* selection_mode_group; GtkWidget* single_button; GtkWidget* browse_button; GtkWidget* multiple_button; GtkWidget* draw_line_button; GtkWidget* view_line_button; GtkWidget* no_root_item_button; GtkWidget* nb_item_spinner; GtkWidget* recursion_spinner; } sTreeSampleSelection; typedef struct sTreeButtons { guint nb_item_add; GtkWidget* add_button; GtkWidget* remove_button; GtkWidget* subtree_button; } sTreeButtons; /* end of tree section */ static void destroy_tooltips (GtkWidget *widget, GtkWindow **window) { GtkTooltips *tt = gtk_object_get_data (GTK_OBJECT (*window), "tooltips"); gtk_object_unref (GTK_OBJECT (tt)); *window = NULL; } static void button_window (GtkWidget *widget, GtkWidget *button) { if (!GTK_WIDGET_VISIBLE (button)) gtk_widget_show (button); else gtk_widget_hide (button); } static void create_buttons (void) { static GtkWidget *window = NULL; GtkWidget *box1; GtkWidget *box2; GtkWidget *table; GtkWidget *button[10]; GtkWidget *separator; if (!window) { window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_signal_connect (GTK_OBJECT (window), "destroy", GTK_SIGNAL_FUNC (gtk_widget_destroyed), &window); gtk_window_set_title (GTK_WINDOW (window), "buttons"); gtk_container_border_width (GTK_CONTAINER (window), 0); box1 = gtk_vbox_new (FALSE, 0); gtk_container_add (GTK_CONTAINER (window), box1); gtk_widget_show (box1); table = gtk_table_new (3, 3, FALSE); gtk_table_set_row_spacings (GTK_TABLE (table), 5); gtk_table_set_col_spacings (GTK_TABLE (table), 5); gtk_container_border_width (GTK_CONTAINER (table), 10); gtk_box_pack_start (GTK_BOX (box1), table, TRUE, TRUE, 0); gtk_widget_show (table); button[0] = gtk_button_new_with_label ("button1"); button[1] = gtk_button_new_with_label ("button2"); button[2] = gtk_button_new_with_label ("button3"); button[3] = gtk_button_new_with_label ("button4"); button[4] = gtk_button_new_with_label ("button5"); button[5] = gtk_button_new_with_label ("button6"); button[6] = gtk_button_new_with_label ("button7"); button[7] = gtk_button_new_with_label ("button8"); button[8] = gtk_button_new_with_label ("button9"); gtk_signal_connect (GTK_OBJECT (button[0]), "clicked", GTK_SIGNAL_FUNC(button_window), button[1]); gtk_table_attach (GTK_TABLE (table), button[0], 0, 1, 0, 1, GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0); gtk_widget_show (button[0]); gtk_signal_connect (GTK_OBJECT (button[1]), "clicked", GTK_SIGNAL_FUNC(button_window), button[2]); gtk_table_attach (GTK_TABLE (table), button[1], 1, 2, 1, 2, GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0); gtk_widget_show (button[1]); gtk_signal_connect (GTK_OBJECT (button[2]), "clicked", GTK_SIGNAL_FUNC(button_window), button[3]); gtk_table_attach (GTK_TABLE (table), button[2], 2, 3, 2, 3, GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0); gtk_widget_show (button[2]); gtk_signal_connect (GTK_OBJECT (button[3]), "clicked", GTK_SIGNAL_FUNC(button_window), button[4]); gtk_table_attach (GTK_TABLE (table), button[3], 0, 1, 2, 3, GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0); gtk_widget_show (button[3]); gtk_signal_connect (GTK_OBJECT (button[4]), "clicked", GTK_SIGNAL_FUNC(button_window), button[5]); gtk_table_attach (GTK_TABLE (table), button[4], 2, 3, 0, 1, GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0); gtk_widget_show (button[4]); gtk_signal_connect (GTK_OBJECT (button[5]), "clicked", GTK_SIGNAL_FUNC(button_window), button[6]); gtk_table_attach (GTK_TABLE (table), button[5], 1, 2, 2, 3, GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0); gtk_widget_show (button[5]); gtk_signal_connect (GTK_OBJECT (button[6]), "clicked", GTK_SIGNAL_FUNC(button_window), button[7]); gtk_table_attach (GTK_TABLE (table), button[6], 1, 2, 0, 1, GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0); gtk_widget_show (button[6]); gtk_signal_connect (GTK_OBJECT (button[7]), "clicked", GTK_SIGNAL_FUNC(button_window), button[8]); gtk_table_attach (GTK_TABLE (table), button[7], 2, 3, 1, 2, GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0); gtk_widget_show (button[7]); gtk_signal_connect (GTK_OBJECT (button[8]), "clicked", GTK_SIGNAL_FUNC(button_window), button[0]); gtk_table_attach (GTK_TABLE (table), button[8], 0, 1, 1, 2, GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0); gtk_widget_show (button[8]); separator = gtk_hseparator_new (); gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0); gtk_widget_show (separator); box2 = gtk_vbox_new (FALSE, 10); gtk_container_border_width (GTK_CONTAINER (box2), 10); gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0); gtk_widget_show (box2); button[9] = gtk_button_new_with_label ("close"); gtk_signal_connect_object (GTK_OBJECT (button[9]), "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy), GTK_OBJECT (window)); gtk_box_pack_start (GTK_BOX (box2), button[9], TRUE, TRUE, 0); GTK_WIDGET_SET_FLAGS (button[9], GTK_CAN_DEFAULT); gtk_widget_grab_default (button[9]); gtk_widget_show (button[9]); } if (!GTK_WIDGET_VISIBLE (window)) gtk_widget_show (window); else gtk_widget_destroy (window); } static void create_toggle_buttons (void) { static GtkWidget *window = NULL; GtkWidget *box1; GtkWidget *box2; GtkWidget *button; GtkWidget *separator; if (!window) { window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_signal_connect (GTK_OBJECT (window), "destroy", GTK_SIGNAL_FUNC(gtk_widget_destroyed), &window); gtk_window_set_title (GTK_WINDOW (window), "toggle buttons"); gtk_container_border_width (GTK_CONTAINER (window), 0); box1 = gtk_vbox_new (FALSE, 0); gtk_container_add (GTK_CONTAINER (window), box1); gtk_widget_show (box1); box2 = gtk_vbox_new (FALSE, 10); gtk_container_border_width (GTK_CONTAINER (box2), 10); gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0); gtk_widget_show (box2); button = gtk_toggle_button_new_with_label ("button1"); gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0); gtk_widget_show (button); button = gtk_toggle_button_new_with_label ("button2"); gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0); gtk_widget_show (button); button = gtk_toggle_button_new_with_label ("button3"); gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0); gtk_widget_show (button); separator = gtk_hseparator_new (); gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0); gtk_widget_show (separator); box2 = gtk_vbox_new (FALSE, 10); gtk_container_border_width (GTK_CONTAINER (box2), 10); gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0); gtk_widget_show (box2); button = gtk_button_new_with_label ("close"); gtk_signal_connect_object (GTK_OBJECT (button), "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy), GTK_OBJECT (window)); gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0); GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT); gtk_widget_grab_default (button); gtk_widget_show (button); } if (!GTK_WIDGET_VISIBLE (window)) gtk_widget_show (window); else gtk_widget_destroy (window); } static void create_check_buttons (void) { static GtkWidget *window = NULL; GtkWidget *box1; GtkWidget *box2; GtkWidget *button; GtkWidget *separator; if (!window) { window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_signal_connect (GTK_OBJECT (window), "destroy", GTK_SIGNAL_FUNC(gtk_widget_destroyed), &window); gtk_window_set_title (GTK_WINDOW (window), "check buttons"); gtk_container_border_width (GTK_CONTAINER (window), 0); box1 = gtk_vbox_new (FALSE, 0); gtk_container_add (GTK_CONTAINER (window), box1); gtk_widget_show (box1); box2 = gtk_vbox_new (FALSE, 10); gtk_container_border_width (GTK_CONTAINER (box2), 10); gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0); gtk_widget_show (box2); button = gtk_check_button_new_with_label ("button1"); gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0); gtk_widget_show (button); button = gtk_check_button_new_with_label ("button2"); gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0); gtk_widget_show (button); button = gtk_check_button_new_with_label ("button3"); gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0); gtk_widget_show (button); separator = gtk_hseparator_new (); gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0); gtk_widget_show (separator); box2 = gtk_vbox_new (FALSE, 10); gtk_container_border_width (GTK_CONTAINER (box2), 10); gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0); gtk_widget_show (box2); button = gtk_button_new_with_label ("close"); gtk_signal_connect_object (GTK_OBJECT (button), "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy), GTK_OBJECT (window)); gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0); GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT); gtk_widget_grab_default (button); gtk_widget_show (button); } if (!GTK_WIDGET_VISIBLE (window)) gtk_widget_show (window); else gtk_widget_destroy (window); } static void create_radio_buttons (void) { static GtkWidget *window = NULL; GtkWidget *box1; GtkWidget *box2; GtkWidget *button; GtkWidget *separator; if (!window) { window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_signal_connect (GTK_OBJECT (window), "destroy", GTK_SIGNAL_FUNC(gtk_widget_destroyed), &window); gtk_window_set_title (GTK_WINDOW (window), "radio buttons"); gtk_container_border_width (GTK_CONTAINER (window), 0); box1 = gtk_vbox_new (FALSE, 0); gtk_container_add (GTK_CONTAINER (window), box1); gtk_widget_show (box1); box2 = gtk_vbox_new (FALSE, 10); gtk_container_border_width (GTK_CONTAINER (box2), 10); gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0); gtk_widget_show (box2); button = gtk_radio_button_new_with_label (NULL, "button1"); gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0); gtk_widget_show (button); button = gtk_radio_button_new_with_label ( gtk_radio_button_group (GTK_RADIO_BUTTON (button)), "button2"); gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON (button), TRUE); gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0); gtk_widget_show (button); button = gtk_radio_button_new_with_label ( gtk_radio_button_group (GTK_RADIO_BUTTON (button)), "button3"); gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0); gtk_widget_show (button); separator = gtk_hseparator_new (); gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0); gtk_widget_show (separator); box2 = gtk_vbox_new (FALSE, 10); gtk_container_border_width (GTK_CONTAINER (box2), 10); gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0); gtk_widget_show (box2); button = gtk_button_new_with_label ("close"); gtk_signal_connect_object (GTK_OBJECT (button), "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy), GTK_OBJECT (window)); gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0); GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT); gtk_widget_grab_default (button); gtk_widget_show (button); } if (!GTK_WIDGET_VISIBLE (window)) gtk_widget_show (window); else gtk_widget_destroy (window); } static void bbox_widget_destroy (GtkWidget* widget, GtkWidget* todestroy) { } static void create_bbox_window (gint horizontal, char* title, gint pos, gint spacing, gint child_w, gint child_h, gint layout) { GtkWidget* window; GtkWidget* box1; GtkWidget* bbox; GtkWidget* button; /* create a new window */ window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_title (GTK_WINDOW (window), title); gtk_signal_connect (GTK_OBJECT (window), "destroy", GTK_SIGNAL_FUNC(bbox_widget_destroy), window); if (horizontal) { gtk_widget_set_usize (window, 550, 60); gtk_widget_set_uposition (window, 150, pos); box1 = gtk_vbox_new (FALSE, 0); } else { gtk_widget_set_usize (window, 150, 400); gtk_widget_set_uposition (window, pos, 200); box1 = gtk_vbox_new (FALSE, 0); } gtk_container_add (GTK_CONTAINER (window), box1); gtk_widget_show (box1); if (horizontal) bbox = gtk_hbutton_box_new(); else bbox = gtk_vbutton_box_new(); gtk_button_box_set_layout (GTK_BUTTON_BOX (bbox), layout); gtk_button_box_set_spacing (GTK_BUTTON_BOX (bbox), spacing); gtk_button_box_set_child_size (GTK_BUTTON_BOX (bbox), child_w, child_h); gtk_widget_show (bbox); gtk_container_border_width (GTK_CONTAINER(box1), 25); gtk_box_pack_start (GTK_BOX (box1), bbox, TRUE, TRUE, 0); button = gtk_button_new_with_label ("OK"); gtk_container_add (GTK_CONTAINER(bbox), button); gtk_signal_connect (GTK_OBJECT (button), "clicked", GTK_SIGNAL_FUNC(bbox_widget_destroy), window); gtk_widget_show (button); button = gtk_button_new_with_label ("Cancel"); gtk_container_add (GTK_CONTAINER(bbox), button); gtk_widget_show (button); button = gtk_button_new_with_label ("Help"); gtk_container_add (GTK_CONTAINER(bbox), button); gtk_widget_show (button); gtk_widget_show (window); } static void test_hbbox (void) { create_bbox_window (TRUE, "Spread", 50, 40, 85, 28, GTK_BUTTONBOX_SPREAD); create_bbox_window (TRUE, "Edge", 200, 40, 85, 25, GTK_BUTTONBOX_EDGE); create_bbox_window (TRUE, "Start", 350, 40, 85, 25, GTK_BUTTONBOX_START); create_bbox_window (TRUE, "End", 500, 15, 30, 25, GTK_BUTTONBOX_END); } static void test_vbbox (void) { create_bbox_window (FALSE, "Spread", 50, 40, 85, 25, GTK_BUTTONBOX_SPREAD); create_bbox_window (FALSE, "Edge", 250, 40, 85, 28, GTK_BUTTONBOX_EDGE); create_bbox_window (FALSE, "Start", 450, 40, 85, 25, GTK_BUTTONBOX_START); create_bbox_window (FALSE, "End", 650, 15, 30, 25, GTK_BUTTONBOX_END); } static void create_button_box (void) { static GtkWidget* window = NULL; GtkWidget* bbox; GtkWidget* button; if (!window) { window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_title (GTK_WINDOW (window), "Button Box Test"); gtk_signal_connect (GTK_OBJECT (window), "destroy", GTK_SIGNAL_FUNC(gtk_widget_destroyed), &window); gtk_container_border_width (GTK_CONTAINER (window), 20); /* *these 15 lines are a nice and easy example for GtkHButtonBox */ bbox = gtk_hbutton_box_new (); gtk_container_add (GTK_CONTAINER (window), bbox); gtk_widget_show (bbox); button = gtk_button_new_with_label ("Horizontal"); gtk_signal_connect (GTK_OBJECT (button), "clicked", GTK_SIGNAL_FUNC(test_hbbox), 0); gtk_container_add (GTK_CONTAINER (bbox), button); gtk_widget_show (button); button = gtk_button_new_with_label ("Vertical"); gtk_signal_connect (GTK_OBJECT (button), "clicked", GTK_SIGNAL_FUNC(test_vbbox), 0); gtk_container_add (GTK_CONTAINER (bbox), button); gtk_widget_show (button); } if (!GTK_WIDGET_VISIBLE (window)) gtk_widget_show (window); else gtk_widget_destroy (window); } static GtkWidget* new_pixmap (char *filename, GdkWindow *window, GdkColor *background) { GtkWidget *wpixmap; GdkPixmap *pixmap; GdkBitmap *mask; pixmap = gdk_pixmap_create_from_xpm (window, &mask, background, filename); wpixmap = gtk_pixmap_new (pixmap, mask); return wpixmap; } static void set_toolbar_horizontal (GtkWidget *widget, gpointer data) { gtk_toolbar_set_orientation (GTK_TOOLBAR (data), GTK_ORIENTATION_HORIZONTAL); } static void set_toolbar_vertical (GtkWidget *widget, gpointer data) { gtk_toolbar_set_orientation (GTK_TOOLBAR (data), GTK_ORIENTATION_VERTICAL); } static void set_toolbar_icons (GtkWidget *widget, gpointer data) { gtk_toolbar_set_style (GTK_TOOLBAR (data), GTK_TOOLBAR_ICONS); } static void set_toolbar_text (GtkWidget *widget, gpointer data) { gtk_toolbar_set_style (GTK_TOOLBAR (data), GTK_TOOLBAR_TEXT); } static void set_toolbar_both (GtkWidget *widget, gpointer data) { gtk_toolbar_set_style (GTK_TOOLBAR (data), GTK_TOOLBAR_BOTH); } static void set_toolbar_small_space (GtkWidget *widget, gpointer data) { gtk_toolbar_set_space_size (GTK_TOOLBAR (data), 5); } static void set_toolbar_big_space (GtkWidget *widget, gpointer data) { gtk_toolbar_set_space_size (GTK_TOOLBAR (data), 10); } static void set_toolbar_enable (GtkWidget *widget, gpointer data) { gtk_toolbar_set_tooltips (GTK_TOOLBAR (data), TRUE); } static void set_toolbar_disable (GtkWidget *widget, gpointer data) { gtk_toolbar_set_tooltips (GTK_TOOLBAR (data), FALSE); } static void set_toolbar_borders (GtkWidget *widget, gpointer data) { gtk_toolbar_set_button_relief (GTK_TOOLBAR (data), GTK_RELIEF_NORMAL); } static void set_toolbar_borderless (GtkWidget *widget, gpointer data) { gtk_toolbar_set_button_relief (GTK_TOOLBAR (data), GTK_RELIEF_NONE); } static void create_toolbar (void) { static GtkWidget *window = NULL; GtkWidget *toolbar; GtkWidget *entry; if (!window) { window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_title (GTK_WINDOW (window), "Toolbar test"); gtk_window_set_policy (GTK_WINDOW (window), FALSE, TRUE, TRUE); gtk_signal_connect (GTK_OBJECT (window), "destroy", GTK_SIGNAL_FUNC (gtk_widget_destroyed), &window); gtk_container_border_width (GTK_CONTAINER (window), 0); gtk_widget_realize (window); toolbar = gtk_toolbar_new (GTK_ORIENTATION_HORIZONTAL, GTK_TOOLBAR_BOTH); gtk_toolbar_set_button_relief (GTK_TOOLBAR (toolbar), GTK_RELIEF_NONE); gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), "Horizontal", "Horizontal toolbar layout", "Toolbar/Horizontal", new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]), (GtkSignalFunc) set_toolbar_horizontal, toolbar); gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), "Vertical", "Vertical toolbar layout", "Toolbar/Vertical", new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]), (GtkSignalFunc) set_toolbar_vertical, toolbar); gtk_toolbar_append_space (GTK_TOOLBAR(toolbar)); gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), "Icons", "Only show toolbar icons", "Toolbar/IconsOnly", new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]), (GtkSignalFunc) set_toolbar_icons, toolbar); gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), "Text", "Only show toolbar text", "Toolbar/TextOnly", new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]), (GtkSignalFunc) set_toolbar_text, toolbar); gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), "Both", "Show toolbar icons and text", "Toolbar/Both", new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]), (GtkSignalFunc) set_toolbar_both, toolbar); gtk_toolbar_append_space (GTK_TOOLBAR (toolbar)); entry = gtk_entry_new (); gtk_widget_show(entry); gtk_toolbar_append_widget (GTK_TOOLBAR (toolbar), entry, "This is an unusable GtkEntry ;)", "Hey don't click me!!!"); gtk_toolbar_append_space (GTK_TOOLBAR (toolbar)); gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), "Small", "Use small spaces", "Toolbar/Small", new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]), (GtkSignalFunc) set_toolbar_small_space, toolbar); gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), "Big", "Use big spaces", "Toolbar/Big", new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]), (GtkSignalFunc) set_toolbar_big_space, toolbar); gtk_toolbar_append_space (GTK_TOOLBAR (toolbar)); gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), "Enable", "Enable tooltips", NULL, new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]), (GtkSignalFunc) set_toolbar_enable, toolbar); gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), "Disable", "Disable tooltips", NULL, new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]), (GtkSignalFunc) set_toolbar_disable, toolbar); gtk_toolbar_append_space (GTK_TOOLBAR (toolbar)); gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), "Borders", "Show Borders", NULL, new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]), (GtkSignalFunc) set_toolbar_borders, toolbar); gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), "Borderless", "Hide Borders", NULL, new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]), (GtkSignalFunc) set_toolbar_borderless, toolbar); gtk_container_add (GTK_CONTAINER (window), toolbar); gtk_widget_show (toolbar); } if (!GTK_WIDGET_VISIBLE (window)) gtk_widget_show (window); else gtk_widget_destroy (window); } static GtkWidget* make_toolbar (GtkWidget *window) { GtkWidget *toolbar; if (!GTK_WIDGET_REALIZED (window)) gtk_widget_realize (window); toolbar = gtk_toolbar_new (GTK_ORIENTATION_HORIZONTAL, GTK_TOOLBAR_BOTH); gtk_toolbar_set_button_relief (GTK_TOOLBAR (toolbar), GTK_RELIEF_NONE); gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), "Horizontal", "Horizontal toolbar layout", NULL, new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]), (GtkSignalFunc) set_toolbar_horizontal, toolbar); gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), "Vertical", "Vertical toolbar layout", NULL, new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]), (GtkSignalFunc) set_toolbar_vertical, toolbar); gtk_toolbar_append_space (GTK_TOOLBAR(toolbar)); gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), "Icons", "Only show toolbar icons", NULL, new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]), (GtkSignalFunc) set_toolbar_icons, toolbar); gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), "Text", "Only show toolbar text", NULL, new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]), (GtkSignalFunc) set_toolbar_text, toolbar); gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), "Both", "Show toolbar icons and text", NULL, new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]), (GtkSignalFunc) set_toolbar_both, toolbar); gtk_toolbar_append_space (GTK_TOOLBAR (toolbar)); gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), "Small", "Use small spaces", NULL, new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]), (GtkSignalFunc) set_toolbar_small_space, toolbar); gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), "Big", "Use big spaces", "Toolbar/Big", new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]), (GtkSignalFunc) set_toolbar_big_space, toolbar); gtk_toolbar_append_space (GTK_TOOLBAR (toolbar)); gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), "Enable", "Enable tooltips", NULL, new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]), (GtkSignalFunc) set_toolbar_enable, toolbar); gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), "Disable", "Disable tooltips", NULL, new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]), (GtkSignalFunc) set_toolbar_disable, toolbar); gtk_toolbar_append_space (GTK_TOOLBAR (toolbar)); gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), "Borders", "Show Borders", NULL, new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]), (GtkSignalFunc) set_toolbar_borders, toolbar); gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), "Borderless", "Hide Borders", NULL, new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]), (GtkSignalFunc) set_toolbar_borderless, toolbar); return toolbar; } static guint statusbar_counter = 1; static void statusbar_push (GtkWidget *button, GtkStatusbar *statusbar) { gchar text[1024]; sprintf (text, "something %d", statusbar_counter++); gtk_statusbar_push (statusbar, 1, text); } static void statusbar_pop (GtkWidget *button, GtkStatusbar *statusbar) { gtk_statusbar_pop (statusbar, 1); } static void statusbar_steal (GtkWidget *button, GtkStatusbar *statusbar) { gtk_statusbar_remove (statusbar, 1, 4); } static void statusbar_popped (GtkStatusbar *statusbar, guint context_id, const gchar *text) { if (!statusbar->messages) statusbar_counter = 1; } static void statusbar_contexts (GtkWidget *button, GtkStatusbar *statusbar) { gchar *string; string = "any context"; g_print ("GtkStatusBar: context=\"%s\", context_id=%d\n", string, gtk_statusbar_get_context_id (statusbar, string)); string = "idle messages"; g_print ("GtkStatusBar: context=\"%s\", context_id=%d\n", string, gtk_statusbar_get_context_id (statusbar, string)); string = "some text"; g_print ("GtkStatusBar: context=\"%s\", context_id=%d\n", string, gtk_statusbar_get_context_id (statusbar, string)); string = "hit the mouse"; g_print ("GtkStatusBar: context=\"%s\", context_id=%d\n", string, gtk_statusbar_get_context_id (statusbar, string)); string = "hit the mouse2"; g_print ("GtkStatusBar: context=\"%s\", context_id=%d\n", string, gtk_statusbar_get_context_id (statusbar, string)); } static void statusbar_dump_stack (GtkWidget *button, GtkStatusbar *statusbar) { GSList *list; for (list = statusbar->messages; list; list = list->next) { GtkStatusbarMsg *msg; msg = list->data; g_print ("context_id: %d, message_id: %d, status_text: \"%s\"\n", msg->context_id, msg->message_id, msg->text); } } static void create_statusbar (void) { static GtkWidget *window = NULL; GtkWidget *box1; GtkWidget *box2; GtkWidget *button; GtkWidget *separator; GtkWidget *statusbar; if (!window) { window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_signal_connect (GTK_OBJECT (window), "destroy", GTK_SIGNAL_FUNC (gtk_widget_destroyed), &window); gtk_window_set_title (GTK_WINDOW (window), "statusbar"); gtk_container_border_width (GTK_CONTAINER (window), 0); box1 = gtk_vbox_new (FALSE, 0); gtk_container_add (GTK_CONTAINER (window), box1); gtk_widget_show (box1); box2 = gtk_vbox_new (FALSE, 10); gtk_container_border_width (GTK_CONTAINER (box2), 10); gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0); gtk_widget_show (box2); statusbar = gtk_statusbar_new (); gtk_box_pack_end (GTK_BOX (box1), statusbar, TRUE, TRUE, 0); gtk_widget_show (statusbar); gtk_signal_connect (GTK_OBJECT (statusbar), "text_popped", GTK_SIGNAL_FUNC (statusbar_popped), NULL); button = gtk_widget_new (gtk_button_get_type (), "GtkButton::label", "push something", "GtkWidget::visible", TRUE, "GtkWidget::parent", box2, "GtkObject::signal::clicked", statusbar_push, statusbar, NULL); button = gtk_widget_new (gtk_button_get_type (), "GtkButton::label", "pop", "GtkWidget::visible", TRUE, "GtkWidget::parent", box2, "GtkObject::signal::clicked", statusbar_pop, statusbar, NULL); button = gtk_widget_new (gtk_button_get_type (), "GtkButton::label", "steal #4", "GtkWidget::visible", TRUE, "GtkWidget::parent", box2, "GtkObject::signal::clicked", statusbar_steal, statusbar, NULL); button = gtk_widget_new (gtk_button_get_type (), "GtkButton::label", "dump stack", "GtkWidget::visible", TRUE, "GtkWidget::parent", box2, "GtkObject::signal::clicked", statusbar_dump_stack, statusbar, NULL); button = gtk_widget_new (gtk_button_get_type (), "GtkButton::label", "test contexts", "GtkWidget::visible", TRUE, "GtkWidget::parent", box2, "GtkObject::signal::clicked", statusbar_contexts, statusbar, NULL); separator = gtk_hseparator_new (); gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0); gtk_widget_show (separator); box2 = gtk_vbox_new (FALSE, 10); gtk_container_border_width (GTK_CONTAINER (box2), 10); gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0); gtk_widget_show (box2); button = gtk_button_new_with_label ("close"); gtk_signal_connect_object (GTK_OBJECT (button), "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy), GTK_OBJECT (window)); gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0); GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT); gtk_widget_grab_default (button); gtk_widget_show (button); } if (!GTK_WIDGET_VISIBLE (window)) gtk_widget_show (window); else gtk_widget_destroy (window); } static void handle_box_child_signal (GtkHandleBox *hb, GtkWidget *child, const gchar *action) { printf ("%s: child <%s> %sed\n", gtk_type_name (GTK_OBJECT_TYPE (hb)), gtk_type_name (GTK_OBJECT_TYPE (child)), action); } static void cb_tree_destroy_event(GtkWidget* w) { sTreeButtons* tree_buttons; /* free buttons structure associate at this tree */ tree_buttons = gtk_object_get_user_data(GTK_OBJECT(w)); free(tree_buttons); } static void cb_add_new_item(GtkWidget* w, GtkTree* tree) { sTreeButtons* tree_buttons; GList* selected_list; GtkWidget* selected_item; GtkWidget* subtree; GtkWidget* item_new; char buffer[255]; tree_buttons = gtk_object_get_user_data(GTK_OBJECT(tree)); selected_list = GTK_TREE_SELECTION(tree); if(selected_list == NULL) { /* there is no item in tree */ subtree = GTK_WIDGET(tree); } else { /* list can have only one element */ selected_item = GTK_WIDGET(selected_list->data); subtree = GTK_TREE_ITEM_SUBTREE(selected_item); if(subtree == NULL) { /* current selected item have not subtree ... create it */ subtree = gtk_tree_new(); gtk_tree_item_set_subtree(GTK_TREE_ITEM(selected_item), subtree); } } /* at this point, we know which subtree will be used to add new item */ /* create a new item */ sprintf(buffer, "item add %d", tree_buttons->nb_item_add); item_new = gtk_tree_item_new_with_label(buffer); gtk_tree_append(GTK_TREE(subtree), item_new); gtk_widget_show(item_new); tree_buttons->nb_item_add++; } static void cb_remove_item(GtkWidget*w, GtkTree* tree) { GList* selected_list; GList* clear_list; selected_list = GTK_TREE_SELECTION(tree); clear_list = NULL; while (selected_list) { clear_list = g_list_prepend (clear_list, selected_list->data); selected_list = selected_list->next; } clear_list = g_list_reverse (clear_list); gtk_tree_remove_items(tree, clear_list); g_list_free (clear_list); } static void cb_remove_subtree(GtkWidget*w, GtkTree* tree) { GList* selected_list; GtkTreeItem *item; selected_list = GTK_TREE_SELECTION(tree); if (selected_list) { item = GTK_TREE_ITEM (selected_list->data); if (item->subtree) gtk_tree_item_remove_subtree (item); } } static void cb_tree_changed(GtkTree* tree) { sTreeButtons* tree_buttons; GList* selected_list; guint nb_selected; tree_buttons = gtk_object_get_user_data(GTK_OBJECT(tree)); selected_list = GTK_TREE_SELECTION(tree); nb_selected = g_list_length(selected_list); if(nb_selected == 0) { if(tree->children == NULL) gtk_widget_set_sensitive(tree_buttons->add_button, TRUE); else gtk_widget_set_sensitive(tree_buttons->add_button, FALSE); gtk_widget_set_sensitive(tree_buttons->remove_button, FALSE); gtk_widget_set_sensitive(tree_buttons->subtree_button, FALSE); } else { gtk_widget_set_sensitive(tree_buttons->remove_button, TRUE); gtk_widget_set_sensitive(tree_buttons->add_button, (nb_selected == 1)); gtk_widget_set_sensitive(tree_buttons->subtree_button, (nb_selected == 1)); } } static void create_subtree(GtkWidget* item, guint level, guint nb_item_max, guint recursion_level_max) { GtkWidget* item_subtree; GtkWidget* item_new; guint nb_item; char buffer[255]; int no_root_item; if(level == recursion_level_max) return; if(level == -1) { /* query with no root item */ level = 0; item_subtree = item; no_root_item = 1; } else { /* query with no root item */ /* create subtree and associate it with current item */ item_subtree = gtk_tree_new(); no_root_item = 0; } for(nb_item = 0; nb_item < nb_item_max; nb_item++) { sprintf(buffer, "item %d-%d", level, nb_item); item_new = gtk_tree_item_new_with_label(buffer); gtk_tree_append(GTK_TREE(item_subtree), item_new); create_subtree(item_new, level+1, nb_item_max, recursion_level_max); gtk_widget_show(item_new); } if(!no_root_item) gtk_tree_item_set_subtree(GTK_TREE_ITEM(item), item_subtree); } static void create_tree_sample(guint selection_mode, guint draw_line, guint view_line, guint no_root_item, guint nb_item_max, guint recursion_level_max) { GtkWidget* window; GtkWidget* box1; GtkWidget* box2; GtkWidget* separator; GtkWidget* button; GtkWidget* scrolled_win; GtkWidget* root_tree; GtkWidget* root_item; sTreeButtons* tree_buttons; /* create tree buttons struct */ if((tree_buttons = g_malloc(sizeof(sTreeButtons))) == NULL) { g_error("can't allocate memory for tree structure !\n"); return; } tree_buttons->nb_item_add = 0; /* create top level window */ window = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_title(GTK_WINDOW(window), "Tree Sample"); gtk_signal_connect(GTK_OBJECT(window), "destroy", (GtkSignalFunc) cb_tree_destroy_event, NULL); gtk_object_set_user_data(GTK_OBJECT(window), tree_buttons); box1 = gtk_vbox_new(FALSE, 0); gtk_container_add(GTK_CONTAINER(window), box1); gtk_widget_show(box1); /* create tree box */ box2 = gtk_vbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(box1), box2, TRUE, TRUE, 0); gtk_container_border_width(GTK_CONTAINER(box2), 5); gtk_widget_show(box2); /* create scrolled window */ scrolled_win = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_box_pack_start (GTK_BOX (box2), scrolled_win, TRUE, TRUE, 0); gtk_widget_set_usize (scrolled_win, 200, 200); gtk_widget_show (scrolled_win); /* create root tree widget */ root_tree = gtk_tree_new(); gtk_signal_connect(GTK_OBJECT(root_tree), "selection_changed", (GtkSignalFunc)cb_tree_changed, (gpointer)NULL); gtk_object_set_user_data(GTK_OBJECT(root_tree), tree_buttons); gtk_container_add(GTK_CONTAINER(scrolled_win), root_tree); gtk_tree_set_selection_mode(GTK_TREE(root_tree), selection_mode); gtk_tree_set_view_lines(GTK_TREE(root_tree), draw_line); gtk_tree_set_view_mode(GTK_TREE(root_tree), !view_line); gtk_widget_show(root_tree); if ( no_root_item ) { /* set root tree to subtree function with root item variable */ root_item = GTK_WIDGET(root_tree); } else { /* create root tree item widget */ root_item = gtk_tree_item_new_with_label("root item"); gtk_tree_append(GTK_TREE(root_tree), root_item); gtk_widget_show(root_item); } create_subtree(root_item, -no_root_item, nb_item_max, recursion_level_max); box2 = gtk_vbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(box1), box2, FALSE, FALSE, 0); gtk_container_border_width(GTK_CONTAINER(box2), 5); gtk_widget_show(box2); button = gtk_button_new_with_label("Add Item"); gtk_widget_set_sensitive(button, FALSE); gtk_signal_connect(GTK_OBJECT (button), "clicked", (GtkSignalFunc) cb_add_new_item, (gpointer)root_tree); gtk_box_pack_start(GTK_BOX(box2), button, TRUE, TRUE, 0); gtk_widget_show(button); tree_buttons->add_button = button; button = gtk_button_new_with_label("Remove Item(s)"); gtk_widget_set_sensitive(button, FALSE); gtk_signal_connect(GTK_OBJECT (button), "clicked", (GtkSignalFunc) cb_remove_item, (gpointer)root_tree); gtk_box_pack_start(GTK_BOX(box2), button, TRUE, TRUE, 0); gtk_widget_show(button); tree_buttons->remove_button = button; button = gtk_button_new_with_label("Remove Subtree"); gtk_widget_set_sensitive(button, FALSE); gtk_signal_connect(GTK_OBJECT (button), "clicked", (GtkSignalFunc) cb_remove_subtree, (gpointer)root_tree); gtk_box_pack_start(GTK_BOX(box2), button, TRUE, TRUE, 0); gtk_widget_show(button); tree_buttons->subtree_button = button; /* create separator */ separator = gtk_hseparator_new(); gtk_box_pack_start(GTK_BOX(box1), separator, FALSE, FALSE, 0); gtk_widget_show(separator); /* create button box */ box2 = gtk_vbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(box1), box2, FALSE, FALSE, 0); gtk_container_border_width(GTK_CONTAINER(box2), 5); gtk_widget_show(box2); button = gtk_button_new_with_label("Close"); gtk_box_pack_start(GTK_BOX(box2), button, TRUE, TRUE, 0); gtk_signal_connect_object(GTK_OBJECT (button), "clicked", (GtkSignalFunc) gtk_widget_destroy, GTK_OBJECT(window)); gtk_widget_show(button); gtk_widget_show(window); } static void cb_create_tree(GtkWidget* w) { guint selection_mode = GTK_SELECTION_SINGLE; guint view_line; guint draw_line; guint no_root_item; guint nb_item; guint recursion_level; /* get selection mode choice */ if(GTK_TOGGLE_BUTTON(sTreeSampleSelection.single_button)->active) selection_mode = GTK_SELECTION_SINGLE; else if(GTK_TOGGLE_BUTTON(sTreeSampleSelection.browse_button)->active) selection_mode = GTK_SELECTION_BROWSE; else selection_mode = GTK_SELECTION_MULTIPLE; /* get options choice */ draw_line = GTK_TOGGLE_BUTTON(sTreeSampleSelection.draw_line_button)->active; view_line = GTK_TOGGLE_BUTTON(sTreeSampleSelection.view_line_button)->active; no_root_item = GTK_TOGGLE_BUTTON(sTreeSampleSelection.no_root_item_button)->active; /* get levels */ nb_item = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(sTreeSampleSelection.nb_item_spinner)); recursion_level = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(sTreeSampleSelection.recursion_spinner)); if (pow (nb_item, recursion_level) > 10000) { g_print ("%g total items? That will take a very long time. Try less\n", pow (nb_item, recursion_level)); return; } create_tree_sample(selection_mode, draw_line, view_line, no_root_item, nb_item, recursion_level); } void create_tree_mode_window(void) { static GtkWidget* window; GtkWidget* box1; GtkWidget* box2; GtkWidget* box3; GtkWidget* box4; GtkWidget* box5; GtkWidget* button; GtkWidget* frame; GtkWidget* separator; GtkWidget* label; GtkWidget* spinner; GtkAdjustment *adj; if (!window) { /* create toplevel window */ window = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_title(GTK_WINDOW(window), "Tree Mode Selection Window"); gtk_signal_connect (GTK_OBJECT (window), "destroy", GTK_SIGNAL_FUNC(gtk_widget_destroyed), &window); box1 = gtk_vbox_new(FALSE, 0); gtk_container_add(GTK_CONTAINER(window), box1); gtk_widget_show(box1); /* create upper box - selection box */ box2 = gtk_vbox_new(FALSE, 5); gtk_box_pack_start(GTK_BOX(box1), box2, TRUE, TRUE, 0); gtk_container_border_width(GTK_CONTAINER(box2), 5); gtk_widget_show(box2); box3 = gtk_hbox_new(FALSE, 5); gtk_box_pack_start(GTK_BOX(box2), box3, TRUE, TRUE, 0); gtk_widget_show(box3); /* create selection mode frame */ frame = gtk_frame_new("Selection Mode"); gtk_box_pack_start(GTK_BOX(box3), frame, TRUE, TRUE, 0); gtk_widget_show(frame); box4 = gtk_vbox_new(FALSE, 0); gtk_container_add(GTK_CONTAINER(frame), box4); gtk_container_border_width(GTK_CONTAINER(box4), 5); gtk_widget_show(box4); /* create radio button */ button = gtk_radio_button_new_with_label(NULL, "SINGLE"); gtk_box_pack_start(GTK_BOX(box4), button, TRUE, TRUE, 0); gtk_widget_show(button); sTreeSampleSelection.single_button = button; button = gtk_radio_button_new_with_label(gtk_radio_button_group (GTK_RADIO_BUTTON (button)), "BROWSE"); gtk_box_pack_start(GTK_BOX(box4), button, TRUE, TRUE, 0); gtk_widget_show(button); sTreeSampleSelection.browse_button = button; button = gtk_radio_button_new_with_label(gtk_radio_button_group (GTK_RADIO_BUTTON (button)), "MULTIPLE"); gtk_box_pack_start(GTK_BOX(box4), button, TRUE, TRUE, 0); gtk_widget_show(button); sTreeSampleSelection.multiple_button = button; sTreeSampleSelection.selection_mode_group = gtk_radio_button_group (GTK_RADIO_BUTTON (button)); /* create option mode frame */ frame = gtk_frame_new("Options"); gtk_box_pack_start(GTK_BOX(box3), frame, TRUE, TRUE, 0); gtk_widget_show(frame); box4 = gtk_vbox_new(FALSE, 0); gtk_container_add(GTK_CONTAINER(frame), box4); gtk_container_border_width(GTK_CONTAINER(box4), 5); gtk_widget_show(box4); /* create check button */ button = gtk_check_button_new_with_label("Draw line"); gtk_box_pack_start(GTK_BOX(box4), button, TRUE, TRUE, 0); gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(button), TRUE); gtk_widget_show(button); sTreeSampleSelection.draw_line_button = button; button = gtk_check_button_new_with_label("View Line mode"); gtk_box_pack_start(GTK_BOX(box4), button, TRUE, TRUE, 0); gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(button), TRUE); gtk_widget_show(button); sTreeSampleSelection.view_line_button = button; button = gtk_check_button_new_with_label("Without Root item"); gtk_box_pack_start(GTK_BOX(box4), button, TRUE, TRUE, 0); gtk_widget_show(button); sTreeSampleSelection.no_root_item_button = button; /* create recursion parameter */ frame = gtk_frame_new("Size Parameters"); gtk_box_pack_start(GTK_BOX(box2), frame, TRUE, TRUE, 0); gtk_widget_show(frame); box4 = gtk_hbox_new(FALSE, 5); gtk_container_add(GTK_CONTAINER(frame), box4); gtk_container_border_width(GTK_CONTAINER(box4), 5); gtk_widget_show(box4); /* create number of item spin button */ box5 = gtk_hbox_new(FALSE, 5); gtk_box_pack_start(GTK_BOX(box4), box5, FALSE, FALSE, 0); gtk_widget_show(box5); label = gtk_label_new("Number of Item"); gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5); gtk_box_pack_start (GTK_BOX (box5), label, FALSE, TRUE, 0); gtk_widget_show(label); adj = (GtkAdjustment *) gtk_adjustment_new ((gfloat)DEFAULT_NUMBER_OF_ITEM, 1.0, 255.0, 1.0, 5.0, 0.0); spinner = gtk_spin_button_new (adj, 0, 0); gtk_box_pack_start (GTK_BOX (box5), spinner, FALSE, TRUE, 0); gtk_widget_show(spinner); sTreeSampleSelection.nb_item_spinner = spinner; /* create recursion level spin button */ box5 = gtk_hbox_new(FALSE, 5); gtk_box_pack_start(GTK_BOX(box4), box5, FALSE, FALSE, 0); gtk_widget_show(box5); label = gtk_label_new("Depth Level"); gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5); gtk_box_pack_start (GTK_BOX (box5), label, FALSE, TRUE, 0); gtk_widget_show(label); adj = (GtkAdjustment *) gtk_adjustment_new ((gfloat)DEFAULT_RECURSION_LEVEL, 0.0, 255.0, 1.0, 5.0, 0.0); spinner = gtk_spin_button_new (adj, 0, 0); gtk_box_pack_start (GTK_BOX (box5), spinner, FALSE, TRUE, 0); gtk_widget_show(spinner); sTreeSampleSelection.recursion_spinner = spinner; /* create horizontal separator */ separator = gtk_hseparator_new(); gtk_box_pack_start(GTK_BOX(box1), separator, FALSE, FALSE, 0); gtk_widget_show(separator); /* create bottom button box */ box2 = gtk_hbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(box1), box2, FALSE, FALSE, 0); gtk_container_border_width(GTK_CONTAINER(box2), 5); gtk_widget_show(box2); button = gtk_button_new_with_label("Create Tree Sample"); gtk_box_pack_start(GTK_BOX(box2), button, TRUE, TRUE, 0); gtk_signal_connect(GTK_OBJECT (button), "clicked", (GtkSignalFunc) cb_create_tree, NULL); gtk_widget_show(button); button = gtk_button_new_with_label("Close"); gtk_box_pack_start(GTK_BOX(box2), button, TRUE, TRUE, 0); gtk_signal_connect_object (GTK_OBJECT (button), "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy), GTK_OBJECT (window)); gtk_widget_show(button); } if (!GTK_WIDGET_VISIBLE (window)) gtk_widget_show (window); else gtk_widget_destroy (window); } /* end of function used by tree demos */ static void create_handle_box (void) { static GtkWidget* window = NULL; GtkWidget *handle_box; GtkWidget *handle_box2; GtkWidget *vbox; GtkWidget *hbox; GtkWidget *toolbar; GtkWidget *label; GtkWidget *separator; if (!window) { window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_title (GTK_WINDOW (window), "Handle Box Test"); gtk_window_set_policy (GTK_WINDOW (window), TRUE, TRUE, FALSE); gtk_signal_connect (GTK_OBJECT (window), "destroy", GTK_SIGNAL_FUNC(gtk_widget_destroyed), &window); gtk_container_border_width (GTK_CONTAINER (window), 20); vbox = gtk_vbox_new (FALSE, 0); gtk_container_add (GTK_CONTAINER (window), vbox); gtk_widget_show (vbox); label = gtk_label_new ("Above"); gtk_container_add (GTK_CONTAINER (vbox), label); gtk_widget_show (label); separator = gtk_hseparator_new (); gtk_container_add (GTK_CONTAINER (vbox), separator); gtk_widget_show (separator); hbox = gtk_hbox_new (FALSE, 10); gtk_container_add (GTK_CONTAINER (vbox), hbox); gtk_widget_show (hbox); separator = gtk_hseparator_new (); gtk_container_add (GTK_CONTAINER (vbox), separator); gtk_widget_show (separator); label = gtk_label_new ("Below"); gtk_container_add (GTK_CONTAINER (vbox), label); gtk_widget_show (label); handle_box = gtk_handle_box_new (); gtk_container_add (GTK_CONTAINER (hbox), handle_box); gtk_signal_connect (GTK_OBJECT (handle_box), "child_attached", GTK_SIGNAL_FUNC (handle_box_child_signal), "attached"); gtk_signal_connect (GTK_OBJECT (handle_box), "child_detached", GTK_SIGNAL_FUNC (handle_box_child_signal), "detached"); gtk_widget_show (handle_box); toolbar = make_toolbar (window); gtk_toolbar_set_button_relief (GTK_TOOLBAR (toolbar), GTK_RELIEF_NORMAL); gtk_container_add (GTK_CONTAINER (handle_box), toolbar); gtk_widget_show (toolbar); handle_box = gtk_handle_box_new (); gtk_container_add (GTK_CONTAINER (hbox), handle_box); gtk_signal_connect (GTK_OBJECT (handle_box), "child_attached", GTK_SIGNAL_FUNC (handle_box_child_signal), "attached"); gtk_signal_connect (GTK_OBJECT (handle_box), "child_detached", GTK_SIGNAL_FUNC (handle_box_child_signal), "detached"); gtk_widget_show (handle_box); handle_box2 = gtk_handle_box_new (); gtk_container_add (GTK_CONTAINER (handle_box), handle_box2); gtk_signal_connect (GTK_OBJECT (handle_box2), "child_attached", GTK_SIGNAL_FUNC (handle_box_child_signal), "attached"); gtk_signal_connect (GTK_OBJECT (handle_box2), "child_detached", GTK_SIGNAL_FUNC (handle_box_child_signal), "detached"); gtk_widget_show (handle_box2); label = gtk_label_new ("Fooo!"); gtk_container_add (GTK_CONTAINER (handle_box2), label); gtk_widget_show (label); } if (!GTK_WIDGET_VISIBLE (window)) gtk_widget_show (window); else gtk_widget_destroy (window); } static void reparent_label (GtkWidget *widget, GtkWidget *new_parent) { GtkWidget *label; label = gtk_object_get_user_data (GTK_OBJECT (widget)); gtk_widget_reparent (label, new_parent); } static void set_parent_signal (GtkWidget *child, GtkWidget *old_parent, gpointer func_data) { g_print ("set_parent for \"%s\": new parent: \"%s\", old parent: \"%s\", data: %d\n", gtk_type_name (GTK_OBJECT_TYPE (child)), child->parent ? gtk_type_name (GTK_OBJECT_TYPE (child->parent)) : "NULL", old_parent ? gtk_type_name (GTK_OBJECT_TYPE (old_parent)) : "NULL", GPOINTER_TO_INT (func_data)); } static void create_reparent (void) { static GtkWidget *window = NULL; GtkWidget *box1; GtkWidget *box2; GtkWidget *box3; GtkWidget *frame; GtkWidget *button; GtkWidget *label; GtkWidget *separator; if (!window) { window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_signal_connect (GTK_OBJECT (window), "destroy", GTK_SIGNAL_FUNC(gtk_widget_destroyed), &window); gtk_window_set_title (GTK_WINDOW (window), "buttons"); gtk_container_border_width (GTK_CONTAINER (window), 0); box1 = gtk_vbox_new (FALSE, 0); gtk_container_add (GTK_CONTAINER (window), box1); gtk_widget_show (box1); box2 = gtk_hbox_new (FALSE, 5); gtk_container_border_width (GTK_CONTAINER (box2), 10); gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0); gtk_widget_show (box2); label = gtk_label_new ("Hello World"); frame = gtk_frame_new ("Frame 1"); gtk_box_pack_start (GTK_BOX (box2), frame, TRUE, TRUE, 0); gtk_widget_show (frame); box3 = gtk_vbox_new (FALSE, 5); gtk_container_border_width (GTK_CONTAINER (box3), 5); gtk_container_add (GTK_CONTAINER (frame), box3); gtk_widget_show (box3); button = gtk_button_new_with_label ("switch"); gtk_signal_connect (GTK_OBJECT (button), "clicked", GTK_SIGNAL_FUNC(reparent_label), box3); gtk_object_set_user_data (GTK_OBJECT (button), label); gtk_box_pack_start (GTK_BOX (box3), button, FALSE, TRUE, 0); gtk_widget_show (button); gtk_box_pack_start (GTK_BOX (box3), label, FALSE, TRUE, 0); gtk_signal_connect (GTK_OBJECT (label), "parent_set", GTK_SIGNAL_FUNC (set_parent_signal), GINT_TO_POINTER (42)); gtk_widget_show (label); frame = gtk_frame_new ("Frame 2"); gtk_box_pack_start (GTK_BOX (box2), frame, TRUE, TRUE, 0); gtk_widget_show (frame); box3 = gtk_vbox_new (FALSE, 5); gtk_container_border_width (GTK_CONTAINER (box3), 5); gtk_container_add (GTK_CONTAINER (frame), box3); gtk_widget_show (box3); button = gtk_button_new_with_label ("switch"); gtk_signal_connect (GTK_OBJECT (button), "clicked", GTK_SIGNAL_FUNC(reparent_label), box3); gtk_object_set_user_data (GTK_OBJECT (button), label); gtk_box_pack_start (GTK_BOX (box3), button, FALSE, TRUE, 0); gtk_widget_show (button); separator = gtk_hseparator_new (); gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0); gtk_widget_show (separator); box2 = gtk_vbox_new (FALSE, 10); gtk_container_border_width (GTK_CONTAINER (box2), 10); gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0); gtk_widget_show (box2); button = gtk_button_new_with_label ("close"); gtk_signal_connect_object (GTK_OBJECT (button), "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy), GTK_OBJECT (window)); gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0); GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT); gtk_widget_grab_default (button); gtk_widget_show (button); } if (!GTK_WIDGET_VISIBLE (window)) gtk_widget_show (window); else gtk_widget_destroy (window); } static void create_pixmap (void) { static GtkWidget *window = NULL; GtkWidget *box1; GtkWidget *box2; GtkWidget *box3; GtkWidget *button; GtkWidget *label; GtkWidget *separator; GtkWidget *pixmapwid; GdkPixmap *pixmap; GdkBitmap *mask; GtkStyle *style; if (!window) { window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_signal_connect (GTK_OBJECT (window), "destroy", GTK_SIGNAL_FUNC(gtk_widget_destroyed), &window); gtk_window_set_title (GTK_WINDOW (window), "pixmap"); gtk_container_border_width (GTK_CONTAINER (window), 0); gtk_widget_realize(window); box1 = gtk_vbox_new (FALSE, 0); gtk_container_add (GTK_CONTAINER (window), box1); gtk_widget_show (box1); box2 = gtk_vbox_new (FALSE, 10); gtk_container_border_width (GTK_CONTAINER (box2), 10); gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0); gtk_widget_show (box2); button = gtk_button_new (); gtk_box_pack_start (GTK_BOX (box2), button, FALSE, FALSE, 0); gtk_widget_show (button); style=gtk_widget_get_style(button); pixmap = gdk_pixmap_create_from_xpm (window->window, &mask, &style->bg[GTK_STATE_NORMAL], "test.xpm"); pixmapwid = gtk_pixmap_new (pixmap, mask); label = gtk_label_new ("Pixmap\ntest"); box3 = gtk_hbox_new (FALSE, 0); gtk_container_border_width (GTK_CONTAINER (box3), 2); gtk_container_add (GTK_CONTAINER (box3), pixmapwid); gtk_container_add (GTK_CONTAINER (box3), label); gtk_container_add (GTK_CONTAINER (button), box3); gtk_widget_show (pixmapwid); gtk_widget_show (label); gtk_widget_show (box3); separator = gtk_hseparator_new (); gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0); gtk_widget_show (separator); box2 = gtk_vbox_new (FALSE, 10); gtk_container_border_width (GTK_CONTAINER (box2), 10); gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0); gtk_widget_show (box2); button = gtk_button_new_with_label ("close"); gtk_signal_connect_object (GTK_OBJECT (button), "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy), GTK_OBJECT (window)); gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0); GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT); gtk_widget_grab_default (button); gtk_widget_show (button); } if (!GTK_WIDGET_VISIBLE (window)) gtk_widget_show (window); else gtk_widget_destroy (window); } static void tips_query_widget_entered (GtkTipsQuery *tips_query, GtkWidget *widget, const gchar *tip_text, const gchar *tip_private, GtkWidget *toggle) { if (GTK_TOGGLE_BUTTON (toggle)->active) { gtk_label_set (GTK_LABEL (tips_query), tip_text ? "There is a Tip!" : "There is no Tip!"); /* don't let GtkTipsQuery reset it's label */ gtk_signal_emit_stop_by_name (GTK_OBJECT (tips_query), "widget_entered"); } } static gint tips_query_widget_selected (GtkWidget *tips_query, GtkWidget *widget, const gchar *tip_text, const gchar *tip_private, GdkEventButton *event, gpointer func_data) { if (widget) g_print ("Help \"%s\" requested for <%s>\n", tip_private ? tip_private : "None", gtk_type_name (GTK_OBJECT_TYPE (widget))); return TRUE; } static void create_tooltips (void) { static GtkWidget *window = NULL; GtkWidget *box1; GtkWidget *box2; GtkWidget *box3; GtkWidget *button; GtkWidget *toggle; GtkWidget *frame; GtkWidget *tips_query; GtkWidget *separator; GtkTooltips *tooltips; if (!window) { window = gtk_widget_new (gtk_window_get_type (), "GtkWindow::type", GTK_WINDOW_TOPLEVEL, "GtkContainer::border_width", 0, "GtkWindow::title", "Tooltips", "GtkWindow::allow_shrink", TRUE, "GtkWindow::allow_grow", FALSE, "GtkWindow::auto_shrink", TRUE, "GtkWidget::width", 200, NULL); gtk_signal_connect (GTK_OBJECT (window), "destroy", GTK_SIGNAL_FUNC (destroy_tooltips), &window); tooltips=gtk_tooltips_new(); gtk_object_set_data (GTK_OBJECT (window), "tooltips", tooltips); box1 = gtk_vbox_new (FALSE, 0); gtk_container_add (GTK_CONTAINER (window), box1); gtk_widget_show (box1); box2 = gtk_vbox_new (FALSE, 10); gtk_container_border_width (GTK_CONTAINER (box2), 10); gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0); gtk_widget_show (box2); button = gtk_toggle_button_new_with_label ("button1"); gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0); gtk_widget_show (button); gtk_tooltips_set_tip (tooltips,button,"This is button 1", "ContextHelp/buttons/1"); button = gtk_toggle_button_new_with_label ("button2"); gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0); gtk_widget_show (button); gtk_tooltips_set_tip (tooltips, button, "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.", "ContextHelp/buttons/2_long"); toggle = gtk_toggle_button_new_with_label ("Override TipsQuery Label"); gtk_box_pack_start (GTK_BOX (box2), toggle, TRUE, TRUE, 0); gtk_widget_show (toggle); gtk_tooltips_set_tip (tooltips, toggle, "Toggle TipsQuery view.", "Hi msw! ;)"); box3 = gtk_widget_new (gtk_vbox_get_type (), "GtkBox::homogeneous", FALSE, "GtkBox::spacing", 5, "GtkContainer::border_width", 5, "GtkWidget::visible", TRUE, NULL); tips_query = gtk_tips_query_new (); button = gtk_widget_new (gtk_button_get_type (), "GtkButton::label", "[?]", "GtkWidget::visible", TRUE, "GtkWidget::parent", box3, "GtkObject::object_signal::clicked", gtk_tips_query_start_query, tips_query, NULL); gtk_box_set_child_packing (GTK_BOX (box3), button, FALSE, FALSE, 0, GTK_PACK_START); gtk_tooltips_set_tip (tooltips, button, "Start the Tooltips Inspector", "ContextHelp/buttons/?"); gtk_widget_set (tips_query, "GtkWidget::visible", TRUE, "GtkWidget::parent", box3, "GtkTipsQuery::caller", button, "GtkObject::signal::widget_entered", tips_query_widget_entered, toggle, "GtkObject::signal::widget_selected", tips_query_widget_selected, NULL, NULL); frame = gtk_widget_new (gtk_frame_get_type (), "GtkFrame::label", "ToolTips Inspector", "GtkFrame::label_xalign", (double) 0.5, "GtkContainer::border_width", 0, "GtkWidget::visible", TRUE, "GtkWidget::parent", box2, "GtkContainer::child", box3, NULL); gtk_box_set_child_packing (GTK_BOX (box2), frame, TRUE, TRUE, 10, GTK_PACK_START); separator = gtk_hseparator_new (); gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0); gtk_widget_show (separator); box2 = gtk_vbox_new (FALSE, 10); gtk_container_border_width (GTK_CONTAINER (box2), 10); gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0); gtk_widget_show (box2); button = gtk_button_new_with_label ("close"); gtk_signal_connect_object (GTK_OBJECT (button), "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy), GTK_OBJECT (window)); gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0); GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT); gtk_widget_grab_default (button); gtk_widget_show (button); gtk_tooltips_set_tip (tooltips, button, "Push this button to close window", "ContextHelp/buttons/Close"); } if (!GTK_WIDGET_VISIBLE (window)) gtk_widget_show (window); else gtk_widget_destroy (window); } static GtkWidget* create_menu (int depth) { GtkWidget *menu; GtkWidget *menuitem; GSList *group; char buf[32]; int i, j; if (depth < 1) return NULL; menu = gtk_menu_new (); group = NULL; for (i = 0, j = 1; i < 5; i++, j++) { sprintf (buf, "item %2d - %d", depth, j); menuitem = gtk_radio_menu_item_new_with_label (group, buf); group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menuitem)); if (depth % 2) gtk_check_menu_item_set_show_toggle (GTK_CHECK_MENU_ITEM (menuitem), TRUE); gtk_menu_append (GTK_MENU (menu), menuitem); gtk_widget_show (menuitem); if (i == 3) gtk_widget_set_sensitive (menuitem, FALSE); gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), create_menu (depth - 1)); } return menu; } static void create_menus (void) { static GtkWidget *window = NULL; GtkWidget *box1; GtkWidget *box2; GtkWidget *button; GtkWidget *optionmenu; GtkWidget *separator; if (!window) { GtkWidget *menubar; GtkWidget *menu; GtkWidget *menuitem; GtkAccelGroup *accel_group; window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_signal_connect (GTK_OBJECT (window), "destroy", GTK_SIGNAL_FUNC(gtk_widget_destroyed), &window); gtk_signal_connect (GTK_OBJECT (window), "delete-event", GTK_SIGNAL_FUNC (gtk_true), NULL); gtk_window_set_title (GTK_WINDOW (window), "menus"); gtk_container_border_width (GTK_CONTAINER (window), 0); box1 = gtk_vbox_new (FALSE, 0); gtk_container_add (GTK_CONTAINER (window), box1); gtk_widget_show (box1); menubar = gtk_menu_bar_new (); gtk_box_pack_start (GTK_BOX (box1), menubar, FALSE, TRUE, 0); gtk_widget_show (menubar); menu = create_menu (2); menuitem = gtk_menu_item_new_with_label ("test\nline2"); gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), menu); gtk_menu_bar_append (GTK_MENU_BAR (menubar), menuitem); gtk_widget_show (menuitem); menuitem = gtk_menu_item_new_with_label ("foo"); gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), create_menu (3)); gtk_menu_bar_append (GTK_MENU_BAR (menubar), menuitem); gtk_widget_show (menuitem); menuitem = gtk_menu_item_new_with_label ("bar"); gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), create_menu (4)); gtk_menu_item_right_justify (GTK_MENU_ITEM (menuitem)); gtk_menu_bar_append (GTK_MENU_BAR (menubar), menuitem); gtk_widget_show (menuitem); box2 = gtk_vbox_new (FALSE, 10); gtk_container_border_width (GTK_CONTAINER (box2), 10); gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0); gtk_widget_show (box2); menu = create_menu (1); accel_group = gtk_accel_group_get_default (); gtk_menu_set_accel_group (GTK_MENU (menu), accel_group); menuitem = gtk_check_menu_item_new_with_label ("Accelerate Me"); gtk_menu_append (GTK_MENU (menu), menuitem); gtk_widget_show (menuitem); gtk_widget_add_accelerator (menuitem, "activate", accel_group, GDK_F1, 0, GTK_ACCEL_VISIBLE | GTK_ACCEL_SIGNAL_VISIBLE); menuitem = gtk_check_menu_item_new_with_label ("Accelerator Locked"); gtk_menu_append (GTK_MENU (menu), menuitem); gtk_widget_show (menuitem); gtk_widget_add_accelerator (menuitem, "activate", accel_group, GDK_F2, 0, GTK_ACCEL_VISIBLE | GTK_ACCEL_LOCKED); menuitem = gtk_check_menu_item_new_with_label ("Accelerators Frozen"); gtk_menu_append (GTK_MENU (menu), menuitem); gtk_widget_show (menuitem); gtk_widget_add_accelerator (menuitem, "activate", accel_group, GDK_F2, 0, GTK_ACCEL_VISIBLE); gtk_widget_add_accelerator (menuitem, "activate", accel_group, GDK_F3, 0, GTK_ACCEL_VISIBLE); gtk_widget_freeze_accelerators (menuitem); optionmenu = gtk_option_menu_new (); gtk_option_menu_set_menu (GTK_OPTION_MENU (optionmenu), menu); gtk_option_menu_set_history (GTK_OPTION_MENU (optionmenu), 3); gtk_box_pack_start (GTK_BOX (box2), optionmenu, TRUE, TRUE, 0); gtk_widget_show (optionmenu); separator = gtk_hseparator_new (); gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0); gtk_widget_show (separator); box2 = gtk_vbox_new (FALSE, 10); gtk_container_border_width (GTK_CONTAINER (box2), 10); gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0); gtk_widget_show (box2); button = gtk_button_new_with_label ("close"); gtk_signal_connect_object (GTK_OBJECT (button), "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy), GTK_OBJECT (window)); gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0); GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT); gtk_widget_grab_default (button); gtk_widget_show (button); } if (!GTK_WIDGET_VISIBLE (window)) gtk_widget_show (window); else gtk_widget_destroy (window); } /* * GtkScrolledWindow */ static void scrolled_windows_remove (GtkWidget *widget, GtkWidget *scrollwin) { static GtkWidget *parent = NULL; static GtkWidget *float_parent; if (parent) { gtk_widget_reparent (scrollwin, parent); gtk_widget_destroy (float_parent); float_parent = NULL; parent = NULL; } else { parent = widget->parent; float_parent = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_widget_reparent (scrollwin, float_parent); gtk_widget_show (float_parent); } } /* * GtkScrolledWindow */ static void create_scrolled_windows (void) { static GtkWidget *window; GtkWidget *scrolled_window; GtkWidget *table; GtkWidget *button; char buffer[32]; int i, j; if (!window) { window = gtk_dialog_new (); gtk_signal_connect (GTK_OBJECT (window), "destroy", GTK_SIGNAL_FUNC(gtk_widget_destroyed), &window); gtk_window_set_title (GTK_WINDOW (window), "dialog"); gtk_container_border_width (GTK_CONTAINER (window), 0); scrolled_window = gtk_scrolled_window_new (NULL, NULL); gtk_container_border_width (GTK_CONTAINER (scrolled_window), 10); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), scrolled_window, TRUE, TRUE, 0); gtk_widget_show (scrolled_window); table = gtk_table_new (20, 20, FALSE); gtk_table_set_row_spacings (GTK_TABLE (table), 10); gtk_table_set_col_spacings (GTK_TABLE (table), 10); gtk_container_add (GTK_CONTAINER (scrolled_window), table); gtk_container_set_focus_hadjustment (GTK_CONTAINER (table), gtk_scrolled_window_get_hadjustment (GTK_SCROLLED_WINDOW (scrolled_window))); gtk_container_set_focus_vadjustment (GTK_CONTAINER (table), gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (scrolled_window))); gtk_widget_show (table); for (i = 0; i < 20; i++) for (j = 0; j < 20; j++) { sprintf (buffer, "button (%d,%d)\n", i, j); button = gtk_toggle_button_new_with_label (buffer); gtk_table_attach_defaults (GTK_TABLE (table), button, i, i+1, j, j+1); gtk_widget_show (button); } button = gtk_button_new_with_label ("close"); gtk_signal_connect_object (GTK_OBJECT (button), "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy), GTK_OBJECT (window)); GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT); gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area), button, TRUE, TRUE, 0); gtk_widget_grab_default (button); gtk_widget_show (button); button = gtk_button_new_with_label ("remove"); gtk_signal_connect_object (GTK_OBJECT (button), "clicked", GTK_SIGNAL_FUNC(scrolled_windows_remove), GTK_OBJECT (scrolled_window)); GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT); gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area), button, TRUE, TRUE, 0); gtk_widget_grab_default (button); gtk_widget_show (button); } if (!GTK_WIDGET_VISIBLE (window)) gtk_widget_show (window); else gtk_widget_destroy (window); } /* * GtkEntry */ static void entry_toggle_editable (GtkWidget *checkbutton, GtkWidget *entry) { gtk_entry_set_editable(GTK_ENTRY(entry), GTK_TOGGLE_BUTTON(checkbutton)->active); } static void entry_toggle_visibility (GtkWidget *checkbutton, GtkWidget *entry) { gtk_entry_set_visibility(GTK_ENTRY(entry), GTK_TOGGLE_BUTTON(checkbutton)->active); } static void create_entry (void) { static GtkWidget *window = NULL; GtkWidget *box1; GtkWidget *box2; GtkWidget *editable_check; GtkWidget *entry, *cb; GtkWidget *button; GtkWidget *separator; GList *cbitems = NULL; if (!window) { cbitems = g_list_append(cbitems, "item0"); cbitems = g_list_append(cbitems, "item1 item1"); cbitems = g_list_append(cbitems, "item2 item2 item2"); cbitems = g_list_append(cbitems, "item3 item3 item3 item3"); cbitems = g_list_append(cbitems, "item4 item4 item4 item4 item4"); cbitems = g_list_append(cbitems, "item5 item5 item5 item5 item5 item5"); cbitems = g_list_append(cbitems, "item6 item6 item6 item6 item6"); cbitems = g_list_append(cbitems, "item7 item7 item7 item7"); cbitems = g_list_append(cbitems, "item8 item8 item8"); cbitems = g_list_append(cbitems, "item9 item9"); window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_signal_connect (GTK_OBJECT (window), "destroy", GTK_SIGNAL_FUNC(gtk_widget_destroyed), &window); gtk_window_set_title (GTK_WINDOW (window), "entry"); gtk_container_border_width (GTK_CONTAINER (window), 0); box1 = gtk_vbox_new (FALSE, 0); gtk_container_add (GTK_CONTAINER (window), box1); gtk_widget_show (box1); box2 = gtk_vbox_new (FALSE, 10); gtk_container_border_width (GTK_CONTAINER (box2), 10); gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0); gtk_widget_show (box2); entry = gtk_entry_new (); gtk_entry_set_text (GTK_ENTRY (entry), "hello world"); gtk_editable_select_region (GTK_EDITABLE (entry), 0, -1); gtk_box_pack_start (GTK_BOX (box2), entry, TRUE, TRUE, 0); gtk_widget_show (entry); cb = gtk_combo_new (); gtk_combo_set_popdown_strings (GTK_COMBO (cb), cbitems); gtk_entry_set_text (GTK_ENTRY (GTK_COMBO(cb)->entry), "hello world"); gtk_editable_select_region (GTK_EDITABLE (GTK_COMBO(cb)->entry), 0, -1); gtk_box_pack_start (GTK_BOX (box2), cb, TRUE, TRUE, 0); gtk_widget_show (cb); editable_check = gtk_check_button_new_with_label("Editable"); gtk_box_pack_start (GTK_BOX (box2), editable_check, FALSE, TRUE, 0); gtk_signal_connect (GTK_OBJECT(editable_check), "toggled", GTK_SIGNAL_FUNC(entry_toggle_editable), entry); gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(editable_check), TRUE); gtk_widget_show (editable_check); editable_check = gtk_check_button_new_with_label("Visible"); gtk_box_pack_start (GTK_BOX (box2), editable_check, FALSE, TRUE, 0); gtk_signal_connect (GTK_OBJECT(editable_check), "toggled", GTK_SIGNAL_FUNC(entry_toggle_visibility), entry); gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(editable_check), TRUE); gtk_widget_show (editable_check); separator = gtk_hseparator_new (); gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0); gtk_widget_show (separator); box2 = gtk_vbox_new (FALSE, 10); gtk_container_border_width (GTK_CONTAINER (box2), 10); gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0); gtk_widget_show (box2); button = gtk_button_new_with_label ("close"); gtk_signal_connect_object (GTK_OBJECT (button), "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy), GTK_OBJECT (window)); gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0); GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT); gtk_widget_grab_default (button); gtk_widget_show (button); } if (!GTK_WIDGET_VISIBLE (window)) gtk_widget_show (window); else gtk_widget_destroy (window); } /* * GtkSpinButton */ static GtkWidget *spinner1; static void toggle_snap (GtkWidget *widget, GtkSpinButton *spin) { gtk_spin_button_set_snap_to_ticks (spin, GTK_TOGGLE_BUTTON (widget)->active); } static void toggle_numeric (GtkWidget *widget, GtkSpinButton *spin) { gtk_spin_button_set_numeric (spin, GTK_TOGGLE_BUTTON (widget)->active); } static void change_digits (GtkWidget *widget, GtkSpinButton *spin) { gtk_spin_button_set_digits (GTK_SPIN_BUTTON (spinner1), gtk_spin_button_get_value_as_int (spin)); } static void get_value (GtkWidget *widget, gpointer data) { gchar buf[32]; GtkLabel *label; GtkSpinButton *spin; spin = GTK_SPIN_BUTTON (spinner1); label = GTK_LABEL (gtk_object_get_user_data (GTK_OBJECT (widget))); if (GPOINTER_TO_INT (data) == 1) sprintf (buf, "%d", gtk_spin_button_get_value_as_int (spin)); else sprintf (buf, "%0.*f", spin->digits, gtk_spin_button_get_value_as_float (spin)); gtk_label_set (label, buf); } static void create_spins (void) { static GtkWidget *window = NULL; GtkWidget *frame; GtkWidget *hbox; GtkWidget *main_vbox; GtkWidget *vbox; GtkWidget *vbox2; GtkWidget *spinner2; GtkWidget *spinner; GtkWidget *button; GtkWidget *label; GtkWidget *val_label; GtkAdjustment *adj; if (!window) { window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_signal_connect (GTK_OBJECT (window), "destroy", GTK_SIGNAL_FUNC (gtk_widget_destroyed), &window); gtk_window_set_title (GTK_WINDOW (window), "GtkSpinButton"); main_vbox = gtk_vbox_new (FALSE, 5); gtk_container_border_width (GTK_CONTAINER (main_vbox), 10); gtk_container_add (GTK_CONTAINER (window), main_vbox); frame = gtk_frame_new ("Not accelerated"); gtk_box_pack_start (GTK_BOX (main_vbox), frame, TRUE, TRUE, 0); vbox = gtk_vbox_new (FALSE, 0); gtk_container_border_width (GTK_CONTAINER (vbox), 5); gtk_container_add (GTK_CONTAINER (frame), vbox); /* Day, month, year spinners */ hbox = gtk_hbox_new (FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 5); vbox2 = gtk_vbox_new (FALSE, 0); gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 5); label = gtk_label_new ("Day :"); gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5); gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, TRUE, 0); adj = (GtkAdjustment *) gtk_adjustment_new (1.0, 1.0, 31.0, 1.0, 5.0, 0.0); spinner = gtk_spin_button_new (adj, 0, 0); gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spinner), TRUE); gtk_spin_button_set_shadow_type (GTK_SPIN_BUTTON (spinner), GTK_SHADOW_OUT); gtk_box_pack_start (GTK_BOX (vbox2), spinner, FALSE, TRUE, 0); vbox2 = gtk_vbox_new (FALSE, 0); gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 5); label = gtk_label_new ("Month :"); gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5); gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, TRUE, 0); adj = (GtkAdjustment *) gtk_adjustment_new (1.0, 1.0, 12.0, 1.0, 5.0, 0.0); spinner = gtk_spin_button_new (adj, 0, 0); gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spinner), TRUE); gtk_spin_button_set_shadow_type (GTK_SPIN_BUTTON (spinner), GTK_SHADOW_ETCHED_IN); gtk_box_pack_start (GTK_BOX (vbox2), spinner, FALSE, TRUE, 0); vbox2 = gtk_vbox_new (FALSE, 0); gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 5); label = gtk_label_new ("Year :"); gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5); gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, TRUE, 0); adj = (GtkAdjustment *) gtk_adjustment_new (1998.0, 0.0, 2100.0, 1.0, 100.0, 0.0); spinner = gtk_spin_button_new (adj, 0, 0); gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spinner), TRUE); gtk_spin_button_set_shadow_type (GTK_SPIN_BUTTON (spinner), GTK_SHADOW_IN); gtk_widget_set_usize (spinner, 55, 0); gtk_box_pack_start (GTK_BOX (vbox2), spinner, FALSE, TRUE, 0); frame = gtk_frame_new ("Accelerated"); gtk_box_pack_start (GTK_BOX (main_vbox), frame, TRUE, TRUE, 0); vbox = gtk_vbox_new (FALSE, 0); gtk_container_border_width (GTK_CONTAINER (vbox), 5); gtk_container_add (GTK_CONTAINER (frame), vbox); hbox = gtk_hbox_new (FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 5); vbox2 = gtk_vbox_new (FALSE, 0); gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 5); label = gtk_label_new ("Value :"); gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5); gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, TRUE, 0); adj = (GtkAdjustment *) gtk_adjustment_new (0.0, -10000.0, 10000.0, 0.5, 100.0, 0.0); spinner1 = gtk_spin_button_new (adj, 1.0, 2); gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spinner1), TRUE); gtk_widget_set_usize (spinner1, 100, 0); gtk_box_pack_start (GTK_BOX (vbox2), spinner1, FALSE, TRUE, 0); vbox2 = gtk_vbox_new (FALSE, 0); gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 5); label = gtk_label_new ("Digits :"); gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5); gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, TRUE, 0); adj = (GtkAdjustment *) gtk_adjustment_new (2, 1, 5, 1, 1, 0); spinner2 = gtk_spin_button_new (adj, 0.0, 0); gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spinner2), TRUE); gtk_signal_connect (GTK_OBJECT (adj), "value_changed", GTK_SIGNAL_FUNC (change_digits), (gpointer) spinner2); gtk_box_pack_start (GTK_BOX (vbox2), spinner2, FALSE, TRUE, 0); hbox = gtk_hbox_new (FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 5); button = gtk_check_button_new_with_label ("Snap to 0.5-ticks"); gtk_signal_connect (GTK_OBJECT (button), "clicked", GTK_SIGNAL_FUNC (toggle_snap), spinner1); gtk_box_pack_start (GTK_BOX (vbox), button, TRUE, TRUE, 0); gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON (button), TRUE); button = gtk_check_button_new_with_label ("Numeric only input mode"); gtk_signal_connect (GTK_OBJECT (button), "clicked", GTK_SIGNAL_FUNC (toggle_numeric), spinner1); gtk_box_pack_start (GTK_BOX (vbox), button, TRUE, TRUE, 0); gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON (button), TRUE); val_label = gtk_label_new (""); hbox = gtk_hbox_new (FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 5); button = gtk_button_new_with_label ("Value as Int"); gtk_object_set_user_data (GTK_OBJECT (button), val_label); gtk_signal_connect (GTK_OBJECT (button), "clicked", GTK_SIGNAL_FUNC (get_value), GINT_TO_POINTER (1)); gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5); button = gtk_button_new_with_label ("Value as Float"); gtk_object_set_user_data (GTK_OBJECT (button), val_label); gtk_signal_connect (GTK_OBJECT (button), "clicked", GTK_SIGNAL_FUNC (get_value), GINT_TO_POINTER (2)); gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5); gtk_box_pack_start (GTK_BOX (vbox), val_label, TRUE, TRUE, 0); gtk_label_set (GTK_LABEL (val_label), "0"); hbox = gtk_hbox_new (FALSE, 0); gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, TRUE, 0); button = gtk_button_new_with_label ("Close"); gtk_signal_connect_object (GTK_OBJECT (button), "clicked", GTK_SIGNAL_FUNC (gtk_widget_destroy), GTK_OBJECT (window)); gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5); } if (!GTK_WIDGET_VISIBLE (window)) gtk_widget_show_all (window); else gtk_widget_destroy (window); } /* * Cursors */ static gint cursor_expose_event (GtkWidget *widget, GdkEvent *event, gpointer user_data) { GtkDrawingArea *darea; GdkDrawable *drawable; GdkGC *black_gc; GdkGC *gray_gc; GdkGC *white_gc; guint max_width; guint max_height; g_return_val_if_fail (widget != NULL, TRUE); g_return_val_if_fail (GTK_IS_DRAWING_AREA (widget), TRUE); darea = GTK_DRAWING_AREA (widget); drawable = widget->window; white_gc = widget->style->white_gc; gray_gc = widget->style->bg_gc[GTK_STATE_NORMAL]; black_gc = widget->style->black_gc; max_width = widget->allocation.width; max_height = widget->allocation.height; gdk_draw_rectangle (drawable, white_gc, TRUE, 0, 0, max_width, max_height / 2); gdk_draw_rectangle (drawable, black_gc, TRUE, 0, max_height / 2, max_width, max_height / 2); gdk_draw_rectangle (drawable, gray_gc, TRUE, max_width / 3, max_height / 3, max_width / 3, max_height / 3); return TRUE; } static void set_cursor (GtkWidget *spinner, GtkWidget *widget) { guint c; GdkCursor *cursor; c = CLAMP (gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (spinner)), 0, 152); c &= 0xfe; cursor = gdk_cursor_new (c); gdk_window_set_cursor (widget->window, cursor); gdk_cursor_destroy (cursor); } static gint cursor_event (GtkWidget *widget, GdkEvent *event, GtkSpinButton *spinner) { if ((event->type == GDK_BUTTON_PRESS) && ((event->button.button == 1) || (event->button.button == 3))) { gtk_spin_button_spin (spinner, event->button.button == 1 ? GTK_SPIN_STEP_FORWARD : GTK_SPIN_STEP_BACKWARD, 0); return TRUE; } return FALSE; } static void create_cursors (void) { static GtkWidget *window = NULL; GtkWidget *frame; GtkWidget *hbox; GtkWidget *main_vbox; GtkWidget *vbox; GtkWidget *darea; GtkWidget *spinner; GtkWidget *button; GtkWidget *label; GtkWidget *any; GtkAdjustment *adj; if (!window) { window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_signal_connect (GTK_OBJECT (window), "destroy", GTK_SIGNAL_FUNC (gtk_widget_destroyed), &window); gtk_window_set_title (GTK_WINDOW (window), "Cursors"); main_vbox = gtk_vbox_new (FALSE, 5); gtk_container_border_width (GTK_CONTAINER (main_vbox), 0); gtk_container_add (GTK_CONTAINER (window), main_vbox); vbox = gtk_widget_new (gtk_vbox_get_type (), "GtkBox::homogeneous", FALSE, "GtkBox::spacing", 5, "GtkContainer::border_width", 10, "GtkWidget::parent", main_vbox, "GtkWidget::visible", TRUE, NULL); hbox = gtk_hbox_new (FALSE, 0); gtk_container_border_width (GTK_CONTAINER (hbox), 5); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0); label = gtk_label_new ("Cursor Value:"); gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0); adj = (GtkAdjustment *) gtk_adjustment_new (0, 0, 152, 2, 10, 0); spinner = gtk_spin_button_new (adj, 0, 0); gtk_box_pack_start (GTK_BOX (hbox), spinner, TRUE, TRUE, 0); frame = gtk_widget_new (gtk_frame_get_type (), "GtkFrame::shadow", GTK_SHADOW_ETCHED_IN, "GtkFrame::label_xalign", 0.5, "GtkFrame::label", "Cursor Area", "GtkContainer::border_width", 10, "GtkWidget::parent", vbox, "GtkWidget::visible", TRUE, NULL); darea = gtk_drawing_area_new (); gtk_widget_set_usize (darea, 80, 80); gtk_container_add (GTK_CONTAINER (frame), darea); gtk_signal_connect (GTK_OBJECT (darea), "expose_event", GTK_SIGNAL_FUNC (cursor_expose_event), NULL); gtk_widget_set_events (darea, GDK_EXPOSURE_MASK | GDK_BUTTON_PRESS_MASK); gtk_signal_connect (GTK_OBJECT (darea), "button_press_event", GTK_SIGNAL_FUNC (cursor_event), spinner); gtk_widget_show (darea); gtk_signal_connect (GTK_OBJECT (spinner), "changed", GTK_SIGNAL_FUNC (set_cursor), darea); any = gtk_widget_new (gtk_hseparator_get_type (), "GtkWidget::visible", TRUE, NULL); gtk_box_pack_start (GTK_BOX (main_vbox), any, FALSE, TRUE, 0); hbox = gtk_hbox_new (FALSE, 0); gtk_container_border_width (GTK_CONTAINER (hbox), 10); gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, TRUE, 0); button = gtk_button_new_with_label ("Close"); gtk_signal_connect_object (GTK_OBJECT (button), "clicked", GTK_SIGNAL_FUNC (gtk_widget_destroy), GTK_OBJECT (window)); gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5); gtk_widget_show_all (window); set_cursor (spinner, darea); } else gtk_widget_destroy (window); } /* * GtkList */ static void list_add (GtkWidget *widget, GtkWidget *list) { static int i = 1; gchar buffer[64]; GtkWidget *list_item; sprintf (buffer, "added item %d", i++); list_item = gtk_list_item_new_with_label (buffer); gtk_widget_show (list_item); gtk_container_add (GTK_CONTAINER (list), list_item); } static void list_remove (GtkWidget *widget, GtkWidget *list) { GList *tmp_list; GList *clear_list; tmp_list = GTK_LIST (list)->selection; clear_list = NULL; while (tmp_list) { clear_list = g_list_prepend (clear_list, tmp_list->data); tmp_list = tmp_list->next; } clear_list = g_list_reverse (clear_list); gtk_list_remove_items (GTK_LIST (list), clear_list); g_list_free (clear_list); } static void list_clear (GtkWidget *widget, GtkWidget *list) { gtk_list_clear_items (GTK_LIST (list), 3 - 1, 6 - 1); } static void create_list (void) { static GtkWidget *window = NULL; static char *list_items[] = { "hello", "world", "blah", "foo", "bar", "argh", "spencer", "is a", "wussy", "programmer", }; static int nlist_items = sizeof (list_items) / sizeof (list_items[0]); GtkWidget *box1; GtkWidget *box2; GtkWidget *scrolled_win; GtkWidget *list; GtkWidget *list_item; GtkWidget *button; GtkWidget *separator; int i; if (!window) { window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_signal_connect (GTK_OBJECT (window), "destroy", GTK_SIGNAL_FUNC(gtk_widget_destroyed), &window); gtk_window_set_title (GTK_WINDOW (window), "list"); gtk_container_border_width (GTK_CONTAINER (window), 0); box1 = gtk_vbox_new (FALSE, 0); gtk_container_add (GTK_CONTAINER (window), box1); gtk_widget_show (box1); box2 = gtk_vbox_new (FALSE, 10); gtk_container_border_width (GTK_CONTAINER (box2), 10); gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0); gtk_widget_show (box2); scrolled_win = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_box_pack_start (GTK_BOX (box2), scrolled_win, TRUE, TRUE, 0); gtk_widget_show (scrolled_win); list = gtk_list_new (); gtk_list_set_selection_mode (GTK_LIST (list), GTK_SELECTION_MULTIPLE); gtk_list_set_selection_mode (GTK_LIST (list), GTK_SELECTION_BROWSE); gtk_container_add (GTK_CONTAINER (scrolled_win), list); gtk_container_set_focus_vadjustment (GTK_CONTAINER (list), gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (scrolled_win))); gtk_widget_show (list); for (i = 0; i < nlist_items; i++) { list_item = gtk_list_item_new_with_label (list_items[i]); gtk_container_add (GTK_CONTAINER (list), list_item); gtk_widget_show (list_item); } button = gtk_button_new_with_label ("add"); GTK_WIDGET_UNSET_FLAGS (button, GTK_CAN_FOCUS); gtk_signal_connect (GTK_OBJECT (button), "clicked", GTK_SIGNAL_FUNC(list_add), list); gtk_box_pack_start (GTK_BOX (box2), button, FALSE, TRUE, 0); gtk_widget_show (button); button = gtk_button_new_with_label ("clear items 3 - 5"); GTK_WIDGET_UNSET_FLAGS (button, GTK_CAN_FOCUS); gtk_signal_connect (GTK_OBJECT (button), "clicked", GTK_SIGNAL_FUNC(list_clear), list); gtk_box_pack_start (GTK_BOX (box2), button, FALSE, TRUE, 0); gtk_widget_show (button); button = gtk_button_new_with_label ("remove"); GTK_WIDGET_UNSET_FLAGS (button, GTK_CAN_FOCUS); gtk_signal_connect (GTK_OBJECT (button), "clicked", GTK_SIGNAL_FUNC(list_remove), list); gtk_box_pack_start (GTK_BOX (box2), button, FALSE, TRUE, 0); gtk_widget_show (button); separator = gtk_hseparator_new (); gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0); gtk_widget_show (separator); box2 = gtk_vbox_new (FALSE, 10); gtk_container_border_width (GTK_CONTAINER (box2), 10); gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0); gtk_widget_show (box2); button = gtk_button_new_with_label ("close"); gtk_signal_connect_object (GTK_OBJECT (button), "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy), GTK_OBJECT (window)); gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0); GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT); gtk_widget_grab_default (button); gtk_widget_show (button); } if (!GTK_WIDGET_VISIBLE (window)) gtk_widget_show (window); else gtk_widget_destroy (window); } /* * GtkCList */ #define TESTGTK_CLIST_COLUMNS 7 static gint clist_rows = 0; static gint clist_selected_row = 0; static void add1000_clist (GtkWidget *widget, gpointer data) { gint i, row; char text[TESTGTK_CLIST_COLUMNS][50]; char *texts[TESTGTK_CLIST_COLUMNS]; GdkBitmap *mask; GdkPixmap *pixmap; pixmap = gdk_pixmap_create_from_xpm (GTK_CLIST (data)->clist_window, &mask, >K_WIDGET (data)->style->white, "3DRings.xpm"); for (i = 0; i < TESTGTK_CLIST_COLUMNS; i++) { texts[i] = text[i]; sprintf (text[i], "Column %d", i); } texts[3] = NULL; sprintf (text[1], "Right"); sprintf (text[2], "Center"); gtk_clist_freeze (GTK_CLIST (data)); for (i = 0; i < 1000; i++) { sprintf (text[0], "Row %d", clist_rows++); row = gtk_clist_append (GTK_CLIST (data), texts); gtk_clist_set_pixtext (GTK_CLIST (data), row, 3, "Hello World", 5, pixmap, mask); } gtk_clist_thaw (GTK_CLIST (data)); gdk_pixmap_unref (pixmap); gdk_bitmap_unref (mask); } static void add10000_clist (GtkWidget *widget, gpointer data) { gint i; char text[TESTGTK_CLIST_COLUMNS][50]; char *texts[TESTGTK_CLIST_COLUMNS]; for (i = 0; i < TESTGTK_CLIST_COLUMNS; i++) { texts[i] = text[i]; sprintf (text[i], "Column %d", i); } sprintf (text[1], "Right"); sprintf (text[2], "Center"); gtk_clist_freeze (GTK_CLIST (data)); for (i = 0; i < 10000; i++) { sprintf (text[0], "Row %d", clist_rows++); gtk_clist_append (GTK_CLIST (data), texts); } gtk_clist_thaw (GTK_CLIST (data)); } void clear_clist (GtkWidget *widget, gpointer data) { gtk_clist_clear (GTK_CLIST (data)); clist_rows = 0; } void remove_row_clist (GtkWidget *widget, gpointer data) { gtk_clist_remove (GTK_CLIST (data), clist_selected_row); clist_rows--; } void show_titles_clist (GtkWidget *widget, gpointer data) { gtk_clist_column_titles_show (GTK_CLIST (data)); } void hide_titles_clist (GtkWidget *widget, gpointer data) { gtk_clist_column_titles_hide (GTK_CLIST (data)); } void select_clist (GtkWidget *widget, gint row, gint column, GdkEventButton * bevent) { gint i; guint8 spacing; gchar *text; GdkPixmap *pixmap; GdkBitmap *mask; GList *list; g_print ("GtkCList Selection: row %d column %d button %d\n", row, column, bevent ? bevent->button : 0); for (i = 0; i < TESTGTK_CLIST_COLUMNS; i++) { switch (gtk_clist_get_cell_type (GTK_CLIST (widget), row, i)) { case GTK_CELL_TEXT: g_print ("CELL %d GTK_CELL_TEXT\n", i); gtk_clist_get_text (GTK_CLIST (widget), row, i, &text); g_print ("TEXT: %s\n", text); break; case GTK_CELL_PIXMAP: g_print ("CELL %d GTK_CELL_PIXMAP\n", i); gtk_clist_get_pixmap (GTK_CLIST (widget), row, i, &pixmap, &mask); g_print ("PIXMAP: %p\n", pixmap); g_print ("MASK: %p\n", mask); break; case GTK_CELL_PIXTEXT: g_print ("CELL %d GTK_CELL_PIXTEXT\n", i); gtk_clist_get_pixtext (GTK_CLIST (widget), row, i, &text, &spacing, &pixmap, &mask); g_print ("TEXT: %s\n", text); g_print ("SPACING: %d\n", spacing); g_print ("PIXMAP: %p\n", pixmap); g_print ("MASK: %p\n", mask); break; default: break; } } /* print selections list */ g_print ("\nSelected Rows:"); list = GTK_CLIST (widget)->selection; while (list) { g_print (" %d ", GPOINTER_TO_INT (list->data)); list = list->next; } g_print ("\n\n\n"); clist_selected_row = row; } void unselect_clist (GtkWidget *widget, gint row, gint column, GdkEventButton * bevent) { gint i; guint8 spacing; gchar *text; GdkPixmap *pixmap; GdkBitmap *mask; GList *list; g_print ("GtkCList Unselection: row %d column %d button %d\n", row, column, bevent ? bevent->button : 0); for (i = 0; i < TESTGTK_CLIST_COLUMNS; i++) { switch (gtk_clist_get_cell_type (GTK_CLIST (widget), row, i)) { case GTK_CELL_TEXT: g_print ("CELL %d GTK_CELL_TEXT\n", i); gtk_clist_get_text (GTK_CLIST (widget), row, i, &text); g_print ("TEXT: %s\n", text); break; case GTK_CELL_PIXMAP: g_print ("CELL %d GTK_CELL_PIXMAP\n", i); gtk_clist_get_pixmap (GTK_CLIST (widget), row, i, &pixmap, &mask); g_print ("PIXMAP: %p\n", pixmap); g_print ("MASK: %p\n", mask); break; case GTK_CELL_PIXTEXT: g_print ("CELL %d GTK_CELL_PIXTEXT\n", i); gtk_clist_get_pixtext (GTK_CLIST (widget), row, i, &text, &spacing, &pixmap, &mask); g_print ("TEXT: %s\n", text); g_print ("SPACING: %d\n", spacing); g_print ("PIXMAP: %p\n", pixmap); g_print ("MASK: %p\n", mask); break; default: break; } } /* print selections list */ g_print ("\nSelected Rows:"); list = GTK_CLIST (widget)->selection; while (list) { g_print (" %d ", GPOINTER_TO_INT (list->data)); list = list->next; } g_print ("\n\n\n"); clist_selected_row = row; } static void insert_row_clist (GtkWidget *widget, gpointer data) { static char *text[] = { "This", "is", "a", "inserted", "row", "la la la la la", "la la la la" }; gtk_clist_insert (GTK_CLIST (data), clist_selected_row, text); clist_rows++; } static void clist_warning_test (GtkWidget *button, GtkWidget *clist) { GtkWidget *child; static gboolean add_remove = FALSE; add_remove = !add_remove; child = gtk_label_new ("Test"); gtk_widget_ref (child); gtk_object_sink (GTK_OBJECT (child)); if (add_remove) gtk_container_add (GTK_CONTAINER (clist), child); else { child->parent = clist; gtk_container_remove (GTK_CONTAINER (clist), child); child->parent = NULL; } gtk_widget_destroy (child); gtk_widget_unref (child); } static void create_clist (void) { gint i; static GtkWidget *window = NULL; static char *titles[] = { "Title 0", "Title 1", "Title 2", "Title 3", "Title 4", "Title 5", "Title 6" }; char text[TESTGTK_CLIST_COLUMNS][50]; char *texts[TESTGTK_CLIST_COLUMNS]; GtkWidget *box1; GtkWidget *box2; GtkWidget *clist; GtkWidget *button; GtkWidget *separator; if (!window) { window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_signal_connect (GTK_OBJECT (window), "destroy", GTK_SIGNAL_FUNC(gtk_widget_destroyed), &window); gtk_window_set_title (GTK_WINDOW (window), "clist"); gtk_container_border_width (GTK_CONTAINER (window), 0); box1 = gtk_vbox_new (FALSE, 0); gtk_container_add (GTK_CONTAINER (window), box1); gtk_widget_show (box1); box2 = gtk_hbox_new (FALSE, 10); gtk_container_border_width (GTK_CONTAINER (box2), 10); gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0); gtk_widget_show (box2); /* create GtkCList here so we have a pointer to throw at the * button callbacks -- more is done with it later */ clist = gtk_clist_new_with_titles (TESTGTK_CLIST_COLUMNS, titles); /*clist = gtk_clist_new (TESTGTK_CLIST_COLUMNS);*/ /* control buttons */ button = gtk_button_new_with_label ("Add 1,000 Rows With Pixmaps"); gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0); gtk_signal_connect (GTK_OBJECT (button), "clicked", (GtkSignalFunc) add1000_clist, (gpointer) clist); gtk_widget_show (button); button = gtk_button_new_with_label ("Add 10,000 Rows"); gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0); gtk_signal_connect (GTK_OBJECT (button), "clicked", (GtkSignalFunc) add10000_clist, (gpointer) clist); gtk_widget_show (button); button = gtk_button_new_with_label ("Clear List"); gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0); gtk_signal_connect (GTK_OBJECT (button), "clicked", (GtkSignalFunc) clear_clist, (gpointer) clist); gtk_widget_show (button); button = gtk_button_new_with_label ("Remove Row"); gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0); gtk_signal_connect (GTK_OBJECT (button), "clicked", (GtkSignalFunc) remove_row_clist, (gpointer) clist); gtk_widget_show (button); /* second layer of buttons */ box2 = gtk_hbox_new (FALSE, 10); gtk_container_border_width (GTK_CONTAINER (box2), 10); gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0); gtk_widget_show (box2); button = gtk_button_new_with_label ("Insert Row"); gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0); gtk_signal_connect (GTK_OBJECT (button), "clicked", (GtkSignalFunc) insert_row_clist, (gpointer) clist); gtk_widget_show (button); button = gtk_button_new_with_label ("Show Title Buttons"); gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0); gtk_signal_connect (GTK_OBJECT (button), "clicked", (GtkSignalFunc) show_titles_clist, (gpointer) clist); gtk_widget_show (button); button = gtk_button_new_with_label ("Hide Title Buttons"); gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0); gtk_signal_connect (GTK_OBJECT (button), "clicked", (GtkSignalFunc) hide_titles_clist, (gpointer) clist); gtk_widget_show (button); button = gtk_button_new_with_label ("Warning Test"); gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0); gtk_signal_connect (GTK_OBJECT (button), "clicked", (GtkSignalFunc) clist_warning_test, (gpointer) clist); gtk_widget_show (button); /* vbox for the list itself */ box2 = gtk_vbox_new (FALSE, 10); gtk_container_border_width (GTK_CONTAINER (box2), 10); gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0); gtk_widget_show (box2); /* * the rest of the clist configuration */ gtk_clist_set_row_height (GTK_CLIST (clist), 20); gtk_signal_connect (GTK_OBJECT (clist), "select_row", (GtkSignalFunc) select_clist, NULL); gtk_signal_connect (GTK_OBJECT (clist), "unselect_row", (GtkSignalFunc) unselect_clist, NULL); gtk_clist_set_column_width (GTK_CLIST (clist), 0, 100); for (i = 1; i < TESTGTK_CLIST_COLUMNS; i++) gtk_clist_set_column_width (GTK_CLIST (clist), i, 80); gtk_clist_set_selection_mode (GTK_CLIST (clist), GTK_SELECTION_BROWSE); gtk_clist_set_policy (GTK_CLIST (clist), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_clist_set_column_justification (GTK_CLIST (clist), 1, GTK_JUSTIFY_RIGHT); gtk_clist_set_column_justification (GTK_CLIST (clist), 2, GTK_JUSTIFY_CENTER); for (i = 0; i < TESTGTK_CLIST_COLUMNS; i++) { texts[i] = text[i]; sprintf (text[i], "Column %d", i); } sprintf (text[1], "Right"); sprintf (text[2], "Center"); for (i = 0; i < 100; i++) { sprintf (text[0], "Row %d", clist_rows++); gtk_clist_append (GTK_CLIST (clist), texts); } gtk_container_border_width (GTK_CONTAINER (clist), 5); gtk_box_pack_start (GTK_BOX (box2), clist, TRUE, TRUE, 0); gtk_widget_show (clist); separator = gtk_hseparator_new (); gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0); gtk_widget_show (separator); box2 = gtk_vbox_new (FALSE, 10); gtk_container_border_width (GTK_CONTAINER (box2), 10); gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0); gtk_widget_show (box2); button = gtk_button_new_with_label ("close"); gtk_signal_connect_object (GTK_OBJECT (button), "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy), GTK_OBJECT (window)); gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0); GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT); gtk_widget_grab_default (button); gtk_widget_show (button); } if (!GTK_WIDGET_VISIBLE (window)) gtk_widget_show (window); else { clist_rows = 0; gtk_widget_destroy (window); } } /* * GtkCTree */ static char * book_open_xpm[] = { "16 16 4 1", " c None s None", ". c black", "X c #808080", "o c white", " ", " .. ", " .Xo. ... ", " .Xoo. ..oo. ", " .Xooo.Xooo... ", " .Xooo.oooo.X. ", " .Xooo.Xooo.X. ", " .Xooo.oooo.X. ", " .Xooo.Xooo.X. ", " .Xooo.oooo.X. ", " .Xoo.Xoo..X. ", " .Xo.o..ooX. ", " .X..XXXXX. ", " ..X....... ", " .. ", " "}; static char * book_closed_xpm[] = { "16 16 6 1", " c None s None", ". c black", "X c red", "o c yellow", "O c #808080", "# c white", " ", " .. ", " ..XX. ", " ..XXXXX. ", " ..XXXXXXXX. ", ".ooXXXXXXXXX. ", "..ooXXXXXXXXX. ", ".X.ooXXXXXXXXX. ", ".XX.ooXXXXXX.. ", " .XX.ooXXX..#O ", " .XX.oo..##OO. ", " .XX..##OO.. ", " .X.#OO.. ", " ..O.. ", " .. ", " "}; static char * mini_page_xpm[] = { "16 16 4 1", " c None s None", ". c black", "X c white", "o c #808080", " ", " ....... ", " .XXXXX.. ", " .XoooX.X. ", " .XXXXX.... ", " .XooooXoo.o ", " .XXXXXXXX.o ", " .XooooooX.o ", " .XXXXXXXX.o ", " .XooooooX.o ", " .XXXXXXXX.o ", " .XooooooX.o ", " .XXXXXXXX.o ", " ..........o ", " oooooooooo ", " "}; GdkPixmap *pixmap1; GdkPixmap *pixmap2; GdkPixmap *pixmap3; GdkBitmap *mask1; GdkBitmap *mask2; GdkBitmap *mask3; static gint books = 0; static gint pages = 0; static GtkWidget *book_label; static GtkWidget *page_label; static GtkWidget *sel_label; static GtkWidget *vis_label; static GtkWidget *omenu; static GtkWidget *omenu2; static GtkWidget *omenu3; static GtkWidget *spin1; static GtkWidget *spin2; static GtkWidget *spin3; #define RADIOMENUTOGGLED(_rmi_, __i) { \ GSList * __g; \ __i = 0; \ __g = gtk_radio_menu_item_group(_rmi_); \ while( __g && !((GtkCheckMenuItem *)(__g->data))->active) { \ __g = __g->next; \ __i++; \ }\ } #define RADIOBUTTONTOGGLED(_rb_, __i) { \ GSList * __g; \ __i = 0; \ __g = gtk_radio_button_group(_rb_); \ while( __g && !((GtkToggleButton *)(__g->data))->active) { \ __g = __g->next; \ __i++; \ }\ } void after_press (GtkCTree *ctree, gpointer data) { char buf[80]; sprintf (buf, "%d", g_list_length (GTK_CLIST (ctree)->selection)); gtk_label_set (GTK_LABEL (sel_label), buf); sprintf (buf, "%d", g_list_length (GTK_CLIST (ctree)->row_list)); gtk_label_set (GTK_LABEL (vis_label), buf); sprintf (buf, "%d", books); gtk_label_set (GTK_LABEL (book_label), buf); sprintf (buf, "%d", pages); gtk_label_set (GTK_LABEL (page_label), buf); } void after_move (GtkCTree *ctree, GList *child, GList *parent, GList *sibling, gpointer data) { char *source; char *target1; char *target2; gtk_ctree_get_node_info (ctree, child, &source, NULL, NULL, NULL, NULL, NULL, NULL, NULL); if (parent) gtk_ctree_get_node_info (ctree, parent, &target1, NULL, NULL, NULL, NULL, NULL, NULL, NULL); if (sibling) gtk_ctree_get_node_info (ctree, sibling, &target2, NULL, NULL, NULL, NULL, NULL, NULL, NULL); g_print ("Moving \"%s\" to \"%s\" with sibling \"%s\".\n", source, (parent) ? target1 : "nil", (sibling) ? target2 : "nil"); } gint button_press (GtkCTree *ctree, GdkEventButton *event, gpointer data) { gint row; gint column; GList *work; gint res; res = gtk_clist_get_selection_info (GTK_CLIST (ctree), event->x, event->y, &row, &column); if (!res && event->button != 3) return FALSE; work = g_list_nth (GTK_CLIST (ctree)->row_list, row); switch (event->button) { case 1: if (GTK_CLIST (ctree)->selection_mode == GTK_SELECTION_MULTIPLE && event->state & GDK_SHIFT_MASK) gtk_signal_emit_stop_by_name (GTK_OBJECT (ctree),"button_press_event"); break; case 2: if (GTK_CTREE_ROW (work)->children && gtk_ctree_is_hot_spot (ctree, event->x, event->y)) { if (GTK_CTREE_ROW (work)->expanded) gtk_ctree_collapse_recursive (ctree, work); else gtk_ctree_expand_recursive (ctree, work); after_press (ctree, NULL); gtk_signal_emit_stop_by_name (GTK_OBJECT (ctree), "button_press_event"); } break; default: break; } return FALSE; } gint button_release (GtkCTree *ctree, GdkEventButton *event, gpointer data) { gint row; gint column; GList *work; gint res; res = gtk_clist_get_selection_info (GTK_CLIST (ctree), event->x, event->y, &row, &column); if (!res || event->button != 1) return FALSE; work = g_list_nth (GTK_CLIST (ctree)->row_list, row); if (GTK_CLIST (ctree)->selection_mode == GTK_SELECTION_MULTIPLE && event->state & GDK_SHIFT_MASK) { if (GTK_CTREE_ROW (work)->row.state == GTK_STATE_SELECTED) gtk_ctree_unselect_recursive (ctree, work); else gtk_ctree_select_recursive (ctree, work); after_press (ctree, NULL); gtk_signal_emit_stop_by_name (GTK_OBJECT (ctree), "button_release_event"); } return FALSE; } void count_items (GtkCTree *ctree, GList *list) { if (GTK_CTREE_ROW (list)->is_leaf) pages--; else books--; } void expand_all (GtkWidget *widget, GtkCTree *ctree) { gtk_ctree_expand_recursive (ctree, NULL); after_press (ctree, NULL); } void collapse_all (GtkWidget *widget, GtkCTree *ctree) { gtk_ctree_collapse_recursive (ctree, NULL); after_press (ctree, NULL); } void select_all (GtkWidget *widget, GtkCTree *ctree) { gtk_ctree_select_recursive (ctree, NULL); after_press (ctree, NULL); } void unselect_all (GtkWidget *widget, GtkCTree *ctree) { gtk_ctree_unselect_recursive (ctree, NULL); after_press (ctree, NULL); } void remove_selection (GtkWidget *widget, GtkCTree *ctree) { GList *work; GList *selection; GList *new_sel; selection = GTK_CLIST (ctree)->selection; new_sel = NULL; gtk_clist_freeze (GTK_CLIST (ctree)); while (selection) { work = selection->data; if (GTK_CTREE_ROW (work)->is_leaf) pages--; else gtk_ctree_post_recursive (ctree, work, (GtkCTreeFunc) count_items, NULL); if (GTK_CLIST (ctree)->selection_mode == GTK_SELECTION_BROWSE) { if (GTK_CTREE_ROW (work)->children) { new_sel = GTK_CTREE_ROW (work)->sibling; if (!new_sel) new_sel = work->prev; } else { if (work->next) new_sel = work->next; else new_sel = work->prev; } } gtk_ctree_remove (ctree, work); selection = GTK_CLIST (ctree)->selection; } if (new_sel) gtk_ctree_select (ctree, new_sel); gtk_clist_thaw (GTK_CLIST (ctree)); after_press (ctree, NULL); } void sort_all (GtkWidget *widget, GtkCTree *ctree) { gtk_ctree_sort_recursive (ctree, NULL); } void change_indent (GtkWidget *widget, GtkCTree *ctree) { gtk_ctree_set_indent (ctree, GTK_ADJUSTMENT (widget)->value); } void toggle_reorderable (GtkWidget *widget, GtkCTree *ctree) { gtk_ctree_set_reorderable (ctree, GTK_TOGGLE_BUTTON (widget)->active); } void toggle_line_style (GtkWidget *widget, GtkCTree *ctree) { gint i; if (!GTK_WIDGET_MAPPED (widget)) return; RADIOMENUTOGGLED ((GtkRadioMenuItem *) (((GtkOptionMenu *)omenu2)->menu_item),i); gtk_ctree_set_line_style (ctree, (GtkCTreeLineStyle) (2-i)); } void toggle_justify (GtkWidget *widget, GtkCTree *ctree) { gint i; if (!GTK_WIDGET_MAPPED (widget)) return; RADIOMENUTOGGLED ((GtkRadioMenuItem *) (((GtkOptionMenu *)omenu3)->menu_item),i); gtk_clist_set_column_justification (GTK_CLIST (ctree), 0, (GtkJustification) (1-i)); } void toggle_sel_mode (GtkWidget *widget, GtkCTree *ctree) { gint i; if (!GTK_WIDGET_MAPPED (widget)) return; RADIOMENUTOGGLED ((GtkRadioMenuItem *) (((GtkOptionMenu *)omenu)->menu_item), i); gtk_ctree_set_selection_mode (ctree, (GtkSelectionMode) (3-i)); after_press (ctree, NULL); } void build_recursive (GtkCTree *ctree, gint cur_depth, gint depth, gint num_books, gint num_pages, GList *parent) { gchar *text[2]; gchar buf1[60]; gchar buf2[60]; GList *sibling; gint i; text[0] = buf1; text[1] = buf2; sibling = NULL; for (i = num_pages + num_books; i > num_books; i--) { pages++; sprintf (buf1, "Page %02d", (gint) random() % 100); sprintf (buf2, "Item %d-%d", cur_depth, i); sibling = gtk_ctree_insert (ctree, parent, sibling, text, 5, pixmap3, mask3, NULL, NULL, TRUE, FALSE); } if (cur_depth == depth) return; for (i = num_books; i > 0; i--) { books++; sprintf (buf1, "Book %02d", (gint) random() % 100); sprintf (buf2, "Item %d-%d", cur_depth, i); sibling = gtk_ctree_insert (ctree, parent, sibling, text, 5, pixmap1, mask1, pixmap2, mask2, FALSE, FALSE); build_recursive (ctree, cur_depth + 1, depth, num_books, num_pages, sibling); } } void rebuild_tree (GtkWidget *widget, GtkCTree *ctree) { gchar *text [2]; gchar label1[] = "Root"; gchar label2[] = ""; GList *parent; guint b, d, p, n; text[0] = label1; text[1] = label2; d = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (spin1)); b = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (spin2)); p = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (spin3)); n = ((pow (b, d) - 1) / (b - 1)) * (p + 1); if (n > 200000) { g_print ("%d total items? Try less\n",n); return; } gtk_clist_freeze (GTK_CLIST (ctree)); gtk_ctree_clear (ctree); books = 1; pages = 0; parent = gtk_ctree_insert (ctree, NULL, NULL, text, 5, pixmap1, mask1, pixmap2, mask2, FALSE, TRUE); build_recursive (ctree, 1, d, b, p, parent); gtk_clist_thaw (GTK_CLIST (ctree)); after_press (ctree, NULL); } void create_ctree (void) { static GtkWidget *window = NULL; GtkTooltips *tooltips; GtkCTree *ctree; GtkWidget *vbox; GtkWidget *hbox; GtkWidget *hbox2; GtkWidget *frame; GtkWidget *label; GtkWidget *button; GtkWidget *menu_item; GtkWidget *menu; GtkWidget *submenu; GtkWidget *check; GtkAdjustment *adj; GtkWidget *spinner; GSList *group; GdkColor transparent; char *title[] = { "Tree" , "Info" }; char buf[80]; if (!window) { window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_signal_connect (GTK_OBJECT (window), "destroy", GTK_SIGNAL_FUNC (gtk_widget_destroyed), &window); gtk_window_set_title (GTK_WINDOW (window), "GtkCTree"); gtk_container_border_width (GTK_CONTAINER (window), 0); tooltips = gtk_tooltips_new (); gtk_object_ref (GTK_OBJECT (tooltips)); gtk_object_sink (GTK_OBJECT (tooltips)); gtk_object_set_data_full (GTK_OBJECT (window), "tooltips", tooltips, (GtkDestroyNotify) gtk_object_unref); vbox = gtk_vbox_new (FALSE, 0); gtk_container_add (GTK_CONTAINER (window), vbox); hbox = gtk_hbox_new (FALSE, 5); gtk_container_border_width (GTK_CONTAINER (hbox), 5); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0); label = gtk_label_new ("Depth :"); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0); adj = (GtkAdjustment *) gtk_adjustment_new (4, 1, 10, 1, 5, 0); spin1 = gtk_spin_button_new (adj, 0, 0); gtk_box_pack_start (GTK_BOX (hbox), spin1, FALSE, TRUE, 5); label = gtk_label_new ("Books :"); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0); adj = (GtkAdjustment *) gtk_adjustment_new (3, 1, 20, 1, 5, 0); spin2 = gtk_spin_button_new (adj, 0, 0); gtk_box_pack_start (GTK_BOX (hbox), spin2, FALSE, TRUE, 5); label = gtk_label_new ("Pages :"); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0); adj = (GtkAdjustment *) gtk_adjustment_new (5, 1, 20, 1, 5, 0); spin3 = gtk_spin_button_new (adj, 0, 0); gtk_box_pack_start (GTK_BOX (hbox), spin3, FALSE, TRUE, 5); button = gtk_button_new_with_label ("Close"); gtk_box_pack_end (GTK_BOX (hbox), button, TRUE, TRUE, 0); gtk_signal_connect_object(GTK_OBJECT (button), "clicked", (GtkSignalFunc) gtk_widget_destroy, GTK_OBJECT(window)); button = gtk_button_new_with_label ("Rebuild tree"); gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0); ctree = GTK_CTREE (gtk_ctree_new_with_titles (2, 0, title)); gtk_ctree_set_line_style (ctree, GTK_CTREE_LINES_DOTTED); gtk_ctree_set_reorderable (ctree, TRUE); gtk_signal_connect (GTK_OBJECT (ctree), "button_press_event", GTK_SIGNAL_FUNC (button_press), NULL); gtk_signal_connect_after (GTK_OBJECT (ctree), "button_press_event", GTK_SIGNAL_FUNC (after_press), NULL); gtk_signal_connect (GTK_OBJECT (ctree), "button_release_event", GTK_SIGNAL_FUNC (button_release), NULL); gtk_signal_connect_after (GTK_OBJECT (ctree), "button_release_event", GTK_SIGNAL_FUNC (after_press), NULL); gtk_signal_connect_after (GTK_OBJECT (ctree), "tree_move", GTK_SIGNAL_FUNC (after_move), NULL); gtk_box_pack_start (GTK_BOX (vbox), GTK_WIDGET (ctree), TRUE, TRUE, 0); gtk_clist_column_titles_passive (GTK_CLIST (ctree)); gtk_clist_set_column_justification (GTK_CLIST (ctree), 2, GTK_JUSTIFY_RIGHT); gtk_clist_set_selection_mode (GTK_CLIST (ctree), GTK_SELECTION_MULTIPLE); gtk_clist_set_policy (GTK_CLIST (ctree), GTK_POLICY_ALWAYS, GTK_POLICY_AUTOMATIC); gtk_clist_set_column_width (GTK_CLIST (ctree), 0, 200); gtk_clist_set_column_width (GTK_CLIST (ctree), 1, 200); gtk_signal_connect (GTK_OBJECT (button), "clicked", GTK_SIGNAL_FUNC (rebuild_tree), ctree); hbox = gtk_hbox_new (FALSE, 5); gtk_container_border_width (GTK_CONTAINER (hbox), 5); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0); button = gtk_button_new_with_label ("Expand all"); gtk_signal_connect (GTK_OBJECT (button), "clicked", GTK_SIGNAL_FUNC (expand_all), ctree); gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0); button = gtk_button_new_with_label ("Collapse all"); gtk_signal_connect (GTK_OBJECT (button), "clicked", GTK_SIGNAL_FUNC (collapse_all), ctree); gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0); button = gtk_button_new_with_label ("Sort tree"); gtk_signal_connect (GTK_OBJECT (button), "clicked", GTK_SIGNAL_FUNC (sort_all), ctree); gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0); hbox = gtk_hbox_new (FALSE, 5); gtk_container_border_width (GTK_CONTAINER (hbox), 5); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0); button = gtk_button_new_with_label ("Select all"); gtk_signal_connect (GTK_OBJECT (button), "clicked", GTK_SIGNAL_FUNC (select_all), ctree); gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0); button = gtk_button_new_with_label ("Unselect all"); gtk_signal_connect (GTK_OBJECT (button), "clicked", GTK_SIGNAL_FUNC (unselect_all), ctree); gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0); button = gtk_button_new_with_label ("Remove selection"); gtk_signal_connect (GTK_OBJECT (button), "clicked", GTK_SIGNAL_FUNC (remove_selection), ctree); gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0); hbox = gtk_hbox_new (TRUE, 5); gtk_container_border_width (GTK_CONTAINER (hbox), 5); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0); hbox2 = gtk_hbox_new (FALSE, 0); gtk_box_pack_start (GTK_BOX (hbox), hbox2, FALSE, TRUE, 0); label = gtk_label_new ("Indent :"); gtk_box_pack_start (GTK_BOX (hbox2), label, FALSE, TRUE, 0); adj = (GtkAdjustment *) gtk_adjustment_new (20, 0, 60, 1, 10, 0); spinner = gtk_spin_button_new (adj, 0, 0); gtk_tooltips_set_tip (tooltips, spinner, "Tree indentation.", NULL); gtk_signal_connect (GTK_OBJECT (adj), "value_changed", GTK_SIGNAL_FUNC (change_indent), ctree); gtk_box_pack_start (GTK_BOX (hbox2), spinner, FALSE, TRUE, 5); check = gtk_check_button_new_with_label ("Reorderable"); gtk_tooltips_set_tip (tooltips, check, "Tree items can be reordered by dragging.", NULL); gtk_signal_connect (GTK_OBJECT (check), "clicked", GTK_SIGNAL_FUNC (toggle_reorderable), ctree); gtk_box_pack_start (GTK_BOX (hbox), check, FALSE, TRUE, 0); gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON (check), TRUE); omenu2 = gtk_option_menu_new (); gtk_tooltips_set_tip (tooltips, omenu2, "The tree's line style.", NULL); menu = gtk_menu_new (); submenu = NULL; group = NULL; menu_item = gtk_radio_menu_item_new_with_label (group, "Solid"); gtk_signal_connect (GTK_OBJECT (menu_item), "activate", GTK_SIGNAL_FUNC (toggle_line_style), ctree); group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menu_item)); gtk_menu_append (GTK_MENU (menu), menu_item); gtk_widget_show (menu_item); menu_item = gtk_radio_menu_item_new_with_label (group, "Dotted"); gtk_signal_connect (GTK_OBJECT (menu_item), "activate", GTK_SIGNAL_FUNC (toggle_line_style), ctree); group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menu_item)); gtk_menu_append (GTK_MENU (menu), menu_item); gtk_check_menu_item_set_state (GTK_CHECK_MENU_ITEM (menu_item), TRUE); gtk_widget_show (menu_item); menu_item = gtk_radio_menu_item_new_with_label (group, "No lines"); gtk_signal_connect (GTK_OBJECT (menu_item), "activate", GTK_SIGNAL_FUNC (toggle_line_style), ctree); group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menu_item)); gtk_menu_append (GTK_MENU (menu), menu_item); gtk_widget_show (menu_item); gtk_option_menu_set_menu (GTK_OPTION_MENU (omenu2), menu); gtk_box_pack_start (GTK_BOX (hbox), omenu2, FALSE, TRUE, 0); gtk_option_menu_set_history (GTK_OPTION_MENU (omenu2), 1); omenu3 = gtk_option_menu_new (); gtk_tooltips_set_tip (tooltips, omenu3, "The tree's justification.", NULL); menu = gtk_menu_new (); submenu = NULL; group = NULL; menu_item = gtk_radio_menu_item_new_with_label (group, "Left"); gtk_signal_connect (GTK_OBJECT (menu_item), "activate", GTK_SIGNAL_FUNC (toggle_justify), ctree); group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menu_item)); gtk_menu_append (GTK_MENU (menu), menu_item); gtk_check_menu_item_set_state (GTK_CHECK_MENU_ITEM (menu_item), TRUE); gtk_widget_show (menu_item); menu_item = gtk_radio_menu_item_new_with_label (group, "Right"); gtk_signal_connect (GTK_OBJECT (menu_item), "activate", GTK_SIGNAL_FUNC (toggle_justify), ctree); group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menu_item)); gtk_menu_append (GTK_MENU (menu), menu_item); gtk_widget_show (menu_item); gtk_option_menu_set_menu (GTK_OPTION_MENU (omenu3), menu); gtk_box_pack_start (GTK_BOX (hbox), omenu3, FALSE, TRUE, 0); gtk_option_menu_set_history (GTK_OPTION_MENU (omenu3), 0); omenu = gtk_option_menu_new (); gtk_tooltips_set_tip (tooltips, omenu, "The list's selection mode.", NULL); menu = gtk_menu_new (); submenu = NULL; group = NULL; menu_item = gtk_radio_menu_item_new_with_label (group, "Single"); gtk_signal_connect (GTK_OBJECT (menu_item), "activate", GTK_SIGNAL_FUNC (toggle_sel_mode), ctree); group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menu_item)); gtk_menu_append (GTK_MENU (menu), menu_item); gtk_widget_show (menu_item); menu_item = gtk_radio_menu_item_new_with_label (group, "Browse"); gtk_signal_connect (GTK_OBJECT (menu_item), "activate", GTK_SIGNAL_FUNC (toggle_sel_mode), ctree); group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menu_item)); gtk_menu_append (GTK_MENU (menu), menu_item); gtk_widget_show (menu_item); menu_item = gtk_radio_menu_item_new_with_label (group, "Multiple"); gtk_signal_connect (GTK_OBJECT (menu_item), "activate", GTK_SIGNAL_FUNC (toggle_sel_mode), ctree); group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menu_item)); gtk_menu_append (GTK_MENU (menu), menu_item); gtk_check_menu_item_set_state (GTK_CHECK_MENU_ITEM (menu_item), TRUE); gtk_widget_show (menu_item); menu_item = gtk_radio_menu_item_new_with_label (group, "Extended"); gtk_signal_connect (GTK_OBJECT (menu_item), "activate", GTK_SIGNAL_FUNC (toggle_sel_mode), ctree); group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menu_item)); gtk_menu_append (GTK_MENU (menu), menu_item); gtk_widget_show (menu_item); gtk_option_menu_set_menu (GTK_OPTION_MENU (omenu), menu); gtk_box_pack_start (GTK_BOX (hbox), omenu, FALSE, TRUE, 0); gtk_option_menu_set_history (GTK_OPTION_MENU (omenu), 2); gtk_widget_realize (window); pixmap1 = gdk_pixmap_create_from_xpm_d (window->window, &mask1, &transparent, book_closed_xpm); pixmap2 = gdk_pixmap_create_from_xpm_d (window->window, &mask2, &transparent, book_open_xpm); pixmap3 = gdk_pixmap_create_from_xpm_d (window->window, &mask3, &transparent, mini_page_xpm); gtk_widget_set_usize (GTK_WIDGET (ctree), 0, 300); frame = gtk_frame_new (NULL); gtk_container_border_width (GTK_CONTAINER (frame), 0); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_OUT); gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, TRUE, 0); hbox = gtk_hbox_new (TRUE, 2); gtk_container_border_width (GTK_CONTAINER (hbox), 2); gtk_container_add (GTK_CONTAINER (frame), hbox); frame = gtk_frame_new (NULL); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN); gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, TRUE, 0); hbox2 = gtk_hbox_new (FALSE, 0); gtk_container_border_width (GTK_CONTAINER (hbox2), 2); gtk_container_add (GTK_CONTAINER (frame), hbox2); label = gtk_label_new ("Books :"); gtk_box_pack_start (GTK_BOX (hbox2), label, FALSE, TRUE, 0); sprintf (buf, "%d", books); book_label = gtk_label_new (buf); gtk_box_pack_end (GTK_BOX (hbox2), book_label, FALSE, TRUE, 5); frame = gtk_frame_new (NULL); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN); gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, TRUE, 0); hbox2 = gtk_hbox_new (FALSE, 0); gtk_container_border_width (GTK_CONTAINER (hbox2), 2); gtk_container_add (GTK_CONTAINER (frame), hbox2); label = gtk_label_new ("Pages :"); gtk_box_pack_start (GTK_BOX (hbox2), label, FALSE, TRUE, 0); sprintf (buf, "%d", pages); page_label = gtk_label_new (buf); gtk_box_pack_end (GTK_BOX (hbox2), page_label, FALSE, TRUE, 5); frame = gtk_frame_new (NULL); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN); gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, TRUE, 0); hbox2 = gtk_hbox_new (FALSE, 0); gtk_container_border_width (GTK_CONTAINER (hbox2), 2); gtk_container_add (GTK_CONTAINER (frame), hbox2); label = gtk_label_new ("Selected :"); gtk_box_pack_start (GTK_BOX (hbox2), label, FALSE, TRUE, 0); sprintf (buf, "%d", g_list_length (GTK_CLIST (ctree)->selection)); sel_label = gtk_label_new (buf); gtk_box_pack_end (GTK_BOX (hbox2), sel_label, FALSE, TRUE, 5); frame = gtk_frame_new (NULL); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN); gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, TRUE, 0); hbox2 = gtk_hbox_new (FALSE, 0); gtk_container_border_width (GTK_CONTAINER (hbox2), 2); gtk_container_add (GTK_CONTAINER (frame), hbox2); label = gtk_label_new ("Visible :"); gtk_box_pack_start (GTK_BOX (hbox2), label, FALSE, TRUE, 0); sprintf (buf, "%d", g_list_length (GTK_CLIST (ctree)->row_list)); vis_label = gtk_label_new (buf); gtk_box_pack_end (GTK_BOX (hbox2), vis_label, FALSE, TRUE, 5); rebuild_tree (NULL, ctree); } if (!GTK_WIDGET_VISIBLE (window)) gtk_widget_show_all (window); else gtk_widget_destroy (window); } /* * GtkColorSelect */ void color_selection_ok (GtkWidget *w, GtkColorSelectionDialog *cs) { GtkColorSelection *colorsel; gdouble color[4]; colorsel=GTK_COLOR_SELECTION(cs->colorsel); gtk_color_selection_get_color(colorsel,color); gtk_color_selection_set_color(colorsel,color); } void color_selection_changed (GtkWidget *w, GtkColorSelectionDialog *cs) { GtkColorSelection *colorsel; gdouble color[4]; colorsel=GTK_COLOR_SELECTION(cs->colorsel); gtk_color_selection_get_color(colorsel,color); } void create_color_selection (void) { static GtkWidget *window = NULL; if (!window) { window = gtk_color_selection_dialog_new ("color selection dialog"); gtk_color_selection_set_opacity ( GTK_COLOR_SELECTION (GTK_COLOR_SELECTION_DIALOG (window)->colorsel), TRUE); gtk_color_selection_set_update_policy( GTK_COLOR_SELECTION (GTK_COLOR_SELECTION_DIALOG (window)->colorsel), GTK_UPDATE_CONTINUOUS); gtk_window_position (GTK_WINDOW (window), GTK_WIN_POS_MOUSE); gtk_signal_connect (GTK_OBJECT (window), "destroy", GTK_SIGNAL_FUNC(gtk_widget_destroyed), &window); gtk_signal_connect ( GTK_OBJECT (GTK_COLOR_SELECTION_DIALOG (window)->colorsel), "color_changed", GTK_SIGNAL_FUNC(color_selection_changed), window); gtk_signal_connect ( GTK_OBJECT (GTK_COLOR_SELECTION_DIALOG (window)->ok_button), "clicked", GTK_SIGNAL_FUNC(color_selection_ok), window); gtk_signal_connect_object ( GTK_OBJECT (GTK_COLOR_SELECTION_DIALOG (window)->cancel_button), "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy), GTK_OBJECT (window)); } if (!GTK_WIDGET_VISIBLE (window)) gtk_widget_show (window); else gtk_widget_destroy (window); } void file_selection_hide_fileops (GtkWidget *widget, GtkFileSelection *fs) { gtk_file_selection_hide_fileop_buttons (fs); } void file_selection_ok (GtkWidget *w, GtkFileSelection *fs) { g_print ("%s\n", gtk_file_selection_get_filename (fs)); gtk_widget_destroy (GTK_WIDGET (fs)); } void create_file_selection (void) { static GtkWidget *window = NULL; GtkWidget *button; if (!window) { window = gtk_file_selection_new ("file selection dialog"); gtk_file_selection_hide_fileop_buttons (GTK_FILE_SELECTION (window)); gtk_window_position (GTK_WINDOW (window), GTK_WIN_POS_MOUSE); gtk_signal_connect (GTK_OBJECT (window), "destroy", GTK_SIGNAL_FUNC(gtk_widget_destroyed), &window); gtk_signal_connect (GTK_OBJECT (GTK_FILE_SELECTION (window)->ok_button), "clicked", GTK_SIGNAL_FUNC(file_selection_ok), window); gtk_signal_connect_object (GTK_OBJECT (GTK_FILE_SELECTION (window)->cancel_button), "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy), GTK_OBJECT (window)); button = gtk_button_new_with_label ("Hide Fileops"); gtk_signal_connect (GTK_OBJECT (button), "clicked", (GtkSignalFunc) file_selection_hide_fileops, (gpointer) window); gtk_box_pack_start (GTK_BOX (GTK_FILE_SELECTION (window)->action_area), button, FALSE, FALSE, 0); gtk_widget_show (button); button = gtk_button_new_with_label ("Show Fileops"); gtk_signal_connect_object (GTK_OBJECT (button), "clicked", (GtkSignalFunc) gtk_file_selection_show_fileop_buttons, (gpointer) window); gtk_box_pack_start (GTK_BOX (GTK_FILE_SELECTION (window)->action_area), button, FALSE, FALSE, 0); gtk_widget_show (button); } if (!GTK_WIDGET_VISIBLE (window)) gtk_widget_show (window); else gtk_widget_destroy (window); } void font_selection_ok (GtkWidget *w, GtkFontSelectionDialog *fs) { g_print ("%s\n", gtk_font_selection_dialog_get_font_name (fs)); gtk_widget_destroy (GTK_WIDGET (fs)); } void create_font_selection (void) { static GtkWidget *window = NULL; if (!window) { window = gtk_font_selection_dialog_new ("Font Selection Dialog"); gtk_window_position (GTK_WINDOW (window), GTK_WIN_POS_MOUSE); gtk_signal_connect (GTK_OBJECT (window), "destroy", GTK_SIGNAL_FUNC(gtk_widget_destroyed), &window); gtk_signal_connect (GTK_OBJECT (GTK_FONT_SELECTION_DIALOG (window)->ok_button), "clicked", GTK_SIGNAL_FUNC(font_selection_ok), GTK_FONT_SELECTION_DIALOG (window)); gtk_signal_connect_object (GTK_OBJECT (GTK_FONT_SELECTION_DIALOG (window)->cancel_button), "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy), GTK_OBJECT (window)); } if (!GTK_WIDGET_VISIBLE (window)) gtk_widget_show (window); else gtk_widget_destroy (window); } /* * GtkDialog */ static GtkWidget *dialog_window = NULL; void label_toggle (GtkWidget *widget, GtkWidget **label) { if (!(*label)) { *label = gtk_label_new ("Dialog Test"); gtk_signal_connect (GTK_OBJECT (*label), "destroy", GTK_SIGNAL_FUNC (gtk_widget_destroyed), label); gtk_misc_set_padding (GTK_MISC (*label), 10, 10); gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog_window)->vbox), *label, TRUE, TRUE, 0); gtk_widget_show (*label); } else gtk_widget_destroy (*label); } void create_dialog (void) { static GtkWidget *label; GtkWidget *button; if (!dialog_window) { dialog_window = gtk_dialog_new (); gtk_signal_connect (GTK_OBJECT (dialog_window), "destroy", GTK_SIGNAL_FUNC(gtk_widget_destroyed), &dialog_window); gtk_window_set_title (GTK_WINDOW (dialog_window), "dialog"); gtk_container_border_width (GTK_CONTAINER (dialog_window), 0); button = gtk_button_new_with_label ("OK"); GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT); gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog_window)->action_area), button, TRUE, TRUE, 0); gtk_widget_grab_default (button); gtk_widget_show (button); button = gtk_button_new_with_label ("Toggle"); gtk_signal_connect (GTK_OBJECT (button), "clicked", GTK_SIGNAL_FUNC (label_toggle), &label); GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT); gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog_window)->action_area), button, TRUE, TRUE, 0); gtk_widget_show (button); label = NULL; } if (!GTK_WIDGET_VISIBLE (dialog_window)) gtk_widget_show (dialog_window); else gtk_widget_destroy (dialog_window); } /* * GtkRange */ void create_range_controls (void) { static GtkWidget *window = NULL; GtkWidget *box1; GtkWidget *box2; GtkWidget *button; GtkWidget *scrollbar; GtkWidget *scale; GtkWidget *separator; GtkObject *adjustment; if (!window) { window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_signal_connect (GTK_OBJECT (window), "destroy", GTK_SIGNAL_FUNC(gtk_widget_destroyed), &window); gtk_window_set_title (GTK_WINDOW (window), "range controls"); gtk_container_border_width (GTK_CONTAINER (window), 0); box1 = gtk_vbox_new (FALSE, 0); gtk_container_add (GTK_CONTAINER (window), box1); gtk_widget_show (box1); box2 = gtk_vbox_new (FALSE, 10); gtk_container_border_width (GTK_CONTAINER (box2), 10); gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0); gtk_widget_show (box2); adjustment = gtk_adjustment_new (0.0, 0.0, 101.0, 0.1, 1.0, 1.0); scale = gtk_hscale_new (GTK_ADJUSTMENT (adjustment)); gtk_widget_set_usize (GTK_WIDGET (scale), 150, 30); gtk_range_set_update_policy (GTK_RANGE (scale), GTK_UPDATE_DELAYED); gtk_scale_set_digits (GTK_SCALE (scale), 1); gtk_scale_set_draw_value (GTK_SCALE (scale), TRUE); gtk_box_pack_start (GTK_BOX (box2), scale, TRUE, TRUE, 0); gtk_widget_show (scale); scrollbar = gtk_hscrollbar_new (GTK_ADJUSTMENT (adjustment)); gtk_range_set_update_policy (GTK_RANGE (scrollbar), GTK_UPDATE_CONTINUOUS); gtk_box_pack_start (GTK_BOX (box2), scrollbar, TRUE, TRUE, 0); gtk_widget_show (scrollbar); separator = gtk_hseparator_new (); gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0); gtk_widget_show (separator); box2 = gtk_vbox_new (FALSE, 10); gtk_container_border_width (GTK_CONTAINER (box2), 10); gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0); gtk_widget_show (box2); button = gtk_button_new_with_label ("close"); gtk_signal_connect_object (GTK_OBJECT (button), "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy), GTK_OBJECT (window)); gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0); GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT); gtk_widget_grab_default (button); gtk_widget_show (button); } if (!GTK_WIDGET_VISIBLE (window)) gtk_widget_show (window); else gtk_widget_destroy (window); } /* * GtkRulers */ void create_rulers (void) { static GtkWidget *window = NULL; GtkWidget *table; GtkWidget *ruler; if (!window) { window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_policy (GTK_WINDOW (window), TRUE, TRUE, FALSE); gtk_signal_connect (GTK_OBJECT (window), "destroy", GTK_SIGNAL_FUNC(gtk_widget_destroyed), &window); gtk_window_set_title (GTK_WINDOW (window), "rulers"); gtk_widget_set_usize (window, 300, 300); gtk_widget_set_events (window, GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK); gtk_container_border_width (GTK_CONTAINER (window), 0); table = gtk_table_new (2, 2, FALSE); gtk_container_add (GTK_CONTAINER (window), table); gtk_widget_show (table); ruler = gtk_hruler_new (); gtk_ruler_set_metric (GTK_RULER (ruler), GTK_CENTIMETERS); gtk_ruler_set_range (GTK_RULER (ruler), 100, 0, 0, 20); gtk_signal_connect_object ( GTK_OBJECT (window), "motion_notify_event", GTK_SIGNAL_FUNC( GTK_WIDGET_CLASS (GTK_OBJECT (ruler)->klass)->motion_notify_event), GTK_OBJECT (ruler)); gtk_table_attach (GTK_TABLE (table), ruler, 1, 2, 0, 1, GTK_EXPAND | GTK_FILL, GTK_FILL, 0, 0); gtk_widget_show (ruler); ruler = gtk_vruler_new (); gtk_ruler_set_range (GTK_RULER (ruler), 5, 15, 0, 20); gtk_signal_connect_object ( GTK_OBJECT (window), "motion_notify_event", GTK_SIGNAL_FUNC (GTK_WIDGET_CLASS (GTK_OBJECT (ruler)->klass)->motion_notify_event), GTK_OBJECT (ruler)); gtk_table_attach (GTK_TABLE (table), ruler, 0, 1, 1, 2, GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0); gtk_widget_show (ruler); } if (!GTK_WIDGET_VISIBLE (window)) gtk_widget_show (window); else gtk_widget_destroy (window); } static void text_toggle_editable (GtkWidget *checkbutton, GtkWidget *text) { gtk_text_set_editable(GTK_TEXT(text), GTK_TOGGLE_BUTTON(checkbutton)->active); } static void text_toggle_word_wrap (GtkWidget *checkbutton, GtkWidget *text) { gtk_text_set_word_wrap(GTK_TEXT(text), GTK_TOGGLE_BUTTON(checkbutton)->active); } /* * GtkText */ void create_text (void) { static GtkWidget *window = NULL; GtkWidget *box1; GtkWidget *box2; GtkWidget *hbox; GtkWidget *button; GtkWidget *check; GtkWidget *separator; GtkWidget *table; GtkWidget *hscrollbar; GtkWidget *vscrollbar; GtkWidget *text; FILE *infile; if (!window) { window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_widget_set_name (window, "text window"); gtk_widget_set_usize (window, 500, 500); gtk_window_set_policy (GTK_WINDOW(window), TRUE, TRUE, FALSE); gtk_signal_connect (GTK_OBJECT (window), "destroy", GTK_SIGNAL_FUNC(gtk_widget_destroyed), &window); gtk_window_set_title (GTK_WINDOW (window), "test"); gtk_container_border_width (GTK_CONTAINER (window), 0); box1 = gtk_vbox_new (FALSE, 0); gtk_container_add (GTK_CONTAINER (window), box1); gtk_widget_show (box1); box2 = gtk_vbox_new (FALSE, 10); gtk_container_border_width (GTK_CONTAINER (box2), 10); gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0); gtk_widget_show (box2); table = gtk_table_new (2, 2, FALSE); gtk_table_set_row_spacing (GTK_TABLE (table), 0, 2); gtk_table_set_col_spacing (GTK_TABLE (table), 0, 2); gtk_box_pack_start (GTK_BOX (box2), table, TRUE, TRUE, 0); gtk_widget_show (table); text = gtk_text_new (NULL, NULL); gtk_text_set_editable (GTK_TEXT (text), TRUE); gtk_table_attach (GTK_TABLE (table), text, 0, 1, 0, 1, GTK_EXPAND | GTK_SHRINK | GTK_FILL, GTK_EXPAND | GTK_SHRINK | GTK_FILL, 0, 0); gtk_widget_show (text); hscrollbar = gtk_hscrollbar_new (GTK_TEXT (text)->hadj); gtk_table_attach (GTK_TABLE (table), hscrollbar, 0, 1, 1, 2, GTK_EXPAND | GTK_FILL | GTK_SHRINK, GTK_FILL, 0, 0); gtk_widget_show (hscrollbar); vscrollbar = gtk_vscrollbar_new (GTK_TEXT (text)->vadj); gtk_table_attach (GTK_TABLE (table), vscrollbar, 1, 2, 0, 1, GTK_FILL, GTK_EXPAND | GTK_SHRINK | GTK_FILL, 0, 0); gtk_widget_show (vscrollbar); gtk_text_freeze (GTK_TEXT (text)); gtk_widget_realize (text); infile = fopen("testgtk.c", "r"); if (infile) { char buffer[1024]; int nchars; while (1) { nchars = fread(buffer, 1, 1024, infile); gtk_text_insert (GTK_TEXT (text), NULL, NULL, NULL, buffer, nchars); if (nchars < 1024) break; } fclose (infile); } gtk_text_insert (GTK_TEXT (text), NULL, &text->style->black, NULL, "And even ", -1); gtk_text_insert (GTK_TEXT (text), NULL, &text->style->bg[GTK_STATE_NORMAL], NULL, "colored", -1); gtk_text_insert (GTK_TEXT (text), NULL, &text->style->black, NULL, "text", -1); gtk_text_thaw (GTK_TEXT (text)); hbox = gtk_hbutton_box_new (); gtk_box_pack_start (GTK_BOX (box2), hbox, FALSE, FALSE, 0); gtk_widget_show (hbox); check = gtk_check_button_new_with_label("Editable"); gtk_box_pack_start (GTK_BOX (hbox), check, FALSE, FALSE, 0); gtk_signal_connect (GTK_OBJECT(check), "toggled", GTK_SIGNAL_FUNC(text_toggle_editable), text); gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(check), TRUE); gtk_widget_show (check); check = gtk_check_button_new_with_label("Wrap Words"); gtk_box_pack_start (GTK_BOX (hbox), check, FALSE, TRUE, 0); gtk_signal_connect (GTK_OBJECT(check), "toggled", GTK_SIGNAL_FUNC(text_toggle_word_wrap), text); gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(check), FALSE); gtk_widget_show (check); separator = gtk_hseparator_new (); gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0); gtk_widget_show (separator); box2 = gtk_vbox_new (FALSE, 10); gtk_container_border_width (GTK_CONTAINER (box2), 10); gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0); gtk_widget_show (box2); button = gtk_button_new_with_label ("close"); gtk_signal_connect_object (GTK_OBJECT (button), "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy), GTK_OBJECT (window)); gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0); GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT); gtk_widget_grab_default (button); gtk_widget_show (button); } if (!GTK_WIDGET_VISIBLE (window)) gtk_widget_show (window); else gtk_widget_destroy (window); } /* * GtkNotebook */ GdkPixmap *book_open; GdkPixmap *book_closed; GdkBitmap *book_open_mask; GdkBitmap *book_closed_mask; static void notebook_reparent (GtkWidget *widget, GtkWidget *scrollwin) { static GtkWidget *parent = NULL; static GtkWidget *float_parent; if (parent) { gtk_widget_reparent (scrollwin, parent); gtk_widget_destroy (float_parent); float_parent = NULL; parent = NULL; } else { parent = widget->parent; float_parent = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_widget_show (float_parent); gtk_widget_reparent (scrollwin, float_parent); } } static void page_switch (GtkWidget *widget, GtkNotebookPage *page, gint page_num) { GtkNotebookPage *oldpage; GtkWidget *pixwid; oldpage = GTK_NOTEBOOK (widget)->cur_page; if (page == oldpage) return; pixwid = ((GtkBoxChild*)(GTK_BOX (page->tab_label)->children->data))->widget; gtk_pixmap_set (GTK_PIXMAP (pixwid), book_open, book_open_mask); pixwid = ((GtkBoxChild*) (GTK_BOX (page->menu_label)->children->data))->widget; gtk_pixmap_set (GTK_PIXMAP (pixwid), book_open, book_open_mask); if (oldpage) { pixwid = ((GtkBoxChild*) (GTK_BOX (oldpage->tab_label)->children->data))->widget; gtk_pixmap_set (GTK_PIXMAP (pixwid), book_closed, book_closed_mask); pixwid = ((GtkBoxChild*) (GTK_BOX (oldpage->menu_label)->children->data))->widget; gtk_pixmap_set (GTK_PIXMAP (pixwid), book_closed, book_closed_mask); } } static void create_pages (GtkNotebook *notebook, gint start, gint end) { GtkWidget *child = NULL; GtkWidget *label; GtkWidget *entry; GtkWidget *box; GtkWidget *hbox; GtkWidget *label_box; GtkWidget *menu_box; GtkWidget *button; GtkWidget *pixwid; gint i; char buffer[32]; for (i = start; i <= end; i++) { sprintf (buffer, "Page %d", i); switch (i%4) { case 3: child = gtk_button_new_with_label (buffer); gtk_container_border_width (GTK_CONTAINER(child), 10); break; case 2: child = gtk_label_new (buffer); break; case 1: child = gtk_frame_new (buffer); gtk_container_border_width (GTK_CONTAINER (child), 10); box = gtk_vbox_new (TRUE,0); gtk_container_border_width (GTK_CONTAINER (box), 10); gtk_container_add (GTK_CONTAINER (child), box); label = gtk_label_new (buffer); gtk_box_pack_start (GTK_BOX(box), label, TRUE, TRUE, 5); entry = gtk_entry_new (); gtk_box_pack_start (GTK_BOX(box), entry, TRUE, TRUE, 5); hbox = gtk_hbox_new (TRUE,0); gtk_box_pack_start (GTK_BOX(box), hbox, TRUE, TRUE, 5); button = gtk_button_new_with_label ("Ok"); gtk_box_pack_start (GTK_BOX(hbox), button, TRUE, TRUE, 5); button = gtk_button_new_with_label ("Cancel"); gtk_box_pack_start (GTK_BOX(hbox), button, TRUE, TRUE, 5); break; case 0: child = gtk_frame_new (buffer); gtk_container_border_width (GTK_CONTAINER (child), 10); label = gtk_label_new (buffer); gtk_container_add (GTK_CONTAINER (child), label); break; } gtk_widget_show_all (child); label_box = gtk_hbox_new (FALSE, 0); pixwid = gtk_pixmap_new (book_closed, book_closed_mask); gtk_box_pack_start (GTK_BOX (label_box), pixwid, FALSE, TRUE, 0); gtk_misc_set_padding (GTK_MISC (pixwid), 3, 1); label = gtk_label_new (buffer); gtk_box_pack_start (GTK_BOX (label_box), label, FALSE, TRUE, 0); gtk_widget_show_all (label_box); menu_box = gtk_hbox_new (FALSE, 0); pixwid = gtk_pixmap_new (book_closed, book_closed_mask); gtk_box_pack_start (GTK_BOX (menu_box), pixwid, FALSE, TRUE, 0); gtk_misc_set_padding (GTK_MISC (pixwid), 3, 1); label = gtk_label_new (buffer); gtk_box_pack_start (GTK_BOX (menu_box), label, FALSE, TRUE, 0); gtk_widget_show_all (menu_box); gtk_notebook_append_page_menu (notebook, child, label_box, menu_box); } } static void rotate_notebook (GtkButton *button, GtkNotebook *notebook) { gtk_notebook_set_tab_pos (notebook, (notebook->tab_pos + 1) % 4); } static void standard_notebook (GtkButton *button, GtkNotebook *notebook) { gint i; gtk_notebook_set_show_tabs (notebook, TRUE); gtk_notebook_set_scrollable (notebook, FALSE); if (g_list_length (notebook->children) == 15) for (i = 0; i < 10; i++) gtk_notebook_remove_page (notebook, 5); } static void notabs_notebook (GtkButton *button, GtkNotebook *notebook) { gint i; gtk_notebook_set_show_tabs (notebook, FALSE); if (g_list_length (notebook->children) == 15) for (i = 0; i < 10; i++) gtk_notebook_remove_page (notebook, 5); } static void scrollable_notebook (GtkButton *button, GtkNotebook *notebook) { gtk_notebook_set_show_tabs (notebook, TRUE); gtk_notebook_set_scrollable (notebook, TRUE); if (g_list_length (notebook->children) == 5) create_pages (notebook, 6, 15); } static void notebook_popup (GtkToggleButton *button, GtkNotebook *notebook) { if (button->active) gtk_notebook_popup_enable (notebook); else gtk_notebook_popup_disable (notebook); } static void create_notebook (void) { static GtkWidget *window = NULL; GtkWidget *box1; GtkWidget *box2; GtkWidget *button; GtkWidget *separator; GtkWidget *notebook; GtkWidget *omenu; GtkWidget *menu; GtkWidget *submenu; GtkWidget *menuitem; GSList *group; GdkColor *transparent = NULL; if (!window) { window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_signal_connect (GTK_OBJECT (window), "destroy", GTK_SIGNAL_FUNC(gtk_widget_destroyed), &window); gtk_window_set_title (GTK_WINDOW (window), "notebook"); gtk_container_border_width (GTK_CONTAINER (window), 0); box1 = gtk_vbox_new (FALSE, 0); gtk_container_add (GTK_CONTAINER (window), box1); notebook = gtk_notebook_new (); gtk_signal_connect (GTK_OBJECT (notebook), "switch_page", GTK_SIGNAL_FUNC (page_switch), NULL); gtk_notebook_set_tab_pos (GTK_NOTEBOOK (notebook), GTK_POS_TOP); gtk_box_pack_start (GTK_BOX (box1), notebook, TRUE, TRUE, 0); gtk_container_border_width (GTK_CONTAINER (notebook), 10); gtk_widget_realize (notebook); book_open = gdk_pixmap_create_from_xpm_d (notebook->window, &book_open_mask, transparent, book_open_xpm); book_closed = gdk_pixmap_create_from_xpm_d (notebook->window, &book_closed_mask, transparent, book_closed_xpm); create_pages (GTK_NOTEBOOK (notebook), 1, 5); separator = gtk_hseparator_new (); gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 10); box2 = gtk_hbox_new (TRUE, 5); gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0); omenu = gtk_option_menu_new (); menu = gtk_menu_new (); submenu = NULL; group = NULL; menuitem = gtk_radio_menu_item_new_with_label (group, "Standard"); gtk_signal_connect_object (GTK_OBJECT (menuitem), "activate", GTK_SIGNAL_FUNC (standard_notebook), GTK_OBJECT (notebook)); group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menuitem)); gtk_menu_append (GTK_MENU (menu), menuitem); gtk_widget_show (menuitem); menuitem = gtk_radio_menu_item_new_with_label (group, "w/o Tabs"); gtk_signal_connect_object (GTK_OBJECT (menuitem), "activate", GTK_SIGNAL_FUNC (notabs_notebook), GTK_OBJECT (notebook)); group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menuitem)); gtk_menu_append (GTK_MENU (menu), menuitem); gtk_widget_show (menuitem); menuitem = gtk_radio_menu_item_new_with_label (group, "Scrollable"); gtk_signal_connect_object (GTK_OBJECT (menuitem), "activate", GTK_SIGNAL_FUNC (scrollable_notebook), GTK_OBJECT (notebook)); group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menuitem)); gtk_menu_append (GTK_MENU (menu), menuitem); gtk_widget_show (menuitem); gtk_option_menu_set_menu (GTK_OPTION_MENU (omenu), menu); gtk_box_pack_start (GTK_BOX (box2), omenu, FALSE, FALSE, 0); button = gtk_check_button_new_with_label ("enable popup menu"); gtk_box_pack_start (GTK_BOX (box2), button, FALSE, FALSE, 0); gtk_signal_connect (GTK_OBJECT(button), "clicked", GTK_SIGNAL_FUNC (notebook_popup), GTK_OBJECT (notebook)); box2 = gtk_hbox_new (FALSE, 10); gtk_container_border_width (GTK_CONTAINER (box2), 10); gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0); button = gtk_button_new_with_label ("close"); gtk_signal_connect_object (GTK_OBJECT (button), "clicked", GTK_SIGNAL_FUNC (gtk_widget_destroy), GTK_OBJECT (window)); gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0); GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT); gtk_widget_grab_default (button); button = gtk_button_new_with_label ("next"); gtk_signal_connect_object (GTK_OBJECT (button), "clicked", GTK_SIGNAL_FUNC (gtk_notebook_next_page), GTK_OBJECT (notebook)); gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0); GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT); button = gtk_button_new_with_label ("prev"); gtk_signal_connect_object (GTK_OBJECT (button), "clicked", GTK_SIGNAL_FUNC (gtk_notebook_prev_page), GTK_OBJECT (notebook)); gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0); GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT); button = gtk_button_new_with_label ("rotate"); gtk_signal_connect (GTK_OBJECT (button), "clicked", GTK_SIGNAL_FUNC (rotate_notebook), notebook); gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0); GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT); button = gtk_button_new_with_label ("reparent"); gtk_signal_connect (GTK_OBJECT (button), "clicked", GTK_SIGNAL_FUNC (notebook_reparent), notebook); gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0); GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT); } if (!GTK_WIDGET_VISIBLE (window)) gtk_widget_show_all (window); else gtk_widget_destroy (window); } /* * GtkPanes */ void create_panes (void) { static GtkWidget *window = NULL; GtkWidget *frame; GtkWidget *hpaned; GtkWidget *vpaned; GtkWidget *button; if (!window) { window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_signal_connect (GTK_OBJECT (window), "destroy", GTK_SIGNAL_FUNC(gtk_widget_destroyed), &window); gtk_window_set_title (GTK_WINDOW (window), "Panes"); gtk_container_border_width (GTK_CONTAINER (window), 0); vpaned = gtk_vpaned_new (); gtk_container_add (GTK_CONTAINER (window), vpaned); gtk_container_border_width (GTK_CONTAINER(vpaned), 5); gtk_widget_show (vpaned); hpaned = gtk_hpaned_new (); gtk_paned_add1 (GTK_PANED (vpaned), hpaned); frame = gtk_frame_new (NULL); gtk_frame_set_shadow_type (GTK_FRAME(frame), GTK_SHADOW_IN); gtk_widget_set_usize (frame, 60, 60); gtk_paned_add1 (GTK_PANED (hpaned), frame); gtk_widget_show (frame); button = gtk_button_new_with_label ("Hi there"); gtk_container_add (GTK_CONTAINER(frame), button); gtk_widget_show (button); frame = gtk_frame_new (NULL); gtk_frame_set_shadow_type (GTK_FRAME(frame), GTK_SHADOW_IN); gtk_widget_set_usize (frame, 80, 60); gtk_paned_add2 (GTK_PANED (hpaned), frame); gtk_widget_show (frame); gtk_widget_show (hpaned); frame = gtk_frame_new (NULL); gtk_frame_set_shadow_type (GTK_FRAME(frame), GTK_SHADOW_IN); gtk_widget_set_usize (frame, 60, 80); gtk_paned_add2 (GTK_PANED (vpaned), frame); gtk_widget_show (frame); } if (!GTK_WIDGET_VISIBLE (window)) gtk_widget_show (window); else gtk_widget_destroy (window); } /* * Drag -N- Drop */ gint dnd_drop_destroy_popup (GtkWidget *widget, GtkWindow **window) { if(GTK_IS_BUTTON(widget)) /* I.e. they clicked the close button */ gtk_widget_destroy(GTK_WIDGET(*window)); else { gtk_grab_remove(GTK_WIDGET(*window)); *window = NULL; } return FALSE; } void dnd_drop (GtkWidget *button, GdkEvent *event) { static GtkWidget *window = NULL; GtkWidget *vbox, *lbl, *btn; gchar *msg; /* DND doesn't obey gtk_grab's, so check if we're already displaying * drop modal dialog first */ if (window) return; window = gtk_window_new(GTK_WINDOW_DIALOG); gtk_container_border_width (GTK_CONTAINER(window), 10); gtk_signal_connect (GTK_OBJECT (window), "destroy", GTK_SIGNAL_FUNC(dnd_drop_destroy_popup), &window); gtk_signal_connect (GTK_OBJECT (window), "delete-event", GTK_SIGNAL_FUNC(gtk_false), &window); vbox = gtk_vbox_new(FALSE, 5); /* Display message that we got from drop source */ msg = g_malloc(strlen(event->dropdataavailable.data) + strlen(event->dropdataavailable.data_type) + 100); sprintf(msg, "Drop data of type %s was:\n\n%s", event->dropdataavailable.data_type, (char *)event->dropdataavailable.data); lbl = gtk_label_new(msg); gtk_label_set_justify(GTK_LABEL(lbl), GTK_JUSTIFY_FILL); g_free(msg); gtk_widget_show(lbl); gtk_box_pack_start_defaults(GTK_BOX(vbox), lbl); /* Provide an obvious way out of this heinousness */ btn = gtk_button_new_with_label("Continue with life in\nspite of this oppression"); gtk_signal_connect_object (GTK_OBJECT (btn), "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy), GTK_OBJECT (window)); gtk_widget_show(btn); gtk_box_pack_start_defaults(GTK_BOX(vbox), btn); gtk_container_add(GTK_CONTAINER(window), vbox); gtk_widget_show(vbox); gtk_grab_add(window); gtk_widget_show(window); } void dnd_drag_request (GtkWidget *button, GdkEvent *event) { #define DND_STRING "Bill Gates demands royalties for\nyour use of his innovation." gtk_widget_dnd_data_set (button, event, DND_STRING, strlen(DND_STRING) + 1); } void create_dnd (void) { static GtkWidget *window = NULL; GtkWidget *box1; GtkWidget *box2; GtkWidget *box3; GtkWidget *frame; GtkWidget *button; GtkWidget *separator; /* For clarity... */ char *possible_drag_types[] = {"text/plain"}; char *accepted_drop_types[] = {"text/plain"}; static GtkWidget *drag_icon = NULL; static GtkWidget *drop_icon = NULL; if (!window) { GdkPoint hotspot = {5,5}; if (!drag_icon) { drag_icon = shape_create_icon ("Modeller.xpm", 440, 140, 0,0, GTK_WINDOW_POPUP); gtk_signal_connect (GTK_OBJECT (drag_icon), "destroy", GTK_SIGNAL_FUNC(gtk_widget_destroyed), &drag_icon); gtk_widget_hide (drag_icon); } if (!drop_icon) { drop_icon = shape_create_icon ("3DRings.xpm", 440, 140, 0,0, GTK_WINDOW_POPUP); gtk_signal_connect (GTK_OBJECT (drop_icon), "destroy", GTK_SIGNAL_FUNC(gtk_widget_destroyed), &drop_icon); gtk_widget_hide (drop_icon); } gdk_dnd_set_drag_shape(drag_icon->window, &hotspot, drop_icon->window, &hotspot); window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_signal_connect (GTK_OBJECT (window), "destroy", GTK_SIGNAL_FUNC(gtk_widget_destroyed), &window); gtk_window_set_title (GTK_WINDOW (window), "Drag -N- Drop"); gtk_container_border_width (GTK_CONTAINER (window), 0); box1 = gtk_vbox_new (FALSE, 0); gtk_container_add (GTK_CONTAINER (window), box1); gtk_widget_show (box1); box2 = gtk_hbox_new (FALSE, 5); gtk_container_border_width (GTK_CONTAINER (box2), 10); gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0); gtk_widget_show (box2); frame = gtk_frame_new ("Drag"); gtk_box_pack_start (GTK_BOX (box2), frame, TRUE, TRUE, 0); gtk_widget_show (frame); box3 = gtk_vbox_new (FALSE, 5); gtk_container_border_width (GTK_CONTAINER (box3), 5); gtk_container_add (GTK_CONTAINER (frame), box3); gtk_widget_show (box3); /* * FROM Button */ button = gtk_button_new_with_label ("Drag me!"); gtk_box_pack_start (GTK_BOX (box3), button, FALSE, TRUE, 0); gtk_widget_show (button); /* * currently, the widget has to be realized to * set dnd on it, this needs to change */ gtk_widget_realize (button); gtk_signal_connect (GTK_OBJECT (button), "drag_request_event", GTK_SIGNAL_FUNC(dnd_drag_request), button); gtk_widget_dnd_drag_set (button, TRUE, possible_drag_types, 1); frame = gtk_frame_new ("Drop"); gtk_box_pack_start (GTK_BOX (box2), frame, TRUE, TRUE, 0); gtk_widget_show (frame); box3 = gtk_vbox_new (FALSE, 5); gtk_container_border_width (GTK_CONTAINER (box3), 5); gtk_container_add (GTK_CONTAINER (frame), box3); gtk_widget_show (box3); /* * TO Button */ button = gtk_button_new_with_label ("To"); gtk_box_pack_start (GTK_BOX (box3), button, FALSE, TRUE, 0); gtk_widget_show (button); gtk_widget_realize (button); gtk_signal_connect (GTK_OBJECT (button), "drop_data_available_event", GTK_SIGNAL_FUNC(dnd_drop), button); gtk_widget_dnd_drop_set (button, TRUE, accepted_drop_types, 1, FALSE); separator = gtk_hseparator_new (); gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0); gtk_widget_show (separator); box2 = gtk_vbox_new (FALSE, 10); gtk_container_border_width (GTK_CONTAINER (box2), 10); gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0); gtk_widget_show (box2); button = gtk_button_new_with_label ("close"); gtk_signal_connect_object (GTK_OBJECT (button), "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy), GTK_OBJECT (window)); gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0); GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT); gtk_widget_grab_default (button); gtk_widget_show (button); } if (!GTK_WIDGET_VISIBLE (window)) gtk_widget_show (window); else gtk_widget_destroy (window); } /* * Shaped Windows */ static GdkWindow *root_win = NULL; typedef struct _cursoroffset {gint x,y;} CursorOffset; static void shape_pressed (GtkWidget *widget, GdkEventButton *event) { CursorOffset *p; /* ignore double and triple click */ if (event->type != GDK_BUTTON_PRESS) return; p = gtk_object_get_user_data (GTK_OBJECT(widget)); p->x = (int) event->x; p->y = (int) event->y; gtk_grab_add (widget); gdk_pointer_grab (widget->window, TRUE, GDK_BUTTON_RELEASE_MASK | GDK_BUTTON_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK, NULL, NULL, 0); } static void shape_released (GtkWidget *widget) { gtk_grab_remove (widget); gdk_pointer_ungrab (0); } static void shape_motion (GtkWidget *widget, GdkEventMotion *event) { gint xp, yp; CursorOffset * p; GdkModifierType mask; p = gtk_object_get_user_data (GTK_OBJECT (widget)); /* * Can't use event->x / event->y here * because I need absolute coordinates. */ gdk_window_get_pointer (root_win, &xp, &yp, &mask); gtk_widget_set_uposition (widget, xp - p->x, yp - p->y); } GtkWidget * shape_create_icon (char *xpm_file, gint x, gint y, gint px, gint py, gint window_type) { GtkWidget *window; GtkWidget *pixmap; GtkWidget *fixed; CursorOffset* icon_pos; GdkGC* gc; GdkBitmap *gdk_pixmap_mask; GdkPixmap *gdk_pixmap; GtkStyle *style; style = gtk_widget_get_default_style (); gc = style->black_gc; /* * GDK_WINDOW_TOPLEVEL works also, giving you a title border */ window = gtk_window_new (window_type); fixed = gtk_fixed_new (); gtk_widget_set_usize (fixed, 100,100); gtk_container_add (GTK_CONTAINER (window), fixed); gtk_widget_show (fixed); gtk_widget_set_events (window, gtk_widget_get_events (window) | GDK_BUTTON_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK | GDK_BUTTON_PRESS_MASK); gtk_widget_realize (window); gdk_pixmap = gdk_pixmap_create_from_xpm (window->window, &gdk_pixmap_mask, &style->bg[GTK_STATE_NORMAL], xpm_file); pixmap = gtk_pixmap_new (gdk_pixmap, gdk_pixmap_mask); gtk_fixed_put (GTK_FIXED (fixed), pixmap, px,py); gtk_widget_show (pixmap); gtk_widget_shape_combine_mask (window, gdk_pixmap_mask, px,py); gtk_signal_connect (GTK_OBJECT (window), "button_press_event", GTK_SIGNAL_FUNC (shape_pressed),NULL); gtk_signal_connect (GTK_OBJECT (window), "button_release_event", GTK_SIGNAL_FUNC (shape_released),NULL); gtk_signal_connect (GTK_OBJECT (window), "motion_notify_event", GTK_SIGNAL_FUNC (shape_motion),NULL); icon_pos = g_new (CursorOffset, 1); gtk_object_set_user_data(GTK_OBJECT(window), icon_pos); gtk_widget_set_uposition (window, x, y); gtk_widget_show (window); return window; } void create_shapes (void) { /* Variables used by the Drag/Drop and Shape Window demos */ static GtkWidget *modeller = NULL; static GtkWidget *sheets = NULL; static GtkWidget *rings = NULL; root_win = gdk_window_foreign_new (GDK_ROOT_WINDOW ()); if (!modeller) { modeller = shape_create_icon ("Modeller.xpm", 440, 140, 0,0, GTK_WINDOW_POPUP); gtk_signal_connect (GTK_OBJECT (modeller), "destroy", GTK_SIGNAL_FUNC(gtk_widget_destroyed), &modeller); } else gtk_widget_destroy (modeller); if (!sheets) { sheets = shape_create_icon ("FilesQueue.xpm", 580, 170, 0,0, GTK_WINDOW_POPUP); gtk_signal_connect (GTK_OBJECT (sheets), "destroy", GTK_SIGNAL_FUNC(gtk_widget_destroyed), &sheets); } else gtk_widget_destroy (sheets); if (!rings) { rings = shape_create_icon ("3DRings.xpm", 460, 270, 25,25, GTK_WINDOW_TOPLEVEL); gtk_signal_connect (GTK_OBJECT (rings), "destroy", GTK_SIGNAL_FUNC(gtk_widget_destroyed), &rings); } else gtk_widget_destroy (rings); } void create_wmhints (void) { static GtkWidget *window = NULL; GtkWidget *label; GtkWidget *separator; GtkWidget *button; GtkWidget *box1; GtkWidget *box2; GdkBitmap *circles; if (!window) { window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_signal_connect (GTK_OBJECT (window), "destroy", GTK_SIGNAL_FUNC(gtk_widget_destroyed), &window); gtk_window_set_title (GTK_WINDOW (window), "WM Hints"); gtk_container_border_width (GTK_CONTAINER (window), 0); gtk_widget_realize (window); circles = gdk_bitmap_create_from_data (window->window, circles_bits, circles_width, circles_height); gdk_window_set_icon (window->window, NULL, circles, circles); gdk_window_set_icon_name (window->window, "WMHints Test Icon"); gdk_window_set_decorations (window->window, GDK_DECOR_ALL | GDK_DECOR_MENU); gdk_window_set_functions (window->window, GDK_FUNC_ALL | GDK_FUNC_RESIZE); box1 = gtk_vbox_new (FALSE, 0); gtk_container_add (GTK_CONTAINER (window), box1); gtk_widget_show (box1); label = gtk_label_new ("Try iconizing me!"); gtk_widget_set_usize (label, 150, 50); gtk_box_pack_start (GTK_BOX (box1), label, TRUE, TRUE, 0); gtk_widget_show (label); separator = gtk_hseparator_new (); gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0); gtk_widget_show (separator); box2 = gtk_vbox_new (FALSE, 10); gtk_container_border_width (GTK_CONTAINER (box2), 10); gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0); gtk_widget_show (box2); button = gtk_button_new_with_label ("close"); gtk_signal_connect_object (GTK_OBJECT (button), "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy), GTK_OBJECT (window)); gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0); GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT); gtk_widget_grab_default (button); gtk_widget_show (button); } if (!GTK_WIDGET_VISIBLE (window)) gtk_widget_show (window); else gtk_widget_destroy (window); } /* * Progress Bar */ static int progress_timer = 0; gint progress_timeout (gpointer data) { gfloat new_val; new_val = GTK_PROGRESS_BAR (data)->percentage; if (new_val >= 1.0) new_val = 0.0; new_val += 0.02; gtk_progress_bar_update (GTK_PROGRESS_BAR (data), new_val); return TRUE; } static void destroy_progress (GtkWidget *widget, GtkWidget **window) { gtk_timeout_remove (progress_timer); progress_timer = 0; *window = NULL; } void create_progress_bar (void) { static GtkWidget *window = NULL; GtkWidget *button; GtkWidget *vbox; GtkWidget *pbar; GtkWidget *label; GtkTooltips *tooltips; if (!window) { window = gtk_dialog_new (); gtk_signal_connect (GTK_OBJECT (window), "destroy", GTK_SIGNAL_FUNC(destroy_progress), &window); gtk_window_set_title (GTK_WINDOW (window), "dialog"); gtk_container_border_width (GTK_CONTAINER (window), 0); tooltips = gtk_tooltips_new(); vbox = gtk_vbox_new (FALSE, 5); gtk_container_border_width (GTK_CONTAINER (vbox), 10); gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), vbox, TRUE, TRUE, 0); gtk_widget_show (vbox); label = gtk_label_new ("progress..."); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, TRUE, 0); gtk_widget_show (label); pbar = gtk_progress_bar_new (); gtk_widget_set_events (pbar, GDK_ENTER_NOTIFY_MASK | GDK_LEAVE_NOTIFY_MASK); gtk_widget_set_usize (pbar, 200, 20); gtk_box_pack_start (GTK_BOX (vbox), pbar, TRUE, TRUE, 0); gtk_widget_show (pbar); gtk_tooltips_set_tip (tooltips, pbar, "Countdown is progressing yet!", "Secret!"); gtk_tooltips_set_delay (tooltips, 0); progress_timer = gtk_timeout_add (100, progress_timeout, pbar); button = gtk_button_new_with_label ("close"); gtk_signal_connect_object (GTK_OBJECT (button), "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy), GTK_OBJECT (window)); GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT); gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area), button, TRUE, TRUE, 0); gtk_widget_grab_default (button); gtk_widget_show (button); } if (!GTK_WIDGET_VISIBLE (window)) gtk_widget_show (window); else gtk_widget_destroy (window); } /* * Color Preview */ static int color_idle = 0; gint color_idle_func (GtkWidget *preview) { static int count = 1; guchar buf[768]; int i, j, k; for (i = 0; i < 256; i++) { for (j = 0, k = 0; j < 256; j++) { buf[k+0] = i + count; buf[k+1] = 0; buf[k+2] = j + count; k += 3; } gtk_preview_draw_row (GTK_PREVIEW (preview), buf, 0, i, 256); } count += 1; gtk_widget_draw (preview, NULL); return TRUE; } static void color_preview_destroy (GtkWidget *widget, GtkWidget **window) { gtk_idle_remove (color_idle); color_idle = 0; *window = NULL; } void create_color_preview (void) { static GtkWidget *window = NULL; GtkWidget *preview; guchar buf[768]; int i, j, k; if (!window) { window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_signal_connect (GTK_OBJECT (window), "destroy", GTK_SIGNAL_FUNC(color_preview_destroy), &window); gtk_window_set_title (GTK_WINDOW (window), "test"); gtk_container_border_width (GTK_CONTAINER (window), 10); preview = gtk_preview_new (GTK_PREVIEW_COLOR); gtk_preview_size (GTK_PREVIEW (preview), 256, 256); gtk_container_add (GTK_CONTAINER (window), preview); gtk_widget_show (preview); for (i = 0; i < 256; i++) { for (j = 0, k = 0; j < 256; j++) { buf[k+0] = i; buf[k+1] = 0; buf[k+2] = j; k += 3; } gtk_preview_draw_row (GTK_PREVIEW (preview), buf, 0, i, 256); } color_idle = gtk_idle_add ((GtkFunction) color_idle_func, preview); } if (!GTK_WIDGET_VISIBLE (window)) gtk_widget_show (window); else gtk_widget_destroy (window); } /* * Gray Preview */ static int gray_idle = 0; gint gray_idle_func (GtkWidget *preview) { static int count = 1; guchar buf[256]; int i, j; for (i = 0; i < 256; i++) { for (j = 0; j < 256; j++) buf[j] = i + j + count; gtk_preview_draw_row (GTK_PREVIEW (preview), buf, 0, i, 256); } count += 1; gtk_widget_draw (preview, NULL); return TRUE; } static void gray_preview_destroy (GtkWidget *widget, GtkWidget **window) { gtk_idle_remove (gray_idle); gray_idle = 0; *window = NULL; } void create_gray_preview (void) { static GtkWidget *window = NULL; GtkWidget *preview; guchar buf[256]; int i, j; if (!window) { window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_signal_connect (GTK_OBJECT (window), "destroy", GTK_SIGNAL_FUNC(gray_preview_destroy), &window); gtk_window_set_title (GTK_WINDOW (window), "test"); gtk_container_border_width (GTK_CONTAINER (window), 10); preview = gtk_preview_new (GTK_PREVIEW_GRAYSCALE); gtk_preview_size (GTK_PREVIEW (preview), 256, 256); gtk_container_add (GTK_CONTAINER (window), preview); gtk_widget_show (preview); for (i = 0; i < 256; i++) { for (j = 0; j < 256; j++) buf[j] = i + j; gtk_preview_draw_row (GTK_PREVIEW (preview), buf, 0, i, 256); } gray_idle = gtk_idle_add ((GtkFunction) gray_idle_func, preview); } if (!GTK_WIDGET_VISIBLE (window)) gtk_widget_show (window); else gtk_widget_destroy (window); } /* * Selection Test */ void selection_test_received (GtkWidget *list, GtkSelectionData *data) { GdkAtom *atoms; GtkWidget *list_item; GList *item_list; int i, l; if (data->length < 0) { g_print ("Selection retrieval failed\n"); return; } if (data->type != GDK_SELECTION_TYPE_ATOM) { g_print ("Selection \"TARGETS\" was not returned as atoms!\n"); return; } /* Clear out any current list items */ gtk_list_clear_items (GTK_LIST(list), 0, -1); /* Add new items to list */ atoms = (GdkAtom *)data->data; item_list = NULL; l = data->length / sizeof (GdkAtom); for (i = 0; i < l; i++) { char *name; name = gdk_atom_name (atoms[i]); if (name != NULL) { list_item = gtk_list_item_new_with_label (name); g_free (name); } else list_item = gtk_list_item_new_with_label ("(bad atom)"); gtk_widget_show (list_item); item_list = g_list_append (item_list, list_item); } gtk_list_append_items (GTK_LIST (list), item_list); return; } void selection_test_get_targets (GtkWidget *widget, GtkWidget *list) { static GdkAtom targets_atom = GDK_NONE; if (targets_atom == GDK_NONE) targets_atom = gdk_atom_intern ("TARGETS", FALSE); gtk_selection_convert (list, GDK_SELECTION_PRIMARY, targets_atom, GDK_CURRENT_TIME); } void create_selection_test (void) { static GtkWidget *window = NULL; GtkWidget *button; GtkWidget *vbox; GtkWidget *scrolled_win; GtkWidget *list; GtkWidget *label; if (!window) { window = gtk_dialog_new (); gtk_signal_connect (GTK_OBJECT (window), "destroy", GTK_SIGNAL_FUNC(gtk_widget_destroyed), &window); gtk_window_set_title (GTK_WINDOW (window), "Selection Test"); gtk_container_border_width (GTK_CONTAINER (window), 0); /* Create the list */ vbox = gtk_vbox_new (FALSE, 5); gtk_container_border_width (GTK_CONTAINER (vbox), 10); gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), vbox, TRUE, TRUE, 0); gtk_widget_show (vbox); label = gtk_label_new ("Gets available targets for current selection"); gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0); gtk_widget_show (label); scrolled_win = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_box_pack_start (GTK_BOX (vbox), scrolled_win, TRUE, TRUE, 0); gtk_widget_set_usize (scrolled_win, 100, 200); gtk_widget_show (scrolled_win); list = gtk_list_new (); gtk_container_add (GTK_CONTAINER (scrolled_win), list); gtk_signal_connect (GTK_OBJECT(list), "selection_received", GTK_SIGNAL_FUNC (selection_test_received), NULL); gtk_widget_show (list); /* .. And create some buttons */ button = gtk_button_new_with_label ("Get Targets"); gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area), button, TRUE, TRUE, 0); gtk_signal_connect (GTK_OBJECT (button), "clicked", GTK_SIGNAL_FUNC (selection_test_get_targets), list); gtk_widget_show (button); button = gtk_button_new_with_label ("Quit"); gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area), button, TRUE, TRUE, 0); gtk_signal_connect_object (GTK_OBJECT (button), "clicked", GTK_SIGNAL_FUNC (gtk_widget_destroy), GTK_OBJECT (window)); gtk_widget_show (button); } if (!GTK_WIDGET_VISIBLE (window)) gtk_widget_show (window); else gtk_widget_destroy (window); } /* * Gamma Curve */ void create_gamma_curve (void) { static GtkWidget *window = NULL, *curve; static int count = 0; gfloat vec[256]; gint max; gint i; if (!window) { window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_title (GTK_WINDOW (window), "test"); gtk_container_border_width (GTK_CONTAINER (window), 10); gtk_signal_connect (GTK_OBJECT (window), "destroy", GTK_SIGNAL_FUNC(gtk_widget_destroyed), &window); curve = gtk_gamma_curve_new (); gtk_container_add (GTK_CONTAINER (window), curve); gtk_widget_show (curve); } max = 127 + (count % 2)*128; gtk_curve_set_range (GTK_CURVE (GTK_GAMMA_CURVE (curve)->curve), 0, max, 0, max); for (i = 0; i < max; ++i) vec[i] = (127 / sqrt (max)) * sqrt (i); gtk_curve_set_vector (GTK_CURVE (GTK_GAMMA_CURVE (curve)->curve), max, vec); if (!GTK_WIDGET_VISIBLE (window)) gtk_widget_show (window); else if (count % 4 == 3) { gtk_widget_destroy (window); window = NULL; } ++count; } static int scroll_test_pos = 0.0; static GdkGC *scroll_test_gc = NULL; static gint scroll_test_expose (GtkWidget *widget, GdkEventExpose *event, GtkAdjustment *adj) { gint i,j; gint imin, imax, jmin, jmax; imin = (event->area.x) / 10; imax = (event->area.x + event->area.width + 9) / 10; jmin = ((int)adj->value + event->area.y) / 10; jmax = ((int)adj->value + event->area.y + event->area.height + 9) / 10; gdk_window_clear_area (widget->window, event->area.x, event->area.y, event->area.width, event->area.height); for (i=imin; iwindow, widget->style->black_gc, TRUE, 10*i, 10*j - (int)adj->value, 1+i%10, 1+j%10); return TRUE; } static void scroll_test_configure (GtkWidget *widget, GdkEventConfigure *event, GtkAdjustment *adj) { adj->page_increment = 0.9 * widget->allocation.height; adj->page_size = widget->allocation.height; gtk_signal_emit_by_name (GTK_OBJECT (adj), "changed"); } static void scroll_test_adjustment_changed (GtkAdjustment *adj, GtkWidget *widget) { gint source_min = (int)adj->value - scroll_test_pos; gint source_max = source_min + widget->allocation.height; gint dest_min = 0; gint dest_max = widget->allocation.height; GdkRectangle rect; GdkEvent *event; scroll_test_pos = adj->value; if (!GTK_WIDGET_DRAWABLE (widget)) return; if (source_min < 0) { rect.x = 0; rect.y = 0; rect.width = widget->allocation.width; rect.height = -source_min; if (rect.height > widget->allocation.height) rect.height = widget->allocation.height; source_min = 0; dest_min = rect.height; } else { rect.x = 0; rect.y = 2*widget->allocation.height - source_max; if (rect.y < 0) rect.y = 0; rect.width = widget->allocation.width; rect.height = widget->allocation.height - rect.y; source_max = widget->allocation.height; dest_max = rect.y; } if (source_min != source_max) { if (scroll_test_gc == NULL) { scroll_test_gc = gdk_gc_new (widget->window); gdk_gc_set_exposures (scroll_test_gc, TRUE); } gdk_draw_pixmap (widget->window, scroll_test_gc, widget->window, 0, source_min, 0, dest_min, widget->allocation.width, source_max - source_min); /* Make sure graphics expose events are processed before scrolling * again */ while ((event = gdk_event_get_graphics_expose (widget->window)) != NULL) { gtk_widget_event (widget, event); if (event->expose.count == 0) { gdk_event_free (event); break; } gdk_event_free (event); } } if (rect.height != 0) gtk_widget_draw (widget, &rect); } void create_scroll_test (void) { static GtkWidget *window = NULL; GtkWidget *hbox; GtkWidget *drawing_area; GtkWidget *scrollbar; GtkWidget *button; GtkAdjustment *adj; if (!window) { window = gtk_dialog_new (); gtk_signal_connect (GTK_OBJECT (window), "destroy", GTK_SIGNAL_FUNC(gtk_widget_destroyed), &window); gtk_window_set_title (GTK_WINDOW (window), "Scroll Test"); gtk_container_border_width (GTK_CONTAINER (window), 0); hbox = gtk_hbox_new (FALSE, 0); gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), hbox, TRUE, TRUE, 0); gtk_widget_show (hbox); drawing_area = gtk_drawing_area_new (); gtk_drawing_area_size (GTK_DRAWING_AREA (drawing_area), 200, 200); gtk_box_pack_start (GTK_BOX (hbox), drawing_area, TRUE, TRUE, 0); gtk_widget_show (drawing_area); gtk_widget_set_events (drawing_area, GDK_EXPOSURE_MASK); adj = GTK_ADJUSTMENT (gtk_adjustment_new (0.0, 0.0, 1000.0, 1.0, 180.0, 200.0)); scroll_test_pos = 0.0; scrollbar = gtk_vscrollbar_new (adj); gtk_box_pack_start (GTK_BOX (hbox), scrollbar, FALSE, FALSE, 0); gtk_widget_show (scrollbar); gtk_signal_connect (GTK_OBJECT (drawing_area), "expose_event", GTK_SIGNAL_FUNC (scroll_test_expose), adj); gtk_signal_connect (GTK_OBJECT (drawing_area), "configure_event", GTK_SIGNAL_FUNC (scroll_test_configure), adj); gtk_signal_connect (GTK_OBJECT (adj), "value_changed", GTK_SIGNAL_FUNC (scroll_test_adjustment_changed), drawing_area); /* .. And create some buttons */ button = gtk_button_new_with_label ("Quit"); gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area), button, TRUE, TRUE, 0); gtk_signal_connect_object (GTK_OBJECT (button), "clicked", GTK_SIGNAL_FUNC (gtk_widget_destroy), GTK_OBJECT (window)); gtk_widget_show (button); } if (!GTK_WIDGET_VISIBLE (window)) gtk_widget_show (window); else gtk_widget_destroy (window); } /* * Timeout Test */ static int timer = 0; gint timeout_test (GtkWidget *label) { static int count = 0; static char buffer[32]; sprintf (buffer, "count: %d", ++count); gtk_label_set (GTK_LABEL (label), buffer); return TRUE; } void start_timeout_test (GtkWidget *widget, GtkWidget *label) { if (!timer) { timer = gtk_timeout_add (100, (GtkFunction) timeout_test, label); } } void stop_timeout_test (GtkWidget *widget, gpointer data) { if (timer) { gtk_timeout_remove (timer); timer = 0; } } void destroy_timeout_test (GtkWidget *widget, GtkWidget **window) { stop_timeout_test (NULL, NULL); *window = NULL; } void create_timeout_test (void) { static GtkWidget *window = NULL; GtkWidget *button; GtkWidget *label; if (!window) { window = gtk_dialog_new (); gtk_signal_connect (GTK_OBJECT (window), "destroy", GTK_SIGNAL_FUNC(destroy_timeout_test), &window); gtk_window_set_title (GTK_WINDOW (window), "Timeout Test"); gtk_container_border_width (GTK_CONTAINER (window), 0); label = gtk_label_new ("count: 0"); gtk_misc_set_padding (GTK_MISC (label), 10, 10); gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), label, TRUE, TRUE, 0); gtk_widget_show (label); button = gtk_button_new_with_label ("close"); gtk_signal_connect_object (GTK_OBJECT (button), "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy), GTK_OBJECT (window)); GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT); gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area), button, TRUE, TRUE, 0); gtk_widget_grab_default (button); gtk_widget_show (button); button = gtk_button_new_with_label ("start"); gtk_signal_connect (GTK_OBJECT (button), "clicked", GTK_SIGNAL_FUNC(start_timeout_test), label); GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT); gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area), button, TRUE, TRUE, 0); gtk_widget_show (button); button = gtk_button_new_with_label ("stop"); gtk_signal_connect (GTK_OBJECT (button), "clicked", GTK_SIGNAL_FUNC(stop_timeout_test), NULL); GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT); gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area), button, TRUE, TRUE, 0); gtk_widget_show (button); } if (!GTK_WIDGET_VISIBLE (window)) gtk_widget_show (window); else gtk_widget_destroy (window); } /* * Idle Test */ static int idle = 0; gint idle_test (GtkWidget *label) { static int count = 0; static char buffer[32]; sprintf (buffer, "count: %d", ++count); gtk_label_set (GTK_LABEL (label), buffer); return TRUE; } void start_idle_test (GtkWidget *widget, GtkWidget *label) { if (!idle) { idle = gtk_idle_add ((GtkFunction) idle_test, label); } } void stop_idle_test (GtkWidget *widget, gpointer data) { if (idle) { gtk_idle_remove (idle); idle = 0; } } void destroy_idle_test (GtkWidget *widget, GtkWidget **window) { stop_idle_test (NULL, NULL); *window = NULL; } void create_idle_test (void) { static GtkWidget *window = NULL; GtkWidget *button; GtkWidget *label; if (!window) { window = gtk_dialog_new (); gtk_signal_connect (GTK_OBJECT (window), "destroy", GTK_SIGNAL_FUNC(destroy_idle_test), &window); gtk_window_set_title (GTK_WINDOW (window), "Idle Test"); gtk_container_border_width (GTK_CONTAINER (window), 0); label = gtk_label_new ("count: 0"); gtk_misc_set_padding (GTK_MISC (label), 10, 10); gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), label, TRUE, TRUE, 0); gtk_widget_show (label); button = gtk_button_new_with_label ("close"); gtk_signal_connect_object (GTK_OBJECT (button), "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy), GTK_OBJECT (window)); GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT); gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area), button, TRUE, TRUE, 0); gtk_widget_grab_default (button); gtk_widget_show (button); button = gtk_button_new_with_label ("start"); gtk_signal_connect (GTK_OBJECT (button), "clicked", GTK_SIGNAL_FUNC(start_idle_test), label); GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT); gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area), button, TRUE, TRUE, 0); gtk_widget_show (button); button = gtk_button_new_with_label ("stop"); gtk_signal_connect (GTK_OBJECT (button), "clicked", GTK_SIGNAL_FUNC(stop_idle_test), NULL); GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT); gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area), button, TRUE, TRUE, 0); gtk_widget_show (button); } if (!GTK_WIDGET_VISIBLE (window)) gtk_widget_show (window); else gtk_widget_destroy (window); } void reload_rc_file (void) { GList *toplevels; if (gtk_rc_reparse_all ()) { toplevels = gdk_window_get_toplevels(); while (toplevels) { GtkWidget *widget; gdk_window_get_user_data (toplevels->data, (gpointer *)&widget); if (widget) gtk_widget_reset_rc_styles (widget); toplevels = toplevels->next; } g_list_free (toplevels); } } void reload_all_rc_files (void) { static GdkAtom atom_rcfiles = GDK_NONE; GdkEventClient sev; int i; if (!atom_rcfiles) atom_rcfiles = gdk_atom_intern("_GTK_READ_RCFILES", FALSE); for(i = 0; i < 5; i++) sev.data.l[i] = 0; sev.data_format = 32; sev.message_type = atom_rcfiles; gdk_event_send_clientmessage_toall ((GdkEvent *) &sev); } void create_rc_file (void) { static GtkWidget *window = NULL; GtkWidget *button; if (!window) { window = gtk_dialog_new (); gtk_signal_connect (GTK_OBJECT (window), "destroy", GTK_SIGNAL_FUNC(destroy_idle_test), &window); gtk_window_set_title (GTK_WINDOW (window), "Reload Rc file"); gtk_container_border_width (GTK_CONTAINER (window), 0); button = gtk_button_new_with_label ("Reload"); gtk_signal_connect (GTK_OBJECT (button), "clicked", GTK_SIGNAL_FUNC(reload_rc_file), NULL); GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT); gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area), button, TRUE, TRUE, 0); gtk_widget_grab_default (button); gtk_widget_show (button); button = gtk_button_new_with_label ("Reload All"); gtk_signal_connect (GTK_OBJECT (button), "clicked", GTK_SIGNAL_FUNC(reload_all_rc_files), NULL); GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT); gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area), button, TRUE, TRUE, 0); gtk_widget_show (button); button = gtk_button_new_with_label ("Close"); gtk_signal_connect_object (GTK_OBJECT (button), "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy), GTK_OBJECT (window)); GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT); gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area), button, TRUE, TRUE, 0); gtk_widget_show (button); } if (!GTK_WIDGET_VISIBLE (window)) gtk_widget_show (window); else gtk_widget_destroy (window); } /* * Test of recursive mainloop */ void mainloop_destroyed (GtkWidget *w, GtkWidget **window) { *window = NULL; gtk_main_quit (); } void create_mainloop (void) { static GtkWidget *window = NULL; GtkWidget *label; GtkWidget *button; if (!window) { window = gtk_dialog_new (); gtk_window_set_title (GTK_WINDOW (window), "Test Main Loop"); gtk_signal_connect (GTK_OBJECT (window), "destroy", GTK_SIGNAL_FUNC(mainloop_destroyed), &window); label = gtk_label_new ("In recursive main loop..."); gtk_misc_set_padding (GTK_MISC(label), 20, 20); gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), label, TRUE, TRUE, 0); gtk_widget_show (label); button = gtk_button_new_with_label ("Leave"); gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area), button, FALSE, TRUE, 0); gtk_signal_connect_object (GTK_OBJECT (button), "clicked", GTK_SIGNAL_FUNC (gtk_widget_destroy), GTK_OBJECT (window)); GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT); gtk_widget_grab_default (button); gtk_widget_show (button); } if (!GTK_WIDGET_VISIBLE (window)) { gtk_widget_show (window); g_print ("create_mainloop: start\n"); gtk_main (); g_print ("create_mainloop: done\n"); } else gtk_widget_destroy (window); } /* * Main Window and Exit */ void do_exit (GtkWidget *widget, GtkWidget *window) { gtk_widget_destroy (window); gtk_main_quit (); } void create_main_window (void) { struct { char *label; void (*func) (); } buttons[] = { { "button box", create_button_box }, { "buttons", create_buttons }, { "check buttons", create_check_buttons }, { "clist", create_clist}, { "color selection", create_color_selection }, { "ctree", create_ctree }, { "cursors", create_cursors }, { "dialog", create_dialog }, { "dnd", create_dnd }, { "entry", create_entry }, { "file selection", create_file_selection }, { "font selection", create_font_selection }, { "gamma curve", create_gamma_curve }, { "handle box", create_handle_box }, { "list", create_list }, { "menus", create_menus }, { "miscellaneous", NULL }, { "notebook", create_notebook }, { "panes", create_panes }, { "pixmap", create_pixmap }, { "preview color", create_color_preview }, { "preview gray", create_gray_preview }, { "progress bar", create_progress_bar }, { "radio buttons", create_radio_buttons }, { "range controls", create_range_controls }, { "rc file", create_rc_file }, { "reparent", create_reparent }, { "rulers", create_rulers }, { "scrolled windows", create_scrolled_windows }, { "shapes", create_shapes }, { "spinbutton", create_spins }, { "statusbar", create_statusbar }, { "test idle", create_idle_test }, { "test mainloop", create_mainloop }, { "test scrolling", create_scroll_test }, { "test selection", create_selection_test }, { "test timeout", create_timeout_test }, { "text", create_text }, { "toggle buttons", create_toggle_buttons }, { "toolbar", create_toolbar }, { "tooltips", create_tooltips }, { "tree", create_tree_mode_window}, { "WM hints", create_wmhints }, }; int nbuttons = sizeof (buttons) / sizeof (buttons[0]); GtkWidget *window; GtkWidget *box1; GtkWidget *box2; GtkWidget *scrolled_window; GtkWidget *button; GtkWidget *label; gchar buffer[64]; GtkWidget *separator; int i; window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_policy (GTK_WINDOW (window), FALSE, FALSE, FALSE); gtk_widget_set_name (window, "main window"); gtk_widget_set_usize (window, 200, 400); gtk_widget_set_uposition (window, 20, 20); gtk_signal_connect (GTK_OBJECT (window), "destroy", GTK_SIGNAL_FUNC(gtk_main_quit), NULL); gtk_signal_connect (GTK_OBJECT (window), "delete-event", GTK_SIGNAL_FUNC (gtk_false), NULL); box1 = gtk_vbox_new (FALSE, 0); gtk_container_add (GTK_CONTAINER (window), box1); gtk_widget_show (box1); if (gtk_micro_version > 0) sprintf (buffer, "Gtk+ v%d.%d.%d", gtk_major_version, gtk_minor_version, gtk_micro_version); else sprintf (buffer, "Gtk+ v%d.%d", gtk_major_version, gtk_minor_version); label = gtk_label_new (buffer); gtk_widget_show (label); gtk_box_pack_start (GTK_BOX (box1), label, FALSE, FALSE, 0); scrolled_window = gtk_scrolled_window_new (NULL, NULL); gtk_container_border_width (GTK_CONTAINER (scrolled_window), 10); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); GTK_WIDGET_UNSET_FLAGS (GTK_SCROLLED_WINDOW (scrolled_window)->vscrollbar, GTK_CAN_FOCUS); gtk_box_pack_start (GTK_BOX (box1), scrolled_window, TRUE, TRUE, 0); gtk_widget_show (scrolled_window); box2 = gtk_vbox_new (FALSE, 0); gtk_container_border_width (GTK_CONTAINER (box2), 10); gtk_container_add (GTK_CONTAINER (scrolled_window), box2); gtk_container_set_focus_vadjustment (GTK_CONTAINER (box2), gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (scrolled_window))); gtk_widget_show (box2); for (i = 0; i < nbuttons; i++) { button = gtk_button_new_with_label (buttons[i].label); if (buttons[i].func) gtk_signal_connect (GTK_OBJECT (button), "clicked", GTK_SIGNAL_FUNC(buttons[i].func), NULL); else gtk_widget_set_sensitive (button, FALSE); gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0); gtk_widget_show (button); } separator = gtk_hseparator_new (); gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0); gtk_widget_show (separator); box2 = gtk_vbox_new (FALSE, 10); gtk_container_border_width (GTK_CONTAINER (box2), 10); gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0); gtk_widget_show (box2); button = gtk_button_new_with_label ("close"); gtk_signal_connect (GTK_OBJECT (button), "clicked", GTK_SIGNAL_FUNC (do_exit), window); gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0); GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT); gtk_widget_grab_default (button); gtk_widget_show (button); gtk_widget_show (window); } int main (int argc, char *argv[]) { gtk_set_locale (); gtk_init (&argc, &argv); #ifdef HAVE_LIBGLE gle_init (&argc, &argv); #endif /* !HAVE_LIBGLE */ gtk_rc_parse ("testgtkrc"); create_main_window (); gtk_main (); return 0; }