#include "prop-editor.h"
-#include "circles.xbm"
#include "test.xpm"
gboolean
GtkWidget *omenu;
gint i;
- omenu = gtk_combo_box_new_text ();
+ omenu = gtk_combo_box_text_new ();
g_signal_connect (omenu, "changed",
G_CALLBACK (func), data);
for (i = 0; i < num_items; i++)
- gtk_combo_box_append_text (GTK_COMBO_BOX (omenu), items[i]);
+ gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (omenu), items[i]);
gtk_combo_box_set_active (GTK_COMBO_BOX (omenu), history);
static gboolean
-on_alpha_window_expose (GtkWidget *widget,
- GdkEventExpose *expose)
+on_alpha_window_draw (GtkWidget *widget,
+ cairo_t *cr)
{
- cairo_t *cr;
cairo_pattern_t *pattern;
- int radius;
-
- cr = gdk_cairo_create (widget->window);
+ int radius, width, height;
- radius = MIN (widget->allocation.width, widget->allocation.height) / 2;
- pattern = cairo_pattern_create_radial (widget->allocation.width / 2,
- widget->allocation.height / 2,
+ width = gtk_widget_get_allocated_width (widget);
+ height = gtk_widget_get_allocated_height (widget);
+ radius = MIN (width, height) / 2;
+ pattern = cairo_pattern_create_radial (width / 2,
+ height / 2,
0.0,
- widget->allocation.width / 2,
- widget->allocation.height / 2,
+ width / 2,
+ height / 2,
radius * 1.33);
- if (gdk_screen_get_rgba_colormap (gtk_widget_get_screen (widget)) &&
+ if (gdk_screen_get_rgba_visual (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_operator (cr, CAIRO_OPERATOR_OVER);
cairo_paint (cr);
- cairo_destroy (cr);
-
return FALSE;
}
GTK_EXPAND | GTK_FILL, 0,
0, 0);
- hbox = gtk_hbox_new (FALSE, 0);
+ hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 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);
}
static void
-on_alpha_screen_changed (GtkWidget *widget,
+on_alpha_screen_changed (GtkWindow *window,
GdkScreen *old_screen,
GtkWidget *label)
{
- GdkScreen *screen = gtk_widget_get_screen (widget);
- GdkColormap *colormap = gdk_screen_get_rgba_colormap (screen);
+ GdkScreen *screen = gtk_widget_get_screen (GTK_WIDGET (window));
+ GdkVisual *visual = gdk_screen_get_rgba_visual (screen);
- if (!colormap)
+ if (!visual)
{
- colormap = gdk_screen_get_default_colormap (screen);
+ visual = gdk_screen_get_system_visual (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);
+ gtk_widget_set_visual (GTK_WIDGET (window), visual);
}
static void
NULL);
gtk_widget_set_app_paintable (window, TRUE);
- g_signal_connect (window, "expose-event",
- G_CALLBACK (on_alpha_window_expose), NULL);
+ g_signal_connect (window, "draw",
+ G_CALLBACK (on_alpha_window_draw), NULL);
content_area = gtk_dialog_get_content_area (GTK_DIALOG (window));
- vbox = gtk_vbox_new (FALSE, 8);
+ vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 8);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 12);
gtk_box_pack_start (GTK_BOX (content_area), 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);
+ on_alpha_screen_changed (GTK_WINDOW (window), NULL, label);
g_signal_connect (window, "screen-changed",
G_CALLBACK (on_alpha_screen_changed), label);
* Composited non-toplevel window
*/
-/* The expose event handler for the event box.
+/* The draw 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
* default background colour).
*/
static gboolean
-transparent_expose (GtkWidget *widget,
- GdkEventExpose *event)
+transparent_draw (GtkWidget *widget,
+ cairo_t *cr)
{
- 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);
+ cairo_paint (cr);
return FALSE;
}
* called before then GTK would just blindly paint over our work.
*/
static gboolean
-window_expose_event (GtkWidget *widget,
- GdkEventExpose *event)
+window_draw (GtkWidget *widget,
+ cairo_t *cr)
{
- cairo_region_t *region;
+ GtkAllocation allocation;
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);
+ gtk_widget_get_allocation (child, &allocation);
/* 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 = cairo_region_create_rectangle (&child->allocation);
- cairo_region_intersect (region, event->region);
- gdk_cairo_region (cr, region);
- cairo_clip (cr);
+ gdk_cairo_set_source_window (cr, gtk_widget_get_window (child),
+ allocation.x,
+ allocation.y);
/* 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;
}
if (!window)
{
GtkWidget *event, *button;
- GdkScreen *screen;
- GdkColormap *rgba;
GdkColor red;
/* make the widgets */
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);
+ g_signal_connect (event, "draw",
+ G_CALLBACK (transparent_draw), NULL);
/* put them inside one another */
gtk_container_set_border_width (GTK_CONTAINER (window), 10);
/* set the event box GdkWindow to be composited.
* obviously must be performed after event box is realised.
*/
- gdk_window_set_composited (event->window, TRUE);
+ gdk_window_set_composited (gtk_widget_get_window (event),
+ 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);
+ g_signal_connect_after (window, "draw",
+ G_CALLBACK (window_draw), NULL);
}
if (!gtk_widget_get_visible (window))
* Big windows and guffaw scrolling
*/
-static gboolean
-pattern_expose (GtkWidget *widget,
- GdkEventExpose *event,
- gpointer data)
-{
- GdkColor *color;
- GdkWindow *window = event->window;
-
- color = g_object_get_data (G_OBJECT (window), "pattern-color");
- if (color)
- {
- cairo_t *cr = gdk_cairo_create (window);
-
- gdk_cairo_set_source_color (cr, color);
- gdk_cairo_rectangle (cr, &event->area);
- cairo_fill (cr);
-
- cairo_destroy (cr);
- }
-
- return FALSE;
-}
-
static void
pattern_set_bg (GtkWidget *widget,
GdkWindow *child,
{ 0, 0xaaaa, 0xaaaa, 0xffff }
};
- g_object_set_data (G_OBJECT (child), "pattern-color", (gpointer) &colors[level]);
gdk_window_set_user_data (child, widget);
+ gdk_window_set_background (child, &colors[level]);
}
static void
attributes.wclass = GDK_INPUT_OUTPUT;
attributes.event_mask = GDK_EXPOSURE_MASK;
attributes.visual = gtk_widget_get_visual (widget);
- attributes.colormap = gtk_widget_get_colormap (widget);
child = gdk_window_new (parent, &attributes,
- GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP);
+ GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL);
pattern_set_bg (widget, child, level);
if (gtk_widget_get_realized (darea))
{
- gdk_window_scroll (darea->window, *old_value - new_value, 0);
+ gdk_window_scroll (gtk_widget_get_window (darea),
+ *old_value - new_value, 0);
*old_value = new_value;
}
}
if (gtk_widget_get_realized (darea))
{
- gdk_window_scroll (darea->window, 0, *old_value - new_value);
+ gdk_window_scroll (gtk_widget_get_window (darea),
+ 0, *old_value - new_value);
*old_value = new_value;
}
}
pattern_realize (GtkWidget *widget,
gpointer data)
{
- pattern_set_bg (widget, widget->window, 0);
- create_pattern (widget, widget->window, 1, PATTERN_SIZE, PATTERN_SIZE);
+ GdkWindow *window;
+
+ window = gtk_widget_get_window (widget);
+ pattern_set_bg (widget, window, 0);
+ create_pattern (widget, window, 1, PATTERN_SIZE, PATTERN_SIZE);
}
static void
darea = gtk_drawing_area_new ();
- hadj = (GtkAdjustment *)gtk_adjustment_new (0, 0, PATTERN_SIZE, 10, 100, 100);
+ hadj = gtk_adjustment_new (0, 0, PATTERN_SIZE, 10, 100, 100);
g_signal_connect (hadj, "value_changed",
G_CALLBACK (pattern_hadj_changed), darea);
g_object_set_data (G_OBJECT (hadj), "old-value", ¤t_x);
-
- vadj = (GtkAdjustment *)gtk_adjustment_new (0, 0, PATTERN_SIZE, 10, 100, 100);
+
+ vadj = gtk_adjustment_new (0, 0, PATTERN_SIZE, 10, 100, 100);
g_signal_connect (vadj, "value_changed",
G_CALLBACK (pattern_vadj_changed), darea);
g_object_set_data (G_OBJECT (vadj), "old-value", ¤t_y);
g_signal_connect (darea, "realize",
G_CALLBACK (pattern_realize),
NULL);
- g_signal_connect (darea, "expose_event",
- G_CALLBACK (pattern_expose),
- NULL);
eventbox = gtk_event_box_new ();
gtk_table_attach (GTK_TABLE (table), eventbox,
gtk_container_add (GTK_CONTAINER (eventbox), darea);
- scrollbar = gtk_hscrollbar_new (hadj);
+ scrollbar = gtk_scrollbar_new (GTK_ORIENTATION_HORIZONTAL, hadj);
gtk_table_attach (GTK_TABLE (table), scrollbar,
0, 1, 1, 2,
GTK_FILL | GTK_EXPAND, GTK_FILL,
0, 0);
- scrollbar = gtk_vscrollbar_new (vadj);
+ scrollbar = gtk_scrollbar_new (GTK_ORIENTATION_VERTICAL, vadj);
gtk_table_attach (GTK_TABLE (table), scrollbar,
1, 2, 0, 1,
GTK_FILL, GTK_EXPAND | GTK_FILL,
gtk_window_set_title (GTK_WINDOW (window), "GtkButton");
gtk_container_set_border_width (GTK_CONTAINER (window), 0);
- box1 = gtk_vbox_new (FALSE, 0);
+ box1 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_container_add (GTK_CONTAINER (window), box1);
table = gtk_table_new (3, 3, FALSE);
gtk_table_attach (GTK_TABLE (table), button[8], 0, 1, 1, 2,
GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
- separator = gtk_hseparator_new ();
+ separator = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
- box2 = gtk_vbox_new (FALSE, 10);
+ box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10);
gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
gtk_window_set_title (GTK_WINDOW (window), "GtkToggleButton");
gtk_container_set_border_width (GTK_CONTAINER (window), 0);
- box1 = gtk_vbox_new (FALSE, 0);
+ box1 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_container_add (GTK_CONTAINER (window), box1);
- box2 = gtk_vbox_new (FALSE, 10);
+ box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10);
gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
gtk_toggle_button_set_inconsistent (GTK_TOGGLE_BUTTON (button), TRUE);
gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
- separator = gtk_hseparator_new ();
+ separator = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
- box2 = gtk_vbox_new (FALSE, 10);
+ box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10);
gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
box1 = gtk_dialog_get_content_area (GTK_DIALOG (window));
- box2 = gtk_vbox_new (FALSE, 10);
+ box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10);
gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
gtk_toggle_button_set_inconsistent (GTK_TOGGLE_BUTTON (button), TRUE);
gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
- separator = gtk_hseparator_new ();
+ separator = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
table = create_widget_grid (GTK_TYPE_CHECK_BUTTON);
box1 = gtk_dialog_get_content_area (GTK_DIALOG (window));
- box2 = gtk_vbox_new (FALSE, 10);
+ box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10);
gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
gtk_toggle_button_set_inconsistent (GTK_TOGGLE_BUTTON (button), TRUE);
gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
- separator = gtk_hseparator_new ();
+ separator = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
- box2 = gtk_vbox_new (FALSE, 10);
+ box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10);
gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (button), FALSE);
gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
- separator = gtk_hseparator_new ();
+ separator = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
table = create_widget_grid (GTK_TYPE_RADIO_BUTTON);
frame = gtk_frame_new (title);
if (horizontal)
- bbox = gtk_hbutton_box_new ();
+ bbox = gtk_button_box_new (GTK_ORIENTATION_HORIZONTAL);
else
- bbox = gtk_vbutton_box_new ();
+ bbox = gtk_button_box_new (GTK_ORIENTATION_VERTICAL);
gtk_container_set_border_width (GTK_CONTAINER (bbox), 5);
gtk_container_add (GTK_CONTAINER (frame), bbox);
gtk_container_set_border_width (GTK_CONTAINER (window), 10);
- main_vbox = gtk_vbox_new (FALSE, 0);
+ main_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_container_add (GTK_CONTAINER (window), main_vbox);
frame_horz = gtk_frame_new ("Horizontal Button Boxes");
gtk_box_pack_start (GTK_BOX (main_vbox), frame_horz, TRUE, TRUE, 10);
- vbox = gtk_vbox_new (FALSE, 0);
+ vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 10);
gtk_container_add (GTK_CONTAINER (frame_horz), vbox);
frame_vert = gtk_frame_new ("Vertical Button Boxes");
gtk_box_pack_start (GTK_BOX (main_vbox), frame_vert, TRUE, TRUE, 10);
- hbox = gtk_hbox_new (FALSE, 0);
+ hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_container_set_border_width (GTK_CONTAINER (hbox), 10);
gtk_container_add (GTK_CONTAINER (frame_vert), hbox);
*/
static GtkWidget*
-new_pixmap (char *filename,
+new_pixbuf (char *filename,
GdkWindow *window,
GdkColor *background)
{
- GtkWidget *wpixmap;
- GdkPixmap *pixmap;
- GdkBitmap *mask;
+ GtkWidget *widget;
+ GdkPixbuf *pixbuf;
- if (strcmp (filename, "test.xpm") == 0 ||
- !file_exists (filename))
- {
- pixmap = gdk_pixmap_create_from_xpm_d (window, &mask,
- background,
- openfile);
- }
+ if (strcmp (filename, "test.xpm") == 0)
+ pixbuf = NULL;
else
- pixmap = gdk_pixmap_create_from_xpm (window, &mask,
- background,
- filename);
+ pixbuf = gdk_pixbuf_new_from_file (filename, NULL);
+
+ if (pixbuf == NULL)
+ pixbuf = gdk_pixbuf_new_from_xpm_data ((const char **) openfile);
- wpixmap = gtk_image_new_from_pixmap (pixmap, mask);
+ widget = gtk_image_new_from_pixbuf (pixbuf);
+
+ g_object_unref (pixbuf);
- return wpixmap;
+ return widget;
}
{
GtkWidget *icon;
- icon = new_pixmap ("test.xpm", window->window,
- &window->style->bg[GTK_STATE_NORMAL]);
+ icon = new_pixbuf ("test.xpm", gtk_widget_get_window (window),
+ >k_widget_get_style (window)->bg[GTK_STATE_NORMAL]);
toolitem = gtk_tool_button_new (icon, create_toolbar_items[i].label);
}
if (create_toolbar_items[i].callback)
toolitem = gtk_separator_tool_item_new ();
continue;
}
- icon = new_pixmap ("test.xpm", window->window,
- &window->style->bg[GTK_STATE_NORMAL]);
+ icon = new_pixbuf ("test.xpm", gtk_widget_get_window (window),
+ >k_widget_get_style (window)->bg[GTK_STATE_NORMAL]);
toolitem = gtk_tool_button_new (icon, make_toolbar_items[i].label);
gtk_tool_item_set_tooltip_text (toolitem, make_toolbar_items[i].tooltip);
if (make_toolbar_items[i].callback != NULL)
gtk_window_set_title (GTK_WINDOW (window), "statusbar");
gtk_container_set_border_width (GTK_CONTAINER (window), 0);
- box1 = gtk_vbox_new (FALSE, 0);
+ box1 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_container_add (GTK_CONTAINER (window), box1);
- box2 = gtk_vbox_new (FALSE, 10);
+ box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10);
gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
"signal_after::clicked", statusbar_push_long, statusbar,
NULL);
- separator = gtk_hseparator_new ();
+ separator = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
- box2 = gtk_vbox_new (FALSE, 10);
+ box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10);
gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
gtk_widget_destroy (window);
}
-/*
- * Gridded geometry
- */
-#define GRID_SIZE 20
-#define DEFAULT_GEOMETRY "10x10"
-
-static gboolean
-gridded_geometry_expose (GtkWidget *widget,
- GdkEventExpose *event)
-{
- int i, j;
- cairo_t *cr;
-
- cr = gdk_cairo_create (widget->window);
-
- cairo_rectangle (cr, 0, 0, widget->allocation.width, widget->allocation.height);
- gdk_cairo_set_source_color (cr, &widget->style->base[widget->state]);
- cairo_fill (cr);
-
- for (i = 0 ; i * GRID_SIZE < widget->allocation.width; i++)
- for (j = 0 ; j * GRID_SIZE < widget->allocation.height; j++)
- {
- if ((i + j) % 2 == 0)
- cairo_rectangle (cr, i * GRID_SIZE, j * GRID_SIZE, GRID_SIZE, GRID_SIZE);
- }
-
- gdk_cairo_set_source_color (cr, &widget->style->text[widget->state]);
- cairo_fill (cr);
-
- cairo_destroy (cr);
-
- return FALSE;
-}
-
-static void
-gridded_geometry_subresponse (GtkDialog *dialog,
- gint response_id,
- gchar *geometry_string)
-{
- if (response_id == GTK_RESPONSE_NONE)
- {
- gtk_widget_destroy (GTK_WIDGET (dialog));
- }
- else
- {
- if (!gtk_window_parse_geometry (GTK_WINDOW (dialog), geometry_string))
- {
- g_print ("Can't parse geometry string %s\n", geometry_string);
- gtk_window_parse_geometry (GTK_WINDOW (dialog), DEFAULT_GEOMETRY);
- }
- }
-}
-
-static void
-gridded_geometry_response (GtkDialog *dialog,
- gint response_id,
- GtkEntry *entry)
-{
- if (response_id == GTK_RESPONSE_NONE)
- {
- gtk_widget_destroy (GTK_WIDGET (dialog));
- }
- else
- {
- gchar *geometry_string = g_strdup (gtk_entry_get_text (entry));
- gchar *title = g_strdup_printf ("Gridded window at: %s", geometry_string);
- GtkWidget *content_area;
- GtkWidget *window;
- GtkWidget *drawing_area;
- GtkWidget *box;
- GdkGeometry geometry;
-
- window = gtk_dialog_new_with_buttons (title,
- NULL, 0,
- "Reset", 1,
- GTK_STOCK_CLOSE, GTK_RESPONSE_NONE,
- NULL);
-
- gtk_window_set_screen (GTK_WINDOW (window),
- gtk_widget_get_screen (GTK_WIDGET (dialog)));
- g_free (title);
- g_signal_connect (window, "response",
- G_CALLBACK (gridded_geometry_subresponse), geometry_string);
-
- content_area = gtk_dialog_get_content_area (GTK_DIALOG (window));
-
- box = gtk_vbox_new (FALSE, 0);
- gtk_box_pack_start (GTK_BOX (content_area), box, TRUE, TRUE, 0);
-
- gtk_container_set_border_width (GTK_CONTAINER (box), 7);
-
- drawing_area = gtk_drawing_area_new ();
- g_signal_connect (drawing_area, "expose_event",
- G_CALLBACK (gridded_geometry_expose), NULL);
- gtk_box_pack_start (GTK_BOX (box), drawing_area, TRUE, TRUE, 0);
-
- /* Gross hack to work around bug 68668... if we set the size request
- * large enough, then the current
- *
- * request_of_window - request_of_geometry_widget
- *
- * method of getting the base size works more or less works.
- */
- gtk_widget_set_size_request (drawing_area, 2000, 2000);
-
- geometry.base_width = 0;
- geometry.base_height = 0;
- geometry.min_width = 2 * GRID_SIZE;
- geometry.min_height = 2 * GRID_SIZE;
- geometry.width_inc = GRID_SIZE;
- geometry.height_inc = GRID_SIZE;
-
- gtk_window_set_geometry_hints (GTK_WINDOW (window), drawing_area,
- &geometry,
- GDK_HINT_BASE_SIZE | GDK_HINT_MIN_SIZE | GDK_HINT_RESIZE_INC);
-
- if (!gtk_window_parse_geometry (GTK_WINDOW (window), geometry_string))
- {
- g_print ("Can't parse geometry string %s\n", geometry_string);
- gtk_window_parse_geometry (GTK_WINDOW (window), DEFAULT_GEOMETRY);
- }
-
- gtk_widget_show_all (window);
- }
-}
-
-static void
-create_gridded_geometry (GtkWidget *widget)
-{
- static GtkWidget *window = NULL;
- gpointer window_ptr;
- GtkWidget *content_area;
- GtkWidget *entry;
- GtkWidget *label;
-
- if (!window)
- {
- window = gtk_dialog_new_with_buttons ("Gridded Geometry",
- NULL, 0,
- "Create", 1,
- GTK_STOCK_CLOSE, GTK_RESPONSE_NONE,
- NULL);
-
- gtk_window_set_screen (GTK_WINDOW (window),
- gtk_widget_get_screen (widget));
-
- content_area = gtk_dialog_get_content_area (GTK_DIALOG (window));
-
- label = gtk_label_new ("Geometry string:");
- gtk_box_pack_start (GTK_BOX (content_area), label, FALSE, FALSE, 0);
-
- entry = gtk_entry_new ();
- gtk_entry_set_text (GTK_ENTRY (entry), DEFAULT_GEOMETRY);
- gtk_box_pack_start (GTK_BOX (content_area), entry, FALSE, FALSE, 0);
-
- g_signal_connect (window, "response",
- G_CALLBACK (gridded_geometry_response), entry);
- window_ptr = &window;
- g_object_add_weak_pointer (G_OBJECT (window), window_ptr);
-
- gtk_widget_show_all (window);
- }
- else
- gtk_widget_destroy (window);
-}
-
/*
* GtkHandleBox
*/
gtk_container_set_border_width (GTK_CONTAINER (window), 20);
- vbox = gtk_vbox_new (FALSE, 0);
+ vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_container_add (GTK_CONTAINER (window), vbox);
gtk_widget_show (vbox);
gtk_container_add (GTK_CONTAINER (vbox), label);
gtk_widget_show (label);
- separator = gtk_hseparator_new ();
+ separator = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
gtk_container_add (GTK_CONTAINER (vbox), separator);
gtk_widget_show (separator);
- hbox = gtk_hbox_new (FALSE, 10);
+ hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 10);
gtk_container_add (GTK_CONTAINER (vbox), hbox);
gtk_widget_show (hbox);
- separator = gtk_hseparator_new ();
+ separator = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
gtk_container_add (GTK_CONTAINER (vbox), separator);
gtk_widget_show (separator);
sensitivity_toggled (GtkWidget *toggle,
GtkWidget *widget)
{
- gtk_widget_set_sensitive (widget, GTK_TOGGLE_BUTTON (toggle)->active);
+ gtk_widget_set_sensitive (widget,
+ gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (toggle)));
}
static GtkWidget*
GtkWidget *widget)
{
set_selectable_recursive (widget,
- GTK_TOGGLE_BUTTON (toggle)->active);
+ gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (toggle)));
}
static GtkWidget*
gtk_window_set_title (GTK_WINDOW (window), "Label");
- vbox = gtk_vbox_new (FALSE, 5);
+ vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
- hbox = gtk_hbox_new (FALSE, 5);
+ hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 5);
gtk_container_add (GTK_CONTAINER (window), vbox);
gtk_box_pack_end (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
- vbox = gtk_vbox_new (FALSE, 5);
+ vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 0);
gtk_container_set_border_width (GTK_CONTAINER (window), 5);
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);
+ vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 0);
frame = gtk_frame_new ("Line wrapped label");
label = gtk_label_new ("This is an example of a line-wrapped label. It should not be taking "\
"but this _word is <span foreground=\"purple\"><big>purple</big></span>\n"
"<span underline=\"double\">We like <sup>superscript</sup> and <sub>subscript</sub> too</span>");
- g_assert (gtk_label_get_mnemonic_keyval (GTK_LABEL (label)) == GDK_s);
+ g_assert (gtk_label_get_mnemonic_keyval (GTK_LABEL (label)) == GDK_KEY_s);
gtk_container_add (GTK_CONTAINER (frame), label);
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
gtk_widget_get_screen (widget));
g_signal_connect (window, "response",
- G_CALLBACK (gtk_object_destroy), NULL);
+ G_CALLBACK (gtk_widget_destroy), NULL);
g_signal_connect (window, "destroy",
G_CALLBACK (gtk_widget_destroyed), &window);
content_area = gtk_dialog_get_content_area (GTK_DIALOG (window));
- vbox = gtk_vbox_new (FALSE, 5);
+ vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
gtk_box_pack_start (GTK_BOX (content_area), vbox, TRUE, TRUE, 0);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 10);
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);
+ scale_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 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);
+ hscale = gtk_scale_new_with_range (GTK_ORIENTATION_HORIZONTAL,
+ 0, 360, 5);
g_signal_connect (hscale, "value-changed",
G_CALLBACK (on_angle_scale_changed), label);
}
static gboolean
-on_rotated_text_expose (GtkWidget *widget,
- GdkEventExpose *event,
- GdkPixbuf *tile_pixbuf)
+on_rotated_text_draw (GtkWidget *widget,
+ cairo_t *cr,
+ GdkPixbuf *tile_pixbuf)
{
static const gchar *words[] = { "The", "grand", "old", "Duke", "of", "York",
"had", "10,000", "men" };
int n_words;
int i;
+ int width, height;
double radius;
PangoLayout *layout;
PangoContext *context;
PangoFontDescription *desc;
- cairo_t *cr;
-
- cr = gdk_cairo_create (event->window);
if (tile_pixbuf)
{
else
cairo_set_source_rgb (cr, 0, 0, 0);
- radius = MIN (widget->allocation.width, widget->allocation.height) / 2.;
+ width = gtk_widget_get_allocated_width (widget);
+ height = gtk_widget_get_allocated_height (widget);
+ radius = MIN (width, height) / 2.;
cairo_translate (cr,
- radius + (widget->allocation.width - 2 * radius) / 2,
- radius + (widget->allocation.height - 2 * radius) / 2);
+ radius + (width - 2 * radius) / 2,
+ radius + (height - 2 * radius) / 2);
cairo_scale (cr, radius / DEFAULT_TEXT_RADIUS, radius / DEFAULT_TEXT_RADIUS);
context = gtk_widget_get_pango_context (widget);
}
g_object_unref (layout);
- cairo_destroy (cr);
return FALSE;
}
gtk_widget_get_screen (widget));
g_signal_connect (window, "response",
- G_CALLBACK (gtk_object_destroy), NULL);
+ G_CALLBACK (gtk_widget_destroy), NULL);
g_signal_connect (window, "destroy",
G_CALLBACK (gtk_widget_destroyed), &window);
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, "draw",
+ G_CALLBACK (on_rotated_text_draw), tile_pixbuf);
g_signal_connect (drawing_area, "unrealize",
G_CALLBACK (on_rotated_text_unrealize), NULL);
gtk_widget_show_all (gtk_bin_get_child (GTK_BIN (window)));
gtk_widget_set_size_request (drawing_area, DEFAULT_TEXT_RADIUS * 2, DEFAULT_TEXT_RADIUS * 2);
- gtk_widget_size_request (window, &requisition);
+ gtk_widget_get_preferred_size ( (window),
+ &requisition, NULL);
gtk_widget_set_size_request (drawing_area, -1, -1);
gtk_window_resize (GTK_WINDOW (window), requisition.width, requisition.height);
}
GtkWidget *old_parent,
gpointer func_data)
{
+ GtkWidget *parent;
+
+ parent = gtk_widget_get_parent (child);
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",
+ parent ? g_type_name (G_OBJECT_TYPE (parent)) : "NULL",
old_parent ? g_type_name (G_OBJECT_TYPE (old_parent)) : "NULL",
GPOINTER_TO_INT (func_data));
}
gtk_window_set_title (GTK_WINDOW (window), "reparent");
gtk_container_set_border_width (GTK_CONTAINER (window), 0);
- box1 = gtk_vbox_new (FALSE, 0);
+ box1 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_container_add (GTK_CONTAINER (window), box1);
- box2 = gtk_hbox_new (FALSE, 5);
+ box2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 5);
gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
frame = gtk_frame_new ("Frame 1");
gtk_box_pack_start (GTK_BOX (box2), frame, TRUE, TRUE, 0);
- box3 = gtk_vbox_new (FALSE, 5);
+ box3 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
gtk_container_set_border_width (GTK_CONTAINER (box3), 5);
gtk_container_add (GTK_CONTAINER (frame), box3);
frame = gtk_frame_new ("Frame 2");
gtk_box_pack_start (GTK_BOX (box2), frame, TRUE, TRUE, 0);
- box3 = gtk_vbox_new (FALSE, 5);
+ box3 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
gtk_container_set_border_width (GTK_CONTAINER (box3), 5);
gtk_container_add (GTK_CONTAINER (frame), box3);
G_CALLBACK (reparent_label),
event_box);
- separator = gtk_hseparator_new ();
+ separator = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
- box2 = gtk_vbox_new (FALSE, 10);
+ box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10);
gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
}
static gboolean
-grippy_expose (GtkWidget *area, GdkEventExpose *event, GdkWindowEdge edge)
+grippy_draw (GtkWidget *area, cairo_t *cr, GdkWindowEdge edge)
{
- gtk_paint_resize_grip (area->style,
- area->window,
+ gtk_paint_resize_grip (gtk_widget_get_style (area),
+ cr,
gtk_widget_get_state (area),
- &event->area,
area,
"statusbar",
edge,
0, 0,
- area->allocation.width,
- area->allocation.height);
+ gtk_widget_get_allocated_width (area),
+ gtk_widget_get_allocated_height (area));
return TRUE;
}
G_CALLBACK (gtk_widget_destroyed),
&window);
- vbox = gtk_vbox_new (FALSE, 0);
+ vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_container_add (GTK_CONTAINER (window), vbox);
- hbox = gtk_hbox_new (FALSE, 0);
+ hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 0);
/* North west */
area = gtk_drawing_area_new ();
gtk_widget_add_events (area, GDK_BUTTON_PRESS_MASK);
gtk_box_pack_start (GTK_BOX (hbox), area, TRUE, TRUE, 0);
- g_signal_connect (area, "expose_event", G_CALLBACK (grippy_expose),
+ g_signal_connect (area, "draw", G_CALLBACK (grippy_draw),
GINT_TO_POINTER (GDK_WINDOW_EDGE_NORTH_WEST));
g_signal_connect (area, "button_press_event", G_CALLBACK (grippy_button_press),
GINT_TO_POINTER (GDK_WINDOW_EDGE_NORTH_WEST));
area = gtk_drawing_area_new ();
gtk_widget_add_events (area, GDK_BUTTON_PRESS_MASK);
gtk_box_pack_start (GTK_BOX (hbox), area, TRUE, TRUE, 0);
- g_signal_connect (area, "expose_event", G_CALLBACK (grippy_expose),
+ g_signal_connect (area, "draw", G_CALLBACK (grippy_draw),
GINT_TO_POINTER (GDK_WINDOW_EDGE_NORTH));
g_signal_connect (area, "button_press_event", G_CALLBACK (grippy_button_press),
GINT_TO_POINTER (GDK_WINDOW_EDGE_NORTH));
area = gtk_drawing_area_new ();
gtk_widget_add_events (area, GDK_BUTTON_PRESS_MASK);
gtk_box_pack_start (GTK_BOX (hbox), area, TRUE, TRUE, 0);
- g_signal_connect (area, "expose_event", G_CALLBACK (grippy_expose),
+ g_signal_connect (area, "draw", G_CALLBACK (grippy_draw),
GINT_TO_POINTER (GDK_WINDOW_EDGE_NORTH_EAST));
g_signal_connect (area, "button_press_event", G_CALLBACK (grippy_button_press),
GINT_TO_POINTER (GDK_WINDOW_EDGE_NORTH_EAST));
- hbox = gtk_hbox_new (FALSE, 0);
+ hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 0);
/* West */
area = gtk_drawing_area_new ();
gtk_widget_add_events (area, GDK_BUTTON_PRESS_MASK);
gtk_box_pack_start (GTK_BOX (hbox), area, TRUE, TRUE, 0);
- g_signal_connect (area, "expose_event", G_CALLBACK (grippy_expose),
+ g_signal_connect (area, "draw", G_CALLBACK (grippy_draw),
GINT_TO_POINTER (GDK_WINDOW_EDGE_WEST));
g_signal_connect (area, "button_press_event", G_CALLBACK (grippy_button_press),
GINT_TO_POINTER (GDK_WINDOW_EDGE_WEST));
area = gtk_drawing_area_new ();
gtk_widget_add_events (area, GDK_BUTTON_PRESS_MASK);
gtk_box_pack_start (GTK_BOX (hbox), area, TRUE, TRUE, 0);
- g_signal_connect (area, "expose_event", G_CALLBACK (grippy_expose),
+ g_signal_connect (area, "draw", G_CALLBACK (grippy_draw),
GINT_TO_POINTER (GDK_WINDOW_EDGE_EAST));
g_signal_connect (area, "button_press_event", G_CALLBACK (grippy_button_press),
GINT_TO_POINTER (GDK_WINDOW_EDGE_EAST));
- hbox = gtk_hbox_new (FALSE, 0);
+ hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 0);
/* South west */
area = gtk_drawing_area_new ();
gtk_widget_add_events (area, GDK_BUTTON_PRESS_MASK);
gtk_box_pack_start (GTK_BOX (hbox), area, TRUE, TRUE, 0);
- g_signal_connect (area, "expose_event", G_CALLBACK (grippy_expose),
+ g_signal_connect (area, "draw", G_CALLBACK (grippy_draw),
GINT_TO_POINTER (GDK_WINDOW_EDGE_SOUTH_WEST));
g_signal_connect (area, "button_press_event", G_CALLBACK (grippy_button_press),
GINT_TO_POINTER (GDK_WINDOW_EDGE_SOUTH_WEST));
area = gtk_drawing_area_new ();
gtk_widget_add_events (area, GDK_BUTTON_PRESS_MASK);
gtk_box_pack_start (GTK_BOX (hbox), area, TRUE, TRUE, 0);
- g_signal_connect (area, "expose_event", G_CALLBACK (grippy_expose),
+ g_signal_connect (area, "draw", G_CALLBACK (grippy_draw),
GINT_TO_POINTER (GDK_WINDOW_EDGE_SOUTH));
g_signal_connect (area, "button_press_event", G_CALLBACK (grippy_button_press),
GINT_TO_POINTER (GDK_WINDOW_EDGE_SOUTH));
area = gtk_drawing_area_new ();
gtk_widget_add_events (area, GDK_BUTTON_PRESS_MASK);
gtk_box_pack_start (GTK_BOX (hbox), area, TRUE, TRUE, 0);
- g_signal_connect (area, "expose_event", G_CALLBACK (grippy_expose),
+ g_signal_connect (area, "draw", G_CALLBACK (grippy_draw),
GINT_TO_POINTER (GDK_WINDOW_EDGE_SOUTH_EAST));
g_signal_connect (area, "button_press_event", G_CALLBACK (grippy_button_press),
GINT_TO_POINTER (GDK_WINDOW_EDGE_SOUTH_EAST));
lx = g_object_get_data (G_OBJECT (window), "x");
ly = g_object_get_data (G_OBJECT (window), "y");
- gdk_window_get_root_origin (window->window, &upositionx, &upositiony);
+ gdk_window_get_root_origin (gtk_widget_get_window (window),
+ &upositionx, &upositiony);
sprintf (buffer, "%d", upositionx);
gtk_label_set_text (lx, buffer);
sprintf (buffer, "%d", upositiony);
static void
uposition_stop_configure (GtkToggleButton *toggle,
- GtkObject *window)
+ GObject *window)
{
- if (toggle->active)
+ if (gtk_toggle_button_get_active (toggle))
g_signal_handlers_block_by_func (window, G_CALLBACK (uposition_configure), NULL);
else
g_signal_handlers_unblock_by_func (window, G_CALLBACK (uposition_configure), NULL);
G_CALLBACK (gtk_widget_destroyed),
&window);
- main_vbox = gtk_vbox_new (FALSE, 5);
+ main_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 0);
gtk_container_add (GTK_CONTAINER (window), main_vbox);
NULL),
NULL);
- hbox = gtk_hbox_new (FALSE, 0);
+ hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (hbox), x_label, TRUE, TRUE, 0);
g_object_set_data (G_OBJECT (window), "x", x_label);
- hbox = gtk_hbox_new (FALSE, 0);
+ hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0);
NULL);
gtk_box_pack_start (GTK_BOX (main_vbox), any, FALSE, TRUE, 0);
- hbox = gtk_hbox_new (FALSE, 0);
+ hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_container_set_border_width (GTK_CONTAINER (hbox), 10);
gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, TRUE, 0);
*/
static void
-create_pixmap (GtkWidget *widget)
+create_pixbuf (GtkWidget *widget)
{
static GtkWidget *window = NULL;
GtkWidget *box1;
GtkWidget *button;
GtkWidget *label;
GtkWidget *separator;
- GtkWidget *pixmapwid;
+ GtkWidget *pixbufwid;
+ GdkWindow *gdk_window;
if (!window)
{
gtk_container_set_border_width (GTK_CONTAINER (window), 0);
gtk_widget_realize(window);
- box1 = gtk_vbox_new (FALSE, 0);
+ box1 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_container_add (GTK_CONTAINER (window), box1);
- box2 = gtk_vbox_new (FALSE, 10);
+ box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10);
gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
button = gtk_button_new ();
gtk_box_pack_start (GTK_BOX (box2), button, FALSE, FALSE, 0);
- pixmapwid = new_pixmap ("test.xpm", window->window, NULL);
+ gdk_window = gtk_widget_get_window (window);
- label = gtk_label_new ("Pixmap\ntest");
- box3 = gtk_hbox_new (FALSE, 0);
+ pixbufwid = new_pixbuf ("test.xpm", gdk_window, NULL);
+
+ label = gtk_label_new ("Pixbuf\ntest");
+ box3 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_container_set_border_width (GTK_CONTAINER (box3), 2);
- gtk_container_add (GTK_CONTAINER (box3), pixmapwid);
+ gtk_container_add (GTK_CONTAINER (box3), pixbufwid);
gtk_container_add (GTK_CONTAINER (box3), label);
gtk_container_add (GTK_CONTAINER (button), box3);
button = gtk_button_new ();
gtk_box_pack_start (GTK_BOX (box2), button, FALSE, FALSE, 0);
-
- pixmapwid = new_pixmap ("test.xpm", window->window, NULL);
- label = gtk_label_new ("Pixmap\ntest");
- box3 = gtk_hbox_new (FALSE, 0);
+ pixbufwid = new_pixbuf ("test.xpm", gdk_window, NULL);
+
+ label = gtk_label_new ("Pixbuf\ntest");
+ box3 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_container_set_border_width (GTK_CONTAINER (box3), 2);
- gtk_container_add (GTK_CONTAINER (box3), pixmapwid);
+ gtk_container_add (GTK_CONTAINER (box3), pixbufwid);
gtk_container_add (GTK_CONTAINER (box3), label);
gtk_container_add (GTK_CONTAINER (button), box3);
gtk_widget_set_sensitive (button, FALSE);
- separator = gtk_hseparator_new ();
+ separator = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
- box2 = gtk_vbox_new (FALSE, 10);
+ box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10);
gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
gtk_window_set_screen (GTK_WINDOW (window),
gtk_widget_get_screen (widget));
- box1 = gtk_vbox_new (FALSE, 0);
+ box1 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_container_add (GTK_CONTAINER (window), box1);
- box2 = gtk_vbox_new (FALSE, 10);
+ box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10);
gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
NULL);
gtk_box_set_child_packing (GTK_BOX (box2), frame, TRUE, TRUE, 10, GTK_PACK_START);
- separator = gtk_hseparator_new ();
+ separator = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
- box2 = gtk_vbox_new (FALSE, 10);
+ box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10);
gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
if (window == NULL)
{
GtkWidget *vbox;
- GdkPixmap *pixmap;
- GdkBitmap *mask;
+ GdkPixbuf *pixbuf;
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
G_CALLBACK (gtk_widget_destroyed),
&window);
- vbox = gtk_vbox_new (FALSE, 5);
+ vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
gtk_container_add (GTK_CONTAINER (window), vbox);
gtk_image_new_from_stock (GTK_STOCK_DIALOG_WARNING,
GTK_ICON_SIZE_DIALOG));
- pixmap = gdk_pixmap_colormap_create_from_xpm_d (NULL,
- gtk_widget_get_colormap (window),
- &mask,
- NULL,
- openfile);
+ pixbuf = gdk_pixbuf_new_from_xpm_data ((const char **) openfile);
- pack_image (vbox, "Pixmap",
- gtk_image_new_from_pixmap (pixmap, mask));
+ pack_image (vbox, "Pixbuf",
+ gtk_image_new_from_pixbuf (pixbuf));
+
+ g_object_unref (pixbuf);
}
if (!gtk_widget_get_visible (window))
gtk_container_set_border_width (GTK_CONTAINER (window), 0);
- box1 = gtk_vbox_new (FALSE, 0);
+ box1 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_container_add (GTK_CONTAINER (window), box1);
gtk_widget_show (box1);
gtk_menu_shell_append (GTK_MENU_SHELL (menubar), menuitem);
gtk_widget_show (menuitem);
- box2 = gtk_vbox_new (FALSE, 10);
+ box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10);
gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
gtk_widget_show (box2);
gtk_widget_add_accelerator (menuitem,
"activate",
accel_group,
- GDK_F1,
+ GDK_KEY_F1,
0,
GTK_ACCEL_VISIBLE);
menuitem = gtk_check_menu_item_new_with_label ("Accelerator Locked");
gtk_widget_add_accelerator (menuitem,
"activate",
accel_group,
- GDK_F2,
+ GDK_KEY_F2,
0,
GTK_ACCEL_VISIBLE | GTK_ACCEL_LOCKED);
menuitem = gtk_check_menu_item_new_with_label ("Accelerators Frozen");
gtk_widget_add_accelerator (menuitem,
"activate",
accel_group,
- GDK_F2,
+ GDK_KEY_F2,
0,
GTK_ACCEL_VISIBLE);
gtk_widget_add_accelerator (menuitem,
"activate",
accel_group,
- GDK_F3,
+ GDK_KEY_F3,
0,
GTK_ACCEL_VISIBLE);
-
- optionmenu = gtk_combo_box_new_text ();
+
+ optionmenu = gtk_combo_box_text_new ();
gtk_combo_box_set_active (GTK_COMBO_BOX (optionmenu), 3);
gtk_box_pack_start (GTK_BOX (box2), optionmenu, TRUE, TRUE, 0);
gtk_widget_show (optionmenu);
- separator = gtk_hseparator_new ();
+ separator = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
gtk_widget_show (separator);
- box2 = gtk_vbox_new (FALSE, 10);
+ box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10);
gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
gtk_widget_show (box2);
window_ptr = &window;
g_object_add_weak_pointer (G_OBJECT (window), window_ptr);
- g_signal_connect (window, "response", G_CALLBACK (gtk_object_destroy), NULL);
+ g_signal_connect (window, "response", G_CALLBACK (gtk_widget_destroy), NULL);
gtk_widget_show_all (window);
}
gtk_window_set_modal (GTK_WINDOW(window),TRUE);
/* Create widgets */
- box1 = gtk_vbox_new (FALSE,5);
+ box1 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
frame1 = gtk_frame_new ("Standard dialogs in modal form");
- box2 = gtk_vbox_new (TRUE,5);
+ box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
+ gtk_box_set_homogeneous (GTK_BOX (box2), TRUE);
btnColor = gtk_button_new_with_label ("Color");
btnFile = gtk_button_new_with_label ("File Selection");
btnClose = gtk_button_new_with_label ("Close");
gtk_container_add (GTK_CONTAINER (frame1), box2);
gtk_box_pack_start (GTK_BOX (box2), btnColor, FALSE, FALSE, 4);
gtk_box_pack_start (GTK_BOX (box2), btnFile, FALSE, FALSE, 4);
- gtk_box_pack_start (GTK_BOX (box1), gtk_hseparator_new (), FALSE, FALSE, 4);
+ gtk_box_pack_start (GTK_BOX (box1), gtk_separator_new (GTK_ORIENTATION_HORIZONTAL), FALSE, FALSE, 4);
gtk_box_pack_start (GTK_BOX (box1), btnClose, FALSE, FALSE, 4);
/* connect signals */
static GtkWidget *sw_parent = NULL;
static GtkWidget *sw_float_parent;
-static guint sw_destroyed_handler = 0;
+static gulong sw_destroyed_handler = 0;
static gboolean
scrolled_windows_delete_cb (GtkWidget *widget, GdkEventAny *event, GtkWidget *scrollwin)
}
else
{
- sw_parent = scrollwin->parent;
+ sw_parent = gtk_widget_get_parent (scrollwin);
sw_float_parent = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_screen (GTK_WINDOW (sw_float_parent),
gtk_widget_get_screen (widget));
GtkWidget *entry)
{
gtk_entry_set_has_frame (GTK_ENTRY(entry),
- GTK_TOGGLE_BUTTON(checkbutton)->active);
+ gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (checkbutton)));
}
static void
entry_toggle_sensitive (GtkWidget *checkbutton,
GtkWidget *entry)
{
- gtk_widget_set_sensitive (entry, GTK_TOGGLE_BUTTON(checkbutton)->active);
+ gtk_widget_set_sensitive (entry,
+ gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON(checkbutton)));
}
static gboolean
entry_toggle_progress (GtkWidget *checkbutton,
GtkWidget *entry)
{
- if (GTK_TOGGLE_BUTTON (checkbutton)->active)
+ if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (checkbutton)))
{
guint timeout = gdk_threads_add_timeout (100,
entry_progress_timeout,
GtkWidget *entry)
{
g_object_set_data (G_OBJECT (entry), "progress-pulse",
- GUINT_TO_POINTER ((guint) GTK_TOGGLE_BUTTON (checkbutton)->active));
+ GUINT_TO_POINTER ((guint) gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (checkbutton))));
}
static void
GtkWidget *sensitive_check;
GtkWidget *progress_check;
GtkWidget *entry;
- GtkComboBox *cb;
+ GtkComboBoxText *cb;
GtkWidget *cb_entry;
GtkWidget *button;
GtkWidget *separator;
gtk_container_set_border_width (GTK_CONTAINER (window), 0);
- box1 = gtk_vbox_new (FALSE, 0);
+ box1 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_container_add (GTK_CONTAINER (window), box1);
- box2 = gtk_vbox_new (FALSE, 10);
+ box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10);
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);
+ hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 5);
gtk_box_pack_start (GTK_BOX (box2), hbox, TRUE, TRUE, 0);
entry = gtk_entry_new ();
G_CALLBACK (props_clicked),
entry);
- cb = GTK_COMBO_BOX (gtk_combo_box_entry_new_text ());
- gtk_combo_box_append_text (cb, "item0");
- gtk_combo_box_append_text (cb, "item0");
- gtk_combo_box_append_text (cb, "item1 item1");
- gtk_combo_box_append_text (cb, "item2 item2 item2");
- gtk_combo_box_append_text (cb, "item3 item3 item3 item3");
- gtk_combo_box_append_text (cb, "item4 item4 item4 item4 item4");
- gtk_combo_box_append_text (cb, "item5 item5 item5 item5 item5 item5");
- gtk_combo_box_append_text (cb, "item6 item6 item6 item6 item6");
- gtk_combo_box_append_text (cb, "item7 item7 item7 item7");
- gtk_combo_box_append_text (cb, "item8 item8 item8");
- gtk_combo_box_append_text (cb, "item9 item9");
+ cb = GTK_COMBO_BOX_TEXT (gtk_combo_box_text_new_with_entry ());
+
+ gtk_combo_box_text_append_text (cb, "item0");
+ gtk_combo_box_text_append_text (cb, "item0");
+ gtk_combo_box_text_append_text (cb, "item1 item1");
+ gtk_combo_box_text_append_text (cb, "item2 item2 item2");
+ gtk_combo_box_text_append_text (cb, "item3 item3 item3 item3");
+ gtk_combo_box_text_append_text (cb, "item4 item4 item4 item4 item4");
+ gtk_combo_box_text_append_text (cb, "item5 item5 item5 item5 item5 item5");
+ gtk_combo_box_text_append_text (cb, "item6 item6 item6 item6 item6");
+ gtk_combo_box_text_append_text (cb, "item7 item7 item7 item7");
+ gtk_combo_box_text_append_text (cb, "item8 item8 item8");
+ gtk_combo_box_text_append_text (cb, "item9 item9");
cb_entry = gtk_bin_get_child (GTK_BIN (cb));
gtk_entry_set_text (GTK_ENTRY (cb_entry), "hello world \n\n\n foo");
g_signal_connect (progress_check, "toggled",
G_CALLBACK (entry_toggle_pulse), entry);
- separator = gtk_hseparator_new ();
+ separator = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
- box2 = gtk_vbox_new (FALSE, 10);
+ box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10);
gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
gtk_window_set_title (GTK_WINDOW (window), "expander");
gtk_container_set_border_width (GTK_CONTAINER (window), 0);
- box1 = gtk_vbox_new (FALSE, 0);
+ box1 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_container_add (GTK_CONTAINER (window), box1);
expander = gtk_expander_new ("The Hidden");
GtkEventBox *event_box)
{
gtk_event_box_set_visible_window (event_box,
- GTK_TOGGLE_BUTTON(checkbutton)->active);
+ gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (checkbutton)));
}
static void
GtkEventBox *event_box)
{
gtk_event_box_set_above_child (event_box,
- GTK_TOGGLE_BUTTON(checkbutton)->active);
+ gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (checkbutton)));
}
static void
gtk_window_set_title (GTK_WINDOW (window), "event box");
gtk_container_set_border_width (GTK_CONTAINER (window), 0);
- box1 = gtk_vbox_new (FALSE, 0);
+ box1 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_container_add (GTK_CONTAINER (window), box1);
gtk_widget_modify_bg (window, GTK_STATE_NORMAL, &color);
- hbox = gtk_hbox_new (FALSE, 0);
+ hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_pack_start (GTK_BOX (box1), hbox, TRUE, FALSE, 0);
event_box = gtk_event_box_new ();
gtk_box_pack_start (GTK_BOX (hbox), event_box, TRUE, FALSE, 0);
- vbox = gtk_vbox_new (FALSE, 0);
+ vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_container_add (GTK_CONTAINER (event_box), vbox);
g_signal_connect (event_box, "button_press_event",
G_CALLBACK (event_box_label_pressed),
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 ();
+ separator = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
- box2 = gtk_vbox_new (FALSE, 10);
+ box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10);
gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
g_object_unref (vgroup1);
g_object_unref (vgroup2);
- hbox = gtk_hbox_new (FALSE, 5);
+ hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 5);
gtk_box_pack_start (GTK_BOX (content_area), hbox, FALSE, FALSE, 0);
spin_button = gtk_spin_button_new_with_range (1, 100, 1);
static void
toggle_snap (GtkWidget *widget, GtkSpinButton *spin)
{
- gtk_spin_button_set_snap_to_ticks (spin, GTK_TOGGLE_BUTTON (widget)->active);
+ gtk_spin_button_set_snap_to_ticks (spin,
+ gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget)));
}
static void
toggle_numeric (GtkWidget *widget, GtkSpinButton *spin)
{
- gtk_spin_button_set_numeric (spin, GTK_TOGGLE_BUTTON (widget)->active);
+ gtk_spin_button_set_numeric (spin,
+ gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget)));
}
static void
gtk_window_set_title (GTK_WINDOW (window), "GtkSpinButton");
- main_vbox = gtk_vbox_new (FALSE, 5);
+ main_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 10);
gtk_container_add (GTK_CONTAINER (window), main_vbox);
frame = gtk_frame_new ("Not accelerated");
gtk_box_pack_start (GTK_BOX (main_vbox), frame, TRUE, TRUE, 0);
- vbox = gtk_vbox_new (FALSE, 0);
+ vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 5);
gtk_container_add (GTK_CONTAINER (frame), vbox);
/* Time, month, hex spinners */
- hbox = gtk_hbox_new (FALSE, 0);
+ hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 5);
- vbox2 = gtk_vbox_new (FALSE, 0);
+ vbox2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 5);
label = gtk_label_new ("Time :");
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, TRUE, 0);
-
- adj = (GtkAdjustment *) gtk_adjustment_new (0, 0, 1410, 30, 60, 0);
+
+ adj = gtk_adjustment_new (0, 0, 1410, 30, 60, 0);
spinner = gtk_spin_button_new (adj, 0, 0);
gtk_editable_set_editable (GTK_EDITABLE (spinner), FALSE);
g_signal_connect (spinner,
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);
+ vbox2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 5);
label = gtk_label_new ("Month :");
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, TRUE, 0);
-
- adj = (GtkAdjustment *) gtk_adjustment_new (1.0, 1.0, 12.0, 1.0,
+
+ adj = gtk_adjustment_new (1.0, 1.0, 12.0, 1.0,
5.0, 0.0);
spinner = gtk_spin_button_new (adj, 0, 0);
gtk_spin_button_set_update_policy (GTK_SPIN_BUTTON (spinner),
gtk_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);
+ vbox2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 5);
label = gtk_label_new ("Hex :");
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, TRUE, 0);
- adj = (GtkAdjustment *) gtk_adjustment_new (0, 0, 255, 1, 16, 0);
+ adj = gtk_adjustment_new (0, 0, 255, 1, 16, 0);
spinner = gtk_spin_button_new (adj, 0, 0);
gtk_editable_set_editable (GTK_EDITABLE (spinner), TRUE);
g_signal_connect (spinner,
frame = gtk_frame_new ("Accelerated");
gtk_box_pack_start (GTK_BOX (main_vbox), frame, TRUE, TRUE, 0);
- vbox = gtk_vbox_new (FALSE, 0);
+ vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 5);
gtk_container_add (GTK_CONTAINER (frame), vbox);
- hbox = gtk_hbox_new (FALSE, 0);
+ hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 5);
- vbox2 = gtk_vbox_new (FALSE, 0);
+ vbox2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_box_pack_start (GTK_BOX (hbox), vbox2, FALSE, FALSE, 5);
label = gtk_label_new ("Value :");
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, TRUE, 0);
- adj = (GtkAdjustment *) gtk_adjustment_new (0.0, -10000.0, 10000.0,
+ adj = gtk_adjustment_new (0.0, -10000.0, 10000.0,
0.5, 100.0, 0.0);
spinner1 = gtk_spin_button_new (adj, 1.0, 2);
gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spinner1), TRUE);
gtk_box_pack_start (GTK_BOX (vbox2), spinner1, FALSE, TRUE, 0);
- vbox2 = gtk_vbox_new (FALSE, 0);
+ vbox2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_box_pack_start (GTK_BOX (hbox), vbox2, FALSE, FALSE, 5);
label = gtk_label_new ("Digits :");
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, TRUE, 0);
- adj = (GtkAdjustment *) gtk_adjustment_new (2, 1, 15, 1, 1, 0);
+ adj = gtk_adjustment_new (2, 1, 15, 1, 1, 0);
spinner2 = gtk_spin_button_new (adj, 0.0, 0);
g_signal_connect (adj, "value_changed",
G_CALLBACK (change_digits),
spinner2);
gtk_box_pack_start (GTK_BOX (vbox2), spinner2, FALSE, TRUE, 0);
- hbox = gtk_hbox_new (FALSE, 0);
+ hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 5);
button = gtk_check_button_new_with_label ("Snap to 0.5-ticks");
val_label = gtk_label_new ("");
- hbox = gtk_hbox_new (FALSE, 0);
+ hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 5);
button = gtk_button_new_with_label ("Value as Int");
frame = gtk_frame_new ("Using Convenience Constructor");
gtk_box_pack_start (GTK_BOX (main_vbox), frame, TRUE, TRUE, 0);
- hbox = gtk_hbox_new (FALSE, 0);
+ hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
gtk_container_add (GTK_CONTAINER (frame), hbox);
gtk_box_pack_start (GTK_BOX (hbox), spinner, TRUE, TRUE, 5);
gtk_box_pack_start (GTK_BOX (hbox), val_label, TRUE, TRUE, 5);
- hbox = gtk_hbox_new (FALSE, 0);
+ hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, TRUE, 0);
button = gtk_button_new_with_label ("Close");
*/
static gint
-cursor_expose_event (GtkWidget *widget,
- GdkEvent *event,
- gpointer user_data)
-{
- GtkDrawingArea *darea;
- GdkDrawable *drawable;
- guint max_width;
- guint max_height;
- cairo_t *cr;
-
- g_return_val_if_fail (widget != NULL, TRUE);
- g_return_val_if_fail (GTK_IS_DRAWING_AREA (widget), TRUE);
-
- darea = GTK_DRAWING_AREA (widget);
- drawable = widget->window;
- max_width = widget->allocation.width;
- max_height = widget->allocation.height;
+cursor_draw (GtkWidget *widget,
+ cairo_t *cr,
+ gpointer user_data)
+{
+ int width, height;
- cr = gdk_cairo_create (drawable);
+ width = gtk_widget_get_allocated_width (widget);
+ height = gtk_widget_get_allocated_height (widget);
cairo_set_source_rgb (cr, 1, 1, 1);
- cairo_rectangle (cr, 0, 0, max_width, max_height / 2);
+ cairo_rectangle (cr, 0, 0, width, height / 2);
cairo_fill (cr);
cairo_set_source_rgb (cr, 0, 0, 0);
- cairo_rectangle (cr, 0, max_height / 2, max_width, max_height / 2);
+ cairo_rectangle (cr, 0, height / 2, width, height / 2);
cairo_fill (cr);
- gdk_cairo_set_source_color (cr, &widget->style->bg[GTK_STATE_NORMAL]);
- cairo_rectangle (cr, max_width / 3, max_height / 3, max_width / 3, max_height / 3);
+ gdk_cairo_set_source_color (cr, >k_widget_get_style (widget)->bg[GTK_STATE_NORMAL]);
+ cairo_rectangle (cr, width / 3, height / 3, width / 3, height / 3);
cairo_fill (cr);
- cairo_destroy (cr);
-
return TRUE;
}
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_window_set_cursor (gtk_widget_get_window (widget),
+ cursor);
gdk_cursor_unref (cursor);
}
gtk_window_set_title (GTK_WINDOW (window), "Cursors");
- main_vbox = gtk_vbox_new (FALSE, 5);
+ main_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 0);
gtk_container_add (GTK_CONTAINER (window), main_vbox);
NULL);
#ifdef GDK_WINDOWING_X11
- hbox = gtk_hbox_new (FALSE, 0);
+ hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0);
G_CALLBACK (change_cursor_theme), hbox);
#endif
- hbox = gtk_hbox_new (FALSE, 0);
+ hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 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);
-
- adj = (GtkAdjustment *) gtk_adjustment_new (0,
- 0, 152,
- 2,
- 10, 0);
+
+ adj = gtk_adjustment_new (0,
+ 0, 152,
+ 2,
+ 10, 0);
spinner = gtk_spin_button_new (adj, 0, 0);
gtk_box_pack_start (GTK_BOX (hbox), spinner, TRUE, TRUE, 0);
frame =
g_object_new (gtk_frame_get_type (),
- "GtkFrame::shadow", GTK_SHADOW_ETCHED_IN,
"GtkFrame::label_xalign", 0.5,
"GtkFrame::label", "Cursor Area",
"GtkContainer::border_width", 10,
gtk_widget_set_size_request (darea, 80, 80);
gtk_container_add (GTK_CONTAINER (frame), darea);
g_signal_connect (darea,
- "expose_event",
- G_CALLBACK (cursor_expose_event),
+ "draw",
+ G_CALLBACK (cursor_draw),
NULL);
gtk_widget_set_events (darea, GDK_EXPOSURE_MASK | GDK_BUTTON_PRESS_MASK);
g_signal_connect (darea,
NULL);
gtk_box_pack_start (GTK_BOX (main_vbox), any, FALSE, TRUE, 0);
- hbox = gtk_hbox_new (FALSE, 0);
+ hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_container_set_border_width (GTK_CONTAINER (hbox), 10);
gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, TRUE, 0);
gtk_window_set_title (GTK_WINDOW (window), "GtkColorButton");
gtk_container_set_border_width (GTK_CONTAINER (window), 0);
- hbox = gtk_hbox_new (FALSE, 8);
+ hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 8);
gtk_container_set_border_width (GTK_CONTAINER (hbox), 8);
gtk_container_add (GTK_CONTAINER (window), hbox);
GtkTextDirection text_dir)
{
GtkWidget *frame = gtk_frame_new (title);
- GtkWidget *bbox = gtk_hbutton_box_new ();
+ GtkWidget *bbox = gtk_button_box_new (GTK_ORIENTATION_HORIZONTAL);
GtkWidget *back_button = gtk_button_new_from_stock (GTK_STOCK_GO_BACK);
GtkWidget *forward_button = gtk_button_new_from_stock (GTK_STOCK_GO_FORWARD);
gtk_window_set_title (GTK_WINDOW (window), "GtkFontButton");
gtk_container_set_border_width (GTK_CONTAINER (window), 0);
- hbox = gtk_hbox_new (FALSE, 8);
+ hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 8);
gtk_container_set_border_width (GTK_CONTAINER (hbox), 8);
gtk_container_add (GTK_CONTAINER (window), hbox);
gtk_widget_destroy (*label);
}
-#define RESPONSE_TOGGLE_SEPARATOR 1
-
-static void
-print_response (GtkWidget *dialog,
- gint response_id,
- gpointer data)
-{
- g_print ("response signal received (%d)\n", response_id);
-
- if (response_id == RESPONSE_TOGGLE_SEPARATOR)
- {
- gtk_dialog_set_has_separator (GTK_DIALOG (dialog),
- !gtk_dialog_get_has_separator (GTK_DIALOG (dialog)));
- }
-}
-
static void
create_dialog (GtkWidget *widget)
{
gtk_window_set_screen (GTK_WINDOW (dialog_window),
gtk_widget_get_screen (widget));
- g_signal_connect (dialog_window,
- "response",
- G_CALLBACK (print_response),
- NULL);
-
g_signal_connect (dialog_window, "destroy",
G_CALLBACK (gtk_widget_destroyed),
&dialog_window);
gtk_widget_show (button);
label = NULL;
-
- button = gtk_button_new_with_label ("Separator");
-
- gtk_widget_set_can_default (button, TRUE);
-
- gtk_dialog_add_action_widget (GTK_DIALOG (dialog_window),
- button,
- RESPONSE_TOGGLE_SEPARATOR);
- gtk_widget_show (button);
}
if (!gtk_widget_get_visible (dialog_window))
break;
}
if (!found)
- gtk_combo_box_append_text (GTK_COMBO_BOX (data->combo), display_name);
+ gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (data->combo), display_name);
new_screen = gdk_display_get_default_screen (display);
}
}
g_signal_connect (window, "destroy",
G_CALLBACK (gtk_widget_destroy), NULL);
- vbox = gtk_vbox_new (FALSE, 3);
+ vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 3);
gtk_container_add (GTK_CONTAINER (window), vbox);
frame = gtk_frame_new ("Select screen or display");
"only one screen on the current display");
gtk_widget_set_sensitive (radio_scr, FALSE);
}
- combo_dpy = gtk_combo_box_new_text ();
- gtk_combo_box_append_text (GTK_COMBO_BOX (combo_dpy), "diabolo:0.0");
+ combo_dpy = gtk_combo_box_text_new_with_entry ();
+ gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo_dpy), "diabolo:0.0");
gtk_entry_set_text (GTK_ENTRY (gtk_bin_get_child (GTK_BIN (combo_dpy))),
"<hostname>:<X Server Num>.<Screen Num>");
gtk_table_attach_defaults (GTK_TABLE (table), radio_scr, 0, 1, 1, 2);
gtk_table_attach_defaults (GTK_TABLE (table), combo_dpy, 1, 2, 0, 1);
- bbox = gtk_hbutton_box_new ();
+ bbox = gtk_button_box_new (GTK_ORIENTATION_HORIZONTAL);
applyb = gtk_button_new_from_stock (GTK_STOCK_APPLY);
cancelb = gtk_button_new_from_stock (GTK_STOCK_CANCEL);
/* Event Watcher
*/
-static gboolean event_watcher_enter_id = 0;
-static gboolean event_watcher_leave_id = 0;
+static gulong event_watcher_enter_id = 0;
+static gulong event_watcher_leave_id = 0;
static gboolean
event_watcher (GSignalInvocationHint *ihint,
GtkWidget *scrollbar;
GtkWidget *scale;
GtkWidget *separator;
- GtkObject *adjustment;
+ GtkAdjustment *adjustment;
GtkWidget *hbox;
if (!window)
gtk_container_set_border_width (GTK_CONTAINER (window), 0);
- box1 = gtk_vbox_new (FALSE, 0);
+ box1 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_container_add (GTK_CONTAINER (window), box1);
gtk_widget_show (box1);
- box2 = gtk_vbox_new (FALSE, 10);
+ box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10);
gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
gtk_widget_show (box2);
adjustment = gtk_adjustment_new (0.0, 0.0, 101.0, 0.1, 1.0, 1.0);
- scale = gtk_hscale_new (GTK_ADJUSTMENT (adjustment));
+ scale = gtk_scale_new (GTK_ORIENTATION_HORIZONTAL, GTK_ADJUSTMENT (adjustment));
gtk_widget_set_size_request (GTK_WIDGET (scale), 150, -1);
gtk_range_set_update_policy (GTK_RANGE (scale), GTK_UPDATE_DELAYED);
gtk_scale_set_digits (GTK_SCALE (scale), 1);
gtk_box_pack_start (GTK_BOX (box2), scale, TRUE, TRUE, 0);
gtk_widget_show (scale);
- scrollbar = gtk_hscrollbar_new (GTK_ADJUSTMENT (adjustment));
+ scrollbar = gtk_scrollbar_new (GTK_ORIENTATION_HORIZONTAL, GTK_ADJUSTMENT (adjustment));
gtk_range_set_update_policy (GTK_RANGE (scrollbar),
GTK_UPDATE_CONTINUOUS);
gtk_box_pack_start (GTK_BOX (box2), scrollbar, TRUE, TRUE, 0);
gtk_widget_show (scrollbar);
- scale = gtk_hscale_new (GTK_ADJUSTMENT (adjustment));
+ scale = gtk_scale_new (GTK_ORIENTATION_HORIZONTAL, GTK_ADJUSTMENT (adjustment));
gtk_scale_set_draw_value (GTK_SCALE (scale), TRUE);
g_signal_connect (scale,
"format_value",
gtk_box_pack_start (GTK_BOX (box2), scale, TRUE, TRUE, 0);
gtk_widget_show (scale);
- hbox = gtk_hbox_new (FALSE, 0);
+ hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
- scale = gtk_vscale_new (GTK_ADJUSTMENT (adjustment));
+ scale = gtk_scale_new (GTK_ORIENTATION_VERTICAL, GTK_ADJUSTMENT (adjustment));
gtk_widget_set_size_request (scale, -1, 200);
gtk_scale_set_digits (GTK_SCALE (scale), 2);
gtk_scale_set_draw_value (GTK_SCALE (scale), TRUE);
gtk_box_pack_start (GTK_BOX (hbox), scale, TRUE, TRUE, 0);
gtk_widget_show (scale);
- scale = gtk_vscale_new (GTK_ADJUSTMENT (adjustment));
+ scale = gtk_scale_new (GTK_ORIENTATION_VERTICAL, GTK_ADJUSTMENT (adjustment));
gtk_widget_set_size_request (scale, -1, 200);
gtk_scale_set_digits (GTK_SCALE (scale), 2);
gtk_scale_set_draw_value (GTK_SCALE (scale), TRUE);
gtk_box_pack_start (GTK_BOX (hbox), scale, TRUE, TRUE, 0);
gtk_widget_show (scale);
- scale = gtk_vscale_new (GTK_ADJUSTMENT (adjustment));
+ scale = gtk_scale_new (GTK_ORIENTATION_VERTICAL, GTK_ADJUSTMENT (adjustment));
gtk_scale_set_draw_value (GTK_SCALE (scale), TRUE);
g_signal_connect (scale,
"format_value",
gtk_box_pack_start (GTK_BOX (box2), hbox, TRUE, TRUE, 0);
gtk_widget_show (hbox);
- separator = gtk_hseparator_new ();
+ separator = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
gtk_widget_show (separator);
- box2 = gtk_vbox_new (FALSE, 10);
+ box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10);
gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
gtk_widget_show (box2);
gtk_container_add (GTK_CONTAINER (window), table);
gtk_widget_show (table);
- ruler = gtk_hruler_new ();
+ ruler = gtk_ruler_new (GTK_ORIENTATION_HORIZONTAL);
gtk_ruler_set_metric (GTK_RULER (ruler), GTK_CENTIMETERS);
gtk_ruler_set_range (GTK_RULER (ruler), 100, 0, 0, 20);
gtk_widget_show (ruler);
- ruler = gtk_vruler_new ();
+ ruler = gtk_ruler_new (GTK_ORIENTATION_VERTICAL);
gtk_ruler_set_range (GTK_RULER (ruler), 5, 15, 0, 20);
g_signal_connect_swapped (window,
* GtkNotebook
*/
-static char * book_open_xpm[] = {
+static const char * book_open_xpm[] = {
"16 16 4 1",
" c None s None",
". c black",
" .. ",
" "};
-static char * book_closed_xpm[] = {
+static const char * book_closed_xpm[] = {
"16 16 6 1",
" c None s None",
". c black",
child = gtk_frame_new (buffer);
gtk_container_set_border_width (GTK_CONTAINER (child), 10);
- vbox = gtk_vbox_new (TRUE,0);
+ vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
+ gtk_box_set_homogeneous (GTK_BOX (vbox), TRUE);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 10);
gtk_container_add (GTK_CONTAINER (child), vbox);
- hbox = gtk_hbox_new (TRUE,0);
+ hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
+ gtk_box_set_homogeneous (GTK_BOX (hbox), TRUE);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 5);
button = gtk_check_button_new_with_label ("Fill Tab");
gtk_widget_show_all (child);
- label_box = gtk_hbox_new (FALSE, 0);
+ label_box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
pixwid = gtk_image_new_from_pixbuf (book_closed);
g_object_set_data (G_OBJECT (child), "tab_pixmap", pixwid);
gtk_widget_show_all (label_box);
- menu_box = gtk_hbox_new (FALSE, 0);
+ menu_box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
pixwid = gtk_image_new_from_pixbuf (book_closed);
g_object_set_data (G_OBJECT (child), "menu_pixmap", pixwid);
notebook_popup (GtkToggleButton *button,
GtkNotebook *notebook)
{
- if (button->active)
+ if (gtk_toggle_button_get_active (button))
gtk_notebook_popup_enable (notebook);
else
gtk_notebook_popup_disable (notebook);
gtk_window_set_title (GTK_WINDOW (window), "notebook");
gtk_container_set_border_width (GTK_CONTAINER (window), 0);
- box1 = gtk_vbox_new (FALSE, 0);
+ box1 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_container_add (GTK_CONTAINER (window), box1);
sample_notebook = gtk_notebook_new ();
gtk_widget_realize (sample_notebook);
if (!book_open)
- book_open = gdk_pixbuf_new_from_xpm_data ((const char **)book_open_xpm);
+ book_open = gdk_pixbuf_new_from_xpm_data (book_open_xpm);
if (!book_closed)
- book_closed = gdk_pixbuf_new_from_xpm_data ((const char **)book_closed_xpm);
+ book_closed = gdk_pixbuf_new_from_xpm_data (book_closed_xpm);
create_pages (GTK_NOTEBOOK (sample_notebook), 1, 5);
- separator = gtk_hseparator_new ();
+ separator = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 10);
- box2 = gtk_hbox_new (FALSE, 5);
+ box2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 5);
gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
G_CALLBACK (notebook_popup),
sample_notebook);
- box2 = gtk_hbox_new (FALSE, 5);
+ box2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 5);
gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
g_signal_connect (button, "clicked",
G_CALLBACK (show_all_pages), sample_notebook);
- box2 = gtk_hbox_new (TRUE, 10);
+ box2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 10);
+ gtk_box_set_homogeneous (GTK_BOX (box2), TRUE);
gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
G_CALLBACK (rotate_notebook), sample_notebook);
gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
- separator = gtk_hseparator_new ();
+ separator = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 5);
button = gtk_button_new_with_label ("close");
gtk_window_set_title (GTK_WINDOW (window), "Panes");
gtk_container_set_border_width (GTK_CONTAINER (window), 0);
- vbox = gtk_vbox_new (FALSE, 0);
+ vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_container_add (GTK_CONTAINER (window), vbox);
- vpaned = gtk_vpaned_new ();
+ vpaned = gtk_paned_new (GTK_ORIENTATION_VERTICAL);
gtk_box_pack_start (GTK_BOX (vbox), vpaned, TRUE, TRUE, 0);
gtk_container_set_border_width (GTK_CONTAINER(vpaned), 5);
- hpaned = gtk_hpaned_new ();
+ hpaned = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL);
gtk_paned_add1 (GTK_PANED (vpaned), hpaned);
frame = gtk_frame_new (NULL);
gtk_window_set_screen (GTK_WINDOW (window1),
gtk_widget_get_screen (widget));
- hpaned1 = gtk_hpaned_new ();
+ hpaned1 = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL);
gtk_container_add (GTK_CONTAINER (window1), hpaned1);
frame1 = gtk_frame_new (NULL);
gtk_paned_pack1 (GTK_PANED (hpaned1), frame1, FALSE, TRUE);
gtk_frame_set_shadow_type (GTK_FRAME (frame1), GTK_SHADOW_IN);
- vbox1 = gtk_vbox_new (FALSE, 0);
+ vbox1 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_container_add (GTK_CONTAINER (frame1), vbox1);
button7 = gtk_button_new_with_label ("button7");
button9 = gtk_button_new_with_label ("button9");
gtk_box_pack_start (GTK_BOX (vbox1), button9, FALSE, FALSE, 0);
- vpaned1 = gtk_vpaned_new ();
+ vpaned1 = gtk_paned_new (GTK_ORIENTATION_VERTICAL);
gtk_paned_pack2 (GTK_PANED (hpaned1), vpaned1, TRUE, TRUE);
frame2 = gtk_frame_new (NULL);
frame5 = gtk_frame_new (NULL);
gtk_container_add (GTK_CONTAINER (frame2), frame5);
- hbox1 = gtk_hbox_new (FALSE, 0);
+ hbox1 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_container_add (GTK_CONTAINER (frame5), hbox1);
button5 = gtk_button_new_with_label ("button5");
gtk_window_set_screen (GTK_WINDOW (window2),
gtk_widget_get_screen (widget));
- hpaned2 = gtk_hpaned_new ();
+ hpaned2 = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL);
gtk_container_add (GTK_CONTAINER (window2), hpaned2);
frame6 = gtk_frame_new (NULL);
button13 = gtk_button_new_with_label ("button13");
gtk_container_add (GTK_CONTAINER (frame6), button13);
- hbox2 = gtk_hbox_new (FALSE, 0);
+ hbox2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_paned_pack2 (GTK_PANED (hpaned2), hbox2, TRUE, TRUE);
- vpaned2 = gtk_vpaned_new ();
+ vpaned2 = gtk_paned_new (GTK_ORIENTATION_VERTICAL);
gtk_box_pack_start (GTK_BOX (hbox2), vpaned2, TRUE, TRUE, 0);
frame7 = gtk_frame_new (NULL);
gtk_widget_get_screen (widget));
- vbox2 = gtk_vbox_new (FALSE, 0);
+ vbox2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_container_add (GTK_CONTAINER (window3), vbox2);
label1 = gtk_label_new ("Three panes nested inside each other");
gtk_box_pack_start (GTK_BOX (vbox2), label1, FALSE, FALSE, 0);
- hpaned3 = gtk_hpaned_new ();
+ hpaned3 = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL);
gtk_box_pack_start (GTK_BOX (vbox2), hpaned3, TRUE, TRUE, 0);
frame9 = gtk_frame_new (NULL);
button14 = gtk_button_new_with_label ("button14");
gtk_container_add (GTK_CONTAINER (frame9), button14);
- hpaned4 = gtk_hpaned_new ();
+ hpaned4 = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL);
gtk_paned_pack2 (GTK_PANED (hpaned3), hpaned4, TRUE, TRUE);
frame10 = gtk_frame_new (NULL);
button15 = gtk_button_new_with_label ("button15");
gtk_container_add (GTK_CONTAINER (frame10), button15);
- hpaned5 = gtk_hpaned_new ();
+ hpaned5 = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL);
gtk_paned_pack2 (GTK_PANED (hpaned4), hpaned5, TRUE, TRUE);
frame11 = gtk_frame_new (NULL);
gtk_window_set_screen (GTK_WINDOW (window4),
gtk_widget_get_screen (widget));
- vbox3 = gtk_vbox_new (FALSE, 0);
+ vbox3 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_container_add (GTK_CONTAINER (window4), vbox3);
label2 = gtk_label_new ("Widget tree:\n\nhpaned \n - vpaned\n - hbox\n - vpaned\n - vpaned\n - vpaned\n");
gtk_box_pack_start (GTK_BOX (vbox3), label2, FALSE, FALSE, 0);
gtk_label_set_justify (GTK_LABEL (label2), GTK_JUSTIFY_LEFT);
- hpaned6 = gtk_hpaned_new ();
+ hpaned6 = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL);
gtk_box_pack_start (GTK_BOX (vbox3), hpaned6, TRUE, TRUE, 0);
- vpaned3 = gtk_vpaned_new ();
+ vpaned3 = gtk_paned_new (GTK_ORIENTATION_VERTICAL);
gtk_paned_pack1 (GTK_PANED (hpaned6), vpaned3, FALSE, TRUE);
button19 = gtk_button_new_with_label ("button19");
button18 = gtk_button_new_with_label ("button18");
gtk_paned_pack2 (GTK_PANED (vpaned3), button18, TRUE, TRUE);
- hbox3 = gtk_hbox_new (FALSE, 0);
+ hbox3 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_paned_pack2 (GTK_PANED (hpaned6), hbox3, TRUE, TRUE);
- vpaned4 = gtk_vpaned_new ();
+ vpaned4 = gtk_paned_new (GTK_ORIENTATION_VERTICAL);
gtk_box_pack_start (GTK_BOX (hbox3), vpaned4, TRUE, TRUE, 0);
button21 = gtk_button_new_with_label ("button21");
button20 = gtk_button_new_with_label ("button20");
gtk_paned_pack2 (GTK_PANED (vpaned4), button20, TRUE, TRUE);
- vpaned5 = gtk_vpaned_new ();
+ vpaned5 = gtk_paned_new (GTK_ORIENTATION_VERTICAL);
gtk_box_pack_start (GTK_BOX (hbox3), vpaned5, TRUE, TRUE, 0);
button23 = gtk_button_new_with_label ("button23");
button22 = gtk_button_new_with_label ("button22");
gtk_paned_pack2 (GTK_PANED (vpaned5), button22, TRUE, TRUE);
- vpaned6 = gtk_vpaned_new ();
+ vpaned6 = gtk_paned_new (GTK_ORIENTATION_VERTICAL);
gtk_box_pack_start (GTK_BOX (hbox3), vpaned6, TRUE, TRUE, 0);
button25 = gtk_button_new_with_label ("button25");
p->y = (int) event->y;
gtk_grab_add (widget);
- gdk_pointer_grab (widget->window, TRUE,
+ gdk_pointer_grab (gtk_widget_get_window (widget), TRUE,
GDK_BUTTON_RELEASE_MASK |
GDK_BUTTON_MOTION_MASK |
GDK_POINTER_MOTION_HINT_MASK,
gint window_type)
{
GtkWidget *window;
- GtkWidget *pixmap;
+ GtkWidget *image;
GtkWidget *fixed;
CursorOffset* icon_pos;
- GdkBitmap *gdk_pixmap_mask;
- GdkPixmap *gdk_pixmap;
- GtkStyle *style;
-
- style = gtk_widget_get_default_style ();
+ cairo_surface_t *mask;
+ cairo_region_t *mask_region;
+ GdkPixbuf *pixbuf;
+ cairo_t *cr;
/*
* GDK_WINDOW_TOPLEVEL works also, giving you a title border
GDK_BUTTON_PRESS_MASK);
gtk_widget_realize (window);
- gdk_pixmap = gdk_pixmap_create_from_xpm (window->window, &gdk_pixmap_mask,
- &style->bg[GTK_STATE_NORMAL],
- xpm_file);
- pixmap = gtk_image_new_from_pixmap (gdk_pixmap, gdk_pixmap_mask);
- gtk_fixed_put (GTK_FIXED (fixed), pixmap, px,py);
- gtk_widget_show (pixmap);
+ pixbuf = gdk_pixbuf_new_from_file (xpm_file, NULL);
+ g_assert (pixbuf); /* FIXME: error handling */
+
+ mask = cairo_image_surface_create (CAIRO_FORMAT_A1,
+ gdk_pixbuf_get_width (pixbuf),
+ gdk_pixbuf_get_height (pixbuf));
+ cr = cairo_create (mask);
+ gdk_cairo_set_source_pixbuf (cr, pixbuf, 0, 0);
+ cairo_paint (cr);
+ cairo_destroy (cr);
+
+ mask_region = gdk_cairo_region_create_from_surface (mask);
+
+ cairo_region_translate (mask_region, px, py);
+
+ image = gtk_image_new_from_pixbuf (pixbuf);
+ gtk_fixed_put (GTK_FIXED (fixed), image, px,py);
+ gtk_widget_show (image);
- gtk_widget_shape_combine_mask (window, gdk_pixmap_mask, px, py);
+ gtk_widget_shape_combine_region (window, mask_region);
- g_object_unref (gdk_pixmap_mask);
- g_object_unref (gdk_pixmap);
+ cairo_region_destroy (mask_region);
+ cairo_surface_destroy (mask);
+ g_object_unref (pixbuf);
g_signal_connect (window, "button_press_event",
G_CALLBACK (shape_pressed), NULL);
x += 20;
}
- gdk_window_shape_combine_region (with_region->window,
+ gdk_window_shape_combine_region (gtk_widget_get_window (with_region),
region,
0, 0);
}
GtkWidget *button;
GtkWidget *box1;
GtkWidget *box2;
-
- GdkBitmap *circles;
+ GdkWindow *gdk_window;
+ GdkPixbuf *pixbuf;
+ GList *list;
if (!window)
{
gtk_container_set_border_width (GTK_CONTAINER (window), 0);
gtk_widget_realize (window);
+
+ gdk_window = gtk_widget_get_window (window);
+
+ pixbuf = gdk_pixbuf_new_from_xpm_data ((const char **) openfile);
+ list = g_list_prepend (NULL, pixbuf);
+
+ gdk_window_set_icon_list (gdk_window, list);
- circles = gdk_bitmap_create_from_data (window->window,
- (gchar *) circles_bits,
- circles_width,
- circles_height);
- gdk_window_set_icon (window->window, NULL,
- circles, circles);
-
- gdk_window_set_icon_name (window->window, "WMHints Test Icon");
+ g_list_free (list);
+ g_object_unref (pixbuf);
+
+ gdk_window_set_icon_name (gdk_window, "WMHints Test Icon");
- gdk_window_set_decorations (window->window, GDK_DECOR_ALL | GDK_DECOR_MENU);
- gdk_window_set_functions (window->window, GDK_FUNC_ALL | GDK_FUNC_RESIZE);
+ gdk_window_set_decorations (gdk_window, GDK_DECOR_ALL | GDK_DECOR_MENU);
+ gdk_window_set_functions (gdk_window, GDK_FUNC_ALL | GDK_FUNC_RESIZE);
- box1 = gtk_vbox_new (FALSE, 0);
+ box1 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_container_add (GTK_CONTAINER (window), box1);
gtk_widget_show (box1);
gtk_widget_show (label);
- separator = gtk_hseparator_new ();
+ separator = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
gtk_widget_show (separator);
- box2 = gtk_vbox_new (FALSE, 10);
+ box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10);
gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
gtk_widget_show (box2);
GtkWidget *label = data;
gchar *msg;
- msg = g_strconcat (GTK_WINDOW (widget)->title, ": ",
+ msg = g_strconcat (gtk_window_get_title (GTK_WINDOW (widget)), ": ",
(event->new_window_state & GDK_WINDOW_STATE_WITHDRAWN) ?
"withdrawn" : "not withdrawn", ", ",
(event->new_window_state & GDK_WINDOW_STATE_ICONIFIED) ?
GtkWidget *hbox;
GtkWidget *button;
- hbox = gtk_hbox_new (FALSE, 5);
+ hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 5);
g_signal_connect_object (hbox,
"destroy",
GtkWidget *button_above;
GtkWidget *button_below;
- vbox = gtk_vbox_new (FALSE, 0);
+ vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
button = gtk_button_new_with_label ("Stick");
g_signal_connect_object (button,
gtk_window_set_title (GTK_WINDOW (window), "Window states");
- box1 = gtk_vbox_new (FALSE, 0);
+ box1 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_container_add (GTK_CONTAINER (window), box1);
iconified = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gpointer data)
{
g_object_set (g_object_get_data (data, "target"),
- "resizable", GTK_TOGGLE_BUTTON (widget)->active,
+ "resizable", gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget)),
NULL);
}
gtk_window_set_screen (GTK_WINDOW (window),
gtk_widget_get_screen (destroy_with));
- vbox = gtk_vbox_new (FALSE, 0);
+ vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_widget_show (vbox);
gtk_container_add (GTK_CONTAINER (window), vbox);
window,
G_CONNECT_SWAPPED);
- vbox = gtk_vbox_new (FALSE, 5);
+ vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
gtk_container_add (GTK_CONTAINER (control_window), vbox);
G_CALLBACK (configure_event_callback),
label);
- adj = (GtkAdjustment *) gtk_adjustment_new (10.0, -2000.0, 2000.0, 1.0,
- 5.0, 0.0);
+ adj = gtk_adjustment_new (10.0, -2000.0, 2000.0, 1.0, 5.0, 0.0);
spin = gtk_spin_button_new (adj, 0, 0);
gtk_box_pack_start (GTK_BOX (vbox), spin, FALSE, FALSE, 0);
g_object_set_data (G_OBJECT (control_window), "spin1", spin);
- adj = (GtkAdjustment *) gtk_adjustment_new (10.0, -2000.0, 2000.0, 1.0,
- 5.0, 0.0);
+ adj = gtk_adjustment_new (10.0, -2000.0, 2000.0, 1.0, 5.0, 0.0);
spin = gtk_spin_button_new (adj, 0, 0);
gtk_box_pack_start (GTK_BOX (vbox), spin, FALSE, FALSE, 0);
window,
G_CONNECT_SWAPPED);
gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
-
- om = gtk_combo_box_new_text ();
+
+ om = gtk_combo_box_text_new ();
i = 0;
while (i < 10)
{
};
g_assert (names[i]);
- gtk_combo_box_append_text (GTK_COMBO_BOX (om), names[i]);
+ gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (om), names[i]);
++i;
}
gtk_box_pack_end (GTK_BOX (vbox), om, FALSE, FALSE, 0);
- om = gtk_combo_box_new_text ();
+ om = gtk_combo_box_text_new ();
i = 0;
while (i < 5)
{
};
g_assert (names[i]);
- gtk_combo_box_append_text (GTK_COMBO_BOX (om), names[i]);
+ gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (om), names[i]);
++i;
}
i = gtk_combo_box_get_active (GTK_COMBO_BOX (widget));
- gtk_progress_bar_set_orientation (GTK_PROGRESS_BAR (pdata->pbar),
- (GtkProgressBarOrientation) i);
+ if (i == 0 || i == 1)
+ gtk_orientable_set_orientation (GTK_ORIENTABLE (pdata->pbar), GTK_ORIENTATION_HORIZONTAL);
+ else
+ gtk_orientable_set_orientation (GTK_ORIENTABLE (pdata->pbar), GTK_ORIENTATION_VERTICAL);
+
+ if (i == 1 || i == 2)
+ gtk_progress_bar_set_inverted (GTK_PROGRESS_BAR (pdata->pbar), TRUE);
+ else
+ gtk_progress_bar_set_inverted (GTK_PROGRESS_BAR (pdata->pbar), FALSE);
}
static void
gtk_window_set_title (GTK_WINDOW (pdata->window), "GtkProgressBar");
gtk_container_set_border_width (GTK_CONTAINER (pdata->window), 0);
- vbox = gtk_vbox_new (FALSE, 5);
+ vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 10);
gtk_box_pack_start (GTK_BOX (content_area), vbox, FALSE, TRUE, 0);
frame = gtk_frame_new ("Progress");
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, TRUE, 0);
- vbox2 = gtk_vbox_new (FALSE, 5);
+ vbox2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
gtk_container_add (GTK_CONTAINER (frame), vbox2);
align = gtk_alignment_new (0.5, 0.5, 0, 0);
align = gtk_alignment_new (0.5, 0.5, 0, 0);
gtk_box_pack_start (GTK_BOX (vbox2), align, FALSE, FALSE, 5);
- hbox = gtk_hbox_new (FALSE, 5);
+ hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 5);
gtk_container_add (GTK_CONTAINER (align), hbox);
label = gtk_label_new ("Label updated by user :");
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
frame = gtk_frame_new ("Options");
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, TRUE, 0);
- vbox2 = gtk_vbox_new (FALSE, 5);
+ vbox2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
gtk_container_add (GTK_CONTAINER (frame), vbox2);
tab = gtk_table_new (7, 2, FALSE);
pdata->omenu1 = build_option_menu (items1, 4, 0,
progressbar_toggle_orientation,
pdata);
- hbox = gtk_hbox_new (FALSE, 0);
+ hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_table_attach (GTK_TABLE (tab), hbox, 1, 2, 0, 1,
GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
5, 5);
GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
5, 5);
- hbox = gtk_hbox_new (FALSE, 0);
+ hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_table_attach (GTK_TABLE (tab), hbox, 1, 2, 1, 2,
GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
5, 5);
2, // PANGO_ELLIPSIZE_MIDDLE
progressbar_toggle_ellipsize,
pdata);
- hbox = gtk_hbox_new (FALSE, 0);
+ hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_table_attach (GTK_TABLE (tab), hbox, 1, 2, 10, 11,
GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
5, 5);
gint x_offset = 0;
gint y_offset = 0;
- new_allocation = widget->allocation;
+ gtk_widget_get_allocation (widget, &new_allocation);
if (data->found || !gtk_widget_get_mapped (widget))
return;
new_allocation.x = 0;
new_allocation.y = 0;
}
-
- if (widget->parent && !data->first)
+
+ if (gtk_widget_get_parent (widget) && !data->first)
{
- GdkWindow *window = widget->window;
- while (window != widget->parent->window)
+ GdkWindow *window = gtk_widget_get_window (widget);
+ while (window != gtk_widget_get_window (gtk_widget_get_parent (widget)))
{
gint tx, ty, twidth, theight;
- gdk_drawable_get_size (window, &twidth, &theight);
+
+ twidth = gdk_window_get_width (window);
+ theight = gdk_window_get_height (window);
if (new_allocation.x < 0)
{
x_offset += tx;
new_allocation.y += ty;
y_offset += ty;
-
+
window = gdk_window_get_parent (window);
}
}
if (widget)
{
- gdk_window_get_pointer (widget->window,
+ gdk_window_get_pointer (gtk_widget_get_window (widget),
&x, &y, NULL);
data.x = x;
GtkWidget **window;
GdkCursor *cursor;
gboolean in_query;
- gint handler;
+ gulong handler;
};
static void
query_properties (GtkButton *button,
struct PropertiesData *data)
{
+ GtkWidget *widget = GTK_WIDGET (button);
gint failure;
g_signal_connect (button, "event",
if (!data->cursor)
- data->cursor = gdk_cursor_new_for_display (gtk_widget_get_display (GTK_WIDGET (button)),
+ data->cursor = gdk_cursor_new_for_display (gtk_widget_get_display (widget),
GDK_TARGET);
-
- failure = gdk_pointer_grab (GTK_WIDGET (button)->window,
+
+ failure = gdk_pointer_grab (gtk_widget_get_window (widget),
TRUE,
GDK_BUTTON_RELEASE_MASK,
NULL,
data->cursor,
GDK_CURRENT_TIME);
- gtk_grab_add (GTK_WIDGET (button));
+ gtk_grab_add (widget);
data->in_query = TRUE;
}
gtk_window_set_title (GTK_WINDOW (window), "test properties");
gtk_container_set_border_width (GTK_CONTAINER (window), 10);
- vbox = gtk_vbox_new (FALSE, 1);
+ vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 1);
gtk_container_add (GTK_CONTAINER (window), vbox);
label = gtk_label_new ("This is just a dumb test to test properties.\nIf you need a generic module, get GLE.");
res_widget = gtk_widget_get_toplevel (res_widget);
if (res_widget)
{
- GdkPixmap *pixmap;
+ cairo_surface_t *surface;
GtkWidget *window, *image;
+ GdkPixbuf *pixbuf;
+ int width, height;
+ cairo_t *cr;
+
+ width = gtk_widget_get_allocated_width (res_widget);
+ height = gtk_widget_get_allocated_height (res_widget);
+
+ surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, width, height);
+
+ cr = cairo_create (surface);
+ gtk_widget_draw (res_widget, cr);
+ cairo_destroy (cr);
+
+ pixbuf = gdk_pixbuf_get_from_surface (surface,
+ 0, 0,
+ width, height);
+ cairo_surface_destroy (surface);
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);
+ image = gtk_image_new_from_pixbuf (pixbuf);
+ g_object_unref (pixbuf);
+
gtk_container_add (GTK_CONTAINER (window), image);
- g_object_unref (pixmap);
gtk_widget_show_all (window);
}
snapshot_widget (GtkButton *button,
struct SnapshotData *data)
{
+ GtkWidget *widget = GTK_WIDGET (button);
gint failure;
g_signal_connect (button, "event",
G_CALLBACK (snapshot_widget_event), data);
- data->is_toplevel = GTK_WIDGET (button) == data->toplevel_button;
-
+ data->is_toplevel = widget == data->toplevel_button;
+
if (!data->cursor)
- data->cursor = gdk_cursor_new_for_display (gtk_widget_get_display (GTK_WIDGET (button)),
+ data->cursor = gdk_cursor_new_for_display (gtk_widget_get_display (widget),
GDK_TARGET);
-
- failure = gdk_pointer_grab (GTK_WIDGET (button)->window,
+
+ failure = gdk_pointer_grab (gtk_widget_get_window (widget),
TRUE,
GDK_BUTTON_RELEASE_MASK,
NULL,
data->cursor,
GDK_CURRENT_TIME);
- gtk_grab_add (GTK_WIDGET (button));
+ gtk_grab_add (widget);
data->in_query = TRUE;
}
gtk_window_set_title (GTK_WINDOW (window), "test snapshot");
gtk_container_set_border_width (GTK_CONTAINER (window), 10);
- vbox = gtk_vbox_new (FALSE, 1);
+ vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 1);
gtk_container_add (GTK_CONTAINER (window), vbox);
button = gtk_button_new_with_label ("Snapshot widget");
/* Create the list */
- vbox = gtk_vbox_new (FALSE, 5);
+ vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 10);
gtk_box_pack_start (GTK_BOX (content_area), vbox, TRUE, TRUE, 0);
static int scroll_test_pos = 0.0;
static gint
-scroll_test_expose (GtkWidget *widget, GdkEventExpose *event,
- GtkAdjustment *adj)
+scroll_test_draw (GtkWidget *widget,
+ cairo_t *cr,
+ GtkAdjustment *adj)
{
gint i,j;
gint imin, imax, jmin, jmax;
- cairo_t *cr;
+ GdkRectangle clip;
- imin = (event->area.x) / 10;
- imax = (event->area.x + event->area.width + 9) / 10;
-
- jmin = ((int)adj->value + event->area.y) / 10;
- jmax = ((int)adj->value + event->area.y + event->area.height + 9) / 10;
+ gdk_cairo_get_clip_rectangle (cr, &clip);
- gdk_window_clear_area (widget->window,
- event->area.x, event->area.y,
- event->area.width, event->area.height);
+ imin = (clip.x) / 10;
+ imax = (clip.x + clip.width + 9) / 10;
- cr = gdk_cairo_create (widget->window);
+ jmin = ((int)adj->value + clip.y) / 10;
+ jmax = ((int)adj->value + clip.y + clip.height + 9) / 10;
for (i=imin; i<imax; i++)
for (j=jmin; j<jmax; j++)
cairo_fill (cr);
- cairo_destroy (cr);
-
return TRUE;
}
scroll_test_configure (GtkWidget *widget, GdkEventConfigure *event,
GtkAdjustment *adj)
{
- adj->page_increment = 0.9 * widget->allocation.height;
- adj->page_size = widget->allocation.height;
+ GtkAllocation allocation;
+
+ gtk_widget_get_allocation (widget, &allocation);
+ adj->page_increment = 0.9 * allocation.height;
+ adj->page_size = allocation.height;
g_signal_emit_by_name (adj, "changed");
}
static void
scroll_test_adjustment_changed (GtkAdjustment *adj, GtkWidget *widget)
{
- /* gint source_min = (int)adj->value - scroll_test_pos; */
+ GdkWindow *window;
gint dy;
dy = scroll_test_pos - (int)adj->value;
if (!gtk_widget_is_drawable (widget))
return;
- gdk_window_scroll (widget->window, 0, dy);
- gdk_window_process_updates (widget->window, FALSE);
+
+ window = gtk_widget_get_window (widget);
+ gdk_window_scroll (window, 0, dy);
+ gdk_window_process_updates (window, FALSE);
}
gtk_window_set_title (GTK_WINDOW (window), "Scroll Test");
gtk_container_set_border_width (GTK_CONTAINER (window), 0);
- hbox = gtk_hbox_new (FALSE, 0);
+ hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_pack_start (GTK_BOX (content_area), hbox, TRUE, TRUE, 0);
gtk_widget_show (hbox);
gtk_widget_set_events (drawing_area, GDK_EXPOSURE_MASK | GDK_SCROLL_MASK);
- adj = GTK_ADJUSTMENT (gtk_adjustment_new (0.0, 0.0, 1000.0, 1.0, 180.0, 200.0));
+ adj = gtk_adjustment_new (0.0, 0.0, 1000.0, 1.0, 180.0, 200.0);
scroll_test_pos = 0.0;
- scrollbar = gtk_vscrollbar_new (adj);
+ scrollbar = gtk_scrollbar_new (GTK_ORIENTATION_VERTICAL, adj);
gtk_box_pack_start (GTK_BOX (hbox), scrollbar, FALSE, FALSE, 0);
gtk_widget_show (scrollbar);
- g_signal_connect (drawing_area, "expose_event",
- G_CALLBACK (scroll_test_expose), adj);
+ g_signal_connect (drawing_area, "draw",
+ G_CALLBACK (scroll_test_draw), adj);
g_signal_connect (drawing_area, "configure_event",
G_CALLBACK (scroll_test_configure), adj);
g_signal_connect (drawing_area, "scroll_event",
frame = gtk_aspect_frame_new ("Testing RC file prioritization", 0.5, 0.5, 0.0, TRUE);
gtk_box_pack_start (GTK_BOX (content_area), frame, FALSE, FALSE, 0);
- vbox = gtk_vbox_new (FALSE, 0);
+ vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_container_add (GTK_CONTAINER (frame), vbox);
label = gtk_label_new ("This label should be red");
gtk_widget_destroy (window);
}
-gboolean
-layout_expose_handler (GtkWidget *widget, GdkEventExpose *event)
+static gboolean
+layout_draw_handler (GtkWidget *widget, cairo_t *cr)
{
GtkLayout *layout;
GdkWindow *bin_window;
- cairo_t *cr;
-
- gint i,j;
+ GdkRectangle clip;
+ gint i,j,x,y;
gint imin, imax, jmin, jmax;
layout = GTK_LAYOUT (widget);
bin_window = gtk_layout_get_bin_window (layout);
- if (event->window != bin_window)
+ if (!gtk_cairo_should_draw_window (cr, bin_window))
return FALSE;
- imin = (event->area.x) / 10;
- imax = (event->area.x + event->area.width + 9) / 10;
+ gdk_window_get_position (bin_window, &x, &y);
+ cairo_translate (cr, x, y);
- jmin = (event->area.y) / 10;
- jmax = (event->area.y + event->area.height + 9) / 10;
+ gdk_cairo_get_clip_rectangle (cr, &clip);
- cr = gdk_cairo_create (bin_window);
+ imin = (clip.x) / 10;
+ imax = (clip.x + clip.width + 9) / 10;
+
+ jmin = (clip.y) / 10;
+ jmax = (clip.y + clip.height + 9) / 10;
for (i=imin; i<imax; i++)
for (j=jmin; j<jmax; j++)
cairo_fill (cr);
- cairo_destroy (cr);
-
return FALSE;
}
/* We set step sizes here since GtkLayout does not set
* them itself.
*/
- hadjustment = gtk_layout_get_hadjustment (layout);
- vadjustment = gtk_layout_get_vadjustment (layout);
+ hadjustment = gtk_scrollable_get_hadjustment (GTK_SCROLLABLE (layout));
+ vadjustment = gtk_scrollable_get_vadjustment (GTK_SCROLLABLE (layout));
gtk_adjustment_set_step_increment (hadjustment, 10.0);
gtk_adjustment_set_step_increment (vadjustment, 10.0);
- gtk_layout_set_hadjustment (layout, hadjustment);
- gtk_layout_set_vadjustment (layout, vadjustment);
+ gtk_scrollable_set_hadjustment (GTK_SCROLLABLE (layout), hadjustment);
+ gtk_scrollable_set_vadjustment (GTK_SCROLLABLE (layout), vadjustment);
gtk_widget_set_events (layout_widget, GDK_EXPOSURE_MASK);
- g_signal_connect (layout, "expose_event",
- G_CALLBACK (layout_expose_handler), NULL);
+ g_signal_connect (layout, "draw",
+ G_CALLBACK (layout_draw_handler), NULL);
gtk_layout_set_size (layout, 1600, 128000);
gtk_box_pack_start (GTK_BOX (action_area), button, TRUE, TRUE, 0);
gtk_widget_show (button);
- vbox = gtk_vbox_new (FALSE, 5);
+ vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 10);
gtk_box_pack_start (GTK_BOX (content_area), vbox, FALSE, FALSE, 0);
{ "flipping", create_flipping },
{ "focus", create_focus },
{ "font selection", create_font_selection },
- { "gridded geometry", create_gridded_geometry },
{ "handle box", create_handle_box },
{ "image", create_image },
{ "key lookup", create_key_lookup },
{ "notebook", create_notebook },
{ "panes", create_panes },
{ "paned keyboard", create_paned_keyboard_navigation },
- { "pixmap", create_pixmap },
+ { "pixbuf", create_pixbuf },
{ "progress bar", create_progress_bar },
{ "properties", create_properties },
{ "radio buttons", create_radio_buttons },
G_CALLBACK (gtk_false),
NULL);
- box1 = gtk_vbox_new (FALSE, 0);
+ box1 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_container_add (GTK_CONTAINER (window), box1);
if (gtk_micro_version > 0)
sprintf (buffer,
"Gtk+ v%d.%d.%d",
- gtk_major_version,
- gtk_minor_version,
- gtk_micro_version);
+ gtk_get_major_version (),
+ gtk_get_minor_version (),
+ gtk_get_micro_version ());
else
sprintf (buffer,
"Gtk+ v%d.%d",
- gtk_major_version,
- gtk_minor_version);
+ gtk_get_major_version (),
+ gtk_get_minor_version ());
label = gtk_label_new (buffer);
gtk_box_pack_start (GTK_BOX (box1), label, FALSE, FALSE, 0);
GTK_POLICY_AUTOMATIC);
gtk_box_pack_start (GTK_BOX (box1), scrolled_window, TRUE, TRUE, 0);
- box2 = gtk_vbox_new (FALSE, 0);
+ box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (scrolled_window), box2);
gtk_container_set_focus_vadjustment (GTK_CONTAINER (box2),
gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
}
- separator = gtk_hseparator_new ();
+ separator = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
- box2 = gtk_vbox_new (FALSE, 10);
+ box2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10);
gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
projects / ~andy / gtk / blobdiff