build_option_menu (gchar *items[],
gint num_items,
gint history,
- void (*func)(GtkWidget *widget, gpointer data),
+ void (*func) (GtkWidget *widget, gpointer data),
gpointer data);
/* macro, structure and variables used by tree window demos */
}
+/*
+ * 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
*/
}
- 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);
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_set_can_default (button[9], TRUE);
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);
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_set_can_default (button, TRUE);
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_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);
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);
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);
gtk_widget_get_screen (widget));
gtk_window_set_title (GTK_WINDOW (window), "Toolbar test");
- gtk_window_set_resizable (GTK_WINDOW (window), FALSE);
g_signal_connect (window, "destroy",
G_CALLBACK (gtk_widget_destroyed),
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_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)
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,
"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);
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_set_can_default (button, TRUE);
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);
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);
create_gridded_geometry (GtkWidget *widget)
{
static GtkWidget *window = NULL;
+ gpointer window_ptr;
GtkWidget *entry;
GtkWidget *label;
g_signal_connect (window, "response",
G_CALLBACK (gridded_geometry_response), entry);
- g_object_add_weak_pointer (G_OBJECT (window), (gpointer *)&window);
+ window_ptr = &window;
+ g_object_add_weak_pointer (G_OBJECT (window), window_ptr);
gtk_widget_show_all (window);
}
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);
g_signal_connect (window, "destroy",
G_CALLBACK (gtk_widget_destroyed),
"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);
src);
gtk_box_pack_start (GTK_BOX (hbox),
- sw, TRUE, TRUE, 0);
+ sw, TRUE, TRUE, 0);
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;
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));
g_signal_connect (button,
"toggled",
return button;
}
+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;
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);
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
frame = gtk_frame_new ("Bidirection Label");
- label = gtk_label_new ("Arabic \330\247\331\204\330\263\331\204\330\247\331\205 \330\271\331\204\331\212\331\203\331\205\n"
- "Hebrew \327\251\327\234\327\225\327\235");
- 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);
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
}
-/*
- * Reparent demo
- */
-
-static void
-reparent_label (GtkWidget *widget,
- GtkWidget *new_parent)
-{
- GtkWidget *label;
-
- label = g_object_get_data (G_OBJECT (widget), "user_data");
-
- gtk_widget_reparent (label, new_parent);
-}
-
static void
-set_parent_signal (GtkWidget *child,
- GtkWidget *old_parent,
- gpointer func_data)
+on_angle_scale_changed (GtkRange *range,
+ GtkLabel *label)
{
- g_print ("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));
+ gtk_label_set_angle (GTK_LABEL (label), gtk_range_get_value (range));
}
static void
-create_reparent (GtkWidget *widget)
+create_rotated_label (GtkWidget *widget)
{
static GtkWidget *window = NULL;
- GtkWidget *box1;
- GtkWidget *box2;
- GtkWidget *box3;
- GtkWidget *frame;
- GtkWidget *button;
- GtkWidget *label;
- GtkWidget *separator;
- GtkWidget *event_box;
+ 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);
+
+ 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_get_visible (window))
+ gtk_widget_show (window);
+ else
+ gtk_widget_destroy (window);
+}
+
+/*
+ * Reparent demo
+ */
+
+static void
+reparent_label (GtkWidget *widget,
+ GtkWidget *new_parent)
+{
+ GtkWidget *label;
+
+ label = g_object_get_data (G_OBJECT (widget), "user_data");
+
+ gtk_widget_reparent (label, new_parent);
+}
+
+static void
+set_parent_signal (GtkWidget *child,
+ GtkWidget *old_parent,
+ gpointer 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 (GtkWidget *widget)
+{
+ static GtkWidget *window = NULL;
+ GtkWidget *box1;
+ GtkWidget *box2;
+ GtkWidget *box3;
+ GtkWidget *frame;
+ GtkWidget *button;
+ GtkWidget *label;
+ GtkWidget *separator;
+ GtkWidget *event_box;
if (!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_set_can_default (button, TRUE);
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);
GINT_TO_POINTER (GDK_WINDOW_EDGE_SOUTH_EAST));
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
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,
"title", "Saved Position",
NULL),
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,
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);
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_set_can_default (button, TRUE);
gtk_widget_grab_default (button);
gtk_widget_show_all (window);
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_set_can_default (button, TRUE);
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);
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",
"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,
"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,
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_set_can_default (button, TRUE);
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);
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);
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 (GtkWidget *widget)
{
gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), menu);
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 (screen, 3, 5, TRUE));
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_set_can_default (button, TRUE);
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);
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 },
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_set_can_default (button, TRUE);
gtk_widget_grab_default (button);
gtk_item_factory_delete_item (item_factory, "/Preferences/ShouldNotAppear");
create_key_lookup (GtkWidget *widget)
{
static GtkWidget *window = NULL;
+ gpointer window_ptr;
if (!window)
{
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);
GdkScreen *screen = gtk_widget_get_screen (widget);
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_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_YES);
+ make_message_dialog (screen, &question, GTK_MESSAGE_QUESTION, GTK_BUTTONS_YES_NO, GTK_RESPONSE_NO);
}
/*
g_signal_connect_swapped (button, "clicked",
G_CALLBACK (gtk_widget_destroy),
window);
- GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
+ gtk_widget_set_can_default (button, TRUE);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
button, TRUE, TRUE, 0);
gtk_widget_grab_default (button);
g_signal_connect (button, "clicked",
G_CALLBACK (scrolled_windows_remove),
scrolled_window);
- GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
+ gtk_widget_set_can_default (button, TRUE);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
button, TRUE, TRUE, 0);
gtk_widget_grab_default (button);
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);
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_props_clicked (GtkWidget *button,
- GObject *entry)
+entry_toggle_progress (GtkWidget *checkbutton,
+ GtkWidget *entry)
{
- GtkWidget *window = create_prop_editor (entry, 0);
+ 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_window_set_title (GTK_WINDOW (window), "Entry Properties");
+ gtk_entry_set_progress_fraction (GTK_ENTRY (entry), 0.0);
+ }
+}
+
+static void
+entry_toggle_pulse (GtkWidget *checkbutton,
+ GtkWidget *entry)
+{
+ g_object_set_data (G_OBJECT (entry), "progress-pulse",
+ GUINT_TO_POINTER ((guint) GTK_TOGGLE_BUTTON (checkbutton)->active));
+}
+
+static void
+props_clicked (GtkWidget *button,
+ GObject *object)
+{
+ GtkWidget *window = create_prop_editor (object, 0);
+
+ gtk_window_set_title (GTK_WINDOW (window), "Object Properties");
}
static void
GtkWidget *hbox;
GtkWidget *has_frame_check;
GtkWidget *sensitive_check;
+ GtkWidget *progress_check;
GtkWidget *entry, *cb;
GtkWidget *button;
GtkWidget *separator;
gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
- hbox = gtk_hbox_new (FALSE, 5);
- gtk_box_pack_start (GTK_BOX (box2), hbox, TRUE, TRUE, 0);
+ hbox = gtk_hbox_new (FALSE, 5);
+ gtk_box_pack_start (GTK_BOX (box2), hbox, TRUE, TRUE, 0);
+
+ entry = gtk_entry_new ();
+ gtk_entry_set_text (GTK_ENTRY (entry), "hello world \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);
+ g_signal_connect (button, "clicked",
+ G_CALLBACK (props_clicked),
+ entry);
+
+ cb = gtk_combo_new ();
+ gtk_combo_set_popdown_strings (GTK_COMBO (cb), cbitems);
+ gtk_entry_set_text (GTK_ENTRY (GTK_COMBO(cb)->entry), "hello world \n\n\n foo");
+ gtk_editable_select_region (GTK_EDITABLE (GTK_COMBO(cb)->entry),
+ 0, -1);
+ gtk_box_pack_start (GTK_BOX (box2), cb, TRUE, TRUE, 0);
+
+ sensitive_check = gtk_check_button_new_with_label("Sensitive");
+ gtk_box_pack_start (GTK_BOX (box2), sensitive_check, FALSE, TRUE, 0);
+ 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);
+ 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_can_default (button, TRUE);
+ 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);
- entry = gtk_entry_new ();
- 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);
- g_signal_connect (button, "clicked",
- G_CALLBACK (entry_props_clicked),
- entry);
+ event_box = gtk_event_box_new ();
+ gtk_box_pack_start (GTK_BOX (hbox), event_box, TRUE, FALSE, 0);
- cb = gtk_combo_new ();
- gtk_combo_set_popdown_strings (GTK_COMBO (cb), cbitems);
- gtk_entry_set_text (GTK_ENTRY (GTK_COMBO(cb)->entry), "hello world \n\n\n foo");
- gtk_editable_select_region (GTK_EDITABLE (GTK_COMBO(cb)->entry),
- 0, -1);
- gtk_box_pack_start (GTK_BOX (box2), cb, TRUE, TRUE, 0);
+ 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);
- sensitive_check = gtk_check_button_new_with_label("Sensitive");
- gtk_box_pack_start (GTK_BOX (box2), sensitive_check, FALSE, TRUE, 0);
- g_signal_connect (sensitive_check, "toggled",
- G_CALLBACK (entry_toggle_sensitive), entry);
- gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (sensitive_check), TRUE);
+ 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);
+
- has_frame_check = gtk_check_button_new_with_label("Has Frame");
- gtk_box_pack_start (GTK_BOX (box2), has_frame_check, FALSE, TRUE, 0);
- 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);
+ 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);
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_set_can_default (button, TRUE);
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
*/
gtk_window_set_screen (GTK_WINDOW (window), screen);
- gtk_window_set_resizable (GTK_WINDOW (window), FALSE);
+ gtk_window_set_resizable (GTK_WINDOW (window), TRUE);
g_signal_connect (window, "response",
G_CALLBACK (gtk_widget_destroy),
&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);
}
}
G_CALLBACK (spin_button_time_output_func),
NULL);
gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spinner), TRUE);
- gtk_widget_set_size_request (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);
G_CALLBACK (spin_button_month_output_func),
NULL);
gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spinner), TRUE);
- gtk_widget_set_size_request (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);
G_CALLBACK (spin_button_hex_output_func),
NULL);
gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spinner), TRUE);
- gtk_widget_set_size_request (spinner, 55, -1);
+ 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");
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);
label = g_object_get_data (G_OBJECT (spinner), "user_data");
- class = gtk_type_class (GDK_TYPE_CURSOR_TYPE);
+ class = g_type_class_ref (GDK_TYPE_CURSOR_TYPE);
vals = class->values;
while (vals && vals->value != c)
else
gtk_label_set_text (GTK_LABEL (label), "<unknown>");
+ 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 (GtkWidget *widget)
{
GtkWidget *label;
GtkWidget *any;
GtkAdjustment *adj;
+ GtkWidget *entry;
+ GtkWidget *size;
if (!window)
{
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",
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,
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);
list = GTK_LIST (data);
- if (!GTK_WIDGET_MAPPED (widget))
+ if (!gtk_widget_get_mapped (widget))
return;
i = gtk_option_menu_get_history (GTK_OPTION_MENU (widget));
G_CALLBACK (gtk_widget_destroy),
window);
- GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
+ gtk_widget_set_can_default (button, TRUE);
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);
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;
}
gtk_widget_destroy (child);
- gtk_widget_unref (child);
+ g_object_unref (child);
}
static void
clist = GTK_CLIST (data);
- if (!GTK_WIDGET_MAPPED (widget))
+ if (!gtk_widget_get_mapped (widget))
return;
i = gtk_option_menu_get_history (GTK_OPTION_MENU (widget));
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)
{
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);
G_CALLBACK (gtk_widget_destroy),
window);
- GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
+ gtk_widget_set_can_default (button, TRUE);
gtk_widget_grab_default (button);
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
{
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");
}
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));
ctree = GTK_CTREE (data);
- if (!GTK_WIDGET_MAPPED (widget))
+ if (!gtk_widget_get_mapped (widget))
return;
i = gtk_option_menu_get_history (GTK_OPTION_MENU (widget));
ctree = GTK_CTREE (data);
- if (!GTK_WIDGET_MAPPED (widget))
+ if (!gtk_widget_get_mapped (widget))
return;
i = gtk_option_menu_get_history (GTK_OPTION_MENU (widget));
ctree = GTK_CTREE (data);
- if (!GTK_WIDGET_MAPPED (widget))
+ if (!gtk_widget_get_mapped (widget))
return;
i = gtk_option_menu_get_history (GTK_OPTION_MENU (widget));
ctree = GTK_CTREE (data);
- if (!GTK_WIDGET_MAPPED (widget))
+ if (!gtk_widget_get_mapped (widget))
return;
i = gtk_option_menu_get_history (GTK_OPTION_MENU (widget));
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);
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);
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 (GtkWidget *widget)
GtkWidget *picker;
GtkWidget *hbox;
GtkWidget *label;
+ GtkWidget *button;
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_screen (GTK_WINDOW (window),
picker = gtk_color_button_new ();
gtk_color_button_set_use_alpha (GTK_COLOR_BUTTON (picker), TRUE);
gtk_container_add (GTK_CONTAINER (hbox), picker);
+
+ 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))
+ if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
gtk_widget_destroy (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)
gtk_window_set_title (GTK_WINDOW (window), "Bidirectional Flipping");
check_button = gtk_check_button_new_with_label ("Right-to-left global direction");
+ 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);
+
+ 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);
create_forward_back ("Right-to-Left", GTK_TEXT_DIR_RTL),
TRUE, TRUE, 0);
- if (gtk_widget_get_default_direction () == GTK_TEXT_DIR_RTL)
- gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check_button), TRUE);
-
- g_signal_connect (check_button, "toggled",
- G_CALLBACK (flipping_toggled_cb), FALSE);
-
- gtk_container_set_border_width (GTK_CONTAINER (check_button), 10);
-
button = gtk_button_new_with_label ("Close");
g_signal_connect_swapped (button, "clicked",
G_CALLBACK (gtk_widget_destroy), window);
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);
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);
gtk_container_add (GTK_CONTAINER (hbox), picker);
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
gtk_container_set_border_width (GTK_CONTAINER (dialog_window), 0);
button = gtk_button_new_with_label ("OK");
- GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
+ gtk_widget_set_can_default (button, TRUE);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog_window)->action_area),
button, TRUE, TRUE, 0);
gtk_widget_grab_default (button);
g_signal_connect (button, "clicked",
G_CALLBACK (label_toggle),
&label);
- GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
+ gtk_widget_set_can_default (button, TRUE);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog_window)->action_area),
button, TRUE, TRUE, 0);
gtk_widget_show (button);
button = gtk_button_new_with_label ("Separator");
- GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
+ gtk_widget_set_can_default (button, TRUE);
gtk_dialog_add_action_widget (GTK_DIALOG (dialog_window),
button,
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);
GdkDisplay *display = gdk_screen_get_display (screen);
- window = gtk_widget_new (gtk_window_get_type (),
+ window = g_object_new (gtk_window_get_type (),
"screen", screen,
"user_data", NULL,
"type", GTK_WINDOW_TOPLEVEL,
g_signal_connect_swapped (button, "clicked",
G_CALLBACK (gtk_widget_destroy),
dialog_window);
- GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
+ gtk_widget_set_can_default (button, TRUE);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog_window)->action_area),
button, TRUE, TRUE, 0);
gtk_widget_grab_default (button);
gtk_widget_show (button);
}
- if (!GTK_WIDGET_VISIBLE (dialog_window))
+ if (!gtk_widget_get_visible (dialog_window))
gtk_widget_show (dialog_window);
else
gtk_widget_destroy (dialog_window);
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_set_can_default (button, TRUE);
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);
gtk_widget_show (ruler);
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
gtk_widget_show (window);
else
gtk_widget_destroy (window);
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_set_can_default (button, TRUE);
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_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_set_can_default (button, TRUE);
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_widget_show_all (vbox);
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
gtk_widget_show (window);
else
gtk_widget_destroy (window);
&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));
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,
window);
gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
- GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
+ gtk_widget_set_can_default (button, TRUE);
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);
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);
* 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;
pdata = (ProgressData *) data;
- if (!GTK_WIDGET_MAPPED (widget))
+ if (!gtk_widget_get_mapped (widget))
return;
i = gtk_option_menu_get_history (GTK_OPTION_MENU (widget));
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)
{
pdata = (ProgressData *) data;
- if (!GTK_WIDGET_MAPPED (widget))
+ if (!gtk_widget_get_mapped (widget))
return;
i = gtk_option_menu_get_history (GTK_OPTION_MENU (widget));
"Continuous",
"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);
gtk_window_set_screen (GTK_WINDOW (pdata->window),
gtk_widget_get_screen (widget));
- gtk_window_set_resizable (GTK_WINDOW (pdata->window), FALSE);
+ gtk_window_set_resizable (GTK_WINDOW (pdata->window), TRUE);
g_signal_connect (pdata->window, "destroy",
G_CALLBACK (destroy_progress),
g_signal_connect (adj, "value_changed",
G_CALLBACK (progress_value_changed), pdata);
- pdata->pbar = gtk_widget_new (GTK_TYPE_PROGRESS_BAR,
+ 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_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);
check = gtk_check_button_new_with_label ("Activity mode");
g_signal_connect (check, "clicked",
G_CALLBACK (toggle_activity_mode), pdata);
- gtk_table_attach (GTK_TABLE (tab), check, 0, 1, 5, 6,
+ 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_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 : ");
g_signal_connect_swapped (button, "clicked",
G_CALLBACK (gtk_widget_destroy),
pdata->window);
- GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
+ gtk_widget_set_can_default (button, TRUE);
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);
new_allocation = widget->allocation;
- if (data->found || !GTK_WIDGET_MAPPED (widget))
+ if (data->found || !gtk_widget_get_mapped (widget))
return;
/* Note that in the following code, we only count the
* 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;
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)
{
data);
}
- if (!GTK_WIDGET_VISIBLE (window))
+ 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_get_visible (window))
gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
}
+
/*
* Color Preview
*/
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);
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);
window);
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
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)
{
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);
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);
g_signal_connect_swapped (button, "clicked",
G_CALLBACK (gtk_widget_destroy),
window);
- GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
+ gtk_widget_set_can_default (button, TRUE);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
button, TRUE, TRUE, 0);
gtk_widget_grab_default (button);
g_signal_connect (button, "clicked",
G_CALLBACK(start_timeout_test),
label);
- GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
+ gtk_widget_set_can_default (button, TRUE);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
button, TRUE, TRUE, 0);
gtk_widget_show (button);
g_signal_connect (button, "clicked",
G_CALLBACK (stop_timeout_test),
NULL);
- GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
+ gtk_widget_set_can_default (button, TRUE);
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);
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);
g_signal_connect_swapped (button, "clicked",
G_CALLBACK (gtk_widget_destroy),
window);
- GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
+ gtk_widget_set_can_default (button, TRUE);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
button, TRUE, TRUE, 0);
gtk_widget_grab_default (button);
g_signal_connect (button, "clicked",
G_CALLBACK (start_idle_test),
label);
- GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
+ gtk_widget_set_can_default (button, TRUE);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
button, TRUE, TRUE, 0);
gtk_widget_show (button);
g_signal_connect (button, "clicked",
G_CALLBACK (stop_idle_test),
NULL);
- GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
+ gtk_widget_set_can_default (button, TRUE);
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);
button = gtk_button_new_with_label ("Reload");
g_signal_connect (button, "clicked",
G_CALLBACK (gtk_rc_reparse_all), NULL);
- GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
+ gtk_widget_set_can_default (button, TRUE);
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");
g_signal_connect (button, "clicked",
G_CALLBACK (reload_all_rc_files), NULL);
- GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
+ gtk_widget_set_can_default (button, TRUE);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
button, TRUE, TRUE, 0);
g_signal_connect_swapped (button, "clicked",
G_CALLBACK (gtk_widget_destroy),
window);
- GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
+ gtk_widget_set_can_default (button, TRUE);
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);
G_CALLBACK (gtk_widget_destroy),
window);
- GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
+ gtk_widget_set_can_default (button, TRUE);
gtk_widget_grab_default (button);
gtk_widget_show (button);
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
{
gtk_widget_show (window);
}
}
- if (!GTK_WIDGET_VISIBLE (window))
+ if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
g_signal_connect_swapped (button, "clicked",
G_CALLBACK (gtk_widget_destroy),
window);
- GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
+ gtk_widget_set_can_default (button, TRUE);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area),
button, TRUE, TRUE, 0);
gtk_widget_show (button);
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_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);
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 },
+ { "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, TRUE },
+ { "gridded geometry", create_gridded_geometry },
{ "handle box", create_handle_box },
{ "image from drawable", create_get_image },
{ "image", create_image },
{ "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;
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_set_can_default (button, TRUE);
gtk_widget_grab_default (button);
gtk_widget_show_all (window);
}
static void
-test_init ()
+test_init (void)
{
if (g_file_test ("../gdk-pixbuf/libpixbufloader-pnm.la",
G_FILE_TEST_EXISTS))
*/
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",
projects / ~andy / gtk / blobdiff