/* 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 Lesser 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 * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser 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. */ /* * Modified by the GTK+ Team and others 1997-2000. See the AUTHORS * file for a list of people on the GTK+ Team. See the ChangeLog * files for a list of changes. These files are distributed with * GTK+ at ftp://ftp.gtk.org/pub/gtk/. */ #include "config.h" #undef G_LOG_DOMAIN #include #include #include #include #include #include #ifdef HAVE_UNISTD_H #include #endif #define GTK_ENABLE_BROKEN #include "gtk.h" #include "gdk/gdk.h" #include "gdk/gdkkeysyms.h" #ifdef G_OS_WIN32 #define sleep(n) _sleep(n) #endif #include "circles.xbm" #include "test.xpm" typedef struct _OptionMenuItem { gchar *name; GtkSignalFunc func; } OptionMenuItem; gboolean file_exists (const char *filename) { struct stat statbuf; return stat (filename, &statbuf) == 0; } GtkWidget * shape_create_icon (char *xpm_file, gint x, gint y, gint px, gint py, gint window_type); static GtkWidget * build_option_menu (OptionMenuItem items[], gint num_items, gint history, gpointer data); /* 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 GtkWidget * build_option_menu (OptionMenuItem items[], gint num_items, gint history, gpointer data) { GtkWidget *omenu; GtkWidget *menu; GtkWidget *menu_item; gint i; omenu = gtk_option_menu_new (); menu = gtk_menu_new (); for (i = 0; i < num_items; i++) { menu_item = gtk_menu_item_new_with_label (items[i].name); gtk_signal_connect (GTK_OBJECT (menu_item), "activate", (GtkSignalFunc) items[i].func, data); gtk_menu_shell_append (GTK_MENU_SHELL (menu), menu_item); gtk_widget_show (menu_item); } gtk_option_menu_set_menu (GTK_OPTION_MENU (omenu), menu); gtk_option_menu_set_history (GTK_OPTION_MENU (omenu), history); return omenu; } 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; } /* * GtkButton */ 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) { GtkAccelGroup *accel_group; window = gtk_window_new (GTK_WINDOW_TOPLEVEL); accel_group = gtk_window_get_default_accel_group (GTK_WINDOW (window)); gtk_signal_connect (GTK_OBJECT (window), "destroy", GTK_SIGNAL_FUNC (gtk_widget_destroyed), &window); gtk_window_set_title (GTK_WINDOW (window), "GtkButton"); gtk_container_set_border_width (GTK_CONTAINER (window), 0); box1 = gtk_vbox_new (FALSE, 0); gtk_container_add (GTK_CONTAINER (window), 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_set_border_width (GTK_CONTAINER (table), 10); gtk_box_pack_start (GTK_BOX (box1), table, TRUE, TRUE, 0); button[0] = gtk_button_new_with_label ("button1"); button[1] = gtk_button_new_accel ("_button2", accel_group); button[2] = gtk_button_new_with_label ("button3"); button[3] = gtk_button_new_stock (GTK_STOCK_BUTTON_OK, NULL); 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_stock (GTK_STOCK_BUTTON_CLOSE, accel_group); 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_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_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_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_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_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_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_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_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); separator = gtk_hseparator_new (); gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0); box2 = gtk_vbox_new (FALSE, 10); gtk_container_set_border_width (GTK_CONTAINER (box2), 10); gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0); 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]); } if (!GTK_WIDGET_VISIBLE (window)) gtk_widget_show_all (window); else gtk_widget_hide (window); } /* * GtkToggleButton */ 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), "GtkToggleButton"); gtk_container_set_border_width (GTK_CONTAINER (window), 0); box1 = gtk_vbox_new (FALSE, 0); gtk_container_add (GTK_CONTAINER (window), box1); box2 = gtk_vbox_new (FALSE, 10); gtk_container_set_border_width (GTK_CONTAINER (box2), 10); gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0); button = gtk_toggle_button_new_with_label ("button1"); gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0); button = gtk_toggle_button_new_with_label ("button2"); gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0); button = gtk_toggle_button_new_with_label ("button3"); gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0); separator = gtk_hseparator_new (); gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0); box2 = gtk_vbox_new (FALSE, 10); gtk_container_set_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); } if (!GTK_WIDGET_VISIBLE (window)) gtk_widget_show_all (window); else gtk_widget_destroy (window); } /* * GtkCheckButton */ 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), "GtkCheckButton"); gtk_container_set_border_width (GTK_CONTAINER (window), 0); box1 = gtk_vbox_new (FALSE, 0); gtk_container_add (GTK_CONTAINER (window), box1); box2 = gtk_vbox_new (FALSE, 10); gtk_container_set_border_width (GTK_CONTAINER (box2), 10); gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0); button = gtk_check_button_new_with_label ("button1"); gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0); button = gtk_check_button_new_with_label ("button2"); gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0); button = gtk_check_button_new_with_label ("button3"); gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0); separator = gtk_hseparator_new (); gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0); box2 = gtk_vbox_new (FALSE, 10); gtk_container_set_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); } if (!GTK_WIDGET_VISIBLE (window)) gtk_widget_show_all (window); else gtk_widget_destroy (window); } /* * GtkRadioButton */ 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_set_border_width (GTK_CONTAINER (window), 0); box1 = gtk_vbox_new (FALSE, 0); gtk_container_add (GTK_CONTAINER (window), box1); box2 = gtk_vbox_new (FALSE, 10); gtk_container_set_border_width (GTK_CONTAINER (box2), 10); gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0); button = gtk_radio_button_new_with_label (NULL, "button1"); gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0); button = gtk_radio_button_new_with_label ( gtk_radio_button_group (GTK_RADIO_BUTTON (button)), "button2"); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE); gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0); 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); separator = gtk_hseparator_new (); gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0); box2 = gtk_vbox_new (FALSE, 10); gtk_container_set_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); } if (!GTK_WIDGET_VISIBLE (window)) gtk_widget_show_all (window); else gtk_widget_destroy (window); } /* * GtkButtonBox */ static GtkWidget * create_bbox (gint horizontal, char* title, gint spacing, gint child_w, gint child_h, gint layout) { GtkWidget *frame; GtkWidget *bbox; GtkWidget *button; frame = gtk_frame_new (title); if (horizontal) bbox = gtk_hbutton_box_new (); else bbox = gtk_vbutton_box_new (); gtk_container_set_border_width (GTK_CONTAINER (bbox), 5); gtk_container_add (GTK_CONTAINER (frame), bbox); 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); button = gtk_button_new_with_label ("OK"); gtk_container_add (GTK_CONTAINER (bbox), button); button = gtk_button_new_with_label ("Cancel"); gtk_container_add (GTK_CONTAINER (bbox), button); button = gtk_button_new_with_label ("Help"); gtk_container_add (GTK_CONTAINER (bbox), button); return frame; } static void create_button_box (void) { static GtkWidget* window = NULL; GtkWidget *main_vbox; GtkWidget *vbox; GtkWidget *hbox; GtkWidget *frame_horz; GtkWidget *frame_vert; if (!window) { window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_title (GTK_WINDOW (window), "Button Boxes"); gtk_signal_connect (GTK_OBJECT (window), "destroy", GTK_SIGNAL_FUNC(gtk_widget_destroyed), &window); gtk_container_set_border_width (GTK_CONTAINER (window), 10); main_vbox = gtk_vbox_new (FALSE, 0); gtk_container_add (GTK_CONTAINER (window), main_vbox); frame_horz = gtk_frame_new ("Horizontal Button Boxes"); gtk_box_pack_start (GTK_BOX (main_vbox), frame_horz, TRUE, TRUE, 10); vbox = gtk_vbox_new (FALSE, 0); gtk_container_set_border_width (GTK_CONTAINER (vbox), 10); gtk_container_add (GTK_CONTAINER (frame_horz), vbox); gtk_box_pack_start (GTK_BOX (vbox), create_bbox (TRUE, "Spread", 40, 85, 20, GTK_BUTTONBOX_SPREAD), TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (vbox), create_bbox (TRUE, "Edge", 40, 85, 20, GTK_BUTTONBOX_EDGE), TRUE, TRUE, 5); gtk_box_pack_start (GTK_BOX (vbox), create_bbox (TRUE, "Start", 40, 85, 20, GTK_BUTTONBOX_START), TRUE, TRUE, 5); gtk_box_pack_start (GTK_BOX (vbox), create_bbox (TRUE, "End", 40, 85, 20, GTK_BUTTONBOX_END), TRUE, TRUE, 5); frame_vert = gtk_frame_new ("Vertical Button Boxes"); gtk_box_pack_start (GTK_BOX (main_vbox), frame_vert, TRUE, TRUE, 10); hbox = gtk_hbox_new (FALSE, 0); gtk_container_set_border_width (GTK_CONTAINER (hbox), 10); gtk_container_add (GTK_CONTAINER (frame_vert), hbox); gtk_box_pack_start (GTK_BOX (hbox), create_bbox (FALSE, "Spread", 30, 85, 20, GTK_BUTTONBOX_SPREAD), TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (hbox), create_bbox (FALSE, "Edge", 30, 85, 20, GTK_BUTTONBOX_EDGE), TRUE, TRUE, 5); gtk_box_pack_start (GTK_BOX (hbox), create_bbox (FALSE, "Start", 30, 85, 20, GTK_BUTTONBOX_START), TRUE, TRUE, 5); gtk_box_pack_start (GTK_BOX (hbox), create_bbox (FALSE, "End", 30, 85, 20, GTK_BUTTONBOX_END), TRUE, TRUE, 5); } if (!GTK_WIDGET_VISIBLE (window)) gtk_widget_show_all (window); else gtk_widget_destroy (window); } /* * GtkToolBar */ static GtkWidget* new_pixmap (char *filename, GdkWindow *window, GdkColor *background) { GtkWidget *wpixmap; GdkPixmap *pixmap; GdkBitmap *mask; if (strcmp (filename, "test.xpm") == 0 || !file_exists (filename)) { pixmap = gdk_pixmap_create_from_xpm_d (window, &mask, background, openfile); } else 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_both_horiz (GtkWidget *widget, gpointer data) { gtk_toolbar_set_style (GTK_TOOLBAR (data), GTK_TOOLBAR_BOTH_HORIZ); } 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 set_toolbar_space_style_empty (GtkWidget *widget, gpointer data) { gtk_toolbar_set_space_style (GTK_TOOLBAR (data), GTK_TOOLBAR_SPACE_EMPTY); } static void set_toolbar_space_style_line (GtkWidget *widget, gpointer data) { gtk_toolbar_set_space_style (GTK_TOOLBAR (data), GTK_TOOLBAR_SPACE_LINE); } 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_set_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_item (GTK_TOOLBAR (toolbar), "Both (horizontal)", "Show toolbar icons and text in a horizontal fashion", "Toolbar/BothHoriz", new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]), (GtkSignalFunc) set_toolbar_both_horiz, toolbar); gtk_toolbar_append_space (GTK_TOOLBAR (toolbar)); entry = gtk_entry_new (); 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_toolbar_append_space (GTK_TOOLBAR (toolbar)); gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), "Empty", "Empty spaces", NULL, new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]), (GtkSignalFunc) set_toolbar_space_style_empty, toolbar); gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), "Lines", "Lines in spaces", NULL, new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]), (GtkSignalFunc) set_toolbar_space_style_line, toolbar); gtk_container_add (GTK_CONTAINER (window), toolbar); } if (!GTK_WIDGET_VISIBLE (window)) gtk_widget_show_all (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; } /* * GtkStatusBar */ 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 (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 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_set_border_width (GTK_CONTAINER (window), 0); box1 = gtk_vbox_new (FALSE, 0); gtk_container_add (GTK_CONTAINER (window), box1); box2 = gtk_vbox_new (FALSE, 10); gtk_container_set_border_width (GTK_CONTAINER (box2), 10); gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0); statusbar = gtk_statusbar_new (); gtk_box_pack_end (GTK_BOX (box1), statusbar, TRUE, TRUE, 0); gtk_signal_connect (GTK_OBJECT (statusbar), "text_popped", GTK_SIGNAL_FUNC (statusbar_popped), NULL); button = gtk_widget_new (gtk_button_get_type (), "label", "push something", "visible", TRUE, "parent", box2, NULL); g_object_set (G_OBJECT (button), "signal::clicked", statusbar_push, statusbar, NULL); button = gtk_widget_new (gtk_button_get_type (), "label", "pop", "visible", TRUE, "parent", box2, NULL); g_object_set (G_OBJECT (button), "signal_after::clicked", statusbar_pop, statusbar, NULL); button = gtk_widget_new (gtk_button_get_type (), "label", "steal #4", "visible", TRUE, "parent", box2, NULL); g_object_set (G_OBJECT (button), "signal_after::clicked", statusbar_steal, statusbar, NULL); button = gtk_widget_new (gtk_button_get_type (), "label", "test contexts", "visible", TRUE, "parent", box2, NULL); g_object_set (G_OBJECT (button), "swapped_signal_after::clicked", statusbar_contexts, statusbar, NULL); separator = gtk_hseparator_new (); gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0); box2 = gtk_vbox_new (FALSE, 10); gtk_container_set_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); } if (!GTK_WIDGET_VISIBLE (window)) gtk_widget_show_all (window); else gtk_widget_destroy (window); } /* * GtkTree */ 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)); g_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_OLD(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_OLD(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_OLD(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_OLD(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_set_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_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (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_set_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_set_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), "Set Tree Parameters"); 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); /* create upper box - selection box */ box2 = gtk_vbox_new(FALSE, 5); gtk_box_pack_start(GTK_BOX(box1), box2, TRUE, TRUE, 0); gtk_container_set_border_width(GTK_CONTAINER(box2), 5); box3 = gtk_hbox_new(FALSE, 5); gtk_box_pack_start(GTK_BOX(box2), box3, TRUE, TRUE, 0); /* create selection mode frame */ frame = gtk_frame_new("Selection Mode"); gtk_box_pack_start(GTK_BOX(box3), frame, TRUE, TRUE, 0); box4 = gtk_vbox_new(FALSE, 0); gtk_container_add(GTK_CONTAINER(frame), box4); gtk_container_set_border_width(GTK_CONTAINER(box4), 5); /* create radio button */ button = gtk_radio_button_new_with_label(NULL, "SINGLE"); gtk_box_pack_start(GTK_BOX(box4), button, TRUE, TRUE, 0); 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); 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); 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); box4 = gtk_vbox_new(FALSE, 0); gtk_container_add(GTK_CONTAINER(frame), box4); gtk_container_set_border_width(GTK_CONTAINER(box4), 5); /* 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_active(GTK_TOGGLE_BUTTON(button), TRUE); 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_active(GTK_TOGGLE_BUTTON(button), TRUE); 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); 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); box4 = gtk_hbox_new(FALSE, 5); gtk_container_add(GTK_CONTAINER(frame), box4); gtk_container_set_border_width(GTK_CONTAINER(box4), 5); /* create number of item spin button */ box5 = gtk_hbox_new(FALSE, 5); gtk_box_pack_start(GTK_BOX(box4), box5, FALSE, FALSE, 0); label = gtk_label_new("Number of items : "); gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5); gtk_box_pack_start (GTK_BOX (box5), label, FALSE, TRUE, 0); 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); 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); label = gtk_label_new("Depth : "); gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5); gtk_box_pack_start (GTK_BOX (box5), label, FALSE, TRUE, 0); 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); sTreeSampleSelection.recursion_spinner = spinner; /* create horizontal separator */ separator = gtk_hseparator_new(); gtk_box_pack_start(GTK_BOX(box1), separator, FALSE, FALSE, 0); /* create bottom button box */ box2 = gtk_hbox_new(TRUE, 10); gtk_box_pack_start(GTK_BOX(box1), box2, FALSE, FALSE, 0); gtk_container_set_border_width(GTK_CONTAINER(box2), 5); button = gtk_button_new_with_label("Create Tree"); gtk_box_pack_start(GTK_BOX(box2), button, TRUE, TRUE, 0); gtk_signal_connect(GTK_OBJECT (button), "clicked", (GtkSignalFunc) cb_create_tree, NULL); 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)); } if (!GTK_WIDGET_VISIBLE (window)) gtk_widget_show_all (window); else gtk_widget_destroy (window); } /* * GtkHandleBox */ 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 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, TRUE); gtk_signal_connect (GTK_OBJECT (window), "destroy", GTK_SIGNAL_FUNC(gtk_widget_destroyed), &window); gtk_container_set_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_box_pack_start (GTK_BOX (hbox), handle_box, FALSE, FALSE, 0); 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_box_pack_start (GTK_BOX (hbox), handle_box, FALSE, FALSE, 0); 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); } /* * Test for getting an image from a drawable */ struct GetImageData { GtkWidget *src; GtkWidget *snap; GtkWidget *sw; }; static void take_snapshot (GtkWidget *button, gpointer data) { struct GetImageData *gid = data; GdkRectangle visible; int width_fraction; int height_fraction; GdkGC *gc; GdkGC *black_gc; GdkColor color = { 0, 30000, 0, 0 }; GdkRectangle target; GdkImage *shot; /* Do some begin_paint_rect on some random rects, draw some * distinctive stuff into those rects, then take the snapshot. * figure out whether any rects were overlapped and report to * user. */ visible = gid->sw->allocation; visible.x = gtk_scrolled_window_get_hadjustment (GTK_SCROLLED_WINDOW (gid->sw))->value; visible.y = gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (gid->sw))->value; width_fraction = visible.width / 4; height_fraction = visible.height / 4; gc = gdk_gc_new (gid->src->window); black_gc = gid->src->style->black_gc; gdk_gc_set_rgb_fg_color (gc, &color); target.x = visible.x + width_fraction; target.y = visible.y + height_fraction * 3; target.width = width_fraction; target.height = height_fraction / 2; gdk_window_begin_paint_rect (gid->src->window, &target); gdk_draw_rectangle (gid->src->window, gc, TRUE, target.x, target.y, target.width, target.height); gdk_draw_rectangle (gid->src->window, black_gc, FALSE, target.x + 10, target.y + 10, target.width - 20, target.height - 20); target.x = visible.x + width_fraction; target.y = visible.y + height_fraction; target.width = width_fraction; target.height = height_fraction; gdk_window_begin_paint_rect (gid->src->window, &target); gdk_draw_rectangle (gid->src->window, gc, TRUE, target.x, target.y, target.width, target.height); gdk_draw_rectangle (gid->src->window, black_gc, FALSE, target.x + 10, target.y + 10, target.width - 20, target.height - 20); target.x = visible.x + width_fraction * 3; target.y = visible.y + height_fraction; target.width = width_fraction / 2; target.height = height_fraction; gdk_window_begin_paint_rect (gid->src->window, &target); gdk_draw_rectangle (gid->src->window, gc, TRUE, target.x, target.y, target.width, target.height); gdk_draw_rectangle (gid->src->window, black_gc, FALSE, target.x + 10, target.y + 10, target.width - 20, target.height - 20); target.x = visible.x + width_fraction * 2; target.y = visible.y + height_fraction * 2; target.width = width_fraction / 4; target.height = height_fraction / 4; gdk_window_begin_paint_rect (gid->src->window, &target); gdk_draw_rectangle (gid->src->window, gc, TRUE, target.x, target.y, target.width, target.height); gdk_draw_rectangle (gid->src->window, black_gc, FALSE, target.x + 10, target.y + 10, target.width - 20, target.height - 20); target.x += target.width / 2; target.y += target.width / 2; gdk_window_begin_paint_rect (gid->src->window, &target); gdk_draw_rectangle (gid->src->window, gc, TRUE, target.x, target.y, target.width, target.height); gdk_draw_rectangle (gid->src->window, black_gc, FALSE, target.x + 10, target.y + 10, target.width - 20, target.height - 20); /* Screen shot area */ target.x = visible.x + width_fraction * 1.5; target.y = visible.y + height_fraction * 1.5; target.width = width_fraction * 2; target.height = height_fraction * 2; shot = gdk_drawable_get_image (gid->src->window, target.x, target.y, target.width, target.height); gtk_image_set_from_image (GTK_IMAGE (gid->snap), shot, NULL); g_object_unref (G_OBJECT (shot)); gdk_window_end_paint (gid->src->window); gdk_window_end_paint (gid->src->window); gdk_window_end_paint (gid->src->window); gdk_window_end_paint (gid->src->window); gdk_window_end_paint (gid->src->window); gdk_draw_rectangle (gid->src->window, gid->src->style->black_gc, FALSE, target.x, target.y, target.width, target.height); g_object_unref (G_OBJECT (gc)); } static gint image_source_expose (GtkWidget *da, GdkEventExpose *event, gpointer data) { int x = event->area.x; GdkColor red = { 0, 65535, 0, 0 }; GdkColor green = { 0, 0, 65535, 0 }; GdkColor blue = { 0, 0, 0, 65535 }; GdkGC *gc; gc = gdk_gc_new (event->window); while (x < (event->area.x + event->area.width)) { switch (x % 7) { case 0: case 1: case 2: gdk_gc_set_rgb_fg_color (gc, &red); break; case 3: case 4: case 5: gdk_gc_set_rgb_fg_color (gc, &green); break; case 6: case 7: case 8: gdk_gc_set_rgb_fg_color (gc, &blue); break; default: g_assert_not_reached (); break; } gdk_draw_line (event->window, gc, x, event->area.y, x, event->area.y + event->area.height); ++x; } g_object_unref (G_OBJECT (gc)); return TRUE; } static void create_get_image (void) { static GtkWidget *window = NULL; if (window) gtk_widget_destroy (window); else { GtkWidget *sw; GtkWidget *src; GtkWidget *snap; GtkWidget *vbox; GtkWidget *hbox; GtkWidget *button; struct GetImageData *gid; gid = g_new (struct GetImageData, 1); window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_signal_connect (GTK_OBJECT (window), "destroy", GTK_SIGNAL_FUNC (gtk_widget_destroyed), &window); gtk_object_set_data_full (GTK_OBJECT (window), "testgtk-get-image-data", gid, g_free); vbox = gtk_vbox_new (FALSE, 0); gtk_container_add (GTK_CONTAINER (window), vbox); sw = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gid->sw = sw; gtk_widget_set_usize (sw, 400, 400); src = gtk_drawing_area_new (); gtk_widget_set_usize (src, 10000, 10000); gtk_signal_connect (GTK_OBJECT (src), "expose_event", GTK_SIGNAL_FUNC (image_source_expose), gid); gid->src = src; gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (sw), src); gtk_box_pack_start (GTK_BOX (vbox), sw, TRUE, TRUE, 0); hbox = gtk_hbox_new (FALSE, 3); snap = gtk_widget_new (GTK_TYPE_IMAGE, NULL); gid->snap = snap; sw = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_widget_set_usize (sw, 300, 300); gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (sw), snap); gtk_box_pack_end (GTK_BOX (hbox), sw, FALSE, FALSE, 5); button = gtk_button_new_with_label ("Get image from drawable"); gtk_signal_connect (GTK_OBJECT (button), "clicked", GTK_SIGNAL_FUNC (take_snapshot), gid); gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0); gtk_box_pack_end (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); gtk_widget_show_all (window); } } /* * Label Demo */ static void sensitivity_toggled (GtkWidget *toggle, GtkWidget *widget) { gtk_widget_set_sensitive (widget, GTK_TOGGLE_BUTTON (toggle)->active); } static GtkWidget* create_sensitivity_control (GtkWidget *widget) { GtkWidget *button; button = gtk_toggle_button_new_with_label ("Sensitive"); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), GTK_WIDGET_IS_SENSITIVE (widget)); gtk_signal_connect (GTK_OBJECT (button), "toggled", GTK_SIGNAL_FUNC (sensitivity_toggled), widget); gtk_widget_show_all (button); return button; } void create_labels (void) { static GtkWidget *window = NULL; GtkWidget *hbox; GtkWidget *vbox; GtkWidget *frame; GtkWidget *label; GtkWidget *button; if (!window) { guint keyval; 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), "Label"); vbox = gtk_vbox_new (FALSE, 5); hbox = gtk_hbox_new (FALSE, 5); gtk_container_add (GTK_CONTAINER (window), vbox); gtk_box_pack_end (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); button = create_sensitivity_control (hbox); gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0); vbox = gtk_vbox_new (FALSE, 5); gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 0); gtk_container_set_border_width (GTK_CONTAINER (window), 5); frame = gtk_frame_new ("Normal Label"); label = gtk_label_new ("This is a Normal label"); gtk_container_add (GTK_CONTAINER (frame), label); gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0); frame = gtk_frame_new ("Multi-line Label"); label = gtk_label_new ("This is a Multi-line label.\nSecond line\nThird line"); gtk_container_add (GTK_CONTAINER (frame), label); gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0); frame = gtk_frame_new ("Left Justified Label"); label = gtk_label_new ("This is a Left-Justified\nMulti-line label.\nThird line"); gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT); gtk_container_add (GTK_CONTAINER (frame), label); gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0); frame = gtk_frame_new ("Right Justified Label"); label = gtk_label_new ("This is a Right-Justified\nMulti-line label.\nFourth line, (j/k)"); gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_RIGHT); gtk_container_add (GTK_CONTAINER (frame), label); gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0); frame = gtk_frame_new ("Internationalized Label"); label = gtk_label_new ("French (Français) Bonjour, Salut\n" "Korean (한글) 안녕하세요, 안녕하십니까\n" "Russian (Русский) Здравствуйте!"); gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT); gtk_container_add (GTK_CONTAINER (frame), label); gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0); frame = gtk_frame_new ("Bidirection Label"); label = gtk_label_new ("Arabic السلام عليكم\n" "Hebrew שלום"); gtk_widget_set_direction (label, GTK_TEXT_DIR_RTL); gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_RIGHT); gtk_container_add (GTK_CONTAINER (frame), label); gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0); vbox = gtk_vbox_new (FALSE, 5); gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 0); frame = gtk_frame_new ("Line wrapped label"); label = gtk_label_new ("This is an example of a line-wrapped label. It should not be taking "\ "up the entire "/* big space to test spacing */\ "width allocated to it, but automatically wraps the words to fit. "\ "The time has come, for all good men, to come to the aid of their party. "\ "The sixth sheik's six sheep's sick.\n"\ " It supports multiple paragraphs correctly, and correctly adds "\ "many extra spaces. "); gtk_label_set_line_wrap (GTK_LABEL (label), TRUE); gtk_container_add (GTK_CONTAINER (frame), label); gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0); frame = gtk_frame_new ("Filled, wrapped label"); label = gtk_label_new ("This is an example of a line-wrapped, filled label. It should be taking "\ "up the entire width allocated to it. Here is a seneance to prove "\ "my point. Here is another sentence. "\ "Here comes the sun, do de do de do.\n"\ " This is a new paragraph.\n"\ " This is another newer, longer, better paragraph. It is coming to an end, "\ "unfortunately."); gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_FILL); gtk_label_set_line_wrap (GTK_LABEL (label), TRUE); gtk_container_add (GTK_CONTAINER (frame), label); gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0); frame = gtk_frame_new ("Underlined label"); label = gtk_label_new ("This label is underlined!\n" "This one is underlined (こんにちは) in quite a funky fashion"); gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT); gtk_label_set_pattern (GTK_LABEL (label), "_________________________ _ _________ _ _____ _ __ __ ___ ____ _____"); gtk_container_add (GTK_CONTAINER (frame), label); gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0); frame = gtk_frame_new ("Markup label"); label = gtk_label_new (NULL); /* There's also a gtk_label_set_markup() without accel if you * don't have an accelerator key */ keyval = gtk_label_set_markup_with_accel (GTK_LABEL (label), "This label has " "markup _such as " "Big Italics\n" "Monospace font\n" "Underline!\n" "foo\n" "Ugly colors\n" "and nothing on this line,\n" "or this.\n" "or this either\n" "or even on this one\n" "la la la la la\n" "but this _word is purple\n" "We like superscript and subscript too"); g_return_if_fail (keyval == GDK_s); gtk_container_add (GTK_CONTAINER (frame), label); gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0); } if (!GTK_WIDGET_VISIBLE (window)) gtk_widget_show_all (window); else gtk_widget_destroy (window); } /* * Reparent demo */ 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), "reparent"); gtk_container_set_border_width (GTK_CONTAINER (window), 0); box1 = gtk_vbox_new (FALSE, 0); gtk_container_add (GTK_CONTAINER (window), box1); box2 = gtk_hbox_new (FALSE, 5); gtk_container_set_border_width (GTK_CONTAINER (box2), 10); gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0); label = gtk_label_new ("Hello World"); frame = gtk_frame_new ("Frame 1"); gtk_box_pack_start (GTK_BOX (box2), frame, TRUE, TRUE, 0); box3 = gtk_vbox_new (FALSE, 5); gtk_container_set_border_width (GTK_CONTAINER (box3), 5); gtk_container_add (GTK_CONTAINER (frame), 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_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)); frame = gtk_frame_new ("Frame 2"); gtk_box_pack_start (GTK_BOX (box2), frame, TRUE, TRUE, 0); box3 = gtk_vbox_new (FALSE, 5); gtk_container_set_border_width (GTK_CONTAINER (box3), 5); gtk_container_add (GTK_CONTAINER (frame), 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); separator = gtk_hseparator_new (); gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0); box2 = gtk_vbox_new (FALSE, 10); gtk_container_set_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); } if (!GTK_WIDGET_VISIBLE (window)) gtk_widget_show_all (window); else gtk_widget_destroy (window); } /* * Saved Position */ gint upositionx = 0; gint upositiony = 0; static gint uposition_configure (GtkWidget *window) { GtkLabel *lx; GtkLabel *ly; gchar buffer[64]; lx = gtk_object_get_data (GTK_OBJECT (window), "x"); ly = gtk_object_get_data (GTK_OBJECT (window), "y"); gdk_window_get_root_origin (window->window, &upositionx, &upositiony); sprintf (buffer, "%d", upositionx); gtk_label_set_text (lx, buffer); sprintf (buffer, "%d", upositiony); gtk_label_set_text (ly, buffer); return FALSE; } static void uposition_stop_configure (GtkToggleButton *toggle, GtkObject *window) { if (toggle->active) gtk_signal_handler_block_by_func (window, uposition_configure, NULL); else gtk_signal_handler_unblock_by_func (window, uposition_configure, NULL); } static void create_saved_position (void) { static GtkWidget *window = NULL; if (!window) { GtkWidget *hbox; GtkWidget *main_vbox; GtkWidget *vbox; GtkWidget *x_label; GtkWidget *y_label; GtkWidget *button; GtkWidget *label; GtkWidget *any; window = gtk_widget_new (GTK_TYPE_WINDOW, "type", GTK_WINDOW_TOPLEVEL, "signal::configure_event", uposition_configure, NULL, "x", upositionx, "y", upositiony, "title", "Saved Position", NULL); gtk_signal_connect (GTK_OBJECT (window), "destroy", GTK_SIGNAL_FUNC (gtk_widget_destroyed), &window); main_vbox = gtk_vbox_new (FALSE, 5); gtk_container_set_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, "child", gtk_widget_new (GTK_TYPE_TOGGLE_BUTTON, "label", "Stop Events", "active", FALSE, "signal::clicked", uposition_stop_configure, window, "visible", TRUE, NULL), NULL); hbox = gtk_hbox_new (FALSE, 0); gtk_container_set_border_width (GTK_CONTAINER (hbox), 5); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0); label = gtk_label_new ("X Origin : "); gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0); x_label = gtk_label_new (""); gtk_box_pack_start (GTK_BOX (hbox), x_label, TRUE, TRUE, 0); gtk_object_set_data (GTK_OBJECT (window), "x", x_label); hbox = gtk_hbox_new (FALSE, 0); gtk_container_set_border_width (GTK_CONTAINER (hbox), 5); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0); label = gtk_label_new ("Y Origin : "); gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0); y_label = gtk_label_new (""); gtk_box_pack_start (GTK_BOX (hbox), y_label, TRUE, TRUE, 0); gtk_object_set_data (GTK_OBJECT (window), "y", y_label); 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_set_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_SET_FLAGS (button, GTK_CAN_DEFAULT); gtk_widget_grab_default (button); gtk_widget_show_all (window); } else gtk_widget_destroy (window); } /* * GtkPixmap */ static void create_pixmap (void) { static GtkWidget *window = NULL; GtkWidget *box1; GtkWidget *box2; GtkWidget *box3; GtkWidget *button; GtkWidget *label; GtkWidget *separator; GtkWidget *pixmapwid; 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), "GtkPixmap"); gtk_container_set_border_width (GTK_CONTAINER (window), 0); gtk_widget_realize(window); box1 = gtk_vbox_new (FALSE, 0); gtk_container_add (GTK_CONTAINER (window), box1); box2 = gtk_vbox_new (FALSE, 10); gtk_container_set_border_width (GTK_CONTAINER (box2), 10); gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0); button = gtk_button_new (); gtk_box_pack_start (GTK_BOX (box2), button, FALSE, FALSE, 0); pixmapwid = new_pixmap ("test.xpm", window->window, NULL); label = gtk_label_new ("Pixmap\ntest"); box3 = gtk_hbox_new (FALSE, 0); gtk_container_set_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); button = gtk_button_new (); gtk_box_pack_start (GTK_BOX (box2), button, FALSE, FALSE, 0); pixmapwid = new_pixmap ("test.xpm", window->window, NULL); label = gtk_label_new ("Pixmap\ntest"); box3 = gtk_hbox_new (FALSE, 0); gtk_container_set_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_set_sensitive (button, FALSE); separator = gtk_hseparator_new (); gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0); box2 = gtk_vbox_new (FALSE, 10); gtk_container_set_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); } if (!GTK_WIDGET_VISIBLE (window)) gtk_widget_show_all (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_text (GTK_LABEL (tips_query), tip_text ? "There is a Tip!" : "There is no Tip!"); /* don't let GtkTipsQuery reset its 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); box2 = gtk_vbox_new (FALSE, 10); gtk_container_set_border_width (GTK_CONTAINER (box2), 10); gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0); button = gtk_toggle_button_new_with_label ("button1"); gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0); 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_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_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, NULL); g_object_set (G_OBJECT (button), "swapped_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); box2 = gtk_vbox_new (FALSE, 10); gtk_container_set_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); gtk_tooltips_set_tip (tooltips, button, "Push this button to close window", "ContextHelp/buttons/Close"); } if (!GTK_WIDGET_VISIBLE (window)) gtk_widget_show_all (window); else gtk_widget_destroy (window); } /* * GtkImage */ static void pack_image (GtkWidget *box, const gchar *text, GtkWidget *image) { gtk_box_pack_start (GTK_BOX (box), gtk_label_new (text), FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (box), image, TRUE, TRUE, 0); } static void create_image (void) { static GtkWidget *window = NULL; if (window == NULL) { GtkWidget *vbox; GdkPixmap *pixmap; GdkBitmap *mask; window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_signal_connect (GTK_OBJECT (window), "destroy", GTK_SIGNAL_FUNC(gtk_widget_destroyed), &window); vbox = gtk_vbox_new (FALSE, 5); gtk_container_add (GTK_CONTAINER (window), vbox); pack_image (vbox, "Stock Warning Dialog", gtk_image_new_from_stock (GTK_STOCK_DIALOG_WARNING, GTK_ICON_SIZE_DIALOG)); pixmap = gdk_pixmap_colormap_create_from_xpm_d (NULL, gtk_widget_get_colormap (window), &mask, NULL, openfile); pack_image (vbox, "Pixmap", gtk_image_new_from_pixmap (pixmap, mask)); } if (!GTK_WIDGET_VISIBLE (window)) gtk_widget_show_all (window); else gtk_widget_destroy (window); } /* * Menu demo */ static GtkWidget* create_menu (gint depth, gint length, gboolean tearoff) { GtkWidget *menu; GtkWidget *menuitem; GtkWidget *image; GSList *group; char buf[32]; int i, j; if (depth < 1) return NULL; menu = gtk_menu_new (); group = NULL; if (tearoff) { menuitem = gtk_tearoff_menu_item_new (); gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem); gtk_widget_show (menuitem); } image = gtk_image_new_from_stock (GTK_STOCK_OPEN, GTK_ICON_SIZE_MENU); gtk_widget_show (image); menuitem = gtk_image_menu_item_new (image, "Image item"); gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem); gtk_widget_show (menuitem); for (i = 0, j = 1; i < length; 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_shell_append (GTK_MENU_SHELL (menu), menuitem); gtk_widget_show (menuitem); if (i == 3) gtk_widget_set_sensitive (menuitem, FALSE); if (i < 5) gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), create_menu (depth - 1, 5, TRUE)); } 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; GtkWidget *image; 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); accel_group = gtk_accel_group_new (); gtk_accel_group_attach (accel_group, GTK_OBJECT (window)); gtk_window_set_title (GTK_WINDOW (window), "menus"); gtk_container_set_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, 50, TRUE); 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, 5, TRUE)); gtk_menu_bar_append (GTK_MENU_BAR (menubar), menuitem); gtk_widget_show (menuitem); image = gtk_image_new_from_stock (GTK_STOCK_HELP, GTK_ICON_SIZE_MENU); gtk_widget_show (image); menuitem = gtk_image_menu_item_new (image, "Help"); gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), create_menu (4, 5, TRUE)); 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_set_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, 5, FALSE); gtk_menu_set_accel_group (GTK_MENU (menu), accel_group); menuitem = gtk_check_menu_item_new_with_label ("Accelerate Me"); gtk_menu_shell_append (GTK_MENU_SHELL (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_shell_append (GTK_MENU_SHELL (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_shell_append (GTK_MENU_SHELL (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_lock_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_set_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 gtk_ifactory_cb (gpointer callback_data, guint callback_action, GtkWidget *widget) { g_message ("ItemFactory: activated \"%s\"", gtk_item_factory_path_from_widget (widget)); } static GtkItemFactoryEntry menu_items[] = { { "/_File", NULL, 0, 0, "" }, { "/File/tearoff1", NULL, gtk_ifactory_cb, 0, "" }, { "/File/_New", "N", gtk_ifactory_cb, 0 }, { "/File/_Open", "O", gtk_ifactory_cb, 0 }, { "/File/_Save", "S", gtk_ifactory_cb, 0 }, { "/File/Save _As...", NULL, gtk_ifactory_cb, 0 }, { "/File/sep1", NULL, gtk_ifactory_cb, 0, "" }, { "/File/_Quit", "Q", gtk_ifactory_cb, 0 }, { "/_Preferences", NULL, 0, 0, "" }, { "/_Preferences/_Color", NULL, 0, 0, "" }, { "/_Preferences/Color/_Red", NULL, gtk_ifactory_cb, 0, "" }, { "/_Preferences/Color/_Green", NULL, gtk_ifactory_cb, 0, "/Preferences/Color/Red" }, { "/_Preferences/Color/_Blue", NULL, gtk_ifactory_cb, 0, "/Preferences/Color/Red" }, { "/_Preferences/_Shape", NULL, 0, 0, "" }, { "/_Preferences/Shape/_Square", NULL, gtk_ifactory_cb, 0, "" }, { "/_Preferences/Shape/_Rectangle", NULL, gtk_ifactory_cb, 0, "/Preferences/Shape/Square" }, { "/_Preferences/Shape/_Oval", NULL, gtk_ifactory_cb, 0, "/Preferences/Shape/Rectangle" }, { "/_Preferences/Shape/_Rectangle", NULL, gtk_ifactory_cb, 0, "/Preferences/Shape/Square" }, { "/_Preferences/Shape/_Oval", NULL, gtk_ifactory_cb, 0, "/Preferences/Shape/Rectangle" }, /* For testing deletion of menus */ { "/_Preferences/Should_NotAppear", NULL, 0, 0, "" }, { "/Preferences/ShouldNotAppear/SubItem1", NULL, gtk_ifactory_cb, 0 }, { "/Preferences/ShouldNotAppear/SubItem2", NULL, gtk_ifactory_cb, 0 }, { "/_Help", NULL, 0, 0, "" }, { "/Help/_About", NULL, gtk_ifactory_cb, 0 }, }; static int nmenu_items = sizeof (menu_items) / sizeof (menu_items[0]); static void create_item_factory (void) { static GtkWidget *window = NULL; if (!window) { GtkWidget *box1; GtkWidget *box2; GtkWidget *separator; GtkWidget *label; GtkWidget *button; GtkAccelGroup *accel_group; GtkItemFactory *item_factory; 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); accel_group = gtk_accel_group_new (); item_factory = gtk_item_factory_new (GTK_TYPE_MENU_BAR, "
", accel_group); gtk_object_set_data_full (GTK_OBJECT (window), "
", item_factory, (GtkDestroyNotify) gtk_object_unref); gtk_accel_group_attach (accel_group, GTK_OBJECT (window)); gtk_window_set_title (GTK_WINDOW (window), "Item Factory"); gtk_container_set_border_width (GTK_CONTAINER (window), 0); gtk_item_factory_create_items (item_factory, nmenu_items, menu_items, NULL); /* preselect /Preferences/Shape/Oval over the other radios */ gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (gtk_item_factory_get_item (item_factory, "/Preferences/Shape/Oval")), TRUE); box1 = gtk_vbox_new (FALSE, 0); gtk_container_add (GTK_CONTAINER (window), box1); gtk_box_pack_start (GTK_BOX (box1), gtk_item_factory_get_widget (item_factory, "
"), FALSE, FALSE, 0); label = gtk_label_new ("Type\n\nto start"); gtk_widget_set_usize (label, 200, 200); gtk_misc_set_alignment (GTK_MISC (label), 0.5, 0.5); gtk_box_pack_start (GTK_BOX (box1), label, TRUE, TRUE, 0); separator = gtk_hseparator_new (); gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0); box2 = gtk_vbox_new (FALSE, 10); gtk_container_set_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); gtk_item_factory_delete_item (item_factory, "/Preferences/ShouldNotAppear"); gtk_widget_show_all (window); } else gtk_widget_destroy (window); } /* create_modal_window */ static gboolean cmw_destroy_cb(GtkWidget *widget) { /* This is needed to get out of gtk_main */ gtk_main_quit (); return FALSE; } static void cmw_color (GtkWidget *widget, GtkWidget *parent) { GtkWidget *csd; csd=gtk_color_selection_dialog_new ("This is a modal color selection dialog"); /* Set as modal */ gtk_window_set_modal (GTK_WINDOW(csd),TRUE); /* And mark it as a transient dialog */ gtk_window_set_transient_for (GTK_WINDOW (csd), GTK_WINDOW (parent)); gtk_signal_connect (GTK_OBJECT(csd), "destroy", GTK_SIGNAL_FUNC(cmw_destroy_cb),NULL); gtk_signal_connect_object (GTK_OBJECT(GTK_COLOR_SELECTION_DIALOG(csd)->ok_button), "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy), GTK_OBJECT (csd)); gtk_signal_connect_object (GTK_OBJECT(GTK_COLOR_SELECTION_DIALOG(csd)->cancel_button), "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy), GTK_OBJECT (csd)); /* wait until destroy calls gtk_main_quit */ gtk_widget_show (csd); gtk_main (); } static void cmw_file (GtkWidget *widget, GtkWidget *parent) { GtkWidget *fs; fs = gtk_file_selection_new("This is a modal file selection dialog"); /* Set as modal */ gtk_window_set_modal (GTK_WINDOW(fs),TRUE); /* And mark it as a transient dialog */ gtk_window_set_transient_for (GTK_WINDOW (fs), GTK_WINDOW (parent)); gtk_signal_connect (GTK_OBJECT(fs), "destroy", GTK_SIGNAL_FUNC(cmw_destroy_cb),NULL); gtk_signal_connect_object (GTK_OBJECT(GTK_FILE_SELECTION(fs)->ok_button), "clicked",GTK_SIGNAL_FUNC(gtk_widget_destroy), GTK_OBJECT (fs)); gtk_signal_connect_object (GTK_OBJECT(GTK_FILE_SELECTION(fs)->cancel_button), "clicked",GTK_SIGNAL_FUNC(gtk_widget_destroy), GTK_OBJECT (fs)); /* wait until destroy calls gtk_main_quit */ gtk_widget_show (fs); gtk_main(); } static void create_modal_window (void) { GtkWidget *window = NULL; GtkWidget *box1,*box2; GtkWidget *frame1; GtkWidget *btnColor,*btnFile,*btnClose; /* Create modal window (Here you can use any window descendent )*/ window=gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_title (GTK_WINDOW(window),"This window is modal"); /* Set window as modal */ gtk_window_set_modal (GTK_WINDOW(window),TRUE); /* Create widgets */ box1 = gtk_vbox_new (FALSE,5); frame1 = gtk_frame_new ("Standard dialogs in modal form"); box2 = gtk_vbox_new (TRUE,5); btnColor = gtk_button_new_with_label ("Color"); btnFile = gtk_button_new_with_label ("File Selection"); btnClose = gtk_button_new_with_label ("Close"); /* Init widgets */ gtk_container_set_border_width (GTK_CONTAINER(box1),3); gtk_container_set_border_width (GTK_CONTAINER(box2),3); /* Pack widgets */ gtk_container_add (GTK_CONTAINER (window), box1); gtk_box_pack_start (GTK_BOX (box1), frame1, TRUE, TRUE, 4); gtk_container_add (GTK_CONTAINER (frame1), box2); gtk_box_pack_start (GTK_BOX (box2), btnColor, FALSE, FALSE, 4); gtk_box_pack_start (GTK_BOX (box2), btnFile, FALSE, FALSE, 4); gtk_box_pack_start (GTK_BOX (box1), gtk_hseparator_new (), FALSE, FALSE, 4); gtk_box_pack_start (GTK_BOX (box1), btnClose, FALSE, FALSE, 4); /* connect signals */ gtk_signal_connect_object (GTK_OBJECT (btnClose), "clicked", GTK_SIGNAL_FUNC (gtk_widget_destroy), GTK_OBJECT (window)); gtk_signal_connect (GTK_OBJECT (window), "destroy", GTK_SIGNAL_FUNC (cmw_destroy_cb),NULL); gtk_signal_connect (GTK_OBJECT (btnColor), "clicked", GTK_SIGNAL_FUNC (cmw_color),window); gtk_signal_connect (GTK_OBJECT (btnFile), "clicked", GTK_SIGNAL_FUNC (cmw_file),window); /* Show widgets */ gtk_widget_show_all (window); /* wait until dialog get destroyed */ gtk_main(); } /* * GtkMessageDialog */ static void make_message_dialog (GtkWidget **dialog, GtkMessageType type, GtkButtonsType buttons) { if (*dialog) { gtk_widget_destroy (*dialog); return; } *dialog = gtk_message_dialog_new (NULL, 0, type, buttons, "This is a message dialog; it can wrap long lines. This is a long line. La la la. Look this line is wrapped. Blah blah blah blah blah blah. (Note: testgtk has a nonstandard gtkrc that changes some of the message dialog icons.)"); gtk_signal_connect_object (GTK_OBJECT (*dialog), "response", GTK_SIGNAL_FUNC (gtk_widget_destroy), GTK_OBJECT (*dialog)); gtk_signal_connect (GTK_OBJECT (*dialog), "destroy", GTK_SIGNAL_FUNC (gtk_widget_destroyed), dialog); gtk_widget_show (*dialog); } static void create_message_dialog (void) { static GtkWidget *info = NULL; static GtkWidget *warning = NULL; static GtkWidget *error = NULL; static GtkWidget *question = NULL; make_message_dialog (&info, GTK_MESSAGE_INFO, GTK_BUTTONS_OK); make_message_dialog (&warning, GTK_MESSAGE_WARNING, GTK_BUTTONS_CLOSE); make_message_dialog (&error, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK_CANCEL); make_message_dialog (&question, GTK_MESSAGE_QUESTION, GTK_BUTTONS_YES_NO); } /* * GtkScrolledWindow */ static GtkWidget *sw_parent = NULL; static GtkWidget *sw_float_parent; static guint sw_destroyed_handler = 0; static gboolean scrolled_windows_delete_cb (GtkWidget *widget, GdkEventAny *event, GtkWidget *scrollwin) { gtk_widget_reparent (scrollwin, sw_parent); gtk_signal_disconnect (GTK_OBJECT (sw_parent), sw_destroyed_handler); sw_float_parent = NULL; sw_parent = NULL; sw_destroyed_handler = 0; return FALSE; } static void scrolled_windows_destroy_cb (GtkWidget *widget, GtkWidget *scrollwin) { gtk_widget_destroy (sw_float_parent); sw_float_parent = NULL; sw_parent = NULL; sw_destroyed_handler = 0; } static void scrolled_windows_remove (GtkWidget *widget, GtkWidget *scrollwin) { if (sw_parent) { gtk_widget_reparent (scrollwin, sw_parent); gtk_widget_destroy (sw_float_parent); gtk_signal_disconnect (GTK_OBJECT (sw_parent), sw_destroyed_handler); sw_float_parent = NULL; sw_parent = NULL; sw_destroyed_handler = 0; } else { sw_parent = scrollwin->parent; sw_float_parent = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_default_size (GTK_WINDOW (sw_float_parent), 200, 200); gtk_widget_reparent (scrollwin, sw_float_parent); gtk_widget_show (sw_float_parent); sw_destroyed_handler = gtk_signal_connect (GTK_OBJECT (sw_parent), "destroy", GTK_SIGNAL_FUNC (scrolled_windows_destroy_cb), scrollwin); gtk_signal_connect (GTK_OBJECT (sw_float_parent), "delete_event", GTK_SIGNAL_FUNC (scrolled_windows_delete_cb), scrollwin); } } 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_set_border_width (GTK_CONTAINER (window), 0); scrolled_window = gtk_scrolled_window_new (NULL, NULL); gtk_container_set_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_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (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 ("Reparent Out"); gtk_signal_connect (GTK_OBJECT (button), "clicked", GTK_SIGNAL_FUNC(scrolled_windows_remove), 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); gtk_window_set_default_size (GTK_WINDOW (window), 300, 300); } if (!GTK_WIDGET_VISIBLE (window)) gtk_widget_show (window); else gtk_widget_destroy (window); } /* * GtkEntry */ static void entry_toggle_frame (GtkWidget *checkbutton, GtkWidget *entry) { gtk_entry_set_has_frame (GTK_ENTRY(entry), GTK_TOGGLE_BUTTON(checkbutton)->active); } 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_sensitive (GtkWidget *checkbutton, GtkWidget *entry) { gtk_widget_set_sensitive (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 entry_toggle_invisible_char (GtkWidget *checkbutton, GtkWidget *entry) { if (GTK_TOGGLE_BUTTON (checkbutton)->active) gtk_entry_set_invisible_char (GTK_ENTRY (entry), 0); else gtk_entry_set_invisible_char (GTK_ENTRY (entry), '*'); } static void create_entry (void) { static GtkWidget *window = NULL; GtkWidget *box1; GtkWidget *box2; GtkWidget *editable_check; GtkWidget *sensitive_check; GtkWidget *invisible_char_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_set_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_set_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, 5); 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_active(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_active(GTK_TOGGLE_BUTTON(editable_check), TRUE); gtk_widget_show (editable_check); sensitive_check = gtk_check_button_new_with_label("Sensitive"); gtk_box_pack_start (GTK_BOX (box2), sensitive_check, FALSE, TRUE, 0); gtk_signal_connect (GTK_OBJECT(sensitive_check), "toggled", GTK_SIGNAL_FUNC(entry_toggle_sensitive), entry); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(sensitive_check), TRUE); gtk_widget_show (sensitive_check); invisible_char_check = gtk_check_button_new_with_label("invisible_char = 0"); gtk_box_pack_start (GTK_BOX (box2), invisible_char_check, FALSE, TRUE, 0); gtk_signal_connect (GTK_OBJECT(invisible_char_check), "toggled", GTK_SIGNAL_FUNC(entry_toggle_invisible_char), entry); gtk_widget_show (invisible_char_check); editable_check = gtk_check_button_new_with_label("Has Frame"); 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_frame), entry); gtk_toggle_button_set_active(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_set_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_text (label, buf); } static gint spin_button_time_output_func (GtkSpinButton *spin_button) { static gchar buf[6]; gfloat hours; gfloat minutes; hours = spin_button->adjustment->value / 60.0; minutes = (fabs(floor (hours) - hours) < 1e-5) ? 0.0 : 30; sprintf (buf, "%02.0f:%02.0f", floor (hours), minutes); if (strcmp (buf, gtk_entry_get_text (GTK_ENTRY (spin_button)))) gtk_entry_set_text (GTK_ENTRY (spin_button), buf); return TRUE; } static gint spin_button_month_input_func (GtkSpinButton *spin_button, gfloat *new_val) { gint i; static gchar *month[12] = { "January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December" }; gchar *tmp1, *tmp2; gboolean found = FALSE; for (i = 1; i <= 12; i++) { tmp1 = g_strdup (month[i-1]); g_strup (tmp1); tmp2 = g_strdup (gtk_entry_get_text (GTK_ENTRY (spin_button))); g_strup (tmp2); if (strstr (tmp1, tmp2) == tmp1) found = TRUE; g_free (tmp1); g_free (tmp2); if (found) break; } if (!found) { *new_val = 0.0; return GTK_INPUT_ERROR; } *new_val = (gfloat) i; return TRUE; } static gint spin_button_month_output_func (GtkSpinButton *spin_button) { gint i; static gchar *month[12] = { "January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December" }; for (i = 1; i <= 12; i++) if (fabs (spin_button->adjustment->value - (double)i) < 1e-5) { if (strcmp (month[i-1], gtk_entry_get_text (GTK_ENTRY (spin_button)))) gtk_entry_set_text (GTK_ENTRY (spin_button), month[i-1]); } return TRUE; } static gint spin_button_hex_input_func (GtkSpinButton *spin_button, gfloat *new_val) { gchar *buf; gchar *err; gfloat res; buf = gtk_entry_get_text (GTK_ENTRY (spin_button)); res = (gfloat)(strtol(buf, &err, 16)); *new_val = res; if (*err) return GTK_INPUT_ERROR; else return TRUE; } static gint spin_button_hex_output_func (GtkSpinButton *spin_button) { static gchar buf[7]; gint val; val = (gint) spin_button->adjustment->value; if (fabs (val) < 1e-5) sprintf (buf, "0x00"); else sprintf (buf, "0x%.2X", val); if (strcmp (buf, gtk_entry_get_text (GTK_ENTRY (spin_button)))) gtk_entry_set_text (GTK_ENTRY (spin_button), buf); return TRUE; } 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_set_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_set_border_width (GTK_CONTAINER (vbox), 5); gtk_container_add (GTK_CONTAINER (frame), vbox); /* Time, month, hex 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 ("Time :"); 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, 1410, 30, 60, 0); spinner = gtk_spin_button_new (adj, 0, 0); gtk_editable_set_editable (GTK_EDITABLE (spinner), FALSE); gtk_signal_connect (GTK_OBJECT (spinner), "output", GTK_SIGNAL_FUNC (spin_button_time_output_func), NULL); gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spinner), TRUE); gtk_widget_set_usize (spinner, 55, -1); 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_update_policy (GTK_SPIN_BUTTON (spinner), GTK_UPDATE_IF_VALID); gtk_signal_connect (GTK_OBJECT (spinner), "input", GTK_SIGNAL_FUNC (spin_button_month_input_func), NULL); gtk_signal_connect (GTK_OBJECT (spinner), "output", GTK_SIGNAL_FUNC (spin_button_month_output_func), NULL); gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spinner), TRUE); gtk_widget_set_usize (spinner, 85, -1); 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 ("Hex :"); 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, 255, 1, 16, 0); spinner = gtk_spin_button_new (adj, 0, 0); gtk_editable_set_editable (GTK_EDITABLE (spinner), TRUE); gtk_signal_connect (GTK_OBJECT (spinner), "input", GTK_SIGNAL_FUNC (spin_button_hex_input_func), NULL); gtk_signal_connect (GTK_OBJECT (spinner), "output", GTK_SIGNAL_FUNC (spin_button_hex_output_func), NULL); gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spinner), TRUE); 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_set_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_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_active (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_active (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_text (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; GtkWidget *label; GtkEnumValue *vals; c = CLAMP (gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (spinner)), 0, 152); c &= 0xfe; label = gtk_object_get_user_data (GTK_OBJECT (spinner)); vals = gtk_type_enum_get_values (GTK_TYPE_GDK_CURSOR_TYPE); while (vals && vals->value != c) vals++; if (vals) gtk_label_set_text (GTK_LABEL (label), vals->value_nick); else gtk_label_set_text (GTK_LABEL (label), ""); cursor = gdk_cursor_new (c); gdk_window_set_cursor (widget->window, cursor); gdk_cursor_unref (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_set_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_set_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); label = gtk_widget_new (GTK_TYPE_LABEL, "visible", TRUE, "label", "XXX", "parent", vbox, NULL); gtk_container_child_set (GTK_CONTAINER (vbox), label, "expand", FALSE, NULL); gtk_object_set_user_data (GTK_OBJECT (spinner), label); 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_set_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; GtkContainer *container; container = GTK_CONTAINER (list); sprintf (buffer, "added item %d", i++); list_item = gtk_list_item_new_with_label (buffer); gtk_widget_show (list_item); gtk_container_add (container, list_item); } static void list_remove (GtkWidget *widget, GtkList *list) { GList *clear_list = NULL; GList *sel_row = NULL; GList *work = NULL; if (list->selection_mode == GTK_SELECTION_EXTENDED) { GtkWidget *item; item = GTK_CONTAINER (list)->focus_child; if (!item && list->selection) item = list->selection->data; if (item) { work = g_list_find (list->children, item); for (sel_row = work; sel_row; sel_row = sel_row->next) if (GTK_WIDGET (sel_row->data)->state != GTK_STATE_SELECTED) break; if (!sel_row) { for (sel_row = work; sel_row; sel_row = sel_row->prev) if (GTK_WIDGET (sel_row->data)->state != GTK_STATE_SELECTED) break; } } } for (work = list->selection; work; work = work->next) clear_list = g_list_prepend (clear_list, work->data); clear_list = g_list_reverse (clear_list); gtk_list_remove_items (GTK_LIST (list), clear_list); g_list_free (clear_list); if (list->selection_mode == GTK_SELECTION_EXTENDED && sel_row) gtk_list_select_child (list, GTK_WIDGET(sel_row->data)); } static void list_clear (GtkWidget *widget, GtkWidget *list) { gtk_list_clear_items (GTK_LIST (list), 0, -1); } #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++; \ }\ } static GtkWidget *list_omenu; static void list_toggle_sel_mode (GtkWidget *widget, GtkList *list) { gint i; if (!GTK_WIDGET_MAPPED (widget)) return; RADIOMENUTOGGLED ((GtkRadioMenuItem *) (((GtkOptionMenu *)list_omenu)->menu_item), i); gtk_list_set_selection_mode (list, (GtkSelectionMode) (3-i)); } static void create_list (void) { static GtkWidget *window = NULL; static OptionMenuItem items[] = { { "Single", list_toggle_sel_mode }, { "Browse", list_toggle_sel_mode }, { "Multiple", list_toggle_sel_mode }, { "Extended", list_toggle_sel_mode } }; if (!window) { GtkWidget *cbox; GtkWidget *vbox; GtkWidget *hbox; GtkWidget *label; GtkWidget *scrolled_win; GtkWidget *list; GtkWidget *button; GtkWidget *separator; FILE *infile; 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_set_border_width (GTK_CONTAINER (window), 0); vbox = gtk_vbox_new (FALSE, 0); gtk_container_add (GTK_CONTAINER (window), vbox); scrolled_win = gtk_scrolled_window_new (NULL, NULL); gtk_container_set_border_width (GTK_CONTAINER (scrolled_win), 5); gtk_widget_set_usize (scrolled_win, -1, 300); gtk_box_pack_start (GTK_BOX (vbox), scrolled_win, TRUE, TRUE, 0); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); list = gtk_list_new (); gtk_list_set_selection_mode (GTK_LIST (list), GTK_SELECTION_EXTENDED); gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (scrolled_win), list); gtk_container_set_focus_vadjustment (GTK_CONTAINER (list), gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (scrolled_win))); gtk_container_set_focus_hadjustment (GTK_CONTAINER (list), gtk_scrolled_window_get_hadjustment (GTK_SCROLLED_WINDOW (scrolled_win))); if ((infile = fopen("gtkenums.h", "r"))) { char buffer[256]; char *pos; GtkWidget *item; while (fgets (buffer, 256, infile)) { if ((pos = strchr (buffer, '\n'))) *pos = 0; item = gtk_list_item_new_with_label (buffer); gtk_container_add (GTK_CONTAINER (list), item); } fclose (infile); } hbox = gtk_hbox_new (TRUE, 5); gtk_container_set_border_width (GTK_CONTAINER (hbox), 5); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0); button = gtk_button_new_with_label ("Insert Row"); gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0); gtk_signal_connect (GTK_OBJECT (button), "clicked", GTK_SIGNAL_FUNC (list_add), list); button = gtk_button_new_with_label ("Clear List"); gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0); gtk_signal_connect (GTK_OBJECT (button), "clicked", GTK_SIGNAL_FUNC (list_clear), list); button = gtk_button_new_with_label ("Remove Selection"); gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0); gtk_signal_connect (GTK_OBJECT (button), "clicked", GTK_SIGNAL_FUNC (list_remove), list); cbox = gtk_hbox_new (FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), cbox, FALSE, TRUE, 0); hbox = gtk_hbox_new (FALSE, 5); gtk_container_set_border_width (GTK_CONTAINER (hbox), 5); gtk_box_pack_start (GTK_BOX (cbox), hbox, TRUE, FALSE, 0); label = gtk_label_new ("Selection Mode :"); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0); list_omenu = build_option_menu (items, 4, 3, list); gtk_box_pack_start (GTK_BOX (hbox), list_omenu, FALSE, TRUE, 0); separator = gtk_hseparator_new (); gtk_box_pack_start (GTK_BOX (vbox), separator, FALSE, TRUE, 0); cbox = gtk_hbox_new (FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), cbox, FALSE, TRUE, 0); button = gtk_button_new_with_label ("close"); gtk_container_set_border_width (GTK_CONTAINER (button), 10); gtk_box_pack_start (GTK_BOX (cbox), button, TRUE, 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); } if (!GTK_WIDGET_VISIBLE (window)) gtk_widget_show_all (window); else gtk_widget_destroy (window); } /* * GtkCList */ 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 ", " "}; static char * gtk_mini_xpm[] = { "15 20 17 1", " c None", ". c #14121F", "+ c #278828", "@ c #9B3334", "# c #284C72", "$ c #24692A", "% c #69282E", "& c #37C539", "* c #1D2F4D", "= c #6D7076", "- c #7D8482", "; c #E24A49", "> c #515357", ", c #9B9C9B", "' c #2FA232", ") c #3CE23D", "! c #3B6CCB", " ", " ***> ", " >.*!!!* ", " ***....#*= ", " *!*.!!!**!!# ", " .!!#*!#*!!!!# ", " @%#!.##.*!!$& ", " @;%*!*.#!#')) ", " @;;@%!!*$&)'' ", " @%.%@%$'&)$+' ", " @;...@$'*'*)+ ", " @;%..@$+*.')$ ", " @;%%;;$+..$)# ", " @;%%;@$$$'.$# ", " %;@@;;$$+))&* ", " %;;;@+$&)&* ", " %;;@'))+> ", " %;@'&# ", " >%$$ ", " >= "}; #define TESTGTK_CLIST_COLUMNS 12 static gint clist_rows = 0; static GtkWidget *clist_omenu; 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; GtkCList *clist; clist = GTK_CLIST (data); pixmap = gdk_pixmap_create_from_xpm_d (clist->clist_window, &mask, >K_WIDGET (data)->style->white, gtk_mini_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], "CListRow %d", rand() % 10000); row = gtk_clist_append (clist, texts); gtk_clist_set_pixtext (clist, row, 3, "gtk+", 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], "CListRow %d", rand() % 10000); 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 clist_remove_selection (GtkWidget *widget, GtkCList *clist) { gtk_clist_freeze (clist); while (clist->selection) { gint row; clist_rows--; row = GPOINTER_TO_INT (clist->selection->data); gtk_clist_remove (clist, row); if (clist->selection_mode == GTK_SELECTION_BROWSE) break; } if (clist->selection_mode == GTK_SELECTION_EXTENDED && !clist->selection && clist->focus_row >= 0) gtk_clist_select_row (clist, clist->focus_row, -1); gtk_clist_thaw (clist); } void toggle_title_buttons (GtkWidget *widget, GtkCList *clist) { if (GTK_TOGGLE_BUTTON (widget)->active) gtk_clist_column_titles_show (clist); else gtk_clist_column_titles_hide (clist); } void toggle_reorderable (GtkWidget *widget, GtkCList *clist) { gtk_clist_set_reorderable (clist, GTK_TOGGLE_BUTTON (widget)->active); } static void insert_row_clist (GtkWidget *widget, gpointer data) { static char *text[] = { "This", "is an", "inserted", "row.", "This", "is an", "inserted", "row.", "This", "is an", "inserted", "row." }; static GtkStyle *style1 = NULL; static GtkStyle *style2 = NULL; static GtkStyle *style3 = NULL; gint row; if (GTK_CLIST (data)->focus_row >= 0) row = gtk_clist_insert (GTK_CLIST (data), GTK_CLIST (data)->focus_row, text); else row = gtk_clist_prepend (GTK_CLIST (data), text); if (!style1) { GdkColor col1; GdkColor col2; col1.red = 0; col1.green = 56000; col1.blue = 0; col2.red = 32000; col2.green = 0; col2.blue = 56000; style1 = gtk_style_copy (GTK_WIDGET (data)->style); style1->base[GTK_STATE_NORMAL] = col1; style1->base[GTK_STATE_SELECTED] = col2; style2 = gtk_style_copy (GTK_WIDGET (data)->style); style2->fg[GTK_STATE_NORMAL] = col1; style2->fg[GTK_STATE_SELECTED] = col2; style3 = gtk_style_copy (GTK_WIDGET (data)->style); style3->fg[GTK_STATE_NORMAL] = col1; style3->base[GTK_STATE_NORMAL] = col2; pango_font_description_free (style3->font_desc); style3->font_desc = pango_font_description_from_string ("courier 12"); } gtk_clist_set_cell_style (GTK_CLIST (data), row, 3, style1); gtk_clist_set_cell_style (GTK_CLIST (data), row, 4, style2); gtk_clist_set_cell_style (GTK_CLIST (data), row, 0, style3); 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 undo_selection (GtkWidget *button, GtkCList *clist) { gtk_clist_undo_selection (clist); } static void clist_toggle_sel_mode (GtkWidget *widget, GtkCList *clist) { gint i; if (!GTK_WIDGET_MAPPED (widget)) return; RADIOMENUTOGGLED ((GtkRadioMenuItem *) (((GtkOptionMenu *)clist_omenu)->menu_item), i); gtk_clist_set_selection_mode (clist, (GtkSelectionMode) (3-i)); } static void clist_click_column (GtkCList *clist, gint column, gpointer data) { if (column == 4) gtk_clist_set_column_visibility (clist, column, FALSE); else if (column == clist->sort_column) { if (clist->sort_type == GTK_SORT_ASCENDING) clist->sort_type = GTK_SORT_DESCENDING; else clist->sort_type = GTK_SORT_ASCENDING; } else gtk_clist_set_sort_column (clist, column); gtk_clist_sort (clist); } static void create_clist (void) { gint i; static GtkWidget *window = NULL; static char *titles[] = { "auto resize", "not resizeable", "max width 100", "min width 50", "hide column", "Title 5", "Title 6", "Title 7", "Title 8", "Title 9", "Title 10", "Title 11" }; static OptionMenuItem items[] = { { "Single", clist_toggle_sel_mode }, { "Browse", clist_toggle_sel_mode }, { "Multiple", clist_toggle_sel_mode }, { "Extended", clist_toggle_sel_mode } }; char text[TESTGTK_CLIST_COLUMNS][50]; char *texts[TESTGTK_CLIST_COLUMNS]; GtkWidget *vbox; GtkWidget *hbox; GtkWidget *clist; GtkWidget *button; GtkWidget *separator; GtkWidget *scrolled_win; GtkWidget *check; GtkWidget *undo_button; GtkWidget *label; GtkStyle *style; GdkColor col1; GdkColor col2; if (!window) { clist_rows = 0; 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_set_border_width (GTK_CONTAINER (window), 0); vbox = gtk_vbox_new (FALSE, 0); gtk_container_add (GTK_CONTAINER (window), vbox); scrolled_win = gtk_scrolled_window_new (NULL, NULL); gtk_container_set_border_width (GTK_CONTAINER (scrolled_win), 5); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); /* 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); gtk_container_add (GTK_CONTAINER (scrolled_win), clist); gtk_signal_connect (GTK_OBJECT (clist), "click_column", (GtkSignalFunc) clist_click_column, NULL); /* control buttons */ hbox = gtk_hbox_new (FALSE, 5); gtk_container_set_border_width (GTK_CONTAINER (hbox), 5); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); button = gtk_button_new_with_label ("Insert Row"); gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0); gtk_signal_connect (GTK_OBJECT (button), "clicked", (GtkSignalFunc) insert_row_clist, (gpointer) clist); button = gtk_button_new_with_label ("Add 1,000 Rows With Pixmaps"); gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0); gtk_signal_connect (GTK_OBJECT (button), "clicked", (GtkSignalFunc) add1000_clist, (gpointer) clist); button = gtk_button_new_with_label ("Add 10,000 Rows"); gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0); gtk_signal_connect (GTK_OBJECT (button), "clicked", (GtkSignalFunc) add10000_clist, (gpointer) clist); /* second layer of buttons */ hbox = gtk_hbox_new (FALSE, 5); gtk_container_set_border_width (GTK_CONTAINER (hbox), 5); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); button = gtk_button_new_with_label ("Clear List"); gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0); gtk_signal_connect (GTK_OBJECT (button), "clicked", (GtkSignalFunc) clear_clist, (gpointer) clist); button = gtk_button_new_with_label ("Remove Selection"); gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0); gtk_signal_connect (GTK_OBJECT (button), "clicked", (GtkSignalFunc) clist_remove_selection, (gpointer) clist); undo_button = gtk_button_new_with_label ("Undo Selection"); gtk_box_pack_start (GTK_BOX (hbox), undo_button, TRUE, TRUE, 0); gtk_signal_connect (GTK_OBJECT (undo_button), "clicked", (GtkSignalFunc) undo_selection, (gpointer) clist); button = gtk_button_new_with_label ("Warning Test"); gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0); gtk_signal_connect (GTK_OBJECT (button), "clicked", (GtkSignalFunc) clist_warning_test,(gpointer) clist); /* third layer of buttons */ hbox = gtk_hbox_new (FALSE, 5); gtk_container_set_border_width (GTK_CONTAINER (hbox), 5); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); check = gtk_check_button_new_with_label ("Show Title Buttons"); gtk_box_pack_start (GTK_BOX (hbox), check, FALSE, TRUE, 0); gtk_signal_connect (GTK_OBJECT (check), "clicked", GTK_SIGNAL_FUNC (toggle_title_buttons), clist); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check), TRUE); check = gtk_check_button_new_with_label ("Reorderable"); gtk_box_pack_start (GTK_BOX (hbox), check, FALSE, TRUE, 0); gtk_signal_connect (GTK_OBJECT (check), "clicked", GTK_SIGNAL_FUNC (toggle_reorderable), clist); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check), TRUE); label = gtk_label_new ("Selection Mode :"); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0); clist_omenu = build_option_menu (items, 4, 3, clist); gtk_box_pack_start (GTK_BOX (hbox), clist_omenu, FALSE, TRUE, 0); /* * the rest of the clist configuration */ gtk_box_pack_start (GTK_BOX (vbox), scrolled_win, TRUE, TRUE, 0); gtk_clist_set_row_height (GTK_CLIST (clist), 18); gtk_widget_set_usize (clist, -1, 300); for (i = 1; i < TESTGTK_CLIST_COLUMNS; i++) gtk_clist_set_column_width (GTK_CLIST (clist), i, 80); gtk_clist_set_column_auto_resize (GTK_CLIST (clist), 0, TRUE); gtk_clist_set_column_resizeable (GTK_CLIST (clist), 1, FALSE); gtk_clist_set_column_max_width (GTK_CLIST (clist), 2, 100); gtk_clist_set_column_min_width (GTK_CLIST (clist), 3, 50); gtk_clist_set_selection_mode (GTK_CLIST (clist), GTK_SELECTION_EXTENDED); 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"); col1.red = 56000; col1.green = 0; col1.blue = 0; col2.red = 0; col2.green = 56000; col2.blue = 32000; style = gtk_style_new (); style->fg[GTK_STATE_NORMAL] = col1; style->base[GTK_STATE_NORMAL] = col2; style->font_desc->size = 14 * PANGO_SCALE; style->font_desc->weight = PANGO_WEIGHT_BOLD; for (i = 0; i < 10; i++) { sprintf (text[0], "CListRow %d", clist_rows++); gtk_clist_append (GTK_CLIST (clist), texts); switch (i % 4) { case 2: gtk_clist_set_row_style (GTK_CLIST (clist), i, style); break; default: gtk_clist_set_cell_style (GTK_CLIST (clist), i, i % 4, style); break; } } gtk_style_unref (style); separator = gtk_hseparator_new (); gtk_box_pack_start (GTK_BOX (vbox), separator, FALSE, TRUE, 0); hbox = gtk_hbox_new (FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0); button = gtk_button_new_with_label ("close"); gtk_container_set_border_width (GTK_CONTAINER (button), 10); gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, 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); } if (!GTK_WIDGET_VISIBLE (window)) gtk_widget_show_all (window); else { clist_rows = 0; gtk_widget_destroy (window); } } /* * GtkCTree */ 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 *omenu1; static GtkWidget *omenu2; static GtkWidget *omenu3; static GtkWidget *omenu4; static GtkWidget *spin1; static GtkWidget *spin2; static GtkWidget *spin3; static gint line_style; void after_press (GtkCTree *ctree, gpointer data) { char buf[80]; sprintf (buf, "%d", g_list_length (GTK_CLIST (ctree)->selection)); gtk_label_set_text (GTK_LABEL (sel_label), buf); sprintf (buf, "%d", g_list_length (GTK_CLIST (ctree)->row_list)); gtk_label_set_text (GTK_LABEL (vis_label), buf); sprintf (buf, "%d", books); gtk_label_set_text (GTK_LABEL (book_label), buf); sprintf (buf, "%d", pages); gtk_label_set_text (GTK_LABEL (page_label), buf); } void after_move (GtkCTree *ctree, GtkCTreeNode *child, GtkCTreeNode *parent, GtkCTreeNode *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"); } void count_items (GtkCTree *ctree, GtkCTreeNode *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 change_style (GtkWidget *widget, GtkCTree *ctree) { static GtkStyle *style1 = NULL; static GtkStyle *style2 = NULL; GtkCTreeNode *node; GdkColor col1; GdkColor col2; if (GTK_CLIST (ctree)->focus_row >= 0) node = GTK_CTREE_NODE (g_list_nth (GTK_CLIST (ctree)->row_list,GTK_CLIST (ctree)->focus_row)); else node = GTK_CTREE_NODE (GTK_CLIST (ctree)->row_list); if (!node) return; if (!style1) { col1.red = 0; col1.green = 56000; col1.blue = 0; col2.red = 32000; col2.green = 0; col2.blue = 56000; style1 = gtk_style_new (); style1->base[GTK_STATE_NORMAL] = col1; style1->fg[GTK_STATE_SELECTED] = col2; style2 = gtk_style_new (); style2->base[GTK_STATE_SELECTED] = col2; style2->fg[GTK_STATE_NORMAL] = col1; style2->base[GTK_STATE_NORMAL] = col2; pango_font_description_free (style2->font_desc); style2->font_desc = pango_font_description_from_string ("courier 30"); } gtk_ctree_node_set_cell_style (ctree, node, 1, style1); gtk_ctree_node_set_cell_style (ctree, node, 0, style2); if (GTK_CTREE_ROW (node)->children) gtk_ctree_node_set_row_style (ctree, GTK_CTREE_ROW (node)->children, style2); } void unselect_all (GtkWidget *widget, GtkCTree *ctree) { gtk_ctree_unselect_recursive (ctree, NULL); after_press (ctree, NULL); } void remove_selection (GtkWidget *widget, GtkCTree *ctree) { GtkCList *clist; GtkCTreeNode *node; clist = GTK_CLIST (ctree); gtk_clist_freeze (clist); while (clist->selection) { node = clist->selection->data; if (GTK_CTREE_ROW (node)->is_leaf) pages--; else gtk_ctree_post_recursive (ctree, node, (GtkCTreeFunc) count_items, NULL); gtk_ctree_remove_node (ctree, node); if (clist->selection_mode == GTK_SELECTION_BROWSE) break; } if (clist->selection_mode == GTK_SELECTION_EXTENDED && !clist->selection && clist->focus_row >= 0) { node = gtk_ctree_node_nth (ctree, clist->focus_row); if (node) gtk_ctree_select (ctree, node); } gtk_clist_thaw (clist); after_press (ctree, NULL); } struct _ExportStruct { gchar *tree; gchar *info; gboolean is_leaf; }; typedef struct _ExportStruct ExportStruct; gboolean gnode2ctree (GtkCTree *ctree, guint depth, GNode *gnode, GtkCTreeNode *cnode, gpointer data) { ExportStruct *es; GdkPixmap *pixmap_closed; GdkBitmap *mask_closed; GdkPixmap *pixmap_opened; GdkBitmap *mask_opened; if (!cnode || !gnode || (!(es = gnode->data))) return FALSE; if (es->is_leaf) { pixmap_closed = pixmap3; mask_closed = mask3; pixmap_opened = NULL; mask_opened = NULL; } else { pixmap_closed = pixmap1; mask_closed = mask1; pixmap_opened = pixmap2; mask_opened = mask2; } gtk_ctree_set_node_info (ctree, cnode, es->tree, 2, pixmap_closed, mask_closed, pixmap_opened, mask_opened, es->is_leaf, (depth < 3)); gtk_ctree_node_set_text (ctree, cnode, 1, es->info); g_free (es); gnode->data = NULL; return TRUE; } gboolean ctree2gnode (GtkCTree *ctree, guint depth, GNode *gnode, GtkCTreeNode *cnode, gpointer data) { ExportStruct *es; if (!cnode || !gnode) return FALSE; es = g_new (ExportStruct, 1); gnode->data = es; es->is_leaf = GTK_CTREE_ROW (cnode)->is_leaf; es->tree = GTK_CELL_PIXTEXT (GTK_CTREE_ROW (cnode)->row.cell[0])->text; es->info = GTK_CELL_PIXTEXT (GTK_CTREE_ROW (cnode)->row.cell[1])->text; return TRUE; } void export_ctree (GtkWidget *widget, GtkCTree *ctree) { char *title[] = { "Tree" , "Info" }; static GtkWidget *export_window = NULL; static GtkCTree *export_ctree; GtkWidget *vbox; GtkWidget *scrolled_win; GtkWidget *button; GtkWidget *sep; GNode *gnode; GtkCTreeNode *node; if (!export_window) { export_window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_signal_connect (GTK_OBJECT (export_window), "destroy", GTK_SIGNAL_FUNC (gtk_widget_destroyed), &export_window); gtk_window_set_title (GTK_WINDOW (export_window), "exported ctree"); gtk_container_set_border_width (GTK_CONTAINER (export_window), 5); vbox = gtk_vbox_new (FALSE, 0); gtk_container_add (GTK_CONTAINER (export_window), vbox); button = gtk_button_new_with_label ("Close"); gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, TRUE, 0); gtk_signal_connect_object (GTK_OBJECT (button), "clicked", (GtkSignalFunc) gtk_widget_destroy, GTK_OBJECT(export_window)); sep = gtk_hseparator_new (); gtk_box_pack_end (GTK_BOX (vbox), sep, FALSE, TRUE, 10); export_ctree = GTK_CTREE (gtk_ctree_new_with_titles (2, 0, title)); gtk_ctree_set_line_style (export_ctree, GTK_CTREE_LINES_DOTTED); scrolled_win = gtk_scrolled_window_new (NULL, NULL); gtk_container_add (GTK_CONTAINER (scrolled_win), GTK_WIDGET (export_ctree)); 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_clist_set_selection_mode (GTK_CLIST (export_ctree), GTK_SELECTION_EXTENDED); gtk_clist_set_column_width (GTK_CLIST (export_ctree), 0, 200); gtk_clist_set_column_width (GTK_CLIST (export_ctree), 1, 200); gtk_widget_set_usize (GTK_WIDGET (export_ctree), 300, 200); } if (!GTK_WIDGET_VISIBLE (export_window)) gtk_widget_show_all (export_window); gtk_clist_clear (GTK_CLIST (export_ctree)); node = GTK_CTREE_NODE (g_list_nth (GTK_CLIST (ctree)->row_list, GTK_CLIST (ctree)->focus_row)); if (!node) return; gnode = gtk_ctree_export_to_gnode (ctree, NULL, NULL, node, ctree2gnode, NULL); if (gnode) { gtk_ctree_insert_gnode (export_ctree, NULL, NULL, gnode, gnode2ctree, NULL); g_node_destroy (gnode); } } void change_indent (GtkWidget *widget, GtkCTree *ctree) { gtk_ctree_set_indent (ctree, GTK_ADJUSTMENT (widget)->value); } void change_spacing (GtkWidget *widget, GtkCTree *ctree) { gtk_ctree_set_spacing (ctree, GTK_ADJUSTMENT (widget)->value); } void change_row_height (GtkWidget *widget, GtkCList *clist) { gtk_clist_set_row_height (clist, GTK_ADJUSTMENT (widget)->value); } void set_background (GtkCTree *ctree, GtkCTreeNode *node, gpointer data) { GtkStyle *style = NULL; if (!node) return; if (ctree->line_style != GTK_CTREE_LINES_TABBED) { if (!GTK_CTREE_ROW (node)->is_leaf) style = GTK_CTREE_ROW (node)->row.data; else if (GTK_CTREE_ROW (node)->parent) style = GTK_CTREE_ROW (GTK_CTREE_ROW (node)->parent)->row.data; } gtk_ctree_node_set_row_style (ctree, node, style); } void ctree_toggle_line_style (GtkWidget *widget, GtkCTree *ctree) { gint i; if (!GTK_WIDGET_MAPPED (widget)) return; RADIOMENUTOGGLED ((GtkRadioMenuItem *) (((GtkOptionMenu *)omenu1)->menu_item), i); if ((ctree->line_style == GTK_CTREE_LINES_TABBED && ((GtkCTreeLineStyle) (3 - i)) != GTK_CTREE_LINES_TABBED) || (ctree->line_style != GTK_CTREE_LINES_TABBED && ((GtkCTreeLineStyle) (3 - i)) == GTK_CTREE_LINES_TABBED)) gtk_ctree_pre_recursive (ctree, NULL, set_background, NULL); gtk_ctree_set_line_style (ctree, 3 - i); line_style = 3 - i; } void ctree_toggle_expander_style (GtkWidget *widget, GtkCTree *ctree) { gint i; if (!GTK_WIDGET_MAPPED (widget)) return; RADIOMENUTOGGLED ((GtkRadioMenuItem *) (((GtkOptionMenu *)omenu2)->menu_item), i); gtk_ctree_set_expander_style (ctree, (GtkCTreeExpanderStyle) (3 - i)); } void ctree_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), ctree->tree_column, (GtkJustification) (1 - i)); } void ctree_toggle_sel_mode (GtkWidget *widget, GtkCTree *ctree) { gint i; if (!GTK_WIDGET_MAPPED (widget)) return; RADIOMENUTOGGLED ((GtkRadioMenuItem *) (((GtkOptionMenu *)omenu4)->menu_item), i); gtk_clist_set_selection_mode (GTK_CLIST (ctree), (GtkSelectionMode) (3 - i)); after_press (ctree, NULL); } void build_recursive (GtkCTree *ctree, gint cur_depth, gint depth, gint num_books, gint num_pages, GtkCTreeNode *parent) { gchar *text[2]; gchar buf1[60]; gchar buf2[60]; GtkCTreeNode *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) rand() % 100); sprintf (buf2, "Item %d-%d", cur_depth, i); sibling = gtk_ctree_insert_node (ctree, parent, sibling, text, 5, pixmap3, mask3, NULL, NULL, TRUE, FALSE); if (parent && ctree->line_style == GTK_CTREE_LINES_TABBED) gtk_ctree_node_set_row_style (ctree, sibling, GTK_CTREE_ROW (parent)->row.style); } if (cur_depth == depth) return; for (i = num_books; i > 0; i--) { GtkStyle *style; books++; sprintf (buf1, "Book %02d", (gint) rand() % 100); sprintf (buf2, "Item %d-%d", cur_depth, i); sibling = gtk_ctree_insert_node (ctree, parent, sibling, text, 5, pixmap1, mask1, pixmap2, mask2, FALSE, FALSE); style = gtk_style_new (); switch (cur_depth % 3) { case 0: style->base[GTK_STATE_NORMAL].red = 10000 * (cur_depth % 6); style->base[GTK_STATE_NORMAL].green = 0; style->base[GTK_STATE_NORMAL].blue = 65535 - ((i * 10000) % 65535); break; case 1: style->base[GTK_STATE_NORMAL].red = 10000 * (cur_depth % 6); style->base[GTK_STATE_NORMAL].green = 65535 - ((i * 10000) % 65535); style->base[GTK_STATE_NORMAL].blue = 0; break; default: style->base[GTK_STATE_NORMAL].red = 65535 - ((i * 10000) % 65535); style->base[GTK_STATE_NORMAL].green = 0; style->base[GTK_STATE_NORMAL].blue = 10000 * (cur_depth % 6); break; } gtk_ctree_node_set_row_data_full (ctree, sibling, style, (GtkDestroyNotify) gtk_style_unref); if (ctree->line_style == GTK_CTREE_LINES_TABBED) gtk_ctree_node_set_row_style (ctree, sibling, style); 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[] = ""; GtkCTreeNode *parent; GtkStyle *style; 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 > 100000) { g_print ("%d total items? Try less\n",n); return; } gtk_clist_freeze (GTK_CLIST (ctree)); gtk_clist_clear (GTK_CLIST (ctree)); books = 1; pages = 0; parent = gtk_ctree_insert_node (ctree, NULL, NULL, text, 5, pixmap1, mask1, pixmap2, mask2, FALSE, TRUE); style = gtk_style_new (); style->base[GTK_STATE_NORMAL].red = 0; style->base[GTK_STATE_NORMAL].green = 45000; style->base[GTK_STATE_NORMAL].blue = 55000; gtk_ctree_node_set_row_data_full (ctree, parent, style, (GtkDestroyNotify) gtk_style_unref); if (ctree->line_style == GTK_CTREE_LINES_TABBED) gtk_ctree_node_set_row_style (ctree, parent, style); build_recursive (ctree, 1, d, b, p, parent); gtk_clist_thaw (GTK_CLIST (ctree)); after_press (ctree, NULL); } static void ctree_click_column (GtkCTree *ctree, gint column, gpointer data) { GtkCList *clist; clist = GTK_CLIST (ctree); if (column == clist->sort_column) { if (clist->sort_type == GTK_SORT_ASCENDING) clist->sort_type = GTK_SORT_DESCENDING; else clist->sort_type = GTK_SORT_ASCENDING; } else gtk_clist_set_sort_column (clist, column); gtk_ctree_sort_recursive (ctree, NULL); } void create_ctree (void) { static GtkWidget *window = NULL; GtkTooltips *tooltips; GtkCTree *ctree; GtkWidget *scrolled_win; GtkWidget *vbox; GtkWidget *bbox; GtkWidget *mbox; GtkWidget *hbox; GtkWidget *hbox2; GtkWidget *frame; GtkWidget *label; GtkWidget *button; GtkWidget *check; GtkAdjustment *adj; GtkWidget *spinner; GdkColor transparent = { 0 }; char *title[] = { "Tree" , "Info" }; char buf[80]; static OptionMenuItem items1[] = { { "No lines", ctree_toggle_line_style }, { "Solid", ctree_toggle_line_style }, { "Dotted", ctree_toggle_line_style }, { "Tabbed", ctree_toggle_line_style } }; static OptionMenuItem items2[] = { { "None", ctree_toggle_expander_style }, { "Square", ctree_toggle_expander_style }, { "Triangle", ctree_toggle_expander_style }, { "Circular", ctree_toggle_expander_style } }; static OptionMenuItem items3[] = { { "Left", ctree_toggle_justify }, { "Right", ctree_toggle_justify } }; static OptionMenuItem items4[] = { { "Single", ctree_toggle_sel_mode }, { "Browse", ctree_toggle_sel_mode }, { "Multiple", ctree_toggle_sel_mode }, { "Extended", ctree_toggle_sel_mode } }; 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_set_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_set_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); scrolled_win = gtk_scrolled_window_new (NULL, NULL); gtk_container_set_border_width (GTK_CONTAINER (scrolled_win), 5); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win), GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS); gtk_box_pack_start (GTK_BOX (vbox), scrolled_win, TRUE, TRUE, 0); ctree = GTK_CTREE (gtk_ctree_new_with_titles (2, 0, title)); gtk_container_add (GTK_CONTAINER (scrolled_win), GTK_WIDGET (ctree)); gtk_clist_set_column_auto_resize (GTK_CLIST (ctree), 0, TRUE); gtk_clist_set_column_width (GTK_CLIST (ctree), 1, 200); gtk_clist_set_selection_mode (GTK_CLIST (ctree), GTK_SELECTION_EXTENDED); gtk_ctree_set_line_style (ctree, GTK_CTREE_LINES_DOTTED); line_style = GTK_CTREE_LINES_DOTTED; gtk_signal_connect (GTK_OBJECT (button), "clicked", GTK_SIGNAL_FUNC (rebuild_tree), ctree); gtk_signal_connect (GTK_OBJECT (ctree), "click_column", (GtkSignalFunc) ctree_click_column, NULL); gtk_signal_connect_after (GTK_OBJECT (ctree), "button_press_event", GTK_SIGNAL_FUNC (after_press), 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_signal_connect_after (GTK_OBJECT (ctree), "end_selection", GTK_SIGNAL_FUNC (after_press), NULL); gtk_signal_connect_after (GTK_OBJECT (ctree), "toggle_focus_row", GTK_SIGNAL_FUNC (after_press), NULL); gtk_signal_connect_after (GTK_OBJECT (ctree), "select_all", GTK_SIGNAL_FUNC (after_press), NULL); gtk_signal_connect_after (GTK_OBJECT (ctree), "unselect_all", GTK_SIGNAL_FUNC (after_press), NULL); gtk_signal_connect_after (GTK_OBJECT (ctree), "scroll_vertical", GTK_SIGNAL_FUNC (after_press), NULL); bbox = gtk_hbox_new (FALSE, 5); gtk_container_set_border_width (GTK_CONTAINER (bbox), 5); gtk_box_pack_start (GTK_BOX (vbox), bbox, FALSE, TRUE, 0); mbox = gtk_vbox_new (TRUE, 5); gtk_box_pack_start (GTK_BOX (bbox), mbox, FALSE, TRUE, 0); label = gtk_label_new ("Row Height :"); gtk_box_pack_start (GTK_BOX (mbox), label, FALSE, FALSE, 0); label = gtk_label_new ("Indent :"); gtk_box_pack_start (GTK_BOX (mbox), label, FALSE, FALSE, 0); label = gtk_label_new ("Spacing :"); gtk_box_pack_start (GTK_BOX (mbox), label, FALSE, FALSE, 0); mbox = gtk_vbox_new (TRUE, 5); gtk_box_pack_start (GTK_BOX (bbox), mbox, FALSE, TRUE, 0); adj = (GtkAdjustment *) gtk_adjustment_new (20, 12, 100, 1, 10, 0); spinner = gtk_spin_button_new (adj, 0, 0); gtk_box_pack_start (GTK_BOX (mbox), spinner, FALSE, FALSE, 5); gtk_tooltips_set_tip (tooltips, spinner, "Row height of list items", NULL); gtk_signal_connect (GTK_OBJECT (adj), "value_changed", GTK_SIGNAL_FUNC (change_row_height), ctree); gtk_clist_set_row_height ( GTK_CLIST (ctree), adj->value); adj = (GtkAdjustment *) gtk_adjustment_new (20, 0, 60, 1, 10, 0); spinner = gtk_spin_button_new (adj, 0, 0); gtk_box_pack_start (GTK_BOX (mbox), spinner, FALSE, FALSE, 5); gtk_tooltips_set_tip (tooltips, spinner, "Tree Indentation.", NULL); gtk_signal_connect (GTK_OBJECT (adj), "value_changed", GTK_SIGNAL_FUNC (change_indent), ctree); adj = (GtkAdjustment *) gtk_adjustment_new (5, 0, 60, 1, 10, 0); spinner = gtk_spin_button_new (adj, 0, 0); gtk_box_pack_start (GTK_BOX (mbox), spinner, FALSE, FALSE, 5); gtk_tooltips_set_tip (tooltips, spinner, "Tree Spacing.", NULL); gtk_signal_connect (GTK_OBJECT (adj), "value_changed", GTK_SIGNAL_FUNC (change_spacing), ctree); mbox = gtk_vbox_new (TRUE, 5); gtk_box_pack_start (GTK_BOX (bbox), mbox, FALSE, TRUE, 0); hbox = gtk_hbox_new (FALSE, 5); gtk_box_pack_start (GTK_BOX (mbox), hbox, FALSE, FALSE, 0); button = gtk_button_new_with_label ("Expand All"); gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0); gtk_signal_connect (GTK_OBJECT (button), "clicked", GTK_SIGNAL_FUNC (expand_all), ctree); button = gtk_button_new_with_label ("Collapse All"); gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0); gtk_signal_connect (GTK_OBJECT (button), "clicked", GTK_SIGNAL_FUNC (collapse_all), ctree); button = gtk_button_new_with_label ("Change Style"); gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0); gtk_signal_connect (GTK_OBJECT (button), "clicked", GTK_SIGNAL_FUNC (change_style), ctree); button = gtk_button_new_with_label ("Export Tree"); gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0); gtk_signal_connect (GTK_OBJECT (button), "clicked", GTK_SIGNAL_FUNC (export_ctree), ctree); hbox = gtk_hbox_new (FALSE, 5); gtk_box_pack_start (GTK_BOX (mbox), hbox, FALSE, FALSE, 0); button = gtk_button_new_with_label ("Select All"); gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0); gtk_signal_connect (GTK_OBJECT (button), "clicked", GTK_SIGNAL_FUNC (select_all), ctree); button = gtk_button_new_with_label ("Unselect All"); gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0); gtk_signal_connect (GTK_OBJECT (button), "clicked", GTK_SIGNAL_FUNC (unselect_all), ctree); button = gtk_button_new_with_label ("Remove Selection"); gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0); gtk_signal_connect (GTK_OBJECT (button), "clicked", GTK_SIGNAL_FUNC (remove_selection), ctree); check = gtk_check_button_new_with_label ("Reorderable"); gtk_box_pack_start (GTK_BOX (hbox), check, FALSE, TRUE, 0); 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_toggle_button_set_active (GTK_TOGGLE_BUTTON (check), TRUE); hbox = gtk_hbox_new (TRUE, 5); gtk_box_pack_start (GTK_BOX (mbox), hbox, FALSE, FALSE, 0); omenu1 = build_option_menu (items1, 4, 2, ctree); gtk_box_pack_start (GTK_BOX (hbox), omenu1, FALSE, TRUE, 0); gtk_tooltips_set_tip (tooltips, omenu1, "The tree's line style.", NULL); omenu2 = build_option_menu (items2, 4, 1, ctree); gtk_box_pack_start (GTK_BOX (hbox), omenu2, FALSE, TRUE, 0); gtk_tooltips_set_tip (tooltips, omenu2, "The tree's expander style.", NULL); omenu3 = build_option_menu (items3, 2, 0, ctree); gtk_box_pack_start (GTK_BOX (hbox), omenu3, FALSE, TRUE, 0); gtk_tooltips_set_tip (tooltips, omenu3, "The tree's justification.", NULL); omenu4 = build_option_menu (items4, 4, 3, ctree); gtk_box_pack_start (GTK_BOX (hbox), omenu4, FALSE, TRUE, 0); gtk_tooltips_set_tip (tooltips, omenu4, "The list's selection mode.", NULL); gtk_widget_realize (window); if (!pixmap1) pixmap1 = gdk_pixmap_create_from_xpm_d (window->window, &mask1, &transparent, book_closed_xpm); if (!pixmap2) pixmap2 = gdk_pixmap_create_from_xpm_d (window->window, &mask2, &transparent, book_open_xpm); if (!pixmap3) 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_set_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_set_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_set_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_set_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_set_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_set_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); } /* * GtkColorSelection */ 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); } static void opacity_toggled_cb (GtkWidget *w, GtkColorSelectionDialog *cs) { GtkColorSelection *colorsel; colorsel = GTK_COLOR_SELECTION (cs->colorsel); gtk_color_selection_set_use_opacity (colorsel, gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (w))); } static void palette_toggled_cb (GtkWidget *w, GtkColorSelectionDialog *cs) { GtkColorSelection *colorsel; colorsel = GTK_COLOR_SELECTION (cs->colorsel); gtk_color_selection_set_use_palette (colorsel, gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (w))); } void create_color_selection (void) { static GtkWidget *window = NULL; if (!window) { GtkWidget *options_hbox; GtkWidget *check_button; window = gtk_color_selection_dialog_new ("color selection dialog"); gtk_window_set_position (GTK_WINDOW (window), GTK_WIN_POS_MOUSE); gtk_signal_connect (GTK_OBJECT (window), "destroy", GTK_SIGNAL_FUNC(gtk_widget_destroyed), &window); options_hbox = gtk_hbox_new (FALSE, 0); gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), options_hbox, FALSE, FALSE, 0); gtk_container_set_border_width (GTK_CONTAINER (options_hbox), 10); check_button = gtk_check_button_new_with_label ("Show Opacity"); gtk_box_pack_start (GTK_BOX (options_hbox), check_button, FALSE, FALSE, 0); gtk_signal_connect (GTK_OBJECT (check_button), "toggled", GTK_SIGNAL_FUNC (opacity_toggled_cb), window); check_button = gtk_check_button_new_with_label ("Show Palette"); gtk_box_pack_end (GTK_BOX (options_hbox), check_button, FALSE, FALSE, 0); gtk_signal_connect (GTK_OBJECT (check_button), "toggled", GTK_SIGNAL_FUNC (palette_toggled_cb), window); gtk_widget_show_all (options_hbox); 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); } /* * GtkFileSelection */ 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_set_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 flipping_toggled_cb (GtkWidget *widget, gpointer data) { int state = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget)); int new_direction = state ? GTK_TEXT_DIR_RTL : GTK_TEXT_DIR_LTR; gtk_widget_set_default_direction (new_direction); } void create_flipping (void) { static GtkWidget *window = NULL; GtkWidget *check_button, *button; 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), "Bidirectional Flipping"); check_button = gtk_check_button_new_with_label ("Right-to-left global direction"); gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), check_button, TRUE, TRUE, 0); if (gtk_widget_get_default_direction () == GTK_TEXT_DIR_RTL) gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check_button), TRUE); gtk_signal_connect (GTK_OBJECT (check_button), "toggled", flipping_toggled_cb, FALSE); gtk_container_set_border_width (GTK_CONTAINER (check_button), 10); 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 (GTK_DIALOG (window)->action_area), button, TRUE, TRUE, 0); } if (!GTK_WIDGET_VISIBLE (window)) gtk_widget_show_all (window); else gtk_widget_destroy (window); } /* * GtkFontSelection */ void font_selection_ok (GtkWidget *w, GtkFontSelectionDialog *fs) { gchar *s = gtk_font_selection_dialog_get_font_name (fs); g_print ("%s\n", s); g_free (s); 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_set_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; static 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); } static 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), "GtkDialog"); gtk_container_set_border_width (GTK_CONTAINER (dialog_window), 0); gtk_widget_set_usize (dialog_window, 200, 110); 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); } /* Event Watcher */ static gboolean event_watcher_enter_id = 0; static gboolean event_watcher_leave_id = 0; static gboolean event_watcher (GtkObject *object, guint signal_id, guint n_params, GtkArg *params, gpointer data) { g_print ("Watch: \"%s\" emitted for %s\n", gtk_signal_name (signal_id), gtk_type_name (GTK_OBJECT_TYPE (object))); return TRUE; } static void event_watcher_down (void) { if (event_watcher_enter_id) { guint signal_id; signal_id = gtk_signal_lookup ("enter_notify_event", GTK_TYPE_WIDGET); gtk_signal_remove_emission_hook (signal_id, event_watcher_enter_id); event_watcher_enter_id = 0; signal_id = gtk_signal_lookup ("leave_notify_event", GTK_TYPE_WIDGET); gtk_signal_remove_emission_hook (signal_id, event_watcher_leave_id); event_watcher_leave_id = 0; } } static void event_watcher_toggle (void) { if (event_watcher_enter_id) event_watcher_down (); else { guint signal_id; signal_id = gtk_signal_lookup ("enter_notify_event", GTK_TYPE_WIDGET); event_watcher_enter_id = gtk_signal_add_emission_hook (signal_id, event_watcher, NULL); signal_id = gtk_signal_lookup ("leave_notify_event", GTK_TYPE_WIDGET); event_watcher_leave_id = gtk_signal_add_emission_hook (signal_id, event_watcher, NULL); } } static void create_event_watcher (void) { 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_signal_connect (GTK_OBJECT (dialog_window), "destroy", GTK_SIGNAL_FUNC (event_watcher_down), NULL); gtk_window_set_title (GTK_WINDOW (dialog_window), "Event Watcher"); gtk_container_set_border_width (GTK_CONTAINER (dialog_window), 0); gtk_widget_set_usize (dialog_window, 200, 110); button = gtk_toggle_button_new_with_label ("Activate Watch"); gtk_signal_connect (GTK_OBJECT (button), "clicked", GTK_SIGNAL_FUNC (event_watcher_toggle), NULL); gtk_container_set_border_width (GTK_CONTAINER (button), 10); gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog_window)->vbox), 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), (GtkObject*) dialog_window); 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); } if (!GTK_WIDGET_VISIBLE (dialog_window)) gtk_widget_show (dialog_window); else gtk_widget_destroy (dialog_window); } /* * GtkRange */ static 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_set_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_set_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_set_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_set_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_GET_CLASS (ruler)->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_GET_CLASS (ruler)->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); } struct { GdkColor color; gchar *name; } text_colors[] = { { { 0, 0x0000, 0x0000, 0x0000 }, "black" }, { { 0, 0xFFFF, 0xFFFF, 0xFFFF }, "white" }, { { 0, 0xFFFF, 0x0000, 0x0000 }, "red" }, { { 0, 0x0000, 0xFFFF, 0x0000 }, "green" }, { { 0, 0x0000, 0x0000, 0xFFFF }, "blue" }, { { 0, 0x0000, 0xFFFF, 0xFFFF }, "cyan" }, { { 0, 0xFFFF, 0x0000, 0xFFFF }, "magenta" }, { { 0, 0xFFFF, 0xFFFF, 0x0000 }, "yellow" } }; int ntext_colors = sizeof(text_colors) / sizeof(text_colors[0]); /* * GtkText */ void text_insert_random (GtkWidget *w, GtkText *text) { int i; char c; for (i=0; i<10; i++) { c = 'A' + rand() % ('Z' - 'A'); gtk_text_set_point (text, rand() % gtk_text_get_length (text)); gtk_text_insert (text, NULL, NULL, NULL, &c, 1); } } void create_text (void) { int i, j; static GtkWidget *window = NULL; GtkWidget *box1; GtkWidget *box2; GtkWidget *hbox; GtkWidget *button; GtkWidget *check; GtkWidget *separator; GtkWidget *scrolled_window; 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_set_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_set_border_width (GTK_CONTAINER (box2), 10); gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0); gtk_widget_show (box2); scrolled_window = gtk_scrolled_window_new (NULL, NULL); gtk_box_pack_start (GTK_BOX (box2), scrolled_window, TRUE, TRUE, 0); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window), GTK_POLICY_NEVER, GTK_POLICY_ALWAYS); gtk_widget_show (scrolled_window); text = gtk_text_new (NULL, NULL); gtk_text_set_editable (GTK_TEXT (text), TRUE); gtk_container_add (GTK_CONTAINER (scrolled_window), text); gtk_widget_grab_focus (text); gtk_widget_show (text); gtk_text_freeze (GTK_TEXT (text)); for (i=0; iactive, pack_type); } static void tab_expand (GtkToggleButton *button, GtkWidget *child) { gboolean fill; GtkPackType pack_type; gtk_notebook_query_tab_label_packing (GTK_NOTEBOOK (sample_notebook), child, NULL, &fill, &pack_type); gtk_notebook_set_tab_label_packing (GTK_NOTEBOOK (sample_notebook), child, button->active, fill, pack_type); } static void tab_pack (GtkToggleButton *button, GtkWidget *child) { gboolean expand; gboolean fill; gtk_notebook_query_tab_label_packing (GTK_NOTEBOOK (sample_notebook), child, &expand, &fill, NULL); gtk_notebook_set_tab_label_packing (GTK_NOTEBOOK (sample_notebook), child, expand, fill, button->active); } static void create_pages (GtkNotebook *notebook, gint start, gint end) { GtkWidget *child = NULL; GtkWidget *button; GtkWidget *label; GtkWidget *hbox; GtkWidget *vbox; GtkWidget *label_box; GtkWidget *menu_box; GtkWidget *pixwid; gint i; char buffer[32]; for (i = start; i <= end; i++) { sprintf (buffer, "Page %d", i); child = gtk_frame_new (buffer); gtk_container_set_border_width (GTK_CONTAINER (child), 10); vbox = gtk_vbox_new (TRUE,0); gtk_container_set_border_width (GTK_CONTAINER (vbox), 10); gtk_container_add (GTK_CONTAINER (child), vbox); hbox = gtk_hbox_new (TRUE,0); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 5); button = gtk_check_button_new_with_label ("Fill Tab"); gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE); gtk_signal_connect (GTK_OBJECT (button), "toggled", GTK_SIGNAL_FUNC (tab_fill), child); button = gtk_check_button_new_with_label ("Expand Tab"); gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5); gtk_signal_connect (GTK_OBJECT (button), "toggled", GTK_SIGNAL_FUNC (tab_expand), child); button = gtk_check_button_new_with_label ("Pack end"); gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5); gtk_signal_connect (GTK_OBJECT (button), "toggled", GTK_SIGNAL_FUNC (tab_pack), child); button = gtk_button_new_with_label ("Hide Page"); gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 5); gtk_signal_connect_object (GTK_OBJECT (button), "clicked", GTK_SIGNAL_FUNC (gtk_widget_hide), GTK_OBJECT (child)); gtk_widget_show_all (child); label_box = gtk_hbox_new (FALSE, 0); pixwid = gtk_pixmap_new (book_closed, book_closed_mask); gtk_object_set_data (GTK_OBJECT (child), "tab_pixmap", pixwid); 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_object_set_data (GTK_OBJECT (child), "menu_pixmap", pixwid); 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 show_all_pages (GtkButton *button, GtkNotebook *notebook) { gtk_container_foreach (GTK_CONTAINER (notebook), (GtkCallback) gtk_widget_show, NULL); } static void standard_notebook (GtkButton *button, GtkNotebook *notebook) { gint i; gtk_notebook_set_show_tabs (notebook, TRUE); gtk_notebook_set_show_border (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); gtk_notebook_set_show_border (notebook, TRUE); if (g_list_length (notebook->children) == 15) for (i = 0; i < 10; i++) gtk_notebook_remove_page (notebook, 5); } static void borderless_notebook (GtkButton *button, GtkNotebook *notebook) { gint i; gtk_notebook_set_show_tabs (notebook, FALSE); gtk_notebook_set_show_border (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_show_border (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 notebook_homogeneous (GtkToggleButton *button, GtkNotebook *notebook) { gtk_notebook_set_homogeneous_tabs (notebook, button->active); } static void create_notebook (void) { static GtkWidget *window = NULL; GtkWidget *box1; GtkWidget *box2; GtkWidget *button; GtkWidget *separator; GtkWidget *omenu; GdkColor *transparent = NULL; GtkWidget *label; static OptionMenuItem items[] = { { "Standard", standard_notebook }, { "No tabs", notabs_notebook }, { "Borderless", borderless_notebook }, { "Scrollable", scrollable_notebook }, }; 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_set_border_width (GTK_CONTAINER (window), 0); box1 = gtk_vbox_new (FALSE, 0); gtk_container_add (GTK_CONTAINER (window), box1); sample_notebook = gtk_notebook_new (); gtk_signal_connect (GTK_OBJECT (sample_notebook), "switch_page", GTK_SIGNAL_FUNC (page_switch), NULL); gtk_notebook_set_tab_pos (GTK_NOTEBOOK (sample_notebook), GTK_POS_TOP); gtk_box_pack_start (GTK_BOX (box1), sample_notebook, TRUE, TRUE, 0); gtk_container_set_border_width (GTK_CONTAINER (sample_notebook), 10); gtk_widget_realize (sample_notebook); if (!book_open) book_open = gdk_pixmap_create_from_xpm_d (sample_notebook->window, &book_open_mask, transparent, book_open_xpm); if (!book_closed) book_closed = gdk_pixmap_create_from_xpm_d (sample_notebook->window, &book_closed_mask, transparent, book_closed_xpm); create_pages (GTK_NOTEBOOK (sample_notebook), 1, 5); separator = gtk_hseparator_new (); gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 10); box2 = gtk_hbox_new (FALSE, 5); gtk_container_set_border_width (GTK_CONTAINER (box2), 10); gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0); button = gtk_check_button_new_with_label ("popup menu"); gtk_box_pack_start (GTK_BOX (box2), button, TRUE, FALSE, 0); gtk_signal_connect (GTK_OBJECT(button), "clicked", GTK_SIGNAL_FUNC (notebook_popup), GTK_OBJECT (sample_notebook)); button = gtk_check_button_new_with_label ("homogeneous tabs"); gtk_box_pack_start (GTK_BOX (box2), button, TRUE, FALSE, 0); gtk_signal_connect (GTK_OBJECT(button), "clicked", GTK_SIGNAL_FUNC (notebook_homogeneous), GTK_OBJECT (sample_notebook)); box2 = gtk_hbox_new (FALSE, 5); gtk_container_set_border_width (GTK_CONTAINER (box2), 10); gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0); label = gtk_label_new ("Notebook Style :"); gtk_box_pack_start (GTK_BOX (box2), label, FALSE, TRUE, 0); omenu = build_option_menu (items, G_N_ELEMENTS (items), 0, sample_notebook); gtk_box_pack_start (GTK_BOX (box2), omenu, FALSE, TRUE, 0); button = gtk_button_new_with_label ("Show all Pages"); gtk_box_pack_start (GTK_BOX (box2), button, FALSE, TRUE, 0); gtk_signal_connect (GTK_OBJECT (button), "clicked", GTK_SIGNAL_FUNC (show_all_pages), sample_notebook); box2 = gtk_hbox_new (TRUE, 10); gtk_container_set_border_width (GTK_CONTAINER (box2), 10); gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0); button = gtk_button_new_with_label ("prev"); gtk_signal_connect_object (GTK_OBJECT (button), "clicked", GTK_SIGNAL_FUNC (gtk_notebook_prev_page), GTK_OBJECT (sample_notebook)); gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0); button = gtk_button_new_with_label ("next"); gtk_signal_connect_object (GTK_OBJECT (button), "clicked", GTK_SIGNAL_FUNC (gtk_notebook_next_page), GTK_OBJECT (sample_notebook)); gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0); button = gtk_button_new_with_label ("rotate"); gtk_signal_connect (GTK_OBJECT (button), "clicked", GTK_SIGNAL_FUNC (rotate_notebook), sample_notebook); gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0); separator = gtk_hseparator_new (); gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 5); button = gtk_button_new_with_label ("close"); gtk_container_set_border_width (GTK_CONTAINER (button), 5); gtk_signal_connect_object (GTK_OBJECT (button), "clicked", GTK_SIGNAL_FUNC (gtk_widget_destroy), GTK_OBJECT (window)); gtk_box_pack_start (GTK_BOX (box1), button, FALSE, FALSE, 0); GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT); gtk_widget_grab_default (button); } if (!GTK_WIDGET_VISIBLE (window)) gtk_widget_show_all (window); else gtk_widget_destroy (window); } /* * GtkPanes */ void toggle_resize (GtkWidget *widget, GtkWidget *child) { GtkPaned *paned = GTK_PANED (child->parent); gboolean is_child1 = (child == paned->child1); gboolean resize, shrink; resize = is_child1 ? paned->child1_resize : paned->child2_resize; shrink = is_child1 ? paned->child1_shrink : paned->child2_shrink; gtk_widget_ref (child); gtk_container_remove (GTK_CONTAINER (child->parent), child); if (is_child1) gtk_paned_pack1 (paned, child, !resize, shrink); else gtk_paned_pack2 (paned, child, !resize, shrink); gtk_widget_unref (child); } void toggle_shrink (GtkWidget *widget, GtkWidget *child) { GtkPaned *paned = GTK_PANED (child->parent); gboolean is_child1 = (child == paned->child1); gboolean resize, shrink; resize = is_child1 ? paned->child1_resize : paned->child2_resize; shrink = is_child1 ? paned->child1_shrink : paned->child2_shrink; gtk_widget_ref (child); gtk_container_remove (GTK_CONTAINER (child->parent), child); if (is_child1) gtk_paned_pack1 (paned, child, resize, !shrink); else gtk_paned_pack2 (paned, child, resize, !shrink); gtk_widget_unref (child); } GtkWidget * create_pane_options (GtkPaned *paned, const gchar *frame_label, const gchar *label1, const gchar *label2) { GtkWidget *frame; GtkWidget *table; GtkWidget *label; GtkWidget *check_button; frame = gtk_frame_new (frame_label); gtk_container_set_border_width (GTK_CONTAINER (frame), 4); table = gtk_table_new (3, 2, 4); gtk_container_add (GTK_CONTAINER (frame), table); label = gtk_label_new (label1); gtk_table_attach_defaults (GTK_TABLE (table), label, 0, 1, 0, 1); check_button = gtk_check_button_new_with_label ("Resize"); gtk_table_attach_defaults (GTK_TABLE (table), check_button, 0, 1, 1, 2); gtk_signal_connect (GTK_OBJECT (check_button), "toggled", GTK_SIGNAL_FUNC (toggle_resize), paned->child1); check_button = gtk_check_button_new_with_label ("Shrink"); gtk_table_attach_defaults (GTK_TABLE (table), check_button, 0, 1, 2, 3); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check_button), TRUE); gtk_signal_connect (GTK_OBJECT (check_button), "toggled", GTK_SIGNAL_FUNC (toggle_shrink), paned->child1); label = gtk_label_new (label2); gtk_table_attach_defaults (GTK_TABLE (table), label, 1, 2, 0, 1); check_button = gtk_check_button_new_with_label ("Resize"); gtk_table_attach_defaults (GTK_TABLE (table), check_button, 1, 2, 1, 2); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check_button), TRUE); gtk_signal_connect (GTK_OBJECT (check_button), "toggled", GTK_SIGNAL_FUNC (toggle_resize), paned->child2); check_button = gtk_check_button_new_with_label ("Shrink"); gtk_table_attach_defaults (GTK_TABLE (table), check_button, 1, 2, 2, 3); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check_button), TRUE); gtk_signal_connect (GTK_OBJECT (check_button), "toggled", GTK_SIGNAL_FUNC (toggle_shrink), paned->child2); return frame; } void create_panes (void) { static GtkWidget *window = NULL; GtkWidget *frame; GtkWidget *hpaned; GtkWidget *vpaned; GtkWidget *button; GtkWidget *vbox; 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_set_border_width (GTK_CONTAINER (window), 0); vbox = gtk_vbox_new (FALSE, 0); gtk_container_add (GTK_CONTAINER (window), vbox); vpaned = gtk_vpaned_new (); gtk_box_pack_start (GTK_BOX (vbox), vpaned, TRUE, TRUE, 0); gtk_container_set_border_width (GTK_CONTAINER(vpaned), 5); 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); button = gtk_button_new_with_label ("Hi there"); gtk_container_add (GTK_CONTAINER(frame), 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); 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); /* Now create toggle buttons to control sizing */ gtk_box_pack_start (GTK_BOX (vbox), create_pane_options (GTK_PANED (hpaned), "Horizontal", "Left", "Right"), FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), create_pane_options (GTK_PANED (vpaned), "Vertical", "Top", "Bottom"), FALSE, FALSE, 0); gtk_widget_show_all (vbox); } if (!GTK_WIDGET_VISIBLE (window)) gtk_widget_show (window); else gtk_widget_destroy (window); } /* * Drag -N- Drop */ #if 0 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_set_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_set_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_set_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_set_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_set_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_set_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); } #endif /* * Shaped Windows */ 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 (NULL, &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); gdk_drawable_unref (gdk_pixmap_mask); gdk_drawable_unref (gdk_pixmap); 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; if (!(file_exists ("Modeller.xpm") && file_exists ("FilesQueue.xpm") && file_exists ("3DRings.xpm"))) return; 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); } /* * WM Hints demo */ 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_set_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_set_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); } /* * GtkProgressBar */ typedef struct _ProgressData { GtkWidget *window; GtkWidget *pbar; GtkWidget *block_spin; GtkWidget *x_align_spin; GtkWidget *y_align_spin; GtkWidget *step_spin; GtkWidget *act_blocks_spin; GtkWidget *label; GtkWidget *omenu1; GtkWidget *omenu2; GtkWidget *entry; int timer; } ProgressData; gint progress_timeout (gpointer data) { gfloat new_val; GtkAdjustment *adj; adj = GTK_PROGRESS (data)->adjustment; new_val = adj->value + 1; if (new_val > adj->upper) new_val = adj->lower; gtk_progress_set_value (GTK_PROGRESS (data), new_val); return TRUE; } static void destroy_progress (GtkWidget *widget, ProgressData **pdata) { gtk_timeout_remove ((*pdata)->timer); (*pdata)->timer = 0; (*pdata)->window = NULL; g_free (*pdata); *pdata = NULL; } static void progressbar_toggle_orientation (GtkWidget *widget, ProgressData *pdata) { gint i; if (!GTK_WIDGET_MAPPED (widget)) return; RADIOMENUTOGGLED ((GtkRadioMenuItem *) (((GtkOptionMenu *)(pdata->omenu1))->menu_item), i); gtk_progress_bar_set_orientation (GTK_PROGRESS_BAR (pdata->pbar), (GtkProgressBarOrientation) (3-i)); } static void toggle_show_text (GtkWidget *widget, ProgressData *pdata) { gtk_progress_set_show_text (GTK_PROGRESS (pdata->pbar), GTK_TOGGLE_BUTTON (widget)->active); gtk_widget_set_sensitive (pdata->entry, GTK_TOGGLE_BUTTON (widget)->active); gtk_widget_set_sensitive (pdata->x_align_spin, GTK_TOGGLE_BUTTON (widget)->active); gtk_widget_set_sensitive (pdata->y_align_spin, GTK_TOGGLE_BUTTON (widget)->active); } static void progressbar_toggle_bar_style (GtkWidget *widget, ProgressData *pdata) { gint i; if (!GTK_WIDGET_MAPPED (widget)) return; RADIOMENUTOGGLED ((GtkRadioMenuItem *) (((GtkOptionMenu *)(pdata->omenu2))->menu_item), i); i = 1 - i; if (i == 1) gtk_widget_set_sensitive (pdata->block_spin, TRUE); else gtk_widget_set_sensitive (pdata->block_spin, FALSE); gtk_progress_bar_set_bar_style (GTK_PROGRESS_BAR (pdata->pbar), (GtkProgressBarStyle) i); } static void progress_value_changed (GtkAdjustment *adj, ProgressData *pdata) { char buf[20]; if (GTK_PROGRESS (pdata->pbar)->activity_mode) sprintf (buf, "???"); else sprintf (buf, "%.0f%%", 100 * gtk_progress_get_current_percentage (GTK_PROGRESS (pdata->pbar))); gtk_label_set_text (GTK_LABEL (pdata->label), buf); } static void adjust_blocks (GtkAdjustment *adj, ProgressData *pdata) { gtk_progress_set_percentage (GTK_PROGRESS (pdata->pbar), 0); gtk_progress_bar_set_discrete_blocks (GTK_PROGRESS_BAR (pdata->pbar), gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (pdata->block_spin))); } static void adjust_step (GtkAdjustment *adj, ProgressData *pdata) { gtk_progress_bar_set_activity_step (GTK_PROGRESS_BAR (pdata->pbar), gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (pdata->step_spin))); } static void adjust_act_blocks (GtkAdjustment *adj, ProgressData *pdata) { gtk_progress_bar_set_activity_blocks (GTK_PROGRESS_BAR (pdata->pbar), gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (pdata->act_blocks_spin))); } static void adjust_align (GtkAdjustment *adj, ProgressData *pdata) { gtk_progress_set_text_alignment (GTK_PROGRESS (pdata->pbar), gtk_spin_button_get_value_as_float (GTK_SPIN_BUTTON (pdata->x_align_spin)), gtk_spin_button_get_value_as_float (GTK_SPIN_BUTTON (pdata->y_align_spin))); } static void toggle_activity_mode (GtkWidget *widget, ProgressData *pdata) { gtk_progress_set_activity_mode (GTK_PROGRESS (pdata->pbar), GTK_TOGGLE_BUTTON (widget)->active); gtk_widget_set_sensitive (pdata->step_spin, GTK_TOGGLE_BUTTON (widget)->active); gtk_widget_set_sensitive (pdata->act_blocks_spin, GTK_TOGGLE_BUTTON (widget)->active); } static void entry_changed (GtkWidget *widget, ProgressData *pdata) { gtk_progress_set_format_string (GTK_PROGRESS (pdata->pbar), gtk_entry_get_text (GTK_ENTRY (pdata->entry))); } void create_progress_bar (void) { GtkWidget *button; GtkWidget *vbox; GtkWidget *vbox2; GtkWidget *hbox; GtkWidget *check; GtkWidget *frame; GtkWidget *tab; GtkWidget *label; GtkWidget *align; GtkAdjustment *adj; static ProgressData *pdata = NULL; static OptionMenuItem items1[] = { { "Left-Right", progressbar_toggle_orientation }, { "Right-Left", progressbar_toggle_orientation }, { "Bottom-Top", progressbar_toggle_orientation }, { "Top-Bottom", progressbar_toggle_orientation } }; static OptionMenuItem items2[] = { { "Continuous", progressbar_toggle_bar_style }, { "Discrete", progressbar_toggle_bar_style } }; if (!pdata) pdata = g_new0 (ProgressData, 1); if (!pdata->window) { pdata->window = gtk_dialog_new (); gtk_window_set_policy (GTK_WINDOW (pdata->window), FALSE, FALSE, TRUE); gtk_signal_connect (GTK_OBJECT (pdata->window), "destroy", GTK_SIGNAL_FUNC (destroy_progress), &pdata); pdata->timer = 0; gtk_window_set_title (GTK_WINDOW (pdata->window), "GtkProgressBar"); gtk_container_set_border_width (GTK_CONTAINER (pdata->window), 0); vbox = gtk_vbox_new (FALSE, 5); gtk_container_set_border_width (GTK_CONTAINER (vbox), 10); gtk_box_pack_start (GTK_BOX (GTK_DIALOG (pdata->window)->vbox), vbox, FALSE, TRUE, 0); frame = gtk_frame_new ("Progress"); gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, TRUE, 0); vbox2 = gtk_vbox_new (FALSE, 5); gtk_container_add (GTK_CONTAINER (frame), vbox2); align = gtk_alignment_new (0.5, 0.5, 0, 0); gtk_box_pack_start (GTK_BOX (vbox2), align, FALSE, FALSE, 5); adj = (GtkAdjustment *) gtk_adjustment_new (0, 1, 300, 0, 0, 0); gtk_signal_connect (GTK_OBJECT (adj), "value_changed", GTK_SIGNAL_FUNC (progress_value_changed), pdata); pdata->pbar = gtk_progress_bar_new_with_adjustment (adj); gtk_progress_set_format_string (GTK_PROGRESS (pdata->pbar), "%v from [%l,%u] (=%p%%)"); gtk_container_add (GTK_CONTAINER (align), pdata->pbar); pdata->timer = gtk_timeout_add (100, progress_timeout, pdata->pbar); align = gtk_alignment_new (0.5, 0.5, 0, 0); gtk_box_pack_start (GTK_BOX (vbox2), align, FALSE, FALSE, 5); hbox = gtk_hbox_new (FALSE, 5); gtk_container_add (GTK_CONTAINER (align), hbox); label = gtk_label_new ("Label updated by user :"); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0); pdata->label = gtk_label_new (""); gtk_box_pack_start (GTK_BOX (hbox), pdata->label, FALSE, TRUE, 0); frame = gtk_frame_new ("Options"); gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, TRUE, 0); vbox2 = gtk_vbox_new (FALSE, 5); gtk_container_add (GTK_CONTAINER (frame), vbox2); tab = gtk_table_new (7, 2, FALSE); gtk_box_pack_start (GTK_BOX (vbox2), tab, FALSE, TRUE, 0); label = gtk_label_new ("Orientation :"); gtk_table_attach (GTK_TABLE (tab), label, 0, 1, 0, 1, GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 5, 5); gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5); pdata->omenu1 = build_option_menu (items1, 4, 0, pdata); hbox = gtk_hbox_new (FALSE, 0); gtk_table_attach (GTK_TABLE (tab), hbox, 1, 2, 0, 1, GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 5, 5); gtk_box_pack_start (GTK_BOX (hbox), pdata->omenu1, TRUE, TRUE, 0); check = gtk_check_button_new_with_label ("Show text"); gtk_signal_connect (GTK_OBJECT (check), "clicked", GTK_SIGNAL_FUNC (toggle_show_text), pdata); gtk_table_attach (GTK_TABLE (tab), check, 0, 1, 1, 2, GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 5, 5); hbox = gtk_hbox_new (FALSE, 0); gtk_table_attach (GTK_TABLE (tab), hbox, 1, 2, 1, 2, GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 5, 5); label = gtk_label_new ("Format : "); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0); pdata->entry = gtk_entry_new (); gtk_signal_connect (GTK_OBJECT (pdata->entry), "changed", GTK_SIGNAL_FUNC (entry_changed), pdata); gtk_box_pack_start (GTK_BOX (hbox), pdata->entry, TRUE, TRUE, 0); gtk_entry_set_text (GTK_ENTRY (pdata->entry), "%v from [%l,%u] (=%p%%)"); gtk_widget_set_usize (pdata->entry, 100, -1); gtk_widget_set_sensitive (pdata->entry, FALSE); label = gtk_label_new ("Text align :"); gtk_table_attach (GTK_TABLE (tab), label, 0, 1, 2, 3, GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 5, 5); gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5); hbox = gtk_hbox_new (FALSE, 0); gtk_table_attach (GTK_TABLE (tab), hbox, 1, 2, 2, 3, GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 5, 5); label = gtk_label_new ("x :"); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 5); adj = (GtkAdjustment *) gtk_adjustment_new (0.5, 0, 1, 0.1, 0.1, 0); pdata->x_align_spin = gtk_spin_button_new (adj, 0, 1); gtk_signal_connect (GTK_OBJECT (adj), "value_changed", GTK_SIGNAL_FUNC (adjust_align), pdata); gtk_box_pack_start (GTK_BOX (hbox), pdata->x_align_spin, FALSE, TRUE, 0); gtk_widget_set_sensitive (pdata->x_align_spin, FALSE); label = gtk_label_new ("y :"); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 5); adj = (GtkAdjustment *) gtk_adjustment_new (0.5, 0, 1, 0.1, 0.1, 0); pdata->y_align_spin = gtk_spin_button_new (adj, 0, 1); gtk_signal_connect (GTK_OBJECT (adj), "value_changed", GTK_SIGNAL_FUNC (adjust_align), pdata); gtk_box_pack_start (GTK_BOX (hbox), pdata->y_align_spin, FALSE, TRUE, 0); gtk_widget_set_sensitive (pdata->y_align_spin, FALSE); label = gtk_label_new ("Bar Style :"); gtk_table_attach (GTK_TABLE (tab), label, 0, 1, 3, 4, GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 5, 5); gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5); pdata->omenu2 = build_option_menu (items2, 2, 0, pdata); hbox = gtk_hbox_new (FALSE, 0); gtk_table_attach (GTK_TABLE (tab), hbox, 1, 2, 3, 4, GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 5, 5); gtk_box_pack_start (GTK_BOX (hbox), pdata->omenu2, TRUE, TRUE, 0); label = gtk_label_new ("Block count :"); gtk_table_attach (GTK_TABLE (tab), label, 0, 1, 4, 5, GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 5, 5); gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5); hbox = gtk_hbox_new (FALSE, 0); gtk_table_attach (GTK_TABLE (tab), hbox, 1, 2, 4, 5, GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 5, 5); adj = (GtkAdjustment *) gtk_adjustment_new (10, 2, 20, 1, 5, 0); pdata->block_spin = gtk_spin_button_new (adj, 0, 0); gtk_signal_connect (GTK_OBJECT (adj), "value_changed", GTK_SIGNAL_FUNC (adjust_blocks), pdata); gtk_box_pack_start (GTK_BOX (hbox), pdata->block_spin, FALSE, TRUE, 0); gtk_widget_set_sensitive (pdata->block_spin, FALSE); check = gtk_check_button_new_with_label ("Activity mode"); gtk_signal_connect (GTK_OBJECT (check), "clicked", GTK_SIGNAL_FUNC (toggle_activity_mode), pdata); gtk_table_attach (GTK_TABLE (tab), check, 0, 1, 5, 6, GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 5, 5); hbox = gtk_hbox_new (FALSE, 0); gtk_table_attach (GTK_TABLE (tab), hbox, 1, 2, 5, 6, GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 5, 5); label = gtk_label_new ("Step size : "); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0); adj = (GtkAdjustment *) gtk_adjustment_new (3, 1, 20, 1, 5, 0); pdata->step_spin = gtk_spin_button_new (adj, 0, 0); gtk_signal_connect (GTK_OBJECT (adj), "value_changed", GTK_SIGNAL_FUNC (adjust_step), pdata); gtk_box_pack_start (GTK_BOX (hbox), pdata->step_spin, FALSE, TRUE, 0); gtk_widget_set_sensitive (pdata->step_spin, FALSE); hbox = gtk_hbox_new (FALSE, 0); gtk_table_attach (GTK_TABLE (tab), hbox, 1, 2, 6, 7, GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 5, 5); label = gtk_label_new ("Blocks : "); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0); adj = (GtkAdjustment *) gtk_adjustment_new (5, 2, 10, 1, 5, 0); pdata->act_blocks_spin = gtk_spin_button_new (adj, 0, 0); gtk_signal_connect (GTK_OBJECT (adj), "value_changed", GTK_SIGNAL_FUNC (adjust_act_blocks), pdata); gtk_box_pack_start (GTK_BOX (hbox), pdata->act_blocks_spin, FALSE, TRUE, 0); gtk_widget_set_sensitive (pdata->act_blocks_spin, FALSE); button = gtk_button_new_with_label ("close"); gtk_signal_connect_object (GTK_OBJECT (button), "clicked", GTK_SIGNAL_FUNC (gtk_widget_destroy), GTK_OBJECT (pdata->window)); GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT); gtk_box_pack_start (GTK_BOX (GTK_DIALOG (pdata->window)->action_area), button, TRUE, TRUE, 0); gtk_widget_grab_default (button); } if (!GTK_WIDGET_VISIBLE (pdata->window)) gtk_widget_show_all (pdata->window); else gtk_widget_destroy (pdata->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) { gtk_widget_push_colormap (gdk_rgb_get_cmap ()); window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_widget_pop_colormap (); gtk_signal_connect (GTK_OBJECT (window), "destroy", GTK_SIGNAL_FUNC(color_preview_destroy), &window); gtk_window_set_title (GTK_WINDOW (window), "test"); gtk_container_set_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); 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_all (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_set_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); 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_all (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_set_border_width (GTK_CONTAINER (window), 0); /* Create the list */ vbox = gtk_vbox_new (FALSE, 5); gtk_container_set_border_width (GTK_CONTAINER (vbox), 10); gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), vbox, TRUE, TRUE, 0); label = gtk_label_new ("Gets available targets for current selection"); gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0); 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); list = gtk_list_new (); gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (scrolled_win), list); gtk_signal_connect (GTK_OBJECT(list), "selection_received", GTK_SIGNAL_FUNC (selection_test_received), NULL); /* .. 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); 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)); } if (!GTK_WIDGET_VISIBLE (window)) gtk_widget_show_all (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_set_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; } /* * Test scrolling */ 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 gint scroll_test_scroll (GtkWidget *widget, GdkEventScroll *event, GtkAdjustment *adj) { gfloat new_value = adj->value + ((event->direction == GDK_SCROLL_UP) ? -adj->page_increment / 2: adj->page_increment / 2); new_value = CLAMP (new_value, adj->lower, adj->upper - adj->page_size); gtk_adjustment_set_value (adj, new_value); 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; GdkGeometry geometry; GdkWindowHints geometry_mask; 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_set_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 | GDK_SCROLL_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 (drawing_area), "scroll_event", GTK_SIGNAL_FUNC (scroll_test_scroll), 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); /* Set up gridded geometry */ geometry_mask = GDK_HINT_MIN_SIZE | GDK_HINT_BASE_SIZE | GDK_HINT_RESIZE_INC; geometry.min_width = 20; geometry.min_height = 20; geometry.base_width = 0; geometry.base_height = 0; geometry.width_inc = 10; geometry.height_inc = 10; gtk_window_set_geometry_hints (GTK_WINDOW (window), drawing_area, &geometry, geometry_mask); } 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_text (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_set_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_id = 0; static gint idle_test (GtkWidget *label) { static int count = 0; static char buffer[32]; sprintf (buffer, "count: %d", ++count); gtk_label_set_text (GTK_LABEL (label), buffer); return TRUE; } static void start_idle_test (GtkWidget *widget, GtkWidget *label) { if (!idle_id) { idle_id = gtk_idle_add ((GtkFunction) idle_test, label); } } static void stop_idle_test (GtkWidget *widget, gpointer data) { if (idle_id) { gtk_idle_remove (idle_id); idle_id = 0; } } static void destroy_idle_test (GtkWidget *widget, GtkWidget **window) { stop_idle_test (NULL, NULL); *window = NULL; } static void toggle_idle_container (GtkObject *button, GtkContainer *container) { gtk_container_set_resize_mode (container, GPOINTER_TO_INT (gtk_object_get_user_data (button))); } static void create_idle_test (void) { static GtkWidget *window = NULL; GtkWidget *button; GtkWidget *label; GtkWidget *container; if (!window) { GtkWidget *frame; GtkWidget *box; 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_set_border_width (GTK_CONTAINER (window), 0); label = gtk_label_new ("count: 0"); gtk_misc_set_padding (GTK_MISC (label), 10, 10); gtk_widget_show (label); container = gtk_widget_new (GTK_TYPE_HBOX, "GtkWidget::visible", TRUE, /* "GtkContainer::child", gtk_widget_new (GTK_TYPE_HBOX, * "GtkWidget::visible", TRUE, */ "GtkContainer::child", label, /* NULL), */ NULL); gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), container, TRUE, TRUE, 0); frame = gtk_widget_new (GTK_TYPE_FRAME, "GtkContainer::border_width", 5, "GtkFrame::label", "Label Container", "GtkWidget::visible", TRUE, "GtkWidget::parent", GTK_DIALOG (window)->vbox, NULL); box = gtk_widget_new (GTK_TYPE_VBOX, "GtkWidget::visible", TRUE, "GtkWidget::parent", frame, NULL); button = gtk_widget_new (GTK_TYPE_RADIO_BUTTON, "GtkButton::label", "Resize-Parent", "GtkObject::user_data", (void*)GTK_RESIZE_PARENT, "GtkObject::signal::clicked", toggle_idle_container, container, "GtkWidget::visible", TRUE, "GtkWidget::parent", box, NULL); button = gtk_widget_new (GTK_TYPE_RADIO_BUTTON, "GtkButton::label", "Resize-Queue", "GtkObject::user_data", (void*)GTK_RESIZE_QUEUE, "GtkObject::signal::clicked", toggle_idle_container, container, "GtkRadioButton::group", button, "GtkWidget::visible", TRUE, "GtkWidget::parent", box, NULL); button = gtk_widget_new (GTK_TYPE_RADIO_BUTTON, "GtkButton::label", "Resize-Immediate", "GtkObject::user_data", (void*)GTK_RESIZE_IMMEDIATE, "GtkObject::signal::clicked", toggle_idle_container, container, "GtkRadioButton::group", button, "GtkWidget::visible", TRUE, "GtkWidget::parent", box, NULL); 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); } /* * rc file test */ 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_set_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); } gint layout_expose_handler (GtkWidget *widget, GdkEventExpose *event) { GtkLayout *layout; gint i,j; gint imin, imax, jmin, jmax; layout = GTK_LAYOUT (widget); imin = (layout->xoffset + event->area.x) / 10; imax = (layout->xoffset + event->area.x + event->area.width + 9) / 10; jmin = (layout->yoffset + event->area.y) / 10; jmax = (layout->yoffset + 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; ibin_window, widget->style->black_gc, TRUE, 10*i - layout->xoffset, 10*j - layout->yoffset, 1+i%10, 1+j%10); return TRUE; } void create_layout (void) { static GtkWidget *window = NULL; GtkWidget *layout; GtkWidget *scrolledwindow; GtkWidget *button; if (!window) { gchar buf[16]; gint i, j; 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), "Layout"); gtk_widget_set_usize (window, 200, 200); scrolledwindow = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolledwindow), GTK_SHADOW_IN); gtk_scrolled_window_set_placement (GTK_SCROLLED_WINDOW (scrolledwindow), GTK_CORNER_TOP_RIGHT); gtk_container_add (GTK_CONTAINER (window), scrolledwindow); layout = gtk_layout_new (NULL, NULL); gtk_container_add (GTK_CONTAINER (scrolledwindow), layout); /* We set step sizes here since GtkLayout does not set * them itself. */ GTK_LAYOUT (layout)->hadjustment->step_increment = 10.0; GTK_LAYOUT (layout)->vadjustment->step_increment = 10.0; gtk_widget_set_events (layout, GDK_EXPOSURE_MASK); gtk_signal_connect (GTK_OBJECT (layout), "expose_event", GTK_SIGNAL_FUNC (layout_expose_handler), NULL); gtk_layout_set_size (GTK_LAYOUT (layout), 1600, 128000); for (i=0 ; i < 16 ; i++) for (j=0 ; j < 16 ; j++) { sprintf(buf, "Button %d, %d", i, j); if ((i + j) % 2) button = gtk_button_new_with_label (buf); else button = gtk_label_new (buf); gtk_layout_put (GTK_LAYOUT (layout), button, j*100, i*100); } for (i=16; i < 1280; i++) { sprintf(buf, "Button %d, %d", i, 0); if (i % 2) button = gtk_button_new_with_label (buf); else button = gtk_label_new (buf); gtk_layout_put (GTK_LAYOUT (layout), button, 0, i*100); } } if (!GTK_WIDGET_VISIBLE (window)) gtk_widget_show_all (window); else gtk_widget_destroy (window); } void create_styles (void) { static GtkWidget *window = NULL; GtkWidget *label; GtkWidget *button; GtkWidget *entry; GtkWidget *vbox; static GdkColor red = { 0, 0xffff, 0, 0 }; static GdkColor green = { 0, 0, 0xffff, 0 }; static GdkColor blue = { 0, 0, 0, 0xffff }; static GdkColor yellow = { 0, 0xffff, 0xffff, 0 }; static GdkColor cyan = { 0, 0 , 0xffff, 0xffff }; PangoFontDescription *font_desc; GtkRcStyle *rc_style; if (!window) { window = gtk_dialog_new (); gtk_signal_connect (GTK_OBJECT (window), "destroy", GTK_SIGNAL_FUNC(gtk_widget_destroyed), &window); 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); vbox = gtk_vbox_new (FALSE, 5); gtk_container_set_border_width (GTK_CONTAINER (vbox), 10); gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), vbox, FALSE, FALSE, 0); label = gtk_label_new ("Font:"); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0); font_desc = pango_font_description_from_string ("Helvetica,Sans Oblique 18"); button = gtk_button_new_with_label ("Some Text"); gtk_widget_modify_font (GTK_BIN (button)->child, font_desc); gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0); label = gtk_label_new ("Foreground:"); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0); button = gtk_button_new_with_label ("Some Text"); gtk_widget_modify_fg (GTK_BIN (button)->child, GTK_STATE_NORMAL, &red); gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0); label = gtk_label_new ("Background:"); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0); button = gtk_button_new_with_label ("Some Text"); gtk_widget_modify_bg (button, GTK_STATE_NORMAL, &green); gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0); label = gtk_label_new ("Text:"); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0); entry = gtk_entry_new (); gtk_entry_set_text (GTK_ENTRY (entry), "Some Text"); gtk_widget_modify_text (entry, GTK_STATE_NORMAL, &blue); gtk_box_pack_start (GTK_BOX (vbox), entry, FALSE, FALSE, 0); label = gtk_label_new ("Base:"); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0); entry = gtk_entry_new (); gtk_entry_set_text (GTK_ENTRY (entry), "Some Text"); gtk_widget_modify_base (entry, GTK_STATE_NORMAL, &yellow); gtk_box_pack_start (GTK_BOX (vbox), entry, FALSE, FALSE, 0); label = gtk_label_new ("Multiple:"); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0); button = gtk_button_new_with_label ("Some Text"); rc_style = gtk_rc_style_new (); rc_style->font_desc = font_desc; rc_style->color_flags[GTK_STATE_NORMAL] = GTK_RC_FG | GTK_RC_BG; rc_style->color_flags[GTK_STATE_PRELIGHT] = GTK_RC_FG | GTK_RC_BG; rc_style->color_flags[GTK_STATE_ACTIVE] = GTK_RC_FG | GTK_RC_BG; rc_style->fg[GTK_STATE_NORMAL] = yellow; rc_style->bg[GTK_STATE_NORMAL] = blue; rc_style->fg[GTK_STATE_PRELIGHT] = blue; rc_style->bg[GTK_STATE_PRELIGHT] = yellow; rc_style->fg[GTK_STATE_ACTIVE] = red; rc_style->bg[GTK_STATE_ACTIVE] = cyan; rc_style->xthickness = 5; rc_style->ythickness = 5; gtk_widget_modify_style (button, rc_style); gtk_widget_modify_style (GTK_BIN (button)->child, rc_style); g_object_unref (G_OBJECT (rc_style)); gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0); } if (!GTK_WIDGET_VISIBLE (window)) gtk_widget_show_all (window); 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 }, { "event watcher", create_event_watcher }, { "file selection", create_file_selection }, { "flipping", create_flipping }, { "font selection", create_font_selection }, { "gamma curve", create_gamma_curve }, { "handle box", create_handle_box }, { "image from drawable", create_get_image }, { "image", create_image }, { "item factory", create_item_factory }, { "labels", create_labels }, { "layout", create_layout }, { "list", create_list }, { "menus", create_menus }, { "message dialog", create_message_dialog }, { "modal window", create_modal_window }, { "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 }, { "saved position", create_saved_position }, { "scrolled windows", create_scrolled_windows }, { "shapes", create_shapes }, { "spinbutton", create_spins }, { "statusbar", create_statusbar }, { "styles", create_styles }, { "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; GdkGeometry geometry; int i; window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_widget_set_name (window, "main window"); gtk_widget_set_uposition (window, 20, 20); gtk_window_set_default_size (GTK_WINDOW (window), -1, 400); geometry.min_width = -1; geometry.min_height = -1; geometry.max_width = -1; geometry.max_height = G_MAXSHORT; gtk_window_set_geometry_hints (GTK_WINDOW (window), NULL, &geometry, GDK_HINT_MIN_SIZE | GDK_HINT_MAX_SIZE); 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); 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_box_pack_start (GTK_BOX (box1), label, FALSE, FALSE, 0); scrolled_window = gtk_scrolled_window_new (NULL, NULL); gtk_container_set_border_width (GTK_CONTAINER (scrolled_window), 10); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_box_pack_start (GTK_BOX (box1), scrolled_window, TRUE, TRUE, 0); box2 = gtk_vbox_new (FALSE, 0); gtk_container_set_border_width (GTK_CONTAINER (box2), 10); gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (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); } separator = gtk_hseparator_new (); gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0); box2 = gtk_vbox_new (FALSE, 10); gtk_container_set_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 (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_all (window); } static void test_init () { if (file_exists ("../gdk-pixbuf/.libs/libpixbufloader-pnm.so")) { putenv ("GDK_PIXBUF_MODULEDIR=../gdk-pixbuf/.libs"); putenv ("GTK_IM_MODULE_FILE=./gtk.immodules"); } } int main (int argc, char *argv[]) { GtkBindingSet *binding_set; g_mem_set_vtable (glib_mem_profiler_table); srand (time (NULL)); test_init (); gtk_set_locale (); /* Check to see if we are being run from the correct * directory. */ if (file_exists ("testgtkrc")) gtk_rc_add_default_file ("testgtkrc"); gtk_init (&argc, &argv); /* bindings test */ binding_set = gtk_binding_set_by_class (gtk_type_class (GTK_TYPE_WIDGET)); gtk_binding_entry_add_signal (binding_set, '9', GDK_CONTROL_MASK | GDK_RELEASE_MASK, "debug_msg", 1, GTK_TYPE_STRING, "GtkWidgetClass 9 test"); create_main_window (); gtk_main (); if (1) { while (g_main_pending ()) g_main_iteration (FALSE); sleep (1); while (g_main_pending ()) g_main_iteration (FALSE); } g_blow_chunks (); g_mem_profile (); return 0; }