* Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
*
* This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Library General Public
+ * modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Library General Public License for more details.
+ * Lesser General Public License for more details.
*
- * You should have received a copy of the GNU Library General Public
+ * You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/
+
+/*
+ * Modified by the GTK+ Team and others 1997-2000. See the AUTHORS
+ * file for a list of people on the GTK+ Team. See the ChangeLog
+ * files for a list of changes. These files are distributed with
+ * GTK+ at ftp://ftp.gtk.org/pub/gtk/.
+ */
+
+#include "config.h"
+
#undef G_LOG_DOMAIN
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
+#include <sys/stat.h>
#include <math.h>
#include <time.h>
-#include "gtk.h"
-#include "../gdk/gdk.h"
-#include "../gdk/gdkx.h"
-#include "../gdk/gdkkeysyms.h"
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+
+#define GTK_ENABLE_BROKEN
+#include "gtk/gtk.h"
+#include "gdk/gdk.h"
+#include "gdk/gdkkeysyms.h"
+
+#ifdef G_OS_WIN32
+#define sleep(n) _sleep(n)
+#endif
+
+#include "prop-editor.h"
#include "circles.xbm"
+#include "test.xpm"
typedef struct _OptionMenuItem
{
GtkSignalFunc func;
} OptionMenuItem;
+gboolean
+file_exists (const char *filename)
+{
+ struct stat statbuf;
+
+ return stat (filename, &statbuf) == 0;
+}
+
GtkWidget *
shape_create_icon (char *xpm_file,
gint x,
gtk_signal_connect (GTK_OBJECT (menu_item), "activate",
(GtkSignalFunc) items[i].func, data);
group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menu_item));
- gtk_menu_append (GTK_MENU (menu), menu_item);
+ gtk_menu_shell_append (GTK_MENU_SHELL (menu), menu_item);
if (i == history)
- gtk_check_menu_item_set_state (GTK_CHECK_MENU_ITEM (menu_item), TRUE);
+ gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (menu_item), TRUE);
gtk_widget_show (menu_item);
}
gtk_box_pack_start (GTK_BOX (box1), table, TRUE, TRUE, 0);
button[0] = gtk_button_new_with_label ("button1");
- button[1] = gtk_button_new_with_label ("button2");
- button[2] = gtk_button_new_with_label ("button3");
- button[3] = gtk_button_new_with_label ("button4");
+ button[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[4] = gtk_button_new_with_label ("button5");
button[5] = gtk_button_new_with_label ("button6");
button[6] = gtk_button_new_with_label ("button7");
- button[7] = gtk_button_new_with_label ("button8");
+ button[7] = gtk_button_new_from_stock (GTK_STOCK_BUTTON_CLOSE);
button[8] = gtk_button_new_with_label ("button9");
-
+
gtk_signal_connect (GTK_OBJECT (button[0]), "clicked",
GTK_SIGNAL_FUNC(button_window),
button[1]);
if (!GTK_WIDGET_VISIBLE (window))
gtk_widget_show_all (window);
else
- gtk_widget_destroy (window);
+ gtk_widget_hide (window);
}
/*
button = gtk_toggle_button_new_with_label ("button3");
gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
+ button = gtk_toggle_button_new_with_label ("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);
gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
- button = gtk_check_button_new_with_label ("button1");
+ button = gtk_check_button_new_with_mnemonic ("_button1");
gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
button = gtk_check_button_new_with_label ("button2");
button = gtk_check_button_new_with_label ("button3");
gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
+ button = gtk_check_button_new_with_label ("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 (
gtk_radio_button_group (GTK_RADIO_BUTTON (button)),
"button2");
- gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON (button), TRUE);
+ 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 (
"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)),
+ "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);
gtk_container_add (GTK_CONTAINER (frame), bbox);
gtk_button_box_set_layout (GTK_BUTTON_BOX (bbox), layout);
- gtk_button_box_set_spacing (GTK_BUTTON_BOX (bbox), spacing);
+ gtk_box_set_spacing (GTK_BOX (bbox), spacing);
gtk_button_box_set_child_size (GTK_BUTTON_BOX (bbox), child_w, child_h);
button = gtk_button_new_with_label ("OK");
GdkPixmap *pixmap;
GdkBitmap *mask;
- pixmap = gdk_pixmap_create_from_xpm (window, &mask,
- background,
- filename);
+ if (strcmp (filename, "test.xpm") == 0 ||
+ !file_exists (filename))
+ {
+ pixmap = gdk_pixmap_create_from_xpm_d (window, &mask,
+ background,
+ openfile);
+ }
+ else
+ pixmap = gdk_pixmap_create_from_xpm (window, &mask,
+ background,
+ filename);
+
wpixmap = gtk_pixmap_new (pixmap, mask);
return wpixmap;
}
+
+static void
+set_toolbar_small_stock (GtkWidget *widget,
+ gpointer data)
+{
+ gtk_toolbar_set_icon_size (GTK_TOOLBAR (data), GTK_ICON_SIZE_SMALL_TOOLBAR);
+}
+
+static void
+set_toolbar_large_stock (GtkWidget *widget,
+ gpointer data)
+{
+ gtk_toolbar_set_icon_size (GTK_TOOLBAR (data), GTK_ICON_SIZE_LARGE_TOOLBAR);
+}
+
static void
set_toolbar_horizontal (GtkWidget *widget,
gpointer data)
}
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)
+set_toolbar_both_horiz (GtkWidget *widget,
+ gpointer data)
{
- gtk_toolbar_set_space_size (GTK_TOOLBAR (data), 10);
+ gtk_toolbar_set_style (GTK_TOOLBAR (data), GTK_TOOLBAR_BOTH_HORIZ);
}
static void
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)
{
gtk_widget_realize (window);
toolbar = gtk_toolbar_new (GTK_ORIENTATION_HORIZONTAL, GTK_TOOLBAR_BOTH);
- gtk_toolbar_set_button_relief (GTK_TOOLBAR (toolbar), GTK_RELIEF_NONE);
+ gtk_toolbar_insert_stock (GTK_TOOLBAR (toolbar),
+ GTK_STOCK_NEW,
+ "Stock icon: New", "Toolbar/New",
+ (GtkSignalFunc) set_toolbar_small_stock, toolbar, -1);
+
+ gtk_toolbar_insert_stock (GTK_TOOLBAR (toolbar),
+ GTK_STOCK_OPEN,
+ "Stock icon: Open", "Toolbar/Open",
+ (GtkSignalFunc) set_toolbar_large_stock, toolbar, -1);
+
gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
"Horizontal", "Horizontal toolbar layout", "Toolbar/Horizontal",
new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
"Both", "Show toolbar icons and text", "Toolbar/Both",
new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
(GtkSignalFunc) set_toolbar_both, toolbar);
-
+ gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
+ "Both (horizontal)",
+ "Show toolbar icons and text in a horizontal fashion",
+ "Toolbar/BothHoriz",
+ new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
+ (GtkSignalFunc) set_toolbar_both_horiz, toolbar);
+
gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
entry = gtk_entry_new ();
gtk_toolbar_append_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);
}
gtk_widget_realize (window);
toolbar = gtk_toolbar_new (GTK_ORIENTATION_HORIZONTAL, GTK_TOOLBAR_BOTH);
- gtk_toolbar_set_button_relief (GTK_TOOLBAR (toolbar), GTK_RELIEF_NONE);
gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
"Horizontal", "Horizontal toolbar layout", NULL,
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_statusbar_get_context_id (statusbar, string));
}
-static void
-statusbar_dump_stack (GtkStatusbar *statusbar)
-{
- GSList *list;
-
- for (list = statusbar->messages; list; list = list->next)
- {
- GtkStatusbarMsg *msg;
-
- msg = list->data;
- g_print ("context_id: %d, message_id: %d, status_text: \"%s\"\n",
- msg->context_id,
- msg->message_id,
- msg->text);
- }
-}
-
static void
create_statusbar (void)
{
"label", "push something",
"visible", TRUE,
"parent", box2,
- "signal::clicked", statusbar_push, statusbar,
- NULL);
-
- button = gtk_widget_new (gtk_button_get_type (),
- "label", "pop",
- "visible", TRUE,
- "parent", box2,
- "signal_after::clicked", statusbar_pop, statusbar,
- NULL);
-
- button = gtk_widget_new (gtk_button_get_type (),
- "label", "steal #4",
- "visible", TRUE,
- "parent", box2,
- "signal_after::clicked", statusbar_steal, statusbar,
- NULL);
-
- button = gtk_widget_new (gtk_button_get_type (),
- "label", "dump stack",
- "visible", TRUE,
- "parent", box2,
- "object_signal::clicked", statusbar_dump_stack, statusbar,
- NULL);
-
- button = gtk_widget_new (gtk_button_get_type (),
- "label", "test contexts",
- "visible", TRUE,
- "parent", box2,
- "object_signal_after::clicked", statusbar_contexts, statusbar,
NULL);
+ g_object_connect (G_OBJECT (button),
+ "signal::clicked", statusbar_push, statusbar,
+ NULL);
+ button = g_object_connect (gtk_widget_new (gtk_button_get_type (),
+ "label", "pop",
+ "visible", TRUE,
+ "parent", box2,
+ NULL),
+ "signal_after::clicked", statusbar_pop, statusbar,
+ NULL);
+
+ button = g_object_connect (gtk_widget_new (gtk_button_get_type (),
+ "label", "steal #4",
+ "visible", TRUE,
+ "parent", box2,
+ NULL),
+ "signal_after::clicked", statusbar_steal, statusbar,
+ NULL);
+
+ button = g_object_connect (gtk_widget_new (gtk_button_get_type (),
+ "label", "test contexts",
+ "visible", TRUE,
+ "parent", box2,
+ NULL),
+ "swapped_signal_after::clicked", statusbar_contexts, statusbar,
+ NULL);
+
separator = gtk_hseparator_new ();
gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
tree_buttons = gtk_object_get_user_data(GTK_OBJECT(tree));
- selected_list = GTK_TREE_SELECTION(tree);
+ selected_list = GTK_TREE_SELECTION_OLD(tree);
if(selected_list == NULL)
{
GList* selected_list;
GList* clear_list;
- selected_list = GTK_TREE_SELECTION(tree);
+ selected_list = GTK_TREE_SELECTION_OLD(tree);
clear_list = NULL;
GList* selected_list;
GtkTreeItem *item;
- selected_list = GTK_TREE_SELECTION(tree);
+ selected_list = GTK_TREE_SELECTION_OLD(tree);
if (selected_list)
{
tree_buttons = gtk_object_get_user_data(GTK_OBJECT(tree));
- selected_list = GTK_TREE_SELECTION(tree);
+ selected_list = GTK_TREE_SELECTION_OLD(tree);
nb_selected = g_list_length(selected_list);
if(nb_selected == 0)
/* create check button */
button = gtk_check_button_new_with_label("Draw line");
gtk_box_pack_start(GTK_BOX(box4), button, TRUE, TRUE, 0);
- gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(button), TRUE);
+ gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), TRUE);
sTreeSampleSelection.draw_line_button = button;
button = gtk_check_button_new_with_label("View Line mode");
gtk_box_pack_start(GTK_BOX(box4), button, TRUE, TRUE, 0);
- gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(button), TRUE);
+ gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), TRUE);
sTreeSampleSelection.view_line_button = button;
button = gtk_check_button_new_with_label("Without Root item");
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
gtk_box_pack_start (GTK_BOX (box5), label, FALSE, TRUE, 0);
- adj = (GtkAdjustment *) gtk_adjustment_new ((gfloat)DEFAULT_NUMBER_OF_ITEM, 1.0, 255.0, 1.0,
+ adj = (GtkAdjustment *) gtk_adjustment_new (DEFAULT_NUMBER_OF_ITEM, 1.0, 255.0, 1.0,
5.0, 0.0);
spinner = gtk_spin_button_new (adj, 0, 0);
gtk_box_pack_start (GTK_BOX (box5), spinner, FALSE, TRUE, 0);
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
gtk_box_pack_start (GTK_BOX (box5), label, FALSE, TRUE, 0);
- adj = (GtkAdjustment *) gtk_adjustment_new ((gfloat)DEFAULT_RECURSION_LEVEL, 0.0, 255.0, 1.0,
+ adj = (GtkAdjustment *) gtk_adjustment_new (DEFAULT_RECURSION_LEVEL, 0.0, 255.0, 1.0,
5.0, 0.0);
spinner = gtk_spin_button_new (adj, 0, 0);
gtk_box_pack_start (GTK_BOX (box5), spinner, FALSE, TRUE, 0);
gtk_window_set_policy (GTK_WINDOW (window),
TRUE,
TRUE,
- FALSE);
+ TRUE);
gtk_signal_connect (GTK_OBJECT (window), "destroy",
GTK_SIGNAL_FUNC(gtk_widget_destroyed),
gtk_widget_show (label);
handle_box = gtk_handle_box_new ();
- gtk_container_add (GTK_CONTAINER (hbox), handle_box);
+ gtk_box_pack_start (GTK_BOX (hbox), handle_box, FALSE, FALSE, 0);
gtk_signal_connect (GTK_OBJECT (handle_box),
"child_attached",
GTK_SIGNAL_FUNC (handle_box_child_signal),
gtk_widget_show (handle_box);
toolbar = make_toolbar (window);
- gtk_toolbar_set_button_relief (GTK_TOOLBAR (toolbar), GTK_RELIEF_NORMAL);
+
gtk_container_add (GTK_CONTAINER (handle_box), toolbar);
gtk_widget_show (toolbar);
handle_box = gtk_handle_box_new ();
- gtk_container_add (GTK_CONTAINER (hbox), handle_box);
+ gtk_box_pack_start (GTK_BOX (hbox), handle_box, FALSE, FALSE, 0);
gtk_signal_connect (GTK_OBJECT (handle_box),
"child_attached",
GTK_SIGNAL_FUNC (handle_box_child_signal),
gtk_widget_destroy (window);
}
+/*
+ * Test for getting an image from a drawable
+ */
+
+struct GetImageData
+{
+ GtkWidget *src;
+ GtkWidget *snap;
+ GtkWidget *sw;
+};
+
+static void
+take_snapshot (GtkWidget *button,
+ gpointer data)
+{
+ struct GetImageData *gid = data;
+ GdkRectangle visible;
+ int width_fraction;
+ int height_fraction;
+ GdkGC *gc;
+ GdkGC *black_gc;
+ GdkColor color = { 0, 30000, 0, 0 };
+ GdkRectangle target;
+ GdkImage *shot;
+
+ /* Do some begin_paint_rect on some random rects, draw some
+ * distinctive stuff into those rects, then take the snapshot.
+ * figure out whether any rects were overlapped and report to
+ * user.
+ */
+
+ visible = gid->sw->allocation;
+
+ visible.x = gtk_scrolled_window_get_hadjustment (GTK_SCROLLED_WINDOW (gid->sw))->value;
+ visible.y = gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (gid->sw))->value;
+
+ width_fraction = visible.width / 4;
+ height_fraction = visible.height / 4;
+
+ gc = gdk_gc_new (gid->src->window);
+ black_gc = gid->src->style->black_gc;
+
+ gdk_gc_set_rgb_fg_color (gc, &color);
+
+
+ target.x = visible.x + width_fraction;
+ target.y = visible.y + height_fraction * 3;
+ target.width = width_fraction;
+ target.height = height_fraction / 2;
+
+ gdk_window_begin_paint_rect (gid->src->window,
+ &target);
+
+ gdk_draw_rectangle (gid->src->window,
+ gc,
+ TRUE,
+ target.x, target.y,
+ target.width, target.height);
+
+ gdk_draw_rectangle (gid->src->window,
+ black_gc,
+ FALSE,
+ target.x + 10, target.y + 10,
+ target.width - 20, target.height - 20);
+
+ target.x = visible.x + width_fraction;
+ target.y = visible.y + height_fraction;
+ target.width = width_fraction;
+ target.height = height_fraction;
+
+ gdk_window_begin_paint_rect (gid->src->window,
+ &target);
+
+ gdk_draw_rectangle (gid->src->window,
+ gc,
+ TRUE,
+ target.x, target.y,
+ target.width, target.height);
+
+ gdk_draw_rectangle (gid->src->window,
+ black_gc,
+ FALSE,
+ target.x + 10, target.y + 10,
+ target.width - 20, target.height - 20);
+
+ target.x = visible.x + width_fraction * 3;
+ target.y = visible.y + height_fraction;
+ target.width = width_fraction / 2;
+ target.height = height_fraction;
+
+ gdk_window_begin_paint_rect (gid->src->window,
+ &target);
+
+ gdk_draw_rectangle (gid->src->window,
+ gc,
+ TRUE,
+ target.x, target.y,
+ target.width, target.height);
+
+ gdk_draw_rectangle (gid->src->window,
+ black_gc,
+ FALSE,
+ target.x + 10, target.y + 10,
+ target.width - 20, target.height - 20);
+
+ target.x = visible.x + width_fraction * 2;
+ target.y = visible.y + height_fraction * 2;
+ target.width = width_fraction / 4;
+ target.height = height_fraction / 4;
+
+ gdk_window_begin_paint_rect (gid->src->window,
+ &target);
+
+ gdk_draw_rectangle (gid->src->window,
+ gc,
+ TRUE,
+ target.x, target.y,
+ target.width, target.height);
+
+ gdk_draw_rectangle (gid->src->window,
+ black_gc,
+ FALSE,
+ target.x + 10, target.y + 10,
+ target.width - 20, target.height - 20);
+
+ target.x += target.width / 2;
+ target.y += target.width / 2;
+
+ gdk_window_begin_paint_rect (gid->src->window,
+ &target);
+
+ gdk_draw_rectangle (gid->src->window,
+ gc,
+ TRUE,
+ target.x, target.y,
+ target.width, target.height);
+
+ gdk_draw_rectangle (gid->src->window,
+ black_gc,
+ FALSE,
+ target.x + 10, target.y + 10,
+ target.width - 20, target.height - 20);
+
+ /* Screen shot area */
+
+ target.x = visible.x + width_fraction * 1.5;
+ target.y = visible.y + height_fraction * 1.5;
+ target.width = width_fraction * 2;
+ target.height = height_fraction * 2;
+
+ shot = gdk_drawable_get_image (gid->src->window,
+ target.x, target.y,
+ target.width, target.height);
+
+ gtk_image_set_from_image (GTK_IMAGE (gid->snap),
+ shot, NULL);
+
+ g_object_unref (G_OBJECT (shot));
+
+ gdk_window_end_paint (gid->src->window);
+ gdk_window_end_paint (gid->src->window);
+ gdk_window_end_paint (gid->src->window);
+ gdk_window_end_paint (gid->src->window);
+ gdk_window_end_paint (gid->src->window);
+
+ gdk_draw_rectangle (gid->src->window,
+ gid->src->style->black_gc,
+ FALSE,
+ target.x, target.y,
+ target.width, target.height);
+
+ g_object_unref (G_OBJECT (gc));
+}
+
+static gint
+image_source_expose (GtkWidget *da,
+ GdkEventExpose *event,
+ gpointer data)
+{
+ int x = event->area.x;
+ GdkColor red = { 0, 65535, 0, 0 };
+ GdkColor green = { 0, 0, 65535, 0 };
+ GdkColor blue = { 0, 0, 0, 65535 };
+ GdkGC *gc;
+
+ gc = gdk_gc_new (event->window);
+
+ while (x < (event->area.x + event->area.width))
+ {
+ switch (x % 7)
+ {
+ case 0:
+ case 1:
+ case 2:
+ gdk_gc_set_rgb_fg_color (gc, &red);
+ break;
+
+ case 3:
+ case 4:
+ case 5:
+ gdk_gc_set_rgb_fg_color (gc, &green);
+ break;
+
+ case 6:
+ case 7:
+ case 8:
+ gdk_gc_set_rgb_fg_color (gc, &blue);
+ break;
+
+ default:
+ g_assert_not_reached ();
+ break;
+ }
+
+ gdk_draw_line (event->window,
+ gc,
+ x, event->area.y,
+ x, event->area.y + event->area.height);
+
+ ++x;
+ }
+
+ g_object_unref (G_OBJECT (gc));
+
+ return TRUE;
+}
+
+static void
+create_get_image (void)
+{
+ static GtkWidget *window = NULL;
+
+ if (window)
+ gtk_widget_destroy (window);
+ else
+ {
+ GtkWidget *sw;
+ GtkWidget *src;
+ GtkWidget *snap;
+ GtkWidget *vbox;
+ GtkWidget *hbox;
+ GtkWidget *button;
+ struct GetImageData *gid;
+
+ gid = g_new (struct GetImageData, 1);
+
+ window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+
+ gtk_signal_connect (GTK_OBJECT (window),
+ "destroy",
+ GTK_SIGNAL_FUNC (gtk_widget_destroyed),
+ &window);
+
+ gtk_object_set_data_full (GTK_OBJECT (window),
+ "testgtk-get-image-data",
+ gid,
+ g_free);
+
+ vbox = gtk_vbox_new (FALSE, 0);
+
+ gtk_container_add (GTK_CONTAINER (window), vbox);
+
+ sw = gtk_scrolled_window_new (NULL, NULL);
+ gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
+ GTK_POLICY_AUTOMATIC,
+ GTK_POLICY_AUTOMATIC);
+
+ gid->sw = sw;
+
+ gtk_widget_set_usize (sw, 400, 400);
+
+ src = gtk_drawing_area_new ();
+ gtk_widget_set_usize (src, 10000, 10000);
+
+ gtk_signal_connect (GTK_OBJECT (src),
+ "expose_event",
+ GTK_SIGNAL_FUNC (image_source_expose),
+ gid);
+
+ gid->src = src;
+
+ gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (sw),
+ src);
+
+ gtk_box_pack_start (GTK_BOX (vbox),
+ sw, TRUE, TRUE, 0);
+
+
+ hbox = gtk_hbox_new (FALSE, 3);
+
+ snap = gtk_widget_new (GTK_TYPE_IMAGE, NULL);
+
+ gid->snap = snap;
+
+ sw = gtk_scrolled_window_new (NULL, NULL);
+ gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
+ GTK_POLICY_AUTOMATIC,
+ GTK_POLICY_AUTOMATIC);
+ gtk_widget_set_usize (sw, 300, 300);
+
+ gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (sw), snap);
+
+ gtk_box_pack_end (GTK_BOX (hbox), sw, FALSE, FALSE, 5);
+
+ button = gtk_button_new_with_label ("Get image from drawable");
+
+ gtk_signal_connect (GTK_OBJECT (button),
+ "clicked",
+ GTK_SIGNAL_FUNC (take_snapshot),
+ gid);
+
+ gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0);
+
+ gtk_box_pack_end (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
+
+ gtk_widget_show_all (window);
+ }
+}
+
/*
* Label Demo
*/
+static void
+sensitivity_toggled (GtkWidget *toggle,
+ GtkWidget *widget)
+{
+ gtk_widget_set_sensitive (widget, GTK_TOGGLE_BUTTON (toggle)->active);
+}
+
+static GtkWidget*
+create_sensitivity_control (GtkWidget *widget)
+{
+ GtkWidget *button;
+
+ button = gtk_toggle_button_new_with_label ("Sensitive");
+
+ gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button),
+ GTK_WIDGET_IS_SENSITIVE (widget));
+
+ gtk_signal_connect (GTK_OBJECT (button),
+ "toggled",
+ GTK_SIGNAL_FUNC (sensitivity_toggled),
+ widget);
+
+ gtk_widget_show_all (button);
+
+ return button;
+}
+
+static void
+set_selectable_recursive (GtkWidget *widget,
+ gboolean setting)
+{
+ if (GTK_IS_CONTAINER (widget))
+ {
+ GList *children;
+ GList *tmp;
+
+ children = gtk_container_children (GTK_CONTAINER (widget));
+ tmp = children;
+ while (tmp)
+ {
+ set_selectable_recursive (tmp->data, setting);
+
+ tmp = tmp->next;
+ }
+ g_list_free (children);
+ }
+ else if (GTK_IS_LABEL (widget))
+ {
+ gtk_label_set_selectable (GTK_LABEL (widget), setting);
+ }
+}
+
+static void
+selectable_toggled (GtkWidget *toggle,
+ GtkWidget *widget)
+{
+ set_selectable_recursive (widget,
+ GTK_TOGGLE_BUTTON (toggle)->active);
+}
+
+static GtkWidget*
+create_selectable_control (GtkWidget *widget)
+{
+ GtkWidget *button;
+
+ button = gtk_toggle_button_new_with_label ("Selectable");
+
+ gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button),
+ FALSE);
+
+ gtk_signal_connect (GTK_OBJECT (button),
+ "toggled",
+ GTK_SIGNAL_FUNC (selectable_toggled),
+ widget);
+
+ gtk_widget_show_all (button);
+
+ return button;
+}
+
void create_labels (void)
{
static GtkWidget *window = NULL;
GtkWidget *vbox;
GtkWidget *frame;
GtkWidget *label;
-
+ GtkWidget *button;
+
if (!window)
{
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
&window);
gtk_window_set_title (GTK_WINDOW (window), "Label");
+
vbox = gtk_vbox_new (FALSE, 5);
+
hbox = gtk_hbox_new (FALSE, 5);
- gtk_container_add (GTK_CONTAINER (window), hbox);
+ gtk_container_add (GTK_CONTAINER (window), vbox);
+
+ gtk_box_pack_end (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
+
+ button = create_sensitivity_control (hbox);
+
+ gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
+
+ button = create_selectable_control (hbox);
+
+ gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
+
+ vbox = gtk_vbox_new (FALSE, 5);
+
gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 0);
gtk_container_set_border_width (GTK_CONTAINER (window), 5);
gtk_container_add (GTK_CONTAINER (frame), label);
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
- vbox = gtk_vbox_new (FALSE, 5);
- gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 0);
- frame = gtk_frame_new ("Line wrapped label");
- label = gtk_label_new ("This is an example of a line-wrapped label. It should not be taking "\
- "up the entire "/* big space to test spacing */\
- "width allocated to it, but automatically wraps the words to fit. "\
- "The time has come, for all good men, to come to the aid of their party. "\
+ frame = gtk_frame_new ("Internationalized Label");
+ label = gtk_label_new ("French (Français) Bonjour, Salut\n"
+ "Korean (한글) 안녕하세요, 안녕하십니까\n"
+ "Russian (Русский) Здравствуйте!");
+ gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
+ gtk_container_add (GTK_CONTAINER (frame), label);
+ gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
+
+ frame = gtk_frame_new ("Bidirection Label");
+ label = gtk_label_new ("Arabic السلام عليكم\n"
+ "Hebrew שלום");
+ gtk_widget_set_direction (label, GTK_TEXT_DIR_RTL);
+ gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_RIGHT);
+ gtk_container_add (GTK_CONTAINER (frame), label);
+ gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
+
+ vbox = gtk_vbox_new (FALSE, 5);
+ gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 0);
+ frame = gtk_frame_new ("Line wrapped label");
+ label = gtk_label_new ("This is an example of a line-wrapped label. It should not be taking "\
+ "up the entire "/* big space to test spacing */\
+ "width allocated to it, but automatically wraps the words to fit. "\
+ "The time has come, for all good men, to come to the aid of their party. "\
"The sixth sheik's six sheep's sick.\n"\
" It supports multiple paragraphs correctly, and correctly adds "\
"many extra spaces. ");
frame = gtk_frame_new ("Underlined label");
label = gtk_label_new ("This label is underlined!\n"
- "This one is underlined in ÆüËܸì¤ÎÆþÍÑquite a funky fashion");
+ "This one is underlined (こんにちは) in quite a funky fashion");
gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
gtk_label_set_pattern (GTK_LABEL (label), "_________________________ _ _________ _ _____ _ __ __ ___ ____ _____");
gtk_container_add (GTK_CONTAINER (frame), label);
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
+ frame = gtk_frame_new ("Markup label");
+ label = gtk_label_new (NULL);
+
+ /* There's also a gtk_label_set_markup() without accel if you
+ * don't have an accelerator key
+ */
+ gtk_label_set_markup_with_mnemonic (GTK_LABEL (label),
+ "This <span foreground=\"blue\" background=\"orange\">label</span> has "
+ "<b>markup</b> _such as "
+ "<big><i>Big Italics</i></big>\n"
+ "<tt>Monospace font</tt>\n"
+ "<u>Underline!</u>\n"
+ "foo\n"
+ "<span foreground=\"green\" background=\"red\">Ugly colors</span>\n"
+ "and nothing on this line,\n"
+ "or this.\n"
+ "or this either\n"
+ "or even on this one\n"
+ "la <big>la <big>la <big>la <big>la</big></big></big></big>\n"
+ "but this _word is <span foreground=\"purple\"><big>purple</big></span>\n"
+ "<span underline=\"double\">We like <sup>superscript</sup> and <sub>subscript</sub> too</span>");
+
+ g_assert (gtk_label_get_mnemonic_keyval (GTK_LABEL (label)) == GDK_s);
+
+ gtk_container_add (GTK_CONTAINER (frame), label);
+ gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
}
+
if (!GTK_WIDGET_VISIBLE (window))
gtk_widget_show_all (window);
else
return FALSE;
}
+static void
+uposition_stop_configure (GtkToggleButton *toggle,
+ GtkObject *window)
+{
+ if (toggle->active)
+ gtk_signal_handler_block_by_func (window, GTK_SIGNAL_FUNC (uposition_configure), NULL);
+ else
+ gtk_signal_handler_unblock_by_func (window, GTK_SIGNAL_FUNC (uposition_configure), NULL);
+}
+
static void
create_saved_position (void)
{
GtkWidget *label;
GtkWidget *any;
- window = gtk_widget_new (GTK_TYPE_WINDOW,
- "type", GTK_WINDOW_TOPLEVEL,
- "signal::configure_event", uposition_configure, NULL,
- "x", upositionx,
- "y", upositiony,
- "title", "Saved Position",
- NULL);
+ window = g_object_connect (gtk_widget_new (GTK_TYPE_WINDOW,
+ "type", GTK_WINDOW_TOPLEVEL,
+ "x", upositionx,
+ "y", upositiony,
+ "title", "Saved Position",
+ NULL),
+ "signal::configure_event", uposition_configure, NULL,
+ NULL);
gtk_signal_connect (GTK_OBJECT (window), "destroy",
GTK_SIGNAL_FUNC (gtk_widget_destroyed),
"GtkContainer::border_width", 10,
"GtkWidget::parent", main_vbox,
"GtkWidget::visible", TRUE,
+ "child", g_object_connect (gtk_widget_new (GTK_TYPE_TOGGLE_BUTTON,
+ "label", "Stop Events",
+ "active", FALSE,
+ "visible", TRUE,
+ NULL),
+ "signal::clicked", uposition_stop_configure, window,
+ NULL),
NULL);
hbox = gtk_hbox_new (FALSE, 0);
GtkWidget *label;
GtkWidget *separator;
GtkWidget *pixmapwid;
- GdkPixmap *pixmap;
- GdkBitmap *mask;
if (!window)
{
button = gtk_button_new ();
gtk_box_pack_start (GTK_BOX (box2), button, FALSE, FALSE, 0);
- pixmap = gdk_pixmap_create_from_xpm (window->window, &mask, NULL,
- "test.xpm");
- pixmapwid = gtk_pixmap_new (pixmap, mask);
- gdk_pixmap_unref (pixmap);
- gdk_pixmap_unref (mask);
+ pixmapwid = new_pixmap ("test.xpm", window->window, NULL);
+
+ label = gtk_label_new ("Pixmap\ntest");
+ box3 = gtk_hbox_new (FALSE, 0);
+ gtk_container_set_border_width (GTK_CONTAINER (box3), 2);
+ gtk_container_add (GTK_CONTAINER (box3), pixmapwid);
+ gtk_container_add (GTK_CONTAINER (box3), label);
+ gtk_container_add (GTK_CONTAINER (button), box3);
+
+ button = gtk_button_new ();
+ gtk_box_pack_start (GTK_BOX (box2), button, FALSE, FALSE, 0);
+
+ pixmapwid = new_pixmap ("test.xpm", window->window, NULL);
label = gtk_label_new ("Pixmap\ntest");
box3 = gtk_hbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER (box3), label);
gtk_container_add (GTK_CONTAINER (button), box3);
+ gtk_widget_set_sensitive (button, FALSE);
+
separator = gtk_hseparator_new ();
gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
if (GTK_TOGGLE_BUTTON (toggle)->active)
{
gtk_label_set_text (GTK_LABEL (tips_query), tip_text ? "There is a Tip!" : "There is no Tip!");
- /* don't let GtkTipsQuery reset it's label */
+ /* don't let GtkTipsQuery reset its label */
gtk_signal_emit_stop_by_name (GTK_OBJECT (tips_query), "widget_entered");
}
}
box3 =
gtk_widget_new (gtk_vbox_get_type (),
- "GtkBox::homogeneous", FALSE,
- "GtkBox::spacing", 5,
- "GtkContainer::border_width", 5,
- "GtkWidget::visible", TRUE,
+ "homogeneous", FALSE,
+ "spacing", 5,
+ "border_width", 5,
+ "visible", TRUE,
NULL);
tips_query = gtk_tips_query_new ();
button =
gtk_widget_new (gtk_button_get_type (),
- "GtkButton::label", "[?]",
- "GtkWidget::visible", TRUE,
- "GtkWidget::parent", box3,
- "GtkObject::object_signal::clicked", gtk_tips_query_start_query, tips_query,
+ "label", "[?]",
+ "visible", TRUE,
+ "parent", box3,
+ NULL);
+ g_object_connect (G_OBJECT (button),
+ "swapped_signal::clicked", gtk_tips_query_start_query, tips_query,
NULL);
gtk_box_set_child_packing (GTK_BOX (box3), button, FALSE, FALSE, 0, GTK_PACK_START);
gtk_tooltips_set_tip (tooltips,
"ContextHelp/buttons/?");
- gtk_widget_set (tips_query,
- "GtkWidget::visible", TRUE,
- "GtkWidget::parent", box3,
- "GtkTipsQuery::caller", button,
- "GtkObject::signal::widget_entered", tips_query_widget_entered, toggle,
- "GtkObject::signal::widget_selected", tips_query_widget_selected, NULL,
+ 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);
- frame =
- gtk_widget_new (gtk_frame_get_type (),
- "GtkFrame::label", "ToolTips Inspector",
- "GtkFrame::label_xalign", (double) 0.5,
- "GtkContainer::border_width", 0,
- "GtkWidget::visible", TRUE,
- "GtkWidget::parent", box2,
- "GtkContainer::child", box3,
- NULL);
+ frame = gtk_widget_new (gtk_frame_get_type (),
+ "label", "ToolTips Inspector",
+ "label_xalign", (double) 0.5,
+ "border_width", 0,
+ "visible", TRUE,
+ "parent", box2,
+ "child", box3,
+ NULL);
gtk_box_set_child_packing (GTK_BOX (box2), frame, TRUE, TRUE, 10, GTK_PACK_START);
separator = gtk_hseparator_new ();
gtk_widget_destroy (window);
}
+/*
+ * GtkImage
+ */
+
+static void
+pack_image (GtkWidget *box,
+ const gchar *text,
+ GtkWidget *image)
+{
+ gtk_box_pack_start (GTK_BOX (box),
+ gtk_label_new (text),
+ FALSE, FALSE, 0);
+
+ gtk_box_pack_start (GTK_BOX (box),
+ image,
+ TRUE, TRUE, 0);
+}
+
+static void
+create_image (void)
+{
+ static GtkWidget *window = NULL;
+
+ if (window == NULL)
+ {
+ GtkWidget *vbox;
+ GdkPixmap *pixmap;
+ GdkBitmap *mask;
+
+ window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+ /* 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),
+ &window);
+
+ vbox = gtk_vbox_new (FALSE, 5);
+
+ gtk_container_add (GTK_CONTAINER (window), vbox);
+
+ pack_image (vbox, "Stock Warning Dialog",
+ gtk_image_new_from_stock (GTK_STOCK_DIALOG_WARNING,
+ GTK_ICON_SIZE_DIALOG));
+
+ pixmap = gdk_pixmap_colormap_create_from_xpm_d (NULL,
+ gtk_widget_get_colormap (window),
+ &mask,
+ NULL,
+ openfile);
+
+ pack_image (vbox, "Pixmap",
+ gtk_image_new_from_pixmap (pixmap, mask));
+ }
+
+ if (!GTK_WIDGET_VISIBLE (window))
+ gtk_widget_show_all (window);
+ else
+ gtk_widget_destroy (window);
+}
+
/*
* Menu demo
*/
static GtkWidget*
-create_menu (gint depth, gboolean tearoff)
+create_menu (gint depth, gint length, gboolean tearoff)
{
GtkWidget *menu;
GtkWidget *menuitem;
+ GtkWidget *image;
GSList *group;
char buf[32];
int i, j;
if (tearoff)
{
menuitem = gtk_tearoff_menu_item_new ();
- gtk_menu_append (GTK_MENU (menu), menuitem);
+ gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
gtk_widget_show (menuitem);
}
- for (i = 0, j = 1; i < 5; i++, j++)
+ image = gtk_image_new_from_stock (GTK_STOCK_OPEN,
+ GTK_ICON_SIZE_MENU);
+ gtk_widget_show (image);
+ 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);
+
+ for (i = 0, j = 1; i < length; i++, j++)
{
sprintf (buf, "item %2d - %d", depth, j);
+
menuitem = gtk_radio_menu_item_new_with_label (group, buf);
group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menuitem));
+
if (depth % 2)
gtk_check_menu_item_set_show_toggle (GTK_CHECK_MENU_ITEM (menuitem), TRUE);
- gtk_menu_append (GTK_MENU (menu), menuitem);
+
+ gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
gtk_widget_show (menuitem);
if (i == 3)
gtk_widget_set_sensitive (menuitem, FALSE);
- gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), create_menu (depth - 1, TRUE));
+ if (i == 5)
+ gtk_check_menu_item_set_inconsistent (GTK_CHECK_MENU_ITEM (menuitem),
+ TRUE);
+
+ if (i < 5)
+ gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), create_menu (depth - 1, 5, TRUE));
}
return menu;
GtkWidget *menu;
GtkWidget *menuitem;
GtkAccelGroup *accel_group;
+ GtkWidget *image;
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_box_pack_start (GTK_BOX (box1), menubar, FALSE, TRUE, 0);
gtk_widget_show (menubar);
- menu = create_menu (2, TRUE);
+ menu = create_menu (2, 50, TRUE);
menuitem = gtk_menu_item_new_with_label ("test\nline2");
gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), menu);
gtk_widget_show (menuitem);
menuitem = gtk_menu_item_new_with_label ("foo");
- gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), create_menu (3, TRUE));
+ gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), create_menu (3, 5, TRUE));
gtk_menu_bar_append (GTK_MENU_BAR (menubar), menuitem);
gtk_widget_show (menuitem);
- menuitem = gtk_menu_item_new_with_label ("bar");
- gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), create_menu (4, TRUE));
+ image = gtk_image_new_from_stock (GTK_STOCK_HELP,
+ GTK_ICON_SIZE_MENU);
+ gtk_widget_show (image);
+ 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_bar_append (GTK_MENU_BAR (menubar), menuitem);
gtk_widget_show (menuitem);
gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
gtk_widget_show (box2);
- menu = create_menu (1, FALSE);
+ menu = create_menu (1, 5, FALSE);
gtk_menu_set_accel_group (GTK_MENU (menu), accel_group);
+ menuitem = gtk_image_menu_item_new_from_stock (GTK_STOCK_NEW, accel_group);
+ gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
+ gtk_widget_show (menuitem);
+
menuitem = gtk_check_menu_item_new_with_label ("Accelerate Me");
- gtk_menu_append (GTK_MENU (menu), menuitem);
+ gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
gtk_widget_show (menuitem);
gtk_widget_add_accelerator (menuitem,
"activate",
0,
GTK_ACCEL_VISIBLE | GTK_ACCEL_SIGNAL_VISIBLE);
menuitem = gtk_check_menu_item_new_with_label ("Accelerator Locked");
- gtk_menu_append (GTK_MENU (menu), menuitem);
+ gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
gtk_widget_show (menuitem);
gtk_widget_add_accelerator (menuitem,
"activate",
0,
GTK_ACCEL_VISIBLE | GTK_ACCEL_LOCKED);
menuitem = gtk_check_menu_item_new_with_label ("Accelerators Frozen");
- gtk_menu_append (GTK_MENU (menu), menuitem);
+ gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
gtk_widget_show (menuitem);
gtk_widget_add_accelerator (menuitem,
"activate",
g_message ("ItemFactory: activated \"%s\"", gtk_item_factory_path_from_widget (widget));
}
+/* This file was automatically generated by the make-inline-pixbuf program.
+ * It contains inline RGB image data.
+ */
+static const guchar apple[] =
+{
+ /* File magic (1197763408) */
+ 0x47, 0x64, 0x6b, 0x50,
+ /* Format of following stuff (0) */
+ 0x00, 0x00, 0x00, 0x00,
+ /* Rowstride (64) */
+ 0x00, 0x00, 0x00, 0x40,
+ /* Width (16) */
+ 0x00, 0x00, 0x00, 0x10,
+ /* Height (16) */
+ 0x00, 0x00, 0x00, 0x10,
+ /* Has an alpha channel (TRUE) */
+ 0x01,
+ /* Colorspace (0 == RGB, no other options implemented) (0) */
+ 0x00, 0x00, 0x00, 0x00,
+ /* Number of channels (4) */
+ 0x00, 0x00, 0x00, 0x04,
+ /* Bits per sample (8) */
+ 0x00, 0x00, 0x00, 0x08,
+ /* Image data */
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x16, 0x14, 0x0f, 0x04,
+ 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x61, 0x6d, 0x5b, 0x2b, 0x6e, 0x7c, 0x61, 0xd9,
+ 0x71, 0x80, 0x63, 0xd7, 0x5f, 0x6b, 0x5b, 0x35, 0x00, 0x00, 0x00, 0x00,
+ 0x3a, 0x35, 0x28, 0x8f, 0x00, 0x00, 0x00, 0x32, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x60, 0x6c, 0x5c, 0x07, 0x6d, 0x7b, 0x61, 0xd8,
+ 0x75, 0x84, 0x65, 0xf6, 0x76, 0x86, 0x66, 0xf7, 0x6a, 0x77, 0x60, 0xec,
+ 0x5e, 0x6a, 0x58, 0x47, 0x1c, 0x1a, 0x13, 0xa2, 0x4b, 0x47, 0x30, 0x07,
+ 0x55, 0x4e, 0x33, 0x21, 0x48, 0x3e, 0x2a, 0x08, 0xd0, 0xb8, 0x84, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x69, 0x76, 0x5f, 0x74,
+ 0x75, 0x84, 0x65, 0xf3, 0x67, 0x75, 0x5e, 0xc4, 0x69, 0x62, 0x55, 0x75,
+ 0x94, 0x50, 0x50, 0x69, 0x75, 0x5c, 0x52, 0xb2, 0x69, 0x38, 0x34, 0xa2,
+ 0xa7, 0x5b, 0x53, 0xea, 0xa3, 0x52, 0x4f, 0xff, 0x90, 0x47, 0x42, 0xfa,
+ 0x76, 0x44, 0x36, 0xb9, 0x59, 0x38, 0x29, 0x3c, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5f, 0x6b, 0x5a, 0x09,
+ 0x69, 0x76, 0x5e, 0xb0, 0x5f, 0x6b, 0x59, 0x57, 0x9a, 0x4b, 0x4d, 0x5b,
+ 0xb8, 0x5f, 0x63, 0xfa, 0xcc, 0x7d, 0x7e, 0xff, 0xc5, 0x69, 0x68, 0xff,
+ 0xc7, 0x6b, 0x67, 0xff, 0xc5, 0x6f, 0x67, 0xff, 0xba, 0x5e, 0x5a, 0xff,
+ 0xb1, 0x4d, 0x4d, 0xff, 0x92, 0x4b, 0x42, 0xff, 0x6a, 0x3e, 0x30, 0xfc,
+ 0x5c, 0x3b, 0x27, 0x6d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x5d, 0x69, 0x57, 0x09, 0x5d, 0x69, 0x57, 0x09, 0x92, 0x47, 0x46, 0x1e,
+ 0xba, 0x65, 0x64, 0xf4, 0xe7, 0xbf, 0xc0, 0xff, 0xdf, 0xa5, 0xa3, 0xff,
+ 0xd4, 0x84, 0x81, 0xff, 0xd1, 0x7c, 0x76, 0xff, 0xc9, 0x78, 0x6d, 0xff,
+ 0xbb, 0x6a, 0x5d, 0xff, 0xb3, 0x5a, 0x52, 0xff, 0x9f, 0x4b, 0x47, 0xff,
+ 0x78, 0x45, 0x35, 0xff, 0x5f, 0x3c, 0x28, 0xfa, 0x53, 0x5a, 0x38, 0x24,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0xa1, 0x54, 0x4d, 0x8c, 0xcf, 0x8e, 0x89, 0xff, 0xe3, 0xb1, 0xae, 0xff,
+ 0xd8, 0x94, 0x8e, 0xff, 0xd3, 0x8a, 0x82, 0xff, 0xcf, 0x80, 0x76, 0xff,
+ 0xc4, 0x75, 0x67, 0xff, 0xb7, 0x6c, 0x5c, 0xff, 0xab, 0x5e, 0x51, 0xff,
+ 0x9c, 0x4c, 0x46, 0xff, 0x7e, 0x4a, 0x3a, 0xff, 0x5c, 0x3c, 0x26, 0xff,
+ 0x58, 0x3d, 0x28, 0x55, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0xa2, 0x59, 0x4f, 0xc3, 0xcd, 0x8e, 0x88, 0xff,
+ 0xd3, 0x93, 0x8c, 0xff, 0xd0, 0x8c, 0x83, 0xff, 0xcc, 0x84, 0x79, 0xff,
+ 0xc7, 0x7c, 0x6e, 0xff, 0xbc, 0x73, 0x61, 0xff, 0xb1, 0x6b, 0x59, 0xff,
+ 0xa3, 0x5f, 0x4f, 0xff, 0x93, 0x50, 0x44, 0xff, 0x78, 0x48, 0x35, 0xff,
+ 0x59, 0x3b, 0x25, 0xff, 0x4f, 0x3d, 0x28, 0x4f, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x9b, 0x5b, 0x4d, 0xbc,
+ 0xbd, 0x7e, 0x72, 0xff, 0xc6, 0x86, 0x7a, 0xff, 0xc5, 0x7f, 0x72, 0xff,
+ 0xc2, 0x7b, 0x6c, 0xff, 0xbf, 0x77, 0x63, 0xff, 0xb7, 0x72, 0x5b, 0xff,
+ 0xa9, 0x6b, 0x53, 0xff, 0x9a, 0x60, 0x4b, 0xff, 0x8b, 0x56, 0x41, 0xff,
+ 0x6a, 0x44, 0x2e, 0xff, 0x53, 0x38, 0x21, 0xfd, 0x42, 0x4b, 0x2e, 0x1a,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x8e, 0x57, 0x48, 0x6e, 0xa6, 0x6b, 0x5a, 0xff, 0xb3, 0x74, 0x62, 0xff,
+ 0xb8, 0x75, 0x61, 0xff, 0xba, 0x76, 0x61, 0xff, 0xb7, 0x74, 0x5c, 0xff,
+ 0xae, 0x6e, 0x54, 0xff, 0x9f, 0x67, 0x4c, 0xff, 0x90, 0x5d, 0x43, 0xff,
+ 0x79, 0x4d, 0x38, 0xff, 0x5c, 0x3d, 0x25, 0xff, 0x50, 0x39, 0x23, 0xb8,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x78, 0x52, 0x43, 0x07, 0x92, 0x5c, 0x47, 0xdc,
+ 0x9e, 0x64, 0x4e, 0xff, 0xa8, 0x6b, 0x52, 0xff, 0xaa, 0x6d, 0x53, 0xff,
+ 0xa7, 0x6d, 0x50, 0xff, 0x9c, 0x67, 0x4a, 0xff, 0x8e, 0x5d, 0x41, 0xff,
+ 0x7d, 0x54, 0x3a, 0xff, 0x6a, 0x4b, 0x32, 0xff, 0x51, 0x39, 0x23, 0xff,
+ 0x28, 0x20, 0x12, 0x77, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x01,
+ 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x6f, 0x4a, 0x37, 0x2a, 0x81, 0x54, 0x3d, 0xec, 0x8b, 0x5a, 0x41, 0xff,
+ 0x8b, 0x5a, 0x3f, 0xff, 0x85, 0x56, 0x3c, 0xff, 0x7d, 0x52, 0x38, 0xff,
+ 0x77, 0x51, 0x33, 0xff, 0x6f, 0x4e, 0x34, 0xff, 0x5f, 0x45, 0x2c, 0xff,
+ 0x2e, 0x21, 0x14, 0xff, 0x00, 0x00, 0x00, 0xf8, 0x00, 0x00, 0x00, 0x92,
+ 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x14, 0x11, 0x0b, 0x08, 0xb4,
+ 0x50, 0x37, 0x25, 0xfe, 0x6d, 0x49, 0x2f, 0xff, 0x52, 0x37, 0x22, 0xff,
+ 0x50, 0x37, 0x21, 0xff, 0x66, 0x45, 0x2b, 0xff, 0x60, 0x46, 0x2c, 0xff,
+ 0x2d, 0x22, 0x16, 0xff, 0x00, 0x00, 0x00, 0xfe, 0x00, 0x00, 0x00, 0xd2,
+ 0x00, 0x00, 0x00, 0x63, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02,
+ 0x00, 0x00, 0x00, 0x22, 0x00, 0x00, 0x00, 0x64, 0x09, 0x0a, 0x07, 0xa4,
+ 0x00, 0x00, 0x00, 0xbd, 0x00, 0x00, 0x00, 0xbe, 0x00, 0x00, 0x00, 0xc4,
+ 0x00, 0x00, 0x00, 0xb8, 0x00, 0x00, 0x00, 0x9d, 0x00, 0x00, 0x00, 0x6c,
+ 0x00, 0x00, 0x00, 0x2c, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+ 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x0d,
+ 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x06,
+ 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00
+};
+
+
+static void
+dump_accels (gpointer callback_data,
+ guint callback_action,
+ GtkWidget *widget)
+{
+ gtk_item_factory_dump_items (NULL, FALSE, gtk_item_factory_print_func, stdout);
+}
+
static GtkItemFactoryEntry menu_items[] =
{
- { "/_File", NULL, 0, 0, "<Branch>" },
- { "/File/tearoff1", NULL, gtk_ifactory_cb, 0, "<Tearoff>" },
- { "/File/_New", "<control>N", gtk_ifactory_cb, 0 },
- { "/File/_Open", "<control>O", gtk_ifactory_cb, 0 },
- { "/File/_Save", "<control>S", gtk_ifactory_cb, 0 },
- { "/File/Save _As...", NULL, gtk_ifactory_cb, 0 },
- { "/File/sep1", NULL, gtk_ifactory_cb, 0, "<Separator>" },
- { "/File/_Quit", "<control>Q", gtk_ifactory_cb, 0 },
+ { "/_File", NULL, 0, 0, "<Branch>" },
+ { "/File/tearoff1", NULL, gtk_ifactory_cb, 0, "<Tearoff>" },
+ { "/File/_New", NULL, gtk_ifactory_cb, 0, "<StockItem>", GTK_STOCK_NEW },
+ { "/File/_Open", NULL, gtk_ifactory_cb, 0, "<StockItem>", GTK_STOCK_OPEN },
+ { "/File/_Save", NULL, gtk_ifactory_cb, 0, "<StockItem>", GTK_STOCK_SAVE },
+ { "/File/Save _As...", "<control>A", gtk_ifactory_cb, 0, "<StockItem>", GTK_STOCK_SAVE },
+ { "/File/_Dump \"_Accels\"", NULL, dump_accels, 0 },
+ { "/File/\\/Test__Escaping/And\\/\n\tWei\\\\rdly",
+ NULL, gtk_ifactory_cb, 0 },
+ { "/File/sep1", NULL, gtk_ifactory_cb, 0, "<Separator>" },
+ { "/File/_Quit", NULL, gtk_ifactory_cb, 0, "<StockItem>", GTK_STOCK_QUIT },
{ "/_Preferences", NULL, 0, 0, "<Branch>" },
{ "/_Preferences/_Color", NULL, 0, 0, "<Branch>" },
{ "/_Preferences/Color/_Red", NULL, gtk_ifactory_cb, 0, "<RadioItem>" },
- { "/_Preferences/Color/_Green", NULL, gtk_ifactory_cb, 0, "<RadioItem>" },
- { "/_Preferences/Color/_Blue", NULL, gtk_ifactory_cb, 0, "<RadioItem>" },
+ { "/_Preferences/Color/_Green", NULL, gtk_ifactory_cb, 0, "/Preferences/Color/Red" },
+ { "/_Preferences/Color/_Blue", NULL, gtk_ifactory_cb, 0, "/Preferences/Color/Red" },
{ "/_Preferences/_Shape", NULL, 0, 0, "<Branch>" },
{ "/_Preferences/Shape/_Square", NULL, gtk_ifactory_cb, 0, "<RadioItem>" },
- { "/_Preferences/Shape/_Rectangle", NULL, gtk_ifactory_cb, 0, "<RadioItem>" },
- { "/_Preferences/Shape/_Oval", NULL, gtk_ifactory_cb, 0, "<RadioItem>" },
+ { "/_Preferences/Shape/_Rectangle", NULL, gtk_ifactory_cb, 0, "/Preferences/Shape/Square" },
+ { "/_Preferences/Shape/_Oval", NULL, gtk_ifactory_cb, 0, "/Preferences/Shape/Rectangle" },
+ { "/_Preferences/Shape/_Rectangle", NULL, gtk_ifactory_cb, 0, "/Preferences/Shape/Square" },
+ { "/_Preferences/Shape/_Oval", NULL, gtk_ifactory_cb, 0, "/Preferences/Shape/Rectangle" },
+ { "/_Preferences/Shape/_Image", NULL, gtk_ifactory_cb, 0, "<ImageItem>", (gchar**) apple, sizeof(apple) },
+
+ /* For testing deletion of menus */
+ { "/_Preferences/Should_NotAppear", NULL, 0, 0, "<Branch>" },
+ { "/Preferences/ShouldNotAppear/SubItem1", NULL, gtk_ifactory_cb, 0 },
+ { "/Preferences/ShouldNotAppear/SubItem2", NULL, gtk_ifactory_cb, 0 },
{ "/_Help", NULL, 0, 0, "<LastBranch>" },
+ { "/Help/_Help", NULL, gtk_ifactory_cb, 0, "<StockItem>", GTK_STOCK_HELP},
{ "/Help/_About", NULL, gtk_ifactory_cb, 0 },
};
+
static int nmenu_items = sizeof (menu_items) / sizeof (menu_items[0]);
static void
accel_group = gtk_accel_group_new ();
item_factory = gtk_item_factory_new (GTK_TYPE_MENU_BAR, "<main>", accel_group);
- gtk_item_factory_create_items (item_factory, nmenu_items, menu_items, NULL);
+ gtk_object_set_data_full (GTK_OBJECT (window),
+ "<main>",
+ item_factory,
+ (GtkDestroyNotify) gtk_object_unref);
gtk_accel_group_attach (accel_group, GTK_OBJECT (window));
gtk_window_set_title (GTK_WINDOW (window), "Item Factory");
gtk_container_set_border_width (GTK_CONTAINER (window), 0);
-
+ gtk_item_factory_create_items (item_factory, nmenu_items, menu_items, NULL);
+
+ /* preselect /Preferences/Shape/Oval over the other radios
+ */
+ gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (gtk_item_factory_get_item (item_factory,
+ "/Preferences/Shape/Oval")),
+ TRUE);
+
box1 = gtk_vbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER (window), box1);
GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
gtk_widget_grab_default (button);
+ gtk_item_factory_delete_item (item_factory, "/Preferences/ShouldNotAppear");
+
gtk_widget_show_all (window);
}
else
gtk_widget_destroy (window);
}
-/*
- * GtkScrolledWindow
- */
-
-static void
-scrolled_windows_remove (GtkWidget *widget, GtkWidget *scrollwin)
-{
- static GtkWidget *parent = NULL;
- static GtkWidget *float_parent;
-
- if (parent)
- {
- gtk_widget_reparent (scrollwin, parent);
- gtk_widget_destroy (float_parent);
- float_parent = NULL;
- parent = NULL;
- }
- else
- {
- parent = widget->parent;
- float_parent = gtk_window_new (GTK_WINDOW_TOPLEVEL);
- gtk_widget_reparent (scrollwin, float_parent);
- gtk_widget_show (float_parent);
- }
-}
-
/*
create_modal_window
*/
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);
/* Pack widgets */
gtk_container_add (GTK_CONTAINER (window), box1);
- gtk_box_pack_start (GTK_BOX (box1), frame1, TRUE, TRUE, 4);
- gtk_container_add (GTK_CONTAINER (frame1), box2);
- gtk_box_pack_start (GTK_BOX (box2), btnColor, FALSE, FALSE, 4);
- gtk_box_pack_start (GTK_BOX (box2), btnFile, FALSE, FALSE, 4);
- gtk_box_pack_start (GTK_BOX (box1), gtk_hseparator_new (), FALSE, FALSE, 4);
- gtk_box_pack_start (GTK_BOX (box1), btnClose, FALSE, FALSE, 4);
+ gtk_box_pack_start (GTK_BOX (box1), frame1, TRUE, TRUE, 4);
+ gtk_container_add (GTK_CONTAINER (frame1), box2);
+ gtk_box_pack_start (GTK_BOX (box2), btnColor, FALSE, FALSE, 4);
+ gtk_box_pack_start (GTK_BOX (box2), btnFile, FALSE, FALSE, 4);
+ gtk_box_pack_start (GTK_BOX (box1), gtk_hseparator_new (), FALSE, FALSE, 4);
+ gtk_box_pack_start (GTK_BOX (box1), btnClose, FALSE, FALSE, 4);
/* connect signals */
gtk_signal_connect_object (GTK_OBJECT (btnClose), "clicked",
gtk_main();
}
+/*
+ * GtkMessageDialog
+ */
+
+static void
+make_message_dialog (GtkWidget **dialog,
+ GtkMessageType type,
+ GtkButtonsType buttons)
+{
+ if (*dialog)
+ {
+ gtk_widget_destroy (*dialog);
+
+ return;
+ }
+
+ *dialog = gtk_message_dialog_new (NULL, 0, type, buttons,
+ "This is a message dialog; it can wrap long lines. This is a long line. La la la. Look this line is wrapped. Blah blah blah blah blah blah. (Note: testgtk has a nonstandard gtkrc that changes some of the message dialog icons.)");
+
+ gtk_signal_connect_object (GTK_OBJECT (*dialog),
+ "response",
+ GTK_SIGNAL_FUNC (gtk_widget_destroy),
+ GTK_OBJECT (*dialog));
+
+ gtk_signal_connect (GTK_OBJECT (*dialog),
+ "destroy",
+ GTK_SIGNAL_FUNC (gtk_widget_destroyed),
+ dialog);
+
+ gtk_widget_show (*dialog);
+}
+
+static void
+create_message_dialog (void)
+{
+ static GtkWidget *info = NULL;
+ static GtkWidget *warning = NULL;
+ static GtkWidget *error = NULL;
+ static GtkWidget *question = NULL;
+
+ make_message_dialog (&info, GTK_MESSAGE_INFO, GTK_BUTTONS_OK);
+ make_message_dialog (&warning, GTK_MESSAGE_WARNING, GTK_BUTTONS_CLOSE);
+ make_message_dialog (&error, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK_CANCEL);
+ make_message_dialog (&question, GTK_MESSAGE_QUESTION, GTK_BUTTONS_YES_NO);
+}
+
/*
* GtkScrolledWindow
*/
+static GtkWidget *sw_parent = NULL;
+static GtkWidget *sw_float_parent;
+static guint sw_destroyed_handler = 0;
+
+static gboolean
+scrolled_windows_delete_cb (GtkWidget *widget, GdkEventAny *event, GtkWidget *scrollwin)
+{
+ gtk_widget_reparent (scrollwin, sw_parent);
+
+ gtk_signal_disconnect (GTK_OBJECT (sw_parent), sw_destroyed_handler);
+ sw_float_parent = NULL;
+ sw_parent = NULL;
+ sw_destroyed_handler = 0;
+
+ return FALSE;
+}
+
+static void
+scrolled_windows_destroy_cb (GtkWidget *widget, GtkWidget *scrollwin)
+{
+ gtk_widget_destroy (sw_float_parent);
+
+ sw_float_parent = NULL;
+ sw_parent = NULL;
+ sw_destroyed_handler = 0;
+}
+
+static void
+scrolled_windows_remove (GtkWidget *widget, GtkWidget *scrollwin)
+{
+ if (sw_parent)
+ {
+ gtk_widget_reparent (scrollwin, sw_parent);
+ gtk_widget_destroy (sw_float_parent);
+
+ gtk_signal_disconnect (GTK_OBJECT (sw_parent), sw_destroyed_handler);
+ sw_float_parent = NULL;
+ sw_parent = NULL;
+ sw_destroyed_handler = 0;
+ }
+ else
+ {
+ sw_parent = scrollwin->parent;
+ sw_float_parent = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+ gtk_window_set_default_size (GTK_WINDOW (sw_float_parent), 200, 200);
+
+ gtk_widget_reparent (scrollwin, sw_float_parent);
+ gtk_widget_show (sw_float_parent);
+
+ sw_destroyed_handler =
+ gtk_signal_connect (GTK_OBJECT (sw_parent), "destroy",
+ GTK_SIGNAL_FUNC (scrolled_windows_destroy_cb), scrollwin);
+ gtk_signal_connect (GTK_OBJECT (sw_float_parent), "delete_event",
+ GTK_SIGNAL_FUNC (scrolled_windows_delete_cb), scrollwin);
+ }
+}
+
static void
create_scrolled_windows (void)
{
}
- button = gtk_button_new_with_label ("close");
+ button = gtk_button_new_with_label ("Close");
gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
GTK_SIGNAL_FUNC(gtk_widget_destroy),
GTK_OBJECT (window));
gtk_widget_grab_default (button);
gtk_widget_show (button);
- button = gtk_button_new_with_label ("remove");
- gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
- GTK_SIGNAL_FUNC(scrolled_windows_remove),
- GTK_OBJECT (scrolled_window));
+ button = gtk_button_new_with_label ("Reparent Out");
+ gtk_signal_connect (GTK_OBJECT (button), "clicked",
+ GTK_SIGNAL_FUNC(scrolled_windows_remove),
+ scrolled_window);
GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
button, TRUE, TRUE, 0);
*/
static void
-entry_toggle_editable (GtkWidget *checkbutton,
- GtkWidget *entry)
+entry_toggle_frame (GtkWidget *checkbutton,
+ GtkWidget *entry)
{
- gtk_entry_set_editable(GTK_ENTRY(entry),
- GTK_TOGGLE_BUTTON(checkbutton)->active);
+ gtk_entry_set_has_frame (GTK_ENTRY(entry),
+ GTK_TOGGLE_BUTTON(checkbutton)->active);
}
static void
}
static void
-entry_toggle_visibility (GtkWidget *checkbutton,
- GtkWidget *entry)
+entry_props_clicked (GtkWidget *button,
+ GObject *entry)
{
- gtk_entry_set_visibility(GTK_ENTRY(entry),
- GTK_TOGGLE_BUTTON(checkbutton)->active);
+ GtkWidget *window = create_prop_editor (entry, 0);
+
+ 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 *entry, *cb;
GtkWidget *button;
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_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_state(GTK_TOGGLE_BUTTON(editable_check), TRUE);
- gtk_widget_show (editable_check);
-
- editable_check = gtk_check_button_new_with_label("Visible");
- gtk_box_pack_start (GTK_BOX (box2), editable_check, FALSE, TRUE, 0);
- gtk_signal_connect (GTK_OBJECT(editable_check), "toggled",
- GTK_SIGNAL_FUNC(entry_toggle_visibility), entry);
- gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(editable_check), TRUE);
- gtk_widget_show (editable_check);
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_state(GTK_TOGGLE_BUTTON(sensitive_check), TRUE);
- gtk_widget_show (sensitive_check);
+ gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(sensitive_check), TRUE);
+ 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(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_BUTTON_CLOSE,
+ GTK_RESPONSE_NONE,
+ NULL);
+
+ gtk_window_set_resizeable (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
*/
}
static void
-create_spins (void)
+get_spin_value (GtkWidget *widget, gpointer data)
{
- static GtkWidget *window = NULL;
- GtkWidget *frame;
- GtkWidget *hbox;
+ 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)
+{
+ static gchar buf[6];
+ gdouble hours;
+ gdouble minutes;
+
+ hours = spin_button->adjustment->value / 60.0;
+ minutes = (fabs(floor (hours) - hours) < 1e-5) ? 0.0 : 30;
+ sprintf (buf, "%02.0f:%02.0f", floor (hours), minutes);
+ if (strcmp (buf, gtk_entry_get_text (GTK_ENTRY (spin_button))))
+ gtk_entry_set_text (GTK_ENTRY (spin_button), buf);
+ return TRUE;
+}
+
+static gint
+spin_button_month_input_func (GtkSpinButton *spin_button,
+ gdouble *new_val)
+{
+ gint i;
+ static gchar *month[12] = { "January", "February", "March", "April",
+ "May", "June", "July", "August",
+ "September", "October", "November", "December" };
+ gchar *tmp1, *tmp2;
+ gboolean found = FALSE;
+
+ for (i = 1; i <= 12; i++)
+ {
+ tmp1 = g_strdup (month[i-1]);
+ g_strup (tmp1);
+ tmp2 = g_strdup (gtk_entry_get_text (GTK_ENTRY (spin_button)));
+ g_strup (tmp2);
+ if (strstr (tmp1, tmp2) == tmp1)
+ found = TRUE;
+ g_free (tmp1);
+ g_free (tmp2);
+ if (found)
+ break;
+ }
+ if (!found)
+ {
+ *new_val = 0.0;
+ return GTK_INPUT_ERROR;
+ }
+ *new_val = (gdouble) i;
+ return TRUE;
+}
+
+static gint
+spin_button_month_output_func (GtkSpinButton *spin_button)
+{
+ gint i;
+ static gchar *month[12] = { "January", "February", "March", "April",
+ "May", "June", "July", "August", "September",
+ "October", "November", "December" };
+
+ for (i = 1; i <= 12; i++)
+ if (fabs (spin_button->adjustment->value - (double)i) < 1e-5)
+ {
+ if (strcmp (month[i-1], gtk_entry_get_text (GTK_ENTRY (spin_button))))
+ gtk_entry_set_text (GTK_ENTRY (spin_button), month[i-1]);
+ }
+ return TRUE;
+}
+
+static gint
+spin_button_hex_input_func (GtkSpinButton *spin_button,
+ gdouble *new_val)
+{
+ const gchar *buf;
+ gchar *err;
+ gdouble res;
+
+ buf = gtk_entry_get_text (GTK_ENTRY (spin_button));
+ res = strtol(buf, &err, 16);
+ *new_val = res;
+ if (*err)
+ return GTK_INPUT_ERROR;
+ else
+ return TRUE;
+}
+
+static gint
+spin_button_hex_output_func (GtkSpinButton *spin_button)
+{
+ static gchar buf[7];
+ gint val;
+
+ val = (gint) spin_button->adjustment->value;
+ if (fabs (val) < 1e-5)
+ sprintf (buf, "0x00");
+ else
+ sprintf (buf, "0x%.2X", val);
+ if (strcmp (buf, gtk_entry_get_text (GTK_ENTRY (spin_button))))
+ gtk_entry_set_text (GTK_ENTRY (spin_button), buf);
+ return TRUE;
+}
+
+static void
+create_spins (void)
+{
+ static GtkWidget *window = NULL;
+ GtkWidget *frame;
+ GtkWidget *hbox;
GtkWidget *main_vbox;
GtkWidget *vbox;
GtkWidget *vbox2;
gtk_container_set_border_width (GTK_CONTAINER (vbox), 5);
gtk_container_add (GTK_CONTAINER (frame), vbox);
- /* Day, month, year spinners */
+ /* Time, month, hex spinners */
hbox = gtk_hbox_new (FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 5);
vbox2 = gtk_vbox_new (FALSE, 0);
gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 5);
- label = gtk_label_new ("Day :");
+ label = gtk_label_new ("Time :");
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, TRUE, 0);
- adj = (GtkAdjustment *) gtk_adjustment_new (1.0, 1.0, 31.0, 1.0,
- 5.0, 0.0);
+ adj = (GtkAdjustment *) gtk_adjustment_new (0, 0, 1410, 30, 60, 0);
spinner = gtk_spin_button_new (adj, 0, 0);
+ gtk_editable_set_editable (GTK_EDITABLE (spinner), FALSE);
+ gtk_signal_connect (GTK_OBJECT (spinner),
+ "output",
+ GTK_SIGNAL_FUNC (spin_button_time_output_func),
+ NULL);
gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spinner), TRUE);
- gtk_spin_button_set_shadow_type (GTK_SPIN_BUTTON (spinner),
- GTK_SHADOW_OUT);
+ gtk_widget_set_usize (spinner, 55, -1);
gtk_box_pack_start (GTK_BOX (vbox2), spinner, FALSE, TRUE, 0);
vbox2 = gtk_vbox_new (FALSE, 0);
adj = (GtkAdjustment *) gtk_adjustment_new (1.0, 1.0, 12.0, 1.0,
5.0, 0.0);
spinner = gtk_spin_button_new (adj, 0, 0);
+ gtk_spin_button_set_update_policy (GTK_SPIN_BUTTON (spinner),
+ GTK_UPDATE_IF_VALID);
+ gtk_signal_connect (GTK_OBJECT (spinner),
+ "input",
+ GTK_SIGNAL_FUNC (spin_button_month_input_func),
+ NULL);
+ gtk_signal_connect (GTK_OBJECT (spinner),
+ "output",
+ GTK_SIGNAL_FUNC (spin_button_month_output_func),
+ NULL);
gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spinner), TRUE);
- gtk_spin_button_set_shadow_type (GTK_SPIN_BUTTON (spinner),
- GTK_SHADOW_ETCHED_IN);
+ gtk_widget_set_usize (spinner, 85, -1);
gtk_box_pack_start (GTK_BOX (vbox2), spinner, FALSE, TRUE, 0);
vbox2 = gtk_vbox_new (FALSE, 0);
gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 5);
- label = gtk_label_new ("Year :");
+ label = gtk_label_new ("Hex :");
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, TRUE, 0);
- adj = (GtkAdjustment *) gtk_adjustment_new (1998.0, 0.0, 2100.0,
- 1.0, 100.0, 0.0);
+ adj = (GtkAdjustment *) gtk_adjustment_new (0, 0, 255, 1, 16, 0);
spinner = gtk_spin_button_new (adj, 0, 0);
+ gtk_editable_set_editable (GTK_EDITABLE (spinner), TRUE);
+ gtk_signal_connect (GTK_OBJECT (spinner),
+ "input",
+ GTK_SIGNAL_FUNC (spin_button_hex_input_func),
+ NULL);
+ gtk_signal_connect (GTK_OBJECT (spinner),
+ "output",
+ GTK_SIGNAL_FUNC (spin_button_hex_output_func),
+ NULL);
gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spinner), TRUE);
- gtk_spin_button_set_shadow_type (GTK_SPIN_BUTTON (spinner),
- GTK_SHADOW_IN);
gtk_widget_set_usize (spinner, 55, 0);
gtk_box_pack_start (GTK_BOX (vbox2), spinner, FALSE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 5);
vbox2 = gtk_vbox_new (FALSE, 0);
- gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 5);
+ gtk_box_pack_start (GTK_BOX (hbox), vbox2, FALSE, FALSE, 5);
label = gtk_label_new ("Value :");
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
0.5, 100.0, 0.0);
spinner1 = gtk_spin_button_new (adj, 1.0, 2);
gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spinner1), TRUE);
- gtk_widget_set_usize (spinner1, 100, 0);
gtk_box_pack_start (GTK_BOX (vbox2), spinner1, FALSE, TRUE, 0);
vbox2 = gtk_vbox_new (FALSE, 0);
- gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 5);
+ gtk_box_pack_start (GTK_BOX (hbox), vbox2, FALSE, FALSE, 5);
label = gtk_label_new ("Digits :");
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
adj = (GtkAdjustment *) gtk_adjustment_new (2, 1, 5, 1, 1, 0);
spinner2 = gtk_spin_button_new (adj, 0.0, 0);
- gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spinner2), TRUE);
gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
GTK_SIGNAL_FUNC (change_digits),
(gpointer) spinner2);
gtk_box_pack_start (GTK_BOX (vbox2), spinner2, FALSE, TRUE, 0);
hbox = gtk_hbox_new (FALSE, 0);
- gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 5);
+ gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 5);
button = gtk_check_button_new_with_label ("Snap to 0.5-ticks");
gtk_signal_connect (GTK_OBJECT (button), "clicked",
GTK_SIGNAL_FUNC (toggle_snap),
spinner1);
gtk_box_pack_start (GTK_BOX (vbox), button, TRUE, TRUE, 0);
- gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON (button), TRUE);
+ gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
button = gtk_check_button_new_with_label ("Numeric only input mode");
gtk_signal_connect (GTK_OBJECT (button), "clicked",
GTK_SIGNAL_FUNC (toggle_numeric),
spinner1);
gtk_box_pack_start (GTK_BOX (vbox), button, TRUE, TRUE, 0);
- gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON (button), TRUE);
+ gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
val_label = gtk_label_new ("");
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);
gtk_widget_destroy (window);
}
+
/*
* Cursors
*/
guint c;
GdkCursor *cursor;
GtkWidget *label;
- GtkFlagValue *vals;
+ GtkEnumValue *vals;
c = CLAMP (gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (spinner)), 0, 152);
c &= 0xfe;
label = gtk_object_get_user_data (GTK_OBJECT (spinner));
- vals = gtk_type_enum_get_values (GTK_TYPE_GDK_CURSOR_TYPE);
+ vals = gtk_type_enum_get_values (GDK_TYPE_CURSOR_TYPE);
while (vals && vals->value != c)
vals++;
if (vals)
cursor = gdk_cursor_new (c);
gdk_window_set_cursor (widget->window, cursor);
- gdk_cursor_destroy (cursor);
+ gdk_cursor_unref (cursor);
}
static gint
static void
list_remove (GtkWidget *widget,
- GtkWidget *list)
+ GtkList *list)
{
- GList *tmp_list;
- GList *clear_list;
-
- tmp_list = GTK_LIST (list)->selection;
- clear_list = NULL;
+ GList *clear_list = NULL;
+ GList *sel_row = NULL;
+ GList *work = NULL;
- while (tmp_list)
+ if (list->selection_mode == GTK_SELECTION_EXTENDED)
{
- clear_list = g_list_prepend (clear_list, tmp_list->data);
- tmp_list = tmp_list->next;
+ GtkWidget *item;
+
+ item = GTK_CONTAINER (list)->focus_child;
+ if (!item && list->selection)
+ item = list->selection->data;
+
+ if (item)
+ {
+ work = g_list_find (list->children, item);
+ for (sel_row = work; sel_row; sel_row = sel_row->next)
+ if (GTK_WIDGET (sel_row->data)->state != GTK_STATE_SELECTED)
+ break;
+
+ if (!sel_row)
+ {
+ for (sel_row = work; sel_row; sel_row = sel_row->prev)
+ if (GTK_WIDGET (sel_row->data)->state != GTK_STATE_SELECTED)
+ break;
+ }
+ }
}
- clear_list = g_list_reverse (clear_list);
+ for (work = list->selection; work; work = work->next)
+ clear_list = g_list_prepend (clear_list, work->data);
+ clear_list = g_list_reverse (clear_list);
gtk_list_remove_items (GTK_LIST (list), clear_list);
-
g_list_free (clear_list);
+
+ if (list->selection_mode == GTK_SELECTION_EXTENDED && sel_row)
+ gtk_list_select_child (list, GTK_WIDGET(sel_row->data));
}
static void
gtk_list_clear_items (GTK_LIST (list), 0, -1);
}
-static void
-list_undo_selection (GtkWidget *widget,
- GtkWidget *list)
-{
- gtk_list_undo_selection (GTK_LIST (list));
-}
-
#define RADIOMENUTOGGLED(_rmi_, __i) { \
GSList * __g; \
__i = 0; \
create_list (void)
{
static GtkWidget *window = NULL;
- GtkWidget *box1;
- GtkWidget *box2;
- GtkWidget *hbox;
- GtkWidget *label;
- GtkWidget *scrolled_win;
- GtkWidget *list;
- GtkWidget *button;
- GtkWidget *separator;
- GtkWidget *menu;
- GtkWidget *menu_item;
- GSList *group;
- FILE *infile;
+
+ static OptionMenuItem 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) }
+ };
if (!window)
{
+ GtkWidget *cbox;
+ GtkWidget *vbox;
+ GtkWidget *hbox;
+ GtkWidget *label;
+ GtkWidget *scrolled_win;
+ GtkWidget *list;
+ GtkWidget *button;
+ GtkWidget *separator;
+ FILE *infile;
+
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_signal_connect (GTK_OBJECT (window), "destroy",
gtk_window_set_title (GTK_WINDOW (window), "list");
gtk_container_set_border_width (GTK_CONTAINER (window), 0);
- box1 = gtk_vbox_new (FALSE, 0);
- gtk_container_add (GTK_CONTAINER (window), box1);
-
- box2 = gtk_vbox_new (FALSE, 10);
- gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
- gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
+ vbox = gtk_vbox_new (FALSE, 0);
+ gtk_container_add (GTK_CONTAINER (window), vbox);
scrolled_win = gtk_scrolled_window_new (NULL, NULL);
+ gtk_container_set_border_width (GTK_CONTAINER (scrolled_win), 5);
+ gtk_widget_set_usize (scrolled_win, -1, 300);
+ gtk_box_pack_start (GTK_BOX (vbox), scrolled_win, TRUE, TRUE, 0);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
- gtk_box_pack_start (GTK_BOX (box2), scrolled_win, TRUE, TRUE, 0);
- gtk_widget_set_usize (scrolled_win, -1, 300);
list = gtk_list_new ();
gtk_list_set_selection_mode (GTK_LIST (list), GTK_SELECTION_EXTENDED);
- gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (scrolled_win), list);
+ gtk_scrolled_window_add_with_viewport
+ (GTK_SCROLLED_WINDOW (scrolled_win), list);
gtk_container_set_focus_vadjustment
(GTK_CONTAINER (list),
gtk_scrolled_window_get_vadjustment
fclose (infile);
}
- hbox = gtk_hbox_new (TRUE, 10);
- gtk_box_pack_start (GTK_BOX (box2), hbox, FALSE, TRUE, 0);
- button = gtk_button_new_with_label ("Undo Selection");
- gtk_signal_connect (GTK_OBJECT (button), "clicked",
- GTK_SIGNAL_FUNC(list_undo_selection),
- list);
- gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
+ hbox = gtk_hbox_new (TRUE, 5);
+ gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
+ gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0);
- button = gtk_button_new_with_label ("Remove Selection");
+ button = gtk_button_new_with_label ("Insert Row");
+ gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
gtk_signal_connect (GTK_OBJECT (button), "clicked",
- GTK_SIGNAL_FUNC (list_remove),
+ GTK_SIGNAL_FUNC (list_add),
list);
- gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
button = gtk_button_new_with_label ("Clear List");
+ gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
gtk_signal_connect (GTK_OBJECT (button), "clicked",
GTK_SIGNAL_FUNC (list_clear),
list);
- gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
-
- hbox = gtk_hbox_new (FALSE, 10);
- gtk_box_pack_start (GTK_BOX (box2), hbox, FALSE, TRUE, 0);
- button = gtk_button_new_with_label ("Insert Row");
+ button = gtk_button_new_with_label ("Remove Selection");
+ gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
gtk_signal_connect (GTK_OBJECT (button), "clicked",
- GTK_SIGNAL_FUNC (list_add),
+ GTK_SIGNAL_FUNC (list_remove),
list);
- gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
+
+ cbox = gtk_hbox_new (FALSE, 0);
+ gtk_box_pack_start (GTK_BOX (vbox), cbox, FALSE, TRUE, 0);
+
+ hbox = gtk_hbox_new (FALSE, 5);
+ gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
+ gtk_box_pack_start (GTK_BOX (cbox), hbox, TRUE, FALSE, 0);
label = gtk_label_new ("Selection Mode :");
- gtk_signal_connect (GTK_OBJECT (button), "clicked",
- GTK_SIGNAL_FUNC(list_remove),
- list);
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
- list_omenu = gtk_option_menu_new ();
- menu = gtk_menu_new ();
- group = NULL;
-
- menu_item = gtk_radio_menu_item_new_with_label (group, "Single");
- gtk_signal_connect (GTK_OBJECT (menu_item), "activate",
- GTK_SIGNAL_FUNC (list_toggle_sel_mode), list);
- group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menu_item));
- gtk_menu_append (GTK_MENU (menu), menu_item);
- gtk_widget_show (menu_item);
-
- menu_item = gtk_radio_menu_item_new_with_label (group, "Browse");
- gtk_signal_connect (GTK_OBJECT (menu_item), "activate",
- GTK_SIGNAL_FUNC (list_toggle_sel_mode), list);
- group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menu_item));
- gtk_menu_append (GTK_MENU (menu), menu_item);
- gtk_widget_show (menu_item);
-
- menu_item = gtk_radio_menu_item_new_with_label (group, "Multiple");
- gtk_signal_connect (GTK_OBJECT (menu_item), "activate",
- GTK_SIGNAL_FUNC (list_toggle_sel_mode), list);
- group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menu_item));
- gtk_menu_append (GTK_MENU (menu), menu_item);
- gtk_widget_show (menu_item);
-
- menu_item = gtk_radio_menu_item_new_with_label (group, "Extended");
- gtk_signal_connect (GTK_OBJECT (menu_item), "activate",
- GTK_SIGNAL_FUNC (list_toggle_sel_mode), list);
- group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menu_item));
- gtk_menu_append (GTK_MENU (menu), menu_item);
- gtk_check_menu_item_set_state (GTK_CHECK_MENU_ITEM (menu_item), TRUE);
- gtk_widget_show (menu_item);
-
- gtk_option_menu_set_menu (GTK_OPTION_MENU (list_omenu), menu);
+ list_omenu = build_option_menu (items, 4, 3, list);
gtk_box_pack_start (GTK_BOX (hbox), list_omenu, FALSE, TRUE, 0);
-
- gtk_option_menu_set_history (GTK_OPTION_MENU (list_omenu), 3);
separator = gtk_hseparator_new ();
- gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
-
+ gtk_box_pack_start (GTK_BOX (vbox), 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);
+ cbox = gtk_hbox_new (FALSE, 0);
+ gtk_box_pack_start (GTK_BOX (vbox), cbox, FALSE, TRUE, 0);
button = gtk_button_new_with_label ("close");
+ gtk_container_set_border_width (GTK_CONTAINER (button), 10);
+ gtk_box_pack_start (GTK_BOX (cbox), button, TRUE, TRUE, 0);
gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
GTK_SIGNAL_FUNC(gtk_widget_destroy),
GTK_OBJECT (window));
- gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
gtk_widget_grab_default (button);
" >%$$ ",
" >= "};
-#define TESTGTK_CLIST_COLUMNS 20
+#define TESTGTK_CLIST_COLUMNS 12
static gint clist_rows = 0;
static GtkWidget *clist_omenu;
clist_rows = 0;
}
-void
-remove_row_clist (GtkWidget *widget, gpointer data)
-{
- gtk_clist_remove (GTK_CLIST (data), GTK_CLIST (data)->focus_row);
- clist_rows--;
-}
-
-void
-show_titles_clist (GtkWidget *widget, gpointer data)
-{
- gtk_clist_column_titles_show (GTK_CLIST (data));
-}
-
-void
-hide_titles_clist (GtkWidget *widget, gpointer data)
-{
- gtk_clist_column_titles_hide (GTK_CLIST (data));
-}
-
-void toggle_reorderable (GtkWidget *widget, GtkCList *clist)
-{
- gtk_clist_set_reorderable (clist, GTK_TOGGLE_BUTTON (widget)->active);
-}
-
-void
-select_clist (GtkWidget *widget,
- gint row,
- gint column,
- GdkEventButton * bevent,
- GtkWidget *button)
+void clist_remove_selection (GtkWidget *widget, GtkCList *clist)
{
- gint i;
- guint8 spacing;
- gchar *text;
- GdkPixmap *pixmap;
- GdkBitmap *mask;
- GList *list;
-
- g_print ("GtkCList Selection: row %d column %d button %d\n",
- row, column, bevent ? bevent->button : 0);
+ gtk_clist_freeze (clist);
- for (i = 0; i < TESTGTK_CLIST_COLUMNS; i++)
+ while (clist->selection)
{
- switch (gtk_clist_get_cell_type (GTK_CLIST (widget), row, i))
- {
- case GTK_CELL_TEXT:
- g_print ("CELL %d GTK_CELL_TEXT\n", i);
- gtk_clist_get_text (GTK_CLIST (widget), row, i, &text);
- g_print ("TEXT: %s\n", text);
- break;
+ gint row;
- case GTK_CELL_PIXMAP:
- g_print ("CELL %d GTK_CELL_PIXMAP\n", i);
- gtk_clist_get_pixmap (GTK_CLIST (widget), row, i, &pixmap, &mask);
- g_print ("PIXMAP: %p\n", pixmap);
- g_print ("MASK: %p\n", mask);
- break;
+ clist_rows--;
+ row = GPOINTER_TO_INT (clist->selection->data);
- case GTK_CELL_PIXTEXT:
- g_print ("CELL %d GTK_CELL_PIXTEXT\n", i);
- gtk_clist_get_pixtext (GTK_CLIST (widget), row, i, &text, &spacing, &pixmap, &mask);
- g_print ("TEXT: %s\n", text);
- g_print ("SPACING: %d\n", spacing);
- g_print ("PIXMAP: %p\n", pixmap);
- g_print ("MASK: %p\n", mask);
- break;
+ gtk_clist_remove (clist, row);
- default:
- break;
- }
+ if (clist->selection_mode == GTK_SELECTION_BROWSE)
+ break;
}
- /* print selections list */
- g_print ("\nSelected Rows:");
- list = GTK_CLIST (widget)->selection;
- while (list)
- {
- g_print (" %d ", GPOINTER_TO_INT (list->data));
- list = list->next;
- }
+ if (clist->selection_mode == GTK_SELECTION_EXTENDED && !clist->selection &&
+ clist->focus_row >= 0)
+ gtk_clist_select_row (clist, clist->focus_row, -1);
- g_print ("\n\n\n");
+ gtk_clist_thaw (clist);
}
-void
-unselect_clist (GtkWidget *widget,
- gint row,
- gint column,
- GdkEventButton * bevent,
- GtkWidget *button)
+void toggle_title_buttons (GtkWidget *widget, GtkCList *clist)
{
- gint i;
- guint8 spacing;
- gchar *text;
- GdkPixmap *pixmap;
- GdkBitmap *mask;
- GList *list;
-
- g_print ("GtkCList Unselection: row %d column %d button %d\n",
- row, column, bevent ? bevent->button : 0);
-
- for (i = 0; i < TESTGTK_CLIST_COLUMNS; i++)
- {
- switch (gtk_clist_get_cell_type (GTK_CLIST (widget), row, i))
- {
- case GTK_CELL_TEXT:
- g_print ("CELL %d GTK_CELL_TEXT\n", i);
- gtk_clist_get_text (GTK_CLIST (widget), row, i, &text);
- g_print ("TEXT: %s\n", text);
- break;
-
- case GTK_CELL_PIXMAP:
- g_print ("CELL %d GTK_CELL_PIXMAP\n", i);
- gtk_clist_get_pixmap (GTK_CLIST (widget), row, i, &pixmap, &mask);
- g_print ("PIXMAP: %p\n", pixmap);
- g_print ("MASK: %p\n", mask);
- break;
-
- case GTK_CELL_PIXTEXT:
- g_print ("CELL %d GTK_CELL_PIXTEXT\n", i);
- gtk_clist_get_pixtext (GTK_CLIST (widget), row, i, &text, &spacing, &pixmap, &mask);
- g_print ("TEXT: %s\n", text);
- g_print ("SPACING: %d\n", spacing);
- g_print ("PIXMAP: %p\n", pixmap);
- g_print ("MASK: %p\n", mask);
- break;
-
- default:
- break;
- }
- }
-
- /* print selections list */
- g_print ("\nSelected Rows:");
- list = GTK_CLIST (widget)->selection;
- while (list)
- {
- g_print (" %d ", GPOINTER_TO_INT (list->data));
- list = list->next;
- }
+ if (GTK_TOGGLE_BUTTON (widget)->active)
+ gtk_clist_column_titles_show (clist);
+ else
+ gtk_clist_column_titles_hide (clist);
+}
- g_print ("\n\n\n");
+void toggle_reorderable (GtkWidget *widget, GtkCList *clist)
+{
+ gtk_clist_set_reorderable (clist, GTK_TOGGLE_BUTTON (widget)->active);
}
static void
{
static char *text[] =
{
- "This", "is", "an", "inserted", "row.",
- "This", "is", "an", "inserted", "row.",
- "This", "is", "an", "inserted", "row.",
- "This", "is", "an", "inserted", "row."
+ "This", "is an", "inserted", "row.",
+ "This", "is an", "inserted", "row.",
+ "This", "is an", "inserted", "row."
};
static GtkStyle *style1 = NULL;
style3 = gtk_style_copy (GTK_WIDGET (data)->style);
style3->fg[GTK_STATE_NORMAL] = col1;
style3->base[GTK_STATE_NORMAL] = col2;
- gdk_font_unref (style3->font);
- style3->font =
- gdk_font_load ("-*-courier-medium-*-*-*-*-120-*-*-*-*-*-*");
+ pango_font_description_free (style3->font_desc);
+ style3->font_desc = pango_font_description_from_string ("courier 12");
}
gtk_clist_set_cell_style (GTK_CLIST (data), row, 3, style1);
{
"auto resize", "not resizeable", "max width 100", "min width 50",
"hide column", "Title 5", "Title 6", "Title 7",
- "Title 8", "Title 9", "Title 10", "Title 11", "Title 12",
- "Title 13", "Title 14", "Title 15", "Title 16", "Title 17",
- "Title 18", "Title 19"
+ "Title 8", "Title 9", "Title 10", "Title 11"
};
static OptionMenuItem items[] =
{
- { "Single", clist_toggle_sel_mode },
- { "Browse", clist_toggle_sel_mode },
- { "Multiple", clist_toggle_sel_mode },
- { "Extended", clist_toggle_sel_mode }
+ { "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) }
};
char text[TESTGTK_CLIST_COLUMNS][50];
char *texts[TESTGTK_CLIST_COLUMNS];
- GtkWidget *box1;
- GtkWidget *box2;
+ GtkWidget *vbox;
+ GtkWidget *hbox;
GtkWidget *clist;
GtkWidget *button;
GtkWidget *separator;
gtk_window_set_title (GTK_WINDOW (window), "clist");
gtk_container_set_border_width (GTK_CONTAINER (window), 0);
- box1 = gtk_vbox_new (FALSE, 0);
- gtk_container_add (GTK_CONTAINER (window), box1);
-
- box2 = gtk_hbox_new (FALSE, 10);
- gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
- gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0);
+ vbox = gtk_vbox_new (FALSE, 0);
+ gtk_container_add (GTK_CONTAINER (window), vbox);
- /* create GtkCList here so we have a pointer to throw at the
- * button callbacks -- more is done with it later */
- clist = gtk_clist_new_with_titles (TESTGTK_CLIST_COLUMNS, titles);
- gtk_widget_show (clist);
scrolled_win = gtk_scrolled_window_new (NULL, NULL);
+ gtk_container_set_border_width (GTK_CONTAINER (scrolled_win), 5);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
- gtk_container_add (GTK_CONTAINER (scrolled_win), clist);
+ /* create GtkCList here so we have a pointer to throw at the
+ * button callbacks -- more is done with it later */
+ clist = gtk_clist_new_with_titles (TESTGTK_CLIST_COLUMNS, titles);
+ gtk_container_add (GTK_CONTAINER (scrolled_win), clist);
gtk_signal_connect (GTK_OBJECT (clist), "click_column",
(GtkSignalFunc) clist_click_column, NULL);
/* control buttons */
- button = gtk_button_new_with_label ("Add 1,000 Rows With Pixmaps");
- gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
+ hbox = gtk_hbox_new (FALSE, 5);
+ gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
+ gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
+
+ button = gtk_button_new_with_label ("Insert Row");
+ gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
+ gtk_signal_connect (GTK_OBJECT (button), "clicked",
+ (GtkSignalFunc) insert_row_clist, (gpointer) clist);
+ button = gtk_button_new_with_label ("Add 1,000 Rows With Pixmaps");
+ gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
gtk_signal_connect (GTK_OBJECT (button), "clicked",
(GtkSignalFunc) add1000_clist, (gpointer) clist);
button = gtk_button_new_with_label ("Add 10,000 Rows");
- gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
-
+ gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
gtk_signal_connect (GTK_OBJECT (button), "clicked",
(GtkSignalFunc) add10000_clist, (gpointer) clist);
- button = gtk_button_new_with_label ("Clear List");
- gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
-
- gtk_signal_connect (GTK_OBJECT (button), "clicked",
- (GtkSignalFunc) clear_clist, (gpointer) clist);
-
- button = gtk_button_new_with_label ("Remove Row");
- gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
-
- gtk_signal_connect (GTK_OBJECT (button), "clicked",
- (GtkSignalFunc) remove_row_clist, (gpointer) clist);
-
/* second layer of buttons */
- box2 = gtk_hbox_new (FALSE, 10);
- gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
- gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0);
-
- button = gtk_button_new_with_label ("Insert Row");
- gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
+ hbox = gtk_hbox_new (FALSE, 5);
+ gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
+ gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
+ button = gtk_button_new_with_label ("Clear List");
+ gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
gtk_signal_connect (GTK_OBJECT (button), "clicked",
- (GtkSignalFunc) insert_row_clist, (gpointer) clist);
-
- button = gtk_button_new_with_label ("Show Title Buttons");
- gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
+ (GtkSignalFunc) clear_clist, (gpointer) clist);
+ button = gtk_button_new_with_label ("Remove Selection");
+ gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
gtk_signal_connect (GTK_OBJECT (button), "clicked",
- (GtkSignalFunc) show_titles_clist, (gpointer) clist);
+ (GtkSignalFunc) clist_remove_selection,
+ (gpointer) clist);
- button = gtk_button_new_with_label ("Hide Title Buttons");
- gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
-
- gtk_signal_connect (GTK_OBJECT (button), "clicked",
- (GtkSignalFunc) hide_titles_clist, (gpointer) clist);
+ undo_button = gtk_button_new_with_label ("Undo Selection");
+ gtk_box_pack_start (GTK_BOX (hbox), undo_button, TRUE, TRUE, 0);
+ gtk_signal_connect (GTK_OBJECT (undo_button), "clicked",
+ (GtkSignalFunc) undo_selection, (gpointer) clist);
button = gtk_button_new_with_label ("Warning Test");
- gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
-
+ gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
gtk_signal_connect (GTK_OBJECT (button), "clicked",
(GtkSignalFunc) clist_warning_test,(gpointer) clist);
- box2 = gtk_hbox_new (FALSE, 10);
- gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
- gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0);
+ /* third layer of buttons */
+ hbox = gtk_hbox_new (FALSE, 5);
+ gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
+ gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
- undo_button = gtk_button_new_with_label ("Undo last selection");
- gtk_box_pack_start (GTK_BOX (box2), undo_button, TRUE, TRUE, 0);
- gtk_signal_connect (GTK_OBJECT (undo_button), "clicked",
- (GtkSignalFunc) undo_selection, (gpointer) clist);
+ check = gtk_check_button_new_with_label ("Show Title Buttons");
+ gtk_box_pack_start (GTK_BOX (hbox), check, FALSE, TRUE, 0);
+ gtk_signal_connect (GTK_OBJECT (check), "clicked",
+ GTK_SIGNAL_FUNC (toggle_title_buttons), clist);
+ gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check), TRUE);
check = gtk_check_button_new_with_label ("Reorderable");
+ gtk_box_pack_start (GTK_BOX (hbox), check, FALSE, TRUE, 0);
gtk_signal_connect (GTK_OBJECT (check), "clicked",
GTK_SIGNAL_FUNC (toggle_reorderable), clist);
- gtk_box_pack_start (GTK_BOX (box2), check, FALSE, TRUE, 0);
- gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON (check), TRUE);
+ gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check), TRUE);
label = gtk_label_new ("Selection Mode :");
- gtk_box_pack_start (GTK_BOX (box2), label, FALSE, TRUE, 0);
+ gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
clist_omenu = build_option_menu (items, 4, 3, clist);
- gtk_box_pack_start (GTK_BOX (box2), clist_omenu, FALSE, TRUE, 0);
-
- /* vbox for the list itself */
- 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_box_pack_start (GTK_BOX (hbox), clist_omenu, FALSE, TRUE, 0);
/*
* the rest of the clist configuration
*/
+ gtk_box_pack_start (GTK_BOX (vbox), scrolled_win, TRUE, TRUE, 0);
gtk_clist_set_row_height (GTK_CLIST (clist), 18);
gtk_widget_set_usize (clist, -1, 300);
gtk_clist_set_column_resizeable (GTK_CLIST (clist), 1, FALSE);
gtk_clist_set_column_max_width (GTK_CLIST (clist), 2, 100);
gtk_clist_set_column_min_width (GTK_CLIST (clist), 3, 50);
-
gtk_clist_set_selection_mode (GTK_CLIST (clist), GTK_SELECTION_EXTENDED);
-
gtk_clist_set_column_justification (GTK_CLIST (clist), 1,
GTK_JUSTIFY_RIGHT);
gtk_clist_set_column_justification (GTK_CLIST (clist), 2,
style = gtk_style_new ();
style->fg[GTK_STATE_NORMAL] = col1;
style->base[GTK_STATE_NORMAL] = col2;
-
- gdk_font_unref (style->font);
- style->font =
- gdk_font_load ("-adobe-helvetica-bold-r-*-*-*-140-*-*-*-*-*-*");
+
+ style->font_desc->size = 14 * PANGO_SCALE;
+ style->font_desc->weight = PANGO_WEIGHT_BOLD;
for (i = 0; i < 10; i++)
{
}
}
- gtk_container_set_border_width (GTK_CONTAINER (scrolled_win), 5);
- gtk_box_pack_start (GTK_BOX (box2), scrolled_win, TRUE, TRUE, 0);
-
+ gtk_style_unref (style);
+
separator = gtk_hseparator_new ();
- gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
+ gtk_box_pack_start (GTK_BOX (vbox), 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);
+ hbox = gtk_hbox_new (FALSE, 0);
+ gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0);
button = gtk_button_new_with_label ("close");
+ gtk_container_set_border_width (GTK_CONTAINER (button), 10);
+ gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
GTK_SIGNAL_FUNC(gtk_widget_destroy),
GTK_OBJECT (window));
- gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
gtk_widget_grab_default (button);
}
style2->base[GTK_STATE_SELECTED] = col2;
style2->fg[GTK_STATE_NORMAL] = col1;
style2->base[GTK_STATE_NORMAL] = col2;
- gdk_font_unref (style2->font);
- style2->font =
- gdk_font_load ("-*-courier-medium-*-*-*-*-300-*-*-*-*-*-*");
+ pango_font_description_free (style2->font_desc);
+ style2->font_desc = pango_font_description_from_string ("courier 30");
}
gtk_ctree_node_set_cell_style (ctree, node, 1, style1);
{
GtkCList *clist;
GtkCTreeNode *node;
- GList *selection;
- GList *list = NULL;
clist = GTK_CLIST (ctree);
gtk_clist_freeze (clist);
- for (selection = clist->selection; selection; selection = selection->next)
- list = g_list_prepend (list, selection->data);
-
- selection = clist->selection;
- while (selection)
+ while (clist->selection)
{
- node = selection->data;
-
- if (!g_list_find (list, node))
- break;
+ node = clist->selection->data;
if (GTK_CTREE_ROW (node)->is_leaf)
pages--;
else
- gtk_ctree_post_recursive (ctree, node,
+ gtk_ctree_post_recursive (ctree, node,
(GtkCTreeFunc) count_items, NULL);
gtk_ctree_remove_node (ctree, node);
- selection = clist->selection;
+
+ if (clist->selection_mode == GTK_SELECTION_BROWSE)
+ break;
}
- g_list_free (list);
+
+ if (clist->selection_mode == GTK_SELECTION_EXTENDED && !clist->selection &&
+ clist->focus_row >= 0)
+ {
+ node = gtk_ctree_node_nth (ctree, clist->focus_row);
+
+ if (node)
+ gtk_ctree_select (ctree, node);
+ }
+
gtk_clist_thaw (clist);
after_press (ctree, NULL);
}
GtkWidget *check;
GtkAdjustment *adj;
GtkWidget *spinner;
- GdkColor transparent;
+ GdkColor transparent = { 0 };
char *title[] = { "Tree" , "Info" };
char buf[80];
static OptionMenuItem items1[] =
{
- { "No lines", ctree_toggle_line_style },
- { "Solid", ctree_toggle_line_style },
- { "Dotted", ctree_toggle_line_style },
- { "Tabbed", ctree_toggle_line_style }
+ { "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) }
};
static OptionMenuItem items2[] =
{
- { "None", ctree_toggle_expander_style },
- { "Square", ctree_toggle_expander_style },
- { "Triangle", ctree_toggle_expander_style },
- { "Circular", ctree_toggle_expander_style }
+ { "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) }
};
static OptionMenuItem items3[] =
{
- { "Left", ctree_toggle_justify },
- { "Right", ctree_toggle_justify }
+ { "Left", GTK_SIGNAL_FUNC (ctree_toggle_justify) },
+ { "Right", GTK_SIGNAL_FUNC (ctree_toggle_justify) }
};
static OptionMenuItem items4[] =
{
- { "Single", ctree_toggle_sel_mode },
- { "Browse", ctree_toggle_sel_mode },
- { "Multiple", ctree_toggle_sel_mode },
- { "Extended", ctree_toggle_sel_mode }
+ { "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) }
};
if (!window)
(GtkSignalFunc) gtk_widget_destroy,
GTK_OBJECT(window));
- button = gtk_button_new_with_label ("Rebuild tree");
+ button = gtk_button_new_with_label ("Rebuild Tree");
gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
+ scrolled_win = gtk_scrolled_window_new (NULL, NULL);
+ gtk_container_set_border_width (GTK_CONTAINER (scrolled_win), 5);
+ gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
+ GTK_POLICY_AUTOMATIC,
+ GTK_POLICY_ALWAYS);
+ gtk_box_pack_start (GTK_BOX (vbox), scrolled_win, TRUE, TRUE, 0);
+
ctree = GTK_CTREE (gtk_ctree_new_with_titles (2, 0, title));
- gtk_signal_connect (GTK_OBJECT (button), "clicked",
- GTK_SIGNAL_FUNC (rebuild_tree), ctree);
-
+ gtk_container_add (GTK_CONTAINER (scrolled_win), GTK_WIDGET (ctree));
+
+ gtk_clist_set_column_auto_resize (GTK_CLIST (ctree), 0, TRUE);
+ gtk_clist_set_column_width (GTK_CLIST (ctree), 1, 200);
+ gtk_clist_set_selection_mode (GTK_CLIST (ctree), GTK_SELECTION_EXTENDED);
gtk_ctree_set_line_style (ctree, GTK_CTREE_LINES_DOTTED);
line_style = GTK_CTREE_LINES_DOTTED;
+ gtk_signal_connect (GTK_OBJECT (button), "clicked",
+ GTK_SIGNAL_FUNC (rebuild_tree), ctree);
gtk_signal_connect (GTK_OBJECT (ctree), "click_column",
- (GtkSignalFunc) ctree_click_column,
- NULL);
+ (GtkSignalFunc) ctree_click_column, NULL);
+
gtk_signal_connect_after (GTK_OBJECT (ctree), "button_press_event",
GTK_SIGNAL_FUNC (after_press), NULL);
gtk_signal_connect_after (GTK_OBJECT (ctree), "button_release_event",
GTK_SIGNAL_FUNC (after_press), NULL);
gtk_signal_connect_after (GTK_OBJECT (ctree), "scroll_vertical",
GTK_SIGNAL_FUNC (after_press), NULL);
-
- scrolled_win = gtk_scrolled_window_new (NULL, NULL);
- gtk_container_add (GTK_CONTAINER (scrolled_win), GTK_WIDGET (ctree));
- gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
- GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
- gtk_container_set_border_width (GTK_CONTAINER (scrolled_win), 5);
- gtk_box_pack_start (GTK_BOX (vbox), scrolled_win, TRUE, TRUE, 0);
- gtk_clist_set_selection_mode (GTK_CLIST (ctree), GTK_SELECTION_EXTENDED);
- gtk_clist_set_column_auto_resize (GTK_CLIST (ctree), 0, TRUE);
- gtk_clist_set_column_width (GTK_CLIST (ctree), 1, 200);
bbox = gtk_hbox_new (FALSE, 5);
gtk_container_set_border_width (GTK_CONTAINER (bbox), 5);
mbox = gtk_vbox_new (TRUE, 5);
gtk_box_pack_start (GTK_BOX (bbox), mbox, FALSE, TRUE, 0);
- label = gtk_label_new ("Row height :");
+ label = gtk_label_new ("Row Height :");
gtk_box_pack_start (GTK_BOX (mbox), label, FALSE, FALSE, 0);
label = gtk_label_new ("Indent :");
adj = (GtkAdjustment *) gtk_adjustment_new (20, 12, 100, 1, 10, 0);
spinner = gtk_spin_button_new (adj, 0, 0);
+ gtk_box_pack_start (GTK_BOX (mbox), spinner, FALSE, FALSE, 5);
gtk_tooltips_set_tip (tooltips, spinner,
"Row height of list items", NULL);
gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
GTK_SIGNAL_FUNC (change_row_height), ctree);
- gtk_box_pack_start (GTK_BOX (mbox), spinner, FALSE, FALSE, 5);
gtk_clist_set_row_height ( GTK_CLIST (ctree), adj->value);
adj = (GtkAdjustment *) gtk_adjustment_new (20, 0, 60, 1, 10, 0);
spinner = gtk_spin_button_new (adj, 0, 0);
- gtk_tooltips_set_tip (tooltips, spinner, "Tree indentation.", NULL);
+ gtk_box_pack_start (GTK_BOX (mbox), spinner, FALSE, FALSE, 5);
+ gtk_tooltips_set_tip (tooltips, spinner, "Tree Indentation.", NULL);
gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
GTK_SIGNAL_FUNC (change_indent), ctree);
- gtk_box_pack_start (GTK_BOX (mbox), spinner, FALSE, FALSE, 5);
adj = (GtkAdjustment *) gtk_adjustment_new (5, 0, 60, 1, 10, 0);
spinner = gtk_spin_button_new (adj, 0, 0);
- gtk_tooltips_set_tip (tooltips, spinner, "Tree spacing.", NULL);
+ gtk_box_pack_start (GTK_BOX (mbox), spinner, FALSE, FALSE, 5);
+ gtk_tooltips_set_tip (tooltips, spinner, "Tree Spacing.", NULL);
gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
GTK_SIGNAL_FUNC (change_spacing), ctree);
- gtk_box_pack_start (GTK_BOX (mbox), spinner, FALSE, FALSE, 5);
mbox = gtk_vbox_new (TRUE, 5);
gtk_box_pack_start (GTK_BOX (bbox), mbox, FALSE, TRUE, 0);
hbox = gtk_hbox_new (FALSE, 5);
gtk_box_pack_start (GTK_BOX (mbox), hbox, FALSE, FALSE, 0);
- button = gtk_button_new_with_label ("Expand all");
+ button = gtk_button_new_with_label ("Expand All");
+ gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
gtk_signal_connect (GTK_OBJECT (button), "clicked",
GTK_SIGNAL_FUNC (expand_all), ctree);
- gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
- button = gtk_button_new_with_label ("Collapse all");
+ button = gtk_button_new_with_label ("Collapse All");
+ gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
gtk_signal_connect (GTK_OBJECT (button), "clicked",
GTK_SIGNAL_FUNC (collapse_all), ctree);
- gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
button = gtk_button_new_with_label ("Change Style");
+ gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
gtk_signal_connect (GTK_OBJECT (button), "clicked",
GTK_SIGNAL_FUNC (change_style), ctree);
- gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
- button = gtk_button_new_with_label ("Export tree");
+ button = gtk_button_new_with_label ("Export Tree");
+ gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
gtk_signal_connect (GTK_OBJECT (button), "clicked",
GTK_SIGNAL_FUNC (export_ctree), ctree);
- gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
hbox = gtk_hbox_new (FALSE, 5);
gtk_box_pack_start (GTK_BOX (mbox), hbox, FALSE, FALSE, 0);
- button = gtk_button_new_with_label ("Select all");
+ button = gtk_button_new_with_label ("Select All");
+ gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
gtk_signal_connect (GTK_OBJECT (button), "clicked",
GTK_SIGNAL_FUNC (select_all), ctree);
- gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
- button = gtk_button_new_with_label ("Unselect all");
+ button = gtk_button_new_with_label ("Unselect All");
+ gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
gtk_signal_connect (GTK_OBJECT (button), "clicked",
GTK_SIGNAL_FUNC (unselect_all), ctree);
- gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
- button = gtk_button_new_with_label ("Remove selection");
+ button = gtk_button_new_with_label ("Remove Selection");
+ gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
gtk_signal_connect (GTK_OBJECT (button), "clicked",
GTK_SIGNAL_FUNC (remove_selection), ctree);
- gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
check = gtk_check_button_new_with_label ("Reorderable");
+ gtk_box_pack_start (GTK_BOX (hbox), check, FALSE, TRUE, 0);
gtk_tooltips_set_tip (tooltips, check,
"Tree items can be reordered by dragging.", NULL);
gtk_signal_connect (GTK_OBJECT (check), "clicked",
GTK_SIGNAL_FUNC (toggle_reorderable), ctree);
- gtk_box_pack_start (GTK_BOX (hbox), check, FALSE, TRUE, 0);
- gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON (check), TRUE);
+ gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check), TRUE);
hbox = gtk_hbox_new (TRUE, 5);
gtk_box_pack_start (GTK_BOX (mbox), hbox, FALSE, FALSE, 0);
-
+
omenu1 = build_option_menu (items1, 4, 2, ctree);
- gtk_tooltips_set_tip (tooltips, omenu1, "The tree's line style.", NULL);
gtk_box_pack_start (GTK_BOX (hbox), omenu1, FALSE, TRUE, 0);
-
+ gtk_tooltips_set_tip (tooltips, omenu1, "The tree's line style.", NULL);
+
omenu2 = build_option_menu (items2, 4, 1, ctree);
+ gtk_box_pack_start (GTK_BOX (hbox), omenu2, FALSE, TRUE, 0);
gtk_tooltips_set_tip (tooltips, omenu2, "The tree's expander style.",
NULL);
- gtk_box_pack_start (GTK_BOX (hbox), omenu2, FALSE, TRUE, 0);
omenu3 = build_option_menu (items3, 2, 0, ctree);
+ gtk_box_pack_start (GTK_BOX (hbox), omenu3, FALSE, TRUE, 0);
gtk_tooltips_set_tip (tooltips, omenu3, "The tree's justification.",
NULL);
- gtk_box_pack_start (GTK_BOX (hbox), omenu3, FALSE, TRUE, 0);
-
+
omenu4 = build_option_menu (items4, 4, 3, ctree);
+ gtk_box_pack_start (GTK_BOX (hbox), omenu4, FALSE, TRUE, 0);
gtk_tooltips_set_tip (tooltips, omenu4, "The list's selection mode.",
NULL);
- gtk_box_pack_start (GTK_BOX (hbox), omenu4, FALSE, TRUE, 0);
-
+
gtk_widget_realize (window);
-
- pixmap1 = gdk_pixmap_create_from_xpm_d (window->window, &mask1,
- &transparent, book_closed_xpm);
- pixmap2 = gdk_pixmap_create_from_xpm_d (window->window, &mask2,
- &transparent, book_open_xpm);
- pixmap3 = gdk_pixmap_create_from_xpm_d (window->window, &mask3,
- &transparent, mini_page_xpm);
-
+
+ if (!pixmap1)
+ pixmap1 = gdk_pixmap_create_from_xpm_d (window->window, &mask1,
+ &transparent, book_closed_xpm);
+ if (!pixmap2)
+ pixmap2 = gdk_pixmap_create_from_xpm_d (window->window, &mask2,
+ &transparent, book_open_xpm);
+ if (!pixmap3)
+ pixmap3 = gdk_pixmap_create_from_xpm_d (window->window, &mask3,
+ &transparent, mini_page_xpm);
+
gtk_widget_set_usize (GTK_WIDGET (ctree), 0, 300);
-
+
frame = gtk_frame_new (NULL);
gtk_container_set_border_width (GTK_CONTAINER (frame), 0);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_OUT);
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, TRUE, 0);
-
+
hbox = gtk_hbox_new (TRUE, 2);
gtk_container_set_border_width (GTK_CONTAINER (hbox), 2);
gtk_container_add (GTK_CONTAINER (frame), hbox);
-
+
frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, TRUE, 0);
-
+
hbox2 = gtk_hbox_new (FALSE, 0);
gtk_container_set_border_width (GTK_CONTAINER (hbox2), 2);
gtk_container_add (GTK_CONTAINER (frame), hbox2);
-
+
label = gtk_label_new ("Books :");
gtk_box_pack_start (GTK_BOX (hbox2), label, FALSE, TRUE, 0);
-
+
sprintf (buf, "%d", books);
book_label = gtk_label_new (buf);
gtk_box_pack_end (GTK_BOX (hbox2), book_label, FALSE, TRUE, 5);
-
+
frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, TRUE, 0);
-
+
hbox2 = gtk_hbox_new (FALSE, 0);
gtk_container_set_border_width (GTK_CONTAINER (hbox2), 2);
gtk_container_add (GTK_CONTAINER (frame), hbox2);
-
+
label = gtk_label_new ("Pages :");
gtk_box_pack_start (GTK_BOX (hbox2), label, FALSE, TRUE, 0);
-
+
sprintf (buf, "%d", pages);
page_label = gtk_label_new (buf);
gtk_box_pack_end (GTK_BOX (hbox2), page_label, FALSE, TRUE, 5);
-
+
frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, TRUE, 0);
-
+
hbox2 = gtk_hbox_new (FALSE, 0);
gtk_container_set_border_width (GTK_CONTAINER (hbox2), 2);
gtk_container_add (GTK_CONTAINER (frame), hbox2);
-
+
label = gtk_label_new ("Selected :");
gtk_box_pack_start (GTK_BOX (hbox2), label, FALSE, TRUE, 0);
-
+
sprintf (buf, "%d", g_list_length (GTK_CLIST (ctree)->selection));
sel_label = gtk_label_new (buf);
gtk_box_pack_end (GTK_BOX (hbox2), sel_label, FALSE, TRUE, 5);
-
+
frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, TRUE, 0);
-
+
hbox2 = gtk_hbox_new (FALSE, 0);
gtk_container_set_border_width (GTK_CONTAINER (hbox2), 2);
gtk_container_add (GTK_CONTAINER (frame), hbox2);
-
+
label = gtk_label_new ("Visible :");
gtk_box_pack_start (GTK_BOX (hbox2), label, FALSE, TRUE, 0);
-
+
sprintf (buf, "%d", g_list_length (GTK_CLIST (ctree)->row_list));
vis_label = gtk_label_new (buf);
gtk_box_pack_end (GTK_BOX (hbox2), vis_label, FALSE, TRUE, 5);
gtk_color_selection_get_color(colorsel,color);
}
+static void
+opacity_toggled_cb (GtkWidget *w,
+ GtkColorSelectionDialog *cs)
+{
+ GtkColorSelection *colorsel;
+
+ colorsel = GTK_COLOR_SELECTION (cs->colorsel);
+ gtk_color_selection_set_has_opacity_control (colorsel,
+ gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (w)));
+}
+
+static void
+palette_toggled_cb (GtkWidget *w,
+ GtkColorSelectionDialog *cs)
+{
+ GtkColorSelection *colorsel;
+
+ colorsel = GTK_COLOR_SELECTION (cs->colorsel);
+ gtk_color_selection_set_has_palette (colorsel,
+ gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (w)));
+}
+
void
create_color_selection (void)
{
if (!window)
{
+ GtkWidget *options_hbox;
+ GtkWidget *check_button;
+
window = gtk_color_selection_dialog_new ("color selection dialog");
- gtk_color_selection_set_opacity (
- GTK_COLOR_SELECTION (GTK_COLOR_SELECTION_DIALOG (window)->colorsel),
- TRUE);
-
- gtk_color_selection_set_update_policy(
- GTK_COLOR_SELECTION (GTK_COLOR_SELECTION_DIALOG (window)->colorsel),
- GTK_UPDATE_CONTINUOUS);
-
gtk_window_set_position (GTK_WINDOW (window), GTK_WIN_POS_MOUSE);
gtk_signal_connect (GTK_OBJECT (window), "destroy",
GTK_SIGNAL_FUNC(gtk_widget_destroyed),
&window);
+ options_hbox = gtk_hbox_new (FALSE, 0);
+ gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), options_hbox, FALSE, FALSE, 0);
+ gtk_container_set_border_width (GTK_CONTAINER (options_hbox), 10);
+
+ check_button = gtk_check_button_new_with_label ("Show Opacity");
+ gtk_box_pack_start (GTK_BOX (options_hbox), check_button, FALSE, FALSE, 0);
+ gtk_signal_connect (GTK_OBJECT (check_button), "toggled",
+ GTK_SIGNAL_FUNC (opacity_toggled_cb), window);
+
+ check_button = gtk_check_button_new_with_label ("Show Palette");
+ gtk_box_pack_end (GTK_BOX (options_hbox), check_button, FALSE, FALSE, 0);
+ gtk_signal_connect (GTK_OBJECT (check_button), "toggled",
+ GTK_SIGNAL_FUNC (palette_toggled_cb), window);
+
+ gtk_widget_show_all (options_hbox);
+
gtk_signal_connect (
GTK_OBJECT (GTK_COLOR_SELECTION_DIALOG (window)->colorsel),
"color_changed",
gtk_widget_destroy (window);
}
-/*
- * GtkFontSelection
- */
-
void
-font_selection_ok (GtkWidget *w,
- GtkFontSelectionDialog *fs)
+flipping_toggled_cb (GtkWidget *widget, gpointer data)
{
- g_print ("%s\n", gtk_font_selection_dialog_get_font_name (fs));
- gtk_widget_destroy (GTK_WIDGET (fs));
+ int state = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget));
+ int new_direction = state ? GTK_TEXT_DIR_RTL : GTK_TEXT_DIR_LTR;
+
+ gtk_widget_set_default_direction (new_direction);
}
void
-create_font_selection (void)
+create_flipping (void)
{
static GtkWidget *window = NULL;
+ GtkWidget *check_button, *button;
if (!window)
{
- window = gtk_font_selection_dialog_new ("Font Selection Dialog");
-
- gtk_window_set_position (GTK_WINDOW (window), GTK_WIN_POS_MOUSE);
+ window = gtk_dialog_new ();
gtk_signal_connect (GTK_OBJECT (window), "destroy",
GTK_SIGNAL_FUNC(gtk_widget_destroyed),
&window);
- gtk_signal_connect (GTK_OBJECT (GTK_FONT_SELECTION_DIALOG (window)->ok_button),
- "clicked", GTK_SIGNAL_FUNC(font_selection_ok),
- GTK_FONT_SELECTION_DIALOG (window));
- gtk_signal_connect_object (GTK_OBJECT (GTK_FONT_SELECTION_DIALOG (window)->cancel_button),
- "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy),
- GTK_OBJECT (window));
+ gtk_window_set_title (GTK_WINDOW (window), "Bidirectional Flipping");
+
+ check_button = gtk_check_button_new_with_label ("Right-to-left global direction");
+ gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox),
+ check_button, TRUE, TRUE, 0);
+
+ if (gtk_widget_get_default_direction () == GTK_TEXT_DIR_RTL)
+ gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check_button), TRUE);
+
+ gtk_signal_connect (GTK_OBJECT (check_button), "toggled",
+ GTK_SIGNAL_FUNC (flipping_toggled_cb), FALSE);
+
+ gtk_container_set_border_width (GTK_CONTAINER (check_button), 10);
+
+ button = gtk_button_new_with_label ("Close");
+ gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
+ GTK_SIGNAL_FUNC (gtk_widget_destroy), GTK_OBJECT (window));
+ gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
+ button, TRUE, TRUE, 0);
}
if (!GTK_WIDGET_VISIBLE (window))
- gtk_widget_show (window);
+ gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
}
/*
- * GtkDialog
+ * Focus test
*/
-static GtkWidget *dialog_window = NULL;
+static GtkWidget*
+make_focus_table (GList **list)
+{
+ GtkWidget *table;
+ gint i, j;
+
+ table = gtk_table_new (5, 5, FALSE);
+
+ i = 0;
+ j = 0;
+
+ while (i < 5)
+ {
+ j = 0;
+ while (j < 5)
+ {
+ GtkWidget *widget;
+
+ if ((i + j) % 2)
+ widget = gtk_entry_new ();
+ else
+ widget = gtk_button_new_with_label ("Foo");
+
+ *list = g_list_prepend (*list, widget);
+
+ gtk_table_attach (GTK_TABLE (table),
+ widget,
+ i, i + 1,
+ j, j + 1,
+ GTK_EXPAND | GTK_FILL,
+ GTK_EXPAND | GTK_FILL,
+ 5, 5);
+
+ ++j;
+ }
+
+ ++i;
+ }
+
+ *list = g_list_reverse (*list);
+
+ return table;
+}
static void
-label_toggle (GtkWidget *widget,
- GtkWidget **label)
+create_focus (void)
+{
+ static GtkWidget *window = NULL;
+
+ if (!window)
+ {
+ GtkWidget *table;
+ GtkWidget *frame;
+ GList *list = NULL;
+
+ window = gtk_dialog_new_with_buttons ("Keyboard focus navigation",
+ NULL, 0,
+ GTK_STOCK_BUTTON_CLOSE,
+ GTK_RESPONSE_NONE,
+ NULL);
+
+ 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);
+
+ gtk_window_set_title (GTK_WINDOW (window), "Keyboard Focus Navigation");
+
+ frame = gtk_frame_new ("Weird tab focus chain");
+
+ gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox),
+ frame, TRUE, TRUE, 0);
+
+ table = make_focus_table (&list);
+
+ gtk_container_add (GTK_CONTAINER (frame), table);
+
+ gtk_container_set_focus_chain (GTK_CONTAINER (table),
+ list);
+
+ g_list_free (list);
+
+ frame = gtk_frame_new ("Default tab focus chain");
+
+ gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox),
+ frame, TRUE, TRUE, 0);
+
+ list = NULL;
+ table = make_focus_table (&list);
+
+ g_list_free (list);
+
+ gtk_container_add (GTK_CONTAINER (frame), table);
+ }
+
+ if (!GTK_WIDGET_VISIBLE (window))
+ gtk_widget_show_all (window);
+ else
+ gtk_widget_destroy (window);
+}
+
+/*
+ * GtkFontSelection
+ */
+
+void
+font_selection_ok (GtkWidget *w,
+ GtkFontSelectionDialog *fs)
+{
+ gchar *s = gtk_font_selection_dialog_get_font_name (fs);
+
+ g_print ("%s\n", s);
+ g_free (s);
+ gtk_widget_destroy (GTK_WIDGET (fs));
+}
+
+void
+create_font_selection (void)
+{
+ static GtkWidget *window = NULL;
+
+ if (!window)
+ {
+ window = gtk_font_selection_dialog_new ("Font Selection Dialog");
+
+ gtk_window_set_position (GTK_WINDOW (window), GTK_WIN_POS_MOUSE);
+
+ gtk_signal_connect (GTK_OBJECT (window), "destroy",
+ GTK_SIGNAL_FUNC(gtk_widget_destroyed),
+ &window);
+
+ gtk_signal_connect (GTK_OBJECT (GTK_FONT_SELECTION_DIALOG (window)->ok_button),
+ "clicked", GTK_SIGNAL_FUNC(font_selection_ok),
+ GTK_FONT_SELECTION_DIALOG (window));
+ gtk_signal_connect_object (GTK_OBJECT (GTK_FONT_SELECTION_DIALOG (window)->cancel_button),
+ "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy),
+ GTK_OBJECT (window));
+ }
+
+ if (!GTK_WIDGET_VISIBLE (window))
+ gtk_widget_show (window);
+ else
+ gtk_widget_destroy (window);
+}
+
+/*
+ * GtkDialog
+ */
+
+static GtkWidget *dialog_window = NULL;
+
+static void
+label_toggle (GtkWidget *widget,
+ GtkWidget **label)
{
if (!(*label))
{
gtk_widget_destroy (*label);
}
+#define RESPONSE_TOGGLE_SEPARATOR 1
+
+static void
+print_response (GtkWidget *dialog,
+ gint response_id,
+ gpointer data)
+{
+ g_print ("response signal received (%d)\n", response_id);
+
+ if (response_id == RESPONSE_TOGGLE_SEPARATOR)
+ {
+ gtk_dialog_set_has_separator (GTK_DIALOG (dialog),
+ !gtk_dialog_get_has_separator (GTK_DIALOG (dialog)));
+ }
+}
+
static void
create_dialog (void)
{
if (!dialog_window)
{
+ /* This is a terrible example; it's much simpler to create
+ * dialogs than this. Don't use testgtk for example code,
+ * use gtk-demo ;-)
+ */
+
dialog_window = gtk_dialog_new ();
+ gtk_signal_connect (GTK_OBJECT (dialog_window),
+ "response",
+ GTK_SIGNAL_FUNC (print_response),
+ NULL);
+
gtk_signal_connect (GTK_OBJECT (dialog_window), "destroy",
GTK_SIGNAL_FUNC(gtk_widget_destroyed),
&dialog_window);
gtk_window_set_title (GTK_WINDOW (dialog_window), "GtkDialog");
gtk_container_set_border_width (GTK_CONTAINER (dialog_window), 0);
- gtk_widget_set_usize (dialog_window, 200, 110);
button = gtk_button_new_with_label ("OK");
GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
gtk_widget_show (button);
label = NULL;
+
+ button = gtk_button_new_with_label ("Separator");
+
+ GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
+
+ gtk_dialog_add_action_widget (GTK_DIALOG (dialog_window),
+ button,
+ RESPONSE_TOGGLE_SEPARATOR);
+ gtk_widget_show (button);
}
if (!GTK_WIDGET_VISIBLE (dialog_window))
static gboolean event_watcher_leave_id = 0;
static gboolean
-event_watcher (GtkObject *object,
- guint signal_id,
- guint n_params,
- GtkArg *params,
- gpointer data)
+event_watcher (GSignalInvocationHint *ihint,
+ guint n_param_values,
+ const GValue *param_values,
+ gpointer data)
{
g_print ("Watch: \"%s\" emitted for %s\n",
- gtk_signal_name (signal_id),
- gtk_type_name (GTK_OBJECT_TYPE (object)));
+ gtk_signal_name (ihint->signal_id),
+ gtk_type_name (GTK_OBJECT_TYPE (g_value_get_object (param_values + 0))));
return TRUE;
}
guint signal_id;
signal_id = gtk_signal_lookup ("enter_notify_event", GTK_TYPE_WIDGET);
- gtk_signal_remove_emission_hook (signal_id, event_watcher_enter_id);
+ g_signal_remove_emission_hook (signal_id, event_watcher_enter_id);
event_watcher_enter_id = 0;
signal_id = gtk_signal_lookup ("leave_notify_event", GTK_TYPE_WIDGET);
- gtk_signal_remove_emission_hook (signal_id, event_watcher_leave_id);
+ g_signal_remove_emission_hook (signal_id, event_watcher_leave_id);
event_watcher_leave_id = 0;
}
}
guint signal_id;
signal_id = gtk_signal_lookup ("enter_notify_event", GTK_TYPE_WIDGET);
- event_watcher_enter_id = gtk_signal_add_emission_hook (signal_id, event_watcher, NULL);
+ event_watcher_enter_id = g_signal_add_emission_hook (signal_id, 0, event_watcher, NULL, NULL);
signal_id = gtk_signal_lookup ("leave_notify_event", GTK_TYPE_WIDGET);
- event_watcher_leave_id = gtk_signal_add_emission_hook (signal_id, event_watcher, NULL);
+ event_watcher_leave_id = g_signal_add_emission_hook (signal_id, 0, event_watcher, NULL, NULL);
}
}
* GtkRange
*/
+static gchar*
+reformat_value (GtkScale *scale,
+ gdouble value)
+{
+ return g_strdup_printf ("-->%g<--", value);
+}
+
static void
create_range_controls (void)
{
GtkWidget *scale;
GtkWidget *separator;
GtkObject *adjustment;
+ GtkWidget *hbox;
if (!window)
{
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_widget_set_usize (scale, -1, 200);
+ gtk_scale_set_digits (GTK_SCALE (scale), 2);
+ gtk_scale_set_draw_value (GTK_SCALE (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_widget_set_usize (scale, -1, 200);
+ gtk_scale_set_digits (GTK_SCALE (scale), 2);
+ gtk_scale_set_draw_value (GTK_SCALE (scale), TRUE);
+ 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);
gtk_ruler_set_metric (GTK_RULER (ruler), GTK_CENTIMETERS);
gtk_ruler_set_range (GTK_RULER (ruler), 100, 0, 0, 20);
- gtk_signal_connect_object (
- GTK_OBJECT (window),
- "motion_notify_event",
- GTK_SIGNAL_FUNC(
- GTK_WIDGET_CLASS (GTK_OBJECT (ruler)->klass)->motion_notify_event),
- GTK_OBJECT (ruler));
-
+ gtk_signal_connect_object (GTK_OBJECT (window),
+ "motion_notify_event",
+ GTK_SIGNAL_FUNC (GTK_WIDGET_GET_CLASS (ruler)->motion_notify_event),
+ GTK_OBJECT (ruler));
+
gtk_table_attach (GTK_TABLE (table), ruler, 1, 2, 0, 1,
GTK_EXPAND | GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (ruler);
ruler = gtk_vruler_new ();
gtk_ruler_set_range (GTK_RULER (ruler), 5, 15, 0, 20);
- gtk_signal_connect_object (
- GTK_OBJECT (window),
- "motion_notify_event",
- GTK_SIGNAL_FUNC (GTK_WIDGET_CLASS (GTK_OBJECT (ruler)->klass)->motion_notify_event),
- GTK_OBJECT (ruler));
-
+ gtk_signal_connect_object (GTK_OBJECT (window),
+ "motion_notify_event",
+ GTK_SIGNAL_FUNC (GTK_WIDGET_GET_CLASS (ruler)->motion_notify_event),
+ GTK_OBJECT (ruler));
+
gtk_table_attach (GTK_TABLE (table), ruler, 0, 1, 1, 2,
GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
gtk_widget_show (ruler);
GtkWidget *button;
GtkWidget *check;
GtkWidget *separator;
- GtkWidget *table;
- GtkWidget *hscrollbar;
- GtkWidget *vscrollbar;
+ GtkWidget *scrolled_window;
GtkWidget *text;
- GdkFont *font;
FILE *infile;
gtk_widget_show (box2);
- table = gtk_table_new (2, 2, FALSE);
- gtk_table_set_row_spacing (GTK_TABLE (table), 0, 2);
- gtk_table_set_col_spacing (GTK_TABLE (table), 0, 2);
- gtk_box_pack_start (GTK_BOX (box2), table, TRUE, TRUE, 0);
- gtk_widget_show (table);
+ scrolled_window = gtk_scrolled_window_new (NULL, NULL);
+ gtk_box_pack_start (GTK_BOX (box2), scrolled_window, TRUE, TRUE, 0);
+ gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
+ GTK_POLICY_NEVER,
+ GTK_POLICY_ALWAYS);
+ gtk_widget_show (scrolled_window);
text = gtk_text_new (NULL, NULL);
gtk_text_set_editable (GTK_TEXT (text), TRUE);
- gtk_table_attach (GTK_TABLE (table), text, 0, 1, 0, 1,
- GTK_EXPAND | GTK_SHRINK | GTK_FILL,
- GTK_EXPAND | GTK_SHRINK | GTK_FILL, 0, 0);
+ gtk_container_add (GTK_CONTAINER (scrolled_window), text);
gtk_widget_grab_focus (text);
gtk_widget_show (text);
- hscrollbar = gtk_hscrollbar_new (GTK_TEXT (text)->hadj);
- gtk_table_attach (GTK_TABLE (table), hscrollbar, 0, 1, 1, 2,
- GTK_EXPAND | GTK_FILL | GTK_SHRINK, GTK_FILL, 0, 0);
- gtk_widget_show (hscrollbar);
-
- vscrollbar = gtk_vscrollbar_new (GTK_TEXT (text)->vadj);
- gtk_table_attach (GTK_TABLE (table), vscrollbar, 1, 2, 0, 1,
- GTK_FILL, GTK_EXPAND | GTK_SHRINK | GTK_FILL, 0, 0);
- gtk_widget_show (vscrollbar);
gtk_text_freeze (GTK_TEXT (text));
- font = gdk_font_load ("-adobe-courier-medium-r-normal--*-120-*-*-*-*-*-*");
-
for (i=0; i<ntext_colors; i++)
{
- gtk_text_insert (GTK_TEXT (text), font, NULL, NULL,
+ gtk_text_insert (GTK_TEXT (text), NULL, NULL, NULL,
text_colors[i].name, -1);
- gtk_text_insert (GTK_TEXT (text), font, NULL, NULL, "\t", -1);
+ gtk_text_insert (GTK_TEXT (text), NULL, NULL, NULL, "\t", -1);
for (j=0; j<ntext_colors; j++)
{
- gtk_text_insert (GTK_TEXT (text), font,
+ gtk_text_insert (GTK_TEXT (text), NULL,
&text_colors[j].color, &text_colors[i].color,
"XYZ", -1);
}
gtk_text_insert (GTK_TEXT (text), NULL, NULL, NULL, "\n", -1);
}
- /* The Text widget will reference count the font, so we
- * unreference it here
- */
- gdk_font_unref (font);
-
infile = fopen("testgtk.c", "r");
if (infile)
gtk_box_pack_start (GTK_BOX (hbox), check, FALSE, FALSE, 0);
gtk_signal_connect (GTK_OBJECT(check), "toggled",
GTK_SIGNAL_FUNC(text_toggle_editable), text);
- gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(check), TRUE);
+ gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check), TRUE);
gtk_widget_show (check);
check = gtk_check_button_new_with_label("Wrap Words");
gtk_box_pack_start (GTK_BOX (hbox), check, FALSE, TRUE, 0);
gtk_signal_connect (GTK_OBJECT(check), "toggled",
GTK_SIGNAL_FUNC(text_toggle_word_wrap), text);
- gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(check), FALSE);
+ gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check), FALSE);
gtk_widget_show (check);
separator = gtk_hseparator_new ();
GtkWidget *sample_notebook;
static void
-page_switch (GtkWidget *widget, GtkNotebookPage *page, gint page_num)
+set_page_pixmaps (GtkNotebook *notebook, gint page_num,
+ GdkPixmap *pixmap, GdkPixmap *mask)
{
- GtkNotebookPage *oldpage;
+ GtkWidget *page_widget;
GtkWidget *pixwid;
- oldpage = GTK_NOTEBOOK (widget)->cur_page;
+ page_widget = gtk_notebook_get_nth_page (notebook, page_num);
+
+ pixwid = gtk_object_get_data (GTK_OBJECT (page_widget), "tab_pixmap");
+ gtk_pixmap_set (GTK_PIXMAP (pixwid), pixmap, mask);
+
+ pixwid = gtk_object_get_data (GTK_OBJECT (page_widget), "menu_pixmap");
+ gtk_pixmap_set (GTK_PIXMAP (pixwid), pixmap, mask);
+}
- if (page == oldpage)
+static void
+page_switch (GtkWidget *widget, GtkNotebookPage *page, gint page_num)
+{
+ GtkNotebook *notebook = GTK_NOTEBOOK (widget);
+ gint old_page_num = gtk_notebook_get_current_page (notebook);
+
+ if (page_num == old_page_num)
return;
- pixwid = ((GtkBoxChild*)
- (GTK_BOX (page->tab_label)->children->data))->widget;
- gtk_pixmap_set (GTK_PIXMAP (pixwid), book_open, book_open_mask);
- pixwid = ((GtkBoxChild*)
- (GTK_BOX (page->menu_label)->children->data))->widget;
- gtk_pixmap_set (GTK_PIXMAP (pixwid), book_open, book_open_mask);
- if (oldpage)
- {
- pixwid = ((GtkBoxChild*)
- (GTK_BOX (oldpage->tab_label)->children->data))->widget;
- gtk_pixmap_set (GTK_PIXMAP (pixwid), book_closed, book_closed_mask);
- pixwid = ((GtkBoxChild*)
- (GTK_BOX (oldpage->menu_label)->children->data))->widget;
- gtk_pixmap_set (GTK_PIXMAP (pixwid), book_closed, book_closed_mask);
- }
+ set_page_pixmaps (notebook, page_num, book_open, book_open_mask);
+
+ if (old_page_num != -1)
+ set_page_pixmaps (notebook, old_page_num, book_closed, book_closed_mask);
}
static void
GtkWidget *pixwid;
gint i;
char buffer[32];
+ char accel_buffer[32];
for (i = start; i <= end; i++)
{
sprintf (buffer, "Page %d", i);
+ sprintf (accel_buffer, "Page _%d", i);
child = gtk_frame_new (buffer);
gtk_container_set_border_width (GTK_CONTAINER (child), 10);
button = gtk_check_button_new_with_label ("Fill Tab");
gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
- gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON (button), TRUE);
+ gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
gtk_signal_connect (GTK_OBJECT (button), "toggled",
GTK_SIGNAL_FUNC (tab_fill), child);
label_box = gtk_hbox_new (FALSE, 0);
pixwid = gtk_pixmap_new (book_closed, book_closed_mask);
+ gtk_object_set_data (GTK_OBJECT (child), "tab_pixmap", pixwid);
+
gtk_box_pack_start (GTK_BOX (label_box), pixwid, FALSE, TRUE, 0);
gtk_misc_set_padding (GTK_MISC (pixwid), 3, 1);
- label = gtk_label_new (buffer);
+ label = gtk_label_new_with_mnemonic (accel_buffer);
gtk_box_pack_start (GTK_BOX (label_box), label, FALSE, TRUE, 0);
gtk_widget_show_all (label_box);
-
+
+
menu_box = gtk_hbox_new (FALSE, 0);
pixwid = gtk_pixmap_new (book_closed, book_closed_mask);
+ gtk_object_set_data (GTK_OBJECT (child), "menu_pixmap", pixwid);
+
gtk_box_pack_start (GTK_BOX (menu_box), pixwid, FALSE, TRUE, 0);
gtk_misc_set_padding (GTK_MISC (pixwid), 3, 1);
label = gtk_label_new (buffer);
gtk_box_pack_start (GTK_BOX (menu_box), label, FALSE, TRUE, 0);
gtk_widget_show_all (menu_box);
+
gtk_notebook_append_page_menu (notebook, child, label_box, menu_box);
}
}
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++)
gint i;
gtk_notebook_set_show_tabs (notebook, FALSE);
+ gtk_notebook_set_show_border (notebook, TRUE);
+ if (g_list_length (notebook->children) == 15)
+ for (i = 0; i < 10; i++)
+ gtk_notebook_remove_page (notebook, 5);
+}
+
+static void
+borderless_notebook (GtkButton *button,
+ GtkNotebook *notebook)
+{
+ gint i;
+
+ gtk_notebook_set_show_tabs (notebook, FALSE);
+ gtk_notebook_set_show_border (notebook, FALSE);
if (g_list_length (notebook->children) == 15)
for (i = 0; i < 10; i++)
gtk_notebook_remove_page (notebook, 5);
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 OptionMenuItem items[] =
{
- { "Standard", standard_notebook },
- { "No tabs", notabs_notebook },
- { "Scrollable", scrollable_notebook }
+ { "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) },
};
if (!window)
gtk_container_set_border_width (GTK_CONTAINER (sample_notebook), 10);
gtk_widget_realize (sample_notebook);
- book_open = gdk_pixmap_create_from_xpm_d (sample_notebook->window,
- &book_open_mask,
- transparent,
- book_open_xpm);
- book_closed = gdk_pixmap_create_from_xpm_d (sample_notebook->window,
- &book_closed_mask,
+ if (!book_open)
+ book_open = gdk_pixmap_create_from_xpm_d (sample_notebook->window,
+ &book_open_mask,
transparent,
- book_closed_xpm);
+ book_open_xpm);
+ if (!book_closed)
+ book_closed = gdk_pixmap_create_from_xpm_d (sample_notebook->window,
+ &book_closed_mask,
+ transparent,
+ book_closed_xpm);
create_pages (GTK_NOTEBOOK (sample_notebook), 1, 5);
label = gtk_label_new ("Notebook Style :");
gtk_box_pack_start (GTK_BOX (box2), label, FALSE, TRUE, 0);
- omenu = build_option_menu (items, 3, 0, sample_notebook);
+ omenu = build_option_menu (items, G_N_ELEMENTS (items), 0, sample_notebook);
gtk_box_pack_start (GTK_BOX (box2), omenu, FALSE, TRUE, 0);
button = gtk_button_new_with_label ("Show all Pages");
gtk_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);
check_button = gtk_check_button_new_with_label ("Shrink");
gtk_table_attach_defaults (GTK_TABLE (table), check_button,
0, 1, 2, 3);
- gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON (check_button),
+ gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check_button),
TRUE);
gtk_signal_connect (GTK_OBJECT (check_button), "toggled",
GTK_SIGNAL_FUNC (toggle_shrink),
check_button = gtk_check_button_new_with_label ("Resize");
gtk_table_attach_defaults (GTK_TABLE (table), check_button,
1, 2, 1, 2);
- gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON (check_button),
+ gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check_button),
TRUE);
gtk_signal_connect (GTK_OBJECT (check_button), "toggled",
GTK_SIGNAL_FUNC (toggle_resize),
check_button = gtk_check_button_new_with_label ("Shrink");
gtk_table_attach_defaults (GTK_TABLE (table), check_button,
1, 2, 2, 3);
- gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON (check_button),
+ gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check_button),
TRUE);
gtk_signal_connect (GTK_OBJECT (check_button), "toggled",
GTK_SIGNAL_FUNC (toggle_shrink),
paned->child2);
+ 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;
}
if (window)
return;
- window = gtk_window_new(GTK_WINDOW_DIALOG);
+ window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_container_set_border_width (GTK_CONTAINER(window), 10);
gtk_signal_connect (GTK_OBJECT (window), "destroy",
* Shaped Windows
*/
-static GdkWindow *root_win = NULL;
-
typedef struct _cursoroffset {gint x,y;} CursorOffset;
static void
* Can't use event->x / event->y here
* because I need absolute coordinates.
*/
- gdk_window_get_pointer (root_win, &xp, &yp, &mask);
+ gdk_window_get_pointer (NULL, &xp, &yp, &mask);
gtk_widget_set_uposition (widget, xp - p->x, yp - p->y);
}
gtk_fixed_put (GTK_FIXED (fixed), pixmap, px,py);
gtk_widget_show (pixmap);
- gtk_widget_shape_combine_mask (window, gdk_pixmap_mask, px,py);
-
+ gtk_widget_shape_combine_mask (window, gdk_pixmap_mask, px, py);
+
+ gdk_drawable_unref (gdk_pixmap_mask);
+ gdk_drawable_unref (gdk_pixmap);
gtk_signal_connect (GTK_OBJECT (window), "button_press_event",
GTK_SIGNAL_FUNC (shape_pressed),NULL);
static GtkWidget *modeller = NULL;
static GtkWidget *sheets = NULL;
static GtkWidget *rings = NULL;
-
- root_win = gdk_window_foreign_new (GDK_ROOT_WINDOW ());
+ static GtkWidget *with_region = NULL;
+
+ if (!(file_exists ("Modeller.xpm") &&
+ file_exists ("FilesQueue.xpm") &&
+ file_exists ("3DRings.xpm")))
+ return;
+
if (!modeller)
{
}
else
gtk_widget_destroy (rings);
+
+ if (!with_region)
+ {
+ GdkRegion *region;
+ gint x, y;
+
+ with_region = shape_create_icon ("3DRings.xpm",
+ 460, 270, 25,25, GTK_WINDOW_TOPLEVEL);
+
+ gtk_window_set_decorated (GTK_WINDOW (with_region), FALSE);
+
+ gtk_signal_connect (GTK_OBJECT (with_region), "destroy",
+ GTK_SIGNAL_FUNC(gtk_widget_destroyed),
+ &with_region);
+
+ /* reset shape from mask to a region */
+ x = 0;
+ y = 0;
+ region = gdk_region_new ();
+
+ while (x < 460)
+ {
+ while (y < 270)
+ {
+ GdkRectangle rect;
+ rect.x = x;
+ rect.y = y;
+ rect.width = 10;
+ rect.height = 10;
+
+ gdk_region_union_with_rect (region, &rect);
+
+ y += 20;
+ }
+ y = 0;
+ x += 20;
+ }
+
+ gdk_window_shape_combine_region (with_region->window,
+ region,
+ 0, 0);
+ }
+ else
+ gtk_widget_destroy (with_region);
}
/*
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);
+ 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);
+}
+
+
+/*
+ * Window state tracking
+ */
+
+static gint
+window_state_callback (GtkWidget *widget,
+ GdkEventWindowState *event,
+ gpointer data)
+{
+ GtkWidget *label = data;
+ gchar *msg;
+
+ msg = g_strconcat (GTK_WINDOW (widget)->title, ": ",
+ (event->new_window_state & GDK_WINDOW_STATE_WITHDRAWN) ?
+ "withdrawn" : "not withdrawn", ", ",
+ (event->new_window_state & GDK_WINDOW_STATE_ICONIFIED) ?
+ "iconified" : "not iconified", ", ",
+ (event->new_window_state & GDK_WINDOW_STATE_STICKY) ?
+ "sticky" : "not sticky", ", ",
+ (event->new_window_state & GDK_WINDOW_STATE_MAXIMIZED) ?
+ "maximized" : "not maximized",
+ NULL);
+
+ gtk_label_set_text (GTK_LABEL (label), msg);
+
+ g_free (msg);
+
+ return FALSE;
+}
+
+static GtkWidget*
+tracking_label (GtkWidget *window)
+{
+ GtkWidget *label;
+ GtkWidget *hbox;
+ 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_signal_connect (GTK_OBJECT (window),
+ "window_state_event",
+ GTK_SIGNAL_FUNC (window_state_callback),
+ label);
+
+ button = gtk_button_new_with_label ("Deiconify");
+ gtk_signal_connect_object (GTK_OBJECT (button),
+ "clicked",
+ GTK_SIGNAL_FUNC (gtk_window_deiconify),
+ GTK_OBJECT (window));
+ gtk_box_pack_end (GTK_BOX (hbox), button, FALSE, FALSE, 0);
+
+ button = gtk_button_new_with_label ("Iconify");
+ gtk_signal_connect_object (GTK_OBJECT (button),
+ "clicked",
+ GTK_SIGNAL_FUNC (gtk_window_iconify),
+ GTK_OBJECT (window));
+ gtk_box_pack_end (GTK_BOX (hbox), button, FALSE, FALSE, 0);
+
+ button = gtk_button_new_with_label ("Present");
+ gtk_signal_connect_object (GTK_OBJECT (button),
+ "clicked",
+ GTK_SIGNAL_FUNC (gtk_window_present),
+ GTK_OBJECT (window));
+ gtk_box_pack_end (GTK_BOX (hbox), button, FALSE, FALSE, 0);
+
+ button = gtk_button_new_with_label ("Show");
+ gtk_signal_connect_object (GTK_OBJECT (button),
+ "clicked",
+ GTK_SIGNAL_FUNC (gtk_widget_show),
+ GTK_OBJECT (window));
+ gtk_box_pack_end (GTK_BOX (hbox), button, FALSE, FALSE, 0);
+
+ gtk_widget_show_all (hbox);
+
+ return hbox;
+}
+
+static GtkWidget*
+get_state_controls (GtkWidget *window)
+{
+ GtkWidget *vbox;
+ GtkWidget *button;
+
+ vbox = gtk_vbox_new (FALSE, 0);
+
+ button = gtk_button_new_with_label ("Stick");
+ gtk_signal_connect_object (GTK_OBJECT (button),
+ "clicked",
+ GTK_SIGNAL_FUNC (gtk_window_stick),
+ GTK_OBJECT (window));
+ gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
+
+ button = gtk_button_new_with_label ("Unstick");
+ gtk_signal_connect_object (GTK_OBJECT (button),
+ "clicked",
+ GTK_SIGNAL_FUNC (gtk_window_unstick),
+ GTK_OBJECT (window));
+ gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
+
+ button = gtk_button_new_with_label ("Maximize");
+ gtk_signal_connect_object (GTK_OBJECT (button),
+ "clicked",
+ GTK_SIGNAL_FUNC (gtk_window_maximize),
+ GTK_OBJECT (window));
+ gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
+
+ button = gtk_button_new_with_label ("Unmaximize");
+ gtk_signal_connect_object (GTK_OBJECT (button),
+ "clicked",
+ GTK_SIGNAL_FUNC (gtk_window_unmaximize),
+ GTK_OBJECT (window));
+ gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
+
+ button = gtk_button_new_with_label ("Iconify");
+ gtk_signal_connect_object (GTK_OBJECT (button),
+ "clicked",
+ GTK_SIGNAL_FUNC (gtk_window_iconify),
+ GTK_OBJECT (window));
+ gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
+
+ button = gtk_button_new_with_label ("Hide (withdraw)");
+ gtk_signal_connect_object (GTK_OBJECT (button),
+ "clicked",
+ GTK_SIGNAL_FUNC (gtk_widget_hide),
+ GTK_OBJECT (window));
+ gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
+
+ gtk_widget_show_all (vbox);
+
+ return vbox;
+}
+
+void
+create_window_states (void)
+{
+ static GtkWidget *window = NULL;
+ GtkWidget *label;
+ GtkWidget *box1;
+ GtkWidget *iconified;
+ GtkWidget *normal;
+ GtkWidget *controls;
+
+ if (!window)
+ {
+ window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+
+ gtk_signal_connect (GTK_OBJECT (window), "destroy",
+ GTK_SIGNAL_FUNC(gtk_widget_destroyed),
+ &window);
+
+ gtk_window_set_title (GTK_WINDOW (window), "Window states");
+
+ box1 = gtk_vbox_new (FALSE, 0);
+ gtk_container_add (GTK_CONTAINER (window), box1);
+
+ iconified = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+ 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_window_set_title (GTK_WINDOW (normal), "Deiconified initially");
+ controls = get_state_controls (normal);
+ gtk_container_add (GTK_CONTAINER (normal), controls);
+
+ label = tracking_label (iconified);
+ gtk_container_add (GTK_CONTAINER (box1), label);
+
+ label = tracking_label (normal);
+ gtk_container_add (GTK_CONTAINER (box1), label);
+
+ gtk_widget_show_all (iconified);
+ gtk_widget_show_all (normal);
+ gtk_widget_show_all (box1);
+ }
+
+ if (!GTK_WIDGET_VISIBLE (window))
+ gtk_widget_show (window);
+ else
+ gtk_widget_destroy (window);
+}
+
+/*
+ * Window sizing
+ */
+
+static gint
+configure_event_callback (GtkWidget *widget,
+ GdkEventConfigure *event,
+ gpointer data)
+{
+ GtkWidget *label = data;
+ gchar *msg;
+ gint x, y;
+
+#if 0
+ /* FIXME */
+ gtk_window_get_location (GTK_WINDOW (widget), &x, &y);
+#else
+ x = 0;
+ y = 0;
+#endif
+
+ msg = g_strdup_printf ("event: %d,%d %d x %d\n"
+ "location: %d, %d",
+ event->x, event->y, event->width, event->height,
+ x, y);
+
+ gtk_label_set_text (GTK_LABEL (label), msg);
+
+ g_free (msg);
+
+ 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_set_default_size (GTK_WINDOW (g_object_get_data (data, "target")), w, h);
+}
+
+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
+set_usize_callback (GtkWidget *widget,
+ gpointer data)
+{
+ gint w, h;
+
+ get_ints (data, &w, &h);
+
+ gtk_widget_set_usize (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_widget_set_uposition (g_object_get_data (data, "target"), 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 0
+ /* FIXME */
+ if (!gtk_window_parse_geometry (target, text))
+ g_print ("Bad geometry string '%s'\n", text);
+#endif
+
+ 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 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, -3.0, 800.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, -3.0, 800.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 ("Queue resize");
+ gtk_signal_connect_object (GTK_OBJECT (button),
+ "clicked",
+ GTK_SIGNAL_FUNC (gtk_widget_queue_resize),
+ GTK_OBJECT (control_window));
+ gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
+
+ button = gtk_button_new_with_label ("Set size");
+ 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 ("Set usize");
+ 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 ("Set location");
+ 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_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);
- button = gtk_button_new_with_label ("close");
+ gtk_box_pack_end (GTK_BOX (vbox), om, FALSE, FALSE, 0);
+
+ gtk_widget_show_all (vbox);
+
+ return control_window;
+}
- gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
- GTK_SIGNAL_FUNC(gtk_widget_destroy),
- GTK_OBJECT (window));
+void
+create_window_sizing (void)
+{
+ static GtkWidget *window = NULL;
+
+ if (!window)
+ {
+ GtkWidget *label;
+
+ window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
- 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);
+ 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 (window), label);
+ gtk_widget_show (label);
+
+ gtk_signal_connect (GTK_OBJECT (window), "destroy",
+ GTK_SIGNAL_FUNC(gtk_widget_destroyed),
+ &window);
+
+ gtk_window_set_title (GTK_WINDOW (window), "Window to size");
+
+ gtk_widget_show (window_controls (window));
}
if (!GTK_WIDGET_VISIBLE (window))
gint
progress_timeout (gpointer data)
{
- gfloat new_val;
+ gdouble new_val;
GtkAdjustment *adj;
adj = GTK_PROGRESS (data)->adjustment;
static OptionMenuItem items1[] =
{
- { "Left-Right", progressbar_toggle_orientation },
- { "Right-Left", progressbar_toggle_orientation },
- { "Bottom-Top", progressbar_toggle_orientation },
- { "Top-Bottom", progressbar_toggle_orientation }
+ { "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) }
};
static OptionMenuItem items2[] =
{
- { "Continuous", progressbar_toggle_bar_style },
- { "Discrete", progressbar_toggle_bar_style }
+ { "Continuous", GTK_SIGNAL_FUNC (progressbar_toggle_bar_style) },
+ { "Discrete", GTK_SIGNAL_FUNC (progressbar_toggle_bar_style) }
};
if (!pdata)
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)
+{
+ *data->window = NULL;
+
+ if (data->cursor)
+ gdk_cursor_destroy (data->cursor);
+
+ gtk_signal_disconnect (widget, data->handler);
+
+ 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;
+ 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_object (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);
+
+ button = gtk_button_new_with_label ("Query properties");
+ gtk_signal_connect (GTK_OBJECT (button), "clicked",
+ GTK_SIGNAL_FUNC(query_properties),
+ data);
+
+
+ gtk_container_add (GTK_CONTAINER (window), button);
+ }
+
+ if (!GTK_WIDGET_VISIBLE (window))
+ gtk_widget_show_all (window);
+ else
+ gtk_widget_destroy (window);
+
+}
+
+
/*
* Color Preview
*/
if (!window)
{
- gtk_widget_push_visual (gdk_rgb_get_visual ());
gtk_widget_push_colormap (gdk_rgb_get_cmap ());
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_widget_pop_colormap ();
- gtk_widget_pop_visual ();
gtk_signal_connect (GTK_OBJECT (window), "destroy",
GTK_SIGNAL_FUNC(color_preview_destroy),
*/
static int scroll_test_pos = 0.0;
-static GdkGC *scroll_test_gc = NULL;
static gint
scroll_test_expose (GtkWidget *widget, GdkEventExpose *event,
return TRUE;
}
+static gint
+scroll_test_scroll (GtkWidget *widget, GdkEventScroll *event,
+ GtkAdjustment *adj)
+{
+ gdouble new_value = adj->value + ((event->direction == GDK_SCROLL_UP) ?
+ -adj->page_increment / 2:
+ adj->page_increment / 2);
+ new_value = CLAMP (new_value, adj->lower, adj->upper - adj->page_size);
+ gtk_adjustment_set_value (adj, new_value);
+
+ return TRUE;
+}
+
static void
scroll_test_configure (GtkWidget *widget, GdkEventConfigure *event,
GtkAdjustment *adj)
scroll_test_adjustment_changed (GtkAdjustment *adj, GtkWidget *widget)
{
gint source_min = (int)adj->value - scroll_test_pos;
- gint source_max = source_min + widget->allocation.height;
- gint dest_min = 0;
- gint dest_max = widget->allocation.height;
- GdkRectangle rect;
- GdkEvent *event;
+ gint dy;
+ dy = scroll_test_pos - (int)adj->value;
scroll_test_pos = adj->value;
if (!GTK_WIDGET_DRAWABLE (widget))
return;
-
- if (source_min < 0)
- {
- rect.x = 0;
- rect.y = 0;
- rect.width = widget->allocation.width;
- rect.height = -source_min;
- if (rect.height > widget->allocation.height)
- rect.height = widget->allocation.height;
-
- source_min = 0;
- dest_min = rect.height;
- }
- else
- {
- rect.x = 0;
- rect.y = 2*widget->allocation.height - source_max;
- if (rect.y < 0)
- rect.y = 0;
- rect.width = widget->allocation.width;
- rect.height = widget->allocation.height - rect.y;
-
- source_max = widget->allocation.height;
- dest_max = rect.y;
- }
-
- if (source_min != source_max)
- {
- if (scroll_test_gc == NULL)
- {
- scroll_test_gc = gdk_gc_new (widget->window);
- gdk_gc_set_exposures (scroll_test_gc, TRUE);
- }
-
- gdk_draw_pixmap (widget->window,
- scroll_test_gc,
- widget->window,
- 0, source_min,
- 0, dest_min,
- widget->allocation.width,
- source_max - source_min);
-
- /* Make sure graphics expose events are processed before scrolling
- * again */
-
- while ((event = gdk_event_get_graphics_expose (widget->window)) != NULL)
- {
- gtk_widget_event (widget, event);
- if (event->expose.count == 0)
- {
- gdk_event_free (event);
- break;
- }
- gdk_event_free (event);
- }
- }
-
- if (rect.height != 0)
- gtk_widget_draw (widget, &rect);
+ gdk_window_scroll (widget->window, 0, dy);
+ gdk_window_process_updates (widget->window, FALSE);
}
gtk_box_pack_start (GTK_BOX (hbox), drawing_area, TRUE, TRUE, 0);
gtk_widget_show (drawing_area);
- gtk_widget_set_events (drawing_area, GDK_EXPOSURE_MASK);
+ gtk_widget_set_events (drawing_area, GDK_EXPOSURE_MASK | GDK_SCROLL_MASK);
adj = GTK_ADJUSTMENT (gtk_adjustment_new (0.0, 0.0, 1000.0, 1.0, 180.0, 200.0));
scroll_test_pos = 0.0;
GTK_SIGNAL_FUNC (scroll_test_expose), adj);
gtk_signal_connect (GTK_OBJECT (drawing_area), "configure_event",
GTK_SIGNAL_FUNC (scroll_test_configure), adj);
-
+ gtk_signal_connect (GTK_OBJECT (drawing_area), "scroll_event",
+ GTK_SIGNAL_FUNC (scroll_test_scroll), adj);
gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
GTK_SIGNAL_FUNC (scroll_test_adjustment_changed),
* Idle Test
*/
-static int idle = 0;
+static int idle_id = 0;
static gint
idle_test (GtkWidget *label)
start_idle_test (GtkWidget *widget,
GtkWidget *label)
{
- if (!idle)
+ if (!idle_id)
{
- idle = gtk_idle_add ((GtkFunction) idle_test, label);
+ idle_id = gtk_idle_add ((GtkFunction) idle_test, label);
}
}
stop_idle_test (GtkWidget *widget,
gpointer data)
{
- if (idle)
+ if (idle_id)
{
- gtk_idle_remove (idle);
- idle = 0;
+ gtk_idle_remove (idle_id);
+ idle_id = 0;
}
}
toggle_idle_container (GtkObject *button,
GtkContainer *container)
{
- gtk_container_set_resize_mode (container, (guint) gtk_object_get_user_data (button));
+ gtk_container_set_resize_mode (container, GPOINTER_TO_INT (gtk_object_get_user_data (button)));
}
static void
container =
gtk_widget_new (GTK_TYPE_HBOX,
- "GtkWidget::visible", TRUE,
+ "visible", TRUE,
/* "GtkContainer::child", gtk_widget_new (GTK_TYPE_HBOX,
* "GtkWidget::visible", TRUE,
*/
- "GtkContainer::child", label,
+ "child", label,
/* NULL), */
NULL);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox),
frame =
gtk_widget_new (GTK_TYPE_FRAME,
- "GtkContainer::border_width", 5,
- "GtkFrame::label", "Label Container",
- "GtkWidget::visible", TRUE,
- "GtkWidget::parent", GTK_DIALOG (window)->vbox,
+ "border_width", 5,
+ "label", "Label Container",
+ "visible", TRUE,
+ "parent", GTK_DIALOG (window)->vbox,
NULL);
box =
gtk_widget_new (GTK_TYPE_VBOX,
- "GtkWidget::visible", TRUE,
- "GtkWidget::parent", frame,
+ "visible", TRUE,
+ "parent", frame,
NULL);
button =
- gtk_widget_new (GTK_TYPE_RADIO_BUTTON,
- "GtkButton::label", "Resize-Parent",
- "GtkObject::user_data", (void*)GTK_RESIZE_PARENT,
- "GtkObject::signal::clicked", toggle_idle_container, container,
- "GtkWidget::visible", TRUE,
- "GtkWidget::parent", box,
- NULL);
+ g_object_connect (gtk_widget_new (GTK_TYPE_RADIO_BUTTON,
+ "label", "Resize-Parent",
+ "user_data", (void*)GTK_RESIZE_PARENT,
+ "visible", TRUE,
+ "parent", box,
+ NULL),
+ "signal::clicked", toggle_idle_container, container,
+ NULL);
button =
- gtk_widget_new (GTK_TYPE_RADIO_BUTTON,
- "GtkButton::label", "Resize-Queue",
- "GtkObject::user_data", (void*)GTK_RESIZE_QUEUE,
- "GtkObject::signal::clicked", toggle_idle_container, container,
- "GtkRadioButton::group", button,
- "GtkWidget::visible", TRUE,
- "GtkWidget::parent", box,
- NULL);
+ 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 =
- gtk_widget_new (GTK_TYPE_RADIO_BUTTON,
- "GtkButton::label", "Resize-Immediate",
- "GtkObject::user_data", (void*)GTK_RESIZE_IMMEDIATE,
- "GtkObject::signal::clicked", toggle_idle_container, container,
- "GtkRadioButton::group", button,
- "GtkWidget::visible", TRUE,
- "GtkWidget::parent", box,
- NULL);
-
+ 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_button_new_with_label ("close");
gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
gtk_widget_set_usize (window, 200, 200);
scrolledwindow = gtk_scrolled_window_new (NULL, NULL);
+ gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolledwindow),
+ GTK_SHADOW_IN);
+ gtk_scrolled_window_set_placement (GTK_SCROLLED_WINDOW (scrolledwindow),
+ GTK_CORNER_TOP_RIGHT);
gtk_container_add (GTK_CONTAINER (window), scrolledwindow);
layout = gtk_layout_new (NULL, NULL);
gtk_container_add (GTK_CONTAINER (scrolledwindow), layout);
+
+ /* We set step sizes here since GtkLayout does not set
+ * them itself.
+ */
+ GTK_LAYOUT (layout)->hadjustment->step_increment = 10.0;
+ GTK_LAYOUT (layout)->vadjustment->step_increment = 10.0;
gtk_widget_set_events (layout, GDK_EXPOSURE_MASK);
gtk_signal_connect (GTK_OBJECT (layout), "expose_event",
GTK_SIGNAL_FUNC (layout_expose_handler), NULL);
- gtk_layout_set_size (GTK_LAYOUT (layout), 1600, 64000);
+ gtk_layout_set_size (GTK_LAYOUT (layout), 1600, 128000);
for (i=0 ; i < 16 ; i++)
for (j=0 ; j < 16 ; j++)
j*100, i*100);
}
- for (i=16; i < 640; i++)
+ for (i=16; i < 1280; i++)
{
sprintf(buf, "Button %d, %d", i, 0);
if (i % 2)
gtk_widget_destroy (window);
}
+void
+create_styles (void)
+{
+ static GtkWidget *window = NULL;
+ GtkWidget *label;
+ GtkWidget *button;
+ GtkWidget *entry;
+ GtkWidget *vbox;
+ static GdkColor red = { 0, 0xffff, 0, 0 };
+ static GdkColor green = { 0, 0, 0xffff, 0 };
+ static GdkColor blue = { 0, 0, 0, 0xffff };
+ static GdkColor yellow = { 0, 0xffff, 0xffff, 0 };
+ static GdkColor cyan = { 0, 0 , 0xffff, 0xffff };
+ PangoFontDescription *font_desc;
+
+ GtkRcStyle *rc_style;
+
+ if (!window)
+ {
+ window = gtk_dialog_new ();
+ gtk_signal_connect (GTK_OBJECT (window), "destroy",
+ GTK_SIGNAL_FUNC(gtk_widget_destroyed),
+ &window);
+
+
+ button = gtk_button_new_with_label ("Close");
+ gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
+ GTK_SIGNAL_FUNC(gtk_widget_destroy),
+ GTK_OBJECT (window));
+ GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
+ gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
+ button, TRUE, TRUE, 0);
+ gtk_widget_show (button);
+
+ vbox = gtk_vbox_new (FALSE, 5);
+ gtk_container_set_border_width (GTK_CONTAINER (vbox), 10);
+ gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), vbox, FALSE, FALSE, 0);
+
+ label = gtk_label_new ("Font:");
+ gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
+ gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
+
+ font_desc = pango_font_description_from_string ("Helvetica,Sans Oblique 18");
+
+ button = gtk_button_new_with_label ("Some Text");
+ gtk_widget_modify_font (GTK_BIN (button)->child, font_desc);
+ gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
+
+ label = gtk_label_new ("Foreground:");
+ gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
+ gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
+
+ button = gtk_button_new_with_label ("Some Text");
+ gtk_widget_modify_fg (GTK_BIN (button)->child, GTK_STATE_NORMAL, &red);
+ gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
+
+ label = gtk_label_new ("Background:");
+ gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
+ gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
+
+ button = gtk_button_new_with_label ("Some Text");
+ gtk_widget_modify_bg (button, GTK_STATE_NORMAL, &green);
+ gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
+
+ label = gtk_label_new ("Text:");
+ gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
+ gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
+
+ entry = gtk_entry_new ();
+ gtk_entry_set_text (GTK_ENTRY (entry), "Some Text");
+ gtk_widget_modify_text (entry, GTK_STATE_NORMAL, &blue);
+ gtk_box_pack_start (GTK_BOX (vbox), entry, FALSE, FALSE, 0);
+
+ label = gtk_label_new ("Base:");
+ gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
+ gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
+
+ entry = gtk_entry_new ();
+ gtk_entry_set_text (GTK_ENTRY (entry), "Some Text");
+ gtk_widget_modify_base (entry, GTK_STATE_NORMAL, &yellow);
+ gtk_box_pack_start (GTK_BOX (vbox), entry, FALSE, FALSE, 0);
+
+ label = gtk_label_new ("Multiple:");
+ gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
+ gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
+
+ button = gtk_button_new_with_label ("Some Text");
+
+ rc_style = gtk_rc_style_new ();
+
+ rc_style->font_desc = font_desc;
+ rc_style->color_flags[GTK_STATE_NORMAL] = GTK_RC_FG | GTK_RC_BG;
+ rc_style->color_flags[GTK_STATE_PRELIGHT] = GTK_RC_FG | GTK_RC_BG;
+ rc_style->color_flags[GTK_STATE_ACTIVE] = GTK_RC_FG | GTK_RC_BG;
+ rc_style->fg[GTK_STATE_NORMAL] = yellow;
+ rc_style->bg[GTK_STATE_NORMAL] = blue;
+ rc_style->fg[GTK_STATE_PRELIGHT] = blue;
+ rc_style->bg[GTK_STATE_PRELIGHT] = yellow;
+ rc_style->fg[GTK_STATE_ACTIVE] = red;
+ rc_style->bg[GTK_STATE_ACTIVE] = cyan;
+ rc_style->xthickness = 5;
+ rc_style->ythickness = 5;
+
+ gtk_widget_modify_style (button, rc_style);
+ gtk_widget_modify_style (GTK_BIN (button)->child, rc_style);
+
+ g_object_unref (G_OBJECT (rc_style));
+
+ gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
+ }
+
+ if (!GTK_WIDGET_VISIBLE (window))
+ gtk_widget_show_all (window);
+ else
+ gtk_widget_destroy (window);
+}
+
/*
* Main Window and Exit
*/
{ "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 },
{ "preview color", create_color_preview },
{ "preview gray", create_gray_preview },
{ "progress bar", create_progress_bar },
+ { "properties", create_properties },
{ "radio buttons", create_radio_buttons },
{ "range controls", create_range_controls },
{ "rc file", create_rc_file },
{ "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 },
{ "test scrolling", create_scroll_test },
{ "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]);
GtkWidget *window;
GtkWidget *label;
gchar buffer[64];
GtkWidget *separator;
+ GdkGeometry geometry;
int i;
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
- gtk_window_set_policy (GTK_WINDOW (window), FALSE, FALSE, FALSE);
gtk_widget_set_name (window, "main window");
- gtk_widget_set_usize (window, 200, 400);
gtk_widget_set_uposition (window, 20, 20);
+ gtk_window_set_default_size (GTK_WINDOW (window), -1, 400);
+
+ geometry.min_width = -1;
+ geometry.min_height = -1;
+ geometry.max_width = -1;
+ geometry.max_height = G_MAXSHORT;
+ gtk_window_set_geometry_hints (GTK_WINDOW (window), NULL,
+ &geometry,
+ GDK_HINT_MIN_SIZE | GDK_HINT_MAX_SIZE);
gtk_signal_connect (GTK_OBJECT (window), "destroy",
GTK_SIGNAL_FUNC(gtk_main_quit),
scrolled_window = gtk_scrolled_window_new (NULL, NULL);
gtk_container_set_border_width (GTK_CONTAINER (scrolled_window), 10);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
- GTK_POLICY_AUTOMATIC,
+ GTK_POLICY_NEVER,
GTK_POLICY_AUTOMATIC);
gtk_box_pack_start (GTK_BOX (box1), scrolled_window, TRUE, TRUE, 0);
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);
gtk_widget_show_all (window);
}
+static void
+test_init ()
+{
+ if (file_exists ("../gdk-pixbuf/.libs/libpixbufloader-pnm.so"))
+ {
+ putenv ("GDK_PIXBUF_MODULEDIR=../gdk-pixbuf/.libs");
+ putenv ("GTK_IM_MODULE_FILE=../modules/input/gtk.immodules");
+ }
+}
+
int
main (int argc, char *argv[])
{
srand (time (NULL));
+ test_init ();
gtk_set_locale ();
- gtk_rc_add_default_file ("testgtkrc");
+ /* Check to see if we are being run from the correct
+ * directory.
+ */
+ if (file_exists ("testgtkrc"))
+ gtk_rc_add_default_file ("testgtkrc");
gtk_init (&argc, &argv);
- gdk_rgb_init ();
-
/* bindings test
*/
binding_set = gtk_binding_set_by_class (gtk_type_class (GTK_TYPE_WIDGET));
gtk_main ();
+ if (1)
+ {
+ while (g_main_pending ())
+ g_main_iteration (FALSE);
+#if 0
+ sleep (1);
+ while (g_main_pending ())
+ g_main_iteration (FALSE);
+#endif
+ }
+
return 0;
}
projects / ~andy / gtk / blobdiff