`configure' with --without-cairo (in which case you will get no graphing
capability).
- * Cairo (http://cairographics.org/), version 1.5 or later.
+ * Cairo (http://cairographics.org/), version 1.12 or later.
* Pango (http://www.pango.org/), version 1.22 or later.
0.18 and 0.19 have a bug that will prevent library detection,
but other versions should be fine.
- * GTK+ (http://www.gtk.org/), version 2.24.0 or later. However
- it must be Gtk+ 2.something - The Gtk+-3.x series will NOT work!
+ * GTK+ (http://www.gtk.org/), version 3.4.0 or later.
* GtkSourceView (http://projects.gnome.org/gtksourceview/)
- version 2.2 or later.
+ version 3.4.0 or later.
The following packages are optional:
PKG_CHECK_MODULES([GTHREAD], [gthread-2.0], [],
[PSPP_REQUIRED_PREREQ([gthread 2.0 (or use --without-gui)])])
- PKG_CHECK_MODULES([GTK], [gtk+-2.0 >= 2.24], [],
- [PSPP_REQUIRED_PREREQ([gtk+ 2.0 version 2.24 or later (or use --without-gui)])])
+ PKG_CHECK_MODULES([GTK], [gtk+-3.0 >= 3.4.2], [],
+ [PSPP_REQUIRED_PREREQ([gtk+ 3.0 version 3.4.2 or later (or use --without-gui)])])
- PKG_CHECK_MODULES([GTKSOURCEVIEW], [gtksourceview-2.0 >= 2.2], [],
- [PSPP_REQUIRED_PREREQ([gtksourceview 2.0 version 2.2 or later (or use --without-gui)])])
+ PKG_CHECK_MODULES([GTKSOURCEVIEW], [gtksourceview-3.0 >= 3.4.2], [],
+ [PSPP_REQUIRED_PREREQ([gtksourceview 3.0 version 3.4.2 or later (or use --without-gui)])])
AC_ARG_VAR([GLIB_GENMARSHAL])
AC_CHECK_PROGS([GLIB_GENMARSHAL], [glib-genmarshal])
** 10 20 30 40 50 60 70 80
**
** library for GtkXPaned-widget, a 2x2 grid-like variation of GtkPaned of gtk+
- ** Copyright (C) 2012 Free Software Foundation, Inc.
+ ** Copyright (C) 2012, 2013 Free Software Foundation, Inc.
** Copyright (C) 2005-2006 Mirco "MacSlow" Müller <macslow@bangang.de>
**
** This library is free software; you can redistribute it and/or
#include <gtk/gtk.h>
#include <ui/gui/psppire-marshal.h>
#include <gdk/gdkkeysyms.h>
-
+#include <gdk/gdkkeysyms-compat.h>
enum WidgetProperties
{
static void gtk_xpaned_init (GtkXPaned * xpaned);
-static void gtk_xpaned_size_request (GtkWidget * widget,
- GtkRequisition * requisition);
+static void
+gtk_xpaned_get_preferred_width (GtkWidget *widget,
+ gint *minimal_width,
+ gint *natural_width)
+{
+ GtkXPaned *xpaned = GTK_XPANED (widget);
+ gint tl[2], tr[2], bl[2], br[2];
+ gint overhead;
+ gint w[2];
+ int i;
+
+ if (xpaned->top_left_child
+ && gtk_widget_get_visible (xpaned->top_left_child))
+ gtk_widget_get_preferred_width (xpaned->top_left_child, &tl[0], &tl[1]);
+ else
+ tl[0] = tl[1] = 0;
+
+ if (xpaned->top_right_child
+ && gtk_widget_get_visible (xpaned->top_right_child))
+ gtk_widget_get_preferred_width (xpaned->top_right_child, &tr[0], &tr[1]);
+ else
+ tr[0] = tr[1] = 0;
+
+ if (xpaned->bottom_left_child
+ && gtk_widget_get_visible (xpaned->bottom_left_child))
+ gtk_widget_get_preferred_width (xpaned->bottom_left_child, &bl[0], &bl[1]);
+ else
+ bl[0] = bl[1] = 0;
+
+ if (xpaned->bottom_right_child
+ && gtk_widget_get_visible (xpaned->bottom_right_child))
+ gtk_widget_get_preferred_width (xpaned->bottom_right_child,
+ &br[0], &br[1]);
+ else
+ br[0] = br[1] = 0;
+
+ /* add 2 times the set border-width to the GtkXPaneds requisition */
+ overhead = gtk_container_get_border_width (GTK_CONTAINER (xpaned)) * 2;
+
+ /* also add the handle "thickness" to GtkXPaned's width requisition */
+ if (xpaned->top_left_child
+ && gtk_widget_get_visible (xpaned->top_left_child)
+ && xpaned->top_right_child
+ && gtk_widget_get_visible (xpaned->top_right_child)
+ && xpaned->bottom_left_child
+ && gtk_widget_get_visible (xpaned->bottom_left_child)
+ && xpaned->bottom_right_child
+ && gtk_widget_get_visible (xpaned->bottom_right_child))
+ {
+ gint handle_size;
+
+ gtk_widget_style_get (widget, "handle-size", &handle_size, NULL);
+ overhead += handle_size;
+ }
+
+ for (i = 0; i < 2; i++)
+ w[i] = (br[i] ? br[i] : MAX (tl[i] + tr[i], bl[i])) + overhead;
+
+ *minimal_width = w[0];
+ *natural_width = w[1];
+}
+
+static void
+gtk_xpaned_get_preferred_height (GtkWidget *widget,
+ gint *minimal_height,
+ gint *natural_height)
+{
+ GtkXPaned *xpaned = GTK_XPANED (widget);
+ gint tl[2], tr[2], bl[2], br[2];
+ gint overhead;
+ gint h[2];
+ int i;
+
+ if (xpaned->top_left_child
+ && gtk_widget_get_visible (xpaned->top_left_child))
+ gtk_widget_get_preferred_height (xpaned->top_left_child, &tl[0], &tl[1]);
+ else
+ tl[0] = tl[1] = 0;
+
+ if (xpaned->top_right_child
+ && gtk_widget_get_visible (xpaned->top_right_child))
+ gtk_widget_get_preferred_height (xpaned->top_right_child, &tr[0], &tr[1]);
+ else
+ tr[0] = tr[1] = 0;
+
+ if (xpaned->bottom_left_child
+ && gtk_widget_get_visible (xpaned->bottom_left_child))
+ gtk_widget_get_preferred_height (xpaned->bottom_left_child,
+ &bl[0], &bl[1]);
+ else
+ bl[0] = bl[1] = 0;
+
+ if (xpaned->bottom_right_child
+ && gtk_widget_get_visible (xpaned->bottom_right_child))
+ gtk_widget_get_preferred_height (xpaned->bottom_right_child,
+ &br[0], &br[1]);
+ else
+ br[0] = br[1] = 0;
+
+ /* add 2 times the set border-width to the GtkXPaneds requisition */
+ overhead = gtk_container_get_border_width (GTK_CONTAINER (xpaned)) * 2;
+
+ /* also add the handle "thickness" to GtkXPaned's height-requisition */
+ if (xpaned->top_left_child
+ && gtk_widget_get_visible (xpaned->top_left_child)
+ && xpaned->top_right_child
+ && gtk_widget_get_visible (xpaned->top_right_child)
+ && xpaned->bottom_left_child
+ && gtk_widget_get_visible (xpaned->bottom_left_child)
+ && xpaned->bottom_right_child
+ && gtk_widget_get_visible (xpaned->bottom_right_child))
+ {
+ gint handle_size;
+
+ gtk_widget_style_get (widget, "handle-size", &handle_size, NULL);
+ overhead += handle_size;
+ }
+
+ for (i = 0; i < 2; i++)
+ h[i] = (br[i] ? br[i] : bl[i] + MAX (tl[i], tr[i])) + overhead;
+
+ *minimal_height = h[0];
+ *natural_height = h[1];
+}
static void gtk_xpaned_size_allocate (GtkWidget * widget,
GtkAllocation * allocation);
static void gtk_xpaned_unmap (GtkWidget * widget);
-static gboolean gtk_xpaned_expose (GtkWidget * widget,
- GdkEventExpose * event);
+static gboolean gtk_xpaned_draw (GtkWidget * widget,
+ cairo_t *ct);
static gboolean gtk_xpaned_enter (GtkWidget * widget,
GdkEventCrossing * event);
widget_class->unrealize = gtk_xpaned_unrealize;
widget_class->map = gtk_xpaned_map;
widget_class->unmap = gtk_xpaned_unmap;
- widget_class->expose_event = gtk_xpaned_expose;
+ widget_class->draw = gtk_xpaned_draw;
widget_class->focus = gtk_xpaned_focus;
widget_class->enter_notify_event = gtk_xpaned_enter;
widget_class->leave_notify_event = gtk_xpaned_leave;
widget_class->button_press_event = gtk_xpaned_button_press;
widget_class->button_release_event = gtk_xpaned_button_release;
widget_class->motion_notify_event = gtk_xpaned_motion;
- widget_class->size_request = gtk_xpaned_size_request;
+ widget_class->get_preferred_width = gtk_xpaned_get_preferred_width;
+ widget_class->get_preferred_height = gtk_xpaned_get_preferred_height;
+
widget_class->size_allocate = gtk_xpaned_size_allocate;
container_class->add = gtk_xpaned_add;
xpaned->handle_north = NULL;
xpaned->handle_south = NULL;
xpaned->handle_middle = NULL;
- xpaned->xor_gc = NULL;
xpaned->cursor_type_east = GDK_SB_V_DOUBLE_ARROW;
xpaned->cursor_type_west = GDK_SB_V_DOUBLE_ARROW;
xpaned->cursor_type_north = GDK_SB_H_DOUBLE_ARROW;
xpaned->drag_pos.y = -1;
}
-static void
-gtk_xpaned_size_request (GtkWidget * widget, GtkRequisition * requisition)
-{
- GtkXPaned *xpaned = GTK_XPANED (widget);
- GtkRequisition child_requisition;
-
- requisition->width = 0;
- requisition->height = 0;
-
- if (xpaned->top_left_child
- && gtk_widget_get_visible (xpaned->top_left_child))
- {
- gtk_widget_size_request (xpaned->top_left_child, &child_requisition);
-
- requisition->width = child_requisition.width;
- requisition->height = child_requisition.height;
- }
-
- if (xpaned->top_right_child
- && gtk_widget_get_visible (xpaned->top_right_child))
- {
- gtk_widget_size_request (xpaned->top_right_child, &child_requisition);
-
- requisition->width += child_requisition.width;
- requisition->height =
- MAX (requisition->height, child_requisition.height);
- }
-
- if (xpaned->bottom_left_child
- && gtk_widget_get_visible (xpaned->bottom_left_child))
- {
- gtk_widget_size_request (xpaned->bottom_left_child, &child_requisition);
-
- requisition->width = MAX (requisition->width, child_requisition.width);
- requisition->height += child_requisition.height;
- }
-
- if (xpaned->bottom_right_child
- && gtk_widget_get_visible (xpaned->bottom_right_child))
- {
- gtk_widget_size_request (xpaned->bottom_right_child,
- &child_requisition);
-
- requisition->width = child_requisition.width;
- requisition->height = child_requisition.height;
- }
-
- /* add 2 times the set border-width to the GtkXPaneds requisition */
- requisition->width += GTK_CONTAINER (xpaned)->border_width * 2;
- requisition->height += GTK_CONTAINER (xpaned)->border_width * 2;
-
- /* also add the handle "thickness" to GtkXPaneds width- and height-requisitions */
- if (xpaned->top_left_child
- && gtk_widget_get_visible (xpaned->top_left_child)
- && xpaned->top_right_child
- && gtk_widget_get_visible (xpaned->top_right_child)
- && xpaned->bottom_left_child
- && gtk_widget_get_visible (xpaned->bottom_left_child)
- && xpaned->bottom_right_child
- && gtk_widget_get_visible (xpaned->bottom_right_child))
- {
- gint handle_size;
-
- gtk_widget_style_get (widget, "handle-size", &handle_size, NULL);
- requisition->width += handle_size;
- requisition->height += handle_size;
- }
-}
-
void
gtk_xpaned_compute_position (GtkXPaned * xpaned,
const GtkAllocation * allocation,
gtk_xpaned_size_allocate (GtkWidget * widget, GtkAllocation * allocation)
{
GtkXPaned *xpaned = GTK_XPANED (widget);
- gint border_width = GTK_CONTAINER (xpaned)->border_width;
+ gint border_width = gtk_container_get_border_width (GTK_CONTAINER (xpaned));
GtkAllocation top_left_child_allocation;
GtkAllocation top_right_child_allocation;
GtkAllocation bottom_left_child_allocation;
/* determine size of handle(s) */
gtk_widget_style_get (widget, "handle-size", &handle_size, NULL);
- widget->allocation = *allocation;
+ gtk_widget_set_allocation (widget, allocation);
if (xpaned->top_left_child
&& gtk_widget_get_visible (xpaned->top_left_child)
&& gtk_widget_get_visible (xpaned->bottom_right_child))
{
/* what sizes do the children want to be at least at */
- gtk_widget_get_child_requisition (xpaned->top_left_child,
- &top_left_child_requisition);
- gtk_widget_get_child_requisition (xpaned->top_right_child,
- &top_right_child_requisition);
- gtk_widget_get_child_requisition (xpaned->bottom_left_child,
- &bottom_left_child_requisition);
- gtk_widget_get_child_requisition (xpaned->bottom_right_child,
- &bottom_right_child_requisition);
+ gtk_widget_get_preferred_size (xpaned->top_left_child,
+ &top_left_child_requisition, NULL);
+ gtk_widget_get_preferred_size (xpaned->top_right_child,
+ &top_right_child_requisition, NULL);
+ gtk_widget_get_preferred_size (xpaned->bottom_left_child,
+ &bottom_left_child_requisition, NULL);
+ gtk_widget_get_preferred_size (xpaned->bottom_right_child,
+ &bottom_right_child_requisition, NULL);
/* determine the total requisition-sum of all requisitions of borders,
* handles, children etc. */
/* calculate the current positions and sizes of the handles */
xpaned->handle_pos_east.x =
- widget->allocation.x + border_width +
+ allocation->x + border_width +
xpaned->top_left_child_size.width + handle_size;
xpaned->handle_pos_east.y =
- widget->allocation.y + border_width +
+ allocation->y + border_width +
xpaned->top_left_child_size.height;
xpaned->handle_pos_east.width =
- widget->allocation.width - xpaned->top_left_child_size.width -
+ allocation->width - xpaned->top_left_child_size.width -
2 * border_width - handle_size;
xpaned->handle_pos_east.height = handle_size;
- xpaned->handle_pos_west.x = widget->allocation.x + border_width;
+ xpaned->handle_pos_west.x = allocation->x + border_width;
xpaned->handle_pos_west.y = xpaned->handle_pos_east.y;
xpaned->handle_pos_west.width =
- widget->allocation.width - xpaned->handle_pos_east.width -
+ allocation->width - xpaned->handle_pos_east.width -
2 * border_width - handle_size;
xpaned->handle_pos_west.height = handle_size;
xpaned->handle_pos_north.x = xpaned->handle_pos_east.x - handle_size;
- xpaned->handle_pos_north.y = widget->allocation.y + border_width;
+ xpaned->handle_pos_north.y = allocation->y + border_width;
xpaned->handle_pos_north.width = handle_size;
xpaned->handle_pos_north.height =
- xpaned->handle_pos_east.y - widget->allocation.y - border_width;
+ xpaned->handle_pos_east.y - allocation->y - border_width;
xpaned->handle_pos_south.x = xpaned->handle_pos_north.x;
xpaned->handle_pos_south.y = xpaned->handle_pos_east.y + handle_size;
xpaned->handle_pos_south.width = handle_size;
xpaned->handle_pos_south.height =
- widget->allocation.height - xpaned->handle_pos_north.height -
+ allocation->height - xpaned->handle_pos_north.height -
2 * border_width - handle_size;
xpaned->handle_pos_middle.height = handle_size + CENTRUM;
/* set allocation for top-left child */
- top_left_child_allocation.x = widget->allocation.x + border_width;
- top_left_child_allocation.y = widget->allocation.y + border_width;
+ top_left_child_allocation.x = allocation->x + border_width;
+ top_left_child_allocation.y = allocation->y + border_width;
top_left_child_allocation.width = xpaned->handle_pos_west.width;
top_left_child_allocation.height = xpaned->handle_pos_north.height;
/* set allocation for top-right child */
top_right_child_allocation.x =
- widget->allocation.x + border_width + handle_size +
+ allocation->x + border_width + handle_size +
top_left_child_allocation.width;
- top_right_child_allocation.y = widget->allocation.y + border_width;
+ top_right_child_allocation.y = allocation->y + border_width;
top_right_child_allocation.width = xpaned->handle_pos_east.width;
top_right_child_allocation.height = xpaned->handle_pos_north.height;
gtk_widget_set_realized (widget, TRUE);
xpaned = GTK_XPANED (widget);
- widget->window = gtk_widget_get_parent_window (widget);
- g_object_ref (widget->window);
+ gtk_widget_set_window (widget, gtk_widget_get_parent_window (widget));
+ // g_object_ref (widget->window);
attributes_east.window_type = GDK_WINDOW_CHILD;
attributes_west.window_type = GDK_WINDOW_CHILD;
attributes_mask_south = GDK_WA_X | GDK_WA_Y | GDK_WA_CURSOR;
attributes_mask_middle = GDK_WA_X | GDK_WA_Y | GDK_WA_CURSOR;
- xpaned->handle_east = gdk_window_new (widget->window,
+ xpaned->handle_east = gdk_window_new (gtk_widget_get_window (widget),
&attributes_east,
attributes_mask_east);
- xpaned->handle_west = gdk_window_new (widget->window,
+ xpaned->handle_west = gdk_window_new (gtk_widget_get_window (widget),
&attributes_west,
attributes_mask_west);
- xpaned->handle_north = gdk_window_new (widget->window,
+ xpaned->handle_north = gdk_window_new (gtk_widget_get_window (widget),
&attributes_north,
attributes_mask_north);
- xpaned->handle_south = gdk_window_new (widget->window,
+ xpaned->handle_south = gdk_window_new (gtk_widget_get_window (widget),
&attributes_south,
attributes_mask_south);
- xpaned->handle_middle = gdk_window_new (widget->window,
+ xpaned->handle_middle = gdk_window_new (gtk_widget_get_window (widget),
&attributes_middle,
attributes_mask_middle);
gdk_window_set_user_data (xpaned->handle_south, xpaned);
gdk_window_set_user_data (xpaned->handle_middle, xpaned);
- gdk_cursor_unref (attributes_east.cursor);
- gdk_cursor_unref (attributes_west.cursor);
- gdk_cursor_unref (attributes_north.cursor);
- gdk_cursor_unref (attributes_south.cursor);
- gdk_cursor_unref (attributes_middle.cursor);
-
- widget->style = gtk_style_attach (widget->style, widget->window);
+ g_object_unref (attributes_east.cursor);
+ g_object_unref (attributes_west.cursor);
+ g_object_unref (attributes_north.cursor);
+ g_object_unref (attributes_south.cursor);
+ g_object_unref (attributes_middle.cursor);
if (xpaned->top_left_child
&& gtk_widget_get_visible (xpaned->top_left_child)
{
GtkXPaned *xpaned = GTK_XPANED (widget);
- if (xpaned->xor_gc)
- {
- g_object_unref (xpaned->xor_gc);
- xpaned->xor_gc = NULL;
- }
-
if (xpaned->handle_east)
{
gdk_window_set_user_data (xpaned->handle_east, NULL);
}
static gboolean
-gtk_xpaned_expose (GtkWidget * widget, GdkEventExpose * event)
+gtk_xpaned_draw (GtkWidget * widget, cairo_t *cr)
{
GtkXPaned *xpaned = GTK_XPANED (widget);
gint handle_size;
- GdkRectangle horizontalClipArea;
- GdkRectangle verticalClipArea;
/* determine size of handle(s) */
gtk_widget_style_get (widget, "handle-size", &handle_size, NULL);
&& xpaned->bottom_right_child
&& gtk_widget_get_visible (xpaned->bottom_right_child))
{
- GtkStateType state;
+ GtkStyleContext *context;
- if (gtk_widget_is_focus (widget))
- state = GTK_STATE_SELECTED;
- else if (xpaned->handle_prelit)
- state = GTK_STATE_PRELIGHT;
- else
- state = gtk_widget_get_state (widget);
-
- horizontalClipArea.x = xpaned->handle_pos_west.x;
- horizontalClipArea.y = xpaned->handle_pos_west.y;
- horizontalClipArea.width =
- xpaned->handle_pos_west.width + handle_size +
- xpaned->handle_pos_east.width;
- horizontalClipArea.height = handle_size;
-
- verticalClipArea.x = xpaned->handle_pos_north.x;
- verticalClipArea.y = xpaned->handle_pos_north.y;
- verticalClipArea.width = handle_size;
- verticalClipArea.height =
- xpaned->handle_pos_north.height + handle_size +
- xpaned->handle_pos_south.height;
-
- gtk_paint_handle (widget->style,
- widget->window,
- state,
- GTK_SHADOW_NONE,
- &horizontalClipArea,
- widget,
- "paned",
- xpaned->handle_pos_east.x - handle_size - 256 / 2,
- xpaned->handle_pos_west.y + 1,
- 256 + handle_size, handle_size - 2,
- /*xpaned->handle_pos_west.x,
- xpaned->handle_pos_west.y + 1,
- xpaned->handle_pos_west.width + handle_size + xpaned->handle_pos_east.width,
- handle_size - 2, */
- GTK_ORIENTATION_HORIZONTAL);
- gtk_paint_handle (widget->style,
- widget->window,
- state,
- GTK_SHADOW_NONE,
- &verticalClipArea,
- widget,
- "paned",
- xpaned->handle_pos_north.x + 1,
- xpaned->handle_pos_south.y - handle_size - 256 / 2,
- handle_size - 2, 256 + handle_size,
- /*xpaned->handle_pos_north.x + 1,
- xpaned->handle_pos_north.y,
- handle_size - 2,
- xpaned->handle_pos_north.height + handle_size + xpaned->handle_pos_south.height, */
- GTK_ORIENTATION_VERTICAL);
+ context = gtk_widget_get_style_context (widget);
+ gtk_render_handle (context, cr,
+ xpaned->handle_pos_east.x - handle_size - 256 / 2,
+ xpaned->handle_pos_west.y + 1,
+ 256 + handle_size, handle_size - 2);
+
+ gtk_render_handle (context, cr,
+ xpaned->handle_pos_north.x + 1,
+ xpaned->handle_pos_south.y - handle_size - 256 / 2,
+ handle_size - 2, 256 + handle_size);
}
/* Chain up to draw children */
- GTK_WIDGET_CLASS (parent_class)->expose_event (widget, event);
+ GTK_WIDGET_CLASS (parent_class)->draw (widget, cr);
return FALSE;
}
update_drag (GtkXPaned * xpaned)
{
GdkPoint pos;
+ GtkWidget *widget = GTK_WIDGET (xpaned);
gint handle_size;
GtkRequisition size;
+ GtkAllocation allocation;
+
+ gtk_widget_get_allocation (widget, &allocation);
- gtk_widget_get_pointer (GTK_WIDGET (xpaned), &pos.x, &pos.y);
+ gdk_window_get_device_position (gtk_widget_get_window (widget),
+ gdk_device_manager_get_client_pointer (
+ gdk_display_get_device_manager (
+ gtk_widget_get_display (widget))),
+ &pos.x, &pos.y, NULL);
+ if (!gtk_widget_get_has_window (widget))
+ {
+ pos.x -= allocation.x;
+ pos.y -= allocation.y;
+ }
if (xpaned->in_drag_vert)
{
if (is_rtl (xpaned))
{
- gtk_widget_style_get (GTK_WIDGET (xpaned),
- "handle-size", &handle_size, NULL);
+ gtk_widget_style_get (widget, "handle-size", &handle_size, NULL);
- size.height =
- GTK_WIDGET (xpaned)->allocation.height - pos.y - handle_size;
+ size.height = allocation.height - pos.y - handle_size;
}
else
{
size.height = pos.y;
}
- size.height -= GTK_CONTAINER (xpaned)->border_width;
+ size.height -= gtk_container_get_border_width (GTK_CONTAINER (xpaned));
size.height =
CLAMP (size.height, xpaned->min_position.y, xpaned->max_position.y);
if (is_rtl (xpaned))
{
- gtk_widget_style_get (GTK_WIDGET (xpaned),
- "handle-size", &handle_size, NULL);
+ gtk_widget_style_get (widget, "handle-size", &handle_size, NULL);
- size.width =
- GTK_WIDGET (xpaned)->allocation.width - pos.x - handle_size;
+ size.width = allocation.width - pos.x - handle_size;
}
else
{
size.width = pos.x;
}
- size.width -= GTK_CONTAINER (xpaned)->border_width;
+ size.width -= gtk_container_get_border_width (GTK_CONTAINER (xpaned));
size.width =
CLAMP (size.width, xpaned->min_position.x, xpaned->max_position.x);
if (is_rtl (xpaned))
{
- gtk_widget_style_get (GTK_WIDGET (xpaned),
- "handle-size", &handle_size, NULL);
+ gtk_widget_style_get (widget, "handle-size", &handle_size, NULL);
- size.width =
- GTK_WIDGET (xpaned)->allocation.width - pos.x - handle_size;
- size.height =
- GTK_WIDGET (xpaned)->allocation.height - pos.y - handle_size;
+ size.width = allocation.width - pos.x - handle_size;
+ size.height = allocation.height - pos.y - handle_size;
}
else
{
size.height = pos.y;
}
- size.width -= GTK_CONTAINER (xpaned)->border_width;
- size.height -= GTK_CONTAINER (xpaned)->border_width;
+ size.width -= gtk_container_get_border_width (GTK_CONTAINER (xpaned));
+ size.height -= gtk_container_get_border_width (GTK_CONTAINER (xpaned));
size.width =
CLAMP (size.width, xpaned->min_position.x, xpaned->max_position.x);
return retval;
}
+static void
+gtk_xpaned_button_press_grab (GdkWindow *handle, GdkEventButton *event)
+{
+ /* We need a server grab here, not gtk_grab_add(), since
+ * we don't want to pass events on to the widget's children */
+ gdk_device_grab (event->device, handle,
+ GDK_OWNERSHIP_NONE,
+ FALSE,
+ (GDK_POINTER_MOTION_HINT_MASK
+ | GDK_BUTTON1_MOTION_MASK
+ | GDK_BUTTON_RELEASE_MASK
+ | GDK_ENTER_NOTIFY_MASK
+ | GDK_LEAVE_NOTIFY_MASK),
+ NULL, event->time);
+}
+
static gboolean
gtk_xpaned_button_press (GtkWidget * widget, GdkEventButton * event)
{
event->window == xpaned->handle_middle && event->button == 1)
{
xpaned->in_drag_vert_and_horiz = TRUE;
-
- /* We need a server grab here, not gtk_grab_add(), since
- * we don't want to pass events on to the widget's children */
- if (gdk_pointer_grab (xpaned->handle_middle,
- FALSE,
- GDK_POINTER_MOTION_HINT_MASK
- | GDK_BUTTON1_MOTION_MASK
- | GDK_BUTTON_RELEASE_MASK
- | GDK_ENTER_NOTIFY_MASK
- | GDK_LEAVE_NOTIFY_MASK,
- NULL, NULL, event->time) == GDK_GRAB_SUCCESS)
- {
- }
-
+ gtk_xpaned_button_press_grab (xpaned->handle_middle, event);
xpaned->drag_pos.x = event->x;
xpaned->drag_pos.y = event->y;
event->window != xpaned->handle_middle && event->button == 1)
{
xpaned->in_drag_vert = TRUE;
-
- /* We need a server grab here, not gtk_grab_add(), since
- * we don't want to pass events on to the widget's children */
- if (gdk_pointer_grab (xpaned->handle_east,
- FALSE,
- GDK_POINTER_MOTION_HINT_MASK
- | GDK_BUTTON1_MOTION_MASK
- | GDK_BUTTON_RELEASE_MASK
- | GDK_ENTER_NOTIFY_MASK
- | GDK_LEAVE_NOTIFY_MASK,
- NULL, NULL, event->time) == GDK_GRAB_SUCCESS)
- {
- }
-
+ gtk_xpaned_button_press_grab (xpaned->handle_east, event);
xpaned->drag_pos.y = event->y;
return TRUE;
event->window != xpaned->handle_middle && event->button == 1)
{
xpaned->in_drag_vert = TRUE;
-
- /* We need a server grab here, not gtk_grab_add(), since
- * we don't want to pass events on to the widget's children */
- if (gdk_pointer_grab (xpaned->handle_west,
- FALSE,
- GDK_POINTER_MOTION_HINT_MASK
- | GDK_BUTTON1_MOTION_MASK
- | GDK_BUTTON_RELEASE_MASK
- | GDK_ENTER_NOTIFY_MASK
- | GDK_LEAVE_NOTIFY_MASK,
- NULL, NULL, event->time) == GDK_GRAB_SUCCESS)
- {
- }
-
+ gtk_xpaned_button_press_grab (xpaned->handle_west, event);
xpaned->drag_pos.y = event->y;
return TRUE;
event->window != xpaned->handle_middle && event->button == 1)
{
xpaned->in_drag_horiz = TRUE;
-
- /* We need a server grab here, not gtk_grab_add(), since
- * we don't want to pass events on to the widget's children */
- if (gdk_pointer_grab (xpaned->handle_north,
- FALSE,
- GDK_POINTER_MOTION_HINT_MASK
- | GDK_BUTTON1_MOTION_MASK
- | GDK_BUTTON_RELEASE_MASK
- | GDK_ENTER_NOTIFY_MASK
- | GDK_LEAVE_NOTIFY_MASK,
- NULL, NULL, event->time) == GDK_GRAB_SUCCESS)
- {
- }
-
+ gtk_xpaned_button_press_grab (xpaned->handle_north, event);
xpaned->drag_pos.x = event->x;
return TRUE;
event->window != xpaned->handle_middle && event->button == 1)
{
xpaned->in_drag_horiz = TRUE;
-
- /* We need a server grab here, not gtk_grab_add(), since
- * we don't want to pass events on to the widget's children */
- if (gdk_pointer_grab (xpaned->handle_south,
- FALSE,
- GDK_POINTER_MOTION_HINT_MASK
- | GDK_BUTTON1_MOTION_MASK
- | GDK_BUTTON_RELEASE_MASK
- | GDK_ENTER_NOTIFY_MASK
- | GDK_LEAVE_NOTIFY_MASK,
- NULL, NULL, event->time) == GDK_GRAB_SUCCESS)
- {
- }
-
+ gtk_xpaned_button_press_grab (xpaned->handle_south, event);
xpaned->drag_pos.x = event->x;
return TRUE;
xpaned->in_drag_vert = FALSE;
xpaned->drag_pos.y = -1;
xpaned->position_set = TRUE;
- gdk_display_pointer_ungrab (gtk_widget_get_display (widget),
- event->time);
+ gdk_device_ungrab (event->device, event->time);
return TRUE;
}
else if (xpaned->in_drag_horiz && (event->button == 1))
xpaned->in_drag_horiz = FALSE;
xpaned->drag_pos.x = -1;
xpaned->position_set = TRUE;
- gdk_display_pointer_ungrab (gtk_widget_get_display (widget),
- event->time);
+ gdk_device_ungrab (event->device, event->time);
return TRUE;
}
else if (xpaned->in_drag_vert_and_horiz && (event->button == 1))
xpaned->drag_pos.x = -1;
xpaned->drag_pos.y = -1;
xpaned->position_set = TRUE;
- gdk_display_pointer_ungrab (gtk_widget_get_display (widget),
- event->time);
+ gdk_device_ungrab (event->device, event->time);
return TRUE;
}
GdkPoint old_min_position;
GdkPoint old_max_position;
gint handle_size;
- gint border_width = GTK_CONTAINER (xpaned)->border_width;
+ gint border_width = gtk_container_get_border_width (GTK_CONTAINER (xpaned));
g_return_if_fail (GTK_IS_XPANED (xpaned));
toplevel = gtk_widget_get_toplevel (GTK_WIDGET (xpaned));
if (gtk_widget_is_toplevel (toplevel))
- return GTK_WINDOW (toplevel)->focus_widget;
+ return gtk_window_get_focus (GTK_WINDOW (toplevel));
return NULL;
}
/* If there is one or more paned widgets between us and the
* focus widget, we want the topmost of those as last_focus
*/
- for (w = last_focus; w != GTK_WIDGET (xpaned); w = w->parent)
+ for (w = last_focus; w != GTK_WIDGET (xpaned); w = gtk_widget_get_parent (w))
if (GTK_IS_XPANED (w))
last_focus = w;
- if (container->focus_child == xpaned->top_left_child)
+ if (gtk_container_get_focus_child (container) == xpaned->top_left_child)
gtk_xpaned_set_last_top_left_child_focus (xpaned, last_focus);
- else if (container->focus_child == xpaned->top_right_child)
+ else if (gtk_container_get_focus_child (container) == xpaned->top_right_child)
gtk_xpaned_set_last_top_right_child_focus (xpaned, last_focus);
- else if (container->focus_child == xpaned->bottom_left_child)
+ else if (gtk_container_get_focus_child (container) == xpaned->bottom_left_child)
gtk_xpaned_set_last_bottom_left_child_focus (xpaned, last_focus);
- else if (container->focus_child == xpaned->bottom_right_child)
+ else if (gtk_container_get_focus_child (container) == xpaned->bottom_right_child)
gtk_xpaned_set_last_bottom_right_child_focus (xpaned, last_focus);
}
}
gtk_xpaned_set_last_bottom_right_child_focus (xpaned, NULL);
}
- if (GTK_WIDGET (xpaned)->parent)
- ancestor = gtk_widget_get_ancestor (GTK_WIDGET (xpaned)->parent,
+ if (gtk_widget_get_parent (GTK_WIDGET (xpaned)))
+ ancestor = gtk_widget_get_ancestor (gtk_widget_get_parent (GTK_WIDGET (xpaned)),
GTK_TYPE_XPANED);
/* The idea here is that temp_list is a list of widgets we want to cycle
*/
if (direction == GTK_DIR_TAB_FORWARD)
{
- if (container->focus_child == xpaned->top_left_child)
+ if (gtk_container_get_focus_child (container) == xpaned->top_left_child)
{
temp_list =
g_list_append (temp_list, xpaned->last_top_right_child_focus);
temp_list = g_list_append (temp_list, xpaned->top_right_child);
temp_list = g_list_append (temp_list, ancestor);
}
- else if (container->focus_child == xpaned->top_right_child)
+ else if (gtk_container_get_focus_child (container) == xpaned->top_right_child)
{
temp_list = g_list_append (temp_list, ancestor);
temp_list =
g_list_append (temp_list, xpaned->last_bottom_left_child_focus);
temp_list = g_list_append (temp_list, xpaned->bottom_left_child);
}
- else if (container->focus_child == xpaned->bottom_left_child)
+ else if (gtk_container_get_focus_child (container) == xpaned->bottom_left_child)
{
temp_list = g_list_append (temp_list, ancestor);
temp_list =
g_list_append (temp_list, xpaned->last_bottom_right_child_focus);
temp_list = g_list_append (temp_list, xpaned->bottom_right_child);
}
- else if (container->focus_child == xpaned->bottom_right_child)
+ else if (gtk_container_get_focus_child (container) == xpaned->bottom_right_child)
{
temp_list = g_list_append (temp_list, ancestor);
temp_list =
}
else
{
- if (container->focus_child == xpaned->top_left_child)
+ if (gtk_container_get_focus_child (container) == xpaned->top_left_child)
{
temp_list = g_list_append (temp_list, ancestor);
temp_list =
g_list_append (temp_list, xpaned->last_top_right_child_focus);
temp_list = g_list_append (temp_list, xpaned->top_right_child);
}
- else if (container->focus_child == xpaned->top_right_child)
+ else if (gtk_container_get_focus_child (container) == xpaned->top_right_child)
{
temp_list =
g_list_append (temp_list, xpaned->last_bottom_left_child_focus);
temp_list = g_list_append (temp_list, xpaned->bottom_left_child);
temp_list = g_list_append (temp_list, ancestor);
}
- else if (container->focus_child == xpaned->bottom_right_child)
+ else if (gtk_container_get_focus_child (container) == xpaned->bottom_right_child)
{
temp_list =
g_list_append (temp_list, xpaned->last_bottom_left_child_focus);
temp_list = g_list_append (temp_list, xpaned->bottom_left_child);
temp_list = g_list_append (temp_list, ancestor);
}
- else if (container->focus_child == xpaned->top_right_child)
+ else if (gtk_container_get_focus_child (container) == xpaned->top_right_child)
{
temp_list =
g_list_append (temp_list, xpaned->last_bottom_left_child_focus);
GList *result = NULL;
GtkWidget *w;
- for (w = GTK_WIDGET (xpaned); w != NULL; w = w->parent)
+ for (w = GTK_WIDGET (xpaned); w != NULL; w = gtk_widget_get_parent (w))
{
if (GTK_IS_XPANED (w))
topmost = GTK_XPANED (w);
gtk_xpaned_find_neighbours (xpaned, &next, &prev);
- if (container->focus_child == xpaned->top_left_child)
+ if (gtk_container_get_focus_child (container) == xpaned->top_left_child)
{
if (reversed)
{
first = xpaned;
}
}
- else if (container->focus_child == xpaned->top_right_child)
+ else if (gtk_container_get_focus_child (container) == xpaned->top_right_child)
{
if (reversed)
{
if (GTK_IS_WINDOW (toplevel))
gtk_xpaned_set_saved_focus (focus,
- GTK_WINDOW (toplevel)->focus_widget);
+ gtk_window_get_focus (GTK_WINDOW (toplevel)));
gtk_xpaned_set_first_xpaned (focus, first);
focus->original_position.x = gtk_xpaned_get_position_x (focus);
focus->original_position.y = gtk_xpaned_get_position_y (focus);
#ifndef GTK_XPANED_H
#define GTK_XPANED_H
-#include <gtk/gtkcontainer.h>
+#include <gtk/gtk.h>
G_BEGIN_DECLS
#define GTK_TYPE_XPANED (gtk_xpaned_get_type ())
GdkWindow *handle_north;
GdkWindow *handle_south;
GdkWindow *handle_middle;
- GdkGC *xor_gc;
+
GdkCursorType cursor_type_east;
GdkCursorType cursor_type_west;
GdkCursorType cursor_type_north;
static void xr_draw_chart (const struct chart_item *, cairo_t *,
double x, double y, double width, double height);
-/* Draws onto CR at least the region of R that is enclosed in (X,Y)-(X+W,Y+H),
- and possibly some additional parts. */
+/* Draws onto CR */
void
-xr_rendering_draw (struct xr_rendering *r, cairo_t *cr,
- int x, int y, int w, int h)
+xr_rendering_draw_all (struct xr_rendering *r, cairo_t *cr)
{
if (is_table_item (r->item))
{
}
xr->y = r->title_height;
- render_page_draw_region (r->page,
- x * XR_POINT, (y * XR_POINT) - r->title_height,
- w * XR_POINT, h * XR_POINT);
+ render_page_draw (r->page);
}
else
xr_draw_chart (to_chart_item (r->item), cr,
void xr_rendering_apply_options (struct xr_rendering *, struct string_map *o);
void xr_rendering_measure (struct xr_rendering *, int *w, int *h);
-void xr_rendering_draw (struct xr_rendering *, cairo_t *,
- int x, int y, int w, int h);
+void xr_rendering_draw_all (struct xr_rendering *r, cairo_t *cr);
/* Functions for rendering a series of output items to a series of Cairo
contexts, with pagination, possibly including headers.
render_page_draw_cells (page, bb);
}
-/* Returns the greatest value i, 0 <= i < n, such that cp[i] <= x0. */
-static int
-get_clip_min_extent (int x0, const int cp[], int n)
-{
- int low, high, best;
-
- low = 0;
- high = n;
- best = 0;
- while (low < high)
- {
- int middle = low + (high - low) / 2;
-
- if (cp[middle] <= x0)
- {
- best = middle;
- low = middle + 1;
- }
- else
- high = middle;
- }
-
- return best;
-}
-
-/* Returns the least value i, 0 <= i < n, such that cp[i + 1] >= x1. */
-static int
-get_clip_max_extent (int x1, const int cp[], int n)
-{
- int low, high, best;
-
- low = 0;
- high = n;
- best = n;
- while (low < high)
- {
- int middle = low + (high - low) / 2;
-
- if (cp[middle] >= x1)
- best = high = middle;
- else
- low = middle + 1;
- }
-
- return best;
-}
-
-/* Renders the cells of PAGE that intersect (X,Y)-(X+W,Y+H), by calling the
- 'draw_line' and 'draw_cell' functions from the render_params provided to
- render_page_create(). */
-void
-render_page_draw_region (const struct render_page *page,
- int x, int y, int w, int h)
-{
- int bb[TABLE_N_AXES][2];
-
- bb[H][0] = get_clip_min_extent (x, page->cp[H], page->n[H] * 2 + 1);
- bb[H][1] = get_clip_max_extent (x + w, page->cp[H], page->n[H] * 2 + 1);
- bb[V][0] = get_clip_min_extent (y, page->cp[V], page->n[V] * 2 + 1);
- bb[V][1] = get_clip_max_extent (y + h, page->cp[V], page->n[V] * 2 + 1);
-
- render_page_draw_cells (page, bb);
-}
\f
/* Breaking up tables to fit on a page. */
int render_page_get_size (const struct render_page *, enum table_axis);
void render_page_draw (const struct render_page *);
-void render_page_draw_region (const struct render_page *,
- int x, int y, int w, int h);
\f
/* An iterator for breaking render_pages into smaller chunks. */
struct render_break
bin_PROGRAMS += src/ui/gui/psppire
noinst_PROGRAMS += src/ui/gui/spreadsheet-test
-src_ui_gui_psppire_CFLAGS = $(GTK_CFLAGS) $(GTKSOURCEVIEW_CFLAGS) -Wall -DGDK_MULTIHEAD_SAFE=1
-src_ui_gui_spreadsheet_test_CFLAGS = $(GTK_CFLAGS) -Wall -DGDK_MULTIHEAD_SAFE=1
+src_ui_gui_psppire_CFLAGS = $(GTK_CFLAGS) $(GTKSOURCEVIEW_CFLAGS) -Wall -DGDK_MULTIHEAD_SAFE=1
+src_ui_gui_spreadsheet_test_CFLAGS = $(GTK_CFLAGS) -Wall -DGDK_MULTIHEAD_SAFE=1
src_ui_gui_psppire_LDFLAGS = \
#@INCLUDE_NEXT@ @NEXT_GTK_GTK_H@
-#if !GTK_CHECK_VERSION(2,20,0)
-/**
- * gtk_widget_get_realized:
- * @widget: a #GtkWidget
- *
- * Determines whether @widget is realized.
- *
- * Return value: %TRUE if @widget is realized, %FALSE otherwise
- *
- * Since: 2.20
- **/
-static inline gboolean
-gtk_widget_get_realized (GtkWidget *widget)
-{
- g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
- return (GTK_WIDGET_FLAGS (widget) & GTK_REALIZED) != 0;
-}
-
-/**
- * gtk_widget_set_realized:
- * @widget: a #GtkWidget
- * @realized: %TRUE to mark the widget as realized
- *
- * Marks the widget as being realized.
- *
- * This function should only ever be called in a derived widget's
- * "realize" or "unrealize" implementation.
- *
- * Since: 2.20
- */
-static inline void
-gtk_widget_set_realized (GtkWidget *widget,
- gboolean realized)
-{
- g_return_if_fail (GTK_IS_WIDGET (widget));
-
- if (realized)
- GTK_OBJECT_FLAGS (widget) |= GTK_REALIZED;
- else
- GTK_OBJECT_FLAGS (widget) &= ~(GTK_REALIZED);
-}
-
-#endif /* gtk < 2.20 */
-
-#if !GTK_CHECK_VERSION(2,20,0)
-/**
- * gtk_widget_get_mapped:
- * @widget: a #GtkWidget
- *
- * Whether the widget is mapped.
- *
- * Return value: %TRUE if the widget is mapped, %FALSE otherwise.
- *
- * Since: 2.20
- */
-static inline gboolean
-gtk_widget_get_mapped (GtkWidget *widget)
-{
- g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
-
- return (GTK_WIDGET_FLAGS (widget) & GTK_MAPPED) != 0;
-}
-
-/**
- * gtk_widget_set_mapped:
- * @widget: a #GtkWidget
- * @mapped: %TRUE to mark the widget as mapped
- *
- * Marks the widget as being realized.
- *
- * This function should only ever be called in a derived widget's
- * "map" or "unmap" implementation.
- *
- * Since: 2.20
- */
-static inline void
-gtk_widget_set_mapped (GtkWidget *widget,
- gboolean mapped)
-{
- g_return_if_fail (GTK_IS_WIDGET (widget));
-
- if (mapped)
- GTK_OBJECT_FLAGS (widget) |= GTK_MAPPED;
- else
- GTK_OBJECT_FLAGS (widget) &= ~(GTK_MAPPED);
-}
-
-#endif /* gtk < 2.20 */
-
-#if !GTK_CHECK_VERSION(2,18,0)
-/**
- * gtk_widget_get_visible:
- * @widget: a #GtkWidget
- *
- * Determines whether the widget is visible. Note that this doesn't
- * take into account whether the widget's parent is also visible
- * or the widget is obscured in any way.
- *
- * See gtk_widget_set_visible().
- *
- * Return value: %TRUE if the widget is visible
- *
- * Since: 2.18
- **/
-static inline gboolean
-gtk_widget_get_visible (GtkWidget *widget)
-{
- g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
-
- return (GTK_WIDGET_FLAGS (widget) & GTK_VISIBLE) != 0;
-}
-#endif /* gtk < 2.18 */
-
-#if !GTK_CHECK_VERSION(2,18,0)
-/**
- * gtk_widget_is_drawable:
- * @widget: a #GtkWidget
- *
- * Determines whether @widget can be drawn to. A widget can be drawn
- * to if it is mapped and visible.
- *
- * Return value: %TRUE if @widget is drawable, %FALSE otherwise
- *
- * Since: 2.18
- **/
-static inline gboolean
-gtk_widget_is_drawable (GtkWidget *widget)
-{
- g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
-
- return ((GTK_WIDGET_FLAGS (wid) & GTK_VISIBLE) != 0 &&
- (GTK_WIDGET_FLAGS (wid) & GTK_MAPPED) != 0);
-}
-#endif /* gtk < 2.18 */
-
-#if !GTK_CHECK_VERSION(2,18,0)
-/**
- * gtk_widget_has_focus:
- * @widget: a #GtkWidget
- *
- * Determines if the widget has the global input focus. See
- * gtk_widget_is_focus() for the difference between having the global
- * input focus, and only having the focus within a toplevel.
- *
- * Return value: %TRUE if the widget has the global input focus.
- *
- * Since: 2.18
- **/
-static inline gboolean
-gtk_widget_has_focus (GtkWidget *widget)
-{
- g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
+#ifndef G_CONST_RETURN
+#define G_CONST_RETURN const
+#endif
- return GTK_WIDGET_HAS_FOCUS (widget);
-}
-#endif /* gtk < 2.18 */
-#if !GTK_CHECK_VERSION(2,18,0)
-/**
- * gtk_widget_set_can_focus:
- * @widget: a #GtkWidget
- * @can_focus: whether or not @widget can own the input focus.
- *
- * Specifies whether @widget can own the input focus. See
- * gtk_widget_grab_focus() for actually setting the input focus on a
- * widget.
- *
- * Since: 2.18
- **/
-static inline void
-gtk_widget_set_can_focus (GtkWidget *widget,
- gboolean can_focus)
-{
- g_return_if_fail (GTK_IS_WIDGET (widget));
+/* Like GSEAL but only used in PSPP */
+#define PSEAL(X) X
- if (can_focus != GTK_WIDGET_CAN_FOCUS (widget))
- {
- if (can_focus)
- GTK_WIDGET_SET_FLAGS (widget, GTK_CAN_FOCUS);
- else
- GTK_WIDGET_UNSET_FLAGS (widget, GTK_CAN_FOCUS);
+#define gtk_hbox_new(HOMOGENOUS,SPACING) gtk_box_new (GTK_ORIENTATION_HORIZONTAL, SPACING)
+#define gtk_vbox_new(HOMOGENOUS,SPACING) gtk_box_new (GTK_ORIENTATION_VERTICAL, SPACING)
- gtk_widget_queue_resize (widget);
- g_object_notify (G_OBJECT (widget), "can-focus");
- }
-}
-#endif /* gtk < 2.18 */
+#define gtk_vbutton_box_new() gtk_button_box_new (GTK_ORIENTATION_VERTICAL)
+#define gtk_hbutton_box_new() gtk_button_box_new (GTK_ORIENTATION_HORIZONTAL)
-#if !GTK_CHECK_VERSION(2,22,0)
-/**
- * gtk_button_get_event_window:
- * @button: a #GtkButton
- *
- * Returns the button's event window if it is realized, %NULL otherwise.
- * This function should be rarely needed.
- *
- * Return value: (transfer none): @button's event window.
- *
- * Since: 2.22
- */
-static inline GdkWindow*
-gtk_button_get_event_window (GtkButton *button)
-{
- g_return_val_if_fail (GTK_IS_BUTTON (button), NULL);
+#define gtk_vpaned_new() gtk_paned_new (GTK_ORIENTATION_VERTICAL)
+#define gtk_hpaned_new() gtk_paned_new (GTK_ORIENTATION_HORIZONTAL)
- return button->event_window;
-}
-#endif /* gtk < 2.22 */
+#define gdk_cursor_unref(X) g_object_unref (X)
#endif /* PSPP_GTK_GTK_H */
</child>
<child>
<object class="PsppireValueEntry" id="group2-entry">
+ <property name="has-entry">True</property>
<property name="visible">True</property>
<property name="can_focus">True</property>
<property name="events">GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK</property>
</child>
<child>
<object class="PsppireValueEntry" id="group1-entry">
+ <property name="has-entry">True</property>
<property name="visible">True</property>
<property name="can_focus">True</property>
<property name="events">GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK</property>
</child>
<child>
<object class="PsppireValueEntry" id="cut-point-entry">
+ <property name="has-entry">True</property>
<property name="visible">True</property>
<property name="can_focus">True</property>
<property name="events">GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK</property>
return FALSE;
}
+/*
static gboolean
quit_one_loop (gpointer data)
{
gtk_main_quit ();
return FALSE;
}
+*/
struct initialisation_parameters
{
init_p.splash_window = create_splash_window ();
init_p.data_file = optind < argc ? argv[optind] : NULL;
- if ( show_splash )
- gtk_widget_show (init_p.splash_window);
+ // if ( show_splash )
+ // gtk_widget_show (init_p.splash_window);
- g_idle_add (quit_one_loop, 0);
+ // g_idle_add (quit_one_loop, 0);
- gtk_quit_add (0, run_inner_loop, &init_p);
- gtk_main ();
+ // gtk_quit_add (0, run_inner_loop, &init_p);
+ run_inner_loop (&init_p);
+ // gtk_main ();
return 0;
}
gtk_dialog_new_with_buttons ("PSPP",
window,
GTK_DIALOG_MODAL |
- GTK_DIALOG_DESTROY_WITH_PARENT |
- GTK_DIALOG_NO_SEPARATOR,
+ GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_STOCK_OK,
GTK_RESPONSE_ACCEPT,
NULL);
hbox = gtk_hbox_new (FALSE, 10);
- gtk_container_add (GTK_CONTAINER (GTK_DIALOG (dialog)->vbox),
+ gtk_container_add (GTK_CONTAINER (gtk_dialog_get_content_area (GTK_DIALOG (dialog))),
hbox);
gtk_box_pack_start (GTK_BOX (hbox), icon, TRUE, FALSE, 10);
}
+#if GTK3_TRANSITION
if (gtk_assistant_get_page_type (assistant, page)
== GTK_ASSISTANT_PAGE_CONFIRM)
gtk_widget_grab_focus (assistant->apply);
else
gtk_widget_grab_focus (assistant->forward);
+#endif
}
/* Called when the Cancel button in the assistant is clicked. */
#define SEPARATOR_CNT (sizeof separators / sizeof *separators)
static void
-set_quote_list (GtkComboBoxEntry *cb)
+set_quote_list (GtkComboBox *cb)
{
GtkListStore *list = gtk_list_store_new (1, G_TYPE_STRING);
GtkTreeIter iter;
gtk_combo_box_set_model (GTK_COMBO_BOX (cb), GTK_TREE_MODEL (list));
g_object_unref (list);
- gtk_combo_box_entry_set_text_column (cb, 0);
+ gtk_combo_box_set_entry_text_column (cb, 0);
}
/* Initializes IA's separators substructure. */
p->quote_cb = get_widget_assert (builder, "quote-cb");
p->escape_cb = get_widget_assert (builder, "escape");
- set_quote_list (GTK_COMBO_BOX_ENTRY (p->quote_combo));
+ set_quote_list (GTK_COMBO_BOX (p->quote_combo));
p->fields_tree_view = PSPP_SHEET_VIEW (get_widget_assert (builder, "fields"));
g_signal_connect (p->quote_combo, "changed",
G_CALLBACK (on_quote_combo_change), ia);
if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (s->quote_cb)))
{
- gchar *text = gtk_combo_box_get_active_text (
- GTK_COMBO_BOX (s->quote_combo));
+ const gchar *text = gtk_entry_get_text (GTK_ENTRY (gtk_bin_get_child (GTK_BIN (s->quote_combo))));
ds_assign_cstr (&s->quotes, text);
- g_free (text);
}
else
ds_clear (&s->quotes);
/* Grid and tree lines */
PsppSheetViewGridLines grid_lines;
- GdkGC *grid_line_gc[5];
/* Special cells. */
PsppSheetViewSpecialCells special_cells;
guint post_validation_flag : 1;
/* Whether our key press handler is to avoid sending an unhandled binding to the search entry */
+
guint search_entry_avoid_unhandled_binding : 1;
-};
+ /* GtkScrollablePolicy needs to be checked when
+ * driving the scrollable adjustment values */
+ guint hscroll_policy : 1;
+ guint vscroll_policy : 1;
+ };
#ifdef __GNUC__
PsppSheetView *tree_view);
void _pspp_sheet_view_column_cell_render (PsppSheetViewColumn *tree_column,
- GdkWindow *window,
+ cairo_t *cr,
const GdkRectangle *background_area,
const GdkRectangle *cell_area,
- const GdkRectangle *expose_area,
guint flags);
void _pspp_sheet_view_column_get_focus_area (PsppSheetViewColumn *tree_column,
const GdkRectangle *background_area,
gboolean left,
gboolean right);
void _pspp_sheet_view_column_cell_draw_focus (PsppSheetViewColumn *tree_column,
- GdkWindow *window,
+ cairo_t *cr,
const GdkRectangle *background_area,
const GdkRectangle *cell_area,
- const GdkRectangle *expose_area,
guint flags);
void _pspp_sheet_view_column_cell_set_dirty (PsppSheetViewColumn *tree_column);
void _pspp_sheet_view_column_get_neighbor_sizes (PsppSheetViewColumn *column,
/*< private >*/
- PsppSheetView *GSEAL (tree_view);
- PsppSheetSelectionMode GSEAL (type);
+ PsppSheetView *PSEAL (tree_view);
+ PsppSheetSelectionMode PSEAL (type);
};
struct _PsppSheetSelectionClass
static guint tree_column_signals[LAST_SIGNAL] = { 0 };
-G_DEFINE_TYPE_WITH_CODE (PsppSheetViewColumn, pspp_sheet_view_column, GTK_TYPE_OBJECT,
+G_DEFINE_TYPE_WITH_CODE (PsppSheetViewColumn, pspp_sheet_view_column, G_TYPE_OBJECT,
G_IMPLEMENT_INTERFACE (GTK_TYPE_CELL_LAYOUT,
pspp_sheet_view_column_cell_layout_init)
G_IMPLEMENT_INTERFACE (GTK_TYPE_BUILDABLE,
GTK_PARAM_READWRITE));
}
+
+static void _cell_layout_buildable_custom_tag_end (GtkBuildable *buildable,
+ GtkBuilder *builder,
+ GObject *child,
+ const gchar *tagname,
+ gpointer *data);
+
+
+static void _cell_layout_buildable_add_child (GtkBuildable *buildable,
+ GtkBuilder *builder,
+ GObject *child,
+ const gchar *type);
+
+
+static gboolean _cell_layout_buildable_custom_tag_start (GtkBuildable *buildable,
+ GtkBuilder *builder,
+ GObject *child,
+ const gchar *tagname,
+ GMarkupParser *parser,
+ gpointer *data);
+
+
static void
pspp_sheet_view_column_buildable_init (GtkBuildableIface *iface)
{
- iface->add_child = _gtk_cell_layout_buildable_add_child;
- iface->custom_tag_start = _gtk_cell_layout_buildable_custom_tag_start;
- iface->custom_tag_end = _gtk_cell_layout_buildable_custom_tag_end;
+ iface->add_child = _cell_layout_buildable_add_child;
+ iface->custom_tag_start = _cell_layout_buildable_custom_tag_start;
+ iface->custom_tag_end = _cell_layout_buildable_custom_tag_end;
}
static void
if (! tree_column->button)
return;
- hbox = GTK_BIN (tree_column->button)->child;
+ hbox = gtk_bin_get_child (GTK_BIN (tree_column->button));
alignment = tree_column->alignment;
arrow = tree_column->arrow;
- current_child = GTK_BIN (alignment)->child;
+ current_child = gtk_bin_get_child (GTK_BIN (alignment));
/* Set up the actual button */
gtk_alignment_set (GTK_ALIGNMENT (alignment), tree_column->xalign,
((GdkEventButton *)event)->button == 1)
{
column->maybe_reordered = TRUE;
- gdk_window_get_pointer (GTK_BUTTON (widget)->event_window,
+ gdk_window_get_pointer (gtk_button_get_event_window (GTK_BUTTON (widget)),
&column->drag_x,
&column->drag_y,
NULL);
void
_pspp_sheet_view_column_realize_button (PsppSheetViewColumn *column)
{
+ GtkAllocation allocation;
PsppSheetView *tree_view;
GdkWindowAttr attr;
guint attributes_mask;
attr.window_type = GDK_WINDOW_CHILD;
attr.wclass = GDK_INPUT_ONLY;
attr.visual = gtk_widget_get_visual (GTK_WIDGET (tree_view));
- attr.colormap = gtk_widget_get_colormap (GTK_WIDGET (tree_view));
attr.event_mask = gtk_widget_get_events (GTK_WIDGET (tree_view)) |
(GDK_BUTTON_PRESS_MASK |
GDK_BUTTON_RELEASE_MASK |
GDK_POINTER_MOTION_HINT_MASK |
GDK_KEY_PRESS_MASK);
attributes_mask = GDK_WA_CURSOR | GDK_WA_X | GDK_WA_Y;
- attr.cursor = gdk_cursor_new_for_display (gdk_drawable_get_display (tree_view->priv->header_window),
+ attr.cursor = gdk_cursor_new_for_display (gdk_window_get_display (tree_view->priv->header_window),
GDK_SB_H_DOUBLE_ARROW);
attr.y = 0;
attr.width = TREE_VIEW_DRAG_WIDTH;
attr.height = tree_view->priv->header_height;
-
- attr.x = (column->button->allocation.x + (rtl ? 0 : column->button->allocation.width)) - TREE_VIEW_DRAG_WIDTH / 2;
+ gtk_widget_get_allocation (column->button, &allocation);
+ attr.x = (allocation.x + (rtl ? 0 : allocation.width)) - TREE_VIEW_DRAG_WIDTH / 2;
column->window = gdk_window_new (tree_view->priv->header_window,
&attr, attributes_mask);
gdk_window_set_user_data (column->window, tree_view);
GList *list;
for (list = column->cell_list; list; list = list->next)
- if (((PsppSheetViewColumnCellInfo *)list->data)->cell->mode ==
- GTK_CELL_RENDERER_MODE_EDITABLE)
- return TRUE;
+ {
+ GtkCellRendererMode mode;
+ g_object_get (((PsppSheetViewColumnCellInfo *)list->data)->cell, "mode", &mode, NULL);
+ if (mode == GTK_CELL_RENDERER_MODE_EDITABLE)
+ return TRUE;
+ }
return FALSE;
}
{
PsppSheetViewColumnCellInfo *cellinfo = list->data;
- if ((cellinfo->cell->mode == GTK_CELL_RENDERER_MODE_EDITABLE ||
- cellinfo->cell->mode == GTK_CELL_RENDERER_MODE_ACTIVATABLE) &&
- cellinfo->cell->visible)
+ GtkCellRendererMode mode;
+ g_object_get (cellinfo->cell, "mode", &mode, NULL);
+
+ if ((mode == GTK_CELL_RENDERER_MODE_EDITABLE ||
+ mode == GTK_CELL_RENDERER_MODE_ACTIVATABLE) &&
+ gtk_cell_renderer_get_visible (cellinfo->cell))
i++;
}
static gboolean
pspp_sheet_view_column_cell_process_action (PsppSheetViewColumn *tree_column,
- GdkWindow *window,
+ cairo_t *cr,
const GdkRectangle *background_area,
const GdkRectangle *cell_area,
guint flags,
gint action,
- const GdkRectangle *expose_area, /* RENDER */
GdkRectangle *focus_rectangle, /* FOCUS */
GtkCellEditable **editable_widget, /* EVENT */
GdkEvent *event, /* EVENT */
GList *list;
GdkRectangle real_cell_area;
GdkRectangle real_background_area;
- GdkRectangle real_expose_area = *cell_area;
gint depth = 0;
gint expand_cell_count = 0;
gint full_requested_width = 0;
{
PsppSheetViewColumnCellInfo *info = (PsppSheetViewColumnCellInfo *)list->data;
- if (! info->cell->visible)
+ if (! gtk_cell_renderer_get_visible (info->cell))
continue;
if (info->expand == TRUE)
if (info->pack == GTK_PACK_END)
continue;
- if (! info->cell->visible)
+ if (! gtk_cell_renderer_get_visible (info->cell))
continue;
if ((info->has_focus || special_cells == 1) && cursor_row)
if (action == CELL_ACTION_RENDER)
{
gtk_cell_renderer_render (info->cell,
- window,
+ cr,
tree_column->tree_view,
&rtl_background_area,
&rtl_cell_area,
- &real_expose_area,
flags);
}
/* FOCUS */
if (info->pack == GTK_PACK_START)
continue;
- if (! info->cell->visible)
+ if (! gtk_cell_renderer_get_visible (info->cell))
continue;
if ((info->has_focus || special_cells == 1) && cursor_row)
if (action == CELL_ACTION_RENDER)
{
gtk_cell_renderer_render (info->cell,
- window,
+ cr,
tree_column->tree_view,
&rtl_background_area,
&rtl_cell_area,
- &real_expose_area,
flags);
}
/* FOCUS */
* @window: a #GdkDrawable to draw to
* @background_area: entire cell area (including tree expanders and maybe padding on the sides)
* @cell_area: area normally rendered by a cell renderer
- * @expose_area: area that actually needs updating
* @flags: flags that affect rendering
*
* Renders the cell contained by #tree_column. This is used primarily by the
**/
void
_pspp_sheet_view_column_cell_render (PsppSheetViewColumn *tree_column,
- GdkWindow *window,
+ cairo_t *cr,
const GdkRectangle *background_area,
const GdkRectangle *cell_area,
- const GdkRectangle *expose_area,
guint flags)
{
g_return_if_fail (PSPP_IS_SHEET_VIEW_COLUMN (tree_column));
g_return_if_fail (background_area != NULL);
g_return_if_fail (cell_area != NULL);
- g_return_if_fail (expose_area != NULL);
pspp_sheet_view_column_cell_process_action (tree_column,
- window,
+ cr,
background_area,
cell_area,
flags,
CELL_ACTION_RENDER,
- expose_area,
NULL, NULL, NULL, NULL);
}
cell_area,
flags,
CELL_ACTION_EVENT,
- NULL, NULL,
+ NULL,
editable_widget,
event,
path_string);
cell_area,
0,
CELL_ACTION_FOCUS,
- NULL,
focus_area,
NULL, NULL, NULL);
}
void
_pspp_sheet_view_column_cell_draw_focus (PsppSheetViewColumn *tree_column,
- GdkWindow *window,
+ cairo_t *cr,
const GdkRectangle *background_area,
const GdkRectangle *cell_area,
- const GdkRectangle *expose_area,
guint flags)
{
gint focus_line_width;
{
GdkRectangle focus_rectangle;
pspp_sheet_view_column_cell_process_action (tree_column,
- window,
+ cr,
background_area,
cell_area,
flags,
CELL_ACTION_FOCUS,
- expose_area,
&focus_rectangle,
NULL, NULL, NULL);
cell_state = flags & GTK_CELL_RENDERER_SELECTED ? GTK_STATE_SELECTED :
(flags & GTK_CELL_RENDERER_PRELIT ? GTK_STATE_PRELIGHT :
(flags & GTK_CELL_RENDERER_INSENSITIVE ? GTK_STATE_INSENSITIVE : GTK_STATE_NORMAL));
- gtk_paint_focus (tree_column->tree_view->style,
- window,
+
+ gtk_paint_focus (gtk_widget_get_style (GTK_WIDGET (tree_column->tree_view)),
+ cr,
cell_state,
- cell_area,
tree_column->tree_view,
"treeview",
focus_rectangle.x,
{
PsppSheetViewColumnCellInfo *info = (PsppSheetViewColumnCellInfo *) list->data;
- if (info->cell->visible)
+ if (gtk_cell_renderer_get_visible (info->cell))
return TRUE;
}
if (info->cell == cell)
break;
- if (info->cell->visible)
+ if (gtk_cell_renderer_get_visible (info->cell))
l += info->real_width + column->spacing;
}
list = pspp_sheet_view_column_cell_next (column, list);
- if (info->cell->visible)
+ if (gtk_cell_renderer_get_visible (info->cell))
r += info->real_width + column->spacing;
}
break;
}
- if (cellinfo->cell->visible)
+ if (gtk_cell_renderer_get_visible (cellinfo->cell))
current_x += cellinfo->real_width;
}
attributes_text_element,
};
-gboolean
-_gtk_cell_layout_buildable_custom_tag_start (GtkBuildable *buildable,
+static gboolean
+_cell_layout_buildable_custom_tag_start (GtkBuildable *buildable,
GtkBuilder *builder,
GObject *child,
const gchar *tagname,
return FALSE;
}
-void
-_gtk_cell_layout_buildable_custom_tag_end (GtkBuildable *buildable,
+static void
+_cell_layout_buildable_custom_tag_end (GtkBuildable *buildable,
GtkBuilder *builder,
GObject *child,
const gchar *tagname,
g_slice_free (AttributesSubParserData, parser_data);
}
-void
-_gtk_cell_layout_buildable_add_child (GtkBuildable *buildable,
+static void
+_cell_layout_buildable_add_child (GtkBuildable *buildable,
GtkBuilder *builder,
GObject *child,
const gchar *type)
struct _PsppSheetViewColumn
{
- GtkObject parent;
-
- GtkWidget *GSEAL (tree_view);
- GtkWidget *GSEAL (button);
- GtkWidget *GSEAL (child);
- GtkWidget *GSEAL (arrow);
- GtkWidget *GSEAL (alignment);
- GdkWindow *GSEAL (window);
- GtkCellEditable *GSEAL (editable_widget);
- gfloat GSEAL (xalign);
- guint GSEAL (property_changed_signal);
- gint GSEAL (spacing);
- GtkAllocation GSEAL (allocation);
+ GObject parent;
+
+ GtkWidget *PSEAL (tree_view);
+ GtkWidget *PSEAL (button);
+ GtkWidget *PSEAL (child);
+ GtkWidget *PSEAL (arrow);
+ GtkWidget *PSEAL (alignment);
+ GdkWindow *PSEAL (window);
+ GtkCellEditable *PSEAL (editable_widget);
+ gfloat PSEAL (xalign);
+ guint PSEAL (property_changed_signal);
+ gint PSEAL (spacing);
+ GtkAllocation PSEAL (allocation);
/* Sizing fields */
/* see gtk+/doc/tree-column-sizing.txt for more information on them */
- gint GSEAL (requested_width);
- gint GSEAL (button_request);
- gint GSEAL (resized_width);
- gint GSEAL (width);
- gint GSEAL (fixed_width);
- gint GSEAL (min_width);
- gint GSEAL (max_width);
+ gint PSEAL (requested_width);
+ gint PSEAL (button_request);
+ gint PSEAL (resized_width);
+ gint PSEAL (width);
+ gint PSEAL (fixed_width);
+ gint PSEAL (min_width);
+ gint PSEAL (max_width);
/* dragging columns */
- gint GSEAL (drag_x);
- gint GSEAL (drag_y);
+ gint PSEAL (drag_x);
+ gint PSEAL (drag_y);
- gchar *GSEAL (title);
- GList *GSEAL (cell_list);
+ gchar *PSEAL (title);
+ GList *PSEAL (cell_list);
/* Sorting */
- guint GSEAL (sort_clicked_signal);
- guint GSEAL (sort_column_changed_signal);
- gint GSEAL (sort_column_id);
- GtkSortType GSEAL (sort_order);
+ guint PSEAL (sort_clicked_signal);
+ guint PSEAL (sort_column_changed_signal);
+ gint PSEAL (sort_column_id);
+ GtkSortType PSEAL (sort_order);
/* Flags */
- guint GSEAL (visible) : 1;
- guint GSEAL (resizable) : 1;
- guint GSEAL (clickable) : 1;
- guint GSEAL (dirty) : 1;
- guint GSEAL (show_sort_indicator) : 1;
- guint GSEAL (maybe_reordered) : 1;
- guint GSEAL (reorderable) : 1;
- guint GSEAL (use_resized_width) : 1;
- guint GSEAL (expand) : 1;
- guint GSEAL (quick_edit) : 1;
- guint GSEAL (selected) : 1;
- guint GSEAL (selectable) : 1;
- guint GSEAL (row_head) : 1;
- guint GSEAL (tabbable) : 1;
- guint GSEAL (need_button) : 1;
+ guint PSEAL (visible) : 1;
+ guint PSEAL (resizable) : 1;
+ guint PSEAL (clickable) : 1;
+ guint PSEAL (dirty) : 1;
+ guint PSEAL (show_sort_indicator) : 1;
+ guint PSEAL (maybe_reordered) : 1;
+ guint PSEAL (reorderable) : 1;
+ guint PSEAL (use_resized_width) : 1;
+ guint PSEAL (expand) : 1;
+ guint PSEAL (quick_edit) : 1;
+ guint PSEAL (selected) : 1;
+ guint PSEAL (selectable) : 1;
+ guint PSEAL (row_head) : 1;
+ guint PSEAL (tabbable) : 1;
+ guint PSEAL (need_button) : 1;
};
struct _PsppSheetViewColumnClass
{
- GtkObjectClass parent_class;
+ GObjectClass parent_class;
gboolean (*clicked) (PsppSheetViewColumn *tree_column);
gboolean (*button_press_event) (PsppSheetViewColumn *,
#include <gtk/gtk.h>
#include <gdk/gdk.h>
#include <gdk/gdkkeysyms.h>
+#include <gdk/gdkkeysyms-compat.h>
#include <string.h>
#include "ui/gui/psppire-marshal.h"
PROP_MODEL,
PROP_HADJUSTMENT,
PROP_VADJUSTMENT,
+ PROP_HSCROLL_POLICY,
+ PROP_VSCROLL_POLICY,
PROP_HEADERS_VISIBLE,
PROP_HEADERS_CLICKABLE,
PROP_REORDERABLE,
GtkRequisition *requisition);
static void pspp_sheet_view_size_allocate (GtkWidget *widget,
GtkAllocation *allocation);
-static gboolean pspp_sheet_view_expose (GtkWidget *widget,
- GdkEventExpose *event);
+static gboolean pspp_sheet_view_draw (GtkWidget *widget,
+ cairo_t *cr);
static gboolean pspp_sheet_view_key_press (GtkWidget *widget,
GdkEventKey *event);
static gboolean pspp_sheet_view_key_release (GtkWidget *widget,
static void invalidate_empty_focus (PsppSheetView *tree_view);
/* Internal functions */
+static GtkAdjustment *pspp_sheet_view_do_get_hadjustment (PsppSheetView *);
+static GtkAdjustment *pspp_sheet_view_do_get_vadjustment (PsppSheetView *);
+static void pspp_sheet_view_do_set_hadjustment (PsppSheetView *tree_view,
+ GtkAdjustment *adjustment);
+static void pspp_sheet_view_do_set_vadjustment (PsppSheetView *tree_view,
+ GtkAdjustment *adjustment);
static void pspp_sheet_view_add_move_binding (GtkBindingSet *binding_set,
guint keyval,
guint modmask,
static void pspp_sheet_view_search_disable_popdown (GtkEntry *entry,
GtkMenu *menu,
gpointer data);
+#if GTK3_TRANSITION
static void pspp_sheet_view_search_preedit_changed (GtkIMContext *im_context,
PsppSheetView *tree_view);
+#endif
static void pspp_sheet_view_search_activate (GtkEntry *entry,
PsppSheetView *tree_view);
static gboolean pspp_sheet_view_real_search_enable_popdown(gpointer data);
G_DEFINE_TYPE_WITH_CODE (PsppSheetView, pspp_sheet_view, GTK_TYPE_CONTAINER,
G_IMPLEMENT_INTERFACE (GTK_TYPE_BUILDABLE,
- pspp_sheet_view_buildable_init))
+ pspp_sheet_view_buildable_init)
+ G_IMPLEMENT_INTERFACE (GTK_TYPE_SCROLLABLE, NULL))
+
+static void
+pspp_sheet_view_get_preferred_width (GtkWidget *widget,
+ gint *minimal_width,
+ gint *natural_width)
+{
+ GtkRequisition requisition;
+
+ pspp_sheet_view_size_request (widget, &requisition);
+
+ *minimal_width = *natural_width = requisition.width;
+}
+
+static void
+pspp_sheet_view_get_preferred_height (GtkWidget *widget,
+ gint *minimal_height,
+ gint *natural_height)
+{
+ GtkRequisition requisition;
+
+ pspp_sheet_view_size_request (widget, &requisition);
+
+ *minimal_height = *natural_height = requisition.height;
+}
static void
pspp_sheet_view_class_init (PsppSheetViewClass *class)
widget_class->map = pspp_sheet_view_map;
widget_class->realize = pspp_sheet_view_realize;
widget_class->unrealize = pspp_sheet_view_unrealize;
- widget_class->size_request = pspp_sheet_view_size_request;
+ widget_class->get_preferred_width = pspp_sheet_view_get_preferred_width;
+ widget_class->get_preferred_height = pspp_sheet_view_get_preferred_height;
widget_class->size_allocate = pspp_sheet_view_size_allocate;
widget_class->button_press_event = pspp_sheet_view_button_press;
widget_class->button_release_event = pspp_sheet_view_button_release;
widget_class->grab_broken_event = pspp_sheet_view_grab_broken;
/*widget_class->configure_event = pspp_sheet_view_configure;*/
widget_class->motion_notify_event = pspp_sheet_view_motion;
- widget_class->expose_event = pspp_sheet_view_expose;
+ widget_class->draw = pspp_sheet_view_draw;
widget_class->key_press_event = pspp_sheet_view_key_press;
widget_class->key_release_event = pspp_sheet_view_key_release;
widget_class->enter_notify_event = pspp_sheet_view_enter_notify;
GTK_TYPE_TREE_MODEL,
GTK_PARAM_READWRITE));
- g_object_class_install_property (o_class,
- PROP_HADJUSTMENT,
- g_param_spec_object ("hadjustment",
- P_("Horizontal Adjustment"),
- P_("Horizontal Adjustment for the widget"),
- GTK_TYPE_ADJUSTMENT,
- GTK_PARAM_READWRITE));
-
- g_object_class_install_property (o_class,
- PROP_VADJUSTMENT,
- g_param_spec_object ("vadjustment",
- P_("Vertical Adjustment"),
- P_("Vertical Adjustment for the widget"),
- GTK_TYPE_ADJUSTMENT,
- GTK_PARAM_READWRITE));
+ g_object_class_override_property (o_class, PROP_HADJUSTMENT, "hadjustment");
+ g_object_class_override_property (o_class, PROP_VADJUSTMENT, "vadjustment");
+ g_object_class_override_property (o_class, PROP_HSCROLL_POLICY, "hscroll-policy");
+ g_object_class_override_property (o_class, PROP_VSCROLL_POLICY, "vscroll-policy");
g_object_class_install_property (o_class,
PROP_HEADERS_VISIBLE,
GTK_PARAM_READABLE));
/* Signals */
+#if GTK3_TRANSITION
/**
* PsppSheetView::set-scroll-adjustments
* @horizontal: the horizontal #GtkAdjustment
G_TYPE_NONE, 2,
GTK_TYPE_ADJUSTMENT,
GTK_TYPE_ADJUSTMENT);
+#endif
/**
* PsppSheetView::row-activated:
tree_view->priv->button_style = NULL;
tree_view->dispose_has_run = FALSE;
+
+ pspp_sheet_view_do_set_vadjustment (tree_view, NULL);
+ pspp_sheet_view_do_set_hadjustment (tree_view, NULL);
}
\f
pspp_sheet_view_set_model (tree_view, g_value_get_object (value));
break;
case PROP_HADJUSTMENT:
- pspp_sheet_view_set_hadjustment (tree_view, g_value_get_object (value));
+ pspp_sheet_view_do_set_hadjustment (tree_view, g_value_get_object (value));
break;
case PROP_VADJUSTMENT:
- pspp_sheet_view_set_vadjustment (tree_view, g_value_get_object (value));
+ pspp_sheet_view_do_set_vadjustment (tree_view, g_value_get_object (value));
break;
- case PROP_HEADERS_VISIBLE:
+ case PROP_HSCROLL_POLICY:
+ tree_view->priv->hscroll_policy = g_value_get_enum (value);
+ gtk_widget_queue_resize (GTK_WIDGET (tree_view));
+ break;
+ case PROP_VSCROLL_POLICY:
+ tree_view->priv->vscroll_policy = g_value_get_enum (value);
+ gtk_widget_queue_resize (GTK_WIDGET (tree_view));
+ break;
+ case PROP_HEADERS_VISIBLE:
pspp_sheet_view_set_headers_visible (tree_view, g_value_get_boolean (value));
break;
case PROP_HEADERS_CLICKABLE:
case PROP_VADJUSTMENT:
g_value_set_object (value, tree_view->priv->vadjustment);
break;
+ case PROP_HSCROLL_POLICY:
+ g_value_set_enum (value, tree_view->priv->hscroll_policy);
+ break;
+ case PROP_VSCROLL_POLICY:
+ g_value_set_enum (value, tree_view->priv->vscroll_policy);
+ break;
case PROP_HEADERS_VISIBLE:
g_value_set_boolean (value, pspp_sheet_view_get_headers_visible (tree_view));
break;
pspp_sheet_view_map_buttons (tree_view);
- gdk_window_show (widget->window);
+ gdk_window_show (gtk_widget_get_window (widget));
}
static void
pspp_sheet_view_realize (GtkWidget *widget)
{
- gint i;
PsppSheetView *tree_view = PSPP_SHEET_VIEW (widget);
GList *tmp_list;
GdkWindowAttr attributes;
gint attributes_mask;
+ GtkAllocation allocation;
+ GtkAllocation old_allocation;
gtk_widget_set_realized (widget, TRUE);
+ gtk_widget_get_allocation (widget, &allocation);
+ gtk_widget_get_allocation (widget, &old_allocation);
+
/* Make the main, clipping window */
attributes.window_type = GDK_WINDOW_CHILD;
- attributes.x = widget->allocation.x;
- attributes.y = widget->allocation.y;
- attributes.width = widget->allocation.width;
- attributes.height = widget->allocation.height;
+ attributes.x = allocation.x;
+ attributes.y = allocation.y;
+ attributes.width = allocation.width;
+ attributes.height = allocation.height;
attributes.wclass = GDK_INPUT_OUTPUT;
attributes.visual = gtk_widget_get_visual (widget);
- attributes.colormap = gtk_widget_get_colormap (widget);
attributes.event_mask = GDK_VISIBILITY_NOTIFY_MASK;
- attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
+ attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL;
- widget->window = gdk_window_new (gtk_widget_get_parent_window (widget),
- &attributes, attributes_mask);
- gdk_window_set_user_data (widget->window, widget);
+ gtk_widget_set_window (widget,
+ gdk_window_new (gtk_widget_get_parent_window (widget),
+ &attributes, attributes_mask));
+ gdk_window_set_user_data (gtk_widget_get_window (widget), widget);
/* Make the window for the tree */
attributes.x = 0;
attributes.y = TREE_VIEW_HEADER_HEIGHT (tree_view);
- attributes.width = MAX (tree_view->priv->width, widget->allocation.width);
- attributes.height = widget->allocation.height;
+ attributes.width = MAX (tree_view->priv->width, old_allocation.width);
+ attributes.height = old_allocation.height;
attributes.event_mask = (GDK_EXPOSURE_MASK |
GDK_SCROLL_MASK |
GDK_POINTER_MOTION_MASK |
GDK_BUTTON_RELEASE_MASK |
gtk_widget_get_events (widget));
- tree_view->priv->bin_window = gdk_window_new (widget->window,
+ tree_view->priv->bin_window = gdk_window_new (gtk_widget_get_window (widget),
&attributes, attributes_mask);
gdk_window_set_user_data (tree_view->priv->bin_window, widget);
/* Make the column header window */
attributes.x = 0;
attributes.y = 0;
- attributes.width = MAX (tree_view->priv->width, widget->allocation.width);
+ attributes.width = MAX (tree_view->priv->width, old_allocation.width);
attributes.height = tree_view->priv->header_height;
attributes.event_mask = (GDK_EXPOSURE_MASK |
GDK_SCROLL_MASK |
GDK_KEY_RELEASE_MASK |
gtk_widget_get_events (widget));
- tree_view->priv->header_window = gdk_window_new (widget->window,
+ tree_view->priv->header_window = gdk_window_new (gtk_widget_get_window (widget),
&attributes, attributes_mask);
gdk_window_set_user_data (tree_view->priv->header_window, widget);
/* Add them all up. */
- widget->style = gtk_style_attach (widget->style, widget->window);
- gdk_window_set_back_pixmap (widget->window, NULL, FALSE);
- gdk_window_set_background (tree_view->priv->bin_window, &widget->style->base[widget->state]);
- gtk_style_set_background (widget->style, tree_view->priv->header_window, GTK_STATE_NORMAL);
+ gtk_widget_set_style (widget,
+ gtk_style_attach (gtk_widget_get_style (widget), gtk_widget_get_window (widget)));
+ gdk_window_set_background (tree_view->priv->bin_window, >k_widget_get_style (widget)->base[gtk_widget_get_state (widget)]);
+ gtk_style_set_background (gtk_widget_get_style (widget), tree_view->priv->header_window, GTK_STATE_NORMAL);
tmp_list = tree_view->priv->children;
while (tmp_list)
pspp_sheet_view_set_grid_lines (tree_view, tree_view->priv->grid_lines);
install_presize_handler (tree_view);
-
- for (i = 0; i < 5; ++i)
- {
- tree_view->priv->grid_line_gc[i] = gdk_gc_new (widget->window);
- gdk_gc_copy (tree_view->priv->grid_line_gc[i], widget->style->text_aa_gc[i]);
- }
}
static void
pspp_sheet_view_unrealize (GtkWidget *widget)
{
- gint x;
PsppSheetView *tree_view = PSPP_SHEET_VIEW (widget);
PsppSheetViewPrivate *priv = tree_view->priv;
GList *list;
priv->drag_highlight_window = NULL;
}
- for (x = 0 ; x < 5 ; ++x)
- g_object_unref (priv->grid_line_gc[x]);
-
if (tree_view->priv->columns != NULL)
{
list = tree_view->priv->columns;
if (tmpcolumn == column)
{
GdkRectangle invalid_rect;
-
+ GtkAllocation allocation;
+
+ gtk_widget_get_allocation (widget, &allocation);
invalid_rect.x = column_offset;
invalid_rect.y = 0;
invalid_rect.width = column->width;
- invalid_rect.height = widget->allocation.height;
+ invalid_rect.height = allocation.height;
- gdk_window_invalidate_rect (widget->window, &invalid_rect, TRUE);
+ gdk_window_invalidate_rect (gtk_widget_get_window (widget), &invalid_rect, TRUE);
break;
}
PsppSheetView *tree_view;
GList *list, *first_column, *last_column;
PsppSheetViewColumn *column;
+ GtkAllocation col_allocation;
GtkAllocation allocation;
gint width = 0;
gint extra, extra_per_column;
last_column && !(PSPP_SHEET_VIEW_COLUMN (last_column->data)->visible);
last_column = last_column->prev)
;
+
if (last_column == NULL)
return;
first_column = first_column->next)
;
- allocation.y = 0;
- allocation.height = tree_view->priv->header_height;
+ col_allocation.y = 0;
+ col_allocation.height = tree_view->priv->header_height;
rtl = (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL);
number_of_expand_columns++;
}
- extra = MAX (widget->allocation.width - full_requested_width, 0);
+ gtk_widget_get_allocation (widget, &allocation);
+ extra = MAX (allocation.width - full_requested_width, 0);
if (number_of_expand_columns > 0)
extra_per_column = extra/number_of_expand_columns;
else
if (column == tree_view->priv->drag_column)
{
GtkAllocation drag_allocation;
- gdk_drawable_get_size (tree_view->priv->drag_window,
- &(drag_allocation.width),
- &(drag_allocation.height));
+ drag_allocation.width = gdk_window_get_width (tree_view->priv->drag_window);
+ drag_allocation.height = gdk_window_get_height (tree_view->priv->drag_window);
drag_allocation.x = 0;
drag_allocation.y = 0;
pspp_sheet_view_column_size_allocate (tree_view->priv->drag_column,
real_requested_width = pspp_sheet_view_get_real_requested_width_from_column (tree_view, column);
- allocation.x = width;
+ col_allocation.x = width;
column->width = real_requested_width;
if (column->expand)
if (column->width != old_width)
g_object_notify (G_OBJECT (column), "width");
- allocation.width = column->width;
+ col_allocation.width = column->width;
width += column->width;
if (column->width > old_width)
column_changed = TRUE;
- pspp_sheet_view_column_size_allocate (column, &allocation);
+ pspp_sheet_view_column_size_allocate (column, &col_allocation);
- if (span_intersects (allocation.x, allocation.width,
- tree_view->priv->hadjustment->value,
- widget->allocation.width)
+ if (span_intersects (col_allocation.x, col_allocation.width,
+ gtk_adjustment_get_value (tree_view->priv->hadjustment),
+ allocation.width)
&& gtk_widget_get_realized (widget))
pspp_sheet_view_column_set_need_button (column, TRUE);
if (column->window)
gdk_window_move_resize (column->window,
- allocation.x + (rtl ? 0 : allocation.width) - TREE_VIEW_DRAG_WIDTH/2,
- allocation.y,
- TREE_VIEW_DRAG_WIDTH, allocation.height);
+ col_allocation.x + (rtl ? 0 : col_allocation.width) - TREE_VIEW_DRAG_WIDTH/2,
+ col_allocation.y,
+ TREE_VIEW_DRAG_WIDTH, col_allocation.height);
}
/* We change the width here. The user might have been resizing columns,
gtk_widget_queue_draw (GTK_WIDGET (tree_view));
}
-
static void
pspp_sheet_view_size_allocate (GtkWidget *widget,
GtkAllocation *allocation)
PsppSheetView *tree_view = PSPP_SHEET_VIEW (widget);
GList *tmp_list;
gboolean width_changed = FALSE;
- gint old_width = widget->allocation.width;
+ GtkAllocation old_allocation;
+ gtk_widget_get_allocation (widget, &old_allocation);
- if (allocation->width != widget->allocation.width)
+ if (allocation->width != old_allocation.width)
width_changed = TRUE;
- widget->allocation = *allocation;
+
+ gtk_widget_set_allocation (widget, allocation);
tmp_list = tree_view->priv->children;
*/
pspp_sheet_view_size_allocate_columns (widget, &width_changed);
- tree_view->priv->hadjustment->page_size = allocation->width;
- tree_view->priv->hadjustment->page_increment = allocation->width * 0.9;
- tree_view->priv->hadjustment->step_increment = allocation->width * 0.1;
- tree_view->priv->hadjustment->lower = 0;
- tree_view->priv->hadjustment->upper = MAX (tree_view->priv->hadjustment->page_size, tree_view->priv->width);
+ gtk_adjustment_set_page_size (tree_view->priv->hadjustment, allocation->width);
+ gtk_adjustment_set_page_increment (tree_view->priv->hadjustment, allocation->width * 0.9);
+ gtk_adjustment_set_step_increment (tree_view->priv->hadjustment, allocation->width * 0.1);
+ gtk_adjustment_set_lower (tree_view->priv->hadjustment, 0);
+ gtk_adjustment_set_upper (tree_view->priv->hadjustment, MAX (gtk_adjustment_get_page_size (tree_view->priv->hadjustment), tree_view->priv->width));
if (gtk_widget_get_direction(widget) == GTK_TEXT_DIR_RTL)
{
{
if (tree_view->priv->init_hadjust_value)
{
- tree_view->priv->hadjustment->value = MAX (tree_view->priv->width - allocation->width, 0);
+ gtk_adjustment_set_value (tree_view->priv->hadjustment, MAX (tree_view->priv->width - allocation->width, 0));
tree_view->priv->init_hadjust_value = FALSE;
}
- else if (allocation->width != old_width)
+ else if (allocation->width != old_allocation.width)
{
- tree_view->priv->hadjustment->value = CLAMP (tree_view->priv->hadjustment->value - allocation->width + old_width, 0, tree_view->priv->width - allocation->width);
+ gtk_adjustment_set_value (tree_view->priv->hadjustment, CLAMP (gtk_adjustment_get_value (tree_view->priv->hadjustment) - allocation->width + old_allocation.width, 0, tree_view->priv->width - allocation->width));
}
else
- tree_view->priv->hadjustment->value = CLAMP (tree_view->priv->width - (tree_view->priv->prev_width - tree_view->priv->hadjustment->value), 0, tree_view->priv->width - allocation->width);
+ gtk_adjustment_set_value (tree_view->priv->hadjustment, CLAMP (tree_view->priv->width - (tree_view->priv->prev_width - gtk_adjustment_get_value (tree_view->priv->hadjustment)), 0, tree_view->priv->width - allocation->width));
}
else
{
- tree_view->priv->hadjustment->value = 0;
+ gtk_adjustment_set_value (tree_view->priv->hadjustment, 0);
tree_view->priv->init_hadjust_value = TRUE;
}
}
else
- if (tree_view->priv->hadjustment->value + allocation->width > tree_view->priv->width)
- tree_view->priv->hadjustment->value = MAX (tree_view->priv->width - allocation->width, 0);
+ if (gtk_adjustment_get_value (tree_view->priv->hadjustment) + allocation->width > tree_view->priv->width)
+ gtk_adjustment_set_value (tree_view->priv->hadjustment, MAX (tree_view->priv->width - allocation->width, 0));
gtk_adjustment_changed (tree_view->priv->hadjustment);
- tree_view->priv->vadjustment->page_size = allocation->height - TREE_VIEW_HEADER_HEIGHT (tree_view);
- tree_view->priv->vadjustment->step_increment = tree_view->priv->vadjustment->page_size * 0.1;
- tree_view->priv->vadjustment->page_increment = tree_view->priv->vadjustment->page_size * 0.9;
- tree_view->priv->vadjustment->lower = 0;
- tree_view->priv->vadjustment->upper = MAX (tree_view->priv->vadjustment->page_size, tree_view->priv->height);
+ gtk_adjustment_set_page_size (tree_view->priv->vadjustment, allocation->height - TREE_VIEW_HEADER_HEIGHT (tree_view));
+ gtk_adjustment_set_step_increment (tree_view->priv->vadjustment, gtk_adjustment_get_page_size (tree_view->priv->vadjustment) * 0.1);
+ gtk_adjustment_set_page_increment (tree_view->priv->vadjustment, gtk_adjustment_get_page_size (tree_view->priv->vadjustment) * 0.9);
+ gtk_adjustment_set_lower (tree_view->priv->vadjustment, 0);
+ gtk_adjustment_set_upper (tree_view->priv->vadjustment, MAX (gtk_adjustment_get_page_size (tree_view->priv->vadjustment), tree_view->priv->height));
gtk_adjustment_changed (tree_view->priv->vadjustment);
/* now the adjustments and window sizes are in sync, we can sync toprow/dy again */
- if (tree_view->priv->height <= tree_view->priv->vadjustment->page_size)
+ if (tree_view->priv->height <= gtk_adjustment_get_page_size (tree_view->priv->vadjustment))
gtk_adjustment_set_value (GTK_ADJUSTMENT (tree_view->priv->vadjustment), 0);
- else if (tree_view->priv->vadjustment->value + tree_view->priv->vadjustment->page_size > tree_view->priv->height)
+ else if (gtk_adjustment_get_value (tree_view->priv->vadjustment) + gtk_adjustment_get_page_size (tree_view->priv->vadjustment) > tree_view->priv->height)
gtk_adjustment_set_value (GTK_ADJUSTMENT (tree_view->priv->vadjustment),
- tree_view->priv->height - tree_view->priv->vadjustment->page_size);
+ tree_view->priv->height - gtk_adjustment_get_page_size (tree_view->priv->vadjustment));
else if (gtk_tree_row_reference_valid (tree_view->priv->top_row))
pspp_sheet_view_top_row_to_dy (tree_view);
else
if (gtk_widget_get_realized (widget))
{
- gdk_window_move_resize (widget->window,
+ gdk_window_move_resize (gtk_widget_get_window (widget),
allocation->x, allocation->y,
allocation->width, allocation->height);
gdk_window_move_resize (tree_view->priv->header_window,
- - (gint) tree_view->priv->hadjustment->value,
+ - (gint) gtk_adjustment_get_value (tree_view->priv->hadjustment),
0,
MAX (tree_view->priv->width, allocation->width),
tree_view->priv->header_height);
gdk_window_move_resize (tree_view->priv->bin_window,
- - (gint) tree_view->priv->hadjustment->value,
+ - (gint) gtk_adjustment_get_value (tree_view->priv->hadjustment),
TREE_VIEW_HEADER_HEIGHT (tree_view),
MAX (tree_view->priv->width, allocation->width),
allocation->height - TREE_VIEW_HEADER_HEIGHT (tree_view));
return TRUE;
/* select */
- pre_val = tree_view->priv->vadjustment->value;
+ pre_val = gtk_adjustment_get_value (tree_view->priv->vadjustment);
path = _pspp_sheet_view_find_path (tree_view, node);
* correct here
*/
- aft_val = tree_view->priv->vadjustment->value;
+ aft_val = gtk_adjustment_get_value (tree_view->priv->vadjustment);
dval = pre_val - aft_val;
cell_area.y += dval;
PSPP_SHEET_VIEW_UNSET_FLAG (tree_view, PSPP_SHEET_VIEW_IN_COLUMN_RESIZE);
gtk_grab_remove (widget);
- gdk_display_pointer_ungrab (gdk_drawable_get_display (event->window),
+ gdk_display_pointer_ungrab (gdk_window_get_display (event->window),
event->time);
return TRUE;
}
}
}
+
static void
prelight_or_select (PsppSheetView *tree_view,
int node,
static void
pspp_sheet_view_motion_draw_column_motion_arrow (PsppSheetView *tree_view)
{
+#if GTK3_TRANSITION
PsppSheetViewColumnReorder *reorder = tree_view->priv->cur_reorder;
GtkWidget *widget = GTK_WIDGET (tree_view);
GdkBitmap *mask = NULL;
/* Get x, y, width, height of arrow */
width = width/2; /* remember, the arrow only takes half the available width */
- gdk_window_get_origin (widget->window, &x, &y);
+ gdk_window_get_origin (gtk_widget_get_window (widget), &x, &y);
if (arrow_type == DRAG_COLUMN_WINDOW_STATE_ARROW_RIGHT)
x += widget->allocation.width - width;
gdk_window_show (tree_view->priv->drag_highlight_window);
gdk_window_raise (tree_view->priv->drag_highlight_window);
+#endif
}
static gboolean
column = pspp_sheet_view_get_column (tree_view, tree_view->priv->drag_pos);
- if (event->is_hint || event->window != widget->window)
+ if (event->is_hint || event->window != gtk_widget_get_window (widget))
gtk_widget_get_pointer (widget, &x, NULL);
else
x = event->x;
if (tree_view->priv->hadjustment)
- x += tree_view->priv->hadjustment->value;
+ x += gtk_adjustment_get_value (tree_view->priv->hadjustment);
new_width = pspp_sheet_view_new_column_width (tree_view,
tree_view->priv->drag_pos, &x);
return;
}
- value = CLAMP (tree_view->priv->vadjustment->value + offset, 0.0,
- tree_view->priv->vadjustment->upper - tree_view->priv->vadjustment->page_size);
+ value = CLAMP (gtk_adjustment_get_value (tree_view->priv->vadjustment) + offset, 0.0,
+ gtk_adjustment_get_upper (tree_view->priv->vadjustment) - gtk_adjustment_get_page_size (tree_view->priv->vadjustment));
gtk_adjustment_set_value (tree_view->priv->vadjustment, value);
}
}
offset = offset/3;
- value = CLAMP (tree_view->priv->hadjustment->value + offset,
- 0.0, tree_view->priv->hadjustment->upper - tree_view->priv->hadjustment->page_size);
+ value = CLAMP (gtk_adjustment_get_value (tree_view->priv->hadjustment) + offset,
+ 0.0, gtk_adjustment_get_upper (tree_view->priv->hadjustment) - gtk_adjustment_get_page_size (tree_view->priv->hadjustment));
gtk_adjustment_set_value (tree_view->priv->hadjustment, value);
return TRUE;
PsppSheetView *tree_view = (PsppSheetView *) widget;
PsppSheetViewColumn *column = tree_view->priv->drag_column;
gint x, y;
+ GtkAllocation allocation;
/* Sanity Check */
if ((column == NULL) ||
/* Handle moving the header */
gdk_window_get_position (tree_view->priv->drag_window, &x, &y);
+ gtk_widget_get_allocation (GTK_WIDGET (tree_view), &allocation);
x = CLAMP (x + (gint)event->x - column->drag_x, 0,
- MAX (tree_view->priv->width, GTK_WIDGET (tree_view)->allocation.width) - column->allocation.width);
+ MAX (tree_view->priv->width, allocation.width) - column->allocation.width);
gdk_window_move (tree_view->priv->drag_window, x, y);
/* autoscroll, if needed */
tree_view->priv->rubber_band_end_node = end_node;
}
+#define GDK_RECTANGLE_PTR(X) ((GdkRectangle *)(X))
+
static void
pspp_sheet_view_update_rubber_band (PsppSheetView *tree_view)
{
gint x, y;
- GdkRectangle old_area;
- GdkRectangle new_area;
- GdkRectangle common;
- GdkRegion *invalid_region;
+ cairo_rectangle_int_t old_area;
+ cairo_rectangle_int_t new_area;
+ cairo_rectangle_int_t common;
+ cairo_region_t *invalid_region;
PsppSheetViewColumn *column;
old_area.x = MIN (tree_view->priv->press_start_x, tree_view->priv->rubber_band_x);
new_area.width = ABS (x - tree_view->priv->press_start_x) + 1;
new_area.height = ABS (y - tree_view->priv->press_start_y) + 1;
- invalid_region = gdk_region_rectangle (&old_area);
- gdk_region_union_with_rect (invalid_region, &new_area);
+ invalid_region = cairo_region_create_rectangle (&old_area);
+ cairo_region_union_rectangle (invalid_region, &new_area);
- gdk_rectangle_intersect (&old_area, &new_area, &common);
+ gdk_rectangle_intersect (GDK_RECTANGLE_PTR (&old_area),
+ GDK_RECTANGLE_PTR (&new_area), GDK_RECTANGLE_PTR (&common));
if (common.width > 2 && common.height > 2)
{
- GdkRegion *common_region;
+ cairo_region_t *common_region;
/* make sure the border is invalidated */
common.x += 1;
common.width -= 2;
common.height -= 2;
- common_region = gdk_region_rectangle (&common);
+ common_region = cairo_region_create_rectangle (&common);
- gdk_region_subtract (invalid_region, common_region);
- gdk_region_destroy (common_region);
+ cairo_region_subtract (invalid_region, common_region);
+ cairo_region_destroy (common_region);
}
- gdk_window_invalidate_region (tree_view->priv->bin_window, invalid_region, TRUE);
+#if GTK_MAJOR_VERSION == 3
+ gdk_window_invalidate_region (tree_view->priv->bin_window, invalid_region, TRUE);
+#else
+ {
+ cairo_rectangle_int_t extents;
+ GdkRegion *ereg;
+ cairo_region_get_extents (invalid_region, &extents);
+ ereg = gdk_region_rectangle (GDK_RECTANGLE_PTR (&extents));
+ gdk_window_invalidate_region (tree_view->priv->bin_window, ereg, TRUE);
+ gdk_region_destroy (ereg);
+ }
+#endif
- gdk_region_destroy (invalid_region);
+ cairo_region_destroy (invalid_region);
tree_view->priv->rubber_band_x = x;
tree_view->priv->rubber_band_y = y;
pspp_sheet_view_update_rubber_band_selection (tree_view);
}
+#if GTK3_TRANSITION
static void
pspp_sheet_view_paint_rubber_band (PsppSheetView *tree_view,
GdkRectangle *area)
cairo_t *cr;
GdkRectangle rect;
GdkRectangle rubber_rect;
+ GtkStyle *style;
return;
rubber_rect.x = MIN (tree_view->priv->press_start_x, tree_view->priv->rubber_band_x);
cr = gdk_cairo_create (tree_view->priv->bin_window);
cairo_set_line_width (cr, 1.0);
+ style = gtk_widget_get_style (GTK_WIDGET (tree_view));
cairo_set_source_rgba (cr,
- GTK_WIDGET (tree_view)->style->fg[GTK_STATE_NORMAL].red / 65535.,
- GTK_WIDGET (tree_view)->style->fg[GTK_STATE_NORMAL].green / 65535.,
- GTK_WIDGET (tree_view)->style->fg[GTK_STATE_NORMAL].blue / 65535.,
+ style->fg[GTK_STATE_NORMAL].red / 65535.,
+ style->fg[GTK_STATE_NORMAL].green / 65535.,
+ style->fg[GTK_STATE_NORMAL].blue / 65535.,
.25);
gdk_cairo_rectangle (cr, &rect);
cairo_paint (cr);
cairo_set_source_rgb (cr,
- GTK_WIDGET (tree_view)->style->fg[GTK_STATE_NORMAL].red / 65535.,
- GTK_WIDGET (tree_view)->style->fg[GTK_STATE_NORMAL].green / 65535.,
- GTK_WIDGET (tree_view)->style->fg[GTK_STATE_NORMAL].blue / 65535.);
+ style->fg[GTK_STATE_NORMAL].red / 65535.,
+ style->fg[GTK_STATE_NORMAL].green / 65535.,
+ style->fg[GTK_STATE_NORMAL].blue / 65535.);
cairo_rectangle (cr,
rubber_rect.x + 0.5, rubber_rect.y + 0.5,
cairo_destroy (cr);
}
+#endif
+
static gboolean
pspp_sheet_view_motion_bin_window (GtkWidget *widget,
area.x = 0;
area.y = 0;
- gdk_drawable_get_size (tree_view->priv->bin_window, &area.width, &area.height);
+ area.width = gdk_window_get_width (tree_view->priv->bin_window);
+ area.height = gdk_window_get_height (tree_view->priv->bin_window);
gdk_window_invalidate_rect (tree_view->priv->bin_window, &area, FALSE);
}
* is empty.
*/
static void
-draw_empty_focus (PsppSheetView *tree_view, GdkRectangle *clip_area)
+draw_empty_focus (PsppSheetView *tree_view)
{
GtkWidget *widget = GTK_WIDGET (tree_view);
gint w, h;
+ cairo_t *cr = gdk_cairo_create (tree_view->priv->bin_window);
if (!gtk_widget_has_focus (widget))
return;
- gdk_drawable_get_size (tree_view->priv->bin_window, &w, &h);
+ w = gdk_window_get_width (tree_view->priv->bin_window);
+ h = gdk_window_get_height (tree_view->priv->bin_window);
w -= 2;
h -= 2;
if (w > 0 && h > 0)
gtk_paint_focus (gtk_widget_get_style (widget),
- tree_view->priv->bin_window,
+ cr,
gtk_widget_get_state (widget),
- clip_area,
widget,
NULL,
1, 1, w, h);
+ cairo_destroy (cr);
}
static void
-pspp_sheet_view_draw_grid_lines (PsppSheetView *tree_view,
- GdkEventExpose *event,
- gint n_visible_columns,
- gint min_y,
- gint max_y)
+pspp_sheet_view_draw_vertical_grid_lines (PsppSheetView *tree_view,
+ cairo_t *cr,
+ gint n_visible_columns,
+ gint min_y,
+ gint max_y)
{
GList *list = tree_view->priv->columns;
gint i = 0;
gint current_x = 0;
- gint height;
if (tree_view->priv->grid_lines != PSPP_SHEET_VIEW_GRID_LINES_VERTICAL
&& tree_view->priv->grid_lines != PSPP_SHEET_VIEW_GRID_LINES_BOTH)
return;
- gdk_drawable_get_size (event->window, NULL, &height);
-
/* Only draw the lines for visible rows and columns */
for (list = tree_view->priv->columns; list; list = list->next, i++)
{
if (i != n_visible_columns - 1)
x--;
- if (x >= event->area.x && x < event->area.x + event->area.width)
- gdk_draw_line (event->window,
- tree_view->priv->grid_line_gc[GTK_WIDGET(tree_view)->state],
- x, min_y,
- x, max_y - min_y);
+ cairo_set_line_width (cr, 1.0);
+ cairo_set_line_cap (cr, CAIRO_LINE_CAP_SQUARE);
+ cairo_move_to (cr, x + 0.5, min_y);
+ cairo_line_to (cr, x + 0.5, max_y - min_y);
+ cairo_stroke (cr);
}
}
*/
static gboolean
pspp_sheet_view_bin_expose (GtkWidget *widget,
- GdkEventExpose *event)
+ cairo_t *cr)
{
PsppSheetView *tree_view = PSPP_SHEET_VIEW (widget);
GtkTreePath *path;
gboolean draw_vgrid_lines, draw_hgrid_lines;
gint min_y, max_y;
+ GdkRectangle Zarea;
+ GtkAllocation allocation;
+ gtk_widget_get_allocation (widget, &allocation);
+
+ Zarea.x = 0;
+ Zarea.y = 0;
+ Zarea.height = allocation.height;
+
rtl = (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL);
gtk_widget_style_get (widget,
if (tree_view->priv->row_count == 0)
{
- draw_empty_focus (tree_view, &event->area);
+ draw_empty_focus (tree_view);
return TRUE;
}
+#if GTK3_TRANSITION
/* clip event->area to the visible area */
- if (event->area.height < 0)
+ if (Zarea.height < 0.5)
return TRUE;
+#endif
validate_visible_area (tree_view);
- new_y = TREE_WINDOW_Y_TO_RBTREE_Y (tree_view, event->area.y);
+ new_y = TREE_WINDOW_Y_TO_RBTREE_Y (tree_view, Zarea.y);
if (new_y < 0)
new_y = 0;
y_offset = -pspp_sheet_view_find_offset (tree_view, new_y, &node);
- gdk_drawable_get_size (tree_view->priv->bin_window,
- &bin_window_width, &bin_window_height);
+ bin_window_width =
+ gdk_window_get_width (tree_view->priv->bin_window);
+
+ bin_window_height =
+ gdk_window_get_height (tree_view->priv->bin_window);
+
if (tree_view->priv->height < bin_window_height)
{
- gtk_paint_flat_box (widget->style,
- event->window,
- widget->state,
+ gtk_paint_flat_box (gtk_widget_get_style (widget),
+ cr,
+ gtk_widget_get_state (widget),
GTK_SHADOW_NONE,
- &event->area,
widget,
"cell_even",
0, tree_view->priv->height,
cell_offset = 0;
- background_area.y = y_offset + event->area.y;
+ background_area.y = y_offset + Zarea.y;
background_area.height = max_height;
max_y = background_area.y + max_height;
else
selected_column = TRUE;
- if (cell_offset > event->area.x + event->area.width ||
- cell_offset + column->width < event->area.x)
+#if GTK3_TRANSITION
+ if (cell_offset > Zarea.x + Zarea.width ||
+ cell_offset + column->width < Zarea.x)
{
cell_offset += column->width;
continue;
}
+#endif
if (selected && selected_column)
flags |= GTK_CELL_RENDERER_SELECTED;
cell_area.height -= grid_line_width;
}
+#if GTK3_TRANSITION
if (gdk_region_rect_in (event->region, &background_area) == GDK_OVERLAP_RECTANGLE_OUT)
{
cell_offset += column->width;
continue;
}
+#endif
pspp_sheet_view_column_cell_set_cell_data (column,
tree_view->priv->model,
g_assert (detail);
- if (widget->state == GTK_STATE_INSENSITIVE)
+ if (gtk_widget_get_state (widget) == GTK_STATE_INSENSITIVE)
state = GTK_STATE_INSENSITIVE;
else if (flags & GTK_CELL_RENDERER_SELECTED)
state = GTK_STATE_SELECTED;
else
g_snprintf (new_detail, 128, "%s_middle", detail);
- gtk_paint_flat_box (widget->style,
- event->window,
+ gtk_paint_flat_box (gtk_widget_get_style (widget),
+ cr,
state,
GTK_SHADOW_NONE,
- &event->area,
widget,
new_detail,
background_area.x,
}
else
{
- gtk_paint_flat_box (widget->style,
- event->window,
+ gtk_paint_flat_box (gtk_widget_get_style (widget),
+ cr,
state,
GTK_SHADOW_NONE,
- &event->area,
widget,
detail,
background_area.x,
if (draw_hgrid_lines)
{
- if (background_area.y > 0)
- gdk_draw_line (event->window,
- tree_view->priv->grid_line_gc[widget->state],
- background_area.x, background_area.y,
- background_area.x + background_area.width,
- background_area.y);
-
- if (y_offset + max_height <= event->area.height)
- gdk_draw_line (event->window,
- tree_view->priv->grid_line_gc[widget->state],
- background_area.x, background_area.y + max_height,
- background_area.x + background_area.width,
- background_area.y + max_height);
+ cairo_set_line_width (cr, 1.0);
+ cairo_set_line_cap (cr, CAIRO_LINE_CAP_SQUARE);
+
+ if (background_area.y >= 0)
+ {
+#if GTK3_TRANSITION
+ gdk_draw_line (event->window,
+ tree_view->priv->grid_line_gc[widget->state],
+ background_area.x, background_area.y,
+ background_area.x + background_area.width,
+ background_area.y);
+#else
+ cairo_move_to (cr, background_area.x, background_area.y - 0.5);
+ cairo_line_to (cr, background_area.x + background_area.width,
+ background_area.y - 0.5);
+#endif
+ }
+
+ if (y_offset + max_height <= Zarea.height - 0.5)
+ {
+#if GTK3_TRANSITION
+ gdk_draw_line (event->window,
+ tree_view->priv->grid_line_gc[widget->state],
+ background_area.x, background_area.y + max_height,
+ background_area.x + background_area.width,
+ background_area.y + max_height);
+#else
+
+ cairo_move_to (cr, background_area.x, background_area.y + max_height - 0.5);
+ cairo_line_to (cr, background_area.x + background_area.width,
+ background_area.y + max_height - 0.5);
+#endif
+ }
+ cairo_stroke (cr);
}
_pspp_sheet_view_column_cell_render (column,
- event->window,
+ cr,
&background_area,
&cell_area,
- &event->area,
flags);
if (node == cursor && has_special_cell &&
(column == tree_view->priv->edited_column)))
{
_pspp_sheet_view_column_cell_draw_focus (column,
- event->window,
+ cr,
&background_area,
&cell_area,
- &event->area,
flags);
}
cell_offset += column->width;
}
- if (cell_offset < event->area.x)
+ if (cell_offset < Zarea.x)
{
- gtk_paint_flat_box (widget->style,
- event->window,
+ gtk_paint_flat_box (gtk_widget_get_style (widget),
+ cr,
GTK_STATE_NORMAL,
GTK_SHADOW_NONE,
- &event->area,
widget,
"base",
cell_offset,
background_area.y,
- event->area.x - cell_offset,
+ Zarea.x - cell_offset,
background_area.height);
}
if (node < 0)
break;
- gdk_drawable_get_size (tree_view->priv->bin_window,
- &width, NULL);
+ width = gdk_window_get_width (tree_view->priv->bin_window);
if (row_ending_details)
- gtk_paint_focus (widget->style,
- tree_view->priv->bin_window,
+ gtk_paint_focus (gtk_widget_get_style (widget),
+ cr,
gtk_widget_get_state (widget),
- &event->area,
widget,
(is_first
? (is_last ? "treeview-drop-indicator" : "treeview-drop-indicator-left" )
width, ROW_HEIGHT (tree_view)
- focus_line_width + 1);
else
- gtk_paint_focus (widget->style,
- tree_view->priv->bin_window,
+ gtk_paint_focus (gtk_widget_get_style (widget),
+ cr,
gtk_widget_get_state (widget),
- &event->area,
widget,
"treeview-drop-indicator",
0, BACKGROUND_FIRST_PIXEL (tree_view, node)
break;
}
+#if GTK3_TRANSITION
if (highlight_y >= 0)
{
gdk_draw_line (event->window,
rtl ? 0 : bin_window_width,
highlight_y);
}
+#endif
}
/* draw the big row-spanning focus rectangle, if needed */
(flags & GTK_CELL_RENDERER_INSENSITIVE ? GTK_STATE_INSENSITIVE :
GTK_STATE_NORMAL));
- gdk_drawable_get_size (tree_view->priv->bin_window,
- &width, NULL);
+ width = gdk_window_get_width (tree_view->priv->bin_window);
if (draw_hgrid_lines)
{
}
if (row_ending_details)
- gtk_paint_focus (widget->style,
- tree_view->priv->bin_window,
+ gtk_paint_focus (gtk_widget_get_style (widget),
+ cr,
focus_rect_state,
- &event->area,
widget,
(is_first
? (is_last ? "treeview" : "treeview-left" )
0, tmp_y,
width, tmp_height);
else
- gtk_paint_focus (widget->style,
- tree_view->priv->bin_window,
+ gtk_paint_focus (gtk_widget_get_style (widget),
+ cr,
focus_rect_state,
- &event->area,
widget,
"treeview",
0, tmp_y,
}
while (!done);
}
- while (y_offset < event->area.height);
+ while (y_offset < Zarea.height);
done:
- pspp_sheet_view_draw_grid_lines (tree_view, event, n_visible_columns,
+ pspp_sheet_view_draw_vertical_grid_lines (tree_view, cr, n_visible_columns,
min_y, max_y);
+#if GTK3_TRANSITION
if (tree_view->priv->rubber_band_status == RUBBER_BAND_ACTIVE)
{
GdkRectangle *rectangles;
g_free (rectangles);
}
+#endif
if (cursor_path)
gtk_tree_path_free (cursor_path);
return FALSE;
}
+
static gboolean
-pspp_sheet_view_expose (GtkWidget *widget,
- GdkEventExpose *event)
+pspp_sheet_view_draw (GtkWidget *widget,
+ cairo_t *cr)
{
PsppSheetView *tree_view = PSPP_SHEET_VIEW (widget);
-
- if (event->window == tree_view->priv->bin_window)
+ GtkAllocation allocation;
+ gtk_widget_get_allocation (widget, &allocation);
+
+ if (gtk_cairo_should_draw_window (cr, tree_view->priv->bin_window))
{
gboolean retval;
GList *tmp_list;
- retval = pspp_sheet_view_bin_expose (widget, event);
+ cairo_save (cr);
+ cairo_translate (cr, 0, gdk_window_get_height (tree_view->priv->header_window));
+ retval = pspp_sheet_view_bin_expose (widget, cr);
+ cairo_restore (cr);
/* We can't just chain up to Container::expose as it will try to send the
* event to the headers, so we handle propagating it to our children
PsppSheetViewChild *child = tmp_list->data;
tmp_list = tmp_list->next;
- gtk_container_propagate_expose (GTK_CONTAINER (tree_view), child->widget, event);
+ gtk_container_propagate_draw (GTK_CONTAINER (tree_view), child->widget, cr);
}
return retval;
}
-
- else if (event->window == tree_view->priv->header_window)
+ else if (gtk_cairo_should_draw_window (cr, tree_view->priv->header_window))
{
gint n_visible_columns;
GList *list;
- gtk_paint_flat_box (widget->style,
- event->window,
+ gtk_paint_flat_box (gtk_widget_get_style (widget),
+ cr,
GTK_STATE_NORMAL,
GTK_SHADOW_NONE,
- &event->area,
widget,
"cell_odd",
- event->area.x,
- event->area.y,
- event->area.width,
- event->area.height);
+ allocation.x,
+ allocation.y,
+ allocation.width,
+ allocation.height
+ );
for (list = tree_view->priv->columns; list != NULL; list = list->next)
{
continue;
if (span_intersects (column->allocation.x, column->allocation.width,
- event->area.x, event->area.width)
+ allocation.x, allocation.width)
&& column->button != NULL)
- gtk_container_propagate_expose (GTK_CONTAINER (tree_view),
- column->button, event);
+ gtk_container_propagate_draw (GTK_CONTAINER (tree_view),
+ column->button, cr);
}
n_visible_columns = 0;
continue;
n_visible_columns ++;
}
- pspp_sheet_view_draw_grid_lines (tree_view,
- event,
- n_visible_columns,
- event->area.y,
- event->area.height);
+ pspp_sheet_view_draw_vertical_grid_lines (tree_view,
+ cr,
+ n_visible_columns,
+ allocation.y,
+ allocation.height);
+
+ return TRUE;
}
- else if (event->window == tree_view->priv->drag_window)
+ else if (gtk_cairo_should_draw_window (cr, tree_view->priv->drag_window))
{
- gtk_container_propagate_expose (GTK_CONTAINER (tree_view),
- tree_view->priv->drag_column->button,
- event);
+ gtk_container_propagate_draw (GTK_CONTAINER (tree_view),
+ tree_view->priv->drag_column->button,
+ cr);
+
+ return TRUE;
}
- return TRUE;
+
+ return FALSE;
}
enum
old_text = g_strdup (gtk_entry_get_text (GTK_ENTRY (tree_view->priv->search_entry)));
new_event = gdk_event_copy ((GdkEvent *) event);
g_object_unref (((GdkEventKey *) new_event)->window);
- ((GdkEventKey *) new_event)->window = g_object_ref (tree_view->priv->search_window->window);
+ ((GdkEventKey *) new_event)->window = g_object_ref (gtk_widget_get_window (tree_view->priv->search_window));
gtk_widget_realize (tree_view->priv->search_window);
popup_menu_id = g_signal_connect (tree_view->priv->search_entry,
pspp_sheet_view_node_queue_redraw (PsppSheetView *tree_view,
int node)
{
- gint y;
-
- y = pspp_sheet_view_node_find_offset (tree_view, node)
- - tree_view->priv->vadjustment->value
+ GtkAllocation allocation;
+ gint y = pspp_sheet_view_node_find_offset (tree_view, node)
+ - gtk_adjustment_get_value (tree_view->priv->vadjustment)
+ TREE_VIEW_HEADER_HEIGHT (tree_view);
+ gtk_widget_get_allocation (GTK_WIDGET (tree_view), &allocation);
+
gtk_widget_queue_draw_area (GTK_WIDGET (tree_view),
0, y,
- GTK_WIDGET (tree_view)->allocation.width,
+ allocation.width,
tree_view->priv->fixed_height);
}
y = pspp_sheet_view_node_find_offset (tree_view, node);
height = ROW_HEIGHT (tree_view);
- if (y >= tree_view->priv->vadjustment->value &&
- y + height <= (tree_view->priv->vadjustment->value
- + tree_view->priv->vadjustment->page_size))
+ if (y >= gtk_adjustment_get_value (tree_view->priv->vadjustment) &&
+ y + height <= (gtk_adjustment_get_value (tree_view->priv->vadjustment)
+ + gtk_adjustment_get_page_size (tree_view->priv->vadjustment)))
return TRUE;
return FALSE;
gint total_height;
gint area_above = 0;
gint area_below = 0;
+ GtkAllocation allocation;
if (tree_view->priv->row_count == 0)
return;
if (tree_view->priv->scroll_to_path == NULL)
return;
- total_height = GTK_WIDGET (tree_view)->allocation.height - TREE_VIEW_HEADER_HEIGHT (tree_view);
+ gtk_widget_get_allocation (GTK_WIDGET (tree_view), &allocation);
+
+ total_height = allocation.height - TREE_VIEW_HEADER_HEIGHT (tree_view);
if (total_height == 0)
return;
dy = pspp_sheet_view_node_find_offset (tree_view, node);
- if (dy >= tree_view->priv->vadjustment->value &&
- dy + height <= (tree_view->priv->vadjustment->value
- + tree_view->priv->vadjustment->page_size))
+ if (dy >= gtk_adjustment_get_value (tree_view->priv->vadjustment) &&
+ dy + height <= (gtk_adjustment_get_value (tree_view->priv->vadjustment)
+ + gtk_adjustment_get_page_size (tree_view->priv->vadjustment)))
{
/* row visible: keep the row at the same position */
- area_above = dy - tree_view->priv->vadjustment->value;
- area_below = (tree_view->priv->vadjustment->value +
- tree_view->priv->vadjustment->page_size)
+ area_above = dy - gtk_adjustment_get_value (tree_view->priv->vadjustment);
+ area_below = (gtk_adjustment_get_value (tree_view->priv->vadjustment) +
+ gtk_adjustment_get_page_size (tree_view->priv->vadjustment))
- dy - height;
}
else
{
/* row not visible */
if (dy >= 0
- && dy + height <= tree_view->priv->vadjustment->page_size)
+ && dy + height <= gtk_adjustment_get_page_size (tree_view->priv->vadjustment))
{
/* row at the beginning -- fixed */
area_above = dy;
- area_below = tree_view->priv->vadjustment->page_size
+ area_below = gtk_adjustment_get_page_size (tree_view->priv->vadjustment)
- area_above - height;
}
- else if (dy >= (tree_view->priv->vadjustment->upper -
- tree_view->priv->vadjustment->page_size))
+ else if (dy >= (gtk_adjustment_get_upper (tree_view->priv->vadjustment) -
+ gtk_adjustment_get_page_size (tree_view->priv->vadjustment)))
{
/* row at the end -- fixed */
- area_above = dy - (tree_view->priv->vadjustment->upper -
- tree_view->priv->vadjustment->page_size);
- area_below = tree_view->priv->vadjustment->page_size -
+ area_above = dy - (gtk_adjustment_get_upper (tree_view->priv->vadjustment) -
+ gtk_adjustment_get_page_size (tree_view->priv->vadjustment));
+ area_below = gtk_adjustment_get_page_size (tree_view->priv->vadjustment) -
area_above - height;
if (area_below < 0)
{
- area_above = tree_view->priv->vadjustment->page_size - height;
+ area_above = gtk_adjustment_get_page_size (tree_view->priv->vadjustment) - height;
area_below = 0;
}
}
* in an inconsistent state if we call top_row_to_dy. */
gtk_widget_size_request (GTK_WIDGET (tree_view), &requisition);
- tree_view->priv->hadjustment->upper = MAX (tree_view->priv->hadjustment->upper, (gfloat)requisition.width);
- tree_view->priv->vadjustment->upper = MAX (tree_view->priv->vadjustment->upper, (gfloat)requisition.height);
+ gtk_adjustment_set_upper (tree_view->priv->hadjustment, MAX (gtk_adjustment_get_upper (tree_view->priv->hadjustment), (gfloat)requisition.width));
+ gtk_adjustment_set_upper (tree_view->priv->vadjustment, MAX (gtk_adjustment_get_upper (tree_view->priv->vadjustment), (gfloat)requisition.height));
gtk_adjustment_changed (tree_view->priv->hadjustment);
gtk_adjustment_changed (tree_view->priv->vadjustment);
gtk_widget_queue_resize (GTK_WIDGET (tree_view));
gtk_widget_size_request (GTK_WIDGET (tree_view), &requisition);
- tree_view->priv->hadjustment->upper = MAX (tree_view->priv->hadjustment->upper, (gfloat)requisition.width);
- tree_view->priv->vadjustment->upper = MAX (tree_view->priv->vadjustment->upper, (gfloat)requisition.height);
+ gtk_adjustment_set_upper (tree_view->priv->hadjustment, MAX (gtk_adjustment_get_upper (tree_view->priv->hadjustment), (gfloat)requisition.width));
+ gtk_adjustment_set_upper (tree_view->priv->vadjustment, MAX (gtk_adjustment_get_upper (tree_view->priv->vadjustment), (gfloat)requisition.height));
gtk_adjustment_changed (tree_view->priv->hadjustment);
gtk_adjustment_changed (tree_view->priv->vadjustment);
gtk_widget_queue_resize (GTK_WIDGET (tree_view));
static gboolean
scroll_sync_handler (PsppSheetView *tree_view)
{
- if (tree_view->priv->height <= tree_view->priv->vadjustment->page_size)
+ if (tree_view->priv->height <= gtk_adjustment_get_page_size (tree_view->priv->vadjustment))
gtk_adjustment_set_value (GTK_ADJUSTMENT (tree_view->priv->vadjustment), 0);
else if (gtk_tree_row_reference_valid (tree_view->priv->top_row))
pspp_sheet_view_top_row_to_dy (tree_view);
new_dy = pspp_sheet_view_node_find_offset (tree_view, node);
new_dy += tree_view->priv->top_row_dy;
- if (new_dy + tree_view->priv->vadjustment->page_size > tree_view->priv->height)
- new_dy = tree_view->priv->height - tree_view->priv->vadjustment->page_size;
+ if (new_dy + gtk_adjustment_get_page_size (tree_view->priv->vadjustment) > tree_view->priv->height)
+ new_dy = tree_view->priv->height - gtk_adjustment_get_page_size (tree_view->priv->vadjustment);
new_dy = MAX (0, new_dy);
{
GtkWidget *source_widget;
- *suggested_action = context->suggested_action;
+ *suggested_action = gdk_drag_context_get_suggested_action (context);
source_widget = gtk_drag_get_source_widget (context);
if (source_widget == widget)
/* Default to MOVE, unless the user has
* pressed ctrl or shift to affect available actions
*/
- if ((context->actions & GDK_ACTION_MOVE) != 0)
+ if ((gdk_drag_context_get_actions (context) & GDK_ACTION_MOVE) != 0)
*suggested_action = GDK_ACTION_MOVE;
}
}
+
static void
pspp_sheet_view_drag_begin (GtkWidget *widget,
GdkDragContext *context)
{
+#if GTK3_TRANSITION
PsppSheetView *tree_view;
GtkTreePath *path = NULL;
gint cell_x, cell_y;
g_object_unref (row_pix);
gtk_tree_path_free (path);
+#endif
}
+
static void
pspp_sheet_view_drag_end (GtkWidget *widget,
GdkDragContext *context)
goto done;
/* If drag_data_get does nothing, try providing row data. */
- if (selection_data->target == gdk_atom_intern_static_string ("GTK_TREE_MODEL_ROW"))
+ if (gtk_selection_data_get_target (selection_data) == gdk_atom_intern_static_string ("GTK_TREE_MODEL_ROW"))
{
gtk_tree_set_row_drag_data (selection_data,
model,
if (dest_row == NULL)
return;
- if (selection_data->length >= 0)
+ if (gtk_selection_data_get_length (selection_data) >= 0)
{
if (path_down_mode)
{
}
}
- if (selection_data->length >= 0)
+ if (gtk_selection_data_get_length (selection_data) >= 0)
{
if (gtk_tree_drag_dest_drag_data_received (GTK_TREE_DRAG_DEST (model),
dest_row,
gtk_drag_finish (context,
accepted,
- (context->action == GDK_ACTION_MOVE),
+ (gdk_drag_context_get_actions (context) == GDK_ACTION_MOVE),
time);
if (gtk_tree_path_get_depth (dest_row) == 1
return;
}
- if (GTK_CONTAINER (tree_view)->focus_child != focus_column->button)
+ if (gtk_container_get_focus_child (GTK_CONTAINER (tree_view)) != focus_column->button)
gtk_widget_grab_focus (focus_column->button);
if (clamp_column_visible)
if (! PSPP_SHEET_VIEW_FLAG_SET (tree_view, PSPP_SHEET_VIEW_HEADERS_VISIBLE))
return FALSE;
- focus_child = GTK_CONTAINER (tree_view)->focus_child;
+ focus_child = gtk_container_get_focus_child (GTK_CONTAINER (tree_view));
first_column = tree_view->priv->columns;
while (first_column)
if (!gtk_widget_is_sensitive (widget) || !gtk_widget_get_can_focus (widget))
return FALSE;
- focus_child = container->focus_child;
+ focus_child = gtk_container_get_focus_child (container);
pspp_sheet_view_stop_editing (PSPP_SHEET_VIEW (widget), FALSE);
/* Case 1. Headers currently have focus. */
if (gtk_widget_get_realized (widget))
{
- gint i;
- PsppSheetViewPrivate *priv = PSPP_SHEET_VIEW (widget)->priv;
-
- gdk_window_set_back_pixmap (widget->window, NULL, FALSE);
- gdk_window_set_background (tree_view->priv->bin_window, &widget->style->base[widget->state]);
- gtk_style_set_background (widget->style, tree_view->priv->header_window, GTK_STATE_NORMAL);
- for (i = 0; i < 5 ; ++i)
- {
- g_object_unref (priv->grid_line_gc[i]);
- priv->grid_line_gc[i] = gdk_gc_new (widget->window);
- gdk_gc_copy (priv->grid_line_gc[i], widget->style->text_aa_gc[i]);
- }
-
+ gdk_window_set_background (tree_view->priv->bin_window, >k_widget_get_style (widget)->base[gtk_widget_get_state (widget)]);
+ gtk_style_set_background (gtk_widget_get_style (widget), tree_view->priv->header_window, GTK_STATE_NORMAL);
pspp_sheet_view_set_grid_lines (tree_view, tree_view->priv->grid_lines);
}
/* just return if the node is visible, avoiding a costly expose */
node_dy = pspp_sheet_view_node_find_offset (tree_view, node);
height = ROW_HEIGHT (tree_view);
- if (node_dy >= tree_view->priv->vadjustment->value
- && node_dy + height <= (tree_view->priv->vadjustment->value
- + tree_view->priv->vadjustment->page_size))
+ if (node_dy >= gtk_adjustment_get_value (tree_view->priv->vadjustment)
+ && node_dy + height <= (gtk_adjustment_get_value (tree_view->priv->vadjustment)
+ + gtk_adjustment_get_page_size (tree_view->priv->vadjustment)))
return;
path = _pspp_sheet_view_find_path (tree_view, node);
x = column->allocation.x;
width = column->allocation.width;
- if (width > tree_view->priv->hadjustment->page_size)
+ if (width > gtk_adjustment_get_page_size (tree_view->priv->hadjustment))
{
/* The column is larger than the horizontal page size. If the
* column has cells which can be focussed individually, then we make
x = focus_area.x;
width = focus_area.width;
- if (width < tree_view->priv->hadjustment->page_size)
+ if (width < gtk_adjustment_get_page_size (tree_view->priv->hadjustment))
{
- if ((tree_view->priv->hadjustment->value + tree_view->priv->hadjustment->page_size) < (x + width))
+ if ((gtk_adjustment_get_value (tree_view->priv->hadjustment) + gtk_adjustment_get_page_size (tree_view->priv->hadjustment)) < (x + width))
gtk_adjustment_set_value (tree_view->priv->hadjustment,
- x + width - tree_view->priv->hadjustment->page_size);
- else if (tree_view->priv->hadjustment->value > x)
+ x + width - gtk_adjustment_get_page_size (tree_view->priv->hadjustment));
+ else if (gtk_adjustment_get_value (tree_view->priv->hadjustment) > x)
gtk_adjustment_set_value (tree_view->priv->hadjustment, x);
}
}
gtk_adjustment_set_value (tree_view->priv->hadjustment,
CLAMP (x,
- tree_view->priv->hadjustment->lower,
- tree_view->priv->hadjustment->upper
- - tree_view->priv->hadjustment->page_size));
+ gtk_adjustment_get_lower (tree_view->priv->hadjustment),
+ gtk_adjustment_get_upper (tree_view->priv->hadjustment)
+ - gtk_adjustment_get_page_size (tree_view->priv->hadjustment)));
}
else
{
- if ((tree_view->priv->hadjustment->value + tree_view->priv->hadjustment->page_size) < (x + width))
+ if ((gtk_adjustment_get_value (tree_view->priv->hadjustment) + gtk_adjustment_get_page_size (tree_view->priv->hadjustment)) < (x + width))
gtk_adjustment_set_value (tree_view->priv->hadjustment,
- x + width - tree_view->priv->hadjustment->page_size);
- else if (tree_view->priv->hadjustment->value > x)
+ x + width - gtk_adjustment_get_page_size (tree_view->priv->hadjustment));
+ else if (gtk_adjustment_get_value (tree_view->priv->hadjustment) > x)
gtk_adjustment_set_value (tree_view->priv->hadjustment, x);
}
}
}
else
{
- gint width;
-
- gdk_drawable_get_size (tree_view->priv->header_window, &width, NULL);
+ gint width = gdk_window_get_width (tree_view->priv->header_window);
reorder->right_align = width + TREE_VIEW_COLUMN_DRAG_DEAD_MULTIPLIER (tree_view);
}
}
{
GdkEvent *send_event;
GtkAllocation allocation;
- gint x, y, width, height;
+ gint x, y;
GdkScreen *screen = gtk_widget_get_screen (GTK_WIDGET (tree_view));
GdkDisplay *display = gdk_screen_get_display (screen);
attributes.width = column->allocation.width;
attributes.height = column->allocation.height;
attributes.visual = gtk_widget_get_visual (GTK_WIDGET (tree_view));
- attributes.colormap = gtk_widget_get_colormap (GTK_WIDGET (tree_view));
attributes.event_mask = GDK_VISIBILITY_NOTIFY_MASK | GDK_EXPOSURE_MASK | GDK_POINTER_MOTION_MASK;
- attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
+ attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL ;
tree_view->priv->drag_window = gdk_window_new (tree_view->priv->bin_window,
&attributes,
send_event = gdk_event_new (GDK_LEAVE_NOTIFY);
send_event->crossing.send_event = TRUE;
- send_event->crossing.window = g_object_ref (GTK_BUTTON (column->button)->event_window);
+ send_event->crossing.window = g_object_ref (gtk_button_get_event_window (GTK_BUTTON (column->button)));
send_event->crossing.subwindow = NULL;
send_event->crossing.detail = GDK_NOTIFY_ANCESTOR;
send_event->crossing.time = GDK_CURRENT_TIME;
send_event->button.axes = NULL;
send_event->button.state = 0;
send_event->button.button = 1;
- send_event->button.device = gdk_display_get_core_pointer (display);
+ send_event->button.device =
+ gdk_device_manager_get_client_pointer (gdk_display_get_device_manager (display));
+
send_event->button.x_root = 0;
send_event->button.y_root = 0;
gdk_window_show (tree_view->priv->drag_window);
gdk_window_get_origin (tree_view->priv->header_window, &x, &y);
- gdk_drawable_get_size (tree_view->priv->header_window, &width, &height);
gtk_widget_grab_focus (GTK_WIDGET (tree_view));
while (gtk_events_pending ())
const GdkRectangle *clip_rect)
{
GdkRectangle rect;
+ GtkAllocation allocation;
if (!gtk_widget_get_realized (GTK_WIDGET (tree_view)))
return;
+ gtk_widget_get_allocation (GTK_WIDGET (tree_view), &allocation);
rect.x = 0;
- rect.width = MAX (tree_view->priv->width, GTK_WIDGET (tree_view)->allocation.width);
+ rect.width = MAX (tree_view->priv->width, allocation.width);
rect.y = BACKGROUND_FIRST_PIXEL (tree_view, node);
rect.height = ROW_HEIGHT (tree_view);
y = pspp_sheet_view_node_find_offset (tree_view, cursor_node);
window_y = RBTREE_Y_TO_TREE_WINDOW_Y (tree_view, y);
y += tree_view->priv->cursor_offset;
- y += count * (int)tree_view->priv->vadjustment->page_increment;
- y = CLAMP (y, (gint)tree_view->priv->vadjustment->lower, (gint)tree_view->priv->vadjustment->upper - vertical_separator);
+ y += count * (int)gtk_adjustment_get_page_increment (tree_view->priv->vadjustment);
+ y = CLAMP (y, (gint)gtk_adjustment_get_lower (tree_view->priv->vadjustment), (gint)gtk_adjustment_get_upper (tree_view->priv->vadjustment) - vertical_separator);
if (y >= tree_view->priv->height)
y = tree_view->priv->height - 1;
{
GdkEvent *fevent = gdk_event_new (GDK_FOCUS_CHANGE);
- g_object_ref (widget);
-
- if (in)
- GTK_WIDGET_SET_FLAGS (widget, GTK_HAS_FOCUS);
- else
- GTK_WIDGET_UNSET_FLAGS (widget, GTK_HAS_FOCUS);
-
fevent->focus_change.type = GDK_FOCUS_CHANGE;
- fevent->focus_change.window = g_object_ref (widget->window);
+ fevent->focus_change.window = g_object_ref (gtk_widget_get_window (widget));
fevent->focus_change.in = in;
- gtk_widget_event (widget, fevent);
-
- g_object_notify (G_OBJECT (widget), "has-focus");
-
- g_object_unref (widget);
+ gtk_widget_send_focus_change (widget, fevent);
gdk_event_free (fevent);
}
if (tree_view->priv->search_window != NULL)
{
- if (GTK_WINDOW (toplevel)->group)
- gtk_window_group_add_window (GTK_WINDOW (toplevel)->group,
+ if (gtk_window_get_group (GTK_WINDOW (toplevel)))
+ gtk_window_group_add_window (gtk_window_get_group (GTK_WINDOW (toplevel)),
GTK_WINDOW (tree_view->priv->search_window));
- else if (GTK_WINDOW (tree_view->priv->search_window)->group)
- gtk_window_group_remove_window (GTK_WINDOW (tree_view->priv->search_window)->group,
+ else if (gtk_window_get_group (GTK_WINDOW (tree_view->priv->search_window)))
+ gtk_window_group_remove_window (gtk_window_get_group (GTK_WINDOW (tree_view->priv->search_window)),
GTK_WINDOW (tree_view->priv->search_window));
gtk_window_set_screen (GTK_WINDOW (tree_view->priv->search_window), screen);
return;
tree_view->priv->search_window = gtk_window_new (GTK_WINDOW_POPUP);
gtk_window_set_screen (GTK_WINDOW (tree_view->priv->search_window), screen);
- if (GTK_WINDOW (toplevel)->group)
- gtk_window_group_add_window (GTK_WINDOW (toplevel)->group,
+ if (gtk_window_get_group (GTK_WINDOW (toplevel)))
+ gtk_window_group_add_window (gtk_window_get_group (GTK_WINDOW (toplevel)),
GTK_WINDOW (tree_view->priv->search_window));
gtk_window_set_type_hint (GTK_WINDOW (tree_view->priv->search_window),
g_signal_connect (tree_view->priv->search_entry,
"activate", G_CALLBACK (pspp_sheet_view_search_activate),
tree_view);
+
+#if GTK3_TRANSITION
g_signal_connect (GTK_ENTRY (tree_view->priv->search_entry)->im_context,
"preedit-changed",
G_CALLBACK (pspp_sheet_view_search_preedit_changed),
tree_view);
+#endif
+
gtk_container_add (GTK_CONTAINER (vbox),
tree_view->priv->search_entry);
gint width;
gboolean rtl;
- /* first translate the x position from widget->window
+ /* first translate the x position from gtk_widget_get_window (widget)
* to clist->clist_window
*/
rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
int dy;
} ScrollData;
-/* The window to which widget->window is relative */
+/* The window to which gtk_widget_get_window (widget) is relative */
#define ALLOCATION_WINDOW(widget) \
(!gtk_widget_get_has_window (widget) ? \
- (widget)->window : \
- gdk_window_get_parent ((widget)->window))
+ gtk_widget_get_window (widget) : \
+ gdk_window_get_parent (gtk_widget_get_window (widget)))
static void
adjust_allocation_recurse (GtkWidget *widget,
gpointer data)
{
ScrollData *scroll_data = data;
-
+ GtkAllocation allocation;
+ gtk_widget_get_allocation (widget, &allocation);
/* Need to really size allocate instead of just poking
* into widget->allocation if the widget is not realized.
* FIXME someone figure out why this was.
{
if (gtk_widget_get_visible (widget))
{
- GdkRectangle tmp_rectangle = widget->allocation;
+ GdkRectangle tmp_rectangle = allocation;
tmp_rectangle.x += scroll_data->dx;
tmp_rectangle.y += scroll_data->dy;
{
if (ALLOCATION_WINDOW (widget) == scroll_data->window)
{
- widget->allocation.x += scroll_data->dx;
- widget->allocation.y += scroll_data->dy;
+ allocation.x += scroll_data->dx;
+ allocation.y += scroll_data->dy;
if (GTK_IS_CONTAINER (widget))
gtk_container_forall (GTK_CONTAINER (widget),
gint dy;
gdk_window_move (tree_view->priv->bin_window,
- - tree_view->priv->hadjustment->value,
+ - gtk_adjustment_get_value (tree_view->priv->hadjustment),
TREE_VIEW_HEADER_HEIGHT (tree_view));
gdk_window_move (tree_view->priv->header_window,
- - tree_view->priv->hadjustment->value,
+ - gtk_adjustment_get_value (tree_view->priv->hadjustment),
0);
- dy = tree_view->priv->dy - (int) tree_view->priv->vadjustment->value;
+ dy = tree_view->priv->dy - (int) gtk_adjustment_get_value (tree_view->priv->vadjustment);
if (dy)
{
update_prelight (tree_view,
}
gdk_window_scroll (tree_view->priv->bin_window, 0, dy);
- if (tree_view->priv->dy != (int) tree_view->priv->vadjustment->value)
+ if (tree_view->priv->dy != (int) gtk_adjustment_get_value (tree_view->priv->vadjustment))
{
/* update our dy and top_row */
- tree_view->priv->dy = (int) tree_view->priv->vadjustment->value;
+ tree_view->priv->dy = (int) gtk_adjustment_get_value (tree_view->priv->vadjustment);
if (!tree_view->priv->in_top_row_to_dy)
pspp_sheet_view_dy_to_top_row (tree_view);
for (list = tree_view->priv->columns; list; list = list->next)
{
PsppSheetViewColumn *column = list->data;
- GtkAllocation *allocation = &column->allocation;
+ GtkAllocation *col_allocation = &column->allocation;
+ GtkAllocation widget_allocation;
+ gtk_widget_get_allocation (GTK_WIDGET (tree_view), &widget_allocation);
- if (span_intersects (allocation->x, allocation->width,
- tree_view->priv->hadjustment->value,
- GTK_WIDGET (tree_view)->allocation.width))
+ if (span_intersects (col_allocation->x, col_allocation->width,
+ gtk_adjustment_get_value (tree_view->priv->hadjustment),
+ widget_allocation.width))
{
pspp_sheet_view_column_set_need_button (column, TRUE);
if (!column->button)
{
g_return_val_if_fail (PSPP_IS_SHEET_VIEW (tree_view), NULL);
- if (tree_view->priv->hadjustment == NULL)
- pspp_sheet_view_set_hadjustment (tree_view, NULL);
+ return pspp_sheet_view_do_get_hadjustment (tree_view);
+}
+static GtkAdjustment *
+pspp_sheet_view_do_get_hadjustment (PsppSheetView *tree_view)
+{
return tree_view->priv->hadjustment;
}
g_object_notify (G_OBJECT (tree_view), "hadjustment");
}
+static void
+pspp_sheet_view_do_set_hadjustment (PsppSheetView *tree_view,
+ GtkAdjustment *adjustment)
+{
+ PsppSheetViewPrivate *priv = tree_view->priv;
+
+ if (adjustment && priv->hadjustment == adjustment)
+ return;
+
+ if (priv->hadjustment != NULL)
+ {
+ g_signal_handlers_disconnect_by_func (priv->hadjustment,
+ pspp_sheet_view_adjustment_changed,
+ tree_view);
+ g_object_unref (priv->hadjustment);
+ }
+
+ if (adjustment == NULL)
+ adjustment = gtk_adjustment_new (0.0, 0.0, 0.0,
+ 0.0, 0.0, 0.0);
+
+ g_signal_connect (adjustment, "value-changed",
+ G_CALLBACK (pspp_sheet_view_adjustment_changed), tree_view);
+ priv->hadjustment = g_object_ref_sink (adjustment);
+ /* FIXME: Adjustment should probably be populated here with fresh values, but
+ * internal details are too complicated for me to decipher right now.
+ */
+ pspp_sheet_view_adjustment_changed (NULL, tree_view);
+
+ g_object_notify (G_OBJECT (tree_view), "hadjustment");
+}
+
/**
* pspp_sheet_view_get_vadjustment:
* @tree_view: A #PsppSheetView
*
* Gets the #GtkAdjustment currently being used for the vertical aspect.
*
- * Return value: A #GtkAdjustment object, or %NULL if none is currently being
- * used.
+ * Return value: (transfer none): A #GtkAdjustment object, or %NULL
+ * if none is currently being used.
+ *
+ * Deprecated: 3.0: Use gtk_scrollable_get_vadjustment()
**/
GtkAdjustment *
pspp_sheet_view_get_vadjustment (PsppSheetView *tree_view)
{
g_return_val_if_fail (PSPP_IS_SHEET_VIEW (tree_view), NULL);
- if (tree_view->priv->vadjustment == NULL)
- pspp_sheet_view_set_vadjustment (tree_view, NULL);
+ return pspp_sheet_view_do_get_vadjustment (tree_view);
+}
+static GtkAdjustment *
+pspp_sheet_view_do_get_vadjustment (PsppSheetView *tree_view)
+{
return tree_view->priv->vadjustment;
}
* @adjustment: (allow-none): The #GtkAdjustment to set, or %NULL
*
* Sets the #GtkAdjustment for the current vertical aspect.
+ *
+ * Deprecated: 3.0: Use gtk_scrollable_set_vadjustment()
**/
void
pspp_sheet_view_set_vadjustment (PsppSheetView *tree_view,
- GtkAdjustment *adjustment)
+ GtkAdjustment *adjustment)
{
g_return_if_fail (PSPP_IS_SHEET_VIEW (tree_view));
+ g_return_if_fail (adjustment == NULL || GTK_IS_ADJUSTMENT (adjustment));
- pspp_sheet_view_set_adjustments (tree_view,
- tree_view->priv->hadjustment,
- adjustment);
+ pspp_sheet_view_do_set_vadjustment (tree_view, adjustment);
+}
+
+static void
+pspp_sheet_view_do_set_vadjustment (PsppSheetView *tree_view,
+ GtkAdjustment *adjustment)
+{
+ PsppSheetViewPrivate *priv = tree_view->priv;
+ if (adjustment && priv->vadjustment == adjustment)
+ return;
+
+ if (priv->vadjustment != NULL)
+ {
+ g_signal_handlers_disconnect_by_func (priv->vadjustment,
+ pspp_sheet_view_adjustment_changed,
+ tree_view);
+ g_object_unref (priv->vadjustment);
+ }
+
+ if (adjustment == NULL)
+ adjustment = gtk_adjustment_new (0.0, 0.0, 0.0,
+ 0.0, 0.0, 0.0);
+
+ g_signal_connect (adjustment, "value-changed",
+ G_CALLBACK (pspp_sheet_view_adjustment_changed), tree_view);
+ priv->vadjustment = g_object_ref_sink (adjustment);
+ /* FIXME: Adjustment should probably be populated here with fresh values, but
+ * internal details are too complicated for me to decipher right now.
+ */
+ pspp_sheet_view_adjustment_changed (NULL, tree_view);
g_object_notify (G_OBJECT (tree_view), "vadjustment");
}
gint x, y;
GList *list;
PsppSheetViewColumn *column;
+ GtkAllocation allocation;
g_return_if_fail (PSPP_IS_SHEET_VIEW (tree_view));
+ gtk_widget_get_allocation (GTK_WIDGET (tree_view), &allocation);
+
headers_visible = !! headers_visible;
if (PSPP_SHEET_VIEW_FLAG_SET (tree_view, PSPP_SHEET_VIEW_HEADERS_VISIBLE) == headers_visible)
gdk_window_get_position (tree_view->priv->bin_window, &x, &y);
if (headers_visible)
{
- gdk_window_move_resize (tree_view->priv->bin_window, x, y + TREE_VIEW_HEADER_HEIGHT (tree_view), tree_view->priv->width, GTK_WIDGET (tree_view)->allocation.height - + TREE_VIEW_HEADER_HEIGHT (tree_view));
+ gdk_window_move_resize (tree_view->priv->bin_window, x, y + TREE_VIEW_HEADER_HEIGHT (tree_view),
+ tree_view->priv->width, allocation.height - + TREE_VIEW_HEADER_HEIGHT (tree_view));
if (gtk_widget_get_mapped (GTK_WIDGET (tree_view)))
pspp_sheet_view_map_buttons (tree_view);
}
}
- tree_view->priv->vadjustment->page_size = GTK_WIDGET (tree_view)->allocation.height - TREE_VIEW_HEADER_HEIGHT (tree_view);
- tree_view->priv->vadjustment->page_increment = (GTK_WIDGET (tree_view)->allocation.height - TREE_VIEW_HEADER_HEIGHT (tree_view)) / 2;
- tree_view->priv->vadjustment->lower = 0;
- tree_view->priv->vadjustment->upper = tree_view->priv->height;
+ gtk_adjustment_set_page_size (tree_view->priv->vadjustment, allocation.height - TREE_VIEW_HEADER_HEIGHT (tree_view));
+ gtk_adjustment_set_page_increment (tree_view->priv->vadjustment, (allocation.height - TREE_VIEW_HEADER_HEIGHT (tree_view)) / 2);
+ gtk_adjustment_set_lower (tree_view->priv->vadjustment, 0);
+ gtk_adjustment_set_upper (tree_view->priv->vadjustment, tree_view->priv->height);
gtk_adjustment_changed (tree_view->priv->vadjustment);
gtk_widget_queue_resize (GTK_WIDGET (tree_view));
vadj = tree_view->priv->vadjustment;
if (tree_x != -1)
- gtk_adjustment_set_value (hadj, CLAMP (tree_x, hadj->lower, hadj->upper - hadj->page_size));
+ gtk_adjustment_set_value (hadj, CLAMP (tree_x, gtk_adjustment_get_lower (hadj), gtk_adjustment_get_upper (hadj) - gtk_adjustment_get_page_size (hadj)));
if (tree_y != -1)
- gtk_adjustment_set_value (vadj, CLAMP (tree_y, vadj->lower, vadj->upper - vadj->page_size));
+ gtk_adjustment_set_value (vadj, CLAMP (tree_y, gtk_adjustment_get_lower (vadj), gtk_adjustment_get_upper (vadj) - gtk_adjustment_get_page_size (vadj)));
}
/**
if (tree_view->priv->row_count == 0)
return FALSE;
- if (x > tree_view->priv->hadjustment->upper)
+ if (x > gtk_adjustment_get_upper (tree_view->priv->hadjustment))
return FALSE;
if (x < 0 || y < 0)
if (visible_rect)
{
- visible_rect->x = tree_view->priv->hadjustment->value;
- visible_rect->y = tree_view->priv->vadjustment->value;
- visible_rect->width = widget->allocation.width;
- visible_rect->height = widget->allocation.height - TREE_VIEW_HEADER_HEIGHT (tree_view);
+ GtkAllocation allocation;
+ gtk_widget_get_allocation (widget, &allocation);
+ visible_rect->x = gtk_adjustment_get_value (tree_view->priv->hadjustment);
+ visible_rect->y = gtk_adjustment_get_value (tree_view->priv->vadjustment);
+ visible_rect->width = allocation.width;
+ visible_rect->height = allocation.height - TREE_VIEW_HEADER_HEIGHT (tree_view);
}
}
g_return_if_fail (PSPP_IS_SHEET_VIEW (tree_view));
if (tx)
- *tx = wx + tree_view->priv->hadjustment->value;
+ *tx = wx + gtk_adjustment_get_value (tree_view->priv->hadjustment);
if (ty)
*ty = wy + tree_view->priv->dy;
}
g_return_if_fail (PSPP_IS_SHEET_VIEW (tree_view));
if (wx)
- *wx = tx - tree_view->priv->hadjustment->value;
+ *wx = tx - gtk_adjustment_get_value (tree_view->priv->hadjustment);
if (wy)
*wy = ty - tree_view->priv->dy;
}
g_return_if_fail (PSPP_IS_SHEET_VIEW (tree_view));
if (bx)
- *bx = wx + tree_view->priv->hadjustment->value;
+ *bx = wx + gtk_adjustment_get_value (tree_view->priv->hadjustment);
if (by)
*by = wy - TREE_VIEW_HEADER_HEIGHT (tree_view);
}
g_return_if_fail (PSPP_IS_SHEET_VIEW (tree_view));
if (wx)
- *wx = bx - tree_view->priv->hadjustment->value;
+ *wx = bx - gtk_adjustment_get_value (tree_view->priv->hadjustment);
if (wy)
*wy = by + TREE_VIEW_HEADER_HEIGHT (tree_view);
}
{
gint y;
- if (tree_view->priv->height < tree_view->priv->vadjustment->page_size)
+ if (tree_view->priv->height < gtk_adjustment_get_page_size (tree_view->priv->vadjustment))
y = tree_view->priv->height - 1;
else
- y = TREE_WINDOW_Y_TO_RBTREE_Y (tree_view, tree_view->priv->vadjustment->page_size) - 1;
+ y = TREE_WINDOW_Y_TO_RBTREE_Y (tree_view, gtk_adjustment_get_page_size (tree_view->priv->vadjustment)) - 1;
pspp_sheet_view_find_offset (tree_view, y, &node);
if (node >= 0)
}
-
+#if GTK3_TRANSITION
/* KEEP IN SYNC WITH PSPP_SHEET_VIEW_BIN_EXPOSE */
/**
* pspp_sheet_view_create_row_drag_icon:
background_area.y = y;
background_area.height = ROW_HEIGHT (tree_view);
- gdk_drawable_get_size (tree_view->priv->bin_window,
- &bin_window_width, NULL);
+ bin_window_width = gdk_window_get_width (tree_view->priv->bin_window);
drawable = gdk_pixmap_new (tree_view->priv->bin_window,
bin_window_width + 2,
expose_area.width = bin_window_width + 2;
expose_area.height = background_area.height + 2;
+#if GTK3_TRANSITION
gdk_draw_rectangle (drawable,
widget->style->base_gc [gtk_widget_get_state (widget)],
TRUE,
0, 0,
bin_window_width + 2,
background_area.height + 2);
+#endif
rtl = gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL;
cell_offset += column->width;
}
+#if GTK3_TRANSITION
gdk_draw_rectangle (drawable,
widget->style->black_gc,
FALSE,
0, 0,
bin_window_width + 1,
background_area.height + 1);
+#endif
return drawable;
}
-
+#endif
/**
* pspp_sheet_view_set_destroy_count_func:
gint x, y;
gint tree_x, tree_y;
gint tree_width, tree_height;
- GdkWindow *tree_window = GTK_WIDGET (tree_view)->window;
- GdkScreen *screen = gdk_drawable_get_screen (tree_window);
+ GdkWindow *tree_window = gtk_widget_get_window (GTK_WIDGET (tree_view));
+ GdkScreen *screen = gdk_window_get_screen (tree_window);
GtkRequisition requisition;
gint monitor_num;
GdkRectangle monitor;
gtk_widget_realize (search_dialog);
gdk_window_get_origin (tree_window, &tree_x, &tree_y);
- gdk_drawable_get_size (tree_window,
- &tree_width,
- &tree_height);
+ tree_width = gdk_window_get_width (tree_window);
+ tree_height = gdk_window_get_height (tree_window);
+
gtk_widget_size_request (search_dialog, &requisition);
if (tree_x + tree_width > gdk_screen_get_width (screen))
G_CALLBACK (pspp_sheet_view_search_enable_popdown), data);
}
+#if GTK3_TRANSITION
/* Because we're visible but offscreen, we just set a flag in the preedit
* callback.
*/
}
}
+#endif
static void
pspp_sheet_view_search_activate (GtkEntry *entry,
gtk_tree_path_free (path);
handled = gtk_binding_set_activate (edit_bindings, keyval, event->state,
- GTK_OBJECT (tree_view));
+ G_OBJECT (tree_view));
if (handled)
g_signal_stop_emission_by_name (widget, "event");
guint flags)
{
PsppSheetSelectionMode mode = pspp_sheet_selection_get_mode (tree_view->priv->selection);
- gint pre_val = tree_view->priv->vadjustment->value;
+ gint pre_val = gtk_adjustment_get_value (tree_view->priv->vadjustment);
GtkRequisition requisition;
gint row;
row = gtk_tree_path_get_indices (path)[0];
tree_view->priv->edited_row = row;
pspp_sheet_view_real_set_cursor (tree_view, path, FALSE, TRUE, 0);
- cell_area->y += pre_val - (int)tree_view->priv->vadjustment->value;
+ cell_area->y += pre_val - (int)gtk_adjustment_get_value (tree_view->priv->vadjustment);
pspp_sheet_selection_unselect_all_columns (tree_view->priv->selection);
pspp_sheet_selection_select_column (tree_view->priv->selection, column);
if (gtk_widget_get_realized (widget))
{
- gdk_window_set_back_pixmap (widget->window, NULL, FALSE);
- gdk_window_set_background (tree_view->priv->bin_window, &widget->style->base[widget->state]);
+ GtkStyle *style = gtk_widget_get_style (widget);
+ gdk_window_set_background (tree_view->priv->bin_window, &style->base[gtk_widget_get_state (widget)]);
}
gtk_widget_queue_draw (widget);
}
else
{
+ GtkAllocation allocation;
+ gtk_widget_get_allocation (GTK_WIDGET (tree_view), &allocation);
rect.x = 0;
- rect.width = GTK_WIDGET (tree_view)->allocation.width;
+ rect.width = allocation.width;
}
/* Determine y values. */
else
{
rect.y = 0;
- rect.height = tree_view->priv->vadjustment->page_size;
+ rect.height = gtk_adjustment_get_page_size (tree_view->priv->vadjustment);
}
gtk_tooltip_set_tip_area (tooltip, &rect);
return continue_emission;
}
+
GType
pspp_sheet_view_grid_lines_get_type (void)
{
{
GtkContainer parent;
- PsppSheetViewPrivate *GSEAL (priv);
+ PsppSheetViewPrivate *PSEAL (priv);
gboolean dispose_has_run ;
};
gint drag_y,
GtkTreePath **path,
PsppSheetViewDropPosition *pos);
+
+#if GTK3_TRANSITION
GdkPixmap *pspp_sheet_view_create_row_drag_icon (PsppSheetView *tree_view,
GtkTreePath *path);
+#endif
/* Interactive search */
void pspp_sheet_view_set_enable_search (PsppSheetView *tree_view,
void
facade_button_render (GtkWidget *base,
- GdkDrawable *window,
- GdkRectangle *expose_area,
-
- GdkRectangle *button_area,
+ cairo_t *cr,
+ const GdkRectangle *button_area,
gint border_width,
GtkStyle *button_style,
GtkStateType state_type,
gint x, y;
/* Paint the button. */
- gtk_paint_box (button_style, window,
+ gtk_paint_box (button_style, cr,
state_type,
- GTK_SHADOW_OUT, expose_area, base, "button",
+ GTK_SHADOW_OUT, base, "button",
button_area->x + border_width,
button_area->y + border_width,
button_area->width - border_width * 2,
layout = facade_label_get_layout (base, label);
get_layout_location (base, &label_area, layout, xpad, ypad, xalign, yalign,
&x, &y);
- gtk_paint_layout (label_style, window, state_type, FALSE, expose_area,
+
+ gtk_paint_layout (label_style, cr, state_type, FALSE,
base, "label", x, y, layout);
+
g_object_unref (layout);
}
const GtkRequisition *child_request,
GtkRequisition *);
void facade_button_render (GtkWidget *base,
- GdkDrawable *window,
- GdkRectangle *expose_area,
-
- GdkRectangle *button_area,
+ cairo_t *cr,
+ const GdkRectangle *button_area,
gint border_width,
GtkStyle *button_style,
GtkStateType state_type,
"child-internal-pad-y", &ipad_y_default,
NULL);
- child_min_width = bbox->child_min_width != GTK_BUTTONBOX_DEFAULT
- ? bbox->child_min_width : width_default;
- child_min_height = bbox->child_min_height !=GTK_BUTTONBOX_DEFAULT
- ? bbox->child_min_height : height_default;
- ipad_x = bbox->child_ipad_x != GTK_BUTTONBOX_DEFAULT
- ? bbox->child_ipad_x : ipad_x_default;
- ipad_y = bbox->child_ipad_y != GTK_BUTTONBOX_DEFAULT
- ? bbox->child_ipad_y : ipad_y_default;
+ child_min_width = width_default;
+ child_min_height = height_default;
+ ipad_x = ipad_x_default;
+ ipad_y = ipad_y_default;
nchildren = 0;
nsecondaries = 0;
GParamSpec *pspec)
{
PsppireCellRendererButton *obj = PSPPIRE_CELL_RENDERER_BUTTON (object);
-
switch (prop_id)
{
case PROP_EDITABLE:
obj->editable = g_value_get_boolean (value);
if (obj->editable)
- GTK_CELL_RENDERER (obj)->mode = GTK_CELL_RENDERER_MODE_EDITABLE;
+ g_object_set (obj, "mode", GTK_CELL_RENDERER_MODE_EDITABLE, NULL);
else
- GTK_CELL_RENDERER (obj)->mode = GTK_CELL_RENDERER_MODE_INERT;
+ g_object_set (obj, "mode", GTK_CELL_RENDERER_MODE_INERT, NULL);
break;
case PROP_LABEL:
static void
psppire_cell_renderer_button_render (GtkCellRenderer *cell,
- GdkDrawable *window,
+ cairo_t *cr,
GtkWidget *widget,
- GdkRectangle *background_area,
- GdkRectangle *cell_area,
- GdkRectangle *expose_area,
+ const GdkRectangle *background_area,
+ const GdkRectangle *cell_area,
GtkCellRendererState flags)
{
- PsppireCellRendererButton *button = PSPPIRE_CELL_RENDERER_BUTTON (cell);
GtkStateType state_type;
-
- if (!button->editable || !cell->sensitive)
+ PsppireCellRendererButton *button = PSPPIRE_CELL_RENDERER_BUTTON (cell);
+ gfloat xalign, yalign;
+
+ if (!button->editable || ! gtk_cell_renderer_get_sensitive (cell))
state_type = GTK_STATE_INSENSITIVE;
else if (flags & GTK_CELL_RENDERER_SELECTED)
{
state_type = GTK_STATE_NORMAL;
}
+ gtk_cell_renderer_get_alignment (cell, &xalign, &yalign);
+
+
update_style_cache (button, widget);
- facade_button_render (widget, window, expose_area,
+
+ facade_button_render (widget, cr,
cell_area, button->border_width, button->button_style,
state_type,
button->label_style, button->label, button->xpad,
- button->ypad, cell->xalign, cell->yalign);
+ button->ypad, xalign, yalign);
if (button->slash)
- gdk_draw_line (window, button->button_style->black_gc,
- cell_area->x,
- cell_area->y + cell_area->height,
- cell_area->x + cell_area->width,
- cell_area->y);
+ {
+ cairo_set_line_width (cr, 1.0);
+ cairo_set_line_cap (cr, CAIRO_LINE_CAP_SQUARE);
+ cairo_move_to (cr,
+ cell_area->x,
+ cell_area->y + cell_area->height);
+
+ cairo_line_to (cr,
+ cell_area->x + cell_area->width,
+ cell_area->y);
+ cairo_stroke (cr);
+ }
}
static void
psppire_cell_renderer_button_get_size (GtkCellRenderer *cell,
GtkWidget *widget,
- GdkRectangle *cell_area,
+ const GdkRectangle *cell_area,
gint *x_offset,
gint *y_offset,
gint *width,
GdkEvent *event,
GtkWidget *widget,
const gchar *path,
- GdkRectangle *background_area,
- GdkRectangle *cell_area,
+ const GdkRectangle *background_area,
+ const GdkRectangle *cell_area,
GtkCellRendererState flags)
{
PsppireCellRendererButton *cell_button = PSPPIRE_CELL_RENDERER_BUTTON (cell);
if (!maximized)
{
- gint width, height;
gint x, y;
- gdk_drawable_get_size (w, &width, &height);
+ gint width = gdk_window_get_width (w);
+ gint height= gdk_window_get_height (w);
+
gdk_window_get_position (w, &x, &y);
psppire_conf_set_int (conf, base, "height", height);
static void
psppire_data_editor_switch_page (GtkNotebook *notebook,
-#if GTK_DISABLE_DEPRECATED && GTK_CHECK_VERSION(2,20,0)
- gpointer page,
-#else
- GtkNotebookPage *page,
-#endif
+ GtkWidget *w,
guint page_num)
{
- GTK_NOTEBOOK_CLASS (parent_class)->switch_page (notebook, page, page_num);
+ GTK_NOTEBOOK_CLASS (parent_class)->switch_page (notebook, w, page_num);
psppire_data_editor_update_ui_manager (PSPPIRE_DATA_EDITOR (notebook));
}
/* Data sheet tab. */
GtkWidget *vbox; /* Top-level widget in tab. */
GtkWidget *cell_ref_label; /* GtkLabel that shows selected case and var. */
- GtkWidget *datum_entry; /* GtkComboBoxEntry for editing current cell. */
+ GtkWidget *datum_entry; /* PsppireValueEntry for editing current cell. */
GtkWidget *datasheet_vbox_widget; /* ->vbox child that holds data sheets. */
GtkWidget *data_sheets[4]; /* Normally one data sheet; four, if split. */
gboolean split; /* True if data sheets are split. */
g_assert_not_reached ();
}
- gtk_selection_data_set (selection_data, selection_data->target,
+ gtk_selection_data_set (selection_data, gtk_selection_data_get_target (selection_data),
8,
(const guchar *) string->str, string->len);
gint first_column;
char *c;
- if ( sd->length < 0 )
+ if ( gtk_selection_data_get_length (sd) < 0 )
return;
- if ( sd->type != gdk_atom_intern ("UTF8_STRING", FALSE))
+ if ( gtk_selection_data_get_data_type (sd) != gdk_atom_intern ("UTF8_STRING", FALSE))
return;
- c = (char *) sd->data;
+ c = (char *) gtk_selection_data_get_data (sd);
/* Get the starting selected position in the data sheet. (Possibly we should
only paste into the selected range if it's larger than one cell?) */
g_return_if_fail (next_row >= 0);
g_return_if_fail (next_column >= 0);
- while (count < sd->length)
+ while (count < gtk_selection_data_get_length (sd))
{
gint row = next_row;
gint column = next_column;
struct variable *var;
char *s = c;
- while (*c != '\t' && *c != '\n' && count < sd->length)
+ while (*c != '\t' && *c != '\n' && count < gtk_selection_data_get_length (sd))
{
c++;
count++;
fonts_activate (PsppireDataWindow *de)
{
GtkWidget *toplevel = gtk_widget_get_toplevel (GTK_WIDGET (de));
- PangoFontDescription *current_font;
- gchar *font_name;
- GtkWidget *dialog =
- gtk_font_selection_dialog_new (_("Font Selection"));
-
-
- current_font = GTK_WIDGET(de->data_editor)->style->font_desc;
- font_name = pango_font_description_to_string (current_font);
+ GtkWidget *dialog = gtk_font_selection_dialog_new (_("Font Selection"));
+ GtkStyle *style = gtk_widget_get_style (GTK_WIDGET(de->data_editor));
+ PangoFontDescription *current_font = style->font_desc;
+ gchar *font_name = pango_font_description_to_string (current_font);
gtk_font_selection_dialog_set_font_name (GTK_FONT_SELECTION_DIALOG (dialog), font_name);
static void
psppire_data_window_init (PsppireDataWindow *de)
{
+ GtkWidget *w ;
de->builder = builder_new ("data-editor.ui");
de->ui_manager = GTK_UI_MANAGER (get_object_assert (de->builder, "uimanager1", GTK_TYPE_UI_MANAGER));
- PSPPIRE_WINDOW (de)->menu =
- GTK_MENU_SHELL (gtk_ui_manager_get_widget (de->ui_manager, "/ui/menubar/windows/windows_minimise_all")->parent);
+ w = gtk_ui_manager_get_widget (de->ui_manager, "/ui/menubar/windows/windows_minimise_all");
+
+ PSPPIRE_WINDOW (de)->menu = GTK_MENU_SHELL (gtk_widget_get_parent (w));
de->uim = NULL;
de->merge_id = 0;
{
gint response;
PsppireDialogAction *da = PSPPIRE_DIALOG_ACTION (act);
+ GtkWidget *parent1 = gtk_widget_get_parent (act->dg_table1);
+ GtkWidget *parent2 = gtk_widget_get_parent (act->dg_table2);
- if ( act->dg_table2->parent)
- gtk_container_remove (GTK_CONTAINER (act->dg_table2->parent), act->dg_table2);
-
- if ( act->dg_table1->parent)
- gtk_container_remove (GTK_CONTAINER (act->dg_table1->parent), act->dg_table1);
+ if (parent1)
+ gtk_container_remove (GTK_CONTAINER (parent1), act->dg_table1);
+ if (parent2)
+ gtk_container_remove (GTK_CONTAINER (parent2), act->dg_table2);
if ( var_is_numeric (act->grp_var))
{
GtkAllocation *allocation);
-static const GtkButtonBoxStyle default_layout_style = GTK_BUTTONBOX_EDGE;
+static void
+psppire_hbutton_box_get_preferred_height (GtkWidget *widget,
+ gint *minimal_height,
+ gint *natural_height)
+{
+ GtkRequisition requisition;
+
+ gtk_hbutton_box_size_request (widget, &requisition);
+
+ *minimal_height = *natural_height = requisition.height;
+}
+
+
+static void
+psppire_hbutton_box_get_preferred_width (GtkWidget *widget,
+ gint *minimal_width,
+ gint *natural_width)
+{
+ GtkRequisition requisition;
+
+ gtk_hbutton_box_size_request (widget, &requisition);
+
+ *minimal_width = *natural_width = requisition.width;
+}
+
+
+
GType
psppire_hbutton_box_get_type (void)
widget_class = (GtkWidgetClass*) class;
- widget_class->size_request = gtk_hbutton_box_size_request;
+ widget_class->get_preferred_width = psppire_hbutton_box_get_preferred_width;
+ widget_class->get_preferred_height = psppire_hbutton_box_get_preferred_height;
widget_class->size_allocate = gtk_hbutton_box_size_allocate;
}
box = GTK_BOX (widget);
bbox = GTK_BUTTON_BOX (widget);
- spacing = box->spacing;
- layout = bbox->layout_style != GTK_BUTTONBOX_DEFAULT_STYLE
- ? bbox->layout_style : default_layout_style;
+ spacing = gtk_box_get_spacing (box);
+ layout = gtk_button_box_get_layout (bbox) ;
_psppire_button_box_child_requisition (widget,
&nvis_children,
requisition->width =
nvis_children*child_width + ((nvis_children+1)*spacing);
break;
+ default:
case GTK_BUTTONBOX_EDGE:
case GTK_BUTTONBOX_START:
case GTK_BUTTONBOX_END:
requisition->width = nvis_children*child_width + ((nvis_children-1)*spacing);
break;
- default:
- g_assert_not_reached();
- break;
}
requisition->height = child_height;
}
- requisition->width += GTK_CONTAINER (box)->border_width * 2;
- requisition->height += GTK_CONTAINER (box)->border_width * 2;
+ requisition->width += gtk_container_get_border_width (GTK_CONTAINER (box)) * 2;
+ requisition->height += gtk_container_get_border_width (GTK_CONTAINER (box)) * 2;
}
base_box = GTK_BOX (widget);
box = GTK_BUTTON_BOX (widget);
- spacing = base_box->spacing;
- layout = box->layout_style != GTK_BUTTONBOX_DEFAULT_STYLE
- ? box->layout_style : default_layout_style;
+ spacing = gtk_box_get_spacing (base_box);
+ layout = gtk_button_box_get_layout (box) ;
_psppire_button_box_child_requisition (widget,
&nvis_children,
&n_secondaries,
&child_width,
&child_height);
- widget->allocation = *allocation;
- width = allocation->width - GTK_CONTAINER (box)->border_width*2;
+ gtk_widget_set_allocation (widget, allocation);
+ width = allocation->width - gtk_container_get_border_width (GTK_CONTAINER (box))*2;
switch (layout)
{
case GTK_BUTTONBOX_SPREAD:
childspacing = (width - (nvis_children * child_width)) / (nvis_children + 1);
- x = allocation->x + GTK_CONTAINER (box)->border_width + childspacing;
+ x = allocation->x + gtk_container_get_border_width (GTK_CONTAINER (box)) + childspacing;
secondary_x = x + ((nvis_children - n_secondaries) * (child_width + childspacing));
break;
+ default:
case GTK_BUTTONBOX_EDGE:
if (nvis_children >= 2)
{
childspacing = (width - (nvis_children * child_width)) / (nvis_children - 1);
- x = allocation->x + GTK_CONTAINER (box)->border_width;
+ x = allocation->x + gtk_container_get_border_width (GTK_CONTAINER (box));
secondary_x = x + ((nvis_children - n_secondaries) * (child_width + childspacing));
}
else
break;
case GTK_BUTTONBOX_START:
childspacing = spacing;
- x = allocation->x + GTK_CONTAINER (box)->border_width;
+ x = allocation->x + gtk_container_get_border_width (GTK_CONTAINER (box));
secondary_x = allocation->x + allocation->width
- child_width * n_secondaries
- spacing * (n_secondaries - 1)
- - GTK_CONTAINER (box)->border_width;
+ - gtk_container_get_border_width (GTK_CONTAINER (box));
break;
case GTK_BUTTONBOX_END:
childspacing = spacing;
x = allocation->x + allocation->width
- child_width * (nvis_children - n_secondaries)
- spacing * (nvis_children - n_secondaries - 1)
- - GTK_CONTAINER (box)->border_width;
- secondary_x = allocation->x + GTK_CONTAINER (box)->border_width;
- break;
- default:
- g_assert_not_reached();
+ - gtk_container_get_border_width (GTK_CONTAINER (box));
+ secondary_x = allocation->x + gtk_container_get_border_width (GTK_CONTAINER (box));
break;
}
#include <config.h>
#include <gtk/gtk.h>
#include <gdk/gdkkeysyms.h>
+#include <gdk/gdkkeysyms-compat.h>
#include "psppire-keypad.h"
enum {
static void on_dwgarea_realize (GtkWidget *widget, gpointer data);
static gboolean
-expose_event_callback (GtkWidget *widget, GdkEventExpose *event, gpointer data)
+draw_callback (GtkWidget *widget, cairo_t *cr, gpointer data)
{
PsppireOutputWindow *viewer = PSPPIRE_OUTPUT_WINDOW (data);
struct xr_rendering *r = g_object_get_data (G_OBJECT (widget), "rendering");
- cairo_t *cr = gdk_cairo_create (widget->window);
-
const GtkStyle *style = gtk_widget_get_style (GTK_WIDGET (viewer));
PangoFontDescription *font_desc;
pango_font_description_free (font_desc);
xr_rendering_apply_options (r, &viewer->render_opts);
-
- xr_rendering_draw (r, cr, event->area.x, event->area.y,
- event->area.width, event->area.height);
- cairo_destroy (cr);
+ xr_rendering_draw_all (r, cr);
return TRUE;
}
+
static void
psppire_output_submit (struct output_driver *this,
const struct output_item *item)
return;
}
- cr = gdk_cairo_create (GTK_WIDGET (pod->viewer)->window);
+ cr = gdk_cairo_create (gtk_widget_get_window (GTK_WIDGET (pod->viewer)));
if (pod->xr == NULL)
{
const GtkStyle *style = gtk_widget_get_style (GTK_WIDGET (viewer));
g_signal_connect (drawing_area, "realize",
G_CALLBACK (on_dwgarea_realize), pod->viewer);
- g_signal_connect (drawing_area, "expose_event",
- G_CALLBACK (expose_event_callback), pod->viewer);
+ g_signal_connect (drawing_area, "draw",
+ G_CALLBACK (draw_callback), pod->viewer);
gtk_widget_set_size_request (drawing_area, tw, th);
gtk_layout_put (pod->viewer->output, drawing_area, 0, pod->viewer->y);
g_value_unset (&value);
vadj = gtk_layout_get_vadjustment (window->output);
- min = vadj->lower;
- max = vadj->upper - vadj->page_size;
+ min = gtk_adjustment_get_lower (vadj);
+ max = gtk_adjustment_get_upper (vadj) - gtk_adjustment_get_page_size (vadj);
if (y < min)
y = min;
else if (y > max)
if ( g_file_get_contents (filename, &text, &length, NULL) )
{
- gtk_selection_data_set (selection_data, selection_data->target,
+ gtk_selection_data_set (selection_data, gtk_selection_data_get_target (selection_data),
8,
(const guchar *) text, length);
}
NULL);
{
+ GtkWidget *w;
GtkUIManager *uim = GTK_UI_MANAGER (get_object_assert (xml, "uimanager1", GTK_TYPE_UI_MANAGER));
merge_help_menu (uim);
+ w = gtk_ui_manager_get_widget (uim,"/ui/menubar/windows_menuitem/windows_minimise-all");
+
PSPPIRE_WINDOW (window)->menu =
- GTK_MENU_SHELL (gtk_ui_manager_get_widget (uim,"/ui/menubar/windows_menuitem/windows_minimise-all")->parent);
+ GTK_MENU_SHELL (gtk_widget_get_parent (w));
}
g_signal_connect_swapped (get_action_assert (xml, "file_export"), "activate",
PsppireSyntaxWindow *sw = data;
g_assert (info == SELECT_FMT_TEXT);
- gtk_selection_data_set (selection_data, selection_data->target,
+ gtk_selection_data_set (selection_data, gtk_selection_data_get_target (selection_data),
8,
(const guchar *) sw->cliptext, strlen (sw->cliptext));
{
PsppireSyntaxWindow *syntax_window = data;
- if ( sd->length < 0 )
+ if ( gtk_selection_data_get_length (sd) < 0 )
return;
- if ( sd->type != gdk_atom_intern ("UTF8_STRING", FALSE))
+ if ( gtk_selection_data_get_data_type (sd) != gdk_atom_intern ("UTF8_STRING", FALSE))
return;
gtk_text_buffer_insert_at_cursor (GTK_TEXT_BUFFER (syntax_window->buffer),
- (gchar *) sd->data,
- sd->length);
+ (gchar *) gtk_selection_data_get_data (sd),
+ gtk_selection_data_get_length (sd));
}
{
GtkUIManager *uim = GTK_UI_MANAGER (get_object_assert (xml, "uimanager1", GTK_TYPE_UI_MANAGER));
+ GtkWidget *w = gtk_ui_manager_get_widget (uim,"/ui/menubar/windows/windows_minimise_all");
merge_help_menu (uim);
- PSPPIRE_WINDOW (window)->menu =
- GTK_MENU_SHELL (gtk_ui_manager_get_widget (uim,"/ui/menubar/windows/windows_minimise_all")->parent);
+ PSPPIRE_WINDOW (window)->menu = GTK_MENU_SHELL (gtk_widget_get_parent (w));
}
g_object_unref (xml);
G_DEFINE_TYPE (PsppireValueEntry,
psppire_value_entry,
- GTK_TYPE_COMBO_BOX_ENTRY);
+ GTK_TYPE_COMBO_BOX);
enum
{
}
}
+static void
+psppire_value_entry_text_changed (GtkEntryBuffer *buffer,
+ GParamSpec *pspec,
+ PsppireValueEntry *obj)
+{
+ obj->cur_value = NULL;
+}
+
+
+static void
+on_realize (GtkWidget *w)
+{
+ GtkEntry *entry = GTK_ENTRY (gtk_bin_get_child (GTK_BIN (w)));
+ GtkEntryBuffer *buffer = gtk_entry_get_buffer (entry);
+
+ gtk_combo_box_set_entry_text_column (GTK_COMBO_BOX (w), COL_LABEL);
+
+ g_signal_connect (buffer, "notify::text",
+ G_CALLBACK (psppire_value_entry_text_changed), w);
+
+ GTK_WIDGET_CLASS (psppire_value_entry_parent_class)->realize (w);
+}
+
static void
psppire_value_entry_class_init (PsppireValueEntryClass *class)
{
- GObjectClass *gobject_class;
- gobject_class = G_OBJECT_CLASS (class);
+ GObjectClass *gobject_class = G_OBJECT_CLASS (class);
+ GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (class);
+
gobject_class->finalize = psppire_value_entry_finalize;
gobject_class->set_property = psppire_value_entry_set_property;
gobject_class->get_property = psppire_value_entry_get_property;
+ widget_class->realize = on_realize;
g_object_class_install_property (
gobject_class, PROP_SHOW_VALUE_LABEL,
G_PARAM_READABLE | G_PARAM_WRITABLE));
}
-static void
-psppire_value_entry_text_changed (GtkEntryBuffer *buffer,
- GParamSpec *pspec,
- PsppireValueEntry *obj)
-{
- obj->cur_value = NULL;
-}
-
static void
psppire_value_entry_init (PsppireValueEntry *obj)
{
- GtkEntry *entry = GTK_ENTRY (gtk_bin_get_child (GTK_BIN (obj)));
- GtkEntryBuffer *buffer = gtk_entry_get_buffer (entry);
-
obj->show_value_label = true;
obj->val_labs = NULL;
obj->format = F_8_0;
obj->encoding = NULL;
obj->cur_value = NULL;
- gtk_combo_box_entry_set_text_column (GTK_COMBO_BOX_ENTRY (obj), COL_LABEL);
-
- g_signal_connect (buffer, "notify::text",
- G_CALLBACK (psppire_value_entry_text_changed), obj);
}
static void
GtkWidget *
psppire_value_entry_new (void)
{
- return GTK_WIDGET (g_object_new (PSPPIRE_TYPE_VALUE_ENTRY, NULL));
+ return GTK_WIDGET (g_object_new (PSPPIRE_TYPE_VALUE_ENTRY, "has-entry", TRUE, NULL));
}
static void
#include <gtk/gtk.h>
#include "data/format.h"
-/* PsppireValueEntry is a subclass of GtkComboBoxEntry that is specialized for
+/* PsppireValueEntry is a subclass of GtkComboBox that is specialized for
displaying and entering "union value"s. Its main advantage over a plain
GtkEntry is that, when value labels are supplied, it (optionally) displays
the value label instead of the value. It also allows the user to choose a
struct _PsppireValueEntry
{
- GtkComboBoxEntry parent;
+ GtkComboBox parent;
gboolean show_value_label;
struct _PsppireValueEntryClass
{
- GtkComboBoxEntryClass parent_class;
+ GtkComboBoxClass parent_class;
};
GType psppire_value_entry_get_type (void);
GtkAllocation *allocation);
-static const GtkButtonBoxStyle default_layout_style = GTK_BUTTONBOX_EDGE;
+static void
+psppire_vbutton_box_get_preferred_height (GtkWidget *widget,
+ gint *minimal_height,
+ gint *natural_height)
+{
+ GtkRequisition requisition;
+
+ gtk_vbutton_box_size_request (widget, &requisition);
+
+ *minimal_height = *natural_height = requisition.height;
+}
+
+
+static void
+psppire_vbutton_box_get_preferred_width (GtkWidget *widget,
+ gint *minimal_width,
+ gint *natural_width)
+{
+ GtkRequisition requisition;
+
+ gtk_vbutton_box_size_request (widget, &requisition);
+
+ *minimal_width = *natural_width = requisition.width;
+}
+
GType
psppire_vbutton_box_get_type (void)
widget_class = (GtkWidgetClass*) class;
- widget_class->size_request = gtk_vbutton_box_size_request;
+ widget_class->get_preferred_width = psppire_vbutton_box_get_preferred_width;
+ widget_class->get_preferred_height = psppire_vbutton_box_get_preferred_height;
widget_class->size_allocate = gtk_vbutton_box_size_allocate;
}
box = GTK_BOX (widget);
bbox = GTK_BUTTON_BOX (widget);
- spacing = box->spacing;
- layout = bbox->layout_style != GTK_BUTTONBOX_DEFAULT_STYLE
- ? bbox->layout_style : default_layout_style;
+ spacing = gtk_box_get_spacing (box);
+ layout = gtk_button_box_get_layout (bbox);
_psppire_button_box_child_requisition (widget,
&nvis_children,
case GTK_BUTTONBOX_EDGE:
case GTK_BUTTONBOX_START:
case GTK_BUTTONBOX_END:
+ default:
requisition->height =
nvis_children*child_height + ((nvis_children-1)*spacing);
break;
- default:
- g_assert_not_reached();
- break;
}
requisition->width = child_width;
}
- requisition->width += GTK_CONTAINER (box)->border_width * 2;
- requisition->height += GTK_CONTAINER (box)->border_width * 2;
+ requisition->width += gtk_container_get_border_width (GTK_CONTAINER (box)) * 2;
+ requisition->height += gtk_container_get_border_width (GTK_CONTAINER (box)) * 2;
}
base_box = GTK_BOX (widget);
box = GTK_BUTTON_BOX (widget);
- spacing = base_box->spacing;
- layout = box->layout_style != GTK_BUTTONBOX_DEFAULT_STYLE
- ? box->layout_style : default_layout_style;
+ spacing = gtk_box_get_spacing (base_box);
+ layout = gtk_button_box_get_layout (box) ;
_psppire_button_box_child_requisition (widget,
&nvis_children,
&n_secondaries,
&child_width,
&child_height);
- widget->allocation = *allocation;
- height = allocation->height - GTK_CONTAINER (box)->border_width*2;
+ gtk_widget_set_allocation (widget, allocation);
+ height = allocation->height - gtk_container_get_border_width (GTK_CONTAINER (box))*2;
switch (layout)
{
case GTK_BUTTONBOX_SPREAD:
childspacing = (height - (nvis_children * child_height)) / (nvis_children + 1);
- y = allocation->y + GTK_CONTAINER (box)->border_width + childspacing;
+ y = allocation->y + gtk_container_get_border_width (GTK_CONTAINER (box)) + childspacing;
secondary_y = y + ((nvis_children - n_secondaries) * (child_height + childspacing));
break;
case GTK_BUTTONBOX_EDGE:
+ default:
if (nvis_children >= 2)
{
childspacing = (height - (nvis_children*child_height)) / (nvis_children-1);
- y = allocation->y + GTK_CONTAINER (box)->border_width;
+ y = allocation->y + gtk_container_get_border_width (GTK_CONTAINER (box));
secondary_y = y + ((nvis_children - n_secondaries) * (child_height + childspacing));
}
else
break;
case GTK_BUTTONBOX_START:
childspacing = spacing;
- y = allocation->y + GTK_CONTAINER (box)->border_width;
+ y = allocation->y + gtk_container_get_border_width (GTK_CONTAINER (box));
secondary_y = allocation->y + allocation->height
- child_height * n_secondaries
- spacing * (n_secondaries - 1)
- - GTK_CONTAINER (box)->border_width;
+ - gtk_container_get_border_width (GTK_CONTAINER (box));
break;
case GTK_BUTTONBOX_END:
childspacing = spacing;
y = allocation->y + allocation->height
- child_height * (nvis_children - n_secondaries)
- spacing * (nvis_children - n_secondaries - 1)
- - GTK_CONTAINER (box)->border_width;
- secondary_y = allocation->y + GTK_CONTAINER (box)->border_width;
- break;
- default:
- g_assert_not_reached();
+ - gtk_container_get_border_width (GTK_CONTAINER (box));
+ secondary_y = allocation->y + gtk_container_get_border_width (GTK_CONTAINER (box));
break;
}
static void
menu_toggled (GtkCheckMenuItem *mi, gpointer data)
{
+#if GTK3_TRANSITION
/* Prohibit changes to the state */
mi->active = !mi->active;
+#endif
}
gtk_menu_shell_append (window->menu, item);
+#if GTK3_TRANSITION
/* Set the state without emitting a signal */
GTK_CHECK_MENU_ITEM (item)->active =
(psppire_window_register_lookup (psppire_window_register_new (), key) == window);
+#endif
g_hash_table_insert (window->menuitem_table, key, item);
}
</child>
<child>
<object class="PsppireValueEntry" id="entry2">
+ <property name="has-entry">True</property>
<property name="visible">True</property>
<property name="can_focus">True</property>
</object>
tm = psppire_spreadsheet_model_new (stuff.sp);
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
- hbox = gtk_hbox_new (FALSE, 5);
- vbox = gtk_vbox_new (FALSE, 5);
+ hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 5);
+ vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
button = gtk_button_new_with_label ("Test reader");
g_signal_connect (button, "clicked", G_CALLBACK (on_clicked), &stuff);
</object>
<object class="GtkStatusbar" id="statusbar2">
<property name="visible">True</property>
- <property name="has_resize_grip">True</property>
</object>
</interface>
GtkWidget *widget = GTK_WIDGET (ia->asst.assistant);
GdkDisplay *display = gtk_widget_get_display (widget);
GdkCursor *cursor = gdk_cursor_new_for_display (display, GDK_WATCH);
- gdk_window_set_cursor (widget->window, cursor);
+ gdk_window_set_cursor (gtk_widget_get_window (widget), cursor);
gdk_cursor_unref (cursor);
gdk_display_flush (display);
}
if (--ia->asst.watch_cursor == 0)
{
GtkWidget *widget = GTK_WIDGET (ia->asst.assistant);
- gdk_window_set_cursor (widget->window, NULL);
+ gdk_window_set_cursor (gtk_widget_get_window (widget), NULL);
}
}
</packing>
</child>
<child>
- <object class="GtkComboBoxEntry" id="quote-combo">
+ <object class="GtkComboBox" id="quote-combo">
+ <property name="has-entry">True</property>
<property name="visible">True</property>
<property name="events">GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK</property>
<property name="has_frame">False</property>