#endif
#define GTK_ENABLE_BROKEN
-#include "gtk.h"
+#include "gtk/gtk.h"
#include "gdk/gdk.h"
#include "gdk/gdkkeysyms.h"
#define sleep(n) _sleep(n)
#endif
+#include "prop-editor.h"
+
#include "circles.xbm"
#include "test.xpm"
-typedef struct _OptionMenuItem
-{
- gchar *name;
- GtkSignalFunc func;
-} OptionMenuItem;
-
gboolean
file_exists (const char *filename)
{
gint window_type);
static GtkWidget *
-build_option_menu (OptionMenuItem items[],
- gint num_items,
- gint history,
- gpointer data);
+build_option_menu (gchar *items[],
+ gint num_items,
+ gint history,
+ void (*func)(GtkWidget *widget, gpointer data),
+ gpointer data);
/* macro, structure and variables used by tree window demos */
#define DEFAULT_NUMBER_OF_ITEM 3
/* end of tree section */
static GtkWidget *
-build_option_menu (OptionMenuItem items[],
- gint num_items,
- gint history,
- gpointer data)
+build_option_menu (gchar *items[],
+ gint num_items,
+ gint history,
+ void (*func)(GtkWidget *widget, gpointer data),
+ gpointer data)
{
GtkWidget *omenu;
GtkWidget *menu;
GtkWidget *menu_item;
+ GSList *group;
gint i;
omenu = gtk_option_menu_new ();
+ gtk_signal_connect (GTK_OBJECT (omenu), "changed",
+ GTK_SIGNAL_FUNC (func), data);
menu = gtk_menu_new ();
+ group = NULL;
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);
+ menu_item = gtk_radio_menu_item_new_with_label (group, items[i]);
+ group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menu_item));
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menu_item);
+ if (i == history)
+ gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (menu_item), TRUE);
gtk_widget_show (menu_item);
}
*window = NULL;
}
+
+/*
+ * Big windows and guffaw scrolling
+ */
+
+static gboolean
+pattern_expose (GtkWidget *widget,
+ GdkEventExpose *event,
+ gpointer data)
+{
+ GdkColor *color;
+ GdkWindow *window = event->window;
+
+ color = g_object_get_data (G_OBJECT (window), "pattern-color");
+ if (color)
+ {
+ GdkGC *tmp_gc = gdk_gc_new (window);
+ gdk_gc_set_rgb_fg_color (tmp_gc, color);
+
+ gdk_draw_rectangle (window, tmp_gc, TRUE,
+ event->area.x, event->area.y,
+ event->area.width, event->area.height);
+
+ g_object_unref (G_OBJECT (tmp_gc));
+ }
+
+ return FALSE;
+}
+
+static void
+pattern_set_bg (GtkWidget *widget,
+ GdkWindow *child,
+ gint level)
+{
+ static const GdkColor colors[] = {
+ { 0, 0x4444, 0x4444, 0xffff },
+ { 0, 0x8888, 0x8888, 0xffff },
+ { 0, 0xaaaa, 0xaaaa, 0xffff }
+ };
+
+ g_object_set_data (G_OBJECT (child), "pattern-color", (gpointer)&colors[level]);
+ gdk_window_set_user_data (child, widget);
+}
+
+static void
+create_pattern (GtkWidget *widget,
+ GdkWindow *parent,
+ gint level,
+ gint width,
+ gint height)
+{
+ gint h = 1;
+ gint i = 0;
+
+ GdkWindow *child;
+
+ while (2 * h <= height)
+ {
+ gint w = 1;
+ gint j = 0;
+
+ while (2 * w <= width)
+ {
+ if ((i + j) % 2 == 0)
+ {
+ gint x = w - 1;
+ gint y = h - 1;
+
+ GdkWindowAttr attributes;
+
+ attributes.window_type = GDK_WINDOW_CHILD;
+ attributes.x = x;
+ attributes.y = y;
+ attributes.width = w;
+ attributes.height = h;
+ attributes.wclass = GDK_INPUT_OUTPUT;
+ attributes.event_mask = GDK_EXPOSURE_MASK;
+ attributes.visual = gtk_widget_get_visual (widget);
+ attributes.colormap = gtk_widget_get_colormap (widget);
+
+ child = gdk_window_new (parent, &attributes,
+ GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP);
+
+ pattern_set_bg (widget, child, level);
+
+ if (level < 2)
+ create_pattern (widget, child, level + 1, w, h);
+
+ gdk_window_show (child);
+ }
+ j++;
+ w *= 2;
+ }
+ i++;
+ h *= 2;
+ }
+}
+
+#define PATTERN_SIZE (1 << 18)
+
+static void
+pattern_hadj_changed (GtkAdjustment *adj,
+ GtkWidget *darea)
+{
+ gint *old_value = g_object_get_data (G_OBJECT (adj), "old-value");
+ gint new_value = adj->value;
+
+ if (GTK_WIDGET_REALIZED (darea))
+ {
+ gdk_window_scroll (darea->window, *old_value - new_value, 0);
+ *old_value = new_value;
+ }
+}
+
+static void
+pattern_vadj_changed (GtkAdjustment *adj,
+ GtkWidget *darea)
+{
+ gint *old_value = g_object_get_data (G_OBJECT (adj), "old-value");
+ gint new_value = adj->value;
+
+ if (GTK_WIDGET_REALIZED (darea))
+ {
+ gdk_window_scroll (darea->window, 0, *old_value - new_value);
+ *old_value = new_value;
+ }
+}
+
+static void
+pattern_realize (GtkWidget *widget,
+ gpointer data)
+{
+ pattern_set_bg (widget, widget->window, 0);
+ create_pattern (widget, widget->window, 1, PATTERN_SIZE, PATTERN_SIZE);
+}
+
+static void
+create_big_windows (void)
+{
+ static GtkWidget *window = NULL;
+ GtkWidget *darea, *table, *scrollbar;
+ GtkWidget *eventbox;
+ GtkAdjustment *hadj;
+ GtkAdjustment *vadj;
+ static gint current_x;
+ static gint current_y;
+
+ if (!window)
+ {
+ current_x = 0;
+ current_y = 0;
+
+ window = gtk_dialog_new_with_buttons ("Big Windows",
+ NULL, 0,
+ GTK_STOCK_CLOSE,
+ GTK_RESPONSE_NONE,
+ NULL);
+
+ gtk_window_set_default_size (GTK_WINDOW (window), 200, 300);
+
+ gtk_signal_connect (GTK_OBJECT (window), "destroy",
+ GTK_SIGNAL_FUNC (gtk_widget_destroyed),
+ &window);
+
+ gtk_signal_connect (GTK_OBJECT (window), "response",
+ GTK_SIGNAL_FUNC (gtk_widget_destroy),
+ NULL);
+
+ table = gtk_table_new (2, 2, FALSE);
+ gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox),
+ table, TRUE, TRUE, 0);
+
+ darea = gtk_drawing_area_new ();
+
+ hadj = (GtkAdjustment *)gtk_adjustment_new (0, 0, PATTERN_SIZE, 10, 100, 100);
+ gtk_signal_connect (GTK_OBJECT (hadj), "value_changed",
+ GTK_SIGNAL_FUNC (pattern_hadj_changed), darea);
+ g_object_set_data (G_OBJECT (hadj), "old-value", ¤t_x);
+
+ vadj = (GtkAdjustment *)gtk_adjustment_new (0, 0, PATTERN_SIZE, 10, 100, 100);
+ gtk_signal_connect (GTK_OBJECT (vadj), "value_changed",
+ GTK_SIGNAL_FUNC (pattern_vadj_changed), darea);
+ g_object_set_data (G_OBJECT (vadj), "old-value", ¤t_y);
+
+ gtk_signal_connect (GTK_OBJECT (darea), "realize",
+ GTK_SIGNAL_FUNC (pattern_realize),
+ NULL);
+ gtk_signal_connect (GTK_OBJECT (darea), "expose_event",
+ GTK_SIGNAL_FUNC (pattern_expose),
+ NULL);
+
+ eventbox = gtk_event_box_new ();
+ gtk_table_attach (GTK_TABLE (table), eventbox,
+ 0, 1, 0, 1,
+ GTK_FILL | GTK_EXPAND, GTK_FILL | GTK_EXPAND,
+ 0, 0);
+
+ gtk_container_add (GTK_CONTAINER (eventbox), darea);
+
+ scrollbar = gtk_hscrollbar_new (hadj);
+ gtk_table_attach (GTK_TABLE (table), scrollbar,
+ 0, 1, 1, 2,
+ GTK_FILL | GTK_EXPAND, GTK_FILL,
+ 0, 0);
+
+ scrollbar = gtk_vscrollbar_new (vadj);
+ gtk_table_attach (GTK_TABLE (table), scrollbar,
+ 1, 2, 0, 1,
+ GTK_FILL, GTK_EXPAND | GTK_FILL,
+ 0, 0);
+
+ }
+
+ if (!GTK_WIDGET_VISIBLE (window))
+ gtk_widget_show_all (window);
+ else
+ gtk_widget_hide (window);
+}
+
/*
* GtkButton
*/
button[0] = gtk_button_new_with_label ("button1");
button[1] = gtk_button_new_with_mnemonic ("_button2");
button[2] = gtk_button_new_with_mnemonic ("_button3");
- button[3] = gtk_button_new_from_stock (GTK_STOCK_BUTTON_OK);
+ button[3] = gtk_button_new_from_stock (GTK_STOCK_OK);
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_from_stock (GTK_STOCK_BUTTON_CLOSE);
+ button[7] = gtk_button_new_from_stock (GTK_STOCK_CLOSE);
button[8] = gtk_button_new_with_label ("button9");
gtk_signal_connect (GTK_OBJECT (button[0]), "clicked",
if (!GTK_WIDGET_VISIBLE (window))
gtk_widget_show_all (window);
else
- gtk_widget_hide (window);
+ gtk_widget_destroy (window);
}
/*
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)),
+ gtk_radio_button_get_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)),
+ gtk_radio_button_get_group (GTK_RADIO_BUTTON (button)),
"button3");
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)),
+ gtk_radio_button_get_group (GTK_RADIO_BUTTON (button)),
"inconsistent");
gtk_toggle_button_set_inconsistent (GTK_TOGGLE_BUTTON (button), TRUE);
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);
+ button = gtk_radio_button_new_with_label (NULL, "button4");
+ gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (button), FALSE);
+ gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
+
+ button = gtk_radio_button_new_with_label (
+ gtk_radio_button_get_group (GTK_RADIO_BUTTON (button)),
+ "button5");
+ gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
+ gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (button), FALSE);
+ gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
+
+ button = gtk_radio_button_new_with_label (
+ gtk_radio_button_get_group (GTK_RADIO_BUTTON (button)),
+ "button6");
+ gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (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);
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), 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)
{
{
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_window_set_resizable (GTK_WINDOW (window), FALSE);
gtk_signal_connect (GTK_OBJECT (window), "destroy",
GTK_SIGNAL_FUNC (gtk_widget_destroyed),
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);
+ toolbar = gtk_toolbar_new ();
gtk_toolbar_insert_stock (GTK_TOOLBAR (toolbar),
GTK_STOCK_NEW,
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_space (GTK_TOOLBAR (toolbar));
gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
- "Borders", "Show Borders", NULL,
+ "Frobate", "Frobate tooltip", NULL,
new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
- (GtkSignalFunc) set_toolbar_borders, toolbar);
+ (GtkSignalFunc) NULL, toolbar);
gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
- "Borderless", "Hide Borders", NULL,
+ "Baz", "Baz tooltip", NULL,
new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
- (GtkSignalFunc) set_toolbar_borderless, toolbar);
+ (GtkSignalFunc) NULL, toolbar);
gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
- "Empty", "Empty spaces", NULL,
+ "Blah", "Blah tooltip", NULL,
new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
- (GtkSignalFunc) set_toolbar_space_style_empty, toolbar);
+ (GtkSignalFunc) NULL, toolbar);
gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
- "Lines", "Lines in spaces", NULL,
+ "Bar", "Bar tooltip", NULL,
new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
- (GtkSignalFunc) set_toolbar_space_style_line, toolbar);
+ (GtkSignalFunc) NULL, toolbar);
gtk_container_add (GTK_CONTAINER (window), 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);
+ toolbar = gtk_toolbar_new ();
gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
"Horizontal", "Horizontal toolbar layout", NULL,
gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
- "Small", "Use small spaces", NULL,
+ "Woot", "Woot woot woot", NULL,
new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
- (GtkSignalFunc) set_toolbar_small_space, toolbar);
+ (GtkSignalFunc) NULL, toolbar);
gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
- "Big", "Use big spaces", "Toolbar/Big",
+ "Blah", "Blah blah blah", "Toolbar/Big",
new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
- (GtkSignalFunc) set_toolbar_big_space, toolbar);
+ (GtkSignalFunc) NULL, toolbar);
gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
- "Borders", "Show Borders", NULL,
+ "Hoo", "Hoo tooltip", NULL,
new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
- (GtkSignalFunc) set_toolbar_borders, toolbar);
+ (GtkSignalFunc) NULL, toolbar);
gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
- "Borderless", "Hide Borders", NULL,
+ "Woo", "Woo tooltip", NULL,
new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
- (GtkSignalFunc) set_toolbar_borderless, toolbar);
+ (GtkSignalFunc) NULL, toolbar);
return toolbar;
}
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)),
+ button = gtk_radio_button_new_with_label(gtk_radio_button_get_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)),
+ button = gtk_radio_button_new_with_label(gtk_radio_button_get_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));
+ sTreeSampleSelection.selection_mode_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (button));
/* create option mode frame */
frame = gtk_frame_new("Options");
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_window_set_resizable (GTK_WINDOW (window), FALSE);
gtk_signal_connect (GTK_OBJECT (window), "destroy",
GTK_SIGNAL_FUNC(gtk_widget_destroyed),
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);
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 (Русский) Здравствуйте!");
+ label = gtk_label_new (NULL);
+ gtk_label_set_markup (GTK_LABEL (label),
+ "French (Français) Bonjour, Salut\n"
+ "Korean (한글) 안녕하세요, 안녕하십니까\n"
+ "Russian (Русский) Здравствуйте!\n"
+ "Chinese (Simplified) <span lang=\"zh-cn\">元气 开发</span>\n"
+ "Chinese (Traditional) <span lang=\"zh-tw\">元氣 開發</span>\n"
+ "Japanese <span lang=\"ja\">元気 開発</span>");
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);
"ContextHelp/buttons/?");
- gtk_widget_set (g_object_connect (tips_query,
- "signal::widget_entered", tips_query_widget_entered, toggle,
- "signal::widget_selected", tips_query_widget_selected, NULL,
- NULL),
- "visible", TRUE,
- "parent", box3,
- "caller", button,
- NULL);
+ g_object_set (g_object_connect (tips_query,
+ "signal::widget_entered", tips_query_widget_entered, toggle,
+ "signal::widget_selected", tips_query_widget_selected, NULL,
+ NULL),
+ "visible", TRUE,
+ "parent", box3,
+ "caller", button,
+ NULL);
frame = gtk_widget_new (gtk_frame_get_type (),
"label", "ToolTips Inspector",
GdkBitmap *mask;
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+ /* this is bogus for testing drawing when allocation < request,
+ * don't copy into real code
+ */
+ gtk_window_set_policy (GTK_WINDOW (window), TRUE, TRUE, FALSE);
gtk_signal_connect (GTK_OBJECT (window), "destroy",
GTK_SIGNAL_FUNC(gtk_widget_destroyed),
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");
+ menuitem = gtk_image_menu_item_new_with_label ("Image item");
+ gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menuitem), image);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
gtk_widget_show (menuitem);
NULL);
accel_group = gtk_accel_group_new ();
- gtk_accel_group_attach (accel_group, GTK_OBJECT (window));
+ gtk_window_add_accel_group (GTK_WINDOW (window), accel_group);
gtk_window_set_title (GTK_WINDOW (window), "menus");
gtk_container_set_border_width (GTK_CONTAINER (window), 0);
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");
+ menuitem = gtk_image_menu_item_new_with_label ("Help");
+ gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menuitem), image);
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_item_set_right_justified (GTK_MENU_ITEM (menuitem), TRUE);
gtk_menu_bar_append (GTK_MENU_BAR (menubar), menuitem);
gtk_widget_show (menuitem);
accel_group,
GDK_F1,
0,
- GTK_ACCEL_VISIBLE | GTK_ACCEL_SIGNAL_VISIBLE);
+ GTK_ACCEL_VISIBLE);
menuitem = gtk_check_menu_item_new_with_label ("Accelerator Locked");
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
gtk_widget_show (menuitem);
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);
guint callback_action,
GtkWidget *widget)
{
- gtk_item_factory_dump_items (NULL, FALSE, gtk_item_factory_print_func, stdout);
+ gtk_accel_map_save_fd (1 /* stdout */);
}
static GtkItemFactoryEntry menu_items[] =
{ "/_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" },
- { "/_Preferences/Shape/_Image", NULL, gtk_ifactory_cb, 0, "<ImageItem>", (gchar**) apple, sizeof(apple) },
+ { "/_Preferences/Shape/_Image", NULL, gtk_ifactory_cb, 0, "<ImageItem>", apple },
/* For testing deletion of menus */
{ "/_Preferences/Should_NotAppear", NULL, 0, 0, "<Branch>" },
"<main>",
item_factory,
(GtkDestroyNotify) gtk_object_unref);
- gtk_accel_group_attach (accel_group, GTK_OBJECT (window));
+ gtk_window_add_accel_group (GTK_WINDOW (window), accel_group);
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);
csd=gtk_color_selection_dialog_new ("This is a modal color selection dialog");
+ gtk_color_selection_set_has_palette (GTK_COLOR_SELECTION (GTK_COLOR_SELECTION_DIALOG (csd)->colorsel),
+ TRUE);
+
/* Set as modal */
gtk_window_set_modal (GTK_WINDOW(csd),TRUE);
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)
}
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)
+entry_props_clicked (GtkWidget *button,
+ GObject *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), '*');
-}
-
+ GtkWidget *window = create_prop_editor (entry, 0);
-static void
-entry_toggle_activate_default (GtkWidget *checkbutton,
- GtkWidget *entry)
-{
- gtk_entry_set_activates_default (GTK_ENTRY (entry),
- GTK_TOGGLE_BUTTON (checkbutton)->active);
+ gtk_window_set_title (GTK_WINDOW (window), "Entry Properties");
}
static void
static GtkWidget *window = NULL;
GtkWidget *box1;
GtkWidget *box2;
- GtkWidget *editable_check;
+ GtkWidget *hbox;
+ GtkWidget *has_frame_check;
GtkWidget *sensitive_check;
- GtkWidget *invisible_char_check;
- GtkWidget *activate_check;
GtkWidget *entry, *cb;
GtkWidget *button;
GtkWidget *separator;
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);
+ hbox = gtk_hbox_new (FALSE, 5);
+ gtk_box_pack_start (GTK_BOX (box2), hbox, TRUE, TRUE, 0);
+
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);
+ gtk_box_pack_start (GTK_BOX (hbox), entry, TRUE, TRUE, 0);
+
+ button = gtk_button_new_with_mnemonic ("_Props");
+ gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0);
+ gtk_signal_connect (GTK_OBJECT (button), "clicked",
+ GTK_SIGNAL_FUNC (entry_props_clicked),
+ 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_entry_set_text (GTK_ENTRY (GTK_COMBO(cb)->entry), "hello world \n\n\n foo");
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);
-
- activate_check = gtk_check_button_new_with_label ("Activates default");
- gtk_box_pack_start (GTK_BOX (box2), activate_check, FALSE, TRUE, 0);
- gtk_signal_connect (GTK_OBJECT (activate_check), "toggled",
- GTK_SIGNAL_FUNC (entry_toggle_activate_default), entry);
- gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (activate_check), FALSE);
- gtk_widget_show (activate_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",
+
+ has_frame_check = gtk_check_button_new_with_label("Has Frame");
+ gtk_box_pack_start (GTK_BOX (box2), has_frame_check, FALSE, TRUE, 0);
+ gtk_signal_connect (GTK_OBJECT(has_frame_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);
+ gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(has_frame_check), TRUE);
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_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);
+ gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
}
+/*
+ * GtkSizeGroup
+ */
+
+#define SIZE_GROUP_INITIAL_SIZE 50
+
+static void
+size_group_hsize_changed (GtkSpinButton *spin_button,
+ GtkWidget *button)
+{
+ gtk_widget_set_usize (GTK_BIN (button)->child,
+ gtk_spin_button_get_value_as_int (spin_button),
+ -2);
+}
+
+static void
+size_group_vsize_changed (GtkSpinButton *spin_button,
+ GtkWidget *button)
+{
+ gtk_widget_set_usize (GTK_BIN (button)->child,
+ -2,
+ gtk_spin_button_get_value_as_int (spin_button));
+}
+
+static GtkWidget *
+create_size_group_window (GtkSizeGroup *master_size_group)
+{
+ GtkWidget *window;
+ GtkWidget *table;
+ GtkWidget *main_button;
+ GtkWidget *button;
+ GtkWidget *spin_button;
+ GtkWidget *hbox;
+ GtkSizeGroup *hgroup1;
+ GtkSizeGroup *hgroup2;
+ GtkSizeGroup *vgroup1;
+ GtkSizeGroup *vgroup2;
+
+ window = gtk_dialog_new_with_buttons ("GtkSizeGroup",
+ NULL, 0,
+ GTK_STOCK_CLOSE,
+ GTK_RESPONSE_NONE,
+ NULL);
+
+ gtk_window_set_resizable (GTK_WINDOW (window), FALSE);
+
+ gtk_signal_connect (GTK_OBJECT (window), "response",
+ GTK_SIGNAL_FUNC (gtk_widget_destroy),
+ NULL);
+
+ table = gtk_table_new (2, 2, FALSE);
+ gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), table, TRUE, TRUE, 0);
+
+ 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), 5);
+ gtk_widget_set_usize (table, 250, 250);
+
+ hgroup1 = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
+ hgroup2 = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
+ vgroup1 = gtk_size_group_new (GTK_SIZE_GROUP_VERTICAL);
+ vgroup2 = gtk_size_group_new (GTK_SIZE_GROUP_VERTICAL);
+
+ main_button = gtk_button_new_with_label ("X");
+
+ gtk_table_attach (GTK_TABLE (table), main_button,
+ 0, 1, 0, 1,
+ GTK_EXPAND, GTK_EXPAND,
+ 0, 0);
+ gtk_size_group_add_widget (master_size_group, main_button);
+ gtk_size_group_add_widget (hgroup1, main_button);
+ gtk_size_group_add_widget (vgroup1, main_button);
+ gtk_widget_set_usize (GTK_BIN (main_button)->child, SIZE_GROUP_INITIAL_SIZE, SIZE_GROUP_INITIAL_SIZE);
+
+ button = gtk_button_new ();
+ gtk_table_attach (GTK_TABLE (table), button,
+ 1, 2, 0, 1,
+ GTK_EXPAND, GTK_EXPAND,
+ 0, 0);
+ gtk_size_group_add_widget (vgroup1, button);
+ gtk_size_group_add_widget (vgroup2, button);
+
+ button = gtk_button_new ();
+ gtk_table_attach (GTK_TABLE (table), button,
+ 0, 1, 1, 2,
+ GTK_EXPAND, GTK_EXPAND,
+ 0, 0);
+ gtk_size_group_add_widget (hgroup1, button);
+ gtk_size_group_add_widget (hgroup2, button);
+
+ button = gtk_button_new ();
+ gtk_table_attach (GTK_TABLE (table), button,
+ 1, 2, 1, 2,
+ GTK_EXPAND, GTK_EXPAND,
+ 0, 0);
+ gtk_size_group_add_widget (hgroup2, button);
+ gtk_size_group_add_widget (vgroup2, button);
+
+ g_object_unref (G_OBJECT (hgroup1));
+ g_object_unref (G_OBJECT (hgroup2));
+ g_object_unref (G_OBJECT (vgroup1));
+ g_object_unref (G_OBJECT (vgroup2));
+
+ hbox = gtk_hbox_new (FALSE, 5);
+ gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), hbox, FALSE, FALSE, 0);
+
+ spin_button = gtk_spin_button_new_with_range (1, 100, 1);
+ gtk_spin_button_set_value (GTK_SPIN_BUTTON (spin_button), SIZE_GROUP_INITIAL_SIZE);
+ gtk_box_pack_start (GTK_BOX (hbox), spin_button, TRUE, TRUE, 0);
+ gtk_signal_connect (GTK_OBJECT (spin_button), "value_changed",
+ GTK_SIGNAL_FUNC (size_group_hsize_changed), main_button);
+
+ spin_button = gtk_spin_button_new_with_range (1, 100, 1);
+ gtk_spin_button_set_value (GTK_SPIN_BUTTON (spin_button), SIZE_GROUP_INITIAL_SIZE);
+ gtk_box_pack_start (GTK_BOX (hbox), spin_button, TRUE, TRUE, 0);
+ gtk_signal_connect (GTK_OBJECT (spin_button), "value_changed",
+ GTK_SIGNAL_FUNC (size_group_vsize_changed), main_button);
+
+ return window;
+}
+
+static void
+create_size_groups (void)
+{
+ static GtkWidget *window1 = NULL;
+ static GtkWidget *window2 = NULL;
+ static GtkSizeGroup *master_size_group;
+
+ if (!master_size_group)
+ master_size_group = gtk_size_group_new (GTK_SIZE_GROUP_BOTH);
+
+ if (!window1)
+ {
+ window1 = create_size_group_window (master_size_group);
+
+ gtk_signal_connect (GTK_OBJECT (window1), "destroy",
+ GTK_SIGNAL_FUNC (gtk_widget_destroyed),
+ &window1);
+ }
+
+ if (!window2)
+ {
+ window2 = create_size_group_window (master_size_group);
+
+ gtk_signal_connect (GTK_OBJECT (window2), "destroy",
+ GTK_SIGNAL_FUNC (gtk_widget_destroyed),
+ &window2);
+ }
+
+ if (GTK_WIDGET_VISIBLE (window1) && GTK_WIDGET_VISIBLE (window2))
+ {
+ gtk_widget_destroy (window1);
+ gtk_widget_destroy (window2);
+ }
+ else
+ {
+ if (!GTK_WIDGET_VISIBLE (window1))
+ gtk_widget_show_all (window1);
+ if (!GTK_WIDGET_VISIBLE (window2))
+ gtk_widget_show_all (window2);
+ }
+}
+
/*
* GtkSpinButton
*/
gtk_label_set_text (label, buf);
}
+static void
+get_spin_value (GtkWidget *widget, gpointer data)
+{
+ gchar *buffer;
+ GtkLabel *label;
+ GtkSpinButton *spin;
+
+ spin = GTK_SPIN_BUTTON (widget);
+ label = GTK_LABEL (data);
+
+ buffer = g_strdup_printf ("%0.*f", spin->digits,
+ gtk_spin_button_get_value_as_float (spin));
+ gtk_label_set_text (label, buffer);
+
+ g_free (buffer);
+}
+
static gint
spin_button_time_output_func (GtkSpinButton *spin_button)
{
spin_button_hex_input_func (GtkSpinButton *spin_button,
gdouble *new_val)
{
- gchar *buf;
+ const gchar *buf;
gchar *err;
gdouble res;
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);
+ adj = (GtkAdjustment *) gtk_adjustment_new (2, 1, 15, 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),
gtk_box_pack_start (GTK_BOX (vbox), val_label, TRUE, TRUE, 0);
gtk_label_set_text (GTK_LABEL (val_label), "0");
+ frame = gtk_frame_new ("Using Convenience Constructor");
+ gtk_box_pack_start (GTK_BOX (main_vbox), frame, TRUE, TRUE, 0);
+
+ hbox = gtk_hbox_new (FALSE, 0);
+ gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
+ gtk_container_add (GTK_CONTAINER (frame), hbox);
+
+ val_label = gtk_label_new ("0.0");
+
+ spinner = gtk_spin_button_new_with_range (0.0, 10.0, 0.009);
+ gtk_spin_button_set_value (GTK_SPIN_BUTTON (spinner), 0.0);
+ gtk_signal_connect (GTK_OBJECT (spinner), "value_changed",
+ GTK_SIGNAL_FUNC (get_spin_value), val_label);
+ gtk_box_pack_start (GTK_BOX (hbox), spinner, TRUE, TRUE, 5);
+ gtk_box_pack_start (GTK_BOX (hbox), val_label, TRUE, TRUE, 5);
+
hbox = gtk_hbox_new (FALSE, 0);
gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, TRUE, 0);
c &= 0xfe;
label = gtk_object_get_user_data (GTK_OBJECT (spinner));
- vals = gtk_type_enum_get_values (GTK_TYPE_GDK_CURSOR_TYPE);
+ vals = gtk_type_enum_get_values (GDK_TYPE_CURSOR_TYPE);
while (vals && vals->value != c)
vals++;
if (vals)
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)
+list_toggle_sel_mode (GtkWidget *widget, gpointer data)
{
+ GtkList *list;
gint i;
+ list = GTK_LIST (data);
+
if (!GTK_WIDGET_MAPPED (widget))
return;
- RADIOMENUTOGGLED ((GtkRadioMenuItem *)
- (((GtkOptionMenu *)list_omenu)->menu_item), i);
+ i = gtk_option_menu_get_history (GTK_OPTION_MENU (widget));
- gtk_list_set_selection_mode (list, (GtkSelectionMode) (3-i));
+ gtk_list_set_selection_mode (list, (GtkSelectionMode) i);
}
static void
{
static GtkWidget *window = NULL;
- static OptionMenuItem items[] =
+ static gchar *items[] =
{
- { "Single", GTK_SIGNAL_FUNC (list_toggle_sel_mode) },
- { "Browse", GTK_SIGNAL_FUNC (list_toggle_sel_mode) },
- { "Multiple", GTK_SIGNAL_FUNC (list_toggle_sel_mode) },
- { "Extended", GTK_SIGNAL_FUNC (list_toggle_sel_mode) }
+ "Single",
+ "Browse",
+ "Multiple"
};
if (!window)
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);
+ list_omenu = build_option_menu (items, 3, 3,
+ list_toggle_sel_mode,
+ list);
gtk_box_pack_start (GTK_BOX (hbox), list_omenu, FALSE, TRUE, 0);
separator = gtk_hseparator_new ();
}
static void
-clist_toggle_sel_mode (GtkWidget *widget, GtkCList *clist)
+clist_toggle_sel_mode (GtkWidget *widget, gpointer data)
{
+ GtkCList *clist;
gint i;
+ clist = GTK_CLIST (data);
+
if (!GTK_WIDGET_MAPPED (widget))
return;
- RADIOMENUTOGGLED ((GtkRadioMenuItem *)
- (((GtkOptionMenu *)clist_omenu)->menu_item), i);
+ i = gtk_option_menu_get_history (GTK_OPTION_MENU (widget));
- gtk_clist_set_selection_mode (clist, (GtkSelectionMode) (3-i));
+ gtk_clist_set_selection_mode (clist, (GtkSelectionMode) i);
}
static void
"Title 8", "Title 9", "Title 10", "Title 11"
};
- static OptionMenuItem items[] =
+ static gchar *items[] =
{
- { "Single", GTK_SIGNAL_FUNC (clist_toggle_sel_mode) },
- { "Browse", GTK_SIGNAL_FUNC (clist_toggle_sel_mode) },
- { "Multiple", GTK_SIGNAL_FUNC (clist_toggle_sel_mode) },
- { "Extended", GTK_SIGNAL_FUNC (clist_toggle_sel_mode) }
+ "Single",
+ "Browse",
+ "Multiple",
};
char text[TESTGTK_CLIST_COLUMNS][50];
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);
+ clist_omenu = build_option_menu (items, 3, 3,
+ clist_toggle_sel_mode,
+ clist);
gtk_box_pack_start (GTK_BOX (hbox), clist_omenu, FALSE, TRUE, 0);
/*
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;
+ pango_font_description_set_size (style->font_desc, 14 * PANGO_SCALE);
+ pango_font_description_set_weight (style->font_desc, PANGO_WEIGHT_BOLD);
for (i = 0; i < 10; i++)
{
gtk_ctree_node_set_row_style (ctree, node, style);
}
-void ctree_toggle_line_style (GtkWidget *widget, GtkCTree *ctree)
+void
+ctree_toggle_line_style (GtkWidget *widget, gpointer data)
{
+ GtkCTree *ctree;
gint i;
+ ctree = GTK_CTREE (data);
+
if (!GTK_WIDGET_MAPPED (widget))
return;
- RADIOMENUTOGGLED ((GtkRadioMenuItem *)
- (((GtkOptionMenu *)omenu1)->menu_item), i);
-
+ i = gtk_option_menu_get_history (GTK_OPTION_MENU (widget));
+
if ((ctree->line_style == GTK_CTREE_LINES_TABBED &&
- ((GtkCTreeLineStyle) (3 - i)) != GTK_CTREE_LINES_TABBED) ||
+ ((GtkCTreeLineStyle) i) != GTK_CTREE_LINES_TABBED) ||
(ctree->line_style != GTK_CTREE_LINES_TABBED &&
- ((GtkCTreeLineStyle) (3 - i)) == GTK_CTREE_LINES_TABBED))
+ ((GtkCTreeLineStyle) 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;
+ gtk_ctree_set_line_style (ctree, i);
+ line_style = i;
}
-void ctree_toggle_expander_style (GtkWidget *widget, GtkCTree *ctree)
+void
+ctree_toggle_expander_style (GtkWidget *widget, gpointer data)
{
+ GtkCTree *ctree;
gint i;
+ ctree = GTK_CTREE (data);
+
if (!GTK_WIDGET_MAPPED (widget))
return;
-
- RADIOMENUTOGGLED ((GtkRadioMenuItem *)
- (((GtkOptionMenu *)omenu2)->menu_item), i);
- gtk_ctree_set_expander_style (ctree, (GtkCTreeExpanderStyle) (3 - i));
+ i = gtk_option_menu_get_history (GTK_OPTION_MENU (widget));
+
+ gtk_ctree_set_expander_style (ctree, (GtkCTreeExpanderStyle) i);
}
-void ctree_toggle_justify (GtkWidget *widget, GtkCTree *ctree)
+void
+ctree_toggle_justify (GtkWidget *widget, gpointer data)
{
+ GtkCTree *ctree;
gint i;
+ ctree = GTK_CTREE (data);
+
if (!GTK_WIDGET_MAPPED (widget))
return;
- RADIOMENUTOGGLED ((GtkRadioMenuItem *)
- (((GtkOptionMenu *)omenu3)->menu_item), i);
+ i = gtk_option_menu_get_history (GTK_OPTION_MENU (widget));
gtk_clist_set_column_justification (GTK_CLIST (ctree), ctree->tree_column,
- (GtkJustification) (1 - i));
+ (GtkJustification) i);
}
-void ctree_toggle_sel_mode (GtkWidget *widget, GtkCTree *ctree)
+void
+ctree_toggle_sel_mode (GtkWidget *widget, gpointer data)
{
+ GtkCTree *ctree;
gint i;
+ ctree = GTK_CTREE (data);
+
if (!GTK_WIDGET_MAPPED (widget))
return;
- RADIOMENUTOGGLED ((GtkRadioMenuItem *)
- (((GtkOptionMenu *)omenu4)->menu_item), i);
+ i = gtk_option_menu_get_history (GTK_OPTION_MENU (widget));
- gtk_clist_set_selection_mode (GTK_CLIST (ctree), (GtkSelectionMode) (3 - i));
+ gtk_clist_set_selection_mode (GTK_CLIST (ctree), (GtkSelectionMode) i);
after_press (ctree, NULL);
}
char *title[] = { "Tree" , "Info" };
char buf[80];
- static OptionMenuItem items1[] =
+ static gchar *items1[] =
{
- { "No lines", GTK_SIGNAL_FUNC (ctree_toggle_line_style) },
- { "Solid", GTK_SIGNAL_FUNC (ctree_toggle_line_style) },
- { "Dotted", GTK_SIGNAL_FUNC (ctree_toggle_line_style) },
- { "Tabbed", GTK_SIGNAL_FUNC (ctree_toggle_line_style) }
+ "No lines",
+ "Solid",
+ "Dotted",
+ "Tabbed"
};
- static OptionMenuItem items2[] =
+ static gchar *items2[] =
{
- { "None", GTK_SIGNAL_FUNC (ctree_toggle_expander_style) },
- { "Square", GTK_SIGNAL_FUNC (ctree_toggle_expander_style) },
- { "Triangle", GTK_SIGNAL_FUNC (ctree_toggle_expander_style) },
- { "Circular", GTK_SIGNAL_FUNC (ctree_toggle_expander_style) }
+ "None",
+ "Square",
+ "Triangle",
+ "Circular"
};
- static OptionMenuItem items3[] =
+ static gchar *items3[] =
{
- { "Left", GTK_SIGNAL_FUNC (ctree_toggle_justify) },
- { "Right", GTK_SIGNAL_FUNC (ctree_toggle_justify) }
+ "Left",
+ "Right"
};
-
- static OptionMenuItem items4[] =
+
+ static gchar *items4[] =
{
- { "Single", GTK_SIGNAL_FUNC (ctree_toggle_sel_mode) },
- { "Browse", GTK_SIGNAL_FUNC (ctree_toggle_sel_mode) },
- { "Multiple", GTK_SIGNAL_FUNC (ctree_toggle_sel_mode) },
- { "Extended", GTK_SIGNAL_FUNC (ctree_toggle_sel_mode) }
+ "Single",
+ "Browse",
+ "Multiple",
};
if (!window)
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);
+ omenu1 = build_option_menu (items1, 4, 2,
+ ctree_toggle_line_style,
+ 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);
+ omenu2 = build_option_menu (items2, 4, 1,
+ ctree_toggle_expander_style,
+ 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);
+ omenu3 = build_option_menu (items3, 2, 0,
+ ctree_toggle_justify, 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);
+ omenu4 = build_option_menu (items4, 3, 3,
+ ctree_toggle_sel_mode, ctree);
gtk_box_pack_start (GTK_BOX (hbox), omenu4, FALSE, TRUE, 0);
gtk_tooltips_set_tip (tooltips, omenu4, "The list's selection mode.",
NULL);
GtkColorSelection *colorsel;
colorsel = GTK_COLOR_SELECTION (cs->colorsel);
- gtk_color_selection_set_use_opacity (colorsel,
- gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (w)));
+ gtk_color_selection_set_has_opacity_control (colorsel,
+ gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (w)));
}
static void
GtkColorSelection *colorsel;
colorsel = GTK_COLOR_SELECTION (cs->colorsel);
- gtk_color_selection_set_use_palette (colorsel,
+ gtk_color_selection_set_has_palette (colorsel,
gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (w)));
}
GtkWidget *check_button;
window = gtk_color_selection_dialog_new ("color selection dialog");
+ gtk_widget_show (GTK_COLOR_SELECTION_DIALOG (window)->help_button);
gtk_window_set_position (GTK_WINDOW (window), GTK_WIN_POS_MOUSE);
window = gtk_dialog_new_with_buttons ("Keyboard focus navigation",
NULL, 0,
- GTK_STOCK_BUTTON_CLOSE,
+ GTK_STOCK_CLOSE,
GTK_RESPONSE_NONE,
NULL);
* GtkRange
*/
+static gchar*
+reformat_value (GtkScale *scale,
+ gdouble value)
+{
+ return g_strdup_printf ("-->%0.*g<--",
+ gtk_scale_get_digits (scale), value);
+}
+
static void
create_range_controls (void)
{
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_widget_set_usize (GTK_WIDGET (scale), 150, -1);
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), scrollbar, TRUE, TRUE, 0);
gtk_widget_show (scrollbar);
+ scale = gtk_hscale_new (GTK_ADJUSTMENT (adjustment));
+ gtk_scale_set_draw_value (GTK_SCALE (scale), TRUE);
+ gtk_signal_connect (GTK_OBJECT (scale),
+ "format_value",
+ GTK_SIGNAL_FUNC (reformat_value),
+ NULL);
+ gtk_box_pack_start (GTK_BOX (box2), scale, TRUE, TRUE, 0);
+ gtk_widget_show (scale);
+
hbox = gtk_hbox_new (FALSE, 0);
scale = gtk_vscale_new (GTK_ADJUSTMENT (adjustment));
gtk_range_set_inverted (GTK_RANGE (scale), TRUE);
gtk_box_pack_start (GTK_BOX (hbox), scale, TRUE, TRUE, 0);
gtk_widget_show (scale);
+
+ scale = gtk_vscale_new (GTK_ADJUSTMENT (adjustment));
+ gtk_scale_set_draw_value (GTK_SCALE (scale), TRUE);
+ gtk_signal_connect (GTK_OBJECT (scale),
+ "format_value",
+ GTK_SIGNAL_FUNC (reformat_value),
+ NULL);
+ gtk_box_pack_start (GTK_BOX (hbox), scale, TRUE, TRUE, 0);
+ gtk_widget_show (scale);
+
gtk_box_pack_start (GTK_BOX (box2), hbox, TRUE, TRUE, 0);
gtk_widget_show (hbox);
-
+
separator = gtk_hseparator_new ();
gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
gtk_widget_show (separator);
}
static void
-standard_notebook (GtkButton *button,
- GtkNotebook *notebook)
+notebook_type_changed (GtkWidget *optionmenu,
+ gpointer data)
{
- 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);
-}
+ GtkNotebook *notebook;
+ gint i, c;
-static void
-notabs_notebook (GtkButton *button,
- GtkNotebook *notebook)
-{
- gint i;
+ enum {
+ STANDARD,
+ NOTABS,
+ BORDERLESS,
+ SCROLLABLE
+ };
- 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);
-}
+ notebook = GTK_NOTEBOOK (data);
-static void
-borderless_notebook (GtkButton *button,
- GtkNotebook *notebook)
-{
- gint i;
+ c = gtk_option_menu_get_history (GTK_OPTION_MENU (optionmenu));
- gtk_notebook_set_show_tabs (notebook, FALSE);
- gtk_notebook_set_show_border (notebook, FALSE);
+ switch (c)
+ {
+ case STANDARD:
+ /* standard notebook */
+ gtk_notebook_set_show_tabs (notebook, TRUE);
+ gtk_notebook_set_show_border (notebook, TRUE);
+ gtk_notebook_set_scrollable (notebook, FALSE);
+ break;
+
+ case NOTABS:
+ /* notabs notebook */
+ gtk_notebook_set_show_tabs (notebook, FALSE);
+ gtk_notebook_set_show_border (notebook, TRUE);
+ break;
+
+ case BORDERLESS:
+ /* borderless */
+ gtk_notebook_set_show_tabs (notebook, FALSE);
+ gtk_notebook_set_show_border (notebook, FALSE);
+ break;
+
+ case SCROLLABLE:
+ /* scrollable */
+ 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);
+
+ return;
+ break;
+ }
+
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)
GdkColor *transparent = NULL;
GtkWidget *label;
- static OptionMenuItem items[] =
+ static gchar *items[] =
{
- { "Standard", GTK_SIGNAL_FUNC (standard_notebook) },
- { "No tabs", GTK_SIGNAL_FUNC (notabs_notebook) },
- { "Borderless", GTK_SIGNAL_FUNC (borderless_notebook) },
- { "Scrollable", GTK_SIGNAL_FUNC (scrollable_notebook) },
+ "Standard",
+ "No tabs",
+ "Borderless",
+ "Scrollable"
};
if (!window)
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);
+ omenu = build_option_menu (items, G_N_ELEMENTS (items), 0,
+ notebook_type_changed,
+ sample_notebook);
gtk_box_pack_start (GTK_BOX (box2), omenu, FALSE, TRUE, 0);
button = gtk_button_new_with_label ("Show all Pages");
gtk_widget_unref (child);
}
+static void
+paned_props_clicked (GtkWidget *button,
+ GObject *paned)
+{
+ GtkWidget *window = create_prop_editor (paned, GTK_TYPE_PANED);
+
+ gtk_window_set_title (GTK_WINDOW (window), "Paned Properties");
+}
+
GtkWidget *
-create_pane_options (GtkPaned *paned,
+create_pane_options (GtkPaned *paned,
const gchar *frame_label,
const gchar *label1,
const gchar *label2)
GtkWidget *frame;
GtkWidget *table;
GtkWidget *label;
+ GtkWidget *button;
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);
+ table = gtk_table_new (4, 2, 4);
gtk_container_add (GTK_CONTAINER (frame), table);
label = gtk_label_new (label1);
GTK_SIGNAL_FUNC (toggle_shrink),
paned->child2);
+ button = gtk_button_new_with_mnemonic ("_Properties");
+ gtk_table_attach_defaults (GTK_TABLE (table), button,
+ 0, 2, 3, 4);
+ gtk_signal_connect (GTK_OBJECT (button), "clicked",
+ GTK_SIGNAL_FUNC (paned_props_clicked),
+ paned);
+
return frame;
}
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_TOPLEVEL);
- 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
*/
GtkWidget *button;
hbox = gtk_hbox_new (FALSE, 5);
-
+
gtk_signal_connect_object (GTK_OBJECT (hbox),
"destroy",
GTK_SIGNAL_FUNC (gtk_widget_destroy),
GTK_OBJECT (window));
-
+
label = gtk_label_new ("<no window state events received>");
gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
gtk_container_add (GTK_CONTAINER (window), box1);
iconified = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+ gtk_signal_connect_object (GTK_OBJECT (iconified), "destroy",
+ GTK_SIGNAL_FUNC(gtk_widget_destroy),
+ GTK_OBJECT (window));
gtk_window_iconify (GTK_WINDOW (iconified));
gtk_window_set_title (GTK_WINDOW (iconified), "Iconified initially");
controls = get_state_controls (iconified);
gtk_container_add (GTK_CONTAINER (iconified), controls);
normal = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+ gtk_signal_connect_object (GTK_OBJECT (normal), "destroy",
+ GTK_SIGNAL_FUNC(gtk_widget_destroy),
+ GTK_OBJECT (window));
+
gtk_window_set_title (GTK_WINDOW (normal), "Deiconified initially");
controls = get_state_controls (normal);
gtk_container_add (GTK_CONTAINER (normal), controls);
}
/*
- * GtkProgressBar
+ * Window sizing
*/
-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)
+static gint
+configure_event_callback (GtkWidget *widget,
+ GdkEventConfigure *event,
+ gpointer data)
{
- gdouble new_val;
- GtkAdjustment *adj;
-
- adj = GTK_PROGRESS (data)->adjustment;
+ GtkWidget *label = data;
+ gchar *msg;
+ gint x, y;
+
+ gtk_window_get_position (GTK_WINDOW (widget), &x, &y);
+
+ msg = g_strdup_printf ("event: %d,%d %d x %d\n"
+ "position: %d, %d",
+ event->x, event->y, event->width, event->height,
+ x, y);
+
+ gtk_label_set_text (GTK_LABEL (label), msg);
- new_val = adj->value + 1;
- if (new_val > adj->upper)
- new_val = adj->lower;
+ g_free (msg);
- gtk_progress_set_value (GTK_PROGRESS (data), new_val);
+ return FALSE;
+}
+
+static void
+get_ints (GtkWidget *window,
+ gint *a,
+ gint *b)
+{
+ GtkWidget *spin1;
+ GtkWidget *spin2;
+
+ spin1 = g_object_get_data (G_OBJECT (window), "spin1");
+ spin2 = g_object_get_data (G_OBJECT (window), "spin2");
+
+ *a = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (spin1));
+ *b = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (spin2));
+}
+
+static void
+set_size_callback (GtkWidget *widget,
+ gpointer data)
+{
+ gint w, h;
+
+ get_ints (data, &w, &h);
+
+ gtk_window_resize (GTK_WINDOW (g_object_get_data (data, "target")), w, h);
+}
+
+static void
+unset_default_size_callback (GtkWidget *widget,
+ gpointer data)
+{
+ gtk_window_set_default_size (g_object_get_data (data, "target"),
+ -1, -1);
+}
+
+static void
+set_default_size_callback (GtkWidget *widget,
+ gpointer data)
+{
+ gint w, h;
+
+ get_ints (data, &w, &h);
+
+ gtk_window_set_default_size (g_object_get_data (data, "target"),
+ w, h);
+}
+
+static void
+unset_usize_callback (GtkWidget *widget,
+ gpointer data)
+{
+ gtk_widget_set_size_request (g_object_get_data (data, "target"),
+ -1, -1);
+}
+
+static void
+set_usize_callback (GtkWidget *widget,
+ gpointer data)
+{
+ gint w, h;
+
+ get_ints (data, &w, &h);
+
+ gtk_widget_set_size_request (g_object_get_data (data, "target"),
+ w, h);
+}
+
+static void
+set_location_callback (GtkWidget *widget,
+ gpointer data)
+{
+ gint x, y;
+
+ get_ints (data, &x, &y);
+
+ gtk_window_move (g_object_get_data (data, "target"), x, y);
+}
+
+static void
+move_to_position_callback (GtkWidget *widget,
+ gpointer data)
+{
+ gint x, y;
+ GtkWindow *window;
+
+ window = g_object_get_data (data, "target");
+
+ gtk_window_get_position (window, &x, &y);
+
+ gtk_window_move (window, x, y);
+}
+
+static void
+set_geometry_callback (GtkWidget *entry,
+ gpointer data)
+{
+ gchar *text;
+ GtkWindow *target;
+
+ target = GTK_WINDOW (g_object_get_data (G_OBJECT (data), "target"));
+
+ text = gtk_editable_get_chars (GTK_EDITABLE (entry), 0, -1);
+
+ if (!gtk_window_parse_geometry (target, text))
+ g_print ("Bad geometry string '%s'\n", text);
+
+ g_free (text);
+}
+
+static void
+allow_shrink_callback (GtkWidget *widget,
+ gpointer data)
+{
+ g_object_set (G_OBJECT (g_object_get_data (data, "target")),
+ "allow_shrink",
+ GTK_TOGGLE_BUTTON (widget)->active,
+ NULL);
+}
+
+static void
+allow_grow_callback (GtkWidget *widget,
+ gpointer data)
+{
+ g_object_set (G_OBJECT (g_object_get_data (data, "target")),
+ "allow_grow",
+ GTK_TOGGLE_BUTTON (widget)->active,
+ NULL);
+}
+
+static void
+auto_shrink_callback (GtkWidget *widget,
+ gpointer data)
+{
+ g_object_set (G_OBJECT (g_object_get_data (data, "target")),
+ "auto_shrink",
+ GTK_TOGGLE_BUTTON (widget)->active,
+ NULL);
+}
+
+static void
+gravity_selected (GtkWidget *widget,
+ gpointer data)
+{
+ gtk_window_set_gravity (GTK_WINDOW (g_object_get_data (data, "target")),
+ gtk_option_menu_get_history (GTK_OPTION_MENU (widget)) + GDK_GRAVITY_NORTH_WEST);
+}
+
+static void
+pos_selected (GtkWidget *widget,
+ gpointer data)
+{
+ gtk_window_set_position (GTK_WINDOW (g_object_get_data (data, "target")),
+ gtk_option_menu_get_history (GTK_OPTION_MENU (widget)) + GTK_WIN_POS_NONE);
+}
+
+static void
+move_gravity_window_to_current_position (GtkWidget *widget,
+ gpointer data)
+{
+ gint x, y;
+ GtkWindow *window;
+
+ window = GTK_WINDOW (data);
+
+ gtk_window_get_position (window, &x, &y);
+
+ gtk_window_move (window, x, y);
+}
+
+static void
+get_screen_corner (GtkWindow *window,
+ gint *x,
+ gint *y)
+{
+ int w, h;
+
+ gtk_window_get_size (GTK_WINDOW (window), &w, &h);
+
+ switch (gtk_window_get_gravity (window))
+ {
+ case GDK_GRAVITY_SOUTH_EAST:
+ *x = gdk_screen_width () - w;
+ *y = gdk_screen_height () - h;
+ break;
+
+ case GDK_GRAVITY_NORTH_EAST:
+ *x = gdk_screen_width () - w;
+ *y = 0;
+ break;
+
+ case GDK_GRAVITY_SOUTH_WEST:
+ *x = 0;
+ *y = gdk_screen_height () - h;
+ break;
+
+ case GDK_GRAVITY_NORTH_WEST:
+ *x = 0;
+ *y = 0;
+ break;
+
+ case GDK_GRAVITY_SOUTH:
+ *x = (gdk_screen_width () - w) / 2;
+ *y = gdk_screen_height () - h;
+ break;
+
+ case GDK_GRAVITY_NORTH:
+ *x = (gdk_screen_width () - w) / 2;
+ *y = 0;
+ break;
+
+ case GDK_GRAVITY_WEST:
+ *x = 0;
+ *y = (gdk_screen_height () - h) / 2;
+ break;
+
+ case GDK_GRAVITY_EAST:
+ *x = gdk_screen_width () - w;
+ *y = (gdk_screen_height () - h) / 2;
+ break;
+
+ case GDK_GRAVITY_CENTER:
+ *x = (gdk_screen_width () - w) / 2;
+ *y = (gdk_screen_height () - h) / 2;
+ break;
+
+ case GDK_GRAVITY_STATIC:
+ /* pick some random numbers */
+ *x = 350;
+ *y = 350;
+ break;
+
+ default:
+ g_assert_not_reached ();
+ break;
+ }
+}
+
+static void
+move_gravity_window_to_starting_position (GtkWidget *widget,
+ gpointer data)
+{
+ gint x, y;
+ GtkWindow *window;
+
+ window = GTK_WINDOW (data);
+
+ get_screen_corner (window,
+ &x, &y);
+
+ gtk_window_move (window, x, y);
+}
+
+static GtkWidget*
+make_gravity_window (GtkWidget *destroy_with,
+ GdkGravity gravity,
+ const gchar *title)
+{
+ GtkWidget *window;
+ GtkWidget *button;
+ GtkWidget *vbox;
+ int x, y;
+
+ window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+
+ vbox = gtk_vbox_new (FALSE, 0);
+ gtk_widget_show (vbox);
+
+ gtk_container_add (GTK_CONTAINER (window), vbox);
+ gtk_window_set_title (GTK_WINDOW (window), title);
+ gtk_window_set_gravity (GTK_WINDOW (window), gravity);
+
+ gtk_signal_connect_object (GTK_OBJECT (destroy_with),
+ "destroy",
+ GTK_SIGNAL_FUNC (gtk_widget_destroy),
+ GTK_OBJECT (window));
+
+
+ button = gtk_button_new_with_mnemonic ("_Move to current position");
+
+ g_signal_connect (G_OBJECT (button), "clicked",
+ G_CALLBACK (move_gravity_window_to_current_position),
+ window);
+
+ gtk_container_add (GTK_CONTAINER (vbox), button);
+ gtk_widget_show (button);
+
+ button = gtk_button_new_with_mnemonic ("Move to _starting position");
+
+ g_signal_connect (G_OBJECT (button), "clicked",
+ G_CALLBACK (move_gravity_window_to_starting_position),
+ window);
+
+ gtk_container_add (GTK_CONTAINER (vbox), button);
+ gtk_widget_show (button);
+
+ /* Pretend this is the result of --geometry.
+ * DO NOT COPY THIS CODE unless you are setting --geometry results,
+ * and in that case you probably should just use gtk_window_parse_geometry().
+ * AGAIN, DO NOT SET GDK_HINT_USER_POS! It violates the ICCCM unless
+ * you are parsing --geometry or equivalent.
+ */
+ gtk_window_set_geometry_hints (GTK_WINDOW (window),
+ NULL, NULL,
+ GDK_HINT_USER_POS);
+
+ gtk_window_set_default_size (GTK_WINDOW (window),
+ 200, 200);
+
+ get_screen_corner (GTK_WINDOW (window), &x, &y);
+
+ gtk_window_move (GTK_WINDOW (window),
+ x, y);
+
+ return window;
+}
+
+static void
+do_gravity_test (GtkWidget *widget,
+ gpointer data)
+{
+ GtkWidget *destroy_with = data;
+ GtkWidget *window;
+
+ /* We put a window at each gravity point on the screen. */
+ window = make_gravity_window (destroy_with, GDK_GRAVITY_NORTH_WEST,
+ "NorthWest");
+ gtk_widget_show (window);
+
+ window = make_gravity_window (destroy_with, GDK_GRAVITY_SOUTH_EAST,
+ "SouthEast");
+ gtk_widget_show (window);
+
+ window = make_gravity_window (destroy_with, GDK_GRAVITY_NORTH_EAST,
+ "NorthEast");
+ gtk_widget_show (window);
+
+ window = make_gravity_window (destroy_with, GDK_GRAVITY_SOUTH_WEST,
+ "SouthWest");
+ gtk_widget_show (window);
+
+ window = make_gravity_window (destroy_with, GDK_GRAVITY_SOUTH,
+ "South");
+ gtk_widget_show (window);
+
+ window = make_gravity_window (destroy_with, GDK_GRAVITY_NORTH,
+ "North");
+ gtk_widget_show (window);
+
+
+ window = make_gravity_window (destroy_with, GDK_GRAVITY_WEST,
+ "West");
+ gtk_widget_show (window);
+
+
+ window = make_gravity_window (destroy_with, GDK_GRAVITY_EAST,
+ "East");
+ gtk_widget_show (window);
+
+ window = make_gravity_window (destroy_with, GDK_GRAVITY_CENTER,
+ "Center");
+ gtk_widget_show (window);
+
+ window = make_gravity_window (destroy_with, GDK_GRAVITY_STATIC,
+ "Static");
+ gtk_widget_show (window);
+}
+
+static GtkWidget*
+window_controls (GtkWidget *window)
+{
+ GtkWidget *control_window;
+ GtkWidget *label;
+ GtkWidget *vbox;
+ GtkWidget *button;
+ GtkWidget *spin;
+ GtkAdjustment *adj;
+ GtkWidget *entry;
+ GtkWidget *om;
+ GtkWidget *menu;
+ gint i;
+
+ control_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+
+ gtk_window_set_title (GTK_WINDOW (control_window), "Size controls");
+
+ g_object_set_data (G_OBJECT (control_window),
+ "target",
+ window);
+
+ gtk_signal_connect_object (GTK_OBJECT (control_window),
+ "destroy",
+ GTK_SIGNAL_FUNC (gtk_widget_destroy),
+ GTK_OBJECT (window));
+
+ vbox = gtk_vbox_new (FALSE, 5);
+
+ gtk_container_add (GTK_CONTAINER (control_window), vbox);
+
+ label = gtk_label_new ("<no configure events>");
+ gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
+
+ gtk_signal_connect (GTK_OBJECT (window),
+ "configure_event",
+ GTK_SIGNAL_FUNC (configure_event_callback),
+ label);
+
+ adj = (GtkAdjustment *) gtk_adjustment_new (10.0, -2000.0, 2000.0, 1.0,
+ 5.0, 0.0);
+ spin = gtk_spin_button_new (adj, 0, 0);
+
+ gtk_box_pack_start (GTK_BOX (vbox), spin, FALSE, FALSE, 0);
+
+ g_object_set_data (G_OBJECT (control_window), "spin1", spin);
+
+ adj = (GtkAdjustment *) gtk_adjustment_new (10.0, -2000.0, 2000.0, 1.0,
+ 5.0, 0.0);
+ spin = gtk_spin_button_new (adj, 0, 0);
+
+ gtk_box_pack_start (GTK_BOX (vbox), spin, FALSE, FALSE, 0);
+
+ g_object_set_data (G_OBJECT (control_window), "spin2", spin);
+
+ entry = gtk_entry_new ();
+ gtk_box_pack_start (GTK_BOX (vbox), entry, FALSE, FALSE, 0);
+
+ gtk_signal_connect (GTK_OBJECT (entry), "changed",
+ GTK_SIGNAL_FUNC (set_geometry_callback),
+ control_window);
+
+ button = gtk_button_new_with_label ("Show gravity test windows");
+ gtk_signal_connect_object (GTK_OBJECT (button),
+ "clicked",
+ GTK_SIGNAL_FUNC (do_gravity_test),
+ control_window);
+ gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
+
+ button = gtk_button_new_with_label ("Reshow with initial size");
+ gtk_signal_connect_object (GTK_OBJECT (button),
+ "clicked",
+ GTK_SIGNAL_FUNC (gtk_window_reshow_with_initial_size),
+ GTK_OBJECT (window));
+ gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
+
+ button = gtk_button_new_with_label ("Queue resize");
+ gtk_signal_connect_object (GTK_OBJECT (button),
+ "clicked",
+ GTK_SIGNAL_FUNC (gtk_widget_queue_resize),
+ GTK_OBJECT (window));
+ gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
+
+ button = gtk_button_new_with_label ("Resize");
+ gtk_signal_connect (GTK_OBJECT (button),
+ "clicked",
+ GTK_SIGNAL_FUNC (set_size_callback),
+ GTK_OBJECT (control_window));
+ gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
+
+ button = gtk_button_new_with_label ("Set default size");
+ gtk_signal_connect (GTK_OBJECT (button),
+ "clicked",
+ GTK_SIGNAL_FUNC (set_default_size_callback),
+ GTK_OBJECT (control_window));
+ gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
+
+ button = gtk_button_new_with_label ("Unset default size");
+ gtk_signal_connect (GTK_OBJECT (button),
+ "clicked",
+ GTK_SIGNAL_FUNC (unset_default_size_callback),
+ GTK_OBJECT (control_window));
+ gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
+
+ button = gtk_button_new_with_label ("Set size request");
+ gtk_signal_connect (GTK_OBJECT (button),
+ "clicked",
+ GTK_SIGNAL_FUNC (set_usize_callback),
+ GTK_OBJECT (control_window));
+ gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
+
+ button = gtk_button_new_with_label ("Unset size request");
+ gtk_signal_connect (GTK_OBJECT (button),
+ "clicked",
+ GTK_SIGNAL_FUNC (unset_usize_callback),
+ GTK_OBJECT (control_window));
+ gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
+
+ button = gtk_button_new_with_label ("Move");
+ gtk_signal_connect (GTK_OBJECT (button),
+ "clicked",
+ GTK_SIGNAL_FUNC (set_location_callback),
+ GTK_OBJECT (control_window));
+ gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
+
+ button = gtk_button_new_with_label ("Move to current position");
+ gtk_signal_connect (GTK_OBJECT (button),
+ "clicked",
+ GTK_SIGNAL_FUNC (move_to_position_callback),
+ GTK_OBJECT (control_window));
+ gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
+
+ button = gtk_check_button_new_with_label ("Allow shrink");
+ gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), FALSE);
+ gtk_signal_connect (GTK_OBJECT (button),
+ "toggled",
+ GTK_SIGNAL_FUNC (allow_shrink_callback),
+ GTK_OBJECT (control_window));
+ gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
+
+ button = gtk_check_button_new_with_label ("Allow grow");
+ gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
+ gtk_signal_connect (GTK_OBJECT (button),
+ "toggled",
+ GTK_SIGNAL_FUNC (allow_grow_callback),
+ GTK_OBJECT (control_window));
+ gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
+
+ button = gtk_check_button_new_with_label ("Auto shrink");
+ gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), FALSE);
+ gtk_signal_connect (GTK_OBJECT (button),
+ "toggled",
+ GTK_SIGNAL_FUNC (auto_shrink_callback),
+ GTK_OBJECT (control_window));
+ gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
+
+ button = gtk_button_new_with_mnemonic ("_Show");
+ gtk_signal_connect_object (GTK_OBJECT (button),
+ "clicked",
+ GTK_SIGNAL_FUNC (gtk_widget_show),
+ GTK_OBJECT (window));
+ gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
+
+ button = gtk_button_new_with_mnemonic ("_Hide");
+ gtk_signal_connect_object (GTK_OBJECT (button),
+ "clicked",
+ GTK_SIGNAL_FUNC (gtk_widget_hide),
+ GTK_OBJECT (window));
+ gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
+
+ menu = gtk_menu_new ();
+
+ i = 0;
+ while (i < 10)
+ {
+ GtkWidget *mi;
+ static gchar *names[] = {
+ "GDK_GRAVITY_NORTH_WEST",
+ "GDK_GRAVITY_NORTH",
+ "GDK_GRAVITY_NORTH_EAST",
+ "GDK_GRAVITY_WEST",
+ "GDK_GRAVITY_CENTER",
+ "GDK_GRAVITY_EAST",
+ "GDK_GRAVITY_SOUTH_WEST",
+ "GDK_GRAVITY_SOUTH",
+ "GDK_GRAVITY_SOUTH_EAST",
+ "GDK_GRAVITY_STATIC",
+ NULL
+ };
+
+ g_assert (names[i]);
+
+ mi = gtk_menu_item_new_with_label (names[i]);
+
+ gtk_menu_shell_append (GTK_MENU_SHELL (menu), mi);
+
+ ++i;
+ }
+
+ gtk_widget_show_all (menu);
+
+ om = gtk_option_menu_new ();
+ gtk_option_menu_set_menu (GTK_OPTION_MENU (om), menu);
+
+
+ gtk_signal_connect (GTK_OBJECT (om),
+ "changed",
+ GTK_SIGNAL_FUNC (gravity_selected),
+ control_window);
+
+ gtk_box_pack_end (GTK_BOX (vbox), om, FALSE, FALSE, 0);
+
+
+ menu = gtk_menu_new ();
+
+ i = 0;
+ while (i < 5)
+ {
+ GtkWidget *mi;
+ static gchar *names[] = {
+ "GTK_WIN_POS_NONE",
+ "GTK_WIN_POS_CENTER",
+ "GTK_WIN_POS_MOUSE",
+ "GTK_WIN_POS_CENTER_ALWAYS",
+ "GTK_WIN_POS_CENTER_ON_PARENT",
+ NULL
+ };
+
+ g_assert (names[i]);
+
+ mi = gtk_menu_item_new_with_label (names[i]);
+
+ gtk_menu_shell_append (GTK_MENU_SHELL (menu), mi);
+
+ ++i;
+ }
+
+ gtk_widget_show_all (menu);
+
+ om = gtk_option_menu_new ();
+ gtk_option_menu_set_menu (GTK_OPTION_MENU (om), menu);
+
+
+ gtk_signal_connect (GTK_OBJECT (om),
+ "changed",
+ GTK_SIGNAL_FUNC (pos_selected),
+ control_window);
+
+ gtk_box_pack_end (GTK_BOX (vbox), om, FALSE, FALSE, 0);
+
+ gtk_widget_show_all (vbox);
+
+ return control_window;
+}
+
+void
+create_window_sizing (void)
+{
+ static GtkWidget *window = NULL;
+ static GtkWidget *target_window = NULL;
+
+ if (!target_window)
+ {
+ GtkWidget *label;
+
+ target_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+
+ label = gtk_label_new (NULL);
+ gtk_label_set_markup (GTK_LABEL (label), "<span foreground=\"purple\"><big>Window being resized</big></span>\nBlah blah blah blah\nblah blah blah\nblah blah blah blah blah");
+ gtk_container_add (GTK_CONTAINER (target_window), label);
+ gtk_widget_show (label);
+
+ gtk_signal_connect (GTK_OBJECT (target_window), "destroy",
+ GTK_SIGNAL_FUNC (gtk_widget_destroyed),
+ &target_window);
+
+ window = window_controls (target_window);
+
+ gtk_signal_connect (GTK_OBJECT (window), "destroy",
+ GTK_SIGNAL_FUNC (gtk_widget_destroyed),
+ &window);
+
+ gtk_window_set_title (GTK_WINDOW (target_window), "Window to size");
+ }
+
+ /* don't show target window by default, we want to allow testing
+ * of behavior on first show.
+ */
+
+ 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)
+{
+ gdouble 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
-progressbar_toggle_orientation (GtkWidget *widget, ProgressData *pdata)
+progressbar_toggle_orientation (GtkWidget *widget, gpointer data)
{
+ ProgressData *pdata;
gint i;
+ pdata = (ProgressData *) data;
+
if (!GTK_WIDGET_MAPPED (widget))
return;
- RADIOMENUTOGGLED ((GtkRadioMenuItem *)
- (((GtkOptionMenu *)(pdata->omenu1))->menu_item), i);
+ i = gtk_option_menu_get_history (GTK_OPTION_MENU (widget));
gtk_progress_bar_set_orientation (GTK_PROGRESS_BAR (pdata->pbar),
- (GtkProgressBarOrientation) (3-i));
+ (GtkProgressBarOrientation) i);
}
static void
}
static void
-progressbar_toggle_bar_style (GtkWidget *widget, ProgressData *pdata)
+progressbar_toggle_bar_style (GtkWidget *widget, gpointer data)
{
+ ProgressData *pdata;
gint i;
+ pdata = (ProgressData *) data;
+
if (!GTK_WIDGET_MAPPED (widget))
return;
- RADIOMENUTOGGLED ((GtkRadioMenuItem *)
- (((GtkOptionMenu *)(pdata->omenu2))->menu_item), i);
-
- i = 1 - i;
+ i = gtk_option_menu_get_history (GTK_OPTION_MENU (widget));
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);
}
GtkAdjustment *adj;
static ProgressData *pdata = NULL;
- static OptionMenuItem items1[] =
+ static gchar *items1[] =
{
- { "Left-Right", GTK_SIGNAL_FUNC (progressbar_toggle_orientation) },
- { "Right-Left", GTK_SIGNAL_FUNC (progressbar_toggle_orientation) },
- { "Bottom-Top", GTK_SIGNAL_FUNC (progressbar_toggle_orientation) },
- { "Top-Bottom", GTK_SIGNAL_FUNC (progressbar_toggle_orientation) }
+ "Left-Right",
+ "Right-Left",
+ "Bottom-Top",
+ "Top-Bottom"
};
- static OptionMenuItem items2[] =
+ static gchar *items2[] =
{
- { "Continuous", GTK_SIGNAL_FUNC (progressbar_toggle_bar_style) },
- { "Discrete", GTK_SIGNAL_FUNC (progressbar_toggle_bar_style) }
+ "Continuous",
+ "Discrete"
};
if (!pdata)
5, 5);
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
- pdata->omenu1 = build_option_menu (items1, 4, 0, pdata);
+ pdata->omenu1 = build_option_menu (items1, 4, 0,
+ progressbar_toggle_orientation,
+ 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_misc_set_alignment (GTK_MISC (label), 0, 0.5);
- pdata->omenu2 = build_option_menu (items2, 2, 0, pdata);
+ pdata->omenu2 = build_option_menu (items2, 2, 0,
+ progressbar_toggle_bar_style,
+ 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,
gtk_widget_destroy (pdata->window);
}
+/*
+ * Properties
+ */
+
+typedef struct {
+ int x;
+ int y;
+ gboolean found;
+ gboolean first;
+ GtkWidget *res_widget;
+} FindWidgetData;
+
+static void
+find_widget (GtkWidget *widget, FindWidgetData *data)
+{
+ GtkAllocation new_allocation;
+ gint x_offset = 0;
+ gint y_offset = 0;
+
+ new_allocation = widget->allocation;
+
+ if (data->found || !GTK_WIDGET_MAPPED (widget))
+ return;
+
+ /* Note that in the following code, we only count the
+ * position as being inside a WINDOW widget if it is inside
+ * widget->window; points that are outside of widget->window
+ * but within the allocation are not counted. This is consistent
+ * with the way we highlight drag targets.
+ */
+ if (!GTK_WIDGET_NO_WINDOW (widget))
+ {
+ new_allocation.x = 0;
+ new_allocation.y = 0;
+ }
+
+ if (widget->parent && !data->first)
+ {
+ GdkWindow *window = widget->window;
+ while (window != widget->parent->window)
+ {
+ gint tx, ty, twidth, theight;
+ gdk_window_get_size (window, &twidth, &theight);
+
+ if (new_allocation.x < 0)
+ {
+ new_allocation.width += new_allocation.x;
+ new_allocation.x = 0;
+ }
+ if (new_allocation.y < 0)
+ {
+ new_allocation.height += new_allocation.y;
+ new_allocation.y = 0;
+ }
+ if (new_allocation.x + new_allocation.width > twidth)
+ new_allocation.width = twidth - new_allocation.x;
+ if (new_allocation.y + new_allocation.height > theight)
+ new_allocation.height = theight - new_allocation.y;
+
+ gdk_window_get_position (window, &tx, &ty);
+ new_allocation.x += tx;
+ x_offset += tx;
+ new_allocation.y += ty;
+ y_offset += ty;
+
+ window = gdk_window_get_parent (window);
+ }
+ }
+
+ if ((data->x >= new_allocation.x) && (data->y >= new_allocation.y) &&
+ (data->x < new_allocation.x + new_allocation.width) &&
+ (data->y < new_allocation.y + new_allocation.height))
+ {
+ /* First, check if the drag is in a valid drop site in
+ * one of our children
+ */
+ if (GTK_IS_CONTAINER (widget))
+ {
+ FindWidgetData new_data = *data;
+
+ new_data.x -= x_offset;
+ new_data.y -= y_offset;
+ new_data.found = FALSE;
+ new_data.first = FALSE;
+
+ gtk_container_forall (GTK_CONTAINER (widget),
+ (GtkCallback)find_widget,
+ &new_data);
+
+ data->found = new_data.found;
+ if (data->found)
+ data->res_widget = new_data.res_widget;
+ }
+
+ /* If not, and this widget is registered as a drop site, check to
+ * emit "drag_motion" to check if we are actually in
+ * a drop site.
+ */
+ if (!data->found)
+ {
+ data->found = TRUE;
+ data->res_widget = widget;
+ }
+ }
+}
+
+static GtkWidget *
+find_widget_at_pointer (void)
+{
+ GtkWidget *widget = NULL;
+ GdkWindow *pointer_window;
+ gint x, y;
+ FindWidgetData data;
+
+ pointer_window = gdk_window_at_pointer (NULL, NULL);
+
+ if (pointer_window)
+ gdk_window_get_user_data (pointer_window, (gpointer*) &widget);
+
+ if (widget)
+ {
+ gdk_window_get_pointer (widget->window,
+ &x, &y, NULL);
+
+ data.x = x;
+ data.y = y;
+ data.found = FALSE;
+ data.first = TRUE;
+
+ find_widget (widget, &data);
+ if (data.found)
+ return data.res_widget;
+ return widget;
+ }
+ return NULL;
+}
+
+struct PropertiesData {
+ GtkWidget **window;
+ GdkCursor *cursor;
+ gboolean in_query;
+ gint handler;
+};
+
+static void
+destroy_properties (GtkWidget *widget,
+ struct PropertiesData *data)
+{
+ if (data->window)
+ {
+ *data->window = NULL;
+ data->window = NULL;
+ }
+
+ if (data->cursor)
+ {
+ gdk_cursor_destroy (data->cursor);
+ data->cursor = NULL;
+ }
+
+ if (data->handler)
+ {
+ gtk_signal_disconnect (widget, data->handler);
+ data->handler = 0;
+ }
+
+ g_free (data);
+}
+
+static gint
+property_query_event (GtkWidget *widget,
+ GdkEvent *event,
+ struct PropertiesData *data)
+{
+ GtkWidget *res_widget = NULL;
+
+ if (!data->in_query)
+ return FALSE;
+
+ if (event->type == GDK_BUTTON_RELEASE)
+ {
+ gtk_grab_remove (widget);
+ gdk_pointer_ungrab (GDK_CURRENT_TIME);
+
+ res_widget = find_widget_at_pointer ();
+ if (res_widget)
+ create_prop_editor (G_OBJECT (res_widget), 0);
+
+ data->in_query = FALSE;
+ }
+ return FALSE;
+}
+
+
+static void
+query_properties (GtkButton *button,
+ struct PropertiesData *data)
+{
+ gint failure;
+
+ gtk_signal_connect (GTK_OBJECT (button), "event",
+ (GtkSignalFunc) property_query_event, data);
+
+
+ if (!data->cursor)
+ data->cursor = gdk_cursor_new (GDK_TARGET);
+
+ failure = gdk_pointer_grab (GTK_WIDGET (button)->window,
+ TRUE,
+ GDK_BUTTON_RELEASE_MASK,
+ NULL,
+ data->cursor,
+ GDK_CURRENT_TIME);
+
+ gtk_grab_add (GTK_WIDGET (button));
+
+ data->in_query = TRUE;
+}
+
+static void
+create_properties (void)
+{
+ static GtkWidget *window = NULL;
+ GtkWidget *button;
+ GtkWidget *vbox;
+ GtkWidget *label;
+ struct PropertiesData *data;
+
+ data = g_new (struct PropertiesData, 1);
+ data->window = &window;
+ data->in_query = FALSE;
+ data->cursor = NULL;
+ data->handler = 0;
+
+ if (!window)
+ {
+ window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+
+ data->handler = gtk_signal_connect (GTK_OBJECT (window), "destroy",
+ GTK_SIGNAL_FUNC(destroy_properties),
+ data);
+
+ gtk_window_set_title (GTK_WINDOW (window), "test properties");
+ gtk_container_set_border_width (GTK_CONTAINER (window), 10);
+
+ vbox = gtk_vbox_new (FALSE, 1);
+ gtk_container_add (GTK_CONTAINER (window), vbox);
+
+ label = gtk_label_new ("This is just a dumb test to test properties.\nIf you need a generic module, get GLE.");
+ gtk_box_pack_start (GTK_BOX (vbox), label, TRUE, TRUE, 0);
+
+ button = gtk_button_new_with_label ("Query properties");
+ gtk_box_pack_start (GTK_BOX (vbox), button, TRUE, TRUE, 0);
+ gtk_signal_connect (GTK_OBJECT (button), "clicked",
+ GTK_SIGNAL_FUNC(query_properties),
+ data);
+ }
+
+ if (!GTK_WIDGET_VISIBLE (window))
+ gtk_widget_show_all (window);
+ else
+ gtk_widget_destroy (window);
+
+}
+
+
/*
* Color Preview
*/
static void
scroll_test_adjustment_changed (GtkAdjustment *adj, GtkWidget *widget)
{
- gint source_min = (int)adj->value - scroll_test_pos;
+ /* gint source_min = (int)adj->value - scroll_test_pos; */
gint dy;
dy = scroll_test_pos - (int)adj->value;
if (!GTK_WIDGET_DRAWABLE (widget))
return;
-
gdk_window_scroll (widget->window, 0, dy);
gdk_window_process_updates (widget->window, FALSE);
}
if (!window)
{
+ GtkWidget *button2;
GtkWidget *frame;
GtkWidget *box;
NULL),
"signal::clicked", toggle_idle_container, container,
NULL);
- button =
- g_object_connect (gtk_widget_new (GTK_TYPE_RADIO_BUTTON,
- "label", "Resize-Queue",
- "user_data", (void*)GTK_RESIZE_QUEUE,
- "group", button,
- "visible", TRUE,
- "parent", box,
- NULL),
- "signal::clicked", toggle_idle_container, container,
- NULL);
- button =
- g_object_set (g_object_connect (gtk_widget_new (GTK_TYPE_RADIO_BUTTON,
- "label", "Resize-Immediate",
- "user_data", (void*)GTK_RESIZE_IMMEDIATE,
- NULL),
- "signal::clicked", toggle_idle_container, container,
- NULL),
- "group", button,
- "visible", TRUE,
- "parent", box,
- NULL);
+ button = gtk_widget_new (GTK_TYPE_RADIO_BUTTON,
+ "label", "Resize-Queue",
+ "user_data", (void*)GTK_RESIZE_QUEUE,
+ "group", button,
+ "visible", TRUE,
+ "parent", box,
+ NULL);
+ g_object_connect (button,
+ "signal::clicked", toggle_idle_container, container,
+ NULL);
+ button2 = gtk_widget_new (GTK_TYPE_RADIO_BUTTON,
+ "label", "Resize-Immediate",
+ "user_data", (void*)GTK_RESIZE_IMMEDIATE,
+ NULL);
+ g_object_connect (button2,
+ "signal::clicked", toggle_idle_container, container,
+ NULL);
+ g_object_set (button2,
+ "group", button,
+ "visible", TRUE,
+ "parent", box,
+ NULL);
button = gtk_button_new_with_label ("close");
gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
* 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)
{
button = gtk_button_new_with_label ("Reload");
gtk_signal_connect (GTK_OBJECT (button), "clicked",
- GTK_SIGNAL_FUNC(reload_rc_file), NULL);
+ GTK_SIGNAL_FUNC(gtk_rc_reparse_all), NULL);
GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
button, TRUE, TRUE, 0);
rc_style = gtk_rc_style_new ();
- rc_style->font_desc = font_desc;
+ rc_style->font_desc = pango_font_description_copy (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;
gtk_main_quit ();
}
+struct {
+ char *label;
+ void (*func) ();
+ gboolean do_not_benchmark;
+} buttons[] =
+{
+ { "big windows", create_big_windows },
+ { "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 },
+ { "entry", create_entry },
+ { "event watcher", create_event_watcher },
+ { "file selection", create_file_selection },
+ { "flipping", create_flipping },
+ { "focus", create_focus },
+ { "font selection", create_font_selection },
+ { "gamma curve", create_gamma_curve, TRUE },
+ { "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, TRUE },
+ { "notebook", create_notebook },
+ { "panes", create_panes },
+ { "pixmap", create_pixmap },
+ { "preview color", create_color_preview, TRUE },
+ { "preview gray", create_gray_preview, TRUE },
+ { "progress bar", create_progress_bar },
+ { "properties", create_properties },
+ { "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 },
+ { "size groups", create_size_groups },
+ { "spinbutton", create_spins },
+ { "statusbar", create_statusbar },
+ { "styles", create_styles },
+ { "test idle", create_idle_test },
+ { "test mainloop", create_mainloop, TRUE },
+ { "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 },
+ { "window sizing", create_window_sizing },
+ { "window states", create_window_states }
+};
+int nbuttons = sizeof (buttons) / sizeof (buttons[0]);
+
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 },
- { "focus", create_focus },
- { "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 },
- { "window states", create_window_states }
- };
- int nbuttons = sizeof (buttons) / sizeof (buttons[0]);
GtkWidget *window;
GtkWidget *box1;
GtkWidget *box2;
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");
+ button = gtk_button_new_with_mnemonic ("_Close");
gtk_signal_connect (GTK_OBJECT (button), "clicked",
GTK_SIGNAL_FUNC (do_exit),
window);
if (file_exists ("../gdk-pixbuf/.libs/libpixbufloader-pnm.so"))
{
putenv ("GDK_PIXBUF_MODULEDIR=../gdk-pixbuf/.libs");
- putenv ("GTK_IM_MODULE_FILE=./gtk.immodules");
+ putenv ("GTK_IM_MODULE_FILE=../modules/input/gtk.immodules");
+ }
+}
+
+static char *
+pad (const char *str, int to)
+{
+ static char buf[256];
+ int len = strlen (str);
+ int i;
+
+ for (i = 0; i < to; i++)
+ buf[i] = ' ';
+
+ buf[to] = '\0';
+
+ memcpy (buf, str, len);
+
+ return buf;
+}
+
+static void
+bench_iteration (void (* fn) ())
+{
+ fn (); /* on */
+ while (g_main_iteration (FALSE));
+ fn (); /* off */
+ while (g_main_iteration (FALSE));
+}
+
+void
+do_real_bench (void (* fn) (), char *name, int num)
+{
+ GTimeVal tv0, tv1;
+ double dt_first;
+ double dt;
+ int n;
+ static gboolean printed_headers = FALSE;
+
+ if (!printed_headers) {
+ g_print ("Test Iters First Other\n");
+ g_print ("-------------------- ----- ---------- ----------\n");
+ printed_headers = TRUE;
+ }
+
+ g_get_current_time (&tv0);
+ bench_iteration (fn);
+ g_get_current_time (&tv1);
+
+ dt_first = ((double)tv1.tv_sec - tv0.tv_sec) * 1000.0
+ + (tv1.tv_usec - tv0.tv_usec) / 1000.0;
+
+ g_get_current_time (&tv0);
+ for (n = 0; n < num - 1; n++)
+ bench_iteration (fn);
+ g_get_current_time (&tv1);
+ dt = ((double)tv1.tv_sec - tv0.tv_sec) * 1000.0
+ + (tv1.tv_usec - tv0.tv_usec) / 1000.0;
+
+ g_print ("%s %5d ", pad (name, 20), num);
+ if (num > 1)
+ g_print ("%10.1f %10.1f\n", dt_first, dt/(num-1));
+ else
+ g_print ("%10.1f\n", dt_first);
+}
+
+void
+do_bench (char* what, int num)
+{
+ int i;
+ void (* fn) ();
+ fn = NULL;
+
+ if (g_strcasecmp (what, "ALL") == 0)
+ {
+ for (i = 0; i < nbuttons; i++)
+ {
+ if (!buttons[i].do_not_benchmark)
+ do_real_bench (buttons[i].func, buttons[i].label, num);
+ }
+
+ return;
}
+ else
+ {
+ for (i = 0; i < nbuttons; i++)
+ {
+ if (strcmp (buttons[i].label, what) == 0)
+ {
+ fn = buttons[i].func;
+ break;
+ }
+ }
+
+ if (!fn)
+ g_print ("Can't bench: \"%s\" not found.\n", what);
+ else
+ do_real_bench (fn, buttons[i].label, num);
+ }
+}
+
+void
+usage (void)
+{
+ fprintf (stderr, "Usage: testgtk [--bench ALL|<bench>[:<count>]]\n");
+ exit (1);
}
int
main (int argc, char *argv[])
{
GtkBindingSet *binding_set;
+ int i;
+ gboolean done_benchmarks = FALSE;
srand (time (NULL));
test_init ();
- gtk_set_locale ();
/* Check to see if we are being run from the correct
* directory.
gtk_init (&argc, &argv);
+ /* benchmarking
+ */
+ for (i = 1; i < argc; i++)
+ {
+ if (strncmp (argv[i], "--bench", strlen("--bench")) == 0)
+ {
+ int num = 1;
+ char *nextarg;
+ char *what;
+ char *count;
+
+ nextarg = strchr (argv[i], '=');
+ if (nextarg)
+ nextarg++;
+ else
+ {
+ i++;
+ if (i == argc)
+ usage ();
+ nextarg = argv[i];
+ }
+
+ count = strchr (nextarg, ':');
+ if (count)
+ {
+ what = g_strndup (nextarg, count - nextarg);
+ count++;
+ num = atoi (count);
+ if (num <= 0)
+ usage ();
+ }
+ else
+ what = g_strdup (nextarg);
+
+ do_bench (what, num ? num : 1);
+ done_benchmarks = TRUE;
+ }
+ else
+ usage ();
+ }
+ if (done_benchmarks)
+ return 0;
+
/* bindings test
*/
binding_set = gtk_binding_set_by_class (gtk_type_class (GTK_TYPE_WIDGET));
g_main_iteration (FALSE);
#endif
}
-
return 0;
}
projects / ~andy / gtk / blobdiff