#undef GTK_DISABLE_DEPRECATED
-#include <config.h>
+#include "config.h"
#undef G_LOG_DOMAIN
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_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_VISIBLE (window))
+ gtk_widget_show_all (window);
+ else
+ gtk_widget_destroy (window);
+}
+
/*
* Big windows and guffaw scrolling
*/
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);
}
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,
"swapped_signal_after::clicked", statusbar_contexts, 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", "push something long",
"visible", TRUE,
"parent", box2,
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), TRUE);
+ 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))
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;
GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE,
NULL);
- gtk_window_set_resizable (GTK_WINDOW (window), FALSE);
+ gtk_window_set_resizable (GTK_WINDOW (window), TRUE);
gtk_window_set_screen (GTK_WINDOW (window),
gtk_widget_get_screen (widget));
GtkWidget *old_parent,
gpointer func_data)
{
- 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));
+ 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
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);
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,
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);
gtk_widget_set_sensitive (entry, GTK_TOGGLE_BUTTON(checkbutton)->active);
}
+static gboolean
+entry_progress_timeout (gpointer data)
+{
+ if (GPOINTER_TO_INT (g_object_get_data (G_OBJECT (data), "progress-pulse")))
+ {
+ gtk_entry_progress_pulse (GTK_ENTRY (data));
+ }
+ else
+ {
+ gdouble fraction;
+
+ fraction = gtk_entry_get_progress_fraction (GTK_ENTRY (data));
+
+ fraction += 0.05;
+ if (fraction > 1.0001)
+ fraction = 0.0;
+
+ gtk_entry_set_progress_fraction (GTK_ENTRY (data), fraction);
+ }
+
+ return TRUE;
+}
+
+static void
+entry_remove_timeout (gpointer data)
+{
+ g_source_remove (GPOINTER_TO_UINT (data));
+}
+
+static void
+entry_toggle_progress (GtkWidget *checkbutton,
+ GtkWidget *entry)
+{
+ if (GTK_TOGGLE_BUTTON (checkbutton)->active)
+ {
+ guint timeout = gdk_threads_add_timeout (100,
+ entry_progress_timeout,
+ entry);
+ g_object_set_data_full (G_OBJECT (entry), "timeout-id",
+ GUINT_TO_POINTER (timeout),
+ entry_remove_timeout);
+ }
+ else
+ {
+ g_object_set_data (G_OBJECT (entry), "timeout-id",
+ GUINT_TO_POINTER (0));
+
+ gtk_entry_set_progress_fraction (GTK_ENTRY (entry), 0.0);
+ }
+}
+
+static void
+entry_toggle_pulse (GtkWidget *checkbutton,
+ GtkWidget *entry)
+{
+ g_object_set_data (G_OBJECT (entry), "progress-pulse",
+ GINT_TO_POINTER (GTK_TOGGLE_BUTTON (checkbutton)->active));
+}
+
static void
entry_props_clicked (GtkWidget *button,
GObject *entry)
GtkWidget *hbox;
GtkWidget *has_frame_check;
GtkWidget *sensitive_check;
+ GtkWidget *progress_check;
GtkWidget *entry, *cb;
GtkWidget *button;
GtkWidget *separator;
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);
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_VISIBLE (window))
+ gtk_widget_show_all (window);
+ else
+ gtk_widget_destroy (window);
+}
+
+
/* GtkEventBox */
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),
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);
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
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);
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");
}
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);
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)
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), NULL);
-
- 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);
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,
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,
GtkWidget *act_blocks_spin;
GtkWidget *label;
GtkWidget *omenu1;
+ GtkWidget *elmenu;
GtkWidget *omenu2;
GtkWidget *entry;
int timer;
GTK_TOGGLE_BUTTON (widget)->active);
}
+static void
+progressbar_toggle_ellipsize (GtkWidget *widget,
+ gpointer data)
+{
+ ProgressData *pdata = data;
+ if (GTK_WIDGET_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)
{
"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_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 : ");
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)
{
}
+struct SnapshotData {
+ GtkWidget *toplevel_button;
+ GtkWidget **window;
+ GdkCursor *cursor;
+ gboolean in_query;
+ gboolean is_toplevel;
+ gint handler;
+};
+
+static void
+destroy_snapshot_data (GtkWidget *widget,
+ struct SnapshotData *data)
+{
+ if (*data->window)
+ *data->window = NULL;
+
+ if (data->cursor)
+ {
+ gdk_cursor_unref (data->cursor);
+ data->cursor = NULL;
+ }
+
+ if (data->handler)
+ {
+ g_signal_handler_disconnect (widget, data->handler);
+ data->handler = 0;
+ }
+
+ g_free (data);
+}
+
+static gint
+snapshot_widget_event (GtkWidget *widget,
+ GdkEvent *event,
+ struct SnapshotData *data)
+{
+ GtkWidget *res_widget = NULL;
+
+ if (!data->in_query)
+ return FALSE;
+
+ if (event->type == GDK_BUTTON_RELEASE)
+ {
+ gtk_grab_remove (widget);
+ gdk_display_pointer_ungrab (gtk_widget_get_display (widget),
+ GDK_CURRENT_TIME);
+
+ res_widget = find_widget_at_pointer (gtk_widget_get_display (widget));
+ if (data->is_toplevel && res_widget)
+ res_widget = gtk_widget_get_toplevel (res_widget);
+ if (res_widget)
+ {
+ GdkPixmap *pixmap;
+ GtkWidget *window, *image;
+
+ window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+ pixmap = gtk_widget_get_snapshot (res_widget, NULL);
+ gtk_widget_realize (window);
+ if (gdk_drawable_get_depth (window->window) != gdk_drawable_get_depth (pixmap))
+ {
+ /* this branch is needed to convert ARGB -> RGB */
+ int width, height;
+ GdkPixbuf *pixbuf;
+ gdk_drawable_get_size (pixmap, &width, &height);
+ pixbuf = gdk_pixbuf_get_from_drawable (NULL, pixmap,
+ gtk_widget_get_colormap (res_widget),
+ 0, 0,
+ 0, 0,
+ width, height);
+ image = gtk_image_new_from_pixbuf (pixbuf);
+ g_object_unref (pixbuf);
+ }
+ else
+ image = gtk_image_new_from_pixmap (pixmap, NULL);
+ gtk_container_add (GTK_CONTAINER (window), image);
+ g_object_unref (pixmap);
+ gtk_widget_show_all (window);
+ }
+
+ data->in_query = FALSE;
+ }
+ return FALSE;
+}
+
+
+static void
+snapshot_widget (GtkButton *button,
+ struct SnapshotData *data)
+{
+ gint failure;
+
+ g_signal_connect (button, "event",
+ G_CALLBACK (snapshot_widget_event), data);
+
+ data->is_toplevel = GTK_WIDGET (button) == data->toplevel_button;
+
+ if (!data->cursor)
+ data->cursor = gdk_cursor_new_for_display (gtk_widget_get_display (GTK_WIDGET (button)),
+ GDK_TARGET);
+
+ failure = gdk_pointer_grab (GTK_WIDGET (button)->window,
+ TRUE,
+ GDK_BUTTON_RELEASE_MASK,
+ NULL,
+ data->cursor,
+ GDK_CURRENT_TIME);
+
+ gtk_grab_add (GTK_WIDGET (button));
+
+ data->in_query = TRUE;
+}
+
+static void
+create_snapshot (GtkWidget *widget)
+{
+ static GtkWidget *window = NULL;
+ GtkWidget *button;
+ GtkWidget *vbox;
+ struct SnapshotData *data;
+
+ data = g_new (struct SnapshotData, 1);
+ data->window = &window;
+ data->in_query = FALSE;
+ data->cursor = NULL;
+ data->handler = 0;
+
+ if (!window)
+ {
+ window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+
+ gtk_window_set_screen (GTK_WINDOW (window),
+ gtk_widget_get_screen (widget));
+
+ data->handler = g_signal_connect (window, "destroy",
+ G_CALLBACK (destroy_snapshot_data),
+ data);
+
+ gtk_window_set_title (GTK_WINDOW (window), "test snapshot");
+ gtk_container_set_border_width (GTK_CONTAINER (window), 10);
+
+ vbox = gtk_vbox_new (FALSE, 1);
+ gtk_container_add (GTK_CONTAINER (window), vbox);
+
+ button = gtk_button_new_with_label ("Snapshot widget");
+ gtk_box_pack_start (GTK_BOX (vbox), button, TRUE, TRUE, 0);
+ g_signal_connect (button, "clicked",
+ G_CALLBACK (snapshot_widget),
+ data);
+
+ button = gtk_button_new_with_label ("Snapshot toplevel");
+ data->toplevel_button = button;
+ gtk_box_pack_start (GTK_BOX (vbox), button, TRUE, TRUE, 0);
+ g_signal_connect (button, "clicked",
+ G_CALLBACK (snapshot_widget),
+ data);
+ }
+
+ if (!GTK_WIDGET_VISIBLE (window))
+ gtk_widget_show_all (window);
+ else
+ gtk_widget_destroy (window);
+
+}
+
+
/*
* Color Preview
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);
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);
gboolean do_not_benchmark;
} buttons[] =
{
+ { "alpha window", create_alpha_window },
#ifdef G_OS_WIN32
/* dog slow on NT, no working at all on 9x */
{ "big windows", create_big_windows, TRUE },
{ "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, 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 },
{ "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;
*/
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