* GTK+ at ftp://ftp.gtk.org/pub/gtk/.
*/
+#undef GTK_DISABLE_DEPRECATED
+
#include "config.h"
#undef G_LOG_DOMAIN
}
GtkWidget *
-shape_create_icon (char *xpm_file,
- gint x,
- gint y,
- gint px,
- gint py,
- gint window_type);
+shape_create_icon (GdkScreen *screen,
+ char *xpm_file,
+ gint x,
+ gint y,
+ gint px,
+ gint py,
+ gint window_type);
static GtkWidget *
-build_option_menu (gchar *items[],
- gint num_items,
- gint history,
- void (*func)(GtkWidget *widget, gpointer data),
- gpointer data);
+build_option_menu (gchar *items[],
+ gint num_items,
+ gint history,
+ void (*func) (GtkWidget *widget, gpointer data),
+ gpointer data);
/* macro, structure and variables used by tree window demos */
#define DEFAULT_NUMBER_OF_ITEM 3
/* end of tree section */
static GtkWidget *
-build_option_menu (gchar *items[],
- gint num_items,
- gint history,
- void (*func)(GtkWidget *widget, gpointer data),
- gpointer data)
+build_option_menu (gchar *items[],
+ gint num_items,
+ gint history,
+ void (*func)(GtkWidget *widget, gpointer data),
+ gpointer data)
{
GtkWidget *omenu;
GtkWidget *menu;
gint i;
omenu = gtk_option_menu_new ();
- gtk_signal_connect (GTK_OBJECT (omenu), "changed",
- GTK_SIGNAL_FUNC (func), data);
+ g_signal_connect (omenu, "changed",
+ G_CALLBACK (func), data);
menu = gtk_menu_new ();
group = NULL;
for (i = 0; i < num_items; i++)
{
menu_item = gtk_radio_menu_item_new_with_label (group, items[i]);
- group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menu_item));
+ group = gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (menu_item));
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menu_item);
if (i == history)
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (menu_item), TRUE);
static void
destroy_tooltips (GtkWidget *widget, GtkWindow **window)
{
- GtkTooltips *tt = gtk_object_get_data (GTK_OBJECT (*window), "tooltips");
- gtk_object_unref (GTK_OBJECT (tt));
+ GtkTooltips *tt = g_object_get_data (G_OBJECT (*window), "tooltips");
+ g_object_unref (tt);
*window = NULL;
}
+/*
+ * Windows with an alpha channel
+ */
+
+
+static gboolean
+on_alpha_window_expose (GtkWidget *widget,
+ GdkEventExpose *expose)
+{
+ cairo_t *cr;
+ cairo_pattern_t *pattern;
+ int radius;
+
+ cr = gdk_cairo_create (widget->window);
+
+ radius = MIN (widget->allocation.width, widget->allocation.height) / 2;
+ pattern = cairo_pattern_create_radial (widget->allocation.width / 2,
+ widget->allocation.height / 2,
+ 0.0,
+ widget->allocation.width / 2,
+ widget->allocation.height / 2,
+ radius * 1.33);
+
+ if (gdk_screen_get_rgba_colormap (gtk_widget_get_screen (widget)) &&
+ gtk_widget_is_composited (widget))
+ cairo_set_source_rgba (cr, 1.0, 1.0, 1.0, 0.0); /* transparent */
+ else
+ cairo_set_source_rgb (cr, 1.0, 1.0, 1.0); /* opaque white */
+
+ cairo_set_operator (cr, CAIRO_OPERATOR_SOURCE);
+ cairo_paint (cr);
+
+ cairo_pattern_add_color_stop_rgba (pattern, 0.0,
+ 1.0, 0.75, 0.0, 1.0); /* solid orange */
+ cairo_pattern_add_color_stop_rgba (pattern, 1.0,
+ 1.0, 0.75, 0.0, 0.0); /* transparent orange */
+
+ cairo_set_source (cr, pattern);
+ cairo_pattern_destroy (pattern);
+
+ cairo_set_operator (cr, CAIRO_OPERATOR_OVER);
+ cairo_paint (cr);
+
+ cairo_destroy (cr);
+
+ return FALSE;
+}
+
+static GtkWidget *
+build_alpha_widgets (void)
+{
+ GtkWidget *table;
+ GtkWidget *radio_button;
+ GtkWidget *hbox;
+ GtkWidget *label;
+ GtkWidget *entry;
+
+ table = gtk_table_new (1, 1, FALSE);
+
+ radio_button = gtk_radio_button_new_with_label (NULL, "Red");
+ gtk_table_attach (GTK_TABLE (table),
+ radio_button,
+ 0, 1, 0, 1,
+ GTK_EXPAND | GTK_FILL, 0,
+ 0, 0);
+
+ radio_button = gtk_radio_button_new_with_label_from_widget (GTK_RADIO_BUTTON (radio_button), "Green");
+ gtk_table_attach (GTK_TABLE (table),
+ radio_button,
+ 0, 1, 1, 2,
+ GTK_EXPAND | GTK_FILL, 0,
+ 0, 0);
+
+ radio_button = gtk_radio_button_new_with_label_from_widget (GTK_RADIO_BUTTON (radio_button), "Blue"),
+ gtk_table_attach (GTK_TABLE (table),
+ radio_button,
+ 0, 1, 2, 3,
+ GTK_EXPAND | GTK_FILL, 0,
+ 0, 0);
+
+ gtk_table_attach (GTK_TABLE (table),
+ gtk_check_button_new_with_label ("Sedentary"),
+ 1, 2, 0, 1,
+ GTK_EXPAND | GTK_FILL, 0,
+ 0, 0);
+ gtk_table_attach (GTK_TABLE (table),
+ gtk_check_button_new_with_label ("Nocturnal"),
+ 1, 2, 1, 2,
+ GTK_EXPAND | GTK_FILL, 0,
+ 0, 0);
+ gtk_table_attach (GTK_TABLE (table),
+ gtk_check_button_new_with_label ("Compulsive"),
+ 1, 2, 2, 3,
+ GTK_EXPAND | GTK_FILL, 0,
+ 0, 0);
+
+ radio_button = gtk_radio_button_new_with_label_from_widget (GTK_RADIO_BUTTON (radio_button), "Green");
+ gtk_table_attach (GTK_TABLE (table),
+ radio_button,
+ 0, 1, 1, 2,
+ GTK_EXPAND | GTK_FILL, 0,
+ 0, 0);
+
+ radio_button = gtk_radio_button_new_with_label_from_widget (GTK_RADIO_BUTTON (radio_button), "Blue"),
+ gtk_table_attach (GTK_TABLE (table),
+ radio_button,
+ 0, 1, 2, 3,
+ GTK_EXPAND | GTK_FILL, 0,
+ 0, 0);
+
+ hbox = gtk_hbox_new (FALSE, 0);
+ label = gtk_label_new (NULL);
+ gtk_label_set_markup (GTK_LABEL (label), "<i>Entry: </i>");
+ gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
+ entry = gtk_entry_new ();
+ gtk_box_pack_start (GTK_BOX (hbox), entry, TRUE, TRUE, 0);
+ gtk_table_attach (GTK_TABLE (table),
+ hbox,
+ 0, 1, 3, 4,
+ GTK_EXPAND | GTK_FILL, 0,
+ 0, 0);
+
+ return table;
+}
+
+static gboolean
+on_alpha_drawing_expose (GtkWidget *widget,
+ GdkEventExpose *expose)
+{
+ int x = widget->allocation.x;
+ int y = widget->allocation.y;
+ int width = widget->allocation.width;
+ int height = widget->allocation.height;
+ GdkPixbuf *pixbuf;
+ guchar *buffer;
+ guchar *p;
+ int i, j;
+
+ buffer = g_malloc (64 * 64 * 4);
+
+ gdk_draw_rectangle (widget->window, widget->style->black_gc, FALSE,
+ x, y,
+ width - 1, height - 1);
+
+ p = buffer;
+ for (i = 0; i < 64; i++) {
+ for (j = 0; j < 64; j++) {
+ *(p++) = i * 4 + 3;
+ *(p++) = 0;
+ *(p++) = j + 4 + 3;
+ *(p++) = MIN (255, ((32 - i) * (32 - i) + (32 - j) * (32 - j)) / 8);
+ }
+ }
+ p++;
+
+ gdk_draw_rgb_32_image (widget->window, widget->style->black_gc,
+ x + 18, y + (height - 64) /2,
+ 64, 64, GDK_RGB_DITHER_NORMAL, buffer, 64 * 4);
+
+ pixbuf = gdk_pixbuf_new_from_data (buffer, GDK_COLORSPACE_RGB, TRUE,
+ 8, 64, 64, 4 * 64, NULL, NULL);
+
+ gdk_draw_pixbuf (widget->window, widget->style->black_gc, pixbuf,
+ 0, 0, x + width - 18 - 64, y + (height - 64) /2,
+ 64, 64, GDK_RGB_DITHER_NORMAL, 0, 0);
+
+ g_object_unref (pixbuf);
+
+ g_free (buffer);
+
+ return FALSE;
+}
+
+static GtkWidget *
+build_alpha_drawing ()
+{
+ GtkWidget *hbox;
+
+ hbox = gtk_hbox_new (FALSE, 0);
+ gtk_widget_set_size_request (hbox, 100, 100);
+
+ g_signal_connect (hbox, "expose-event",
+ G_CALLBACK (on_alpha_drawing_expose), NULL);
+
+ return hbox;
+}
+
+static void
+on_alpha_screen_changed (GtkWidget *widget,
+ GdkScreen *old_screen,
+ GtkWidget *label)
+{
+ GdkScreen *screen = gtk_widget_get_screen (widget);
+ GdkColormap *colormap = gdk_screen_get_rgba_colormap (screen);
+
+ if (!colormap)
+ {
+ colormap = gdk_screen_get_rgb_colormap (screen);
+ gtk_label_set_markup (GTK_LABEL (label), "<b>Screen doesn't support alpha</b>");
+ }
+ else
+ {
+ gtk_label_set_markup (GTK_LABEL (label), "<b>Screen supports alpha</b>");
+ }
+
+ gtk_widget_set_colormap (widget, colormap);
+}
+
+static void
+on_composited_changed (GtkWidget *window,
+ GtkLabel *label)
+{
+ gboolean is_composited = gtk_widget_is_composited (window);
+
+ if (is_composited)
+ gtk_label_set_text (label, "Composited");
+ else
+ gtk_label_set_text (label, "Not composited");
+}
+
+void
+create_alpha_window (GtkWidget *widget)
+{
+ static GtkWidget *window;
+
+ if (!window)
+ {
+ GtkWidget *vbox;
+ GtkWidget *label;
+
+ window = gtk_dialog_new_with_buttons ("Alpha Window",
+ GTK_WINDOW (gtk_widget_get_toplevel (widget)), 0,
+ GTK_STOCK_CLOSE, 0,
+ NULL);
+
+ gtk_widget_set_app_paintable (window, TRUE);
+ g_signal_connect (window, "expose-event",
+ G_CALLBACK (on_alpha_window_expose), NULL);
+
+ vbox = gtk_vbox_new (FALSE, 8);
+ gtk_container_set_border_width (GTK_CONTAINER (vbox), 12);
+ gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), vbox,
+ TRUE, TRUE, 0);
+
+ label = gtk_label_new (NULL);
+ gtk_box_pack_start (GTK_BOX (vbox), label, TRUE, TRUE, 0);
+ on_alpha_screen_changed (window, NULL, label);
+ g_signal_connect (window, "screen-changed",
+ G_CALLBACK (on_alpha_screen_changed), label);
+
+ label = gtk_label_new (NULL);
+ gtk_box_pack_start (GTK_BOX (vbox), label, TRUE, TRUE, 0);
+ on_composited_changed (window, GTK_LABEL (label));
+ g_signal_connect (window, "composited_changed", G_CALLBACK (on_composited_changed), label);
+
+ gtk_box_pack_start (GTK_BOX (vbox), build_alpha_widgets (), TRUE, TRUE, 0);
+ gtk_box_pack_start (GTK_BOX (vbox), build_alpha_drawing (), TRUE, TRUE, 0);
+
+ g_signal_connect (window, "destroy",
+ G_CALLBACK (gtk_widget_destroyed),
+ &window);
+
+ g_signal_connect (window, "response",
+ G_CALLBACK (gtk_widget_destroy),
+ NULL);
+ }
+
+ if (!gtk_widget_get_visible (window))
+ gtk_widget_show_all (window);
+ else
+ gtk_widget_destroy (window);
+}
+
+/*
+ * Composited non-toplevel window
+ */
+
+/* The expose event handler for the event box.
+ *
+ * This function simply draws a transparency onto a widget on the area
+ * for which it receives expose events. This is intended to give the
+ * event box a "transparent" background.
+ *
+ * In order for this to work properly, the widget must have an RGBA
+ * colourmap. The widget should also be set as app-paintable since it
+ * doesn't make sense for GTK to draw a background if we are drawing it
+ * (and because GTK might actually replace our transparency with its
+ * default background colour).
+ */
+static gboolean
+transparent_expose (GtkWidget *widget,
+ GdkEventExpose *event)
+{
+ cairo_t *cr;
+
+ cr = gdk_cairo_create (widget->window);
+ cairo_set_operator (cr, CAIRO_OPERATOR_CLEAR);
+ gdk_cairo_region (cr, event->region);
+ cairo_fill (cr);
+ cairo_destroy (cr);
+
+ return FALSE;
+}
+
+/* The expose event handler for the window.
+ *
+ * This function performs the actual compositing of the event box onto
+ * the already-existing background of the window at 50% normal opacity.
+ *
+ * In this case we do not want app-paintable to be set on the widget
+ * since we want it to draw its own (red) background. Because of this,
+ * however, we must ensure that we use g_signal_register_after so that
+ * this handler is called after the red has been drawn. If it was
+ * called before then GTK would just blindly paint over our work.
+ */
+static gboolean
+window_expose_event (GtkWidget *widget,
+ GdkEventExpose *event)
+{
+ GdkRegion *region;
+ GtkWidget *child;
+ cairo_t *cr;
+
+ /* get our child (in this case, the event box) */
+ child = gtk_bin_get_child (GTK_BIN (widget));
+
+ /* create a cairo context to draw to the window */
+ cr = gdk_cairo_create (widget->window);
+
+ /* the source data is the (composited) event box */
+ gdk_cairo_set_source_pixmap (cr, child->window,
+ child->allocation.x,
+ child->allocation.y);
+
+ /* draw no more than our expose event intersects our child */
+ region = gdk_region_rectangle (&child->allocation);
+ gdk_region_intersect (region, event->region);
+ gdk_cairo_region (cr, region);
+ cairo_clip (cr);
+
+ /* composite, with a 50% opacity */
+ cairo_set_operator (cr, CAIRO_OPERATOR_OVER);
+ cairo_paint_with_alpha (cr, 0.5);
+
+ /* we're done */
+ cairo_destroy (cr);
+
+ return FALSE;
+}
+
+void
+create_composited_window (GtkWidget *widget)
+{
+ static GtkWidget *window;
+
+ if (!window)
+ {
+ GtkWidget *event, *button;
+ GdkScreen *screen;
+ GdkColormap *rgba;
+ GdkColor red;
+
+ /* make the widgets */
+ button = gtk_button_new_with_label ("A Button");
+ event = gtk_event_box_new ();
+ window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+
+ g_signal_connect (window, "destroy",
+ G_CALLBACK (gtk_widget_destroyed),
+ &window);
+
+ /* put a red background on the window */
+ gdk_color_parse ("red", &red);
+ gtk_widget_modify_bg (window, GTK_STATE_NORMAL, &red);
+
+ /* set the colourmap for the event box.
+ * must be done before the event box is realised.
+ */
+ screen = gtk_widget_get_screen (event);
+ rgba = gdk_screen_get_rgba_colormap (screen);
+ gtk_widget_set_colormap (event, rgba);
+
+ /* set our event box to have a fully-transparent background
+ * drawn on it. currently there is no way to simply tell gtk
+ * that "transparency" is the background colour for a widget.
+ */
+ gtk_widget_set_app_paintable (GTK_WIDGET (event), TRUE);
+ g_signal_connect (event, "expose-event",
+ G_CALLBACK (transparent_expose), NULL);
+
+ /* put them inside one another */
+ gtk_container_set_border_width (GTK_CONTAINER (window), 10);
+ gtk_container_add (GTK_CONTAINER (window), event);
+ gtk_container_add (GTK_CONTAINER (event), button);
+
+ /* realise and show everything */
+ gtk_widget_realize (button);
+
+ /* set the event box GdkWindow to be composited.
+ * obviously must be performed after event box is realised.
+ */
+ gdk_window_set_composited (event->window, TRUE);
+
+ /* set up the compositing handler.
+ * note that we do _after so that the normal (red) background is drawn
+ * by gtk before our compositing occurs.
+ */
+ g_signal_connect_after (window, "expose-event",
+ G_CALLBACK (window_expose_event), NULL);
+ }
+
+ if (!gtk_widget_get_visible (window))
+ gtk_widget_show_all (window);
+ else
+ gtk_widget_destroy (window);
+}
+
/*
* Big windows and guffaw scrolling
*/
event->area.x, event->area.y,
event->area.width, event->area.height);
- g_object_unref (G_OBJECT (tmp_gc));
+ g_object_unref (tmp_gc);
}
return FALSE;
{ 0, 0xaaaa, 0xaaaa, 0xffff }
};
- g_object_set_data (G_OBJECT (child), "pattern-color", (gpointer)&colors[level]);
+ g_object_set_data (G_OBJECT (child), "pattern-color", (gpointer) &colors[level]);
gdk_window_set_user_data (child, widget);
}
}
static void
-create_big_windows (void)
+create_big_windows (GtkWidget *widget)
{
static GtkWidget *window = NULL;
GtkWidget *darea, *table, *scrollbar;
GtkAdjustment *vadj;
static gint current_x;
static gint current_y;
-
+
if (!window)
{
current_x = 0;
GTK_STOCK_CLOSE,
GTK_RESPONSE_NONE,
NULL);
+
+ gtk_window_set_screen (GTK_WINDOW (window),
+ gtk_widget_get_screen (widget));
gtk_window_set_default_size (GTK_WINDOW (window), 200, 300);
- gtk_signal_connect (GTK_OBJECT (window), "destroy",
- GTK_SIGNAL_FUNC (gtk_widget_destroyed),
- &window);
+ g_signal_connect (window, "destroy",
+ G_CALLBACK (gtk_widget_destroyed),
+ &window);
- gtk_signal_connect (GTK_OBJECT (window), "response",
- GTK_SIGNAL_FUNC (gtk_widget_destroy),
- NULL);
+ g_signal_connect (window, "response",
+ G_CALLBACK (gtk_widget_destroy),
+ NULL);
table = gtk_table_new (2, 2, FALSE);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox),
darea = gtk_drawing_area_new ();
hadj = (GtkAdjustment *)gtk_adjustment_new (0, 0, PATTERN_SIZE, 10, 100, 100);
- gtk_signal_connect (GTK_OBJECT (hadj), "value_changed",
- GTK_SIGNAL_FUNC (pattern_hadj_changed), darea);
+ g_signal_connect (hadj, "value_changed",
+ G_CALLBACK (pattern_hadj_changed), darea);
g_object_set_data (G_OBJECT (hadj), "old-value", ¤t_x);
vadj = (GtkAdjustment *)gtk_adjustment_new (0, 0, PATTERN_SIZE, 10, 100, 100);
- gtk_signal_connect (GTK_OBJECT (vadj), "value_changed",
- GTK_SIGNAL_FUNC (pattern_vadj_changed), darea);
+ g_signal_connect (vadj, "value_changed",
+ G_CALLBACK (pattern_vadj_changed), darea);
g_object_set_data (G_OBJECT (vadj), "old-value", ¤t_y);
- gtk_signal_connect (GTK_OBJECT (darea), "realize",
- GTK_SIGNAL_FUNC (pattern_realize),
- NULL);
- gtk_signal_connect (GTK_OBJECT (darea), "expose_event",
- GTK_SIGNAL_FUNC (pattern_expose),
- NULL);
+ g_signal_connect (darea, "realize",
+ G_CALLBACK (pattern_realize),
+ NULL);
+ g_signal_connect (darea, "expose_event",
+ G_CALLBACK (pattern_expose),
+ NULL);
eventbox = gtk_event_box_new ();
gtk_table_attach (GTK_TABLE (table), eventbox,
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
gtk_widget_hide (window);
button_window (GtkWidget *widget,
GtkWidget *button)
{
- if (!GTK_WIDGET_VISIBLE (button))
+ if (!gtk_widget_get_visible (button))
gtk_widget_show (button);
else
gtk_widget_hide (button);
}
static void
-create_buttons (void)
+create_buttons (GtkWidget *widget)
{
static GtkWidget *window = NULL;
GtkWidget *box1;
if (!window)
{
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+ gtk_window_set_screen (GTK_WINDOW (window),
+ gtk_widget_get_screen (widget));
- gtk_signal_connect (GTK_OBJECT (window), "destroy",
- GTK_SIGNAL_FUNC (gtk_widget_destroyed),
- &window);
+ g_signal_connect (window, "destroy",
+ G_CALLBACK (gtk_widget_destroyed),
+ &window);
gtk_window_set_title (GTK_WINDOW (window), "GtkButton");
gtk_container_set_border_width (GTK_CONTAINER (window), 0);
button[7] = gtk_button_new_from_stock (GTK_STOCK_CLOSE);
button[8] = gtk_button_new_with_label ("button9");
- gtk_signal_connect (GTK_OBJECT (button[0]), "clicked",
- GTK_SIGNAL_FUNC(button_window),
- button[1]);
+ g_signal_connect (button[0], "clicked",
+ G_CALLBACK (button_window),
+ button[1]);
gtk_table_attach (GTK_TABLE (table), button[0], 0, 1, 0, 1,
GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
- gtk_signal_connect (GTK_OBJECT (button[1]), "clicked",
- GTK_SIGNAL_FUNC(button_window),
- button[2]);
+ g_signal_connect (button[1], "clicked",
+ G_CALLBACK (button_window),
+ button[2]);
gtk_table_attach (GTK_TABLE (table), button[1], 1, 2, 1, 2,
GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
- gtk_signal_connect (GTK_OBJECT (button[2]), "clicked",
- GTK_SIGNAL_FUNC(button_window),
- button[3]);
+ g_signal_connect (button[2], "clicked",
+ G_CALLBACK (button_window),
+ button[3]);
gtk_table_attach (GTK_TABLE (table), button[2], 2, 3, 2, 3,
GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
- gtk_signal_connect (GTK_OBJECT (button[3]), "clicked",
- GTK_SIGNAL_FUNC(button_window),
- button[4]);
+ g_signal_connect (button[3], "clicked",
+ G_CALLBACK (button_window),
+ button[4]);
gtk_table_attach (GTK_TABLE (table), button[3], 0, 1, 2, 3,
GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
- gtk_signal_connect (GTK_OBJECT (button[4]), "clicked",
- GTK_SIGNAL_FUNC(button_window),
- button[5]);
+ g_signal_connect (button[4], "clicked",
+ G_CALLBACK (button_window),
+ button[5]);
gtk_table_attach (GTK_TABLE (table), button[4], 2, 3, 0, 1,
GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
- gtk_signal_connect (GTK_OBJECT (button[5]), "clicked",
- GTK_SIGNAL_FUNC(button_window),
- button[6]);
+ g_signal_connect (button[5], "clicked",
+ G_CALLBACK (button_window),
+ button[6]);
gtk_table_attach (GTK_TABLE (table), button[5], 1, 2, 2, 3,
GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
- gtk_signal_connect (GTK_OBJECT (button[6]), "clicked",
- GTK_SIGNAL_FUNC(button_window),
- button[7]);
+ g_signal_connect (button[6], "clicked",
+ G_CALLBACK (button_window),
+ button[7]);
gtk_table_attach (GTK_TABLE (table), button[6], 1, 2, 0, 1,
GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
- gtk_signal_connect (GTK_OBJECT (button[7]), "clicked",
- GTK_SIGNAL_FUNC(button_window),
- button[8]);
+ g_signal_connect (button[7], "clicked",
+ G_CALLBACK (button_window),
+ button[8]);
gtk_table_attach (GTK_TABLE (table), button[7], 2, 3, 1, 2,
GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
- gtk_signal_connect (GTK_OBJECT (button[8]), "clicked",
- GTK_SIGNAL_FUNC(button_window),
- button[0]);
+ g_signal_connect (button[8], "clicked",
+ G_CALLBACK (button_window),
+ button[0]);
gtk_table_attach (GTK_TABLE (table), button[8], 0, 1, 1, 2,
GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
button[9] = gtk_button_new_with_label ("close");
- gtk_signal_connect_object (GTK_OBJECT (button[9]), "clicked",
- GTK_SIGNAL_FUNC(gtk_widget_destroy),
- GTK_OBJECT (window));
+ g_signal_connect_swapped (button[9], "clicked",
+ G_CALLBACK (gtk_widget_destroy),
+ window);
gtk_box_pack_start (GTK_BOX (box2), button[9], TRUE, TRUE, 0);
GTK_WIDGET_SET_FLAGS (button[9], GTK_CAN_DEFAULT);
gtk_widget_grab_default (button[9]);
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
*/
static void
-create_toggle_buttons (void)
+create_toggle_buttons (GtkWidget *widget)
{
static GtkWidget *window = NULL;
GtkWidget *box1;
if (!window)
{
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+ gtk_window_set_screen (GTK_WINDOW (window),
+ gtk_widget_get_screen (widget));
- gtk_signal_connect (GTK_OBJECT (window), "destroy",
- GTK_SIGNAL_FUNC(gtk_widget_destroyed),
- &window);
+ g_signal_connect (window, "destroy",
+ G_CALLBACK (gtk_widget_destroyed),
+ &window);
gtk_window_set_title (GTK_WINDOW (window), "GtkToggleButton");
gtk_container_set_border_width (GTK_CONTAINER (window), 0);
gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
button = gtk_button_new_with_label ("close");
- gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
- GTK_SIGNAL_FUNC(gtk_widget_destroy),
- GTK_OBJECT (window));
+ g_signal_connect_swapped (button, "clicked",
+ G_CALLBACK (gtk_widget_destroy),
+ window);
gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
gtk_widget_grab_default (button);
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
}
+static GtkWidget *
+create_widget_grid (GType widget_type)
+{
+ GtkWidget *table;
+ GtkWidget *group_widget = NULL;
+ gint i, j;
+
+ table = gtk_table_new (FALSE, 3, 3);
+
+ for (i = 0; i < 5; i++)
+ {
+ for (j = 0; j < 5; j++)
+ {
+ GtkWidget *widget;
+ char *tmp;
+
+ if (i == 0 && j == 0)
+ {
+ widget = NULL;
+ }
+ else if (i == 0)
+ {
+ tmp = g_strdup_printf ("%d", j);
+ widget = gtk_label_new (tmp);
+ g_free (tmp);
+ }
+ else if (j == 0)
+ {
+ tmp = g_strdup_printf ("%c", 'A' + i - 1);
+ widget = gtk_label_new (tmp);
+ g_free (tmp);
+ }
+ else
+ {
+ widget = g_object_new (widget_type, NULL);
+
+ if (g_type_is_a (widget_type, GTK_TYPE_RADIO_BUTTON))
+ {
+ if (!group_widget)
+ group_widget = widget;
+ else
+ g_object_set (widget, "group", group_widget, NULL);
+ }
+ }
+
+ if (widget)
+ gtk_table_attach (GTK_TABLE (table), widget,
+ i, i + 1, j, j + 1,
+ 0, 0,
+ 0, 0);
+ }
+ }
+
+ return table;
+}
+
/*
* GtkCheckButton
*/
static void
-create_check_buttons (void)
+create_check_buttons (GtkWidget *widget)
{
static GtkWidget *window = NULL;
GtkWidget *box1;
GtkWidget *box2;
GtkWidget *button;
GtkWidget *separator;
-
+ GtkWidget *table;
+
if (!window)
{
- window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
-
- gtk_signal_connect (GTK_OBJECT (window), "destroy",
- GTK_SIGNAL_FUNC(gtk_widget_destroyed),
- &window);
+ window = gtk_dialog_new_with_buttons ("Check Buttons",
+ NULL, 0,
+ GTK_STOCK_CLOSE,
+ GTK_RESPONSE_NONE,
+ NULL);
- gtk_window_set_title (GTK_WINDOW (window), "GtkCheckButton");
- gtk_container_set_border_width (GTK_CONTAINER (window), 0);
+ gtk_window_set_screen (GTK_WINDOW (window),
+ gtk_widget_get_screen (widget));
- box1 = gtk_vbox_new (FALSE, 0);
- gtk_container_add (GTK_CONTAINER (window), box1);
+ g_signal_connect (window, "destroy",
+ G_CALLBACK (gtk_widget_destroyed),
+ &window);
+ g_signal_connect (window, "response",
+ G_CALLBACK (gtk_widget_destroy),
+ NULL);
+ box1 = GTK_DIALOG (window)->vbox;
+
box2 = gtk_vbox_new (FALSE, 10);
gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
button = gtk_check_button_new_with_label ("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);
- box2 = gtk_vbox_new (FALSE, 10);
- gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
- gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
-
- button = gtk_button_new_with_label ("close");
- gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
- GTK_SIGNAL_FUNC(gtk_widget_destroy),
- GTK_OBJECT (window));
- gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
- GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
- gtk_widget_grab_default (button);
+ table = create_widget_grid (GTK_TYPE_CHECK_BUTTON);
+ gtk_container_set_border_width (GTK_CONTAINER (table), 10);
+ gtk_box_pack_start (GTK_BOX (box1), table, TRUE, TRUE, 0);
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
*/
static void
-create_radio_buttons (void)
+create_radio_buttons (GtkWidget *widget)
{
static GtkWidget *window = NULL;
GtkWidget *box1;
GtkWidget *box2;
GtkWidget *button;
GtkWidget *separator;
+ GtkWidget *table;
if (!window)
{
- window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+ window = gtk_dialog_new_with_buttons ("Radio Buttons",
+ NULL, 0,
+ GTK_STOCK_CLOSE,
+ GTK_RESPONSE_NONE,
+ NULL);
- gtk_signal_connect (GTK_OBJECT (window), "destroy",
- GTK_SIGNAL_FUNC(gtk_widget_destroyed),
- &window);
+ gtk_window_set_screen (GTK_WINDOW (window),
+ gtk_widget_get_screen (widget));
- gtk_window_set_title (GTK_WINDOW (window), "radio buttons");
- gtk_container_set_border_width (GTK_CONTAINER (window), 0);
+ g_signal_connect (window, "destroy",
+ G_CALLBACK (gtk_widget_destroyed),
+ &window);
+ g_signal_connect (window, "response",
+ G_CALLBACK (gtk_widget_destroy),
+ NULL);
- box1 = gtk_vbox_new (FALSE, 0);
- gtk_container_add (GTK_CONTAINER (window), box1);
+ box1 = GTK_DIALOG (window)->vbox;
box2 = gtk_vbox_new (FALSE, 10);
gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
separator = gtk_hseparator_new ();
gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
- box2 = gtk_vbox_new (FALSE, 10);
- gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
- gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
-
- button = gtk_button_new_with_label ("close");
- gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
- GTK_SIGNAL_FUNC(gtk_widget_destroy),
- GTK_OBJECT (window));
- gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
- GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
- gtk_widget_grab_default (button);
+ table = create_widget_grid (GTK_TYPE_RADIO_BUTTON);
+ gtk_container_set_border_width (GTK_CONTAINER (table), 10);
+ gtk_box_pack_start (GTK_BOX (box1), table, TRUE, TRUE, 0);
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
create_bbox (gint horizontal,
char* title,
gint spacing,
- gint child_w,
- gint child_h,
+ gint child_w,
+ gint child_h,
gint layout)
{
GtkWidget *frame;
}
static void
-create_button_box (void)
+create_button_box (GtkWidget *widget)
{
static GtkWidget* window = NULL;
GtkWidget *main_vbox;
GtkWidget *hbox;
GtkWidget *frame_horz;
GtkWidget *frame_vert;
-
+
if (!window)
{
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+ gtk_window_set_screen (GTK_WINDOW (window), gtk_widget_get_screen (widget));
gtk_window_set_title (GTK_WINDOW (window), "Button Boxes");
- gtk_signal_connect (GTK_OBJECT (window), "destroy",
- GTK_SIGNAL_FUNC(gtk_widget_destroyed),
- &window);
-
+ g_signal_connect (window, "destroy",
+ G_CALLBACK (gtk_widget_destroyed),
+ &window);
+
gtk_container_set_border_width (GTK_CONTAINER (window), 10);
main_vbox = gtk_vbox_new (FALSE, 0);
vbox = gtk_vbox_new (FALSE, 0);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 10);
gtk_container_add (GTK_CONTAINER (frame_horz), vbox);
-
+
gtk_box_pack_start (GTK_BOX (vbox),
- create_bbox (TRUE, "Spread", 40, 85, 20, GTK_BUTTONBOX_SPREAD),
+ create_bbox (TRUE, "Spread", 40, 85, 20, GTK_BUTTONBOX_SPREAD),
TRUE, TRUE, 0);
-
+
gtk_box_pack_start (GTK_BOX (vbox),
- create_bbox (TRUE, "Edge", 40, 85, 20, GTK_BUTTONBOX_EDGE),
+ create_bbox (TRUE, "Edge", 40, 85, 20, GTK_BUTTONBOX_EDGE),
TRUE, TRUE, 5);
-
+
gtk_box_pack_start (GTK_BOX (vbox),
- create_bbox (TRUE, "Start", 40, 85, 20, GTK_BUTTONBOX_START),
+ create_bbox (TRUE, "Start", 40, 85, 20, GTK_BUTTONBOX_START),
TRUE, TRUE, 5);
-
+
gtk_box_pack_start (GTK_BOX (vbox),
- create_bbox (TRUE, "End", 40, 85, 20, GTK_BUTTONBOX_END),
+ create_bbox (TRUE, "End", 40, 85, 20, GTK_BUTTONBOX_END),
TRUE, TRUE, 5);
-
+
+ gtk_box_pack_start (GTK_BOX (vbox),
+ create_bbox (TRUE, "Center", 40, 85, 20, GTK_BUTTONBOX_CENTER),
+ TRUE, TRUE, 5);
+
frame_vert = gtk_frame_new ("Vertical Button Boxes");
gtk_box_pack_start (GTK_BOX (main_vbox), frame_vert, TRUE, TRUE, 10);
gtk_container_add (GTK_CONTAINER (frame_vert), hbox);
gtk_box_pack_start (GTK_BOX (hbox),
- create_bbox (FALSE, "Spread", 30, 85, 20, GTK_BUTTONBOX_SPREAD),
+ create_bbox (FALSE, "Spread", 30, 85, 20, GTK_BUTTONBOX_SPREAD),
TRUE, TRUE, 0);
-
+
gtk_box_pack_start (GTK_BOX (hbox),
- create_bbox (FALSE, "Edge", 30, 85, 20, GTK_BUTTONBOX_EDGE),
+ create_bbox (FALSE, "Edge", 30, 85, 20, GTK_BUTTONBOX_EDGE),
TRUE, TRUE, 5);
-
+
gtk_box_pack_start (GTK_BOX (hbox),
- create_bbox (FALSE, "Start", 30, 85, 20, GTK_BUTTONBOX_START),
+ create_bbox (FALSE, "Start", 30, 85, 20, GTK_BUTTONBOX_START),
TRUE, TRUE, 5);
-
+
gtk_box_pack_start (GTK_BOX (hbox),
- create_bbox (FALSE, "End", 30, 85, 20, GTK_BUTTONBOX_END),
+ create_bbox (FALSE, "End", 30, 85, 20, GTK_BUTTONBOX_END),
+ TRUE, TRUE, 5);
+
+ gtk_box_pack_start (GTK_BOX (hbox),
+ create_bbox (FALSE, "Center", 30, 85, 20, GTK_BUTTONBOX_CENTER),
TRUE, TRUE, 5);
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
background,
filename);
- wpixmap = gtk_pixmap_new (pixmap, mask);
+ wpixmap = gtk_image_new_from_pixmap (pixmap, mask);
return wpixmap;
}
}
static void
-create_toolbar (void)
+create_toolbar (GtkWidget *widget)
{
static GtkWidget *window = NULL;
GtkWidget *toolbar;
if (!window)
{
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+ gtk_window_set_screen (GTK_WINDOW (window),
+ gtk_widget_get_screen (widget));
+
gtk_window_set_title (GTK_WINDOW (window), "Toolbar test");
- gtk_window_set_resizable (GTK_WINDOW (window), FALSE);
- gtk_signal_connect (GTK_OBJECT (window), "destroy",
- GTK_SIGNAL_FUNC (gtk_widget_destroyed),
- &window);
+ g_signal_connect (window, "destroy",
+ G_CALLBACK (gtk_widget_destroyed),
+ &window);
gtk_container_set_border_width (GTK_CONTAINER (window), 0);
gtk_widget_realize (window);
gtk_toolbar_insert_stock (GTK_TOOLBAR (toolbar),
GTK_STOCK_NEW,
"Stock icon: New", "Toolbar/New",
- (GtkSignalFunc) set_toolbar_small_stock, toolbar, -1);
+ G_CALLBACK (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);
+ G_CALLBACK (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]),
- (GtkSignalFunc) set_toolbar_horizontal, toolbar);
+ G_CALLBACK (set_toolbar_horizontal), toolbar);
gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
"Vertical", "Vertical toolbar layout", "Toolbar/Vertical",
new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
- (GtkSignalFunc) set_toolbar_vertical, toolbar);
+ G_CALLBACK (set_toolbar_vertical), toolbar);
gtk_toolbar_append_space (GTK_TOOLBAR(toolbar));
gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
"Icons", "Only show toolbar icons", "Toolbar/IconsOnly",
new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
- (GtkSignalFunc) set_toolbar_icons, toolbar);
+ G_CALLBACK (set_toolbar_icons), toolbar);
gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
"Text", "Only show toolbar text", "Toolbar/TextOnly",
new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
- (GtkSignalFunc) set_toolbar_text, toolbar);
+ G_CALLBACK (set_toolbar_text), toolbar);
gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
"Both", "Show toolbar icons and text", "Toolbar/Both",
new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
- (GtkSignalFunc) set_toolbar_both, toolbar);
+ G_CALLBACK (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);
+ G_CALLBACK (set_toolbar_both_horiz), toolbar);
gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
"Enable", "Enable tooltips", NULL,
new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
- (GtkSignalFunc) set_toolbar_enable, toolbar);
+ G_CALLBACK (set_toolbar_enable), toolbar);
gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
"Disable", "Disable tooltips", NULL,
new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
- (GtkSignalFunc) set_toolbar_disable, toolbar);
+ G_CALLBACK (set_toolbar_disable), toolbar);
gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
"Frobate", "Frobate tooltip", NULL,
new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
- (GtkSignalFunc) NULL, toolbar);
+ NULL, toolbar);
gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
"Baz", "Baz tooltip", NULL,
new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
- (GtkSignalFunc) NULL, toolbar);
+ NULL, toolbar);
gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
"Blah", "Blah tooltip", NULL,
new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
- (GtkSignalFunc) NULL, toolbar);
+ NULL, toolbar);
gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
"Bar", "Bar tooltip", NULL,
new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
- (GtkSignalFunc) NULL, toolbar);
+ NULL, toolbar);
gtk_container_add (GTK_CONTAINER (window), toolbar);
+
+ gtk_widget_set_size_request (toolbar, 200, -1);
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
"Horizontal", "Horizontal toolbar layout", NULL,
new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
- (GtkSignalFunc) set_toolbar_horizontal, toolbar);
+ G_CALLBACK (set_toolbar_horizontal), toolbar);
gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
"Vertical", "Vertical toolbar layout", NULL,
new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
- (GtkSignalFunc) set_toolbar_vertical, toolbar);
+ G_CALLBACK (set_toolbar_vertical), toolbar);
gtk_toolbar_append_space (GTK_TOOLBAR(toolbar));
gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
"Icons", "Only show toolbar icons", NULL,
new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
- (GtkSignalFunc) set_toolbar_icons, toolbar);
+ G_CALLBACK (set_toolbar_icons), toolbar);
gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
"Text", "Only show toolbar text", NULL,
new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
- (GtkSignalFunc) set_toolbar_text, toolbar);
+ G_CALLBACK (set_toolbar_text), toolbar);
gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
"Both", "Show toolbar icons and text", NULL,
new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
- (GtkSignalFunc) set_toolbar_both, toolbar);
+ G_CALLBACK (set_toolbar_both), toolbar);
gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
"Woot", "Woot woot woot", NULL,
new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
- (GtkSignalFunc) NULL, toolbar);
+ NULL, toolbar);
gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
"Blah", "Blah blah blah", "Toolbar/Big",
new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
- (GtkSignalFunc) NULL, toolbar);
+ NULL, toolbar);
gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
"Enable", "Enable tooltips", NULL,
new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
- (GtkSignalFunc) set_toolbar_enable, toolbar);
+ G_CALLBACK (set_toolbar_enable), toolbar);
gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
"Disable", "Disable tooltips", NULL,
new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
- (GtkSignalFunc) set_toolbar_disable, toolbar);
+ G_CALLBACK (set_toolbar_disable), toolbar);
gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
"Hoo", "Hoo tooltip", NULL,
new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
- (GtkSignalFunc) NULL, toolbar);
+ NULL, toolbar);
gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
"Woo", "Woo tooltip", NULL,
new_pixmap ("test.xpm", window->window, &window->style->bg[GTK_STATE_NORMAL]),
- (GtkSignalFunc) NULL, toolbar);
+ NULL, toolbar);
return toolbar;
}
gtk_statusbar_push (statusbar, 1, text);
}
+static void
+statusbar_push_long (GtkWidget *button,
+ GtkStatusbar *statusbar)
+{
+ gchar text[1024];
+
+ sprintf (text, "Just because a system has menu choices written with English words, phrases or sentences, that is no guarantee, that it is comprehensible. Individual words may not be familiar to some users (for example, \"repaginate\"), and two menu items may appear to satisfy the users's needs, whereas only one does (for example, \"put away\" or \"eject\").");
+
+ gtk_statusbar_push (statusbar, 1, text);
+}
+
static void
statusbar_pop (GtkWidget *button,
GtkStatusbar *statusbar)
}
static void
-create_statusbar (void)
+create_statusbar (GtkWidget *widget)
{
static GtkWidget *window = NULL;
GtkWidget *box1;
if (!window)
{
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+ gtk_window_set_screen (GTK_WINDOW (window),
+ gtk_widget_get_screen (widget));
- gtk_signal_connect (GTK_OBJECT (window), "destroy",
- GTK_SIGNAL_FUNC (gtk_widget_destroyed),
- &window);
+ g_signal_connect (window, "destroy",
+ G_CALLBACK (gtk_widget_destroyed),
+ &window);
gtk_window_set_title (GTK_WINDOW (window), "statusbar");
gtk_container_set_border_width (GTK_CONTAINER (window), 0);
statusbar = gtk_statusbar_new ();
gtk_box_pack_end (GTK_BOX (box1), statusbar, TRUE, TRUE, 0);
- gtk_signal_connect (GTK_OBJECT (statusbar),
- "text_popped",
- GTK_SIGNAL_FUNC (statusbar_popped),
- NULL);
+ g_signal_connect (statusbar,
+ "text_popped",
+ G_CALLBACK (statusbar_popped),
+ NULL);
- button = gtk_widget_new (gtk_button_get_type (),
+ button = g_object_new (gtk_button_get_type (),
"label", "push something",
"visible", TRUE,
"parent", box2,
NULL);
- g_object_connect (G_OBJECT (button),
+ g_object_connect (button,
"signal::clicked", statusbar_push, statusbar,
NULL);
- button = g_object_connect (gtk_widget_new (gtk_button_get_type (),
+ button = g_object_connect (g_object_new (gtk_button_get_type (),
"label", "pop",
"visible", TRUE,
"parent", box2,
"signal_after::clicked", statusbar_pop, statusbar,
NULL);
- button = g_object_connect (gtk_widget_new (gtk_button_get_type (),
+ button = g_object_connect (g_object_new (gtk_button_get_type (),
"label", "steal #4",
"visible", TRUE,
"parent", box2,
"signal_after::clicked", statusbar_steal, statusbar,
NULL);
- button = g_object_connect (gtk_widget_new (gtk_button_get_type (),
+ button = g_object_connect (g_object_new (gtk_button_get_type (),
"label", "test contexts",
"visible", TRUE,
"parent", box2,
NULL),
"swapped_signal_after::clicked", statusbar_contexts, statusbar,
NULL);
+
+ button = g_object_connect (g_object_new (gtk_button_get_type (),
+ "label", "push something long",
+ "visible", TRUE,
+ "parent", box2,
+ NULL),
+ "signal_after::clicked", statusbar_push_long, statusbar,
+ NULL);
separator = gtk_hseparator_new ();
gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
button = gtk_button_new_with_label ("close");
- gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
- GTK_SIGNAL_FUNC(gtk_widget_destroy),
- GTK_OBJECT (window));
+ g_signal_connect_swapped (button, "clicked",
+ G_CALLBACK (gtk_widget_destroy),
+ window);
gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
gtk_widget_grab_default (button);
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
sTreeButtons* tree_buttons;
/* free buttons structure associate at this tree */
- tree_buttons = gtk_object_get_user_data (GTK_OBJECT (w));
+ tree_buttons = g_object_get_data (G_OBJECT (w), "user_data");
g_free (tree_buttons);
}
GtkWidget* item_new;
char buffer[255];
- tree_buttons = gtk_object_get_user_data(GTK_OBJECT(tree));
+ tree_buttons = g_object_get_data (G_OBJECT (tree), "user_data");
selected_list = GTK_TREE_SELECTION_OLD(tree);
GList* selected_list;
guint nb_selected;
- tree_buttons = gtk_object_get_user_data(GTK_OBJECT(tree));
+ tree_buttons = g_object_get_data (G_OBJECT (tree), "user_data");
selected_list = GTK_TREE_SELECTION_OLD(tree);
nb_selected = g_list_length(selected_list);
}
static void
-create_tree_sample(guint selection_mode,
+create_tree_sample(GdkScreen *screen, guint selection_mode,
guint draw_line, guint view_line, guint no_root_item,
guint nb_item_max, guint recursion_level_max)
{
/* create top level window */
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
+ gtk_window_set_screen (GTK_WINDOW (window), screen);
gtk_window_set_title(GTK_WINDOW(window), "Tree Sample");
- gtk_signal_connect(GTK_OBJECT(window), "destroy",
- (GtkSignalFunc) cb_tree_destroy_event, NULL);
- gtk_object_set_user_data(GTK_OBJECT(window), tree_buttons);
+ g_signal_connect (window, "destroy",
+ G_CALLBACK (cb_tree_destroy_event), NULL);
+ g_object_set_data (G_OBJECT (window), "user_data", tree_buttons);
box1 = gtk_vbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(window), box1);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_box_pack_start (GTK_BOX (box2), scrolled_win, TRUE, TRUE, 0);
- gtk_widget_set_usize (scrolled_win, 200, 200);
+ gtk_widget_set_size_request (scrolled_win, 200, 200);
gtk_widget_show (scrolled_win);
/* create root tree widget */
root_tree = gtk_tree_new();
- gtk_signal_connect(GTK_OBJECT(root_tree), "selection_changed",
- (GtkSignalFunc)cb_tree_changed,
- (gpointer)NULL);
- gtk_object_set_user_data(GTK_OBJECT(root_tree), tree_buttons);
+ g_signal_connect (root_tree, "selection_changed",
+ G_CALLBACK (cb_tree_changed),
+ NULL);
+ g_object_set_data (G_OBJECT (root_tree), "user_data", tree_buttons);
gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (scrolled_win), root_tree);
gtk_tree_set_selection_mode(GTK_TREE(root_tree), selection_mode);
gtk_tree_set_view_lines(GTK_TREE(root_tree), draw_line);
button = gtk_button_new_with_label("Add Item");
gtk_widget_set_sensitive(button, FALSE);
- gtk_signal_connect(GTK_OBJECT (button), "clicked",
- (GtkSignalFunc) cb_add_new_item,
- (gpointer)root_tree);
+ g_signal_connect (button, "clicked",
+ G_CALLBACK (cb_add_new_item),
+ root_tree);
gtk_box_pack_start(GTK_BOX(box2), button, TRUE, TRUE, 0);
gtk_widget_show(button);
tree_buttons->add_button = button;
button = gtk_button_new_with_label("Remove Item(s)");
gtk_widget_set_sensitive(button, FALSE);
- gtk_signal_connect(GTK_OBJECT (button), "clicked",
- (GtkSignalFunc) cb_remove_item,
- (gpointer)root_tree);
+ g_signal_connect (button, "clicked",
+ G_CALLBACK (cb_remove_item),
+ root_tree);
gtk_box_pack_start(GTK_BOX(box2), button, TRUE, TRUE, 0);
gtk_widget_show(button);
tree_buttons->remove_button = button;
button = gtk_button_new_with_label("Remove Subtree");
gtk_widget_set_sensitive(button, FALSE);
- gtk_signal_connect(GTK_OBJECT (button), "clicked",
- (GtkSignalFunc) cb_remove_subtree,
- (gpointer)root_tree);
+ g_signal_connect (button, "clicked",
+ G_CALLBACK (cb_remove_subtree),
+ root_tree);
gtk_box_pack_start(GTK_BOX(box2), button, TRUE, TRUE, 0);
gtk_widget_show(button);
tree_buttons->subtree_button = button;
button = gtk_button_new_with_label("Close");
gtk_box_pack_start(GTK_BOX(box2), button, TRUE, TRUE, 0);
- gtk_signal_connect_object(GTK_OBJECT (button), "clicked",
- (GtkSignalFunc) gtk_widget_destroy,
- GTK_OBJECT(window));
+ g_signal_connect_swapped (button, "clicked",
+ G_CALLBACK (gtk_widget_destroy),
+ window);
gtk_widget_show(button);
gtk_widget_show(window);
return;
}
- create_tree_sample(selection_mode, draw_line, view_line, no_root_item, nb_item, recursion_level);
+ create_tree_sample(gtk_widget_get_screen (w),
+ selection_mode, draw_line,
+ view_line, no_root_item, nb_item, recursion_level);
}
void
-create_tree_mode_window(void)
+create_tree_mode_window(GtkWidget *widget)
{
static GtkWidget* window;
GtkWidget* box1;
{
/* create toplevel window */
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
+ gtk_window_set_screen (GTK_WINDOW (window),
+ gtk_widget_get_screen (widget));
gtk_window_set_title(GTK_WINDOW(window), "Set Tree Parameters");
- gtk_signal_connect (GTK_OBJECT (window), "destroy",
- GTK_SIGNAL_FUNC(gtk_widget_destroyed),
- &window);
+ g_signal_connect (window, "destroy",
+ G_CALLBACK (gtk_widget_destroyed),
+ &window);
box1 = gtk_vbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(window), box1);
button = gtk_button_new_with_label("Create Tree");
gtk_box_pack_start(GTK_BOX(box2), button, TRUE, TRUE, 0);
- gtk_signal_connect(GTK_OBJECT (button), "clicked",
- (GtkSignalFunc) cb_create_tree, NULL);
+ g_signal_connect (button, "clicked",
+ G_CALLBACK (cb_create_tree), NULL);
button = gtk_button_new_with_label("Close");
gtk_box_pack_start(GTK_BOX(box2), button, TRUE, TRUE, 0);
- gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
- GTK_SIGNAL_FUNC(gtk_widget_destroy),
- GTK_OBJECT (window));
+ g_signal_connect_swapped (button, "clicked",
+ G_CALLBACK (gtk_widget_destroy),
+ window);
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
}
+/*
+ * Gridded geometry
+ */
+#define GRID_SIZE 20
+#define DEFAULT_GEOMETRY "10x10"
+
+static gboolean
+gridded_geometry_expose (GtkWidget *widget,
+ GdkEventExpose *event)
+{
+ int i, j;
+
+ gdk_draw_rectangle (widget->window, widget->style->base_gc[widget->state], TRUE,
+ 0, 0, widget->allocation.width, widget->allocation.height);
+
+ for (i = 0 ; i * GRID_SIZE < widget->allocation.width; i++)
+ for (j = 0 ; j * GRID_SIZE < widget->allocation.height; j++)
+ {
+ if ((i + j) % 2 == 0)
+ gdk_draw_rectangle (widget->window, widget->style->text_gc[widget->state], TRUE,
+ i * GRID_SIZE, j * GRID_SIZE, GRID_SIZE, GRID_SIZE);
+ }
+
+ return FALSE;
+}
+
+static void
+gridded_geometry_subresponse (GtkDialog *dialog,
+ gint response_id,
+ gchar *geometry_string)
+{
+ if (response_id == GTK_RESPONSE_NONE)
+ {
+ gtk_widget_destroy (GTK_WIDGET (dialog));
+ }
+ else
+ {
+ if (!gtk_window_parse_geometry (GTK_WINDOW (dialog), geometry_string))
+ {
+ g_print ("Can't parse geometry string %s\n", geometry_string);
+ gtk_window_parse_geometry (GTK_WINDOW (dialog), DEFAULT_GEOMETRY);
+ }
+ }
+}
+
+static void
+gridded_geometry_response (GtkDialog *dialog,
+ gint response_id,
+ GtkEntry *entry)
+{
+ if (response_id == GTK_RESPONSE_NONE)
+ {
+ gtk_widget_destroy (GTK_WIDGET (dialog));
+ }
+ else
+ {
+ gchar *geometry_string = g_strdup (gtk_entry_get_text (entry));
+ gchar *title = g_strdup_printf ("Gridded window at: %s", geometry_string);
+ GtkWidget *window;
+ GtkWidget *drawing_area;
+ GtkWidget *box;
+ GdkGeometry geometry;
+
+ window = gtk_dialog_new_with_buttons (title,
+ NULL, 0,
+ "Reset", 1,
+ GTK_STOCK_CLOSE, GTK_RESPONSE_NONE,
+ NULL);
+
+ gtk_window_set_screen (GTK_WINDOW (window),
+ gtk_widget_get_screen (GTK_WIDGET (dialog)));
+ g_free (title);
+ g_signal_connect (window, "response",
+ G_CALLBACK (gridded_geometry_subresponse), geometry_string);
+
+ box = gtk_vbox_new (FALSE, 0);
+ gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), box, TRUE, TRUE, 0);
+
+ gtk_container_set_border_width (GTK_CONTAINER (box), 7);
+
+ drawing_area = gtk_drawing_area_new ();
+ g_signal_connect (drawing_area, "expose_event",
+ G_CALLBACK (gridded_geometry_expose), NULL);
+ gtk_box_pack_start (GTK_BOX (box), drawing_area, TRUE, TRUE, 0);
+
+ /* Gross hack to work around bug 68668... if we set the size request
+ * large enough, then the current
+ *
+ * request_of_window - request_of_geometry_widget
+ *
+ * method of getting the base size works more or less works.
+ */
+ gtk_widget_set_size_request (drawing_area, 2000, 2000);
+
+ geometry.base_width = 0;
+ geometry.base_height = 0;
+ geometry.min_width = 2 * GRID_SIZE;
+ geometry.min_height = 2 * GRID_SIZE;
+ geometry.width_inc = GRID_SIZE;
+ geometry.height_inc = GRID_SIZE;
+
+ gtk_window_set_geometry_hints (GTK_WINDOW (window), drawing_area,
+ &geometry,
+ GDK_HINT_BASE_SIZE | GDK_HINT_MIN_SIZE | GDK_HINT_RESIZE_INC);
+
+ if (!gtk_window_parse_geometry (GTK_WINDOW (window), geometry_string))
+ {
+ g_print ("Can't parse geometry string %s\n", geometry_string);
+ gtk_window_parse_geometry (GTK_WINDOW (window), DEFAULT_GEOMETRY);
+ }
+
+ gtk_widget_show_all (window);
+ }
+}
+
+static void
+create_gridded_geometry (GtkWidget *widget)
+{
+ static GtkWidget *window = NULL;
+ gpointer window_ptr;
+ GtkWidget *entry;
+ GtkWidget *label;
+
+ if (!window)
+ {
+ window = gtk_dialog_new_with_buttons ("Gridded Geometry",
+ NULL, 0,
+ "Create", 1,
+ GTK_STOCK_CLOSE, GTK_RESPONSE_NONE,
+ NULL);
+
+ gtk_window_set_screen (GTK_WINDOW (window),
+ gtk_widget_get_screen (widget));
+
+ label = gtk_label_new ("Geometry string:");
+ gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), label, FALSE, FALSE, 0);
+
+ entry = gtk_entry_new ();
+ gtk_entry_set_text (GTK_ENTRY (entry), DEFAULT_GEOMETRY);
+ gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), entry, FALSE, FALSE, 0);
+
+ g_signal_connect (window, "response",
+ G_CALLBACK (gridded_geometry_response), entry);
+ window_ptr = &window;
+ g_object_add_weak_pointer (G_OBJECT (window), window_ptr);
+
+ gtk_widget_show_all (window);
+ }
+ else
+ gtk_widget_destroy (window);
+}
+
/*
* GtkHandleBox
*/
const gchar *action)
{
printf ("%s: child <%s> %sed\n",
- gtk_type_name (GTK_OBJECT_TYPE (hb)),
- gtk_type_name (GTK_OBJECT_TYPE (child)),
+ g_type_name (G_OBJECT_TYPE (hb)),
+ g_type_name (G_OBJECT_TYPE (child)),
action);
}
static void
-create_handle_box (void)
+create_handle_box (GtkWidget *widget)
{
static GtkWidget* window = NULL;
GtkWidget *handle_box;
GtkWidget *toolbar;
GtkWidget *label;
GtkWidget *separator;
-
+
if (!window)
{
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+
+ gtk_window_set_screen (GTK_WINDOW (window),
+ gtk_widget_get_screen (widget));
+ gtk_window_set_modal (GTK_WINDOW (window), FALSE);
gtk_window_set_title (GTK_WINDOW (window),
"Handle Box Test");
- gtk_window_set_resizable (GTK_WINDOW (window), FALSE);
+ gtk_window_set_resizable (GTK_WINDOW (window), TRUE);
- gtk_signal_connect (GTK_OBJECT (window), "destroy",
- GTK_SIGNAL_FUNC(gtk_widget_destroyed),
- &window);
+ g_signal_connect (window, "destroy",
+ G_CALLBACK (gtk_widget_destroyed),
+ &window);
gtk_container_set_border_width (GTK_CONTAINER (window), 20);
handle_box = gtk_handle_box_new ();
gtk_box_pack_start (GTK_BOX (hbox), handle_box, FALSE, FALSE, 0);
- gtk_signal_connect (GTK_OBJECT (handle_box),
- "child_attached",
- GTK_SIGNAL_FUNC (handle_box_child_signal),
- "attached");
- gtk_signal_connect (GTK_OBJECT (handle_box),
- "child_detached",
- GTK_SIGNAL_FUNC (handle_box_child_signal),
- "detached");
+ g_signal_connect (handle_box,
+ "child_attached",
+ G_CALLBACK (handle_box_child_signal),
+ "attached");
+ g_signal_connect (handle_box,
+ "child_detached",
+ G_CALLBACK (handle_box_child_signal),
+ "detached");
gtk_widget_show (handle_box);
toolbar = make_toolbar (window);
handle_box = gtk_handle_box_new ();
gtk_box_pack_start (GTK_BOX (hbox), handle_box, FALSE, FALSE, 0);
- gtk_signal_connect (GTK_OBJECT (handle_box),
- "child_attached",
- GTK_SIGNAL_FUNC (handle_box_child_signal),
- "attached");
- gtk_signal_connect (GTK_OBJECT (handle_box),
- "child_detached",
- GTK_SIGNAL_FUNC (handle_box_child_signal),
- "detached");
+ g_signal_connect (handle_box,
+ "child_attached",
+ G_CALLBACK (handle_box_child_signal),
+ "attached");
+ g_signal_connect (handle_box,
+ "child_detached",
+ G_CALLBACK (handle_box_child_signal),
+ "detached");
gtk_widget_show (handle_box);
handle_box2 = gtk_handle_box_new ();
gtk_container_add (GTK_CONTAINER (handle_box), handle_box2);
- gtk_signal_connect (GTK_OBJECT (handle_box2),
- "child_attached",
- GTK_SIGNAL_FUNC (handle_box_child_signal),
- "attached");
- gtk_signal_connect (GTK_OBJECT (handle_box2),
- "child_detached",
- GTK_SIGNAL_FUNC (handle_box_child_signal),
- "detached");
+ g_signal_connect (handle_box2,
+ "child_attached",
+ G_CALLBACK (handle_box_child_signal),
+ "attached");
+ g_signal_connect (handle_box2,
+ "child_detached",
+ G_CALLBACK (handle_box_child_signal),
+ "detached");
gtk_widget_show (handle_box2);
+ hbox = g_object_new (GTK_TYPE_HBOX, "visible", 1, "parent", handle_box2, NULL);
label = gtk_label_new ("Fooo!");
- gtk_container_add (GTK_CONTAINER (handle_box2), label);
+ gtk_container_add (GTK_CONTAINER (hbox), label);
gtk_widget_show (label);
+ g_object_new (GTK_TYPE_ARROW, "visible", 1, "parent", hbox, NULL);
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
gtk_widget_show (window);
else
gtk_widget_destroy (window);
gtk_image_set_from_image (GTK_IMAGE (gid->snap),
shot, NULL);
- g_object_unref (G_OBJECT (shot));
+ g_object_unref (shot);
gdk_window_end_paint (gid->src->window);
gdk_window_end_paint (gid->src->window);
target.x, target.y,
target.width, target.height);
- g_object_unref (G_OBJECT (gc));
+ g_object_unref (gc);
}
static gint
++x;
}
- g_object_unref (G_OBJECT (gc));
+ g_object_unref (gc);
return TRUE;
}
static void
-create_get_image (void)
+create_get_image (GtkWidget *widget)
{
static GtkWidget *window = NULL;
GtkWidget *sw;
GtkWidget *src;
GtkWidget *snap;
- GtkWidget *vbox;
GtkWidget *hbox;
+ GtkWidget *vbox;
GtkWidget *button;
struct GetImageData *gid;
gid = g_new (struct GetImageData, 1);
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+
+ gtk_window_set_screen (GTK_WINDOW (window),
+ gtk_widget_get_screen (widget));
- gtk_signal_connect (GTK_OBJECT (window),
- "destroy",
- GTK_SIGNAL_FUNC (gtk_widget_destroyed),
- &window);
+ g_signal_connect (window,
+ "destroy",
+ G_CALLBACK (gtk_widget_destroyed),
+ &window);
- gtk_object_set_data_full (GTK_OBJECT (window),
- "testgtk-get-image-data",
- gid,
- g_free);
+ g_object_set_data_full (G_OBJECT (window),
+ "testgtk-get-image-data",
+ gid,
+ g_free);
- vbox = gtk_vbox_new (FALSE, 0);
+ hbox = gtk_hbox_new (FALSE, 0);
- gtk_container_add (GTK_CONTAINER (window), vbox);
+ gtk_container_add (GTK_CONTAINER (window), hbox);
sw = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
gid->sw = sw;
- gtk_widget_set_usize (sw, 400, 400);
+ gtk_widget_set_size_request (sw, 400, 400);
src = gtk_drawing_area_new ();
- gtk_widget_set_usize (src, 10000, 10000);
+ gtk_widget_set_size_request (src, 10000, 10000);
- gtk_signal_connect (GTK_OBJECT (src),
- "expose_event",
- GTK_SIGNAL_FUNC (image_source_expose),
- gid);
+ g_signal_connect (src,
+ "expose_event",
+ G_CALLBACK (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);
+ gtk_box_pack_start (GTK_BOX (hbox),
+ sw, TRUE, TRUE, 0);
- hbox = gtk_hbox_new (FALSE, 3);
+ vbox = gtk_vbox_new (FALSE, 3);
- snap = gtk_widget_new (GTK_TYPE_IMAGE, NULL);
+ snap = g_object_new (GTK_TYPE_IMAGE, NULL);
gid->snap = snap;
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
- gtk_widget_set_usize (sw, 300, 300);
+ gtk_widget_set_size_request (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);
+ gtk_box_pack_end (GTK_BOX (vbox), 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);
+ g_signal_connect (button,
+ "clicked",
+ G_CALLBACK (take_snapshot),
+ gid);
- gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0);
+ gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
- gtk_box_pack_end (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
+ gtk_box_pack_end (GTK_BOX (hbox), vbox, FALSE, FALSE, 0);
gtk_widget_show_all (window);
}
button = gtk_toggle_button_new_with_label ("Sensitive");
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button),
- GTK_WIDGET_IS_SENSITIVE (widget));
+ gtk_widget_is_sensitive (widget));
- gtk_signal_connect (GTK_OBJECT (button),
- "toggled",
- GTK_SIGNAL_FUNC (sensitivity_toggled),
- widget);
+ g_signal_connect (button,
+ "toggled",
+ G_CALLBACK (sensitivity_toggled),
+ widget);
gtk_widget_show_all (button);
GList *children;
GList *tmp;
- children = gtk_container_children (GTK_CONTAINER (widget));
+ children = gtk_container_get_children (GTK_CONTAINER (widget));
tmp = children;
while (tmp)
{
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button),
FALSE);
- gtk_signal_connect (GTK_OBJECT (button),
- "toggled",
- GTK_SIGNAL_FUNC (selectable_toggled),
- widget);
+ g_signal_connect (button,
+ "toggled",
+ G_CALLBACK (selectable_toggled),
+ widget);
gtk_widget_show_all (button);
return button;
}
-void create_labels (void)
+static void
+dialog_response (GtkWidget *dialog, gint response_id, GtkLabel *label)
+{
+ const gchar *text;
+
+ gtk_widget_destroy (dialog);
+
+ text = "Some <a href=\"http://en.wikipedia.org/wiki/Text\" title=\"plain text\">text</a> may be marked up\n"
+ "as hyperlinks, which can be clicked\n"
+ "or activated via <a href=\"keynav\">keynav</a>.\n"
+ "The links remain the same.";
+ gtk_label_set_markup (label, text);
+}
+
+static gboolean
+activate_link (GtkWidget *label, const gchar *uri, gpointer data)
+{
+ if (g_strcmp0 (uri, "keynav") == 0)
+ {
+ GtkWidget *dialog;
+
+ dialog = gtk_message_dialog_new_with_markup (GTK_WINDOW (gtk_widget_get_toplevel (label)),
+ GTK_DIALOG_DESTROY_WITH_PARENT,
+ GTK_MESSAGE_INFO,
+ GTK_BUTTONS_OK,
+ "The term <i>keynav</i> is a shorthand for "
+ "keyboard navigation and refers to the process of using a program "
+ "(exclusively) via keyboard input.");
+
+ gtk_window_present (GTK_WINDOW (dialog));
+
+ g_signal_connect (dialog, "response", G_CALLBACK (dialog_response), label);
+
+ return TRUE;
+ }
+
+ return FALSE;
+}
+
+void create_labels (GtkWidget *widget)
{
static GtkWidget *window = NULL;
GtkWidget *hbox;
GtkWidget *frame;
GtkWidget *label;
GtkWidget *button;
-
+
if (!window)
{
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
- gtk_signal_connect (GTK_OBJECT (window), "destroy",
- GTK_SIGNAL_FUNC(gtk_widget_destroyed),
- &window);
+
+ gtk_window_set_screen (GTK_WINDOW (window),
+ gtk_widget_get_screen (widget));
+
+ g_signal_connect (window, "destroy",
+ G_CALLBACK (gtk_widget_destroyed),
+ &window);
gtk_window_set_title (GTK_WINDOW (window), "Label");
frame = gtk_frame_new ("Normal Label");
label = gtk_label_new ("This is a Normal label");
+ gtk_label_set_ellipsize (GTK_LABEL (label), PANGO_ELLIPSIZE_START);
gtk_container_add (GTK_CONTAINER (frame), label);
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
frame = gtk_frame_new ("Multi-line Label");
label = gtk_label_new ("This is a Multi-line label.\nSecond line\nThird line");
+ gtk_label_set_ellipsize (GTK_LABEL (label), PANGO_ELLIPSIZE_END);
gtk_container_add (GTK_CONTAINER (frame), label);
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
frame = gtk_frame_new ("Left Justified Label");
label = gtk_label_new ("This is a Left-Justified\nMulti-line label.\nThird line");
+ gtk_label_set_ellipsize (GTK_LABEL (label), PANGO_ELLIPSIZE_MIDDLE);
gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
gtk_container_add (GTK_CONTAINER (frame), label);
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
frame = gtk_frame_new ("Right Justified Label");
+ gtk_label_set_ellipsize (GTK_LABEL (label), PANGO_ELLIPSIZE_START);
label = gtk_label_new ("This is a Right-Justified\nMulti-line label.\nFourth line, (j/k)");
gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_RIGHT);
gtk_container_add (GTK_CONTAINER (frame), label);
frame = gtk_frame_new ("Internationalized Label");
label = gtk_label_new (NULL);
gtk_label_set_markup (GTK_LABEL (label),
- "French (Français) Bonjour, Salut\n"
- "Korean (한글) 안녕하세요, 안녕하십니까\n"
- "Russian (Русский) Здравствуйте!\n"
- "Chinese (Simplified) <span lang=\"zh-cn\">元气 开发</span>\n"
- "Chinese (Traditional) <span lang=\"zh-tw\">元氣 開發</span>\n"
- "Japanese <span lang=\"ja\">元気 開発</span>");
+ "French (Fran\303\247ais) Bonjour, Salut\n"
+ "Korean (\355\225\234\352\270\200) \354\225\210\353\205\225\355\225\230\354\204\270\354\232\224, \354\225\210\353\205\225\355\225\230\354\213\255\353\213\210\352\271\214\n"
+ "Russian (\320\240\321\203\321\201\321\201\320\272\320\270\320\271) \320\227\320\264\321\200\320\260\320\262\321\201\321\202\320\262\321\203\320\271\321\202\320\265!\n"
+ "Chinese (Simplified) <span lang=\"zh-cn\">\345\205\203\346\260\224 \345\274\200\345\217\221</span>\n"
+ "Chinese (Traditional) <span lang=\"zh-tw\">\345\205\203\346\260\243 \351\226\213\347\231\274</span>\n"
+ "Japanese <span lang=\"ja\">\345\205\203\346\260\227 \351\226\213\347\231\272</span>");
gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
gtk_container_add (GTK_CONTAINER (frame), label);
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
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);
+ label = gtk_label_new ("\342\200\217Arabic \330\247\331\204\330\263\331\204\330\247\331\205 \330\271\331\204\331\212\331\203\331\205\n"
+ "\342\200\217Hebrew \327\251\327\234\327\225\327\235");
+ gtk_container_add (GTK_CONTAINER (frame), label);
+ gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
+
+ frame = gtk_frame_new ("Links in a label");
+ label = gtk_label_new ("Some <a href=\"http://en.wikipedia.org/wiki/Text\" title=\"plain text\">text</a> may be marked up\n"
+ "as hyperlinks, which can be clicked\n"
+ "or activated via <a href=\"keynav\">keynav</a>");
+ gtk_label_set_use_markup (GTK_LABEL (label), TRUE);
gtk_container_add (GTK_CONTAINER (frame), label);
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
+ g_signal_connect (label, "activate-link", G_CALLBACK (activate_link), NULL);
vbox = gtk_vbox_new (FALSE, 5);
gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 0);
frame = gtk_frame_new ("Underlined label");
label = gtk_label_new ("This label is underlined!\n"
- "This one is underlined (こんにちは) in quite a funky fashion");
+ "This one is underlined (\343\201\223\343\202\223\343\201\253\343\201\241\343\201\257) 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);
"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);
+ 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_get_visible (window))
+ gtk_widget_show_all (window);
+ else
+ gtk_widget_destroy (window);
+}
+
+static void
+on_angle_scale_changed (GtkRange *range,
+ GtkLabel *label)
+{
+ gtk_label_set_angle (GTK_LABEL (label), gtk_range_get_value (range));
+}
+
+static void
+create_rotated_label (GtkWidget *widget)
+{
+ static GtkWidget *window = NULL;
+ GtkWidget *vbox;
+ GtkWidget *hscale;
+ GtkWidget *label;
+ GtkWidget *scale_label;
+ GtkWidget *scale_hbox;
+
+ if (!window)
+ {
+ window = gtk_dialog_new_with_buttons ("Rotated Label",
+ GTK_WINDOW (gtk_widget_get_toplevel (widget)), 0,
+ GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE,
+ NULL);
+
+ gtk_window_set_resizable (GTK_WINDOW (window), TRUE);
+
+ gtk_window_set_screen (GTK_WINDOW (window),
+ gtk_widget_get_screen (widget));
+
+ g_signal_connect (window, "response",
+ G_CALLBACK (gtk_object_destroy), NULL);
+ g_signal_connect (window, "destroy",
+ G_CALLBACK (gtk_widget_destroyed), &window);
+
+ vbox = gtk_vbox_new (FALSE, 5);
+ gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), vbox, TRUE, TRUE, 0);
+ gtk_container_set_border_width (GTK_CONTAINER (vbox), 10);
+
+ label = gtk_label_new (NULL);
+ gtk_label_set_markup (GTK_LABEL (label), "Hello World\n<i>Rotate</i> <span underline='single' foreground='blue'>me</span>");
+ gtk_box_pack_start (GTK_BOX (vbox), label, TRUE, TRUE, 0);
+
+ scale_hbox = gtk_hbox_new (FALSE, 0);
+ gtk_box_pack_start (GTK_BOX (vbox), scale_hbox, FALSE, FALSE, 0);
+
+ scale_label = gtk_label_new (NULL);
+ gtk_label_set_markup (GTK_LABEL (scale_label), "<i>Angle: </i>");
+ gtk_box_pack_start (GTK_BOX (scale_hbox), scale_label, FALSE, FALSE, 0);
+
+ hscale = gtk_hscale_new_with_range (0, 360, 5);
+ g_signal_connect (hscale, "value-changed",
+ G_CALLBACK (on_angle_scale_changed), label);
+
+ gtk_range_set_value (GTK_RANGE (hscale), 45);
+ gtk_widget_set_usize (hscale, 200, -1);
+ gtk_box_pack_start (GTK_BOX (scale_hbox), hscale, TRUE, TRUE, 0);
+ }
+
+ if (!gtk_widget_get_visible (window))
+ gtk_widget_show_all (window);
+ else
+ gtk_widget_destroy (window);
+}
+
+#define DEFAULT_TEXT_RADIUS 200
+
+static void
+on_rotated_text_unrealize (GtkWidget *widget)
+{
+ g_object_set_data (G_OBJECT (widget), "text-gc", NULL);
+}
+
+static gboolean
+on_rotated_text_expose (GtkWidget *widget,
+ GdkEventExpose *event,
+ GdkPixbuf *tile_pixbuf)
+{
+ static const gchar *words[] = { "The", "grand", "old", "Duke", "of", "York",
+ "had", "10,000", "men" };
+ PangoRenderer *renderer;
+ GdkGC *gc;
+ int n_words;
+ int i;
+ double radius;
+ PangoMatrix matrix = PANGO_MATRIX_INIT;
+ PangoLayout *layout;
+ PangoContext *context;
+ PangoFontDescription *desc;
+
+ gc = g_object_get_data (G_OBJECT (widget), "text-gc");
+ if (!gc)
+ {
+ static GdkColor black = { 0, 0, 0, 0 };
+
+ gc = gdk_gc_new (widget->window);
+ gdk_gc_set_rgb_fg_color (gc, &black);
+
+ if (tile_pixbuf)
+ {
+ GdkPixmap *tile;
+
+ gint width = gdk_pixbuf_get_width (tile_pixbuf);
+ gint height = gdk_pixbuf_get_height (tile_pixbuf);
+
+ tile = gdk_pixmap_new (widget->window, width, height, -1);
+ gdk_draw_pixbuf (tile, gc, tile_pixbuf,
+ 0, 0, 0, 0, width, height,
+ GDK_RGB_DITHER_NORMAL, 0, 0);
+
+ gdk_gc_set_tile (gc, tile);
+ gdk_gc_set_fill (gc, GDK_TILED);
+
+ g_object_unref (tile);
+ }
+
+ g_object_set_data_full (G_OBJECT (widget), "text-gc", gc, (GDestroyNotify)g_object_unref);
+ }
+
+ renderer = gdk_pango_renderer_get_default (gtk_widget_get_screen (widget));
+ gdk_pango_renderer_set_drawable (GDK_PANGO_RENDERER (renderer), widget->window);
+ gdk_pango_renderer_set_gc (GDK_PANGO_RENDERER (renderer), gc);
+
+ radius = MIN (widget->allocation.width, widget->allocation.height) / 2.;
+
+ pango_matrix_translate (&matrix,
+ radius + (widget->allocation.width - 2 * radius) / 2,
+ radius + (widget->allocation.height - 2 * radius) / 2);
+ pango_matrix_scale (&matrix, radius / DEFAULT_TEXT_RADIUS, radius / DEFAULT_TEXT_RADIUS);
+
+ context = gtk_widget_get_pango_context (widget);
+ layout = pango_layout_new (context);
+ desc = pango_font_description_from_string ("Sans Bold 30");
+ pango_layout_set_font_description (layout, desc);
+ pango_font_description_free (desc);
+
+ n_words = G_N_ELEMENTS (words);
+ for (i = 0; i < n_words; i++)
+ {
+ PangoMatrix rotated_matrix = matrix;
+ int width, height;
+
+ pango_matrix_rotate (&rotated_matrix, - (360. * i) / n_words);
+
+ pango_context_set_matrix (context, &rotated_matrix);
+ pango_layout_context_changed (layout);
+ pango_layout_set_text (layout, words[i], -1);
+
+ pango_layout_get_size (layout, &width, &height);
+
+ pango_renderer_draw_layout (renderer, layout,
+ - width / 2, - DEFAULT_TEXT_RADIUS * PANGO_SCALE);
+ }
+
+ gdk_pango_renderer_set_drawable (GDK_PANGO_RENDERER (renderer), NULL);
+ gdk_pango_renderer_set_gc (GDK_PANGO_RENDERER (renderer), NULL);
+
+ g_object_unref (layout);
+
+ return FALSE;
+}
+
+static void
+create_rotated_text (GtkWidget *widget)
+{
+ static GtkWidget *window = NULL;
+
+ if (!window)
+ {
+ const GdkColor white = { 0, 0xffff, 0xffff, 0xffff };
+ GtkRequisition requisition;
+ GtkWidget *drawing_area;
+ GdkPixbuf *tile_pixbuf;
+
+ window = gtk_dialog_new_with_buttons ("Rotated Text",
+ GTK_WINDOW (gtk_widget_get_toplevel (widget)), 0,
+ GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE,
+ NULL);
+
+ gtk_window_set_resizable (GTK_WINDOW (window), TRUE);
+
+ gtk_window_set_screen (GTK_WINDOW (window),
+ gtk_widget_get_screen (widget));
+
+ g_signal_connect (window, "response",
+ G_CALLBACK (gtk_object_destroy), NULL);
+ g_signal_connect (window, "destroy",
+ G_CALLBACK (gtk_widget_destroyed), &window);
+
+ drawing_area = gtk_drawing_area_new ();
+ gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), drawing_area, TRUE, TRUE, 0);
+ gtk_widget_modify_bg (drawing_area, GTK_STATE_NORMAL, &white);
+
+ tile_pixbuf = gdk_pixbuf_new_from_file ("marble.xpm", NULL);
- gtk_container_add (GTK_CONTAINER (frame), label);
- gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
+ g_signal_connect (drawing_area, "expose-event",
+ G_CALLBACK (on_rotated_text_expose), tile_pixbuf);
+ g_signal_connect (drawing_area, "unrealize",
+ G_CALLBACK (on_rotated_text_unrealize), NULL);
+
+ gtk_widget_show_all (GTK_BIN (window)->child);
+
+ gtk_widget_set_size_request (drawing_area, DEFAULT_TEXT_RADIUS * 2, DEFAULT_TEXT_RADIUS * 2);
+ gtk_widget_size_request (window, &requisition);
+ gtk_widget_set_size_request (drawing_area, -1, -1);
+ gtk_window_resize (GTK_WINDOW (window), requisition.width, requisition.height);
}
- if (!GTK_WIDGET_VISIBLE (window))
- gtk_widget_show_all (window);
+ if (!gtk_widget_get_visible (window))
+ gtk_widget_show (window);
else
gtk_widget_destroy (window);
}
{
GtkWidget *label;
- label = gtk_object_get_user_data (GTK_OBJECT (widget));
+ label = g_object_get_data (G_OBJECT (widget), "user_data");
gtk_widget_reparent (label, new_parent);
}
GtkWidget *old_parent,
gpointer func_data)
{
- g_print ("set_parent for \"%s\": new parent: \"%s\", old parent: \"%s\", data: %d\n",
- gtk_type_name (GTK_OBJECT_TYPE (child)),
- child->parent ? gtk_type_name (GTK_OBJECT_TYPE (child->parent)) : "NULL",
- old_parent ? gtk_type_name (GTK_OBJECT_TYPE (old_parent)) : "NULL",
- GPOINTER_TO_INT (func_data));
+ g_message ("set_parent for \"%s\": new parent: \"%s\", old parent: \"%s\", data: %d\n",
+ g_type_name (G_OBJECT_TYPE (child)),
+ child->parent ? g_type_name (G_OBJECT_TYPE (child->parent)) : "NULL",
+ old_parent ? g_type_name (G_OBJECT_TYPE (old_parent)) : "NULL",
+ GPOINTER_TO_INT (func_data));
}
static void
-create_reparent (void)
+create_reparent (GtkWidget *widget)
{
static GtkWidget *window = NULL;
GtkWidget *box1;
{
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
- gtk_signal_connect (GTK_OBJECT (window), "destroy",
- GTK_SIGNAL_FUNC(gtk_widget_destroyed),
- &window);
+ gtk_window_set_screen (GTK_WINDOW (window),
+ gtk_widget_get_screen (widget));
+
+ g_signal_connect (window, "destroy",
+ G_CALLBACK (gtk_widget_destroyed),
+ &window);
gtk_window_set_title (GTK_WINDOW (window), "reparent");
gtk_container_set_border_width (GTK_CONTAINER (window), 0);
gtk_container_add (GTK_CONTAINER (frame), box3);
button = gtk_button_new_with_label ("switch");
- gtk_object_set_user_data (GTK_OBJECT (button), label);
+ g_object_set_data (G_OBJECT (button), "user_data", label);
gtk_box_pack_start (GTK_BOX (box3), button, FALSE, TRUE, 0);
event_box = gtk_event_box_new ();
gtk_box_pack_start (GTK_BOX (box3), event_box, FALSE, TRUE, 0);
gtk_container_add (GTK_CONTAINER (event_box), label);
- gtk_signal_connect (GTK_OBJECT (button), "clicked",
- GTK_SIGNAL_FUNC(reparent_label),
- event_box);
+ g_signal_connect (button, "clicked",
+ G_CALLBACK (reparent_label),
+ event_box);
- gtk_signal_connect (GTK_OBJECT (label),
- "parent_set",
- GTK_SIGNAL_FUNC (set_parent_signal),
- GINT_TO_POINTER (42));
-
+ g_signal_connect (label, "parent_set",
+ G_CALLBACK (set_parent_signal),
+ GINT_TO_POINTER (42));
frame = gtk_frame_new ("Frame 2");
gtk_box_pack_start (GTK_BOX (box2), frame, TRUE, TRUE, 0);
gtk_container_add (GTK_CONTAINER (frame), box3);
button = gtk_button_new_with_label ("switch");
- gtk_object_set_user_data (GTK_OBJECT (button), label);
+ g_object_set_data (G_OBJECT (button), "user_data", label);
gtk_box_pack_start (GTK_BOX (box3), button, FALSE, TRUE, 0);
event_box = gtk_event_box_new ();
gtk_box_pack_start (GTK_BOX (box3), event_box, FALSE, TRUE, 0);
- gtk_signal_connect (GTK_OBJECT (button), "clicked",
- GTK_SIGNAL_FUNC(reparent_label),
- event_box);
+ g_signal_connect (button, "clicked",
+ G_CALLBACK (reparent_label),
+ event_box);
separator = gtk_hseparator_new ();
gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
button = gtk_button_new_with_label ("close");
- gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
- GTK_SIGNAL_FUNC(gtk_widget_destroy),
- GTK_OBJECT (window));
+ g_signal_connect_swapped (button, "clicked",
+ G_CALLBACK (gtk_widget_destroy), window);
gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
gtk_widget_grab_default (button);
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
+ gtk_widget_show_all (window);
+ else
+ gtk_widget_destroy (window);
+}
+
+/*
+ * Resize Grips
+ */
+static gboolean
+grippy_button_press (GtkWidget *area, GdkEventButton *event, GdkWindowEdge edge)
+{
+ if (event->type == GDK_BUTTON_PRESS)
+ {
+ if (event->button == 1)
+ gtk_window_begin_resize_drag (GTK_WINDOW (gtk_widget_get_toplevel (area)), edge,
+ event->button, event->x_root, event->y_root,
+ event->time);
+ else if (event->button == 2)
+ gtk_window_begin_move_drag (GTK_WINDOW (gtk_widget_get_toplevel (area)),
+ event->button, event->x_root, event->y_root,
+ event->time);
+ }
+ return TRUE;
+}
+
+static gboolean
+grippy_expose (GtkWidget *area, GdkEventExpose *event, GdkWindowEdge edge)
+{
+ gtk_paint_resize_grip (area->style,
+ area->window,
+ GTK_WIDGET_STATE (area),
+ &event->area,
+ area,
+ "statusbar",
+ edge,
+ 0, 0,
+ area->allocation.width,
+ area->allocation.height);
+
+ return TRUE;
+}
+
+static void
+create_resize_grips (GtkWidget *widget)
+{
+ static GtkWidget *window = NULL;
+ GtkWidget *area;
+ GtkWidget *hbox, *vbox;
+ if (!window)
+ {
+ window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+
+ gtk_window_set_screen (GTK_WINDOW (window),
+ gtk_widget_get_screen (widget));
+
+ gtk_window_set_title (GTK_WINDOW (window), "resize grips");
+
+ g_signal_connect (window, "destroy",
+ G_CALLBACK (gtk_widget_destroyed),
+ &window);
+
+ vbox = gtk_vbox_new (FALSE, 0);
+ gtk_container_add (GTK_CONTAINER (window), vbox);
+
+ hbox = gtk_hbox_new (FALSE, 0);
+ gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 0);
+
+ /* North west */
+ area = gtk_drawing_area_new ();
+ gtk_widget_add_events (area, GDK_BUTTON_PRESS_MASK);
+ gtk_box_pack_start (GTK_BOX (hbox), area, TRUE, TRUE, 0);
+ g_signal_connect (area, "expose_event", G_CALLBACK (grippy_expose),
+ GINT_TO_POINTER (GDK_WINDOW_EDGE_NORTH_WEST));
+ g_signal_connect (area, "button_press_event", G_CALLBACK (grippy_button_press),
+ GINT_TO_POINTER (GDK_WINDOW_EDGE_NORTH_WEST));
+
+ /* North */
+ area = gtk_drawing_area_new ();
+ gtk_widget_add_events (area, GDK_BUTTON_PRESS_MASK);
+ gtk_box_pack_start (GTK_BOX (hbox), area, TRUE, TRUE, 0);
+ g_signal_connect (area, "expose_event", G_CALLBACK (grippy_expose),
+ GINT_TO_POINTER (GDK_WINDOW_EDGE_NORTH));
+ g_signal_connect (area, "button_press_event", G_CALLBACK (grippy_button_press),
+ GINT_TO_POINTER (GDK_WINDOW_EDGE_NORTH));
+
+ /* North east */
+ area = gtk_drawing_area_new ();
+ gtk_widget_add_events (area, GDK_BUTTON_PRESS_MASK);
+ gtk_box_pack_start (GTK_BOX (hbox), area, TRUE, TRUE, 0);
+ g_signal_connect (area, "expose_event", G_CALLBACK (grippy_expose),
+ GINT_TO_POINTER (GDK_WINDOW_EDGE_NORTH_EAST));
+ g_signal_connect (area, "button_press_event", G_CALLBACK (grippy_button_press),
+ GINT_TO_POINTER (GDK_WINDOW_EDGE_NORTH_EAST));
+
+ hbox = gtk_hbox_new (FALSE, 0);
+ gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 0);
+
+ /* West */
+ area = gtk_drawing_area_new ();
+ gtk_widget_add_events (area, GDK_BUTTON_PRESS_MASK);
+ gtk_box_pack_start (GTK_BOX (hbox), area, TRUE, TRUE, 0);
+ g_signal_connect (area, "expose_event", G_CALLBACK (grippy_expose),
+ GINT_TO_POINTER (GDK_WINDOW_EDGE_WEST));
+ g_signal_connect (area, "button_press_event", G_CALLBACK (grippy_button_press),
+ GINT_TO_POINTER (GDK_WINDOW_EDGE_WEST));
+
+ /* Middle */
+ area = gtk_drawing_area_new ();
+ gtk_box_pack_start (GTK_BOX (hbox), area, TRUE, TRUE, 0);
+
+ /* East */
+ area = gtk_drawing_area_new ();
+ gtk_widget_add_events (area, GDK_BUTTON_PRESS_MASK);
+ gtk_box_pack_start (GTK_BOX (hbox), area, TRUE, TRUE, 0);
+ g_signal_connect (area, "expose_event", G_CALLBACK (grippy_expose),
+ GINT_TO_POINTER (GDK_WINDOW_EDGE_EAST));
+ g_signal_connect (area, "button_press_event", G_CALLBACK (grippy_button_press),
+ GINT_TO_POINTER (GDK_WINDOW_EDGE_EAST));
+
+
+ hbox = gtk_hbox_new (FALSE, 0);
+ gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 0);
+
+ /* South west */
+ area = gtk_drawing_area_new ();
+ gtk_widget_add_events (area, GDK_BUTTON_PRESS_MASK);
+ gtk_box_pack_start (GTK_BOX (hbox), area, TRUE, TRUE, 0);
+ g_signal_connect (area, "expose_event", G_CALLBACK (grippy_expose),
+ GINT_TO_POINTER (GDK_WINDOW_EDGE_SOUTH_WEST));
+ g_signal_connect (area, "button_press_event", G_CALLBACK (grippy_button_press),
+ GINT_TO_POINTER (GDK_WINDOW_EDGE_SOUTH_WEST));
+ /* South */
+ area = gtk_drawing_area_new ();
+ gtk_widget_add_events (area, GDK_BUTTON_PRESS_MASK);
+ gtk_box_pack_start (GTK_BOX (hbox), area, TRUE, TRUE, 0);
+ g_signal_connect (area, "expose_event", G_CALLBACK (grippy_expose),
+ GINT_TO_POINTER (GDK_WINDOW_EDGE_SOUTH));
+ g_signal_connect (area, "button_press_event", G_CALLBACK (grippy_button_press),
+ GINT_TO_POINTER (GDK_WINDOW_EDGE_SOUTH));
+
+ /* South east */
+ area = gtk_drawing_area_new ();
+ gtk_widget_add_events (area, GDK_BUTTON_PRESS_MASK);
+ gtk_box_pack_start (GTK_BOX (hbox), area, TRUE, TRUE, 0);
+ g_signal_connect (area, "expose_event", G_CALLBACK (grippy_expose),
+ GINT_TO_POINTER (GDK_WINDOW_EDGE_SOUTH_EAST));
+ g_signal_connect (area, "button_press_event", G_CALLBACK (grippy_button_press),
+ GINT_TO_POINTER (GDK_WINDOW_EDGE_SOUTH_EAST));
+ }
+
+ if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
GtkLabel *ly;
gchar buffer[64];
- lx = gtk_object_get_data (GTK_OBJECT (window), "x");
- ly = gtk_object_get_data (GTK_OBJECT (window), "y");
+ lx = g_object_get_data (G_OBJECT (window), "x");
+ ly = g_object_get_data (G_OBJECT (window), "y");
gdk_window_get_root_origin (window->window, &upositionx, &upositiony);
sprintf (buffer, "%d", upositionx);
GtkObject *window)
{
if (toggle->active)
- gtk_signal_handler_block_by_func (window, GTK_SIGNAL_FUNC (uposition_configure), NULL);
+ g_signal_handlers_block_by_func (window, G_CALLBACK (uposition_configure), NULL);
else
- gtk_signal_handler_unblock_by_func (window, GTK_SIGNAL_FUNC (uposition_configure), NULL);
+ g_signal_handlers_unblock_by_func (window, G_CALLBACK (uposition_configure), NULL);
}
static void
-create_saved_position (void)
+create_saved_position (GtkWidget *widget)
{
static GtkWidget *window = NULL;
GtkWidget *label;
GtkWidget *any;
- window = g_object_connect (gtk_widget_new (GTK_TYPE_WINDOW,
+ window = g_object_connect (g_object_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),
- &window);
+ gtk_window_move (GTK_WINDOW (window), upositionx, upositiony);
+
+ gtk_window_set_screen (GTK_WINDOW (window),
+ gtk_widget_get_screen (widget));
+
+
+ g_signal_connect (window, "destroy",
+ G_CALLBACK (gtk_widget_destroyed),
+ &window);
main_vbox = gtk_vbox_new (FALSE, 5);
gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 0);
gtk_container_add (GTK_CONTAINER (window), main_vbox);
vbox =
- gtk_widget_new (gtk_vbox_get_type (),
+ g_object_new (gtk_vbox_get_type (),
"GtkBox::homogeneous", FALSE,
"GtkBox::spacing", 5,
"GtkContainer::border_width", 10,
"GtkWidget::parent", main_vbox,
"GtkWidget::visible", TRUE,
- "child", g_object_connect (gtk_widget_new (GTK_TYPE_TOGGLE_BUTTON,
+ "child", g_object_connect (g_object_new (GTK_TYPE_TOGGLE_BUTTON,
"label", "Stop Events",
"active", FALSE,
"visible", TRUE,
x_label = gtk_label_new ("");
gtk_box_pack_start (GTK_BOX (hbox), x_label, TRUE, TRUE, 0);
- gtk_object_set_data (GTK_OBJECT (window), "x", x_label);
+ g_object_set_data (G_OBJECT (window), "x", x_label);
hbox = gtk_hbox_new (FALSE, 0);
gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
y_label = gtk_label_new ("");
gtk_box_pack_start (GTK_BOX (hbox), y_label, TRUE, TRUE, 0);
- gtk_object_set_data (GTK_OBJECT (window), "y", y_label);
+ g_object_set_data (G_OBJECT (window), "y", y_label);
any =
- gtk_widget_new (gtk_hseparator_get_type (),
+ g_object_new (gtk_hseparator_get_type (),
"GtkWidget::visible", TRUE,
NULL);
gtk_box_pack_start (GTK_BOX (main_vbox), any, FALSE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, TRUE, 0);
button = gtk_button_new_with_label ("Close");
- gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
- GTK_SIGNAL_FUNC (gtk_widget_destroy),
- GTK_OBJECT (window));
+ g_signal_connect_swapped (button, "clicked",
+ G_CALLBACK (gtk_widget_destroy),
+ window);
gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
gtk_widget_grab_default (button);
*/
static void
-create_pixmap (void)
+create_pixmap (GtkWidget *widget)
{
static GtkWidget *window = NULL;
GtkWidget *box1;
{
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
- gtk_signal_connect (GTK_OBJECT (window), "destroy",
- GTK_SIGNAL_FUNC(gtk_widget_destroyed),
- &window);
+ gtk_window_set_screen (GTK_WINDOW (window),
+ gtk_widget_get_screen (widget));
+
+ g_signal_connect (window, "destroy",
+ G_CALLBACK (gtk_widget_destroyed),
+ &window);
gtk_window_set_title (GTK_WINDOW (window), "GtkPixmap");
gtk_container_set_border_width (GTK_CONTAINER (window), 0);
gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
button = gtk_button_new_with_label ("close");
- gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
- GTK_SIGNAL_FUNC(gtk_widget_destroy),
- GTK_OBJECT (window));
+ g_signal_connect_swapped (button, "clicked",
+ G_CALLBACK (gtk_widget_destroy),
+ window);
gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
gtk_widget_grab_default (button);
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
{
gtk_label_set_text (GTK_LABEL (tips_query), tip_text ? "There is a Tip!" : "There is no Tip!");
/* don't let GtkTipsQuery reset its label */
- gtk_signal_emit_stop_by_name (GTK_OBJECT (tips_query), "widget_entered");
+ g_signal_stop_emission_by_name (tips_query, "widget_entered");
}
}
if (widget)
g_print ("Help \"%s\" requested for <%s>\n",
tip_private ? tip_private : "None",
- gtk_type_name (GTK_OBJECT_TYPE (widget)));
+ g_type_name (G_OBJECT_TYPE (widget)));
return TRUE;
}
static void
-create_tooltips (void)
+create_tooltips (GtkWidget *widget)
{
static GtkWidget *window = NULL;
GtkWidget *box1;
if (!window)
{
window =
- gtk_widget_new (gtk_window_get_type (),
+ g_object_new (gtk_window_get_type (),
"GtkWindow::type", GTK_WINDOW_TOPLEVEL,
"GtkContainer::border_width", 0,
"GtkWindow::title", "Tooltips",
"GtkWindow::allow_shrink", TRUE,
"GtkWindow::allow_grow", FALSE,
- "GtkWindow::auto_shrink", TRUE,
- "GtkWidget::width", 200,
NULL);
- gtk_signal_connect (GTK_OBJECT (window), "destroy",
- GTK_SIGNAL_FUNC (destroy_tooltips),
- &window);
+ gtk_window_set_screen (GTK_WINDOW (window),
+ gtk_widget_get_screen (widget));
+
+ g_signal_connect (window, "destroy",
+ G_CALLBACK (destroy_tooltips),
+ &window);
tooltips=gtk_tooltips_new();
g_object_ref (tooltips);
gtk_object_sink (GTK_OBJECT (tooltips));
- gtk_object_set_data (GTK_OBJECT (window), "tooltips", tooltips);
+ g_object_set_data (G_OBJECT (window), "tooltips", tooltips);
box1 = gtk_vbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER (window), box1);
button = gtk_toggle_button_new_with_label ("button1");
gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
- gtk_tooltips_set_tip (tooltips,button,"This is button 1", "ContextHelp/buttons/1");
+ gtk_tooltips_set_tip (tooltips,
+ button,
+ "This is button 1",
+ "ContextHelp/buttons/1");
button = gtk_toggle_button_new_with_label ("button2");
gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
toggle = gtk_toggle_button_new_with_label ("Override TipsQuery Label");
gtk_box_pack_start (GTK_BOX (box2), toggle, TRUE, TRUE, 0);
- gtk_tooltips_set_tip (tooltips, toggle, "Toggle TipsQuery view.", "Hi msw! ;)");
+ gtk_tooltips_set_tip (tooltips,
+ toggle,
+ "Toggle TipsQuery view.",
+ "Hi msw! ;)");
box3 =
- gtk_widget_new (gtk_vbox_get_type (),
+ g_object_new (gtk_vbox_get_type (),
"homogeneous", FALSE,
"spacing", 5,
"border_width", 5,
tips_query = gtk_tips_query_new ();
button =
- gtk_widget_new (gtk_button_get_type (),
+ g_object_new (gtk_button_get_type (),
"label", "[?]",
"visible", TRUE,
"parent", box3,
NULL);
- g_object_connect (G_OBJECT (button),
+ g_object_connect (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);
"caller", button,
NULL);
- frame = gtk_widget_new (gtk_frame_get_type (),
+ frame = g_object_new (gtk_frame_get_type (),
"label", "ToolTips Inspector",
"label_xalign", (double) 0.5,
"border_width", 0,
gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
button = gtk_button_new_with_label ("close");
- gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
- GTK_SIGNAL_FUNC(gtk_widget_destroy),
- GTK_OBJECT (window));
+ g_signal_connect_swapped (button, "clicked",
+ G_CALLBACK (gtk_widget_destroy),
+ window);
gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
gtk_widget_grab_default (button);
gtk_tooltips_set_tip (tooltips, button, "Push this button to close window", "ContextHelp/buttons/Close");
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
}
static void
-create_image (void)
+create_image (GtkWidget *widget)
{
static GtkWidget *window = NULL;
-
+
if (window == NULL)
{
GtkWidget *vbox;
GdkBitmap *mask;
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+
+ gtk_window_set_screen (GTK_WINDOW (window),
+ gtk_widget_get_screen (widget));
+
/* 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);
+ g_object_set (window, "allow_shrink", TRUE, "allow_grow", TRUE, NULL);
- gtk_signal_connect (GTK_OBJECT (window), "destroy",
- GTK_SIGNAL_FUNC(gtk_widget_destroyed),
- &window);
+ g_signal_connect (window, "destroy",
+ G_CALLBACK (gtk_widget_destroyed),
+ &window);
vbox = gtk_vbox_new (FALSE, 5);
gtk_image_new_from_pixmap (pixmap, mask));
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
*/
static GtkWidget*
-create_menu (gint depth, gint length, gboolean tearoff)
+create_menu (GdkScreen *screen, gint depth, gint length, gboolean tearoff)
{
GtkWidget *menu;
GtkWidget *menuitem;
return NULL;
menu = gtk_menu_new ();
+ gtk_menu_set_screen (GTK_MENU (menu), screen);
+
group = NULL;
if (tearoff)
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));
+ group = gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (menuitem));
+#if 0
if (depth % 2)
gtk_check_menu_item_set_show_toggle (GTK_CHECK_MENU_ITEM (menuitem), TRUE);
+#endif
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
gtk_widget_show (menuitem);
TRUE);
if (i < 5)
- gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), create_menu (depth - 1, 5, TRUE));
+ gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem),
+ create_menu (screen, depth - 1, 5, TRUE));
+ }
+
+ return menu;
+}
+
+static GtkWidget*
+create_table_menu (GdkScreen *screen, gint cols, gint rows, gboolean tearoff)
+{
+ GtkWidget *menu;
+ GtkWidget *menuitem;
+ GtkWidget *submenu;
+ GtkWidget *image;
+ char buf[32];
+ int i, j;
+
+ menu = gtk_menu_new ();
+ gtk_menu_set_screen (GTK_MENU (menu), screen);
+
+ j = 0;
+ if (tearoff)
+ {
+ menuitem = gtk_tearoff_menu_item_new ();
+ gtk_menu_attach (GTK_MENU (menu), menuitem, 0, cols, j, j + 1);
+ gtk_widget_show (menuitem);
+ j++;
}
+
+ menuitem = gtk_menu_item_new_with_label ("items");
+ gtk_menu_attach (GTK_MENU (menu), menuitem, 0, cols, j, j + 1);
+
+ submenu = gtk_menu_new ();
+ gtk_menu_set_screen (GTK_MENU (submenu), screen);
+ gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), submenu);
+ gtk_widget_show (menuitem);
+ j++;
+
+ /* now fill the items submenu */
+ 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 ("Image");
+ gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menuitem), image);
+ gtk_menu_attach (GTK_MENU (submenu), menuitem, 0, 1, 0, 1);
+ gtk_widget_show (menuitem);
+
+ menuitem = gtk_menu_item_new_with_label ("x");
+ gtk_menu_attach (GTK_MENU (submenu), menuitem, 1, 2, 0, 1);
+ gtk_widget_show (menuitem);
+
+ menuitem = gtk_menu_item_new_with_label ("x");
+ gtk_menu_attach (GTK_MENU (submenu), menuitem, 0, 1, 1, 2);
+ gtk_widget_show (menuitem);
+
+ image = gtk_image_new_from_stock (GTK_STOCK_HELP,
+ GTK_ICON_SIZE_MENU);
+ gtk_widget_show (image);
+ menuitem = gtk_image_menu_item_new_with_label ("Image");
+ gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menuitem), image);
+ gtk_menu_attach (GTK_MENU (submenu), menuitem, 1, 2, 1, 2);
+ gtk_widget_show (menuitem);
+
+ menuitem = gtk_radio_menu_item_new_with_label (NULL, "Radio");
+ gtk_menu_attach (GTK_MENU (submenu), menuitem, 0, 1, 2, 3);
+ gtk_widget_show (menuitem);
+
+ menuitem = gtk_menu_item_new_with_label ("x");
+ gtk_menu_attach (GTK_MENU (submenu), menuitem, 1, 2, 2, 3);
+ gtk_widget_show (menuitem);
+
+ menuitem = gtk_menu_item_new_with_label ("x");
+ gtk_menu_attach (GTK_MENU (submenu), menuitem, 0, 1, 3, 4);
+ gtk_widget_show (menuitem);
+
+ menuitem = gtk_radio_menu_item_new_with_label (NULL, "Radio");
+ gtk_menu_attach (GTK_MENU (submenu), menuitem, 1, 2, 3, 4);
+ gtk_widget_show (menuitem);
+
+ menuitem = gtk_check_menu_item_new_with_label ("Check");
+ gtk_menu_attach (GTK_MENU (submenu), menuitem, 0, 1, 4, 5);
+ gtk_widget_show (menuitem);
+ menuitem = gtk_menu_item_new_with_label ("x");
+ gtk_menu_attach (GTK_MENU (submenu), menuitem, 1, 2, 4, 5);
+ gtk_widget_show (menuitem);
+
+ menuitem = gtk_menu_item_new_with_label ("x");
+ gtk_menu_attach (GTK_MENU (submenu), menuitem, 0, 1, 5, 6);
+ gtk_widget_show (menuitem);
+
+ menuitem = gtk_check_menu_item_new_with_label ("Check");
+ gtk_menu_attach (GTK_MENU (submenu), menuitem, 1, 2, 5, 6);
+ gtk_widget_show (menuitem);
+
+ menuitem = gtk_menu_item_new_with_label ("1. Inserted normally (8)");
+ gtk_widget_show (menuitem);
+ gtk_menu_shell_insert (GTK_MENU_SHELL (submenu), menuitem, 8);
+
+ menuitem = gtk_menu_item_new_with_label ("2. Inserted normally (2)");
+ gtk_widget_show (menuitem);
+ gtk_menu_shell_insert (GTK_MENU_SHELL (submenu), menuitem, 2);
+
+ menuitem = gtk_menu_item_new_with_label ("3. Inserted normally (0)");
+ gtk_widget_show (menuitem);
+ gtk_menu_shell_insert (GTK_MENU_SHELL (submenu), menuitem, 0);
+
+ menuitem = gtk_menu_item_new_with_label ("4. Inserted normally (-1)");
+ gtk_widget_show (menuitem);
+ gtk_menu_shell_insert (GTK_MENU_SHELL (submenu), menuitem, -1);
+
+ /* end of items submenu */
+
+ menuitem = gtk_menu_item_new_with_label ("spanning");
+ gtk_menu_attach (GTK_MENU (menu), menuitem, 0, cols, j, j + 1);
+
+ submenu = gtk_menu_new ();
+ gtk_menu_set_screen (GTK_MENU (submenu), screen);
+ gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), submenu);
+ gtk_widget_show (menuitem);
+ j++;
+
+ /* now fill the spanning submenu */
+ menuitem = gtk_menu_item_new_with_label ("a");
+ gtk_menu_attach (GTK_MENU (submenu), menuitem, 0, 2, 0, 1);
+ gtk_widget_show (menuitem);
+
+ menuitem = gtk_menu_item_new_with_label ("b");
+ gtk_menu_attach (GTK_MENU (submenu), menuitem, 2, 3, 0, 2);
+ gtk_widget_show (menuitem);
+
+ menuitem = gtk_menu_item_new_with_label ("c");
+ gtk_menu_attach (GTK_MENU (submenu), menuitem, 0, 1, 1, 3);
+ gtk_widget_show (menuitem);
+
+ menuitem = gtk_menu_item_new_with_label ("d");
+ gtk_menu_attach (GTK_MENU (submenu), menuitem, 1, 2, 1, 2);
+ gtk_widget_show (menuitem);
+
+ menuitem = gtk_menu_item_new_with_label ("e");
+ gtk_menu_attach (GTK_MENU (submenu), menuitem, 1, 3, 2, 3);
+ gtk_widget_show (menuitem);
+ /* end of spanning submenu */
+
+ menuitem = gtk_menu_item_new_with_label ("left");
+ gtk_menu_attach (GTK_MENU (menu), menuitem, 0, 1, j, j + 1);
+ submenu = gtk_menu_new ();
+ gtk_menu_set_screen (GTK_MENU (submenu), screen);
+ gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), submenu);
+ gtk_widget_show (menuitem);
+
+ menuitem = gtk_menu_item_new_with_label ("Empty");
+ gtk_menu_attach (GTK_MENU (submenu), menuitem, 0, 1, 0, 1);
+ submenu = gtk_menu_new ();
+ gtk_menu_set_screen (GTK_MENU (submenu), screen);
+ gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), submenu);
+ gtk_widget_show (menuitem);
+
+ menuitem = gtk_menu_item_new_with_label ("right");
+ gtk_menu_attach (GTK_MENU (menu), menuitem, 1, 2, j, j + 1);
+ submenu = gtk_menu_new ();
+ gtk_menu_set_screen (GTK_MENU (submenu), screen);
+ gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), submenu);
+ gtk_widget_show (menuitem);
+
+ menuitem = gtk_menu_item_new_with_label ("Empty");
+ gtk_menu_attach (GTK_MENU (submenu), menuitem, 0, 1, 0, 1);
+ gtk_widget_show (menuitem);
+
+ j++;
+
+ for (; j < rows; j++)
+ for (i = 0; i < cols; i++)
+ {
+ sprintf (buf, "(%d %d)", i, j);
+ menuitem = gtk_menu_item_new_with_label (buf);
+ gtk_menu_attach (GTK_MENU (menu), menuitem, i, i + 1, j, j + 1);
+ gtk_widget_show (menuitem);
+ }
+
+ menuitem = gtk_menu_item_new_with_label ("1. Inserted normally (8)");
+ gtk_menu_shell_insert (GTK_MENU_SHELL (menu), menuitem, 8);
+ gtk_widget_show (menuitem);
+ menuitem = gtk_menu_item_new_with_label ("2. Inserted normally (2)");
+ gtk_menu_shell_insert (GTK_MENU_SHELL (menu), menuitem, 2);
+ gtk_widget_show (menuitem);
+ menuitem = gtk_menu_item_new_with_label ("3. Inserted normally (0)");
+ gtk_menu_shell_insert (GTK_MENU_SHELL (menu), menuitem, 0);
+ gtk_widget_show (menuitem);
+ menuitem = gtk_menu_item_new_with_label ("4. Inserted normally (-1)");
+ gtk_menu_shell_insert (GTK_MENU_SHELL (menu), menuitem, -1);
+ gtk_widget_show (menuitem);
+
return menu;
}
static void
-create_menus (void)
+create_menus (GtkWidget *widget)
{
static GtkWidget *window = NULL;
GtkWidget *box1;
GtkWidget *menuitem;
GtkAccelGroup *accel_group;
GtkWidget *image;
+ GdkScreen *screen = gtk_widget_get_screen (widget);
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+
+ gtk_window_set_screen (GTK_WINDOW (window), screen);
- gtk_signal_connect (GTK_OBJECT (window), "destroy",
- GTK_SIGNAL_FUNC(gtk_widget_destroyed),
- &window);
- gtk_signal_connect (GTK_OBJECT (window), "delete-event",
- GTK_SIGNAL_FUNC (gtk_true),
- NULL);
+ g_signal_connect (window, "destroy",
+ G_CALLBACK (gtk_widget_destroyed),
+ &window);
+ g_signal_connect (window, "delete-event",
+ G_CALLBACK (gtk_true),
+ NULL);
accel_group = gtk_accel_group_new ();
gtk_window_add_accel_group (GTK_WINDOW (window), accel_group);
gtk_box_pack_start (GTK_BOX (box1), menubar, FALSE, TRUE, 0);
gtk_widget_show (menubar);
- menu = create_menu (2, 50, TRUE);
+ menu = create_menu (screen, 2, 50, TRUE);
menuitem = gtk_menu_item_new_with_label ("test\nline2");
gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), menu);
- gtk_menu_bar_append (GTK_MENU_BAR (menubar), menuitem);
+ gtk_menu_shell_append (GTK_MENU_SHELL (menubar), menuitem);
+ gtk_widget_show (menuitem);
+
+ menu = create_table_menu (screen, 2, 50, TRUE);
+
+ menuitem = gtk_menu_item_new_with_label ("table");
+ gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), menu);
+ gtk_menu_shell_append (GTK_MENU_SHELL (menubar), menuitem);
gtk_widget_show (menuitem);
menuitem = gtk_menu_item_new_with_label ("foo");
- gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), create_menu (3, 5, TRUE));
- gtk_menu_bar_append (GTK_MENU_BAR (menubar), menuitem);
+ gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), create_menu (screen, 3, 5, TRUE));
+ gtk_menu_shell_append (GTK_MENU_SHELL (menubar), menuitem);
gtk_widget_show (menuitem);
image = gtk_image_new_from_stock (GTK_STOCK_HELP,
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_set_submenu (GTK_MENU_ITEM (menuitem), create_menu (screen, 4, 5, TRUE));
gtk_menu_item_set_right_justified (GTK_MENU_ITEM (menuitem), TRUE);
- gtk_menu_bar_append (GTK_MENU_BAR (menubar), menuitem);
+ gtk_menu_shell_append (GTK_MENU_SHELL (menubar), menuitem);
gtk_widget_show (menuitem);
menubar = gtk_menu_bar_new ();
gtk_box_pack_start (GTK_BOX (box1), menubar, FALSE, TRUE, 0);
gtk_widget_show (menubar);
- menu = create_menu (2, 10, TRUE);
+ menu = create_menu (screen, 2, 10, TRUE);
menuitem = gtk_menu_item_new_with_label ("Second menu bar");
gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), menu);
- gtk_menu_bar_append (GTK_MENU_BAR (menubar), menuitem);
+ gtk_menu_shell_append (GTK_MENU_SHELL (menubar), menuitem);
gtk_widget_show (menuitem);
box2 = gtk_vbox_new (FALSE, 10);
gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
gtk_widget_show (box2);
- menu = create_menu (1, 5, FALSE);
+ menu = create_menu (screen, 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_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));
+ g_signal_connect_swapped (button, "clicked",
+ G_CALLBACK (gtk_widget_destroy),
+ 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))
+ if (!gtk_widget_get_visible (window))
gtk_widget_show (window);
else
gtk_widget_destroy (window);
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
-};
+/* GdkPixbuf RGBA C-Source image dump */
+
+static const guint8 apple[] =
+{ ""
+ /* Pixbuf magic (0x47646b50) */
+ "GdkP"
+ /* length: header (24) + pixel_data (2304) */
+ "\0\0\11\30"
+ /* pixdata_type (0x1010002) */
+ "\1\1\0\2"
+ /* rowstride (96) */
+ "\0\0\0`"
+ /* width (24) */
+ "\0\0\0\30"
+ /* height (24) */
+ "\0\0\0\30"
+ /* pixel_data: */
+ "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
+ "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
+ "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
+ "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
+ "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
+ "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
+ "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\26\24"
+ "\17\11\0\0\0\2\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
+ "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`m"
+ "[pn{a\344hv_\345_k[`\0\0\0\0\0\0\0\0\0\0\0\0D>/\305\0\0\0_\0\0\0\0\0"
+ "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
+ "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`l[Blza\373s\202d\354w\206g\372p~c"
+ "\374`l[y\0\0\0\0[S\77/\27\25\17\335\0\0\0\20\0\0\0\0\0\0\0\0\0\0\0\0"
+ "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
+ "\0\0\0\0\0\0`l\\\20iw_\356y\211h\373x\207g\364~\216i\364u\204e\366gt"
+ "_\374^jX\241A;-_\0\0\0~\0\0\0\0SM4)SM21B9&\22\320\270\204\1\320\270\204"
+ "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0eq"
+ "]\212r\200c\366v\205f\371jx_\323_kY\232_kZH^jY\26]iW\211@G9\272:6%j\220"
+ "\211]\320\221\211`\377\212\203Z\377~xP\377mkE\331]^;|/0\37\21\0\0\0\0"
+ "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0ly`\40p~b\360lz`\353^kY\246["
+ "eT<\216\200Z\203\227\211_\354\234\217c\377\232\217b\362\232\220c\337"
+ "\243\233k\377\252\241p\377\250\236p\377\241\225h\377\231\214_\377\210"
+ "\202U\377srI\377[]:\355KO0U\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0i"
+ "v^\200`lY\211^jY\"\0\0\0\0\221\204\\\273\250\233r\377\302\267\224\377"
+ "\311\300\237\377\272\256\204\377\271\256\177\377\271\257\200\377\267"
+ "\260\177\377\260\251x\377\250\236l\377\242\225e\377\226\213]\377~zP\377"
+ "ff@\377QT5\377LR2d\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0]iW(\0\0\0\0\0\0\0"
+ "\0\213\203[v\253\240t\377\334\326\301\377\344\340\317\377\321\312\253"
+ "\377\303\271\217\377\300\270\213\377\277\267\210\377\272\264\203\377"
+ "\261\255z\377\250\242n\377\243\232h\377\232\220`\377\210\202V\377nnE"
+ "\377SW6\377RX6\364Za<\34\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0b]@\20"
+ "\234\222e\362\304\274\232\377\337\333\306\377\332\325\273\377\311\302"
+ "\232\377\312\303\236\377\301\273\216\377\300\271\212\377\270\264\200"
+ "\377\256\253v\377\246\243n\377\236\232h\377\230\220`\377\213\203V\377"
+ "wvL\377X]:\377KR0\377NU5v\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\212"
+ "\203Zl\242\234l\377\321\315\260\377\331\324\271\377\320\313\251\377\307"
+ "\301\232\377\303\276\224\377\300\272\214\377\274\267\206\377\264\260"
+ "|\377\253\251s\377\244\243n\377\232\230e\377\223\216^\377\207\200U\377"
+ "ttJ\377[_<\377HO/\377GN0\200\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
+ "\210\204Y\240\245\237o\377\316\310\253\377\310\303\237\377\304\300\230"
+ "\377\303\277\225\377\277\272\216\377\274\270\210\377\266\263\200\377"
+ "\256\254v\377\247\246p\377\237\236j\377\227\226d\377\215\212[\377\203"
+ "\177T\377qsH\377X]8\377FN.\377DK-\200\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
+ "\0\0\0\0\207\204X\257\244\240o\377\300\275\231\377\301\275\226\377\274"
+ "\270\213\377\274\270\214\377\267\264\205\377\264\262\200\377\260\256"
+ "z\377\251\251s\377\243\244n\377\231\232g\377\220\222`\377\210\211Y\377"
+ "|}Q\377hlC\377PU3\377CK,\377DL/Y\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
+ "\0\0\205\204X\220\232\230h\377\261\260\204\377\266\264\212\377\261\260"
+ "\201\377\263\260\200\377\260\257}\377\256\256x\377\253\254t\377\244\246"
+ "o\377\233\236i\377\221\224b\377\211\214\\\377\202\204V\377txM\377]b>"
+ "\377HP0\377@H+\373CJ-\25\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0xxO>"
+ "\215\215_\377\237\237r\377\247\247x\377\247\247t\377\252\252w\377\252"
+ "\252u\377\252\253t\377\243\246o\377\235\240j\377\223\230c\377\213\217"
+ "]\377\201\206V\377x}P\377gkD\377RY5\377BI,\377AI,\262\0\0\0\0\0\0\0\0"
+ "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\202\205W\312\216\220`\377\230"
+ "\232g\377\234\236i\377\236\241l\377\241\244n\377\240\244m\377\232\237"
+ "i\377\223\230c\377\212\221]\377\200\210W\377v|P\377jnG\377Za>\377HP2"
+ "\377=D)\377HQ1:\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
+ "\0wzQ6\177\201U\371\206\211Z\377\216\222`\377\220\225a\377\220\225b\377"
+ "\220\226a\377\213\221_\377\204\213Z\377{\203R\377ryN\377iqH\377^fA\377"
+ "R[;\377BJ-\3778@'\317\0\0\0>\0\0\0\36\0\0\0\7\0\0\0\0\0\0\0\0\0\0\0\0"
+ "\0\0\0\0\0\0\0\0\0\0\0\0ptJTw|Q\371z\177R\377}\202T\377|\203T\377z\200"
+ "R\377v|O\377pwL\377jpF\377dlB\377`hB\377Yb@\377LT6\377<C*\377\11\12\6"
+ "\376\0\0\0\347\0\0\0\262\0\0\0Y\0\0\0\32\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
+ "\0\0\0\0\0\0\0\0\0\0\\`=UgnE\370hnG\377gmE\377djB\377]d>\377[c<\377Y"
+ "b<\377Zc>\377V_>\377OW8\377BK/\377\16\20\12\377\0\0\0\377\0\0\0\377\0"
+ "\0\0\374\0\0\0\320\0\0\0I\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
+ "\0\1\0\0\0\40\22\24\15\260@D+\377W`;\377OV5\377.3\36\377.3\37\377IP0"
+ "\377RZ7\377PZ8\3776=&\377\14\15\10\377\0\0\0\377\0\0\0\377\0\0\0\377"
+ "\0\0\0\347\0\0\0\217\0\0\0""4\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
+ "\0\0\0\0\0\0\0\20\0\0\0P\0\0\0\252\7\10\5\346\7\7\5\375\0\0\0\377\0\0"
+ "\0\377\0\0\0\377\0\0\0\377\0\0\0\377\0\0\0\377\0\0\0\377\0\0\0\374\0"
+ "\0\0\336\0\0\0\254\0\0\0i\0\0\0""2\0\0\0\10\0\0\0\0\0\0\0\0\0\0\0\0\0"
+ "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\11\0\0\0\40\0\0\0D\0\0\0m\0\0\0"
+ "\226\0\0\0\234\0\0\0\234\0\0\0\244\0\0\0\246\0\0\0\232\0\0\0\202\0\0"
+ "\0i\0\0\0T\0\0\0,\0\0\0\15\0\0\0\2\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
+ "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\2\0\0\0\6\0\0\0"
+ "\16\0\0\0\22\0\0\0\24\0\0\0\23\0\0\0\17\0\0\0\14\0\0\0\13\0\0\0\10\0"
+ "\0\0\5\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"};
static void
static GtkItemFactoryEntry menu_items[] =
{
- { "/_File", NULL, 0, 0, "<Branch>" },
+ { "/_File", NULL, NULL, 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 },
{ "/_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>", apple },
+ { "/_Preferences/Coffee", NULL, gtk_ifactory_cb, 0, "<CheckItem>" },
+ { "/_Preferences/Toast", NULL, gtk_ifactory_cb, 0, "<CheckItem>" },
+ { "/_Preferences/Marshmallow Froot Loops", NULL, gtk_ifactory_cb, 0, "<CheckItem>" },
/* For testing deletion of menus */
{ "/_Preferences/Should_NotAppear", NULL, 0, 0, "<Branch>" },
static int nmenu_items = sizeof (menu_items) / sizeof (menu_items[0]);
static void
-create_item_factory (void)
+create_item_factory (GtkWidget *widget)
{
static GtkWidget *window = NULL;
GtkWidget *button;
GtkAccelGroup *accel_group;
GtkItemFactory *item_factory;
+ GtkTooltips *tooltips;
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
- gtk_signal_connect (GTK_OBJECT (window), "destroy",
- GTK_SIGNAL_FUNC(gtk_widget_destroyed),
- &window);
- gtk_signal_connect (GTK_OBJECT (window), "delete-event",
- GTK_SIGNAL_FUNC (gtk_true),
- NULL);
+ gtk_window_set_screen (GTK_WINDOW (window),
+ gtk_widget_get_screen (widget));
+
+ g_signal_connect (window, "destroy",
+ G_CALLBACK(gtk_widget_destroyed),
+ &window);
+ g_signal_connect (window, "delete-event",
+ G_CALLBACK (gtk_true),
+ NULL);
accel_group = gtk_accel_group_new ();
item_factory = gtk_item_factory_new (GTK_TYPE_MENU_BAR, "<main>", accel_group);
- gtk_object_set_data_full (GTK_OBJECT (window),
- "<main>",
- item_factory,
- (GtkDestroyNotify) gtk_object_unref);
+ g_object_set_data_full (G_OBJECT (window),
+ "<main>",
+ item_factory,
+ g_object_unref);
gtk_window_add_accel_group (GTK_WINDOW (window), accel_group);
gtk_window_set_title (GTK_WINDOW (window), "Item Factory");
gtk_container_set_border_width (GTK_CONTAINER (window), 0);
"/Preferences/Shape/Oval")),
TRUE);
+ /* preselect /Preferences/Coffee
+ */
+ gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (gtk_item_factory_get_item (item_factory,
+ "/Preferences/Coffee")),
+ TRUE);
+
+ /* preselect /Preferences/Marshmallow Froot Loops and set it insensitive
+ */
+ gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (gtk_item_factory_get_item (item_factory,
+ "/Preferences/Marshmallow Froot Loops")),
+ TRUE);
+ gtk_widget_set_sensitive (GTK_WIDGET (gtk_item_factory_get_item (item_factory,
+ "/Preferences/Marshmallow Froot Loops")),
+ FALSE);
+
+ /* Test how tooltips (ugh) work on menu items
+ */
+ tooltips = gtk_tooltips_new ();
+ g_object_ref (tooltips);
+ gtk_object_sink (GTK_OBJECT (tooltips));
+ g_object_set_data_full (G_OBJECT (window), "testgtk-tooltips",
+ tooltips, (GDestroyNotify)g_object_unref);
+
+ gtk_tooltips_set_tip (tooltips, gtk_item_factory_get_item (item_factory, "/File/New"),
+ "Create a new file", NULL);
+ gtk_tooltips_set_tip (tooltips, gtk_item_factory_get_item (item_factory, "/File/Open"),
+ "Open a file", NULL);
+ gtk_tooltips_set_tip (tooltips, gtk_item_factory_get_item (item_factory, "/File/Save"),
+ "Safe file", NULL);
+ gtk_tooltips_set_tip (tooltips, gtk_item_factory_get_item (item_factory, "/Preferences/Color"),
+ "Modify color", NULL);
+
box1 = gtk_vbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER (window), box1);
FALSE, FALSE, 0);
label = gtk_label_new ("Type\n<alt>\nto start");
- gtk_widget_set_usize (label, 200, 200);
+ gtk_widget_set_size_request (label, 200, 200);
gtk_misc_set_alignment (GTK_MISC (label), 0.5, 0.5);
gtk_box_pack_start (GTK_BOX (box1), label, TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
button = gtk_button_new_with_label ("close");
- gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
- GTK_SIGNAL_FUNC(gtk_widget_destroy),
- GTK_OBJECT (window));
+ g_signal_connect_swapped (button, "clicked",
+ G_CALLBACK (gtk_widget_destroy),
+ 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);
}
static void
-create_key_lookup (void)
+create_key_lookup (GtkWidget *widget)
{
static GtkWidget *window = NULL;
-
+ gpointer window_ptr;
+
if (!window)
{
GtkAccelGroup *accel_group = gtk_accel_group_new ();
GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE,
NULL);
+ gtk_window_set_screen (GTK_WINDOW (window),
+ gtk_widget_get_screen (widget));
+
/* We have to expand it so the accel labels will draw their labels
*/
gtk_window_set_default_size (GTK_WINDOW (window), 300, -1);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), button, FALSE, FALSE, 0);
button = gtk_button_new_with_mnemonic ("Button 2 (_A)");
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), button, FALSE, FALSE, 0);
- button = gtk_button_new_with_mnemonic ("Button 3 (_ф)");
+ button = gtk_button_new_with_mnemonic ("Button 3 (_\321\204)");
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), button, FALSE, FALSE, 0);
- button = gtk_button_new_with_mnemonic ("Button 4 (_Ф)");
+ button = gtk_button_new_with_mnemonic ("Button 4 (_\320\244)");
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), button, FALSE, FALSE, 0);
button = gtk_button_new_with_mnemonic ("Button 6 (_b)");
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), button, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), button, FALSE, FALSE, 0);
button = gtk_button_new_with_mnemonic ("Button 11 (_!)");
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), button, FALSE, FALSE, 0);
-
- g_object_add_weak_pointer (G_OBJECT (window), (gpointer *)&window);
+ button = accel_button_new (accel_group, "Button 12", "<Super>a");
+ gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), button, FALSE, FALSE, 0);
+ button = accel_button_new (accel_group, "Button 13", "<Hyper>a");
+ gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), button, FALSE, FALSE, 0);
+ button = accel_button_new (accel_group, "Button 14", "<Meta>a");
+ gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), button, FALSE, FALSE, 0);
+ button = accel_button_new (accel_group, "Button 15", "<Shift><Mod4>b");
+ gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), button, FALSE, FALSE, 0);
+
+ window_ptr = &window;
+ g_object_add_weak_pointer (G_OBJECT (window), window_ptr);
g_signal_connect (window, "response", G_CALLBACK (gtk_object_destroy), NULL);
gtk_widget_show_all (window);
{
GtkWidget *csd;
- csd=gtk_color_selection_dialog_new ("This is a modal color selection dialog");
+ csd = gtk_color_selection_dialog_new ("This is a modal color selection dialog");
+
+ gtk_window_set_screen (GTK_WINDOW (csd), gtk_widget_get_screen (parent));
gtk_color_selection_set_has_palette (GTK_COLOR_SELECTION (GTK_COLOR_SELECTION_DIALOG (csd)->colorsel),
TRUE);
/* And mark it as a transient dialog */
gtk_window_set_transient_for (GTK_WINDOW (csd), GTK_WINDOW (parent));
- gtk_signal_connect (GTK_OBJECT(csd), "destroy",
- GTK_SIGNAL_FUNC(cmw_destroy_cb),NULL);
-
- gtk_signal_connect_object (GTK_OBJECT(GTK_COLOR_SELECTION_DIALOG(csd)->ok_button),
- "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy),
- GTK_OBJECT (csd));
- gtk_signal_connect_object (GTK_OBJECT(GTK_COLOR_SELECTION_DIALOG(csd)->cancel_button),
- "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy),
- GTK_OBJECT (csd));
+ g_signal_connect (csd, "destroy",
+ G_CALLBACK (cmw_destroy_cb), NULL);
+
+ g_signal_connect_swapped (GTK_COLOR_SELECTION_DIALOG (csd)->ok_button,
+ "clicked", G_CALLBACK (gtk_widget_destroy), csd);
+ g_signal_connect_swapped (GTK_COLOR_SELECTION_DIALOG (csd)->cancel_button,
+ "clicked", G_CALLBACK (gtk_widget_destroy), csd);
/* wait until destroy calls gtk_main_quit */
gtk_widget_show (csd);
fs = gtk_file_selection_new("This is a modal file selection dialog");
+ gtk_window_set_screen (GTK_WINDOW (fs), gtk_widget_get_screen (parent));
+
/* Set as modal */
gtk_window_set_modal (GTK_WINDOW(fs),TRUE);
/* And mark it as a transient dialog */
gtk_window_set_transient_for (GTK_WINDOW (fs), GTK_WINDOW (parent));
- gtk_signal_connect (GTK_OBJECT(fs), "destroy",
- GTK_SIGNAL_FUNC(cmw_destroy_cb),NULL);
+ g_signal_connect (fs, "destroy",
+ G_CALLBACK (cmw_destroy_cb), NULL);
- gtk_signal_connect_object (GTK_OBJECT(GTK_FILE_SELECTION(fs)->ok_button),
- "clicked",GTK_SIGNAL_FUNC(gtk_widget_destroy),
- GTK_OBJECT (fs));
- gtk_signal_connect_object (GTK_OBJECT(GTK_FILE_SELECTION(fs)->cancel_button),
- "clicked",GTK_SIGNAL_FUNC(gtk_widget_destroy),
- GTK_OBJECT (fs));
+ g_signal_connect_swapped (GTK_FILE_SELECTION (fs)->ok_button,
+ "clicked", G_CALLBACK (gtk_widget_destroy), fs);
+ g_signal_connect_swapped (GTK_FILE_SELECTION (fs)->cancel_button,
+ "clicked", G_CALLBACK (gtk_widget_destroy), fs);
/* wait until destroy calls gtk_main_quit */
gtk_widget_show (fs);
static void
-create_modal_window (void)
+create_modal_window (GtkWidget *widget)
{
GtkWidget *window = NULL;
GtkWidget *box1,*box2;
GtkWidget *btnColor,*btnFile,*btnClose;
/* Create modal window (Here you can use any window descendent )*/
- window=gtk_window_new (GTK_WINDOW_TOPLEVEL);
+ window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+ gtk_window_set_screen (GTK_WINDOW (window),
+ gtk_widget_get_screen (widget));
+
gtk_window_set_title (GTK_WINDOW(window),"This window is modal");
/* Set window as modal */
/* Create widgets */
box1 = gtk_vbox_new (FALSE,5);
- frame1 = gtk_frame_new ("Standard dialogs in modal form");
- box2 = gtk_vbox_new (TRUE,5);
- btnColor = gtk_button_new_with_label ("Color");
- btnFile = gtk_button_new_with_label ("File Selection");
- btnClose = gtk_button_new_with_label ("Close");
+ frame1 = gtk_frame_new ("Standard dialogs in modal form");
+ box2 = gtk_vbox_new (TRUE,5);
+ btnColor = gtk_button_new_with_label ("Color");
+ btnFile = gtk_button_new_with_label ("File Selection");
+ btnClose = gtk_button_new_with_label ("Close");
/* Init widgets */
- gtk_container_set_border_width (GTK_CONTAINER(box1),3);
- gtk_container_set_border_width (GTK_CONTAINER(box2),3);
+ gtk_container_set_border_width (GTK_CONTAINER (box1), 3);
+ gtk_container_set_border_width (GTK_CONTAINER (box2), 3);
/* Pack widgets */
gtk_container_add (GTK_CONTAINER (window), box1);
gtk_box_pack_start (GTK_BOX (box1), btnClose, FALSE, FALSE, 4);
/* connect signals */
- gtk_signal_connect_object (GTK_OBJECT (btnClose), "clicked",
- GTK_SIGNAL_FUNC (gtk_widget_destroy),
- GTK_OBJECT (window));
+ g_signal_connect_swapped (btnClose, "clicked",
+ G_CALLBACK (gtk_widget_destroy), window);
- gtk_signal_connect (GTK_OBJECT (window), "destroy",
- GTK_SIGNAL_FUNC (cmw_destroy_cb),NULL);
+ g_signal_connect (window, "destroy",
+ G_CALLBACK (cmw_destroy_cb), NULL);
- gtk_signal_connect (GTK_OBJECT (btnColor), "clicked",
- GTK_SIGNAL_FUNC (cmw_color),window);
- gtk_signal_connect (GTK_OBJECT (btnFile), "clicked",
- GTK_SIGNAL_FUNC (cmw_file),window);
+ g_signal_connect (btnColor, "clicked",
+ G_CALLBACK (cmw_color), window);
+ g_signal_connect (btnFile, "clicked",
+ G_CALLBACK (cmw_file), window);
/* Show widgets */
gtk_widget_show_all (window);
*/
static void
-make_message_dialog (GtkWidget **dialog,
+make_message_dialog (GdkScreen *screen,
+ GtkWidget **dialog,
GtkMessageType type,
GtkButtonsType buttons,
guint default_response)
*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_window_set_screen (GTK_WINDOW (*dialog), screen);
+
+ g_signal_connect_swapped (*dialog,
+ "response",
+ G_CALLBACK (gtk_widget_destroy),
+ *dialog);
- gtk_signal_connect (GTK_OBJECT (*dialog),
- "destroy",
- GTK_SIGNAL_FUNC (gtk_widget_destroyed),
- dialog);
+ g_signal_connect (*dialog,
+ "destroy",
+ G_CALLBACK (gtk_widget_destroyed),
+ dialog);
gtk_dialog_set_default_response (GTK_DIALOG (*dialog), default_response);
}
static void
-create_message_dialog (void)
+create_message_dialog (GtkWidget *widget)
{
static GtkWidget *info = NULL;
static GtkWidget *warning = NULL;
static GtkWidget *error = NULL;
static GtkWidget *question = NULL;
+ GdkScreen *screen = gtk_widget_get_screen (widget);
- make_message_dialog (&info, GTK_MESSAGE_INFO, GTK_BUTTONS_OK, GTK_RESPONSE_OK);
- make_message_dialog (&warning, GTK_MESSAGE_WARNING, GTK_BUTTONS_CLOSE, GTK_RESPONSE_OK);
- make_message_dialog (&error, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK_CANCEL, GTK_RESPONSE_OK);
- make_message_dialog (&question, GTK_MESSAGE_QUESTION, GTK_BUTTONS_YES_NO, GTK_RESPONSE_YES);
+ make_message_dialog (screen, &info, GTK_MESSAGE_INFO, GTK_BUTTONS_OK, GTK_RESPONSE_OK);
+ make_message_dialog (screen, &warning, GTK_MESSAGE_WARNING, GTK_BUTTONS_CLOSE, GTK_RESPONSE_CLOSE);
+ make_message_dialog (screen, &error, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK_CANCEL, GTK_RESPONSE_OK);
+ make_message_dialog (screen, &question, GTK_MESSAGE_QUESTION, GTK_BUTTONS_YES_NO, GTK_RESPONSE_NO);
}
/*
{
gtk_widget_reparent (scrollwin, sw_parent);
- gtk_signal_disconnect (GTK_OBJECT (sw_parent), sw_destroyed_handler);
+ g_signal_handler_disconnect (sw_parent, sw_destroyed_handler);
sw_float_parent = NULL;
sw_parent = NULL;
sw_destroyed_handler = 0;
gtk_widget_reparent (scrollwin, sw_parent);
gtk_widget_destroy (sw_float_parent);
- gtk_signal_disconnect (GTK_OBJECT (sw_parent), sw_destroyed_handler);
+ g_signal_handler_disconnect (sw_parent, sw_destroyed_handler);
sw_float_parent = NULL;
sw_parent = NULL;
sw_destroyed_handler = 0;
{
sw_parent = scrollwin->parent;
sw_float_parent = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+ gtk_window_set_screen (GTK_WINDOW (sw_float_parent),
+ gtk_widget_get_screen (widget));
+
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);
+ g_signal_connect (sw_parent, "destroy",
+ G_CALLBACK (scrolled_windows_destroy_cb), scrollwin);
+ g_signal_connect (sw_float_parent, "delete_event",
+ G_CALLBACK (scrolled_windows_delete_cb), scrollwin);
}
}
static void
-create_scrolled_windows (void)
+create_scrolled_windows (GtkWidget *widget)
{
static GtkWidget *window;
GtkWidget *scrolled_window;
{
window = gtk_dialog_new ();
- gtk_signal_connect (GTK_OBJECT (window), "destroy",
- GTK_SIGNAL_FUNC(gtk_widget_destroyed),
- &window);
+ gtk_window_set_screen (GTK_WINDOW (window),
+ gtk_widget_get_screen (widget));
+
+ g_signal_connect (window, "destroy",
+ G_CALLBACK (gtk_widget_destroyed),
+ &window);
gtk_window_set_title (GTK_WINDOW (window), "dialog");
gtk_container_set_border_width (GTK_CONTAINER (window), 0);
button = gtk_button_new_with_label ("Close");
- gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
- GTK_SIGNAL_FUNC(gtk_widget_destroy),
- GTK_OBJECT (window));
+ g_signal_connect_swapped (button, "clicked",
+ G_CALLBACK (gtk_widget_destroy),
+ 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);
button = gtk_button_new_with_label ("Reparent Out");
- gtk_signal_connect (GTK_OBJECT (button), "clicked",
- GTK_SIGNAL_FUNC(scrolled_windows_remove),
- scrolled_window);
+ g_signal_connect (button, "clicked",
+ G_CALLBACK (scrolled_windows_remove),
+ scrolled_window);
GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
button, TRUE, TRUE, 0);
gtk_window_set_default_size (GTK_WINDOW (window), 300, 300);
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
gtk_widget_show (window);
else
gtk_widget_destroy (window);
*/
static void
-entry_toggle_frame (GtkWidget *checkbutton,
- GtkWidget *entry)
+entry_toggle_frame (GtkWidget *checkbutton,
+ GtkWidget *entry)
+{
+ gtk_entry_set_has_frame (GTK_ENTRY(entry),
+ GTK_TOGGLE_BUTTON(checkbutton)->active);
+}
+
+static void
+entry_toggle_sensitive (GtkWidget *checkbutton,
+ GtkWidget *entry)
+{
+ gtk_widget_set_sensitive (entry, GTK_TOGGLE_BUTTON(checkbutton)->active);
+}
+
+static gboolean
+entry_progress_timeout (gpointer data)
+{
+ if (GPOINTER_TO_INT (g_object_get_data (G_OBJECT (data), "progress-pulse")))
+ {
+ gtk_entry_progress_pulse (GTK_ENTRY (data));
+ }
+ else
+ {
+ gdouble fraction;
+
+ fraction = gtk_entry_get_progress_fraction (GTK_ENTRY (data));
+
+ fraction += 0.05;
+ if (fraction > 1.0001)
+ fraction = 0.0;
+
+ gtk_entry_set_progress_fraction (GTK_ENTRY (data), fraction);
+ }
+
+ return TRUE;
+}
+
+static void
+entry_remove_timeout (gpointer data)
+{
+ g_source_remove (GPOINTER_TO_UINT (data));
+}
+
+static void
+entry_toggle_progress (GtkWidget *checkbutton,
+ GtkWidget *entry)
{
- gtk_entry_set_has_frame (GTK_ENTRY(entry),
- GTK_TOGGLE_BUTTON(checkbutton)->active);
+ if (GTK_TOGGLE_BUTTON (checkbutton)->active)
+ {
+ guint timeout = gdk_threads_add_timeout (100,
+ entry_progress_timeout,
+ entry);
+ g_object_set_data_full (G_OBJECT (entry), "timeout-id",
+ GUINT_TO_POINTER (timeout),
+ entry_remove_timeout);
+ }
+ else
+ {
+ g_object_set_data (G_OBJECT (entry), "timeout-id",
+ GUINT_TO_POINTER (0));
+
+ gtk_entry_set_progress_fraction (GTK_ENTRY (entry), 0.0);
+ }
}
static void
-entry_toggle_sensitive (GtkWidget *checkbutton,
- GtkWidget *entry)
+entry_toggle_pulse (GtkWidget *checkbutton,
+ GtkWidget *entry)
{
- gtk_widget_set_sensitive (entry, GTK_TOGGLE_BUTTON(checkbutton)->active);
+ g_object_set_data (G_OBJECT (entry), "progress-pulse",
+ GUINT_TO_POINTER ((guint) GTK_TOGGLE_BUTTON (checkbutton)->active));
}
static void
-entry_props_clicked (GtkWidget *button,
- GObject *entry)
+props_clicked (GtkWidget *button,
+ GObject *object)
{
- GtkWidget *window = create_prop_editor (entry, 0);
+ GtkWidget *window = create_prop_editor (object, 0);
- gtk_window_set_title (GTK_WINDOW (window), "Entry Properties");
+ gtk_window_set_title (GTK_WINDOW (window), "Object Properties");
}
static void
-create_entry (void)
+create_entry (GtkWidget *widget)
{
static GtkWidget *window = NULL;
GtkWidget *box1;
GtkWidget *hbox;
GtkWidget *has_frame_check;
GtkWidget *sensitive_check;
+ GtkWidget *progress_check;
GtkWidget *entry, *cb;
GtkWidget *button;
GtkWidget *separator;
cbitems = g_list_append(cbitems, "item9 item9");
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+ gtk_window_set_screen (GTK_WINDOW (window),
+ gtk_widget_get_screen (widget));
- gtk_signal_connect (GTK_OBJECT (window), "destroy",
- GTK_SIGNAL_FUNC(gtk_widget_destroyed),
- &window);
+ g_signal_connect (window, "destroy",
+ G_CALLBACK (gtk_widget_destroyed),
+ &window);
gtk_window_set_title (GTK_WINDOW (window), "entry");
gtk_container_set_border_width (GTK_CONTAINER (window), 0);
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 \330\247\331\204\330\263\331\204\330\247\331\205 \330\271\331\204\331\212\331\203\331\205");
gtk_editable_select_region (GTK_EDITABLE (entry), 0, 5);
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);
+ g_signal_connect (button, "clicked",
+ G_CALLBACK (props_clicked),
+ entry);
cb = gtk_combo_new ();
gtk_combo_set_popdown_strings (GTK_COMBO (cb), cbitems);
sensitive_check = gtk_check_button_new_with_label("Sensitive");
gtk_box_pack_start (GTK_BOX (box2), sensitive_check, FALSE, TRUE, 0);
- gtk_signal_connect (GTK_OBJECT(sensitive_check), "toggled",
- GTK_SIGNAL_FUNC(entry_toggle_sensitive), entry);
- gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(sensitive_check), TRUE);
+ g_signal_connect (sensitive_check, "toggled",
+ G_CALLBACK (entry_toggle_sensitive), entry);
+ 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);
+ g_signal_connect (has_frame_check, "toggled",
+ G_CALLBACK (entry_toggle_frame), entry);
+ gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (has_frame_check), TRUE);
+
+ progress_check = gtk_check_button_new_with_label("Show Progress");
+ gtk_box_pack_start (GTK_BOX (box2), progress_check, FALSE, TRUE, 0);
+ g_signal_connect (progress_check, "toggled",
+ G_CALLBACK (entry_toggle_progress), entry);
+
+ progress_check = gtk_check_button_new_with_label("Pulse Progress");
+ gtk_box_pack_start (GTK_BOX (box2), progress_check, FALSE, TRUE, 0);
+ g_signal_connect (progress_check, "toggled",
+ G_CALLBACK (entry_toggle_pulse), entry);
+
+ separator = gtk_hseparator_new ();
+ gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
+
+ box2 = gtk_vbox_new (FALSE, 10);
+ gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
+ gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
+
+ button = gtk_button_new_with_label ("close");
+ g_signal_connect_swapped (button, "clicked",
+ G_CALLBACK (gtk_widget_destroy),
+ window);
+ gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
+ GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
+ gtk_widget_grab_default (button);
+ }
+
+ if (!gtk_widget_get_visible (window))
+ gtk_widget_show_all (window);
+ else
+ gtk_widget_destroy (window);
+}
+
+static void
+create_expander (GtkWidget *widget)
+{
+ GtkWidget *box1;
+ GtkWidget *expander;
+ GtkWidget *hidden;
+ static GtkWidget *window = NULL;
+
+ if (!window)
+ {
+ window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+ gtk_window_set_screen (GTK_WINDOW (window),
+ gtk_widget_get_screen (widget));
+
+ g_signal_connect (window, "destroy",
+ G_CALLBACK (gtk_widget_destroyed),
+ &window);
+
+ gtk_window_set_title (GTK_WINDOW (window), "expander");
+ gtk_container_set_border_width (GTK_CONTAINER (window), 0);
+
+ box1 = gtk_vbox_new (FALSE, 0);
+ gtk_container_add (GTK_CONTAINER (window), box1);
+
+ expander = gtk_expander_new ("The Hidden");
+
+ gtk_box_pack_start (GTK_BOX (box1), expander, TRUE, TRUE, 0);
+
+ hidden = gtk_label_new ("Revealed!");
+
+ gtk_container_add (GTK_CONTAINER (expander), hidden);
+ }
+
+ if (!gtk_widget_get_visible (window))
+ gtk_widget_show_all (window);
+ else
+ gtk_widget_destroy (window);
+}
+
+
+/* GtkEventBox */
+
+
+static void
+event_box_label_pressed (GtkWidget *widget,
+ GdkEventButton *event,
+ gpointer user_data)
+{
+ g_print ("clicked on event box\n");
+}
+
+static void
+event_box_button_clicked (GtkWidget *widget,
+ GtkWidget *button,
+ gpointer user_data)
+{
+ g_print ("pushed button\n");
+}
+
+static void
+event_box_toggle_visible_window (GtkWidget *checkbutton,
+ GtkEventBox *event_box)
+{
+ gtk_event_box_set_visible_window (event_box,
+ GTK_TOGGLE_BUTTON(checkbutton)->active);
+}
+
+static void
+event_box_toggle_above_child (GtkWidget *checkbutton,
+ GtkEventBox *event_box)
+{
+ gtk_event_box_set_above_child (event_box,
+ GTK_TOGGLE_BUTTON(checkbutton)->active);
+}
+
+static void
+create_event_box (GtkWidget *widget)
+{
+ static GtkWidget *window = NULL;
+ GtkWidget *box1;
+ GtkWidget *box2;
+ GtkWidget *hbox;
+ GtkWidget *vbox;
+ GtkWidget *button;
+ GtkWidget *separator;
+ GtkWidget *event_box;
+ GtkWidget *label;
+ GtkWidget *visible_window_check;
+ GtkWidget *above_child_check;
+ GdkColor color;
+
+ if (!window)
+ {
+ color.red = 0;
+ color.blue = 65535;
+ color.green = 0;
+
+ window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+ gtk_window_set_screen (GTK_WINDOW (window),
+ gtk_widget_get_screen (widget));
+
+ g_signal_connect (window, "destroy",
+ G_CALLBACK (gtk_widget_destroyed),
+ &window);
+
+ gtk_window_set_title (GTK_WINDOW (window), "event box");
+ gtk_container_set_border_width (GTK_CONTAINER (window), 0);
+
+ box1 = gtk_vbox_new (FALSE, 0);
+ gtk_container_add (GTK_CONTAINER (window), box1);
+ gtk_widget_modify_bg (window, GTK_STATE_NORMAL, &color);
+
+ hbox = gtk_hbox_new (FALSE, 0);
+ gtk_box_pack_start (GTK_BOX (box1), hbox, TRUE, FALSE, 0);
+
+ event_box = gtk_event_box_new ();
+ gtk_box_pack_start (GTK_BOX (hbox), event_box, TRUE, FALSE, 0);
+
+ vbox = gtk_vbox_new (FALSE, 0);
+ gtk_container_add (GTK_CONTAINER (event_box), vbox);
+ g_signal_connect (event_box, "button_press_event",
+ G_CALLBACK (event_box_label_pressed),
+ NULL);
+
+ label = gtk_label_new ("Click on this label");
+ gtk_box_pack_start (GTK_BOX (vbox), label, TRUE, FALSE, 0);
+
+ button = gtk_button_new_with_label ("button in eventbox");
+ gtk_box_pack_start (GTK_BOX (vbox), button, TRUE, FALSE, 0);
+ g_signal_connect (button, "clicked",
+ G_CALLBACK (event_box_button_clicked),
+ NULL);
+
+
+ visible_window_check = gtk_check_button_new_with_label("Visible Window");
+ gtk_box_pack_start (GTK_BOX (box1), visible_window_check, FALSE, TRUE, 0);
+ g_signal_connect (visible_window_check, "toggled",
+ G_CALLBACK (event_box_toggle_visible_window), event_box);
+ gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (visible_window_check), FALSE);
+
+ above_child_check = gtk_check_button_new_with_label("Above Child");
+ gtk_box_pack_start (GTK_BOX (box1), above_child_check, FALSE, TRUE, 0);
+ g_signal_connect (above_child_check, "toggled",
+ G_CALLBACK (event_box_toggle_above_child), event_box);
+ gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (above_child_check), FALSE);
separator = gtk_hseparator_new ();
gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
button = gtk_button_new_with_label ("close");
- gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
- GTK_SIGNAL_FUNC(gtk_widget_destroy),
- GTK_OBJECT (window));
+ g_signal_connect_swapped (button, "clicked",
+ G_CALLBACK (gtk_widget_destroy),
+ window);
gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
gtk_widget_grab_default (button);
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
}
+
/*
* GtkSizeGroup
*/
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);
+ gtk_widget_set_size_request (GTK_BIN (button)->child,
+ gtk_spin_button_get_value_as_int (spin_button),
+ -1);
}
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));
+ gtk_widget_set_size_request (GTK_BIN (button)->child,
+ -1,
+ gtk_spin_button_get_value_as_int (spin_button));
}
static GtkWidget *
-create_size_group_window (GtkSizeGroup *master_size_group)
+create_size_group_window (GdkScreen *screen,
+ GtkSizeGroup *master_size_group)
{
GtkWidget *window;
GtkWidget *table;
GTK_RESPONSE_NONE,
NULL);
- gtk_window_set_resizable (GTK_WINDOW (window), FALSE);
+ gtk_window_set_screen (GTK_WINDOW (window), screen);
- gtk_signal_connect (GTK_OBJECT (window), "response",
- GTK_SIGNAL_FUNC (gtk_widget_destroy),
- NULL);
+ gtk_window_set_resizable (GTK_WINDOW (window), TRUE);
+
+ g_signal_connect (window, "response",
+ G_CALLBACK (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);
+ gtk_widget_set_size_request (table, 250, 250);
hgroup1 = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
hgroup2 = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
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);
+ gtk_widget_set_size_request (GTK_BIN (main_button)->child,
+ SIZE_GROUP_INITIAL_SIZE,
+ SIZE_GROUP_INITIAL_SIZE);
button = gtk_button_new ();
gtk_table_attach (GTK_TABLE (table), button,
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));
+ g_object_unref (hgroup1);
+ g_object_unref (hgroup2);
+ g_object_unref (vgroup1);
+ g_object_unref (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);
+ g_signal_connect (spin_button, "value_changed",
+ G_CALLBACK (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);
+ g_signal_connect (spin_button, "value_changed",
+ G_CALLBACK (size_group_vsize_changed), main_button);
return window;
}
static void
-create_size_groups (void)
+create_size_groups (GtkWidget *widget)
{
static GtkWidget *window1 = NULL;
static GtkWidget *window2 = NULL;
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);
+ window1 = create_size_group_window (gtk_widget_get_screen (widget),
+ master_size_group);
- gtk_signal_connect (GTK_OBJECT (window1), "destroy",
- GTK_SIGNAL_FUNC (gtk_widget_destroyed),
- &window1);
+ g_signal_connect (window1, "destroy",
+ G_CALLBACK (gtk_widget_destroyed),
+ &window1);
}
if (!window2)
{
- window2 = create_size_group_window (master_size_group);
+ window2 = create_size_group_window (gtk_widget_get_screen (widget),
+ master_size_group);
- gtk_signal_connect (GTK_OBJECT (window2), "destroy",
- GTK_SIGNAL_FUNC (gtk_widget_destroyed),
- &window2);
+ g_signal_connect (window2, "destroy",
+ G_CALLBACK (gtk_widget_destroyed),
+ &window2);
}
- if (GTK_WIDGET_VISIBLE (window1) && GTK_WIDGET_VISIBLE (window2))
+ if (gtk_widget_get_visible (window1) && gtk_widget_get_visible (window2))
{
gtk_widget_destroy (window1);
gtk_widget_destroy (window2);
}
else
{
- if (!GTK_WIDGET_VISIBLE (window1))
+ if (!gtk_widget_get_visible (window1))
gtk_widget_show_all (window1);
- if (!GTK_WIDGET_VISIBLE (window2))
+ if (!gtk_widget_get_visible (window2))
gtk_widget_show_all (window2);
}
}
GtkSpinButton *spin;
spin = GTK_SPIN_BUTTON (spinner1);
- label = GTK_LABEL (gtk_object_get_user_data (GTK_OBJECT (widget)));
+ label = GTK_LABEL (g_object_get_data (G_OBJECT (widget), "user_data"));
if (GPOINTER_TO_INT (data) == 1)
sprintf (buf, "%d", gtk_spin_button_get_value_as_int (spin));
else
- sprintf (buf, "%0.*f", spin->digits,
- gtk_spin_button_get_value_as_float (spin));
+ sprintf (buf, "%0.*f", spin->digits, gtk_spin_button_get_value (spin));
gtk_label_set_text (label, buf);
}
label = GTK_LABEL (data);
buffer = g_strdup_printf ("%0.*f", spin->digits,
- gtk_spin_button_get_value_as_float (spin));
+ gtk_spin_button_get_value (spin));
gtk_label_set_text (label, buffer);
g_free (buffer);
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);
+ tmp1 = g_ascii_strup (month[i - 1], -1);
+ tmp2 = g_ascii_strup (gtk_entry_get_text (GTK_ENTRY (spin_button)), -1);
if (strstr (tmp1, tmp2) == tmp1)
found = TRUE;
g_free (tmp1);
}
static void
-create_spins (void)
+create_spins (GtkWidget *widget)
{
static GtkWidget *window = NULL;
GtkWidget *frame;
if (!window)
{
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+ gtk_window_set_screen (GTK_WINDOW (window),
+ gtk_widget_get_screen (widget));
- gtk_signal_connect (GTK_OBJECT (window), "destroy",
- GTK_SIGNAL_FUNC (gtk_widget_destroyed),
- &window);
+ g_signal_connect (window, "destroy",
+ G_CALLBACK (gtk_widget_destroyed),
+ &window);
gtk_window_set_title (GTK_WINDOW (window), "GtkSpinButton");
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);
+ g_signal_connect (spinner,
+ "output",
+ G_CALLBACK (spin_button_time_output_func),
+ NULL);
gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spinner), TRUE);
- gtk_widget_set_usize (spinner, 55, -1);
+ gtk_entry_set_width_chars (GTK_ENTRY (spinner), 5);
gtk_box_pack_start (GTK_BOX (vbox2), spinner, FALSE, TRUE, 0);
vbox2 = gtk_vbox_new (FALSE, 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);
+ g_signal_connect (spinner,
+ "input",
+ G_CALLBACK (spin_button_month_input_func),
+ NULL);
+ g_signal_connect (spinner,
+ "output",
+ G_CALLBACK (spin_button_month_output_func),
+ NULL);
gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spinner), TRUE);
- gtk_widget_set_usize (spinner, 85, -1);
+ gtk_entry_set_width_chars (GTK_ENTRY (spinner), 9);
gtk_box_pack_start (GTK_BOX (vbox2), spinner, FALSE, TRUE, 0);
vbox2 = gtk_vbox_new (FALSE, 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);
+ g_signal_connect (spinner,
+ "input",
+ G_CALLBACK (spin_button_hex_input_func),
+ NULL);
+ g_signal_connect (spinner,
+ "output",
+ G_CALLBACK (spin_button_hex_output_func),
+ NULL);
gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spinner), TRUE);
- gtk_widget_set_usize (spinner, 55, 0);
+ gtk_entry_set_width_chars (GTK_ENTRY (spinner), 4);
gtk_box_pack_start (GTK_BOX (vbox2), spinner, FALSE, TRUE, 0);
frame = gtk_frame_new ("Accelerated");
adj = (GtkAdjustment *) gtk_adjustment_new (2, 1, 15, 1, 1, 0);
spinner2 = gtk_spin_button_new (adj, 0.0, 0);
- gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
- GTK_SIGNAL_FUNC (change_digits),
- (gpointer) spinner2);
+ g_signal_connect (adj, "value_changed",
+ G_CALLBACK (change_digits),
+ 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, 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);
+ g_signal_connect (button, "clicked",
+ G_CALLBACK (toggle_snap),
+ spinner1);
gtk_box_pack_start (GTK_BOX (vbox), button, TRUE, TRUE, 0);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
button = gtk_check_button_new_with_label ("Numeric only input mode");
- gtk_signal_connect (GTK_OBJECT (button), "clicked",
- GTK_SIGNAL_FUNC (toggle_numeric),
- spinner1);
+ g_signal_connect (button, "clicked",
+ G_CALLBACK (toggle_numeric),
+ spinner1);
gtk_box_pack_start (GTK_BOX (vbox), button, TRUE, TRUE, 0);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 5);
button = gtk_button_new_with_label ("Value as Int");
- gtk_object_set_user_data (GTK_OBJECT (button), val_label);
- gtk_signal_connect (GTK_OBJECT (button), "clicked",
- GTK_SIGNAL_FUNC (get_value),
- GINT_TO_POINTER (1));
+ g_object_set_data (G_OBJECT (button), "user_data", val_label);
+ g_signal_connect (button, "clicked",
+ G_CALLBACK (get_value),
+ GINT_TO_POINTER (1));
gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
button = gtk_button_new_with_label ("Value as Float");
- gtk_object_set_user_data (GTK_OBJECT (button), val_label);
- gtk_signal_connect (GTK_OBJECT (button), "clicked",
- GTK_SIGNAL_FUNC (get_value),
- GINT_TO_POINTER (2));
+ g_object_set_data (G_OBJECT (button), "user_data", val_label);
+ g_signal_connect (button, "clicked",
+ G_CALLBACK (get_value),
+ GINT_TO_POINTER (2));
gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
gtk_box_pack_start (GTK_BOX (vbox), val_label, TRUE, TRUE, 0);
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);
+ g_signal_connect (spinner, "value_changed",
+ G_CALLBACK (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);
gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, TRUE, 0);
button = gtk_button_new_with_label ("Close");
- gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
- GTK_SIGNAL_FUNC (gtk_widget_destroy),
- GTK_OBJECT (window));
+ g_signal_connect_swapped (button, "clicked",
+ G_CALLBACK (gtk_widget_destroy),
+ window);
gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
guint c;
GdkCursor *cursor;
GtkWidget *label;
- GtkEnumValue *vals;
+ GEnumClass *class;
+ GEnumValue *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 (GDK_TYPE_CURSOR_TYPE);
+ label = g_object_get_data (G_OBJECT (spinner), "user_data");
+
+ class = g_type_class_ref (GDK_TYPE_CURSOR_TYPE);
+ vals = class->values;
+
while (vals && vals->value != c)
vals++;
if (vals)
else
gtk_label_set_text (GTK_LABEL (label), "<unknown>");
- cursor = gdk_cursor_new (c);
+ g_type_class_unref (class);
+
+ cursor = gdk_cursor_new_for_display (gtk_widget_get_display (widget), c);
gdk_window_set_cursor (widget->window, cursor);
gdk_cursor_unref (cursor);
}
return FALSE;
}
+#ifdef GDK_WINDOWING_X11
+#include "x11/gdkx.h"
+
+static void
+change_cursor_theme (GtkWidget *widget,
+ gpointer data)
+{
+ const gchar *theme;
+ gint size;
+ GList *children;
+
+ children = gtk_container_get_children (GTK_CONTAINER (data));
+
+ theme = gtk_entry_get_text (GTK_ENTRY (children->next->data));
+ size = (gint) gtk_spin_button_get_value (GTK_SPIN_BUTTON (children->next->next->data));
+
+ g_list_free (children);
+
+ gdk_x11_display_set_cursor_theme (gtk_widget_get_display (widget),
+ theme, size);
+}
+#endif
+
+
static void
-create_cursors (void)
+create_cursors (GtkWidget *widget)
{
static GtkWidget *window = NULL;
GtkWidget *frame;
GtkWidget *label;
GtkWidget *any;
GtkAdjustment *adj;
+ GtkWidget *entry;
+ GtkWidget *size;
if (!window)
{
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+ gtk_window_set_screen (GTK_WINDOW (window),
+ gtk_widget_get_screen (widget));
- gtk_signal_connect (GTK_OBJECT (window), "destroy",
- GTK_SIGNAL_FUNC (gtk_widget_destroyed),
- &window);
+ g_signal_connect (window, "destroy",
+ G_CALLBACK (gtk_widget_destroyed),
+ &window);
gtk_window_set_title (GTK_WINDOW (window), "Cursors");
gtk_container_add (GTK_CONTAINER (window), main_vbox);
vbox =
- gtk_widget_new (gtk_vbox_get_type (),
+ g_object_new (gtk_vbox_get_type (),
"GtkBox::homogeneous", FALSE,
"GtkBox::spacing", 5,
"GtkContainer::border_width", 10,
"GtkWidget::visible", TRUE,
NULL);
+#ifdef GDK_WINDOWING_X11
hbox = gtk_hbox_new (FALSE, 0);
gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0);
+
+ label = gtk_label_new ("Cursor Theme : ");
+ gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
+ gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
+
+ entry = gtk_entry_new ();
+ gtk_entry_set_text (GTK_ENTRY (entry), "default");
+ gtk_box_pack_start (GTK_BOX (hbox), entry, FALSE, TRUE, 0);
+
+ size = gtk_spin_button_new_with_range (1.0, 64.0, 1.0);
+ gtk_spin_button_set_value (GTK_SPIN_BUTTON (size), 24.0);
+ gtk_box_pack_start (GTK_BOX (hbox), size, TRUE, TRUE, 0);
+ g_signal_connect (entry, "changed",
+ G_CALLBACK (change_cursor_theme), hbox);
+ g_signal_connect (size, "changed",
+ G_CALLBACK (change_cursor_theme), hbox);
+#endif
+
+ hbox = gtk_hbox_new (FALSE, 0);
+ gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
+ gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0);
+
label = gtk_label_new ("Cursor Value : ");
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (hbox), spinner, TRUE, TRUE, 0);
frame =
- gtk_widget_new (gtk_frame_get_type (),
+ g_object_new (gtk_frame_get_type (),
"GtkFrame::shadow", GTK_SHADOW_ETCHED_IN,
"GtkFrame::label_xalign", 0.5,
"GtkFrame::label", "Cursor Area",
NULL);
darea = gtk_drawing_area_new ();
- gtk_widget_set_usize (darea, 80, 80);
+ gtk_widget_set_size_request (darea, 80, 80);
gtk_container_add (GTK_CONTAINER (frame), darea);
- gtk_signal_connect (GTK_OBJECT (darea),
- "expose_event",
- GTK_SIGNAL_FUNC (cursor_expose_event),
- NULL);
+ g_signal_connect (darea,
+ "expose_event",
+ G_CALLBACK (cursor_expose_event),
+ NULL);
gtk_widget_set_events (darea, GDK_EXPOSURE_MASK | GDK_BUTTON_PRESS_MASK);
- gtk_signal_connect (GTK_OBJECT (darea),
- "button_press_event",
- GTK_SIGNAL_FUNC (cursor_event),
- spinner);
+ g_signal_connect (darea,
+ "button_press_event",
+ G_CALLBACK (cursor_event),
+ spinner);
gtk_widget_show (darea);
- gtk_signal_connect (GTK_OBJECT (spinner), "changed",
- GTK_SIGNAL_FUNC (set_cursor),
- darea);
+ g_signal_connect (spinner, "changed",
+ G_CALLBACK (set_cursor),
+ darea);
- label = gtk_widget_new (GTK_TYPE_LABEL,
+ label = g_object_new (GTK_TYPE_LABEL,
"visible", TRUE,
"label", "XXX",
"parent", vbox,
gtk_container_child_set (GTK_CONTAINER (vbox), label,
"expand", FALSE,
NULL);
- gtk_object_set_user_data (GTK_OBJECT (spinner), label);
+ g_object_set_data (G_OBJECT (spinner), "user_data", label);
any =
- gtk_widget_new (gtk_hseparator_get_type (),
+ g_object_new (gtk_hseparator_get_type (),
"GtkWidget::visible", TRUE,
NULL);
gtk_box_pack_start (GTK_BOX (main_vbox), any, FALSE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, TRUE, 0);
button = gtk_button_new_with_label ("Close");
- gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
- GTK_SIGNAL_FUNC (gtk_widget_destroy),
- GTK_OBJECT (window));
+ g_signal_connect_swapped (button, "clicked",
+ G_CALLBACK (gtk_widget_destroy),
+ window);
gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
gtk_widget_show_all (window);
gtk_list_clear_items (GTK_LIST (list), 0, -1);
}
+static gchar *selection_mode_items[] =
+{
+ "Single",
+ "Browse",
+ "Multiple"
+};
+
+static const GtkSelectionMode selection_modes[] = {
+ GTK_SELECTION_SINGLE,
+ GTK_SELECTION_BROWSE,
+ GTK_SELECTION_MULTIPLE
+};
+
static GtkWidget *list_omenu;
static void
i = gtk_option_menu_get_history (GTK_OPTION_MENU (widget));
- gtk_list_set_selection_mode (list, (GtkSelectionMode) i);
+ gtk_list_set_selection_mode (list, selection_modes[i]);
}
static void
-create_list (void)
+create_list (GtkWidget *widget)
{
static GtkWidget *window = NULL;
- static gchar *items[] =
- {
- "Single",
- "Browse",
- "Multiple"
- };
-
if (!window)
{
GtkWidget *cbox;
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
- gtk_signal_connect (GTK_OBJECT (window), "destroy",
- GTK_SIGNAL_FUNC(gtk_widget_destroyed),
- &window);
+ gtk_window_set_screen (GTK_WINDOW (window),
+ gtk_widget_get_screen (widget));
+
+ g_signal_connect (window, "destroy",
+ G_CALLBACK (gtk_widget_destroyed),
+ &window);
gtk_window_set_title (GTK_WINDOW (window), "list");
gtk_container_set_border_width (GTK_CONTAINER (window), 0);
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_widget_set_size_request (scrolled_win, -1, 300);
gtk_box_pack_start (GTK_BOX (vbox), scrolled_win, TRUE, TRUE, 0);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
list = gtk_list_new ();
- gtk_list_set_selection_mode (GTK_LIST (list), GTK_SELECTION_EXTENDED);
+ gtk_list_set_selection_mode (GTK_LIST (list), GTK_SELECTION_SINGLE);
gtk_scrolled_window_add_with_viewport
(GTK_SCROLLED_WINDOW (scrolled_win), list);
gtk_container_set_focus_vadjustment
button = gtk_button_new_with_label ("Insert Row");
gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
- gtk_signal_connect (GTK_OBJECT (button), "clicked",
- GTK_SIGNAL_FUNC (list_add),
- list);
+ g_signal_connect (button, "clicked",
+ G_CALLBACK (list_add),
+ list);
button = gtk_button_new_with_label ("Clear List");
gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
- gtk_signal_connect (GTK_OBJECT (button), "clicked",
- GTK_SIGNAL_FUNC (list_clear),
- list);
+ g_signal_connect (button, "clicked",
+ G_CALLBACK (list_clear),
+ list);
button = gtk_button_new_with_label ("Remove Selection");
gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
- gtk_signal_connect (GTK_OBJECT (button), "clicked",
- GTK_SIGNAL_FUNC (list_remove),
- list);
+ g_signal_connect (button, "clicked",
+ G_CALLBACK (list_remove),
+ list);
cbox = gtk_hbox_new (FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox), cbox, FALSE, TRUE, 0);
label = gtk_label_new ("Selection Mode :");
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
- list_omenu = build_option_menu (items, 3, 3,
+ list_omenu = build_option_menu (selection_mode_items, 3, 3,
list_toggle_sel_mode,
list);
gtk_box_pack_start (GTK_BOX (hbox), list_omenu, 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));
+ g_signal_connect_swapped (button, "clicked",
+ G_CALLBACK (gtk_widget_destroy),
+ window);
GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
gtk_widget_grab_default (button);
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
gtk_clist_thaw (GTK_CLIST (data));
- gdk_pixmap_unref (pixmap);
- gdk_bitmap_unref (mask);
+ g_object_unref (pixmap);
+ g_object_unref (mask);
}
static void
if (!style1)
{
- GdkColor col1;
- GdkColor col2;
-
- col1.red = 0;
- col1.green = 56000;
- col1.blue = 0;
- col2.red = 32000;
- col2.green = 0;
- col2.blue = 56000;
+ GdkColor col1 = { 0, 0, 56000, 0};
+ GdkColor col2 = { 0, 32000, 0, 56000};
style1 = gtk_style_copy (GTK_WIDGET (data)->style);
style1->base[GTK_STATE_NORMAL] = col1;
add_remove = !add_remove;
child = gtk_label_new ("Test");
- gtk_widget_ref (child);
+ g_object_ref (child);
gtk_object_sink (GTK_OBJECT (child));
if (add_remove)
}
gtk_widget_destroy (child);
- gtk_widget_unref (child);
+ g_object_unref (child);
}
static void
i = gtk_option_menu_get_history (GTK_OPTION_MENU (widget));
- gtk_clist_set_selection_mode (clist, (GtkSelectionMode) i);
+ gtk_clist_set_selection_mode (clist, selection_modes[i]);
}
static void
}
static void
-create_clist (void)
+create_clist (GtkWidget *widget)
{
gint i;
static GtkWidget *window = NULL;
"Title 8", "Title 9", "Title 10", "Title 11"
};
- static gchar *items[] =
- {
- "Single",
- "Browse",
- "Multiple",
- };
-
char text[TESTGTK_CLIST_COLUMNS][50];
char *texts[TESTGTK_CLIST_COLUMNS];
GtkWidget *label;
GtkStyle *style;
- GdkColor col1;
- GdkColor col2;
+ GdkColor red_col = { 0, 56000, 0, 0};
+ GdkColor light_green_col = { 0, 0, 56000, 32000};
if (!window)
{
clist_rows = 0;
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+ gtk_window_set_screen (GTK_WINDOW (window),
+ gtk_widget_get_screen (widget));
- gtk_signal_connect (GTK_OBJECT (window), "destroy",
- GTK_SIGNAL_FUNC (gtk_widget_destroyed), &window);
+ g_signal_connect (window, "destroy",
+ G_CALLBACK (gtk_widget_destroyed), &window);
gtk_window_set_title (GTK_WINDOW (window), "clist");
gtk_container_set_border_width (GTK_CONTAINER (window), 0);
* 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);
+ g_signal_connect (clist, "click_column",
+ G_CALLBACK (clist_click_column), NULL);
/* control buttons */
hbox = gtk_hbox_new (FALSE, 5);
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);
+ g_signal_connect (button, "clicked",
+ G_CALLBACK (insert_row_clist), 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);
+ g_signal_connect (button, "clicked",
+ G_CALLBACK (add1000_clist), clist);
button = gtk_button_new_with_label ("Add 10,000 Rows");
gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
- gtk_signal_connect (GTK_OBJECT (button), "clicked",
- (GtkSignalFunc) add10000_clist, (gpointer) clist);
+ g_signal_connect (button, "clicked",
+ G_CALLBACK (add10000_clist), clist);
/* second layer of buttons */
hbox = gtk_hbox_new (FALSE, 5);
button = gtk_button_new_with_label ("Clear List");
gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
- gtk_signal_connect (GTK_OBJECT (button), "clicked",
- (GtkSignalFunc) clear_clist, (gpointer) clist);
+ g_signal_connect (button, "clicked",
+ G_CALLBACK (clear_clist), clist);
button = gtk_button_new_with_label ("Remove Selection");
gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
- gtk_signal_connect (GTK_OBJECT (button), "clicked",
- (GtkSignalFunc) clist_remove_selection,
- (gpointer) clist);
+ g_signal_connect (button, "clicked",
+ G_CALLBACK (clist_remove_selection), 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);
+ g_signal_connect (undo_button, "clicked",
+ G_CALLBACK (undo_selection), clist);
button = gtk_button_new_with_label ("Warning Test");
gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
- gtk_signal_connect (GTK_OBJECT (button), "clicked",
- (GtkSignalFunc) clist_warning_test,(gpointer) clist);
+ g_signal_connect (button, "clicked",
+ G_CALLBACK (clist_warning_test), clist);
/* third layer of buttons */
hbox = gtk_hbox_new (FALSE, 5);
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);
+ g_signal_connect (check, "clicked",
+ G_CALLBACK (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);
+ g_signal_connect (check, "clicked",
+ G_CALLBACK (toggle_reorderable), clist);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check), TRUE);
label = gtk_label_new ("Selection Mode :");
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
- clist_omenu = build_option_menu (items, 3, 3,
+ clist_omenu = build_option_menu (selection_mode_items, 3, 3,
clist_toggle_sel_mode,
clist);
gtk_box_pack_start (GTK_BOX (hbox), clist_omenu, FALSE, TRUE, 0);
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_widget_set_size_request (clist, -1, 300);
for (i = 1; i < TESTGTK_CLIST_COLUMNS; i++)
gtk_clist_set_column_width (GTK_CLIST (clist), i, 80);
sprintf (text[1], "Right");
sprintf (text[2], "Center");
- col1.red = 56000;
- col1.green = 0;
- col1.blue = 0;
- col2.red = 0;
- col2.green = 56000;
- col2.blue = 32000;
-
style = gtk_style_new ();
- style->fg[GTK_STATE_NORMAL] = col1;
- style->base[GTK_STATE_NORMAL] = col2;
+ style->fg[GTK_STATE_NORMAL] = red_col;
+ style->base[GTK_STATE_NORMAL] = light_green_col;
pango_font_description_set_size (style->font_desc, 14 * PANGO_SCALE);
pango_font_description_set_weight (style->font_desc, PANGO_WEIGHT_BOLD);
}
}
- gtk_style_unref (style);
+ g_object_unref (style);
separator = gtk_hseparator_new ();
gtk_box_pack_start (GTK_BOX (vbox), separator, 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));
+ g_signal_connect_swapped (button, "clicked",
+ G_CALLBACK (gtk_widget_destroy),
+ window);
GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
gtk_widget_grab_default (button);
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
{
* GtkCTree
*/
-GdkPixmap *pixmap1;
-GdkPixmap *pixmap2;
-GdkPixmap *pixmap3;
-GdkBitmap *mask1;
-GdkBitmap *mask2;
-GdkBitmap *mask3;
+typedef struct
+{
+ GdkPixmap *pixmap1;
+ GdkPixmap *pixmap2;
+ GdkPixmap *pixmap3;
+ GdkBitmap *mask1;
+ GdkBitmap *mask2;
+ GdkBitmap *mask3;
+} CTreePixmaps;
static gint books = 0;
static gint pages = 0;
static GtkWidget *spin3;
static gint line_style;
+
+static CTreePixmaps *
+get_ctree_pixmaps (GtkCTree *ctree)
+{
+ GdkScreen *screen = gtk_widget_get_screen (GTK_WIDGET (ctree));
+ CTreePixmaps *pixmaps = g_object_get_data (G_OBJECT (screen), "ctree-pixmaps");
+
+ if (!pixmaps)
+ {
+ GdkColormap *colormap = gdk_screen_get_rgb_colormap (screen);
+ pixmaps = g_new (CTreePixmaps, 1);
+
+ pixmaps->pixmap1 = gdk_pixmap_colormap_create_from_xpm_d (NULL, colormap,
+ &pixmaps->mask1,
+ NULL, book_closed_xpm);
+ pixmaps->pixmap2 = gdk_pixmap_colormap_create_from_xpm_d (NULL, colormap,
+ &pixmaps->mask2,
+ NULL, book_open_xpm);
+ pixmaps->pixmap3 = gdk_pixmap_colormap_create_from_xpm_d (NULL, colormap,
+ &pixmaps->mask3,
+ NULL, mini_page_xpm);
+
+ g_object_set_data (G_OBJECT (screen), "ctree-pixmaps", pixmaps);
+ }
+
+ return pixmaps;
+}
+
void after_press (GtkCTree *ctree, gpointer data)
{
char buf[80];
static GtkStyle *style2 = NULL;
GtkCTreeNode *node;
- GdkColor col1;
- GdkColor col2;
+ GdkColor green_col = { 0, 0, 56000, 0};
+ GdkColor purple_col = { 0, 32000, 0, 56000};
if (GTK_CLIST (ctree)->focus_row >= 0)
node = GTK_CTREE_NODE
if (!style1)
{
- col1.red = 0;
- col1.green = 56000;
- col1.blue = 0;
- col2.red = 32000;
- col2.green = 0;
- col2.blue = 56000;
-
style1 = gtk_style_new ();
- style1->base[GTK_STATE_NORMAL] = col1;
- style1->fg[GTK_STATE_SELECTED] = col2;
+ style1->base[GTK_STATE_NORMAL] = green_col;
+ style1->fg[GTK_STATE_SELECTED] = purple_col;
style2 = gtk_style_new ();
- style2->base[GTK_STATE_SELECTED] = col2;
- style2->fg[GTK_STATE_NORMAL] = col1;
- style2->base[GTK_STATE_NORMAL] = col2;
+ style2->base[GTK_STATE_SELECTED] = purple_col;
+ style2->fg[GTK_STATE_NORMAL] = green_col;
+ style2->base[GTK_STATE_NORMAL] = purple_col;
pango_font_description_free (style2->font_desc);
style2->font_desc = pango_font_description_from_string ("courier 30");
}
GdkBitmap *mask_closed;
GdkPixmap *pixmap_opened;
GdkBitmap *mask_opened;
+ CTreePixmaps *pixmaps;
if (!cnode || !gnode || (!(es = gnode->data)))
return FALSE;
+ pixmaps = get_ctree_pixmaps (ctree);
+
if (es->is_leaf)
{
- pixmap_closed = pixmap3;
- mask_closed = mask3;
+ pixmap_closed = pixmaps->pixmap3;
+ mask_closed = pixmaps->mask3;
pixmap_opened = NULL;
mask_opened = NULL;
}
else
{
- pixmap_closed = pixmap1;
- mask_closed = mask1;
- pixmap_opened = pixmap2;
- mask_opened = mask2;
+ pixmap_closed = pixmaps->pixmap1;
+ mask_closed = pixmaps->mask1;
+ pixmap_opened = pixmaps->pixmap2;
+ mask_opened = pixmaps->mask2;
}
gtk_ctree_set_node_info (ctree, cnode, es->tree, 2, pixmap_closed,
if (!export_window)
{
export_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+
+ gtk_window_set_screen (GTK_WINDOW (export_window),
+ gtk_widget_get_screen (widget));
- gtk_signal_connect (GTK_OBJECT (export_window), "destroy",
- GTK_SIGNAL_FUNC (gtk_widget_destroyed),
- &export_window);
+ g_signal_connect (export_window, "destroy",
+ G_CALLBACK (gtk_widget_destroyed),
+ &export_window);
gtk_window_set_title (GTK_WINDOW (export_window), "exported ctree");
gtk_container_set_border_width (GTK_CONTAINER (export_window), 5);
button = gtk_button_new_with_label ("Close");
gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, TRUE, 0);
- gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
- (GtkSignalFunc) gtk_widget_destroy,
- GTK_OBJECT(export_window));
+ g_signal_connect_swapped (button, "clicked",
+ G_CALLBACK (gtk_widget_destroy),
+ export_window);
sep = gtk_hseparator_new ();
gtk_box_pack_end (GTK_BOX (vbox), sep, FALSE, TRUE, 10);
GTK_SELECTION_EXTENDED);
gtk_clist_set_column_width (GTK_CLIST (export_ctree), 0, 200);
gtk_clist_set_column_width (GTK_CLIST (export_ctree), 1, 200);
- gtk_widget_set_usize (GTK_WIDGET (export_ctree), 300, 200);
+ gtk_widget_set_size_request (GTK_WIDGET (export_ctree), 300, 200);
}
- if (!GTK_WIDGET_VISIBLE (export_window))
+ if (!gtk_widget_get_visible (export_window))
gtk_widget_show_all (export_window);
gtk_clist_clear (GTK_CLIST (export_ctree));
i = gtk_option_menu_get_history (GTK_OPTION_MENU (widget));
- gtk_clist_set_selection_mode (GTK_CLIST (ctree), (GtkSelectionMode) i);
+ gtk_clist_set_selection_mode (GTK_CLIST (ctree), selection_modes[i]);
after_press (ctree, NULL);
}
gchar buf1[60];
gchar buf2[60];
GtkCTreeNode *sibling;
+ CTreePixmaps *pixmaps;
gint i;
text[0] = buf1;
text[1] = buf2;
sibling = NULL;
+ pixmaps = get_ctree_pixmaps (ctree);
+
for (i = num_pages + num_books; i > num_books; i--)
{
pages++;
sprintf (buf1, "Page %02d", (gint) rand() % 100);
sprintf (buf2, "Item %d-%d", cur_depth, i);
sibling = gtk_ctree_insert_node (ctree, parent, sibling, text, 5,
- pixmap3, mask3, NULL, NULL,
+ pixmaps->pixmap3, pixmaps->mask3, NULL, NULL,
TRUE, FALSE);
if (parent && ctree->line_style == GTK_CTREE_LINES_TABBED)
sprintf (buf1, "Book %02d", (gint) rand() % 100);
sprintf (buf2, "Item %d-%d", cur_depth, i);
sibling = gtk_ctree_insert_node (ctree, parent, sibling, text, 5,
- pixmap1, mask1, pixmap2, mask2,
+ pixmaps->pixmap1, pixmaps->mask1, pixmaps->pixmap2, pixmaps->mask2,
FALSE, FALSE);
style = gtk_style_new ();
break;
}
gtk_ctree_node_set_row_data_full (ctree, sibling, style,
- (GtkDestroyNotify) gtk_style_unref);
+ (GDestroyNotify) g_object_unref);
if (ctree->line_style == GTK_CTREE_LINES_TABBED)
gtk_ctree_node_set_row_style (ctree, sibling, style);
GtkCTreeNode *parent;
GtkStyle *style;
guint b, d, p, n;
+ CTreePixmaps *pixmaps;
+
+ pixmaps = get_ctree_pixmaps (ctree);
text[0] = label1;
text[1] = label2;
books = 1;
pages = 0;
- parent = gtk_ctree_insert_node (ctree, NULL, NULL, text, 5, pixmap1,
- mask1, pixmap2, mask2, FALSE, TRUE);
+ parent = gtk_ctree_insert_node (ctree, NULL, NULL, text, 5, pixmaps->pixmap1,
+ pixmaps->mask1, pixmaps->pixmap2, pixmaps->mask2, FALSE, TRUE);
style = gtk_style_new ();
style->base[GTK_STATE_NORMAL].red = 0;
style->base[GTK_STATE_NORMAL].green = 45000;
style->base[GTK_STATE_NORMAL].blue = 55000;
gtk_ctree_node_set_row_data_full (ctree, parent, style,
- (GtkDestroyNotify) gtk_style_unref);
+ (GDestroyNotify) g_object_unref);
if (ctree->line_style == GTK_CTREE_LINES_TABBED)
gtk_ctree_node_set_row_style (ctree, parent, style);
gtk_ctree_sort_recursive (ctree, NULL);
}
-void create_ctree (void)
+void create_ctree (GtkWidget *widget)
{
static GtkWidget *window = NULL;
GtkTooltips *tooltips;
GtkWidget *check;
GtkAdjustment *adj;
GtkWidget *spinner;
- GdkColor transparent = { 0 };
char *title[] = { "Tree" , "Info" };
char buf[80];
"Right"
};
- static gchar *items4[] =
- {
- "Single",
- "Browse",
- "Multiple",
- };
-
if (!window)
{
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+ gtk_window_set_screen (GTK_WINDOW (window),
+ gtk_widget_get_screen (widget));
- gtk_signal_connect (GTK_OBJECT (window), "destroy",
- GTK_SIGNAL_FUNC (gtk_widget_destroyed),
- &window);
+ g_signal_connect (window, "destroy",
+ G_CALLBACK (gtk_widget_destroyed),
+ &window);
gtk_window_set_title (GTK_WINDOW (window), "GtkCTree");
gtk_container_set_border_width (GTK_CONTAINER (window), 0);
tooltips = gtk_tooltips_new ();
- gtk_object_ref (GTK_OBJECT (tooltips));
+ g_object_ref (tooltips);
gtk_object_sink (GTK_OBJECT (tooltips));
- gtk_object_set_data_full (GTK_OBJECT (window), "tooltips", tooltips,
- (GtkDestroyNotify) gtk_object_unref);
+ g_object_set_data_full (G_OBJECT (window), "tooltips", tooltips,
+ g_object_unref);
vbox = gtk_vbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER (window), vbox);
button = gtk_button_new_with_label ("Close");
gtk_box_pack_end (GTK_BOX (hbox), button, TRUE, TRUE, 0);
- gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
- (GtkSignalFunc) gtk_widget_destroy,
- GTK_OBJECT(window));
+ g_signal_connect_swapped (button, "clicked",
+ G_CALLBACK (gtk_widget_destroy),
+ window);
button = gtk_button_new_with_label ("Rebuild Tree");
gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
gtk_ctree_set_line_style (ctree, GTK_CTREE_LINES_DOTTED);
line_style = GTK_CTREE_LINES_DOTTED;
- gtk_signal_connect (GTK_OBJECT (button), "clicked",
- GTK_SIGNAL_FUNC (rebuild_tree), ctree);
- gtk_signal_connect (GTK_OBJECT (ctree), "click_column",
- (GtkSignalFunc) ctree_click_column, NULL);
-
- gtk_signal_connect_after (GTK_OBJECT (ctree), "button_press_event",
- GTK_SIGNAL_FUNC (after_press), NULL);
- gtk_signal_connect_after (GTK_OBJECT (ctree), "button_release_event",
- GTK_SIGNAL_FUNC (after_press), NULL);
- gtk_signal_connect_after (GTK_OBJECT (ctree), "tree_move",
- GTK_SIGNAL_FUNC (after_move), NULL);
- gtk_signal_connect_after (GTK_OBJECT (ctree), "end_selection",
- GTK_SIGNAL_FUNC (after_press), NULL);
- gtk_signal_connect_after (GTK_OBJECT (ctree), "toggle_focus_row",
- GTK_SIGNAL_FUNC (after_press), NULL);
- gtk_signal_connect_after (GTK_OBJECT (ctree), "select_all",
- GTK_SIGNAL_FUNC (after_press), NULL);
- gtk_signal_connect_after (GTK_OBJECT (ctree), "unselect_all",
- GTK_SIGNAL_FUNC (after_press), NULL);
- gtk_signal_connect_after (GTK_OBJECT (ctree), "scroll_vertical",
- GTK_SIGNAL_FUNC (after_press), NULL);
+ g_signal_connect (button, "clicked",
+ G_CALLBACK (rebuild_tree), ctree);
+ g_signal_connect (ctree, "click_column",
+ G_CALLBACK (ctree_click_column), NULL);
+
+ g_signal_connect_after (ctree, "button_press_event",
+ G_CALLBACK (after_press), NULL);
+ g_signal_connect_after (ctree, "button_release_event",
+ G_CALLBACK (after_press), NULL);
+ g_signal_connect_after (ctree, "tree_move",
+ G_CALLBACK (after_move), NULL);
+ g_signal_connect_after (ctree, "end_selection",
+ G_CALLBACK (after_press), NULL);
+ g_signal_connect_after (ctree, "toggle_focus_row",
+ G_CALLBACK (after_press), NULL);
+ g_signal_connect_after (ctree, "select_all",
+ G_CALLBACK (after_press), NULL);
+ g_signal_connect_after (ctree, "unselect_all",
+ G_CALLBACK (after_press), NULL);
+ g_signal_connect_after (ctree, "scroll_vertical",
+ G_CALLBACK (after_press), NULL);
bbox = gtk_hbox_new (FALSE, 5);
gtk_container_set_border_width (GTK_CONTAINER (bbox), 5);
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);
+ g_signal_connect (adj, "value_changed",
+ G_CALLBACK (change_row_height), ctree);
gtk_clist_set_row_height ( GTK_CLIST (ctree), adj->value);
adj = (GtkAdjustment *) gtk_adjustment_new (20, 0, 60, 1, 10, 0);
spinner = gtk_spin_button_new (adj, 0, 0);
gtk_box_pack_start (GTK_BOX (mbox), spinner, FALSE, FALSE, 5);
gtk_tooltips_set_tip (tooltips, spinner, "Tree Indentation.", NULL);
- gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
- GTK_SIGNAL_FUNC (change_indent), ctree);
+ g_signal_connect (adj, "value_changed",
+ G_CALLBACK (change_indent), ctree);
adj = (GtkAdjustment *) gtk_adjustment_new (5, 0, 60, 1, 10, 0);
spinner = gtk_spin_button_new (adj, 0, 0);
gtk_box_pack_start (GTK_BOX (mbox), spinner, FALSE, FALSE, 5);
gtk_tooltips_set_tip (tooltips, spinner, "Tree Spacing.", NULL);
- gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
- GTK_SIGNAL_FUNC (change_spacing), ctree);
+ g_signal_connect (adj, "value_changed",
+ G_CALLBACK (change_spacing), ctree);
mbox = gtk_vbox_new (TRUE, 5);
gtk_box_pack_start (GTK_BOX (bbox), mbox, FALSE, TRUE, 0);
button = gtk_button_new_with_label ("Expand All");
gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
- gtk_signal_connect (GTK_OBJECT (button), "clicked",
- GTK_SIGNAL_FUNC (expand_all), ctree);
+ g_signal_connect (button, "clicked",
+ G_CALLBACK (expand_all), ctree);
button = gtk_button_new_with_label ("Collapse All");
gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
- gtk_signal_connect (GTK_OBJECT (button), "clicked",
- GTK_SIGNAL_FUNC (collapse_all), ctree);
+ g_signal_connect (button, "clicked",
+ G_CALLBACK (collapse_all), ctree);
button = gtk_button_new_with_label ("Change Style");
gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
- gtk_signal_connect (GTK_OBJECT (button), "clicked",
- GTK_SIGNAL_FUNC (change_style), ctree);
+ g_signal_connect (button, "clicked",
+ G_CALLBACK (change_style), ctree);
button = gtk_button_new_with_label ("Export Tree");
gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
- gtk_signal_connect (GTK_OBJECT (button), "clicked",
- GTK_SIGNAL_FUNC (export_ctree), ctree);
+ g_signal_connect (button, "clicked",
+ G_CALLBACK (export_ctree), ctree);
hbox = gtk_hbox_new (FALSE, 5);
gtk_box_pack_start (GTK_BOX (mbox), hbox, FALSE, FALSE, 0);
button = gtk_button_new_with_label ("Select All");
gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
- gtk_signal_connect (GTK_OBJECT (button), "clicked",
- GTK_SIGNAL_FUNC (select_all), ctree);
+ g_signal_connect (button, "clicked",
+ G_CALLBACK (select_all), ctree);
button = gtk_button_new_with_label ("Unselect All");
gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
- gtk_signal_connect (GTK_OBJECT (button), "clicked",
- GTK_SIGNAL_FUNC (unselect_all), ctree);
+ g_signal_connect (button, "clicked",
+ G_CALLBACK (unselect_all), ctree);
button = gtk_button_new_with_label ("Remove Selection");
gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
- gtk_signal_connect (GTK_OBJECT (button), "clicked",
- GTK_SIGNAL_FUNC (remove_selection), ctree);
+ g_signal_connect (button, "clicked",
+ G_CALLBACK (remove_selection), ctree);
check = gtk_check_button_new_with_label ("Reorderable");
gtk_box_pack_start (GTK_BOX (hbox), check, FALSE, TRUE, 0);
gtk_tooltips_set_tip (tooltips, check,
"Tree items can be reordered by dragging.", NULL);
- gtk_signal_connect (GTK_OBJECT (check), "clicked",
- GTK_SIGNAL_FUNC (toggle_reorderable), ctree);
+ g_signal_connect (check, "clicked",
+ G_CALLBACK (toggle_reorderable), ctree);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check), TRUE);
hbox = gtk_hbox_new (TRUE, 5);
gtk_tooltips_set_tip (tooltips, omenu3, "The tree's justification.",
NULL);
- omenu4 = build_option_menu (items4, 3, 3,
+ omenu4 = build_option_menu (selection_mode_items, 3, 3,
ctree_toggle_sel_mode, ctree);
gtk_box_pack_start (GTK_BOX (hbox), omenu4, FALSE, TRUE, 0);
gtk_tooltips_set_tip (tooltips, omenu4, "The list's selection mode.",
NULL);
gtk_widget_realize (window);
-
- if (!pixmap1)
- pixmap1 = gdk_pixmap_create_from_xpm_d (window->window, &mask1,
- &transparent, book_closed_xpm);
- if (!pixmap2)
- pixmap2 = gdk_pixmap_create_from_xpm_d (window->window, &mask2,
- &transparent, book_open_xpm);
- if (!pixmap3)
- pixmap3 = gdk_pixmap_create_from_xpm_d (window->window, &mask3,
- &transparent, mini_page_xpm);
-
- gtk_widget_set_usize (GTK_WIDGET (ctree), 0, 300);
+
+ gtk_widget_set_size_request (GTK_WIDGET (ctree), -1, 300);
frame = gtk_frame_new (NULL);
gtk_container_set_border_width (GTK_CONTAINER (frame), 0);
rebuild_tree (NULL, ctree);
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
gtk_color_selection_get_color(colorsel,color);
}
+#if 0 /* unused */
static void
opacity_toggled_cb (GtkWidget *w,
GtkColorSelectionDialog *cs)
gtk_color_selection_set_has_palette (colorsel,
gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (w)));
}
+#endif
void
-create_color_selection (void)
+create_color_selection (GtkWidget *widget)
{
static GtkWidget *window = NULL;
if (!window)
{
- GtkWidget *options_hbox;
- GtkWidget *check_button;
+ GtkWidget *picker;
+ GtkWidget *hbox;
+ GtkWidget *label;
+ GtkWidget *button;
- window = gtk_color_selection_dialog_new ("color selection dialog");
- gtk_widget_show (GTK_COLOR_SELECTION_DIALOG (window)->help_button);
-
- gtk_window_set_position (GTK_WINDOW (window), GTK_WIN_POS_MOUSE);
+ window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+ gtk_window_set_screen (GTK_WINDOW (window),
+ gtk_widget_get_screen (widget));
+
+ g_signal_connect (window, "destroy",
+ G_CALLBACK (gtk_widget_destroyed),
+ &window);
- gtk_signal_connect (GTK_OBJECT (window), "destroy",
- GTK_SIGNAL_FUNC(gtk_widget_destroyed),
- &window);
+ gtk_window_set_title (GTK_WINDOW (window), "GtkColorButton");
+ gtk_container_set_border_width (GTK_CONTAINER (window), 0);
- 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);
+ hbox = gtk_hbox_new (FALSE, 8);
+ gtk_container_set_border_width (GTK_CONTAINER (hbox), 8);
+ gtk_container_add (GTK_CONTAINER (window), hbox);
- check_button = gtk_check_button_new_with_label ("Show Opacity");
- gtk_box_pack_start (GTK_BOX (options_hbox), check_button, FALSE, FALSE, 0);
- gtk_signal_connect (GTK_OBJECT (check_button), "toggled",
- GTK_SIGNAL_FUNC (opacity_toggled_cb), window);
-
- check_button = gtk_check_button_new_with_label ("Show Palette");
- gtk_box_pack_end (GTK_BOX (options_hbox), check_button, FALSE, FALSE, 0);
- gtk_signal_connect (GTK_OBJECT (check_button), "toggled",
- GTK_SIGNAL_FUNC (palette_toggled_cb), window);
-
- gtk_widget_show_all (options_hbox);
-
- gtk_signal_connect (
- GTK_OBJECT (GTK_COLOR_SELECTION_DIALOG (window)->colorsel),
- "color_changed",
- GTK_SIGNAL_FUNC(color_selection_changed),
- window);
+ label = gtk_label_new ("Pick a color");
+ gtk_container_add (GTK_CONTAINER (hbox), label);
- gtk_signal_connect (
- GTK_OBJECT (GTK_COLOR_SELECTION_DIALOG (window)->ok_button),
- "clicked",
- GTK_SIGNAL_FUNC(color_selection_ok),
- window);
+ picker = gtk_color_button_new ();
+ gtk_color_button_set_use_alpha (GTK_COLOR_BUTTON (picker), TRUE);
+ gtk_container_add (GTK_CONTAINER (hbox), picker);
- gtk_signal_connect_object (
- GTK_OBJECT (GTK_COLOR_SELECTION_DIALOG (window)->cancel_button),
- "clicked",
- GTK_SIGNAL_FUNC(gtk_widget_destroy),
- GTK_OBJECT (window));
+ button = gtk_button_new_with_mnemonic ("_Props");
+ gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0);
+ g_signal_connect (button, "clicked",
+ G_CALLBACK (props_clicked),
+ picker);
}
- if (!GTK_WIDGET_VISIBLE (window))
- gtk_widget_show (window);
+ if (!gtk_widget_get_visible (window))
+ gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
}
}
void
-create_file_selection (void)
+create_file_selection (GtkWidget *widget)
{
static GtkWidget *window = NULL;
GtkWidget *button;
if (!window)
{
window = gtk_file_selection_new ("file selection dialog");
+ gtk_window_set_screen (GTK_WINDOW (window),
+ gtk_widget_get_screen (widget));
gtk_file_selection_hide_fileop_buttons (GTK_FILE_SELECTION (window));
gtk_widget_show (button);
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
gtk_widget_show (window);
else
gtk_widget_destroy (window);
gtk_widget_set_default_direction (new_direction);
}
+static void
+orientable_toggle_orientation (GtkOrientable *orientable)
+{
+ GtkOrientation orientation;
+
+ orientation = gtk_orientable_get_orientation (orientable);
+ gtk_orientable_set_orientation (orientable,
+ orientation == GTK_ORIENTATION_HORIZONTAL ?
+ GTK_ORIENTATION_VERTICAL :
+ GTK_ORIENTATION_HORIZONTAL);
+
+ if (GTK_IS_CONTAINER (orientable))
+ {
+ GList *children;
+ GList *child;
+
+ children = gtk_container_get_children (GTK_CONTAINER (orientable));
+
+ for (child = children; child; child = child->next)
+ {
+ if (GTK_IS_ORIENTABLE (child->data))
+ orientable_toggle_orientation (child->data);
+ }
+
+ g_list_free (children);
+ }
+}
+
+void
+flipping_orientation_toggled_cb (GtkWidget *widget, gpointer data)
+{
+ orientable_toggle_orientation (GTK_ORIENTABLE (GTK_DIALOG (gtk_widget_get_toplevel (widget))->vbox));
+}
+
+static void
+set_direction_recurse (GtkWidget *widget,
+ gpointer data)
+{
+ GtkTextDirection *dir = data;
+
+ gtk_widget_set_direction (widget, *dir);
+ if (GTK_IS_CONTAINER (widget))
+ gtk_container_foreach (GTK_CONTAINER (widget),
+ set_direction_recurse,
+ data);
+}
+
+static GtkWidget *
+create_forward_back (const char *title,
+ GtkTextDirection text_dir)
+{
+ GtkWidget *frame = gtk_frame_new (title);
+ GtkWidget *bbox = gtk_hbutton_box_new ();
+ GtkWidget *back_button = gtk_button_new_from_stock (GTK_STOCK_GO_BACK);
+ GtkWidget *forward_button = gtk_button_new_from_stock (GTK_STOCK_GO_FORWARD);
+
+ gtk_container_set_border_width (GTK_CONTAINER (bbox), 5);
+
+ gtk_container_add (GTK_CONTAINER (frame), bbox);
+ gtk_container_add (GTK_CONTAINER (bbox), back_button);
+ gtk_container_add (GTK_CONTAINER (bbox), forward_button);
+
+ set_direction_recurse (frame, &text_dir);
+
+ return frame;
+}
+
void
-create_flipping (void)
+create_flipping (GtkWidget *widget)
{
static GtkWidget *window = NULL;
GtkWidget *check_button, *button;
{
window = gtk_dialog_new ();
- gtk_signal_connect (GTK_OBJECT (window), "destroy",
- GTK_SIGNAL_FUNC(gtk_widget_destroyed),
- &window);
+ gtk_window_set_screen (GTK_WINDOW (window),
+ gtk_widget_get_screen (widget));
+
+ g_signal_connect (window, "destroy",
+ G_CALLBACK (gtk_widget_destroyed),
+ &window);
gtk_window_set_title (GTK_WINDOW (window), "Bidirectional Flipping");
check_button = gtk_check_button_new_with_label ("Right-to-left global direction");
- gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox),
+ gtk_container_set_border_width (GTK_CONTAINER (check_button), 10);
+ 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);
+ g_signal_connect (check_button, "toggled",
+ G_CALLBACK (flipping_toggled_cb), NULL);
+ check_button = gtk_check_button_new_with_label ("Toggle orientation of all boxes");
gtk_container_set_border_width (GTK_CONTAINER (check_button), 10);
-
+ gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox),
+ check_button, TRUE, TRUE, 0);
+
+ g_signal_connect (check_button, "toggled",
+ G_CALLBACK (flipping_orientation_toggled_cb), NULL);
+
+ gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox),
+ create_forward_back ("Default", GTK_TEXT_DIR_NONE),
+ TRUE, TRUE, 0);
+
+ gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox),
+ create_forward_back ("Left-to-Right", GTK_TEXT_DIR_LTR),
+ TRUE, TRUE, 0);
+
+ gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox),
+ create_forward_back ("Right-to-Left", GTK_TEXT_DIR_RTL),
+ TRUE, TRUE, 0);
+
button = gtk_button_new_with_label ("Close");
- gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
- GTK_SIGNAL_FUNC (gtk_widget_destroy), GTK_OBJECT (window));
+ g_signal_connect_swapped (button, "clicked",
+ G_CALLBACK (gtk_widget_destroy), window);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
button, TRUE, TRUE, 0);
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
}
static void
-create_focus (void)
+create_focus (GtkWidget *widget)
{
static GtkWidget *window = NULL;
-
+
if (!window)
{
GtkWidget *table;
GTK_RESPONSE_NONE,
NULL);
- gtk_signal_connect (GTK_OBJECT (window), "destroy",
- GTK_SIGNAL_FUNC (gtk_widget_destroyed),
- &window);
+ gtk_window_set_screen (GTK_WINDOW (window),
+ gtk_widget_get_screen (widget));
+
+ g_signal_connect (window, "destroy",
+ G_CALLBACK (gtk_widget_destroyed),
+ &window);
- gtk_signal_connect (GTK_OBJECT (window), "response",
- GTK_SIGNAL_FUNC (gtk_widget_destroy),
- NULL);
+ g_signal_connect (window, "response",
+ G_CALLBACK (gtk_widget_destroy),
+ NULL);
gtk_window_set_title (GTK_WINDOW (window), "Keyboard Focus Navigation");
gtk_container_add (GTK_CONTAINER (frame), table);
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
}
void
-create_font_selection (void)
+create_font_selection (GtkWidget *widget)
{
static GtkWidget *window = NULL;
if (!window)
{
- window = gtk_font_selection_dialog_new ("Font Selection Dialog");
+ GtkWidget *picker;
+ GtkWidget *hbox;
+ GtkWidget *label;
+
+ window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+ gtk_window_set_screen (GTK_WINDOW (window),
+ gtk_widget_get_screen (widget));
- gtk_window_set_position (GTK_WINDOW (window), GTK_WIN_POS_MOUSE);
+ g_signal_connect (window, "destroy",
+ G_CALLBACK (gtk_widget_destroyed),
+ &window);
+
+ gtk_window_set_title (GTK_WINDOW (window), "GtkFontButton");
+ gtk_container_set_border_width (GTK_CONTAINER (window), 0);
- gtk_signal_connect (GTK_OBJECT (window), "destroy",
- GTK_SIGNAL_FUNC(gtk_widget_destroyed),
- &window);
+ hbox = gtk_hbox_new (FALSE, 8);
+ gtk_container_set_border_width (GTK_CONTAINER (hbox), 8);
+ gtk_container_add (GTK_CONTAINER (window), hbox);
+
+ label = gtk_label_new ("Pick a font");
+ gtk_container_add (GTK_CONTAINER (hbox), label);
- 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));
+ picker = gtk_font_button_new ();
+ gtk_font_button_set_use_font (GTK_FONT_BUTTON (picker), TRUE);
+ gtk_container_add (GTK_CONTAINER (hbox), picker);
}
- if (!GTK_WIDGET_VISIBLE (window))
- gtk_widget_show (window);
+ if (!gtk_widget_get_visible (window))
+ gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
}
if (!(*label))
{
*label = gtk_label_new ("Dialog Test");
- gtk_signal_connect (GTK_OBJECT (*label),
- "destroy",
- GTK_SIGNAL_FUNC (gtk_widget_destroyed),
- label);
+ g_signal_connect (*label,
+ "destroy",
+ G_CALLBACK (gtk_widget_destroyed),
+ label);
gtk_misc_set_padding (GTK_MISC (*label), 10, 10);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog_window)->vbox),
*label, TRUE, TRUE, 0);
}
static void
-create_dialog (void)
+create_dialog (GtkWidget *widget)
{
static GtkWidget *label;
GtkWidget *button;
*/
dialog_window = gtk_dialog_new ();
+ gtk_window_set_screen (GTK_WINDOW (dialog_window),
+ gtk_widget_get_screen (widget));
- gtk_signal_connect (GTK_OBJECT (dialog_window),
- "response",
- GTK_SIGNAL_FUNC (print_response),
- NULL);
+ g_signal_connect (dialog_window,
+ "response",
+ G_CALLBACK (print_response),
+ NULL);
- gtk_signal_connect (GTK_OBJECT (dialog_window), "destroy",
- GTK_SIGNAL_FUNC(gtk_widget_destroyed),
- &dialog_window);
+ g_signal_connect (dialog_window, "destroy",
+ G_CALLBACK (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_show (button);
button = gtk_button_new_with_label ("Toggle");
- gtk_signal_connect (GTK_OBJECT (button), "clicked",
- GTK_SIGNAL_FUNC (label_toggle),
- &label);
+ g_signal_connect (button, "clicked",
+ G_CALLBACK (label_toggle),
+ &label);
GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog_window)->action_area),
button, TRUE, TRUE, 0);
gtk_widget_show (button);
}
- if (!GTK_WIDGET_VISIBLE (dialog_window))
+ if (!gtk_widget_get_visible (dialog_window))
gtk_widget_show (dialog_window);
else
gtk_widget_destroy (dialog_window);
}
+/* Display & Screen test
+ */
+
+typedef struct
+{
+ GtkEntry *entry;
+ GtkWidget *radio_dpy;
+ GtkWidget *toplevel;
+ GtkWidget *dialog_window;
+ GList *valid_display_list;
+} ScreenDisplaySelection;
+
+static gint
+display_name_cmp (gconstpointer a,
+ gconstpointer b)
+{
+ return g_ascii_strcasecmp (a,b);
+}
+
+static void
+screen_display_check (GtkWidget *widget, ScreenDisplaySelection *data)
+{
+ char *display_name;
+ GdkDisplay *display = gtk_widget_get_display (widget);
+ GtkWidget *dialog;
+ GdkScreen *new_screen = NULL;
+ GdkScreen *current_screen = gtk_widget_get_screen (widget);
+
+ if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (data->radio_dpy)))
+ {
+ display_name = g_strdup (gtk_entry_get_text (data->entry));
+ display = gdk_display_open (display_name);
+
+ if (!display)
+ {
+ dialog = gtk_message_dialog_new (GTK_WINDOW (gtk_widget_get_toplevel (widget)),
+ GTK_DIALOG_DESTROY_WITH_PARENT,
+ GTK_MESSAGE_ERROR,
+ GTK_BUTTONS_OK,
+ "The display :\n%s\ncannot be opened",
+ display_name);
+ gtk_window_set_screen (GTK_WINDOW (dialog), current_screen);
+ gtk_widget_show (dialog);
+ g_signal_connect (dialog, "response",
+ G_CALLBACK (gtk_widget_destroy),
+ NULL);
+ }
+ else
+ {
+ if (!g_list_find_custom (data->valid_display_list,
+ display_name,
+ display_name_cmp))
+ data->valid_display_list = g_list_append (data->valid_display_list,
+ display_name);
+
+ new_screen = gdk_display_get_default_screen (display);
+ }
+ }
+ else
+ {
+ gint number_of_screens = gdk_display_get_n_screens (display);
+ gint screen_num = gdk_screen_get_number (current_screen);
+ if ((screen_num +1) < number_of_screens)
+ new_screen = gdk_display_get_screen (display, screen_num + 1);
+ else
+ new_screen = gdk_display_get_screen (display, 0);
+ }
+
+ if (new_screen)
+ {
+ gtk_window_set_screen (GTK_WINDOW (data->toplevel), new_screen);
+ gtk_widget_destroy (data->dialog_window);
+ }
+}
+
+void
+screen_display_destroy_diag (GtkWidget *widget, GtkWidget *data)
+{
+ gtk_widget_destroy (data);
+}
+
+void
+create_display_screen (GtkWidget *widget)
+{
+ GtkWidget *table, *frame, *window, *combo_dpy, *vbox;
+ GtkWidget *radio_dpy, *radio_scr, *applyb, *cancelb;
+ GtkWidget *bbox;
+ ScreenDisplaySelection *scr_dpy_data;
+ GdkScreen *screen = gtk_widget_get_screen (widget);
+ static GList *valid_display_list = NULL;
+
+ GdkDisplay *display = gdk_screen_get_display (screen);
+
+ window = g_object_new (gtk_window_get_type (),
+ "screen", screen,
+ "user_data", NULL,
+ "type", GTK_WINDOW_TOPLEVEL,
+ "title",
+ "Screen or Display selection",
+ "border_width", 10, NULL);
+ g_signal_connect (window, "destroy",
+ G_CALLBACK (gtk_widget_destroy), NULL);
+
+ vbox = gtk_vbox_new (FALSE, 3);
+ gtk_container_add (GTK_CONTAINER (window), vbox);
+
+ frame = gtk_frame_new ("Select screen or display");
+ gtk_container_add (GTK_CONTAINER (vbox), frame);
+
+ table = gtk_table_new (2, 2, TRUE);
+ gtk_table_set_row_spacings (GTK_TABLE (table), 3);
+ gtk_table_set_col_spacings (GTK_TABLE (table), 3);
+
+ gtk_container_add (GTK_CONTAINER (frame), table);
+
+ radio_dpy = gtk_radio_button_new_with_label (NULL, "move to another X display");
+ if (gdk_display_get_n_screens(display) > 1)
+ radio_scr = gtk_radio_button_new_with_label
+ (gtk_radio_button_get_group (GTK_RADIO_BUTTON (radio_dpy)), "move to next screen");
+ else
+ {
+ radio_scr = gtk_radio_button_new_with_label
+ (gtk_radio_button_get_group (GTK_RADIO_BUTTON (radio_dpy)),
+ "only one screen on the current display");
+ gtk_widget_set_sensitive (radio_scr, FALSE);
+ }
+ combo_dpy = gtk_combo_new ();
+ if (!valid_display_list)
+ valid_display_list = g_list_append (valid_display_list, "diabolo:0.0");
+
+ gtk_combo_set_popdown_strings (GTK_COMBO (combo_dpy), valid_display_list);
+
+ gtk_entry_set_text (GTK_ENTRY (GTK_COMBO (combo_dpy)->entry),
+ "<hostname>:<X Server Num>.<Screen Num>");
+
+ gtk_table_attach_defaults (GTK_TABLE (table), radio_dpy, 0, 1, 0, 1);
+ gtk_table_attach_defaults (GTK_TABLE (table), radio_scr, 0, 1, 1, 2);
+ gtk_table_attach_defaults (GTK_TABLE (table), combo_dpy, 1, 2, 0, 1);
+
+ bbox = gtk_hbutton_box_new ();
+ applyb = gtk_button_new_from_stock (GTK_STOCK_APPLY);
+ cancelb = gtk_button_new_from_stock (GTK_STOCK_CANCEL);
+
+ gtk_container_add (GTK_CONTAINER (vbox), bbox);
+
+ gtk_container_add (GTK_CONTAINER (bbox), applyb);
+ gtk_container_add (GTK_CONTAINER (bbox), cancelb);
+
+ scr_dpy_data = g_new0 (ScreenDisplaySelection, 1);
+
+ scr_dpy_data->entry = GTK_ENTRY (GTK_COMBO (combo_dpy)->entry);
+ scr_dpy_data->radio_dpy = radio_dpy;
+ scr_dpy_data->toplevel = gtk_widget_get_toplevel (widget);
+ scr_dpy_data->dialog_window = window;
+ scr_dpy_data->valid_display_list = valid_display_list;
+
+ g_signal_connect (cancelb, "clicked",
+ G_CALLBACK (screen_display_destroy_diag), window);
+ g_signal_connect (applyb, "clicked",
+ G_CALLBACK (screen_display_check), scr_dpy_data);
+ gtk_widget_show_all (window);
+}
+
/* Event Watcher
*/
static gboolean event_watcher_enter_id = 0;
gpointer data)
{
g_print ("Watch: \"%s\" emitted for %s\n",
- gtk_signal_name (ihint->signal_id),
- gtk_type_name (GTK_OBJECT_TYPE (g_value_get_object (param_values + 0))));
+ g_signal_name (ihint->signal_id),
+ G_OBJECT_TYPE_NAME (g_value_get_object (param_values + 0)));
return TRUE;
}
{
guint signal_id;
- signal_id = gtk_signal_lookup ("enter_notify_event", GTK_TYPE_WIDGET);
+ signal_id = g_signal_lookup ("enter_notify_event", GTK_TYPE_WIDGET);
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);
+ signal_id = g_signal_lookup ("leave_notify_event", GTK_TYPE_WIDGET);
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);
+ signal_id = g_signal_lookup ("enter_notify_event", GTK_TYPE_WIDGET);
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);
+ signal_id = g_signal_lookup ("leave_notify_event", GTK_TYPE_WIDGET);
event_watcher_leave_id = g_signal_add_emission_hook (signal_id, 0, event_watcher, NULL, NULL);
}
}
static void
-create_event_watcher (void)
+create_event_watcher (GtkWidget *widget)
{
GtkWidget *button;
if (!dialog_window)
{
dialog_window = gtk_dialog_new ();
+ gtk_window_set_screen (GTK_WINDOW (dialog_window),
+ gtk_widget_get_screen (widget));
- gtk_signal_connect (GTK_OBJECT (dialog_window), "destroy",
- GTK_SIGNAL_FUNC (gtk_widget_destroyed),
- &dialog_window);
- gtk_signal_connect (GTK_OBJECT (dialog_window),
- "destroy",
- GTK_SIGNAL_FUNC (event_watcher_down),
- NULL);
+ g_signal_connect (dialog_window, "destroy",
+ G_CALLBACK (gtk_widget_destroyed),
+ &dialog_window);
+ g_signal_connect (dialog_window, "destroy",
+ G_CALLBACK (event_watcher_down),
+ NULL);
gtk_window_set_title (GTK_WINDOW (dialog_window), "Event Watcher");
gtk_container_set_border_width (GTK_CONTAINER (dialog_window), 0);
- gtk_widget_set_usize (dialog_window, 200, 110);
+ gtk_widget_set_size_request (dialog_window, 200, 110);
button = gtk_toggle_button_new_with_label ("Activate Watch");
- gtk_signal_connect (GTK_OBJECT (button), "clicked",
- GTK_SIGNAL_FUNC (event_watcher_toggle),
- NULL);
+ g_signal_connect (button, "clicked",
+ G_CALLBACK (event_watcher_toggle),
+ NULL);
gtk_container_set_border_width (GTK_CONTAINER (button), 10);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog_window)->vbox),
button, TRUE, TRUE, 0);
gtk_widget_show (button);
button = gtk_button_new_with_label ("Close");
- gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
- GTK_SIGNAL_FUNC (gtk_widget_destroy),
- (GtkObject*) dialog_window);
+ g_signal_connect_swapped (button, "clicked",
+ G_CALLBACK (gtk_widget_destroy),
+ dialog_window);
GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog_window)->action_area),
button, TRUE, TRUE, 0);
gtk_widget_show (button);
}
- if (!GTK_WIDGET_VISIBLE (dialog_window))
+ if (!gtk_widget_get_visible (dialog_window))
gtk_widget_show (dialog_window);
else
gtk_widget_destroy (dialog_window);
}
static void
-create_range_controls (void)
+create_range_controls (GtkWidget *widget)
{
static GtkWidget *window = NULL;
GtkWidget *box1;
{
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
- gtk_signal_connect (GTK_OBJECT (window), "destroy",
- GTK_SIGNAL_FUNC(gtk_widget_destroyed),
- &window);
+ gtk_window_set_screen (GTK_WINDOW (window),
+ gtk_widget_get_screen (widget));
+
+ g_signal_connect (window, "destroy",
+ G_CALLBACK (gtk_widget_destroyed),
+ &window);
gtk_window_set_title (GTK_WINDOW (window), "range controls");
gtk_container_set_border_width (GTK_CONTAINER (window), 0);
adjustment = gtk_adjustment_new (0.0, 0.0, 101.0, 0.1, 1.0, 1.0);
scale = gtk_hscale_new (GTK_ADJUSTMENT (adjustment));
- gtk_widget_set_usize (GTK_WIDGET (scale), 150, -1);
+ gtk_widget_set_size_request (GTK_WIDGET (scale), 150, -1);
gtk_range_set_update_policy (GTK_RANGE (scale), GTK_UPDATE_DELAYED);
gtk_scale_set_digits (GTK_SCALE (scale), 1);
gtk_scale_set_draw_value (GTK_SCALE (scale), TRUE);
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);
+ g_signal_connect (scale,
+ "format_value",
+ G_CALLBACK (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_widget_set_size_request (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_widget_set_size_request (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);
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);
+ g_signal_connect (scale,
+ "format_value",
+ G_CALLBACK (reformat_value),
+ NULL);
gtk_box_pack_start (GTK_BOX (hbox), scale, TRUE, TRUE, 0);
gtk_widget_show (scale);
button = gtk_button_new_with_label ("close");
- gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
- GTK_SIGNAL_FUNC(gtk_widget_destroy),
- GTK_OBJECT (window));
+ g_signal_connect_swapped (button, "clicked",
+ G_CALLBACK (gtk_widget_destroy),
+ 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))
+ if (!gtk_widget_get_visible (window))
gtk_widget_show (window);
else
gtk_widget_destroy (window);
*/
void
-create_rulers (void)
+create_rulers (GtkWidget *widget)
{
static GtkWidget *window = NULL;
GtkWidget *table;
if (!window)
{
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
- gtk_window_set_policy (GTK_WINDOW (window), TRUE, TRUE, FALSE);
- gtk_signal_connect (GTK_OBJECT (window), "destroy",
- GTK_SIGNAL_FUNC(gtk_widget_destroyed),
- &window);
+ gtk_window_set_screen (GTK_WINDOW (window),
+ gtk_widget_get_screen (widget));
+
+ g_object_set (window, "allow_shrink", TRUE, "allow_grow", TRUE, NULL);
+
+ g_signal_connect (window, "destroy",
+ G_CALLBACK (gtk_widget_destroyed),
+ &window);
gtk_window_set_title (GTK_WINDOW (window), "rulers");
- gtk_widget_set_usize (window, 300, 300);
+ gtk_widget_set_size_request (window, 300, 300);
gtk_widget_set_events (window,
GDK_POINTER_MOTION_MASK
| GDK_POINTER_MOTION_HINT_MASK);
gtk_ruler_set_metric (GTK_RULER (ruler), GTK_CENTIMETERS);
gtk_ruler_set_range (GTK_RULER (ruler), 100, 0, 0, 20);
- gtk_signal_connect_object (GTK_OBJECT (window),
- "motion_notify_event",
- GTK_SIGNAL_FUNC (GTK_WIDGET_GET_CLASS (ruler)->motion_notify_event),
- GTK_OBJECT (ruler));
+ g_signal_connect_swapped (window,
+ "motion_notify_event",
+ G_CALLBACK (GTK_WIDGET_GET_CLASS (ruler)->motion_notify_event),
+ ruler);
gtk_table_attach (GTK_TABLE (table), ruler, 1, 2, 0, 1,
GTK_EXPAND | GTK_FILL, GTK_FILL, 0, 0);
ruler = gtk_vruler_new ();
gtk_ruler_set_range (GTK_RULER (ruler), 5, 15, 0, 20);
- gtk_signal_connect_object (GTK_OBJECT (window),
- "motion_notify_event",
- GTK_SIGNAL_FUNC (GTK_WIDGET_GET_CLASS (ruler)->motion_notify_event),
- GTK_OBJECT (ruler));
+ g_signal_connect_swapped (window,
+ "motion_notify_event",
+ G_CALLBACK (GTK_WIDGET_GET_CLASS (ruler)->motion_notify_event),
+ ruler);
gtk_table_attach (GTK_TABLE (table), ruler, 0, 1, 1, 2,
GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
gtk_widget_show (ruler);
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
gtk_widget_show (window);
else
gtk_widget_destroy (window);
}
void
-create_text (void)
+create_text (GtkWidget *widget)
{
int i, j;
if (!window)
{
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+ gtk_window_set_screen (GTK_WINDOW (window),
+ gtk_widget_get_screen (widget));
+
gtk_widget_set_name (window, "text window");
- gtk_widget_set_usize (window, 500, 500);
- gtk_window_set_policy (GTK_WINDOW(window), TRUE, TRUE, FALSE);
+ g_object_set (window, "allow_shrink", TRUE, "allow_grow", TRUE, NULL);
+ gtk_widget_set_size_request (window, 500, 500);
- gtk_signal_connect (GTK_OBJECT (window), "destroy",
- GTK_SIGNAL_FUNC(gtk_widget_destroyed),
- &window);
+ g_signal_connect (window, "destroy",
+ G_CALLBACK (gtk_widget_destroyed),
+ &window);
gtk_window_set_title (GTK_WINDOW (window), "test");
gtk_container_set_border_width (GTK_CONTAINER (window), 0);
check = gtk_check_button_new_with_label("Editable");
gtk_box_pack_start (GTK_BOX (hbox), check, FALSE, FALSE, 0);
- gtk_signal_connect (GTK_OBJECT(check), "toggled",
- GTK_SIGNAL_FUNC(text_toggle_editable), text);
+ g_signal_connect (check, "toggled",
+ G_CALLBACK (text_toggle_editable), text);
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);
+ g_signal_connect (check, "toggled",
+ G_CALLBACK (text_toggle_word_wrap), text);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check), FALSE);
gtk_widget_show (check);
button = gtk_button_new_with_label ("insert random");
- gtk_signal_connect (GTK_OBJECT (button), "clicked",
- GTK_SIGNAL_FUNC(text_insert_random),
- GTK_TEXT (text));
+ g_signal_connect (button, "clicked",
+ G_CALLBACK (text_insert_random),
+ text);
gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
gtk_widget_show (button);
button = gtk_button_new_with_label ("close");
- gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
- GTK_SIGNAL_FUNC(gtk_widget_destroy),
- GTK_OBJECT (window));
+ g_signal_connect_swapped (button, "clicked",
+ G_CALLBACK (gtk_widget_destroy),
+ 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))
+ if (!gtk_widget_get_visible (window))
gtk_widget_show (window);
else
gtk_widget_destroy (window);
* GtkNotebook
*/
-GdkPixmap *book_open;
-GdkPixmap *book_closed;
-GdkBitmap *book_open_mask;
-GdkBitmap *book_closed_mask;
+GdkPixbuf *book_open;
+GdkPixbuf *book_closed;
GtkWidget *sample_notebook;
static void
-set_page_pixmaps (GtkNotebook *notebook, gint page_num,
- GdkPixmap *pixmap, GdkPixmap *mask)
+set_page_image (GtkNotebook *notebook, gint page_num, GdkPixbuf *pixbuf)
{
GtkWidget *page_widget;
GtkWidget *pixwid;
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 = g_object_get_data (G_OBJECT (page_widget), "tab_pixmap");
+ gtk_image_set_from_pixbuf (GTK_IMAGE (pixwid), pixbuf);
- pixwid = gtk_object_get_data (GTK_OBJECT (page_widget), "menu_pixmap");
- gtk_pixmap_set (GTK_PIXMAP (pixwid), pixmap, mask);
+ pixwid = g_object_get_data (G_OBJECT (page_widget), "menu_pixmap");
+ gtk_image_set_from_pixbuf (GTK_IMAGE (pixwid), pixbuf);
}
static void
if (page_num == old_page_num)
return;
- set_page_pixmaps (notebook, page_num, book_open, book_open_mask);
+ set_page_image (notebook, page_num, book_open);
if (old_page_num != -1)
- set_page_pixmaps (notebook, old_page_num, book_closed, book_closed_mask);
+ set_page_image (notebook, old_page_num, book_closed);
}
static void
button = gtk_check_button_new_with_label ("Fill Tab");
gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
- gtk_signal_connect (GTK_OBJECT (button), "toggled",
- GTK_SIGNAL_FUNC (tab_fill), child);
+ g_signal_connect (button, "toggled",
+ G_CALLBACK (tab_fill), child);
button = gtk_check_button_new_with_label ("Expand Tab");
gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
- gtk_signal_connect (GTK_OBJECT (button), "toggled",
- GTK_SIGNAL_FUNC (tab_expand), child);
+ g_signal_connect (button, "toggled",
+ G_CALLBACK (tab_expand), child);
button = gtk_check_button_new_with_label ("Pack end");
gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
- gtk_signal_connect (GTK_OBJECT (button), "toggled",
- GTK_SIGNAL_FUNC (tab_pack), child);
+ g_signal_connect (button, "toggled",
+ G_CALLBACK (tab_pack), child);
button = gtk_button_new_with_label ("Hide Page");
gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 5);
- gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
- GTK_SIGNAL_FUNC (gtk_widget_hide),
- GTK_OBJECT (child));
+ g_signal_connect_swapped (button, "clicked",
+ G_CALLBACK (gtk_widget_hide),
+ child);
gtk_widget_show_all (child);
label_box = gtk_hbox_new (FALSE, 0);
- pixwid = gtk_pixmap_new (book_closed, book_closed_mask);
- gtk_object_set_data (GTK_OBJECT (child), "tab_pixmap", pixwid);
+ pixwid = gtk_image_new_from_pixbuf (book_closed);
+ g_object_set_data (G_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);
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);
+ pixwid = gtk_image_new_from_pixbuf (book_closed);
+ g_object_set_data (G_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);
notebook_homogeneous (GtkToggleButton *button,
GtkNotebook *notebook)
{
- gtk_notebook_set_homogeneous_tabs (notebook, button->active);
+ g_object_set (notebook, "homogeneous", button->active, NULL);
}
static void
-create_notebook (void)
+create_notebook (GtkWidget *widget)
{
static GtkWidget *window = NULL;
GtkWidget *box1;
GtkWidget *button;
GtkWidget *separator;
GtkWidget *omenu;
- GdkColor *transparent = NULL;
GtkWidget *label;
static gchar *items[] =
"Borderless",
"Scrollable"
};
-
+
if (!window)
{
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+ gtk_window_set_screen (GTK_WINDOW (window),
+ gtk_widget_get_screen (widget));
- gtk_signal_connect (GTK_OBJECT (window), "destroy",
- GTK_SIGNAL_FUNC(gtk_widget_destroyed),
- &window);
+ g_signal_connect (window, "destroy",
+ G_CALLBACK (gtk_widget_destroyed),
+ &window);
gtk_window_set_title (GTK_WINDOW (window), "notebook");
gtk_container_set_border_width (GTK_CONTAINER (window), 0);
gtk_container_add (GTK_CONTAINER (window), box1);
sample_notebook = gtk_notebook_new ();
- gtk_signal_connect (GTK_OBJECT (sample_notebook), "switch_page",
- GTK_SIGNAL_FUNC (page_switch), NULL);
+ g_signal_connect (sample_notebook, "switch_page",
+ G_CALLBACK (page_switch), NULL);
gtk_notebook_set_tab_pos (GTK_NOTEBOOK (sample_notebook), GTK_POS_TOP);
gtk_box_pack_start (GTK_BOX (box1), sample_notebook, TRUE, TRUE, 0);
gtk_container_set_border_width (GTK_CONTAINER (sample_notebook), 10);
gtk_widget_realize (sample_notebook);
+
if (!book_open)
- book_open = gdk_pixmap_create_from_xpm_d (sample_notebook->window,
- &book_open_mask,
- transparent,
- book_open_xpm);
+ book_open = gdk_pixbuf_new_from_xpm_data ((const char **)book_open_xpm);
+
if (!book_closed)
- book_closed = gdk_pixmap_create_from_xpm_d (sample_notebook->window,
- &book_closed_mask,
- transparent,
- book_closed_xpm);
+ book_closed = gdk_pixbuf_new_from_xpm_data ((const char **)book_closed_xpm);
create_pages (GTK_NOTEBOOK (sample_notebook), 1, 5);
button = gtk_check_button_new_with_label ("popup menu");
gtk_box_pack_start (GTK_BOX (box2), button, TRUE, FALSE, 0);
- gtk_signal_connect (GTK_OBJECT(button), "clicked",
- GTK_SIGNAL_FUNC (notebook_popup),
- GTK_OBJECT (sample_notebook));
+ g_signal_connect (button, "clicked",
+ G_CALLBACK (notebook_popup),
+ sample_notebook);
button = gtk_check_button_new_with_label ("homogeneous tabs");
gtk_box_pack_start (GTK_BOX (box2), button, TRUE, FALSE, 0);
- gtk_signal_connect (GTK_OBJECT(button), "clicked",
- GTK_SIGNAL_FUNC (notebook_homogeneous),
- GTK_OBJECT (sample_notebook));
+ g_signal_connect (button, "clicked",
+ G_CALLBACK (notebook_homogeneous),
+ sample_notebook);
box2 = gtk_hbox_new (FALSE, 5);
gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
button = gtk_button_new_with_label ("Show all Pages");
gtk_box_pack_start (GTK_BOX (box2), button, FALSE, TRUE, 0);
- gtk_signal_connect (GTK_OBJECT (button), "clicked",
- GTK_SIGNAL_FUNC (show_all_pages), sample_notebook);
+ g_signal_connect (button, "clicked",
+ G_CALLBACK (show_all_pages), sample_notebook);
box2 = gtk_hbox_new (TRUE, 10);
gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
button = gtk_button_new_with_label ("prev");
- gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
- GTK_SIGNAL_FUNC (gtk_notebook_prev_page),
- GTK_OBJECT (sample_notebook));
+ g_signal_connect_swapped (button, "clicked",
+ G_CALLBACK (gtk_notebook_prev_page),
+ sample_notebook);
gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
button = gtk_button_new_with_label ("next");
- gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
- GTK_SIGNAL_FUNC (gtk_notebook_next_page),
- GTK_OBJECT (sample_notebook));
+ g_signal_connect_swapped (button, "clicked",
+ G_CALLBACK (gtk_notebook_next_page),
+ sample_notebook);
gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
button = gtk_button_new_with_label ("rotate");
- gtk_signal_connect (GTK_OBJECT (button), "clicked",
- GTK_SIGNAL_FUNC (rotate_notebook), sample_notebook);
+ g_signal_connect (button, "clicked",
+ G_CALLBACK (rotate_notebook), sample_notebook);
gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
separator = gtk_hseparator_new ();
button = gtk_button_new_with_label ("close");
gtk_container_set_border_width (GTK_CONTAINER (button), 5);
- gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
- GTK_SIGNAL_FUNC (gtk_widget_destroy),
- GTK_OBJECT (window));
+ g_signal_connect_swapped (button, "clicked",
+ G_CALLBACK (gtk_widget_destroy),
+ window);
gtk_box_pack_start (GTK_BOX (box1), button, FALSE, FALSE, 0);
GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
gtk_widget_grab_default (button);
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
void
toggle_resize (GtkWidget *widget, GtkWidget *child)
{
- GtkPaned *paned = GTK_PANED (child->parent);
- gboolean is_child1 = (child == paned->child1);
- gboolean resize, shrink;
-
- resize = is_child1 ? paned->child1_resize : paned->child2_resize;
- shrink = is_child1 ? paned->child1_shrink : paned->child2_shrink;
-
- gtk_widget_ref (child);
- gtk_container_remove (GTK_CONTAINER (child->parent), child);
- if (is_child1)
- gtk_paned_pack1 (paned, child, !resize, shrink);
- else
- gtk_paned_pack2 (paned, child, !resize, shrink);
- gtk_widget_unref (child);
+ GtkContainer *container = GTK_CONTAINER (gtk_widget_get_parent (child));
+ GValue value = { 0, };
+ g_value_init (&value, G_TYPE_BOOLEAN);
+ gtk_container_child_get_property (container, child, "resize", &value);
+ g_value_set_boolean (&value, !g_value_get_boolean (&value));
+ gtk_container_child_set_property (container, child, "resize", &value);
}
void
toggle_shrink (GtkWidget *widget, GtkWidget *child)
{
- GtkPaned *paned = GTK_PANED (child->parent);
- gboolean is_child1 = (child == paned->child1);
- gboolean resize, shrink;
-
- resize = is_child1 ? paned->child1_resize : paned->child2_resize;
- shrink = is_child1 ? paned->child1_shrink : paned->child2_shrink;
-
- gtk_widget_ref (child);
- gtk_container_remove (GTK_CONTAINER (child->parent), child);
- if (is_child1)
- gtk_paned_pack1 (paned, child, resize, !shrink);
- else
- gtk_paned_pack2 (paned, child, resize, !shrink);
- gtk_widget_unref (child);
+ GtkContainer *container = GTK_CONTAINER (gtk_widget_get_parent (child));
+ GValue value = { 0, };
+ g_value_init (&value, G_TYPE_BOOLEAN);
+ gtk_container_child_get_property (container, child, "shrink", &value);
+ g_value_set_boolean (&value, !g_value_get_boolean (&value));
+ gtk_container_child_set_property (container, child, "shrink", &value);
}
static void
GObject *paned)
{
GtkWidget *window = create_prop_editor (paned, GTK_TYPE_PANED);
-
+
gtk_window_set_title (GTK_WINDOW (window), "Paned Properties");
}
check_button = gtk_check_button_new_with_label ("Resize");
gtk_table_attach_defaults (GTK_TABLE (table), check_button,
0, 1, 1, 2);
- gtk_signal_connect (GTK_OBJECT (check_button), "toggled",
- GTK_SIGNAL_FUNC (toggle_resize),
- paned->child1);
+ g_signal_connect (check_button, "toggled",
+ G_CALLBACK (toggle_resize),
+ paned->child1);
check_button = gtk_check_button_new_with_label ("Shrink");
gtk_table_attach_defaults (GTK_TABLE (table), check_button,
0, 1, 2, 3);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check_button),
TRUE);
- gtk_signal_connect (GTK_OBJECT (check_button), "toggled",
- GTK_SIGNAL_FUNC (toggle_shrink),
- paned->child1);
+ g_signal_connect (check_button, "toggled",
+ G_CALLBACK (toggle_shrink),
+ paned->child1);
label = gtk_label_new (label2);
gtk_table_attach_defaults (GTK_TABLE (table), label,
1, 2, 1, 2);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check_button),
TRUE);
- gtk_signal_connect (GTK_OBJECT (check_button), "toggled",
- GTK_SIGNAL_FUNC (toggle_resize),
- paned->child2);
+ g_signal_connect (check_button, "toggled",
+ G_CALLBACK (toggle_resize),
+ paned->child2);
check_button = gtk_check_button_new_with_label ("Shrink");
gtk_table_attach_defaults (GTK_TABLE (table), check_button,
1, 2, 2, 3);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check_button),
TRUE);
- gtk_signal_connect (GTK_OBJECT (check_button), "toggled",
- GTK_SIGNAL_FUNC (toggle_shrink),
- paned->child2);
+ g_signal_connect (check_button, "toggled",
+ G_CALLBACK (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);
+ g_signal_connect (button, "clicked",
+ G_CALLBACK (paned_props_clicked),
+ paned);
return frame;
}
void
-create_panes (void)
+create_panes (GtkWidget *widget)
{
static GtkWidget *window = NULL;
GtkWidget *frame;
{
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
- gtk_signal_connect (GTK_OBJECT (window), "destroy",
- GTK_SIGNAL_FUNC(gtk_widget_destroyed),
- &window);
+ gtk_window_set_screen (GTK_WINDOW (window),
+ gtk_widget_get_screen (widget));
+
+ g_signal_connect (window, "destroy",
+ G_CALLBACK (gtk_widget_destroyed),
+ &window);
gtk_window_set_title (GTK_WINDOW (window), "Panes");
gtk_container_set_border_width (GTK_CONTAINER (window), 0);
frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME(frame), GTK_SHADOW_IN);
- gtk_widget_set_usize (frame, 60, 60);
+ gtk_widget_set_size_request (frame, 60, 60);
gtk_paned_add1 (GTK_PANED (hpaned), frame);
button = gtk_button_new_with_label ("Hi there");
frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME(frame), GTK_SHADOW_IN);
- gtk_widget_set_usize (frame, 80, 60);
+ gtk_widget_set_size_request (frame, 80, 60);
gtk_paned_add2 (GTK_PANED (hpaned), frame);
frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME(frame), GTK_SHADOW_IN);
- gtk_widget_set_usize (frame, 60, 80);
+ gtk_widget_set_size_request (frame, 60, 80);
gtk_paned_add2 (GTK_PANED (vpaned), frame);
/* Now create toggle buttons to control sizing */
gtk_widget_show_all (vbox);
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
gtk_widget_show (window);
else
gtk_widget_destroy (window);
*/
static GtkWidget*
-paned_keyboard_window1 (void)
+paned_keyboard_window1 (GtkWidget *widget)
{
GtkWidget *window1;
GtkWidget *hpaned1;
window1 = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (window1), "Basic paned navigation");
+ gtk_window_set_screen (GTK_WINDOW (window1),
+ gtk_widget_get_screen (widget));
hpaned1 = gtk_hpaned_new ();
gtk_container_add (GTK_CONTAINER (window1), hpaned1);
}
static GtkWidget*
-paned_keyboard_window2 (void)
+paned_keyboard_window2 (GtkWidget *widget)
{
GtkWidget *window2;
GtkWidget *hpaned2;
window2 = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (window2), "\"button 10\" is not inside the horisontal pane");
+ gtk_window_set_screen (GTK_WINDOW (window2),
+ gtk_widget_get_screen (widget));
+
hpaned2 = gtk_hpaned_new ();
gtk_container_add (GTK_CONTAINER (window2), hpaned2);
}
static GtkWidget*
-paned_keyboard_window3 (void)
+paned_keyboard_window3 (GtkWidget *widget)
{
GtkWidget *window3;
GtkWidget *vbox2;
GtkWidget *button17;
window3 = gtk_window_new (GTK_WINDOW_TOPLEVEL);
- gtk_object_set_data (GTK_OBJECT (window3), "window3", window3);
+ g_object_set_data (G_OBJECT (window3), "window3", window3);
gtk_window_set_title (GTK_WINDOW (window3), "Nested panes");
+ gtk_window_set_screen (GTK_WINDOW (window3),
+ gtk_widget_get_screen (widget));
+
+
vbox2 = gtk_vbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER (window3), vbox2);
}
static GtkWidget*
-paned_keyboard_window4 (void)
+paned_keyboard_window4 (GtkWidget *widget)
{
GtkWidget *window4;
GtkWidget *vbox3;
GtkWidget *button24;
window4 = gtk_window_new (GTK_WINDOW_TOPLEVEL);
- gtk_object_set_data (GTK_OBJECT (window4), "window4", window4);
+ g_object_set_data (G_OBJECT (window4), "window4", window4);
gtk_window_set_title (GTK_WINDOW (window4), "window4");
+ gtk_window_set_screen (GTK_WINDOW (window4),
+ gtk_widget_get_screen (widget));
+
vbox3 = gtk_vbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER (window4), vbox3);
}
static void
-create_paned_keyboard_navigation (void)
+create_paned_keyboard_navigation (GtkWidget *widget)
{
static GtkWidget *window1 = NULL;
static GtkWidget *window2 = NULL;
static GtkWidget *window3 = NULL;
static GtkWidget *window4 = NULL;
+ if (window1 &&
+ (gtk_widget_get_screen (window1) != gtk_widget_get_screen (widget)))
+ {
+ gtk_widget_destroy (window1);
+ gtk_widget_destroy (window2);
+ gtk_widget_destroy (window3);
+ gtk_widget_destroy (window4);
+ }
+
if (!window1)
{
- window1 = paned_keyboard_window1 ();
- gtk_signal_connect (GTK_OBJECT (window1), "destroy",
- GTK_SIGNAL_FUNC(gtk_widget_destroyed),
- &window1);
+ window1 = paned_keyboard_window1 (widget);
+ g_signal_connect (window1, "destroy",
+ G_CALLBACK (gtk_widget_destroyed),
+ &window1);
}
if (!window2)
{
- window2 = paned_keyboard_window2 ();
- gtk_signal_connect (GTK_OBJECT (window2), "destroy",
- GTK_SIGNAL_FUNC(gtk_widget_destroyed),
- &window2);
+ window2 = paned_keyboard_window2 (widget);
+ g_signal_connect (window2, "destroy",
+ G_CALLBACK (gtk_widget_destroyed),
+ &window2);
}
if (!window3)
{
- window3 = paned_keyboard_window3 ();
- gtk_signal_connect (GTK_OBJECT (window3), "destroy",
- GTK_SIGNAL_FUNC(gtk_widget_destroyed),
- &window3);
+ window3 = paned_keyboard_window3 (widget);
+ g_signal_connect (window3, "destroy",
+ G_CALLBACK (gtk_widget_destroyed),
+ &window3);
}
if (!window4)
{
- window4 = paned_keyboard_window4 ();
- gtk_signal_connect (GTK_OBJECT (window4), "destroy",
- GTK_SIGNAL_FUNC(gtk_widget_destroyed),
- &window4);
+ window4 = paned_keyboard_window4 (widget);
+ g_signal_connect (window4, "destroy",
+ G_CALLBACK (gtk_widget_destroyed),
+ &window4);
}
- if (GTK_WIDGET_VISIBLE (window1))
+ if (gtk_widget_get_visible (window1))
gtk_widget_destroy (GTK_WIDGET (window1));
else
gtk_widget_show_all (GTK_WIDGET (window1));
- if (GTK_WIDGET_VISIBLE (window2))
+ if (gtk_widget_get_visible (window2))
gtk_widget_destroy (GTK_WIDGET (window2));
else
gtk_widget_show_all (GTK_WIDGET (window2));
- if (GTK_WIDGET_VISIBLE (window3))
+ if (gtk_widget_get_visible (window3))
gtk_widget_destroy (GTK_WIDGET (window3));
else
gtk_widget_show_all (GTK_WIDGET (window3));
- if (GTK_WIDGET_VISIBLE (window4))
+ if (gtk_widget_get_visible (window4))
gtk_widget_destroy (GTK_WIDGET (window4));
else
gtk_widget_show_all (GTK_WIDGET (window4));
if (event->type != GDK_BUTTON_PRESS)
return;
- p = gtk_object_get_user_data (GTK_OBJECT(widget));
+ p = g_object_get_data (G_OBJECT (widget), "cursor_offset");
p->x = (int) event->x;
p->y = (int) event->y;
shape_released (GtkWidget *widget)
{
gtk_grab_remove (widget);
- gdk_pointer_ungrab (0);
+ gdk_display_pointer_ungrab (gtk_widget_get_display (widget),
+ GDK_CURRENT_TIME);
}
static void
CursorOffset * p;
GdkModifierType mask;
- p = gtk_object_get_user_data (GTK_OBJECT (widget));
+ p = g_object_get_data (G_OBJECT (widget), "cursor_offset");
/*
* Can't use event->x / event->y here
}
GtkWidget *
-shape_create_icon (char *xpm_file,
- gint x,
- gint y,
- gint px,
- gint py,
- gint window_type)
+shape_create_icon (GdkScreen *screen,
+ char *xpm_file,
+ gint x,
+ gint y,
+ gint px,
+ gint py,
+ gint window_type)
{
GtkWidget *window;
GtkWidget *pixmap;
* GDK_WINDOW_TOPLEVEL works also, giving you a title border
*/
window = gtk_window_new (window_type);
+ gtk_window_set_screen (GTK_WINDOW (window), screen);
fixed = gtk_fixed_new ();
- gtk_widget_set_usize (fixed, 100,100);
+ gtk_widget_set_size_request (fixed, 100, 100);
gtk_container_add (GTK_CONTAINER (window), fixed);
gtk_widget_show (fixed);
&style->bg[GTK_STATE_NORMAL],
xpm_file);
- pixmap = gtk_pixmap_new (gdk_pixmap, gdk_pixmap_mask);
+ pixmap = gtk_image_new_from_pixmap (gdk_pixmap, gdk_pixmap_mask);
gtk_fixed_put (GTK_FIXED (fixed), pixmap, px,py);
gtk_widget_show (pixmap);
gtk_widget_shape_combine_mask (window, gdk_pixmap_mask, px, py);
- gdk_drawable_unref (gdk_pixmap_mask);
- gdk_drawable_unref (gdk_pixmap);
+ g_object_unref (gdk_pixmap_mask);
+ g_object_unref (gdk_pixmap);
- gtk_signal_connect (GTK_OBJECT (window), "button_press_event",
- GTK_SIGNAL_FUNC (shape_pressed),NULL);
- gtk_signal_connect (GTK_OBJECT (window), "button_release_event",
- GTK_SIGNAL_FUNC (shape_released),NULL);
- gtk_signal_connect (GTK_OBJECT (window), "motion_notify_event",
- GTK_SIGNAL_FUNC (shape_motion),NULL);
+ g_signal_connect (window, "button_press_event",
+ G_CALLBACK (shape_pressed), NULL);
+ g_signal_connect (window, "button_release_event",
+ G_CALLBACK (shape_released), NULL);
+ g_signal_connect (window, "motion_notify_event",
+ G_CALLBACK (shape_motion), NULL);
icon_pos = g_new (CursorOffset, 1);
- gtk_object_set_user_data(GTK_OBJECT(window), icon_pos);
+ g_object_set_data (G_OBJECT (window), "cursor_offset", icon_pos);
gtk_widget_set_uposition (window, x, y);
gtk_widget_show (window);
}
void
-create_shapes (void)
+create_shapes (GtkWidget *widget)
{
/* Variables used by the Drag/Drop and Shape Window demos */
static GtkWidget *modeller = NULL;
static GtkWidget *sheets = NULL;
static GtkWidget *rings = NULL;
static GtkWidget *with_region = NULL;
+ GdkScreen *screen = gtk_widget_get_screen (widget);
if (!(file_exists ("Modeller.xpm") &&
file_exists ("FilesQueue.xpm") &&
if (!modeller)
{
- modeller = shape_create_icon ("Modeller.xpm",
+ modeller = shape_create_icon (screen, "Modeller.xpm",
440, 140, 0,0, GTK_WINDOW_POPUP);
- gtk_signal_connect (GTK_OBJECT (modeller), "destroy",
- GTK_SIGNAL_FUNC(gtk_widget_destroyed),
- &modeller);
+ g_signal_connect (modeller, "destroy",
+ G_CALLBACK (gtk_widget_destroyed),
+ &modeller);
}
else
gtk_widget_destroy (modeller);
if (!sheets)
{
- sheets = shape_create_icon ("FilesQueue.xpm",
+ sheets = shape_create_icon (screen, "FilesQueue.xpm",
580, 170, 0,0, GTK_WINDOW_POPUP);
- gtk_signal_connect (GTK_OBJECT (sheets), "destroy",
- GTK_SIGNAL_FUNC(gtk_widget_destroyed),
- &sheets);
+ g_signal_connect (sheets, "destroy",
+ G_CALLBACK (gtk_widget_destroyed),
+ &sheets);
}
else
if (!rings)
{
- rings = shape_create_icon ("3DRings.xpm",
+ rings = shape_create_icon (screen, "3DRings.xpm",
460, 270, 25,25, GTK_WINDOW_TOPLEVEL);
- gtk_signal_connect (GTK_OBJECT (rings), "destroy",
- GTK_SIGNAL_FUNC(gtk_widget_destroyed),
- &rings);
+ g_signal_connect (rings, "destroy",
+ G_CALLBACK (gtk_widget_destroyed),
+ &rings);
}
else
gtk_widget_destroy (rings);
GdkRegion *region;
gint x, y;
- with_region = shape_create_icon ("3DRings.xpm",
+ with_region = shape_create_icon (screen, "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);
+ g_signal_connect (with_region, "destroy",
+ G_CALLBACK (gtk_widget_destroyed),
+ &with_region);
/* reset shape from mask to a region */
x = 0;
*/
void
-create_wmhints (void)
+create_wmhints (GtkWidget *widget)
{
static GtkWidget *window = NULL;
GtkWidget *label;
{
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
- gtk_signal_connect (GTK_OBJECT (window), "destroy",
- GTK_SIGNAL_FUNC(gtk_widget_destroyed),
- &window);
+ gtk_window_set_screen (GTK_WINDOW (window),
+ gtk_widget_get_screen (widget));
+
+ g_signal_connect (window, "destroy",
+ G_CALLBACK (gtk_widget_destroyed),
+ &window);
gtk_window_set_title (GTK_WINDOW (window), "WM Hints");
gtk_container_set_border_width (GTK_CONTAINER (window), 0);
gtk_widget_realize (window);
circles = gdk_bitmap_create_from_data (window->window,
- circles_bits,
+ (gchar *) circles_bits,
circles_width,
circles_height);
gdk_window_set_icon (window->window, NULL,
gtk_widget_show (box1);
label = gtk_label_new ("Try iconizing me!");
- gtk_widget_set_usize (label, 150, 50);
+ gtk_widget_set_size_request (label, 150, 50);
gtk_box_pack_start (GTK_BOX (box1), label, TRUE, TRUE, 0);
gtk_widget_show (label);
button = gtk_button_new_with_label ("close");
- gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
- GTK_SIGNAL_FUNC(gtk_widget_destroy),
- GTK_OBJECT (window));
+ g_signal_connect_swapped (button, "clicked",
+ G_CALLBACK (gtk_widget_destroy),
+ window);
gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
gtk_widget_show (button);
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
gtk_widget_show (window);
else
gtk_widget_destroy (window);
(event->new_window_state & GDK_WINDOW_STATE_STICKY) ?
"sticky" : "not sticky", ", ",
(event->new_window_state & GDK_WINDOW_STATE_MAXIMIZED) ?
- "maximized" : "not maximized",
+ "maximized" : "not maximized", ", ",
+ (event->new_window_state & GDK_WINDOW_STATE_FULLSCREEN) ?
+ "fullscreen" : "not fullscreen",
+ (event->new_window_state & GDK_WINDOW_STATE_ABOVE) ?
+ "above" : "not above", ", ",
+ (event->new_window_state & GDK_WINDOW_STATE_BELOW) ?
+ "below" : "not below", ", ",
NULL);
gtk_label_set_text (GTK_LABEL (label), msg);
hbox = gtk_hbox_new (FALSE, 5);
- gtk_signal_connect_object (GTK_OBJECT (hbox),
- "destroy",
- GTK_SIGNAL_FUNC (gtk_widget_destroy),
- GTK_OBJECT (window));
+ g_signal_connect_object (hbox,
+ "destroy",
+ G_CALLBACK (gtk_widget_destroy),
+ window,
+ G_CONNECT_SWAPPED);
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);
+ g_signal_connect (window,
+ "window_state_event",
+ G_CALLBACK (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));
+ g_signal_connect_object (button,
+ "clicked",
+ G_CALLBACK (gtk_window_deiconify),
+ window,
+ G_CONNECT_SWAPPED);
+ gtk_box_pack_end (GTK_BOX (hbox), button, FALSE, FALSE, 0);
+
+ button = gtk_button_new_with_label ("Iconify");
+ g_signal_connect_object (button,
+ "clicked",
+ G_CALLBACK (gtk_window_iconify),
+ window,
+ G_CONNECT_SWAPPED);
+ gtk_box_pack_end (GTK_BOX (hbox), button, FALSE, FALSE, 0);
+
+ button = gtk_button_new_with_label ("Fullscreen");
+ g_signal_connect_object (button,
+ "clicked",
+ G_CALLBACK (gtk_window_fullscreen),
+ window,
+ G_CONNECT_SWAPPED);
+ gtk_box_pack_end (GTK_BOX (hbox), button, FALSE, FALSE, 0);
+
+ button = gtk_button_new_with_label ("Unfullscreen");
+ g_signal_connect_object (button,
+ "clicked",
+ G_CALLBACK (gtk_window_unfullscreen),
+ window,
+ G_CONNECT_SWAPPED);
+ gtk_box_pack_end (GTK_BOX (hbox), button, FALSE, FALSE, 0);
+
+ button = gtk_button_new_with_label ("Present");
+ g_signal_connect_object (button,
+ "clicked",
+ G_CALLBACK (gtk_window_present),
+ window,
+ G_CONNECT_SWAPPED);
+ gtk_box_pack_end (GTK_BOX (hbox), button, FALSE, FALSE, 0);
+
+ button = gtk_button_new_with_label ("Show");
+ g_signal_connect_object (button,
+ "clicked",
+ G_CALLBACK (gtk_widget_show),
+ window,
+ G_CONNECT_SWAPPED);
gtk_box_pack_end (GTK_BOX (hbox), button, FALSE, FALSE, 0);
+
+ gtk_widget_show_all (hbox);
+
+ return hbox;
+}
+
+void
+keep_window_above (GtkToggleButton *togglebutton, gpointer data)
+{
+ GtkWidget *button = g_object_get_data (G_OBJECT (togglebutton), "radio");
+
+ gtk_window_set_keep_above (GTK_WINDOW (data),
+ gtk_toggle_button_get_active (togglebutton));
+
+ if (gtk_toggle_button_get_active (togglebutton))
+ gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), FALSE);
+}
+
+void
+keep_window_below (GtkToggleButton *togglebutton, gpointer data)
+{
+ GtkWidget *button = g_object_get_data (G_OBJECT (togglebutton), "radio");
- 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);
+ gtk_window_set_keep_below (GTK_WINDOW (data),
+ gtk_toggle_button_get_active (togglebutton));
- 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;
+ if (gtk_toggle_button_get_active (togglebutton))
+ gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), FALSE);
}
+
static GtkWidget*
get_state_controls (GtkWidget *window)
{
GtkWidget *vbox;
GtkWidget *button;
+ GtkWidget *button_above;
+ GtkWidget *button_below;
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));
+ g_signal_connect_object (button,
+ "clicked",
+ G_CALLBACK (gtk_window_stick),
+ window,
+ G_CONNECT_SWAPPED);
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));
+ g_signal_connect_object (button,
+ "clicked",
+ G_CALLBACK (gtk_window_unstick),
+ window,
+ G_CONNECT_SWAPPED);
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));
+ g_signal_connect_object (button,
+ "clicked",
+ G_CALLBACK (gtk_window_maximize),
+ window,
+ G_CONNECT_SWAPPED);
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));
+ g_signal_connect_object (button,
+ "clicked",
+ G_CALLBACK (gtk_window_unmaximize),
+ window,
+ G_CONNECT_SWAPPED);
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));
+ g_signal_connect_object (button,
+ "clicked",
+ G_CALLBACK (gtk_window_iconify),
+ window,
+ G_CONNECT_SWAPPED);
+ gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
+
+ button = gtk_button_new_with_label ("Fullscreen");
+ g_signal_connect_object (button,
+ "clicked",
+ G_CALLBACK (gtk_window_fullscreen),
+ window,
+ G_CONNECT_SWAPPED);
+ gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
+
+ button = gtk_button_new_with_label ("Unfullscreen");
+ g_signal_connect_object (button,
+ "clicked",
+ G_CALLBACK (gtk_window_unfullscreen),
+ window,
+ G_CONNECT_SWAPPED);
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
+ button_above = gtk_toggle_button_new_with_label ("Keep above");
+ g_signal_connect (button_above,
+ "toggled",
+ G_CALLBACK (keep_window_above),
+ window);
+ gtk_box_pack_start (GTK_BOX (vbox), button_above, FALSE, FALSE, 0);
+
+ button_below = gtk_toggle_button_new_with_label ("Keep below");
+ g_signal_connect (button_below,
+ "toggled",
+ G_CALLBACK (keep_window_below),
+ window);
+ gtk_box_pack_start (GTK_BOX (vbox), button_below, FALSE, FALSE, 0);
+
+ g_object_set_data (G_OBJECT (button_above), "radio", button_below);
+ g_object_set_data (G_OBJECT (button_below), "radio", button_above);
+
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));
+ g_signal_connect_object (button,
+ "clicked",
+ G_CALLBACK (gtk_widget_hide),
+ window,
+ G_CONNECT_SWAPPED);
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
gtk_widget_show_all (vbox);
}
void
-create_window_states (void)
+create_window_states (GtkWidget *widget)
{
static GtkWidget *window = NULL;
GtkWidget *label;
GtkWidget *iconified;
GtkWidget *normal;
GtkWidget *controls;
-
+
if (!window)
{
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+ gtk_window_set_screen (GTK_WINDOW (window),
+ gtk_widget_get_screen (widget));
- gtk_signal_connect (GTK_OBJECT (window), "destroy",
- GTK_SIGNAL_FUNC(gtk_widget_destroyed),
- &window);
+ g_signal_connect (window, "destroy",
+ G_CALLBACK (gtk_widget_destroyed),
+ &window);
gtk_window_set_title (GTK_WINDOW (window), "Window states");
gtk_container_add (GTK_CONTAINER (window), box1);
iconified = gtk_window_new (GTK_WINDOW_TOPLEVEL);
- gtk_signal_connect_object (GTK_OBJECT (iconified), "destroy",
- GTK_SIGNAL_FUNC(gtk_widget_destroy),
- GTK_OBJECT (window));
+
+ gtk_window_set_screen (GTK_WINDOW (iconified),
+ gtk_widget_get_screen (widget));
+
+ g_signal_connect_object (iconified, "destroy",
+ G_CALLBACK (gtk_widget_destroy),
+ window,
+ G_CONNECT_SWAPPED);
gtk_window_iconify (GTK_WINDOW (iconified));
gtk_window_set_title (GTK_WINDOW (iconified), "Iconified initially");
controls = get_state_controls (iconified);
gtk_container_add (GTK_CONTAINER (iconified), controls);
normal = gtk_window_new (GTK_WINDOW_TOPLEVEL);
- gtk_signal_connect_object (GTK_OBJECT (normal), "destroy",
- GTK_SIGNAL_FUNC(gtk_widget_destroy),
- GTK_OBJECT (window));
+
+ gtk_window_set_screen (GTK_WINDOW (normal),
+ gtk_widget_get_screen (widget));
+
+ g_signal_connect_object (normal, "destroy",
+ G_CALLBACK (gtk_widget_destroy),
+ window,
+ G_CONNECT_SWAPPED);
gtk_window_set_title (GTK_WINDOW (normal), "Deiconified initially");
controls = get_state_controls (normal);
gtk_widget_show_all (box1);
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
gtk_widget_show (window);
else
gtk_widget_destroy (window);
}
static void
-unset_usize_callback (GtkWidget *widget,
- gpointer data)
+unset_size_request_callback (GtkWidget *widget,
+ gpointer data)
{
gtk_widget_set_size_request (g_object_get_data (data, "target"),
-1, -1);
}
static void
-set_usize_callback (GtkWidget *widget,
- gpointer data)
+set_size_request_callback (GtkWidget *widget,
+ gpointer data)
{
gint w, h;
allow_shrink_callback (GtkWidget *widget,
gpointer data)
{
- g_object_set (G_OBJECT (g_object_get_data (data, "target")),
+ g_object_set (g_object_get_data (data, "target"),
"allow_shrink",
GTK_TOGGLE_BUTTON (widget)->active,
NULL);
allow_grow_callback (GtkWidget *widget,
gpointer data)
{
- g_object_set (G_OBJECT (g_object_get_data (data, "target")),
+ g_object_set (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)
gint *y)
{
int w, h;
+ GdkScreen * screen = gtk_window_get_screen (window);
gtk_window_get_size (GTK_WINDOW (window), &w, &h);
switch (gtk_window_get_gravity (window))
{
case GDK_GRAVITY_SOUTH_EAST:
- *x = gdk_screen_width () - w;
- *y = gdk_screen_height () - h;
+ *x = gdk_screen_get_width (screen) - w;
+ *y = gdk_screen_get_height (screen) - h;
break;
case GDK_GRAVITY_NORTH_EAST:
- *x = gdk_screen_width () - w;
+ *x = gdk_screen_get_width (screen) - w;
*y = 0;
break;
case GDK_GRAVITY_SOUTH_WEST:
*x = 0;
- *y = gdk_screen_height () - h;
+ *y = gdk_screen_get_height (screen) - h;
break;
case GDK_GRAVITY_NORTH_WEST:
break;
case GDK_GRAVITY_SOUTH:
- *x = (gdk_screen_width () - w) / 2;
- *y = gdk_screen_height () - h;
+ *x = (gdk_screen_get_width (screen) - w) / 2;
+ *y = gdk_screen_get_height (screen) - h;
break;
case GDK_GRAVITY_NORTH:
- *x = (gdk_screen_width () - w) / 2;
+ *x = (gdk_screen_get_width (screen) - w) / 2;
*y = 0;
break;
case GDK_GRAVITY_WEST:
*x = 0;
- *y = (gdk_screen_height () - h) / 2;
+ *y = (gdk_screen_get_height (screen) - h) / 2;
break;
case GDK_GRAVITY_EAST:
- *x = gdk_screen_width () - w;
- *y = (gdk_screen_height () - h) / 2;
+ *x = gdk_screen_get_width (screen) - w;
+ *y = (gdk_screen_get_height (screen) - h) / 2;
break;
case GDK_GRAVITY_CENTER:
- *x = (gdk_screen_width () - w) / 2;
- *y = (gdk_screen_height () - h) / 2;
+ *x = (gdk_screen_get_width (screen) - w) / 2;
+ *y = (gdk_screen_get_height (screen) - h) / 2;
break;
case GDK_GRAVITY_STATIC:
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+ gtk_window_set_screen (GTK_WINDOW (window),
+ gtk_widget_get_screen (destroy_with));
+
vbox = gtk_vbox_new (FALSE, 0);
gtk_widget_show (vbox);
gtk_window_set_title (GTK_WINDOW (window), title);
gtk_window_set_gravity (GTK_WINDOW (window), gravity);
- gtk_signal_connect_object (GTK_OBJECT (destroy_with),
- "destroy",
- GTK_SIGNAL_FUNC (gtk_widget_destroy),
- GTK_OBJECT (window));
+ g_signal_connect_object (destroy_with,
+ "destroy",
+ G_CALLBACK (gtk_widget_destroy),
+ window,
+ G_CONNECT_SWAPPED);
button = gtk_button_new_with_mnemonic ("_Move to current position");
- g_signal_connect (G_OBJECT (button), "clicked",
+ g_signal_connect (button, "clicked",
G_CALLBACK (move_gravity_window_to_current_position),
window);
button = gtk_button_new_with_mnemonic ("Move to _starting position");
- g_signal_connect (G_OBJECT (button), "clicked",
+ g_signal_connect (button, "clicked",
G_CALLBACK (move_gravity_window_to_starting_position),
window);
control_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+ gtk_window_set_screen (GTK_WINDOW (control_window),
+ gtk_widget_get_screen (window));
+
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));
+ g_signal_connect_object (control_window,
+ "destroy",
+ G_CALLBACK (gtk_widget_destroy),
+ window,
+ G_CONNECT_SWAPPED);
vbox = gtk_vbox_new (FALSE, 5);
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);
+ g_signal_connect (window,
+ "configure_event",
+ G_CALLBACK (configure_event_callback),
+ label);
adj = (GtkAdjustment *) gtk_adjustment_new (10.0, -2000.0, 2000.0, 1.0,
5.0, 0.0);
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);
+ g_signal_connect (entry, "changed",
+ G_CALLBACK (set_geometry_callback),
+ control_window);
button = gtk_button_new_with_label ("Show gravity test windows");
- gtk_signal_connect_object (GTK_OBJECT (button),
- "clicked",
- GTK_SIGNAL_FUNC (do_gravity_test),
- control_window);
+ g_signal_connect_swapped (button,
+ "clicked",
+ G_CALLBACK (do_gravity_test),
+ control_window);
gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
button = gtk_button_new_with_label ("Reshow with initial size");
- gtk_signal_connect_object (GTK_OBJECT (button),
- "clicked",
- GTK_SIGNAL_FUNC (gtk_window_reshow_with_initial_size),
- GTK_OBJECT (window));
+ g_signal_connect_object (button,
+ "clicked",
+ G_CALLBACK (gtk_window_reshow_with_initial_size),
+ window,
+ G_CONNECT_SWAPPED);
gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
button = gtk_button_new_with_label ("Queue resize");
- gtk_signal_connect_object (GTK_OBJECT (button),
- "clicked",
- GTK_SIGNAL_FUNC (gtk_widget_queue_resize),
- GTK_OBJECT (window));
+ g_signal_connect_object (button,
+ "clicked",
+ G_CALLBACK (gtk_widget_queue_resize),
+ window,
+ G_CONNECT_SWAPPED);
gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
button = gtk_button_new_with_label ("Resize");
- gtk_signal_connect (GTK_OBJECT (button),
- "clicked",
- GTK_SIGNAL_FUNC (set_size_callback),
- GTK_OBJECT (control_window));
+ g_signal_connect (button,
+ "clicked",
+ G_CALLBACK (set_size_callback),
+ 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));
+ g_signal_connect (button,
+ "clicked",
+ G_CALLBACK (set_default_size_callback),
+ control_window);
gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
button = gtk_button_new_with_label ("Unset default size");
- gtk_signal_connect (GTK_OBJECT (button),
- "clicked",
- GTK_SIGNAL_FUNC (unset_default_size_callback),
- GTK_OBJECT (control_window));
+ g_signal_connect (button,
+ "clicked",
+ G_CALLBACK (unset_default_size_callback),
+ control_window);
gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
button = gtk_button_new_with_label ("Set size request");
- gtk_signal_connect (GTK_OBJECT (button),
- "clicked",
- GTK_SIGNAL_FUNC (set_usize_callback),
- GTK_OBJECT (control_window));
+ g_signal_connect (button,
+ "clicked",
+ G_CALLBACK (set_size_request_callback),
+ control_window);
gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
button = gtk_button_new_with_label ("Unset size request");
- gtk_signal_connect (GTK_OBJECT (button),
- "clicked",
- GTK_SIGNAL_FUNC (unset_usize_callback),
- GTK_OBJECT (control_window));
+ g_signal_connect (button,
+ "clicked",
+ G_CALLBACK (unset_size_request_callback),
+ control_window);
gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
button = gtk_button_new_with_label ("Move");
- gtk_signal_connect (GTK_OBJECT (button),
- "clicked",
- GTK_SIGNAL_FUNC (set_location_callback),
- GTK_OBJECT (control_window));
+ g_signal_connect (button,
+ "clicked",
+ G_CALLBACK (set_location_callback),
+ control_window);
gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
button = gtk_button_new_with_label ("Move to current position");
- gtk_signal_connect (GTK_OBJECT (button),
- "clicked",
- GTK_SIGNAL_FUNC (move_to_position_callback),
- GTK_OBJECT (control_window));
+ g_signal_connect (button,
+ "clicked",
+ G_CALLBACK (move_to_position_callback),
+ 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));
+ g_signal_connect (button,
+ "toggled",
+ G_CALLBACK (allow_shrink_callback),
+ 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));
+ g_signal_connect (button,
+ "toggled",
+ G_CALLBACK (allow_grow_callback),
+ 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));
+ g_signal_connect_object (button,
+ "clicked",
+ G_CALLBACK (gtk_widget_show),
+ window,
+ G_CONNECT_SWAPPED);
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));
+ g_signal_connect_object (button,
+ "clicked",
+ G_CALLBACK (gtk_widget_hide),
+ window,
+ G_CONNECT_SWAPPED);
gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
menu = gtk_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);
+ g_signal_connect (om,
+ "changed",
+ G_CALLBACK (gravity_selected),
+ control_window);
gtk_box_pack_end (GTK_BOX (vbox), om, FALSE, FALSE, 0);
gtk_option_menu_set_menu (GTK_OPTION_MENU (om), menu);
- gtk_signal_connect (GTK_OBJECT (om),
- "changed",
- GTK_SIGNAL_FUNC (pos_selected),
- control_window);
+ g_signal_connect (om,
+ "changed",
+ G_CALLBACK (pos_selected),
+ control_window);
gtk_box_pack_end (GTK_BOX (vbox), om, FALSE, FALSE, 0);
}
void
-create_window_sizing (void)
+create_window_sizing (GtkWidget *widget)
{
static GtkWidget *window = NULL;
static GtkWidget *target_window = NULL;
-
+
if (!target_window)
{
GtkWidget *label;
target_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
-
+ gtk_window_set_screen (GTK_WINDOW (target_window),
+ gtk_widget_get_screen (widget));
label = gtk_label_new (NULL);
gtk_label_set_markup (GTK_LABEL (label), "<span foreground=\"purple\"><big>Window being resized</big></span>\nBlah blah blah blah\nblah blah blah\nblah blah blah blah blah");
gtk_container_add (GTK_CONTAINER (target_window), label);
gtk_widget_show (label);
- gtk_signal_connect (GTK_OBJECT (target_window), "destroy",
- GTK_SIGNAL_FUNC (gtk_widget_destroyed),
- &target_window);
+ g_signal_connect (target_window, "destroy",
+ G_CALLBACK (gtk_widget_destroyed),
+ &target_window);
window = window_controls (target_window);
- gtk_signal_connect (GTK_OBJECT (window), "destroy",
- GTK_SIGNAL_FUNC (gtk_widget_destroyed),
- &window);
+ g_signal_connect (window, "destroy",
+ G_CALLBACK (gtk_widget_destroyed),
+ &window);
gtk_window_set_title (GTK_WINDOW (target_window), "Window to size");
}
* of behavior on first show.
*/
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
gtk_widget_show (window);
else
gtk_widget_destroy (window);
GtkWidget *act_blocks_spin;
GtkWidget *label;
GtkWidget *omenu1;
+ GtkWidget *elmenu;
GtkWidget *omenu2;
GtkWidget *entry;
int timer;
GTK_TOGGLE_BUTTON (widget)->active);
}
+static void
+progressbar_toggle_ellipsize (GtkWidget *widget,
+ gpointer data)
+{
+ ProgressData *pdata = data;
+ if (gtk_widget_is_drawable (widget))
+ {
+ gint i = gtk_option_menu_get_history (GTK_OPTION_MENU (widget));
+ gtk_progress_bar_set_ellipsize (GTK_PROGRESS_BAR (pdata->pbar), i);
+ }
+}
+
static void
progressbar_toggle_bar_style (GtkWidget *widget, gpointer data)
{
adjust_align (GtkAdjustment *adj, ProgressData *pdata)
{
gtk_progress_set_text_alignment (GTK_PROGRESS (pdata->pbar),
- gtk_spin_button_get_value_as_float
- (GTK_SPIN_BUTTON (pdata->x_align_spin)),
- gtk_spin_button_get_value_as_float
- (GTK_SPIN_BUTTON (pdata->y_align_spin)));
+ gtk_spin_button_get_value (GTK_SPIN_BUTTON (pdata->x_align_spin)),
+ gtk_spin_button_get_value (GTK_SPIN_BUTTON (pdata->y_align_spin)));
}
static void
}
void
-create_progress_bar (void)
+create_progress_bar (GtkWidget *widget)
{
GtkWidget *button;
GtkWidget *vbox;
"Discrete"
};
+ static char *ellipsize_items[] = {
+ "None", // PANGO_ELLIPSIZE_NONE,
+ "Start", // PANGO_ELLIPSIZE_START,
+ "Middle", // PANGO_ELLIPSIZE_MIDDLE,
+ "End", // PANGO_ELLIPSIZE_END
+ };
+
if (!pdata)
pdata = g_new0 (ProgressData, 1);
{
pdata->window = gtk_dialog_new ();
- gtk_window_set_policy (GTK_WINDOW (pdata->window), FALSE, FALSE, TRUE);
+ gtk_window_set_screen (GTK_WINDOW (pdata->window),
+ gtk_widget_get_screen (widget));
- gtk_signal_connect (GTK_OBJECT (pdata->window), "destroy",
- GTK_SIGNAL_FUNC (destroy_progress),
- &pdata);
+ gtk_window_set_resizable (GTK_WINDOW (pdata->window), TRUE);
+
+ g_signal_connect (pdata->window, "destroy",
+ G_CALLBACK (destroy_progress),
+ &pdata);
pdata->timer = 0;
gtk_box_pack_start (GTK_BOX (vbox2), align, FALSE, FALSE, 5);
adj = (GtkAdjustment *) gtk_adjustment_new (0, 1, 300, 0, 0, 0);
- gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
- GTK_SIGNAL_FUNC (progress_value_changed), pdata);
+ g_signal_connect (adj, "value_changed",
+ G_CALLBACK (progress_value_changed), pdata);
- pdata->pbar = gtk_progress_bar_new_with_adjustment (adj);
+ pdata->pbar = g_object_new (GTK_TYPE_PROGRESS_BAR,
+ "adjustment", adj,
+ "ellipsize", PANGO_ELLIPSIZE_MIDDLE,
+ NULL);
gtk_progress_set_format_string (GTK_PROGRESS (pdata->pbar),
"%v from [%l,%u] (=%p%%)");
gtk_container_add (GTK_CONTAINER (align), pdata->pbar);
gtk_box_pack_start (GTK_BOX (hbox), pdata->omenu1, TRUE, TRUE, 0);
check = gtk_check_button_new_with_label ("Show text");
- gtk_signal_connect (GTK_OBJECT (check), "clicked",
- GTK_SIGNAL_FUNC (toggle_show_text),
- pdata);
+ g_signal_connect (check, "clicked",
+ G_CALLBACK (toggle_show_text),
+ pdata);
gtk_table_attach (GTK_TABLE (tab), check, 0, 1, 1, 2,
GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
5, 5);
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
pdata->entry = gtk_entry_new ();
- gtk_signal_connect (GTK_OBJECT (pdata->entry), "changed",
- GTK_SIGNAL_FUNC (entry_changed),
- pdata);
+ g_signal_connect (pdata->entry, "changed",
+ G_CALLBACK (entry_changed),
+ pdata);
gtk_box_pack_start (GTK_BOX (hbox), pdata->entry, TRUE, TRUE, 0);
gtk_entry_set_text (GTK_ENTRY (pdata->entry), "%v from [%l,%u] (=%p%%)");
- gtk_widget_set_usize (pdata->entry, 100, -1);
+ gtk_widget_set_size_request (pdata->entry, 100, -1);
gtk_widget_set_sensitive (pdata->entry, FALSE);
label = gtk_label_new ("Text align :");
adj = (GtkAdjustment *) gtk_adjustment_new (0.5, 0, 1, 0.1, 0.1, 0);
pdata->x_align_spin = gtk_spin_button_new (adj, 0, 1);
- gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
- GTK_SIGNAL_FUNC (adjust_align), pdata);
+ g_signal_connect (adj, "value_changed",
+ G_CALLBACK (adjust_align), pdata);
gtk_box_pack_start (GTK_BOX (hbox), pdata->x_align_spin, FALSE, TRUE, 0);
gtk_widget_set_sensitive (pdata->x_align_spin, FALSE);
adj = (GtkAdjustment *) gtk_adjustment_new (0.5, 0, 1, 0.1, 0.1, 0);
pdata->y_align_spin = gtk_spin_button_new (adj, 0, 1);
- gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
- GTK_SIGNAL_FUNC (adjust_align), pdata);
+ g_signal_connect (adj, "value_changed",
+ G_CALLBACK (adjust_align), pdata);
gtk_box_pack_start (GTK_BOX (hbox), pdata->y_align_spin, FALSE, TRUE, 0);
gtk_widget_set_sensitive (pdata->y_align_spin, FALSE);
+ label = gtk_label_new ("Ellipsize text :");
+ gtk_table_attach (GTK_TABLE (tab), label, 0, 1, 10, 11,
+ GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
+ 5, 5);
+ gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
+ pdata->elmenu = build_option_menu (ellipsize_items,
+ sizeof (ellipsize_items) / sizeof (ellipsize_items[0]),
+ 2, // PANGO_ELLIPSIZE_MIDDLE
+ progressbar_toggle_ellipsize,
+ pdata);
+ hbox = gtk_hbox_new (FALSE, 0);
+ gtk_table_attach (GTK_TABLE (tab), hbox, 1, 2, 10, 11,
+ GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
+ 5, 5);
+ gtk_box_pack_start (GTK_BOX (hbox), pdata->elmenu, TRUE, TRUE, 0);
+
label = gtk_label_new ("Bar Style :");
- gtk_table_attach (GTK_TABLE (tab), label, 0, 1, 3, 4,
+ gtk_table_attach (GTK_TABLE (tab), label, 0, 1, 13, 14,
GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
5, 5);
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
progressbar_toggle_bar_style,
pdata);
hbox = gtk_hbox_new (FALSE, 0);
- gtk_table_attach (GTK_TABLE (tab), hbox, 1, 2, 3, 4,
+ gtk_table_attach (GTK_TABLE (tab), hbox, 1, 2, 13, 14,
GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
5, 5);
gtk_box_pack_start (GTK_BOX (hbox), pdata->omenu2, TRUE, TRUE, 0);
label = gtk_label_new ("Block count :");
- gtk_table_attach (GTK_TABLE (tab), label, 0, 1, 4, 5,
+ gtk_table_attach (GTK_TABLE (tab), label, 0, 1, 14, 15,
GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
5, 5);
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
hbox = gtk_hbox_new (FALSE, 0);
- gtk_table_attach (GTK_TABLE (tab), hbox, 1, 2, 4, 5,
+ gtk_table_attach (GTK_TABLE (tab), hbox, 1, 2, 14, 15,
GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
5, 5);
adj = (GtkAdjustment *) gtk_adjustment_new (10, 2, 20, 1, 5, 0);
pdata->block_spin = gtk_spin_button_new (adj, 0, 0);
- gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
- GTK_SIGNAL_FUNC (adjust_blocks), pdata);
+ g_signal_connect (adj, "value_changed",
+ G_CALLBACK (adjust_blocks), pdata);
gtk_box_pack_start (GTK_BOX (hbox), pdata->block_spin, FALSE, TRUE, 0);
gtk_widget_set_sensitive (pdata->block_spin, FALSE);
check = gtk_check_button_new_with_label ("Activity mode");
- gtk_signal_connect (GTK_OBJECT (check), "clicked",
- GTK_SIGNAL_FUNC (toggle_activity_mode),
- pdata);
- gtk_table_attach (GTK_TABLE (tab), check, 0, 1, 5, 6,
+ g_signal_connect (check, "clicked",
+ G_CALLBACK (toggle_activity_mode), pdata);
+ gtk_table_attach (GTK_TABLE (tab), check, 0, 1, 15, 16,
GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
5, 5);
hbox = gtk_hbox_new (FALSE, 0);
- gtk_table_attach (GTK_TABLE (tab), hbox, 1, 2, 5, 6,
+ gtk_table_attach (GTK_TABLE (tab), hbox, 1, 2, 15, 16,
GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
5, 5);
label = gtk_label_new ("Step size : ");
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
adj = (GtkAdjustment *) gtk_adjustment_new (3, 1, 20, 1, 5, 0);
pdata->step_spin = gtk_spin_button_new (adj, 0, 0);
- gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
- GTK_SIGNAL_FUNC (adjust_step), pdata);
+ g_signal_connect (adj, "value_changed",
+ G_CALLBACK (adjust_step), pdata);
gtk_box_pack_start (GTK_BOX (hbox), pdata->step_spin, FALSE, TRUE, 0);
gtk_widget_set_sensitive (pdata->step_spin, FALSE);
hbox = gtk_hbox_new (FALSE, 0);
- gtk_table_attach (GTK_TABLE (tab), hbox, 1, 2, 6, 7,
+ gtk_table_attach (GTK_TABLE (tab), hbox, 1, 2, 16, 17,
GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
5, 5);
label = gtk_label_new ("Blocks : ");
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
adj = (GtkAdjustment *) gtk_adjustment_new (5, 2, 10, 1, 5, 0);
pdata->act_blocks_spin = gtk_spin_button_new (adj, 0, 0);
- gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
- GTK_SIGNAL_FUNC (adjust_act_blocks), pdata);
+ g_signal_connect (adj, "value_changed",
+ G_CALLBACK (adjust_act_blocks), pdata);
gtk_box_pack_start (GTK_BOX (hbox), pdata->act_blocks_spin, FALSE, TRUE,
0);
gtk_widget_set_sensitive (pdata->act_blocks_spin, FALSE);
button = gtk_button_new_with_label ("close");
- gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
- GTK_SIGNAL_FUNC (gtk_widget_destroy),
- GTK_OBJECT (pdata->window));
+ g_signal_connect_swapped (button, "clicked",
+ G_CALLBACK (gtk_widget_destroy),
+ pdata->window);
GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (pdata->window)->action_area),
button, TRUE, TRUE, 0);
gtk_widget_grab_default (button);
}
- if (!GTK_WIDGET_VISIBLE (pdata->window))
+ if (!gtk_widget_get_visible (pdata->window))
gtk_widget_show_all (pdata->window);
else
gtk_widget_destroy (pdata->window);
* but within the allocation are not counted. This is consistent
* with the way we highlight drag targets.
*/
- if (!GTK_WIDGET_NO_WINDOW (widget))
+ if (gtk_widget_get_has_window (widget))
{
new_allocation.x = 0;
new_allocation.y = 0;
while (window != widget->parent->window)
{
gint tx, ty, twidth, theight;
- gdk_window_get_size (window, &twidth, &theight);
+ gdk_drawable_get_size (window, &twidth, &theight);
if (new_allocation.x < 0)
{
}
static GtkWidget *
-find_widget_at_pointer (void)
+find_widget_at_pointer (GdkDisplay *display)
{
GtkWidget *widget = NULL;
GdkWindow *pointer_window;
gint x, y;
FindWidgetData data;
- pointer_window = gdk_window_at_pointer (NULL, NULL);
+ pointer_window = gdk_display_get_window_at_pointer (display, NULL, NULL);
if (pointer_window)
- gdk_window_get_user_data (pointer_window, (gpointer*) &widget);
+ {
+ gpointer widget_ptr;
+
+ gdk_window_get_user_data (pointer_window, &widget_ptr);
+ widget = widget_ptr;
+ }
if (widget)
{
if (data->cursor)
{
- gdk_cursor_destroy (data->cursor);
+ gdk_cursor_unref (data->cursor);
data->cursor = NULL;
}
if (data->handler)
{
- gtk_signal_disconnect (widget, data->handler);
+ g_signal_handler_disconnect (widget, data->handler);
data->handler = 0;
}
if (event->type == GDK_BUTTON_RELEASE)
{
gtk_grab_remove (widget);
- gdk_pointer_ungrab (GDK_CURRENT_TIME);
+ gdk_display_pointer_ungrab (gtk_widget_get_display (widget),
+ GDK_CURRENT_TIME);
- res_widget = find_widget_at_pointer ();
+ res_widget = find_widget_at_pointer (gtk_widget_get_display (widget));
if (res_widget)
- create_prop_editor (G_OBJECT (res_widget), 0);
+ {
+ g_object_set_data (G_OBJECT (res_widget), "prop-editor-screen",
+ gtk_widget_get_screen (widget));
+ create_prop_editor (G_OBJECT (res_widget), 0);
+ }
data->in_query = FALSE;
}
{
gint failure;
- gtk_signal_connect (GTK_OBJECT (button), "event",
- (GtkSignalFunc) property_query_event, data);
+ g_signal_connect (button, "event",
+ G_CALLBACK (property_query_event), data);
if (!data->cursor)
- data->cursor = gdk_cursor_new (GDK_TARGET);
+ data->cursor = gdk_cursor_new_for_display (gtk_widget_get_display (GTK_WIDGET (button)),
+ GDK_TARGET);
failure = gdk_pointer_grab (GTK_WIDGET (button)->window,
TRUE,
}
static void
-create_properties (void)
+create_properties (GtkWidget *widget)
{
static GtkWidget *window = NULL;
GtkWidget *button;
{
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
- data->handler = gtk_signal_connect (GTK_OBJECT (window), "destroy",
- GTK_SIGNAL_FUNC(destroy_properties),
- data);
+ gtk_window_set_screen (GTK_WINDOW (window),
+ gtk_widget_get_screen (widget));
+
+ data->handler = g_signal_connect (window, "destroy",
+ G_CALLBACK (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_box_pack_start (GTK_BOX (vbox), button, TRUE, TRUE, 0);
- gtk_signal_connect (GTK_OBJECT (button), "clicked",
- GTK_SIGNAL_FUNC(query_properties),
- data);
+ g_signal_connect (button, "clicked",
+ G_CALLBACK (query_properties),
+ data);
+ }
+
+ if (!gtk_widget_get_visible (window))
+ gtk_widget_show_all (window);
+ else
+ gtk_widget_destroy (window);
+
+}
+
+struct SnapshotData {
+ GtkWidget *toplevel_button;
+ GtkWidget **window;
+ GdkCursor *cursor;
+ gboolean in_query;
+ gboolean is_toplevel;
+ gint handler;
+};
+
+static void
+destroy_snapshot_data (GtkWidget *widget,
+ struct SnapshotData *data)
+{
+ if (*data->window)
+ *data->window = NULL;
+
+ if (data->cursor)
+ {
+ gdk_cursor_unref (data->cursor);
+ data->cursor = NULL;
+ }
+
+ if (data->handler)
+ {
+ g_signal_handler_disconnect (widget, data->handler);
+ data->handler = 0;
+ }
+
+ g_free (data);
+}
+
+static gint
+snapshot_widget_event (GtkWidget *widget,
+ GdkEvent *event,
+ struct SnapshotData *data)
+{
+ GtkWidget *res_widget = NULL;
+
+ if (!data->in_query)
+ return FALSE;
+
+ if (event->type == GDK_BUTTON_RELEASE)
+ {
+ gtk_grab_remove (widget);
+ gdk_display_pointer_ungrab (gtk_widget_get_display (widget),
+ GDK_CURRENT_TIME);
+
+ res_widget = find_widget_at_pointer (gtk_widget_get_display (widget));
+ if (data->is_toplevel && res_widget)
+ res_widget = gtk_widget_get_toplevel (res_widget);
+ if (res_widget)
+ {
+ GdkPixmap *pixmap;
+ GtkWidget *window, *image;
+
+ window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+ pixmap = gtk_widget_get_snapshot (res_widget, NULL);
+ gtk_widget_realize (window);
+ if (gdk_drawable_get_depth (window->window) != gdk_drawable_get_depth (pixmap))
+ {
+ /* this branch is needed to convert ARGB -> RGB */
+ int width, height;
+ GdkPixbuf *pixbuf;
+ gdk_drawable_get_size (pixmap, &width, &height);
+ pixbuf = gdk_pixbuf_get_from_drawable (NULL, pixmap,
+ gtk_widget_get_colormap (res_widget),
+ 0, 0,
+ 0, 0,
+ width, height);
+ image = gtk_image_new_from_pixbuf (pixbuf);
+ g_object_unref (pixbuf);
+ }
+ else
+ image = gtk_image_new_from_pixmap (pixmap, NULL);
+ gtk_container_add (GTK_CONTAINER (window), image);
+ g_object_unref (pixmap);
+ gtk_widget_show_all (window);
+ }
+
+ data->in_query = FALSE;
+ }
+ return FALSE;
+}
+
+
+static void
+snapshot_widget (GtkButton *button,
+ struct SnapshotData *data)
+{
+ gint failure;
+
+ g_signal_connect (button, "event",
+ G_CALLBACK (snapshot_widget_event), data);
+
+ data->is_toplevel = GTK_WIDGET (button) == data->toplevel_button;
+
+ if (!data->cursor)
+ data->cursor = gdk_cursor_new_for_display (gtk_widget_get_display (GTK_WIDGET (button)),
+ 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_snapshot (GtkWidget *widget)
+{
+ static GtkWidget *window = NULL;
+ GtkWidget *button;
+ GtkWidget *vbox;
+ struct SnapshotData *data;
+
+ data = g_new (struct SnapshotData, 1);
+ data->window = &window;
+ data->in_query = FALSE;
+ data->cursor = NULL;
+ data->handler = 0;
+
+ if (!window)
+ {
+ window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+
+ gtk_window_set_screen (GTK_WINDOW (window),
+ gtk_widget_get_screen (widget));
+
+ data->handler = g_signal_connect (window, "destroy",
+ G_CALLBACK (destroy_snapshot_data),
+ data);
+
+ gtk_window_set_title (GTK_WINDOW (window), "test snapshot");
+ gtk_container_set_border_width (GTK_CONTAINER (window), 10);
+
+ vbox = gtk_vbox_new (FALSE, 1);
+ gtk_container_add (GTK_CONTAINER (window), vbox);
+
+ button = gtk_button_new_with_label ("Snapshot widget");
+ gtk_box_pack_start (GTK_BOX (vbox), button, TRUE, TRUE, 0);
+ g_signal_connect (button, "clicked",
+ G_CALLBACK (snapshot_widget),
+ data);
+
+ button = gtk_button_new_with_label ("Snapshot toplevel");
+ data->toplevel_button = button;
+ gtk_box_pack_start (GTK_BOX (vbox), button, TRUE, TRUE, 0);
+ g_signal_connect (button, "clicked",
+ G_CALLBACK (snapshot_widget),
+ data);
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
}
+
/*
* Color Preview
*/
count += 1;
- gtk_widget_draw (preview, NULL);
+ gtk_widget_queue_draw (preview);
+ gdk_window_process_updates (preview->window, TRUE);
return TRUE;
}
}
void
-create_color_preview (void)
+create_color_preview (GtkWidget *widget)
{
static GtkWidget *window = NULL;
GtkWidget *preview;
if (!window)
{
- gtk_widget_push_colormap (gdk_rgb_get_cmap ());
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
- gtk_widget_pop_colormap ();
+
+ gtk_window_set_screen (GTK_WINDOW (window),
+ gtk_widget_get_screen (widget));
- gtk_signal_connect (GTK_OBJECT (window), "destroy",
- GTK_SIGNAL_FUNC(color_preview_destroy),
- &window);
+ g_signal_connect (window, "destroy",
+ G_CALLBACK (color_preview_destroy),
+ &window);
gtk_window_set_title (GTK_WINDOW (window), "test");
gtk_container_set_border_width (GTK_CONTAINER (window), 10);
color_idle = gtk_idle_add ((GtkFunction) color_idle_func, preview);
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
}
void
-create_gray_preview (void)
+create_gray_preview (GtkWidget *widget)
{
static GtkWidget *window = NULL;
GtkWidget *preview;
{
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
- gtk_signal_connect (GTK_OBJECT (window), "destroy",
- GTK_SIGNAL_FUNC(gray_preview_destroy),
- &window);
+ gtk_window_set_screen (GTK_WINDOW (window),
+ gtk_widget_get_screen (widget));
+
+ g_signal_connect (window, "destroy",
+ G_CALLBACK (gray_preview_destroy),
+ &window);
gtk_window_set_title (GTK_WINDOW (window), "test");
gtk_container_set_border_width (GTK_CONTAINER (window), 10);
gray_idle = gtk_idle_add ((GtkFunction) gray_idle_func, preview);
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
}
void
-create_selection_test (void)
+create_selection_test (GtkWidget *widget)
{
static GtkWidget *window = NULL;
GtkWidget *button;
if (!window)
{
window = gtk_dialog_new ();
+
+ gtk_window_set_screen (GTK_WINDOW (window),
+ gtk_widget_get_screen (widget));
- gtk_signal_connect (GTK_OBJECT (window), "destroy",
- GTK_SIGNAL_FUNC(gtk_widget_destroyed),
- &window);
+ g_signal_connect (window, "destroy",
+ G_CALLBACK (gtk_widget_destroyed),
+ &window);
gtk_window_set_title (GTK_WINDOW (window), "Selection Test");
gtk_container_set_border_width (GTK_CONTAINER (window), 0);
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_box_pack_start (GTK_BOX (vbox), scrolled_win, TRUE, TRUE, 0);
- gtk_widget_set_usize (scrolled_win, 100, 200);
+ gtk_widget_set_size_request (scrolled_win, 100, 200);
list = gtk_list_new ();
gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (scrolled_win), list);
- gtk_signal_connect (GTK_OBJECT(list), "selection_received",
- GTK_SIGNAL_FUNC (selection_test_received), NULL);
+ g_signal_connect (list, "selection_received",
+ G_CALLBACK (selection_test_received), NULL);
/* .. And create some buttons */
button = gtk_button_new_with_label ("Get Targets");
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
button, TRUE, TRUE, 0);
- gtk_signal_connect (GTK_OBJECT (button), "clicked",
- GTK_SIGNAL_FUNC (selection_test_get_targets), list);
+ g_signal_connect (button, "clicked",
+ G_CALLBACK (selection_test_get_targets), list);
button = gtk_button_new_with_label ("Quit");
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
button, TRUE, TRUE, 0);
- gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
- GTK_SIGNAL_FUNC (gtk_widget_destroy),
- GTK_OBJECT (window));
+ g_signal_connect_swapped (button, "clicked",
+ G_CALLBACK (gtk_widget_destroy),
+ window);
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
*/
void
-create_gamma_curve (void)
+create_gamma_curve (GtkWidget *widget)
{
static GtkWidget *window = NULL, *curve;
static int count = 0;
gfloat vec[256];
gint max;
gint i;
-
+
if (!window)
{
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+ gtk_window_set_screen (GTK_WINDOW (window),
+ gtk_widget_get_screen (widget));
+
gtk_window_set_title (GTK_WINDOW (window), "test");
gtk_container_set_border_width (GTK_CONTAINER (window), 10);
- gtk_signal_connect (GTK_OBJECT (window), "destroy",
- GTK_SIGNAL_FUNC(gtk_widget_destroyed),
- &window);
+ g_signal_connect (window, "destroy",
+ G_CALLBACK(gtk_widget_destroyed),
+ &window);
curve = gtk_gamma_curve_new ();
gtk_container_add (GTK_CONTAINER (window), curve);
gtk_curve_set_vector (GTK_CURVE (GTK_GAMMA_CURVE (curve)->curve),
max, vec);
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
gtk_widget_show (window);
else if (count % 4 == 3)
{
adj->page_increment = 0.9 * widget->allocation.height;
adj->page_size = widget->allocation.height;
- gtk_signal_emit_by_name (GTK_OBJECT (adj), "changed");
+ g_signal_emit_by_name (adj, "changed");
}
static void
dy = scroll_test_pos - (int)adj->value;
scroll_test_pos = adj->value;
- if (!GTK_WIDGET_DRAWABLE (widget))
+ if (!gtk_widget_is_drawable (widget))
return;
gdk_window_scroll (widget->window, 0, dy);
gdk_window_process_updates (widget->window, FALSE);
void
-create_scroll_test (void)
+create_scroll_test (GtkWidget *widget)
{
static GtkWidget *window = NULL;
GtkWidget *hbox;
GtkAdjustment *adj;
GdkGeometry geometry;
GdkWindowHints geometry_mask;
-
+
if (!window)
{
window = gtk_dialog_new ();
- gtk_signal_connect (GTK_OBJECT (window), "destroy",
- GTK_SIGNAL_FUNC(gtk_widget_destroyed),
- &window);
+ gtk_window_set_screen (GTK_WINDOW (window),
+ gtk_widget_get_screen (widget));
+
+ g_signal_connect (window, "destroy",
+ G_CALLBACK (gtk_widget_destroyed),
+ &window);
gtk_window_set_title (GTK_WINDOW (window), "Scroll Test");
gtk_container_set_border_width (GTK_CONTAINER (window), 0);
gtk_widget_show (hbox);
drawing_area = gtk_drawing_area_new ();
- gtk_drawing_area_size (GTK_DRAWING_AREA (drawing_area), 200, 200);
+ gtk_widget_set_size_request (drawing_area, 200, 200);
gtk_box_pack_start (GTK_BOX (hbox), drawing_area, TRUE, TRUE, 0);
gtk_widget_show (drawing_area);
gtk_box_pack_start (GTK_BOX (hbox), scrollbar, FALSE, FALSE, 0);
gtk_widget_show (scrollbar);
- gtk_signal_connect (GTK_OBJECT (drawing_area), "expose_event",
- GTK_SIGNAL_FUNC (scroll_test_expose), adj);
- gtk_signal_connect (GTK_OBJECT (drawing_area), "configure_event",
- GTK_SIGNAL_FUNC (scroll_test_configure), adj);
- gtk_signal_connect (GTK_OBJECT (drawing_area), "scroll_event",
- GTK_SIGNAL_FUNC (scroll_test_scroll), adj);
+ g_signal_connect (drawing_area, "expose_event",
+ G_CALLBACK (scroll_test_expose), adj);
+ g_signal_connect (drawing_area, "configure_event",
+ G_CALLBACK (scroll_test_configure), adj);
+ g_signal_connect (drawing_area, "scroll_event",
+ G_CALLBACK (scroll_test_scroll), adj);
- gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
- GTK_SIGNAL_FUNC (scroll_test_adjustment_changed),
- drawing_area);
+ g_signal_connect (adj, "value_changed",
+ G_CALLBACK (scroll_test_adjustment_changed),
+ drawing_area);
/* .. And create some buttons */
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
button, TRUE, TRUE, 0);
- gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
- GTK_SIGNAL_FUNC (gtk_widget_destroy),
- GTK_OBJECT (window));
+ g_signal_connect_swapped (button, "clicked",
+ G_CALLBACK (gtk_widget_destroy),
+ window);
gtk_widget_show (button);
/* Set up gridded geometry */
drawing_area, &geometry, geometry_mask);
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
gtk_widget_show (window);
else
gtk_widget_destroy (window);
}
void
-create_timeout_test (void)
+create_timeout_test (GtkWidget *widget)
{
static GtkWidget *window = NULL;
GtkWidget *button;
{
window = gtk_dialog_new ();
- gtk_signal_connect (GTK_OBJECT (window), "destroy",
- GTK_SIGNAL_FUNC(destroy_timeout_test),
- &window);
+ gtk_window_set_screen (GTK_WINDOW (window),
+ gtk_widget_get_screen (widget));
+
+ g_signal_connect (window, "destroy",
+ G_CALLBACK (destroy_timeout_test),
+ &window);
gtk_window_set_title (GTK_WINDOW (window), "Timeout Test");
gtk_container_set_border_width (GTK_CONTAINER (window), 0);
gtk_widget_show (label);
button = gtk_button_new_with_label ("close");
- gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
- GTK_SIGNAL_FUNC(gtk_widget_destroy),
- GTK_OBJECT (window));
+ g_signal_connect_swapped (button, "clicked",
+ G_CALLBACK (gtk_widget_destroy),
+ 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);
button = gtk_button_new_with_label ("start");
- gtk_signal_connect (GTK_OBJECT (button), "clicked",
- GTK_SIGNAL_FUNC(start_timeout_test),
- label);
+ g_signal_connect (button, "clicked",
+ G_CALLBACK(start_timeout_test),
+ label);
GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
button, TRUE, TRUE, 0);
gtk_widget_show (button);
button = gtk_button_new_with_label ("stop");
- gtk_signal_connect (GTK_OBJECT (button), "clicked",
- GTK_SIGNAL_FUNC(stop_timeout_test),
- NULL);
+ g_signal_connect (button, "clicked",
+ G_CALLBACK (stop_timeout_test),
+ NULL);
GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
button, TRUE, TRUE, 0);
gtk_widget_show (button);
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
gtk_widget_show (window);
else
gtk_widget_destroy (window);
}
static void
-toggle_idle_container (GtkObject *button,
+toggle_idle_container (GObject *button,
GtkContainer *container)
{
- gtk_container_set_resize_mode (container, GPOINTER_TO_INT (gtk_object_get_user_data (button)));
+ gtk_container_set_resize_mode (container, GPOINTER_TO_INT (g_object_get_data (button, "user_data")));
}
static void
-create_idle_test (void)
+create_idle_test (GtkWidget *widget)
{
static GtkWidget *window = NULL;
GtkWidget *button;
window = gtk_dialog_new ();
- gtk_signal_connect (GTK_OBJECT (window), "destroy",
- GTK_SIGNAL_FUNC(destroy_idle_test),
- &window);
+ gtk_window_set_screen (GTK_WINDOW (window),
+ gtk_widget_get_screen (widget));
+
+ g_signal_connect (window, "destroy",
+ G_CALLBACK (destroy_idle_test),
+ &window);
gtk_window_set_title (GTK_WINDOW (window), "Idle Test");
gtk_container_set_border_width (GTK_CONTAINER (window), 0);
gtk_widget_show (label);
container =
- gtk_widget_new (GTK_TYPE_HBOX,
+ g_object_new (GTK_TYPE_HBOX,
"visible", TRUE,
- /* "GtkContainer::child", gtk_widget_new (GTK_TYPE_HBOX,
+ /* "GtkContainer::child", g_object_new (GTK_TYPE_HBOX,
* "GtkWidget::visible", TRUE,
*/
"child", label,
container, TRUE, TRUE, 0);
frame =
- gtk_widget_new (GTK_TYPE_FRAME,
+ g_object_new (GTK_TYPE_FRAME,
"border_width", 5,
"label", "Label Container",
"visible", TRUE,
"parent", GTK_DIALOG (window)->vbox,
NULL);
box =
- gtk_widget_new (GTK_TYPE_VBOX,
+ g_object_new (GTK_TYPE_VBOX,
"visible", TRUE,
"parent", frame,
NULL);
button =
- g_object_connect (gtk_widget_new (GTK_TYPE_RADIO_BUTTON,
+ g_object_connect (g_object_new (GTK_TYPE_RADIO_BUTTON,
"label", "Resize-Parent",
"user_data", (void*)GTK_RESIZE_PARENT,
"visible", TRUE,
NULL),
"signal::clicked", toggle_idle_container, container,
NULL);
- button = gtk_widget_new (GTK_TYPE_RADIO_BUTTON,
+ button = g_object_new (GTK_TYPE_RADIO_BUTTON,
"label", "Resize-Queue",
"user_data", (void*)GTK_RESIZE_QUEUE,
"group", button,
g_object_connect (button,
"signal::clicked", toggle_idle_container, container,
NULL);
- button2 = gtk_widget_new (GTK_TYPE_RADIO_BUTTON,
+ button2 = g_object_new (GTK_TYPE_RADIO_BUTTON,
"label", "Resize-Immediate",
"user_data", (void*)GTK_RESIZE_IMMEDIATE,
NULL);
NULL);
button = gtk_button_new_with_label ("close");
- gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
- GTK_SIGNAL_FUNC(gtk_widget_destroy),
- GTK_OBJECT (window));
+ g_signal_connect_swapped (button, "clicked",
+ G_CALLBACK (gtk_widget_destroy),
+ 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);
button = gtk_button_new_with_label ("start");
- gtk_signal_connect (GTK_OBJECT (button), "clicked",
- GTK_SIGNAL_FUNC(start_idle_test),
- label);
+ g_signal_connect (button, "clicked",
+ G_CALLBACK (start_idle_test),
+ label);
GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
button, TRUE, TRUE, 0);
gtk_widget_show (button);
button = gtk_button_new_with_label ("stop");
- gtk_signal_connect (GTK_OBJECT (button), "clicked",
- GTK_SIGNAL_FUNC(stop_idle_test),
- NULL);
+ g_signal_connect (button, "clicked",
+ G_CALLBACK (stop_idle_test),
+ NULL);
GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
button, TRUE, TRUE, 0);
gtk_widget_show (button);
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
gtk_widget_show (window);
else
gtk_widget_destroy (window);
{
static GdkAtom atom_rcfiles = GDK_NONE;
- GdkEventClient sev;
+ GdkEvent *send_event = gdk_event_new (GDK_CLIENT_EVENT);
int i;
if (!atom_rcfiles)
atom_rcfiles = gdk_atom_intern("_GTK_READ_RCFILES", FALSE);
for(i = 0; i < 5; i++)
- sev.data.l[i] = 0;
- sev.data_format = 32;
- sev.message_type = atom_rcfiles;
- gdk_event_send_clientmessage_toall ((GdkEvent *) &sev);
+ send_event->client.data.l[i] = 0;
+ send_event->client.data_format = 32;
+ send_event->client.message_type = atom_rcfiles;
+ gdk_event_send_clientmessage_toall (send_event);
+
+ gdk_event_free (send_event);
}
void
-create_rc_file (void)
+create_rc_file (GtkWidget *widget)
{
static GtkWidget *window = NULL;
GtkWidget *button;
{
window = gtk_dialog_new ();
- gtk_signal_connect (GTK_OBJECT (window), "destroy",
- GTK_SIGNAL_FUNC(destroy_idle_test),
- &window);
+ gtk_window_set_screen (GTK_WINDOW (window),
+ gtk_widget_get_screen (widget));
+
+ g_signal_connect (window, "destroy",
+ G_CALLBACK (gtk_widget_destroyed),
+ &window);
frame = gtk_aspect_frame_new ("Testing RC file prioritization", 0.5, 0.5, 0.0, TRUE);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), frame, FALSE, FALSE, 0);
gtk_container_set_border_width (GTK_CONTAINER (window), 0);
button = gtk_button_new_with_label ("Reload");
- gtk_signal_connect (GTK_OBJECT (button), "clicked",
- GTK_SIGNAL_FUNC(gtk_rc_reparse_all), NULL);
+ g_signal_connect (button, "clicked",
+ G_CALLBACK (gtk_rc_reparse_all), NULL);
GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
button, TRUE, TRUE, 0);
gtk_widget_grab_default (button);
button = gtk_button_new_with_label ("Reload All");
- gtk_signal_connect (GTK_OBJECT (button), "clicked",
- GTK_SIGNAL_FUNC(reload_all_rc_files), NULL);
+ g_signal_connect (button, "clicked",
+ G_CALLBACK (reload_all_rc_files), NULL);
GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
button, TRUE, TRUE, 0);
button = gtk_button_new_with_label ("Close");
- gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
- GTK_SIGNAL_FUNC(gtk_widget_destroy),
- GTK_OBJECT (window));
+ g_signal_connect_swapped (button, "clicked",
+ G_CALLBACK (gtk_widget_destroy),
+ window);
GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
button, TRUE, TRUE, 0);
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
}
void
-create_mainloop (void)
+create_mainloop (GtkWidget *widget)
{
static GtkWidget *window = NULL;
GtkWidget *label;
{
window = gtk_dialog_new ();
+ gtk_window_set_screen (GTK_WINDOW (window),
+ gtk_widget_get_screen (widget));
+
gtk_window_set_title (GTK_WINDOW (window), "Test Main Loop");
- gtk_signal_connect (GTK_OBJECT (window), "destroy",
- GTK_SIGNAL_FUNC(mainloop_destroyed),
- &window);
+ g_signal_connect (window, "destroy",
+ G_CALLBACK (mainloop_destroyed),
+ &window);
label = gtk_label_new ("In recursive main loop...");
gtk_misc_set_padding (GTK_MISC(label), 20, 20);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area), button,
FALSE, TRUE, 0);
- gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
- GTK_SIGNAL_FUNC (gtk_widget_destroy),
- GTK_OBJECT (window));
+ g_signal_connect_swapped (button, "clicked",
+ G_CALLBACK (gtk_widget_destroy),
+ window);
GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
gtk_widget_grab_default (button);
gtk_widget_show (button);
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
{
gtk_widget_show (window);
return FALSE;
}
-void create_layout (void)
+void create_layout (GtkWidget *widget)
{
static GtkWidget *window = NULL;
GtkWidget *layout;
gint i, j;
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
- gtk_signal_connect (GTK_OBJECT (window), "destroy",
- GTK_SIGNAL_FUNC(gtk_widget_destroyed),
- &window);
+ gtk_window_set_screen (GTK_WINDOW (window),
+ gtk_widget_get_screen (widget));
+
+ g_signal_connect (window, "destroy",
+ G_CALLBACK (gtk_widget_destroyed),
+ &window);
gtk_window_set_title (GTK_WINDOW (window), "Layout");
- gtk_widget_set_usize (window, 200, 200);
+ gtk_widget_set_size_request (window, 200, 200);
scrolledwindow = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolledwindow),
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);
+ g_signal_connect (layout, "expose_event",
+ G_CALLBACK (layout_expose_handler), NULL);
gtk_layout_set_size (GTK_LAYOUT (layout), 1600, 128000);
}
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
}
void
-create_styles (void)
+create_styles (GtkWidget *widget)
{
static GtkWidget *window = NULL;
GtkWidget *label;
if (!window)
{
window = gtk_dialog_new ();
- gtk_signal_connect (GTK_OBJECT (window), "destroy",
- GTK_SIGNAL_FUNC(gtk_widget_destroyed),
- &window);
+ gtk_window_set_screen (GTK_WINDOW (window),
+ gtk_widget_get_screen (widget));
+
+ g_signal_connect (window, "destroy",
+ G_CALLBACK (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));
+ g_signal_connect_swapped (button, "clicked",
+ G_CALLBACK (gtk_widget_destroy),
+ 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_modify_base (entry, GTK_STATE_NORMAL, &yellow);
gtk_box_pack_start (GTK_BOX (vbox), entry, FALSE, FALSE, 0);
+ label = gtk_label_new ("Cursor:");
+ 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_cursor (entry, &red, &red);
+ 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);
gtk_widget_modify_style (button, rc_style);
gtk_widget_modify_style (GTK_BIN (button)->child, rc_style);
- g_object_unref (G_OBJECT (rc_style));
+ g_object_unref (rc_style);
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
struct {
char *label;
- void (*func) ();
+ void (*func) (GtkWidget *widget);
gboolean do_not_benchmark;
} buttons[] =
{
+ { "alpha window", create_alpha_window },
{ "big windows", create_big_windows },
{ "button box", create_button_box },
{ "buttons", create_buttons },
{ "check buttons", create_check_buttons },
{ "clist", create_clist},
{ "color selection", create_color_selection },
+ { "composited window", create_composited_window },
{ "ctree", create_ctree },
{ "cursors", create_cursors },
{ "dialog", create_dialog },
+ { "display & screen", create_display_screen, TRUE },
{ "entry", create_entry },
+ { "event box", create_event_box },
{ "event watcher", create_event_watcher },
+ { "expander", create_expander },
{ "file selection", create_file_selection },
{ "flipping", create_flipping },
{ "focus", create_focus },
{ "font selection", create_font_selection },
{ "gamma curve", create_gamma_curve, TRUE },
+ { "gridded geometry", create_gridded_geometry },
{ "handle box", create_handle_box },
{ "image from drawable", create_get_image },
{ "image", create_image },
{ "range controls", create_range_controls },
{ "rc file", create_rc_file },
{ "reparent", create_reparent },
+ { "resize grips", create_resize_grips },
+ { "rotated label", create_rotated_label },
+ { "rotated text", create_rotated_text },
{ "rulers", create_rulers },
{ "saved position", create_saved_position },
{ "scrolled windows", create_scrolled_windows },
{ "shapes", create_shapes },
{ "size groups", create_size_groups },
+ { "snapshot", create_snapshot },
{ "spinbutton", create_spins },
{ "statusbar", create_statusbar },
{ "styles", create_styles },
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_widget_set_name (window, "main window");
- gtk_widget_set_uposition (window, 20, 20);
+ gtk_widget_set_uposition (window, 50, 20);
gtk_window_set_default_size (GTK_WINDOW (window), -1, 400);
geometry.min_width = -1;
&geometry,
GDK_HINT_MIN_SIZE | GDK_HINT_MAX_SIZE);
- gtk_signal_connect (GTK_OBJECT (window), "destroy",
- GTK_SIGNAL_FUNC(gtk_main_quit),
- NULL);
- gtk_signal_connect (GTK_OBJECT (window), "delete-event",
- GTK_SIGNAL_FUNC (gtk_false),
- NULL);
+ g_signal_connect (window, "destroy",
+ G_CALLBACK (gtk_main_quit),
+ NULL);
+ g_signal_connect (window, "delete-event",
+ G_CALLBACK (gtk_false),
+ NULL);
box1 = gtk_vbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER (window), box1);
{
button = gtk_button_new_with_label (buttons[i].label);
if (buttons[i].func)
- gtk_signal_connect (GTK_OBJECT (button),
- "clicked",
- GTK_SIGNAL_FUNC(buttons[i].func),
- NULL);
+ g_signal_connect (button,
+ "clicked",
+ G_CALLBACK(buttons[i].func),
+ NULL);
else
gtk_widget_set_sensitive (button, FALSE);
gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
button = gtk_button_new_with_mnemonic ("_Close");
- gtk_signal_connect (GTK_OBJECT (button), "clicked",
- GTK_SIGNAL_FUNC (do_exit),
- window);
+ g_signal_connect (button, "clicked",
+ G_CALLBACK (do_exit),
+ window);
gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
gtk_widget_grab_default (button);
}
static void
-test_init ()
+test_init (void)
{
- if (file_exists ("../gdk-pixbuf/libpixbufloader-pnm.la"))
+ if (g_file_test ("../gdk-pixbuf/libpixbufloader-pnm.la",
+ G_FILE_TEST_EXISTS))
{
- putenv ("GDK_PIXBUF_MODULEDIR=../gdk-pixbuf");
- putenv ("GTK_IM_MODULE_FILE=../modules/input/gtk.immodules");
+ g_setenv ("GDK_PIXBUF_MODULE_FILE", "../gdk-pixbuf/gdk-pixbuf.loaders", TRUE);
+ g_setenv ("GTK_IM_MODULE_FILE", "../modules/input/gtk.immodules", TRUE);
}
}
}
static void
-bench_iteration (void (* fn) ())
+bench_iteration (GtkWidget *widget, void (* fn) (GtkWidget *widget))
{
- fn (); /* on */
- while (g_main_iteration (FALSE));
- fn (); /* off */
- while (g_main_iteration (FALSE));
+ fn (widget); /* on */
+ while (g_main_context_iteration (NULL, FALSE));
+ fn (widget); /* off */
+ while (g_main_context_iteration (NULL, FALSE));
}
void
-do_real_bench (void (* fn) (), char *name, int num)
+do_real_bench (GtkWidget *widget, void (* fn) (GtkWidget *widget), char *name, int num)
{
GTimeVal tv0, tv1;
double dt_first;
}
g_get_current_time (&tv0);
- bench_iteration (fn);
+ bench_iteration (widget, fn);
g_get_current_time (&tv1);
dt_first = ((double)tv1.tv_sec - tv0.tv_sec) * 1000.0
g_get_current_time (&tv0);
for (n = 0; n < num - 1; n++)
- bench_iteration (fn);
+ bench_iteration (widget, fn);
g_get_current_time (&tv1);
dt = ((double)tv1.tv_sec - tv0.tv_sec) * 1000.0
+ (tv1.tv_usec - tv0.tv_usec) / 1000.0;
do_bench (char* what, int num)
{
int i;
- void (* fn) ();
+ GtkWidget *widget;
+ void (* fn) (GtkWidget *widget);
fn = NULL;
+ widget = gtk_window_new (GTK_WINDOW_TOPLEVEL);
- if (g_strcasecmp (what, "ALL") == 0)
+ if (g_ascii_strcasecmp (what, "ALL") == 0)
{
for (i = 0; i < nbuttons; i++)
{
if (!buttons[i].do_not_benchmark)
- do_real_bench (buttons[i].func, buttons[i].label, num);
+ do_real_bench (widget, buttons[i].func, buttons[i].label, num);
}
return;
if (!fn)
g_print ("Can't bench: \"%s\" not found.\n", what);
else
- do_real_bench (fn, buttons[i].label, num);
+ do_real_bench (widget, fn, buttons[i].label, num);
}
}
*/
if (file_exists ("testgtkrc"))
gtk_rc_add_default_file ("testgtkrc");
+ else if (file_exists ("tests/testgtkrc"))
+ gtk_rc_add_default_file ("tests/testgtkrc");
+ else
+ g_warning ("Couldn't find file \"testgtkrc\".");
+
+ g_set_application_name ("GTK+ Test Program");
gtk_init (&argc, &argv);
+ gtk_accelerator_set_default_mod_mask (GDK_SHIFT_MASK |
+ GDK_CONTROL_MASK |
+ GDK_MOD1_MASK |
+ GDK_META_MASK |
+ GDK_SUPER_MASK |
+ GDK_HYPER_MASK |
+ GDK_MOD4_MASK);
/* benchmarking
*/
for (i = 1; i < argc; i++)
/* bindings test
*/
- binding_set = gtk_binding_set_by_class (gtk_type_class (GTK_TYPE_WIDGET));
+ binding_set = gtk_binding_set_by_class (g_type_class_ref (GTK_TYPE_WIDGET));
gtk_binding_entry_add_signal (binding_set,
'9', GDK_CONTROL_MASK | GDK_RELEASE_MASK,
"debug_msg",
1,
- GTK_TYPE_STRING, "GtkWidgetClass <ctrl><release>9 test");
+ G_TYPE_STRING, "GtkWidgetClass <ctrl><release>9 test");
/* We use gtk_rc_parse_string() here so we can make sure it works across theme
* changes
if (1)
{
- while (g_main_pending ())
- g_main_iteration (FALSE);
+ while (g_main_context_pending (NULL))
+ g_main_context_iteration (NULL, FALSE);
#if 0
sleep (1);
- while (g_main_pending ())
- g_main_iteration (FALSE);
+ while (g_main_context_pending (NULL))
+ g_main_context_iteration (NULL, FALSE);
#endif
}
return 0;
projects / ~andy / gtk / blobdiff