X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Fui%2Fgui%2Fpspp-sheet-view.c;h=65b15fe574e937d588d74b90f167373ff1d4801c;hb=becb33bfd4e8a9599c45d8bd086d522aa364a83a;hp=c32619346cb18deb544ba597268ed7b7d6b9e536;hpb=a6a3f95261f5d91832956bf2cc360f99caeffc16;p=pspp diff --git a/src/ui/gui/pspp-sheet-view.c b/src/ui/gui/pspp-sheet-view.c index c32619346c..65b15fe574 100644 --- a/src/ui/gui/pspp-sheet-view.c +++ b/src/ui/gui/pspp-sheet-view.c @@ -1,5 +1,5 @@ /* PSPPIRE - a graphical user interface for PSPP. - Copyright (C) 2011, 2012, 2013 Free Software Foundation, Inc. + Copyright (C) 2011, 2012, 2013, 2015 Free Software Foundation, Inc. This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -93,10 +93,8 @@ typedef struct _PsppSheetViewChild PsppSheetViewChild; struct _PsppSheetViewChild { GtkWidget *widget; - gint x; - gint y; - gint width; - gint height; + PsppSheetViewColumn *column; + int node; }; @@ -135,6 +133,8 @@ enum { PROP_MODEL, PROP_HADJUSTMENT, PROP_VADJUSTMENT, + PROP_HSCROLL_POLICY, + PROP_VSCROLL_POLICY, PROP_HEADERS_VISIBLE, PROP_HEADERS_CLICKABLE, PROP_REORDERABLE, @@ -171,8 +171,8 @@ static void pspp_sheet_view_size_request (GtkWidget *widget, 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, @@ -197,8 +197,7 @@ static gint pspp_sheet_view_focus_out (GtkWidget *widget, static gint pspp_sheet_view_focus (GtkWidget *widget, GtkDirectionType direction); static void pspp_sheet_view_grab_focus (GtkWidget *widget); -static void pspp_sheet_view_style_set (GtkWidget *widget, - GtkStyle *previous_style); +static void pspp_sheet_view_style_updated (GtkWidget *widget); static void pspp_sheet_view_grab_notify (GtkWidget *widget, gboolean was_grabbed); static void pspp_sheet_view_state_changed (GtkWidget *widget, @@ -295,6 +294,12 @@ static void pspp_sheet_view_top_row_to_dy (PsppSheetView *tree_view); 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, @@ -395,10 +400,8 @@ static void pspp_sheet_view_search_init (GtkWidget *ent PsppSheetView *tree_view); static void pspp_sheet_view_put (PsppSheetView *tree_view, GtkWidget *child_widget, - gint x, - gint y, - gint width, - gint height); + GtkTreePath *path, + PsppSheetViewColumn *column); static gboolean pspp_sheet_view_start_editing (PsppSheetView *tree_view, GtkTreePath *cursor_path); static gboolean pspp_sheet_view_editable_button_press_event (GtkWidget *, @@ -451,7 +454,32 @@ static GtkBindingSet *edit_bindings; 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) @@ -481,14 +509,15 @@ 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; @@ -504,7 +533,7 @@ pspp_sheet_view_class_init (PsppSheetViewClass *class) widget_class->drag_data_received = pspp_sheet_view_drag_data_received; widget_class->focus = pspp_sheet_view_focus; widget_class->grab_focus = pspp_sheet_view_grab_focus; - widget_class->style_set = pspp_sheet_view_style_set; + widget_class->style_updated = pspp_sheet_view_style_updated; widget_class->grab_notify = pspp_sheet_view_grab_notify; widget_class->state_changed = pspp_sheet_view_state_changed; @@ -531,21 +560,10 @@ pspp_sheet_view_class_init (PsppSheetViewClass *class) 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, @@ -754,6 +772,7 @@ pspp_sheet_view_class_init (PsppSheetViewClass *class) GTK_PARAM_READABLE)); /* Signals */ +#if GTK3_TRANSITION /** * PsppSheetView::set-scroll-adjustments * @horizontal: the horizontal #GtkAdjustment @@ -773,6 +792,7 @@ pspp_sheet_view_class_init (PsppSheetViewClass *class) G_TYPE_NONE, 2, GTK_TYPE_ADJUSTMENT, GTK_TYPE_ADJUSTMENT); +#endif /** * PsppSheetView::row-activated: @@ -1094,6 +1114,11 @@ pspp_sheet_view_init (PsppSheetView *tree_view) 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); + gtk_style_context_add_class (gtk_widget_get_style_context (GTK_WIDGET (tree_view)), + GTK_STYLE_CLASS_VIEW); } @@ -1117,12 +1142,20 @@ pspp_sheet_view_set_property (GObject *object, 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: @@ -1205,6 +1238,12 @@ pspp_sheet_view_get_property (GObject *object, 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; @@ -1459,15 +1498,14 @@ pspp_sheet_view_realize (GtkWidget *widget) { PsppSheetView *tree_view = PSPP_SHEET_VIEW (widget); GList *tmp_list; + GdkWindow *window; 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; @@ -1477,21 +1515,22 @@ pspp_sheet_view_realize (GtkWidget *widget) 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; + + window = gdk_window_new (gtk_widget_get_parent_window (widget), + &attributes, attributes_mask); + gtk_widget_set_window (widget, window); - 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); + gtk_widget_register_window (widget, window); + gtk_widget_get_allocation (widget, &allocation); /* Make the window for the tree */ attributes.x = 0; attributes.y = TREE_VIEW_HEADER_HEIGHT (tree_view); - attributes.width = MAX (tree_view->priv->width, old_allocation.width); - attributes.height = old_allocation.height; + attributes.width = MAX (tree_view->priv->width, allocation.width); + attributes.height = allocation.height; attributes.event_mask = (GDK_EXPOSURE_MASK | GDK_SCROLL_MASK | GDK_POINTER_MOTION_MASK | @@ -1501,14 +1540,15 @@ pspp_sheet_view_realize (GtkWidget *widget) GDK_BUTTON_RELEASE_MASK | gtk_widget_get_events (widget)); - tree_view->priv->bin_window = gdk_window_new (gtk_widget_get_window (widget), + tree_view->priv->bin_window = gdk_window_new (window, &attributes, attributes_mask); - gdk_window_set_user_data (tree_view->priv->bin_window, widget); + gtk_widget_register_window (widget, tree_view->priv->bin_window); + gtk_widget_get_allocation (widget, &allocation); /* Make the column header window */ attributes.x = 0; attributes.y = 0; - attributes.width = MAX (tree_view->priv->width, old_allocation.width); + attributes.width = MAX (tree_view->priv->width, allocation.width); attributes.height = tree_view->priv->header_height; attributes.event_mask = (GDK_EXPOSURE_MASK | GDK_SCROLL_MASK | @@ -1518,16 +1558,18 @@ pspp_sheet_view_realize (GtkWidget *widget) GDK_KEY_RELEASE_MASK | gtk_widget_get_events (widget)); - tree_view->priv->header_window = gdk_window_new (gtk_widget_get_window (widget), + tree_view->priv->header_window = gdk_window_new (window, &attributes, attributes_mask); - gdk_window_set_user_data (tree_view->priv->header_window, widget); + gtk_widget_register_window (widget, tree_view->priv->header_window); - /* Add them all up. */ - gtk_widget_set_style (widget, - gtk_style_attach (gtk_widget_get_style (widget), gtk_widget_get_window (widget))); - gdk_window_set_back_pixmap (gtk_widget_get_window (widget), NULL, FALSE); - 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); + { /* Ensure Background */ + GtkStyleContext *context; + + context = gtk_widget_get_style_context (GTK_WIDGET (tree_view)); + + gtk_style_context_set_background (context, gtk_widget_get_window (GTK_WIDGET (tree_view))); + gtk_style_context_set_background (context, tree_view->priv->header_window); + } tmp_list = tree_view->priv->children; while (tmp_list) @@ -1728,7 +1770,9 @@ pspp_sheet_view_size_request (GtkWidget *widget, tmp_list = tmp_list->next; if (gtk_widget_get_visible (child->widget)) - gtk_widget_size_request (child->widget, &child_requisition); + { + gtk_widget_get_preferred_size (child->widget, NULL, &child_requisition); + } } } @@ -1939,12 +1983,6 @@ pspp_sheet_view_size_allocate_columns (GtkWidget *widget, pspp_sheet_view_column_size_allocate (column, &col_allocation); - 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, col_allocation.x + (rtl ? 0 : col_allocation.width) - TREE_VIEW_DRAG_WIDTH/2, @@ -1963,6 +2001,24 @@ pspp_sheet_view_size_allocate_columns (GtkWidget *widget, gtk_widget_queue_draw (GTK_WIDGET (tree_view)); } +static void +update_childrens_allocation (PsppSheetView *tree_view) +{ + GList *tmp_list; + for (tmp_list = tree_view->priv->children; tmp_list; tmp_list = tmp_list->next) + { + PsppSheetViewChild *child = tmp_list->data; + GtkAllocation allocation; + GtkTreePath *path; + + /* totally ignore our child's requisition */ + path = _pspp_sheet_view_find_path (tree_view, child->node); + pspp_sheet_view_get_cell_area (tree_view, path, child->column, &allocation); + gtk_tree_path_free (path); + gtk_widget_size_allocate (child->widget, &allocation); + } +} + static void pspp_sheet_view_size_allocate (GtkWidget *widget, GtkAllocation *allocation) @@ -1976,26 +2032,11 @@ pspp_sheet_view_size_allocate (GtkWidget *widget, if (allocation->width != old_allocation.width) width_changed = TRUE; + if (gtk_widget_get_direction(widget) == GTK_TEXT_DIR_RTL) + allocation->x += allocation->width - tree_view->priv->width ; gtk_widget_set_allocation (widget, allocation); - tmp_list = tree_view->priv->children; - - while (tmp_list) - { - GtkAllocation allocation; - - PsppSheetViewChild *child = tmp_list->data; - tmp_list = tmp_list->next; - - /* totally ignore our child's requisition */ - allocation.x = child->x; - allocation.y = child->y; - allocation.width = child->width; - allocation.height = child->height; - gtk_widget_size_allocate (child->widget, &allocation); - } - /* We size-allocate the columns first because the width of the * tree view (used in updating the adjustments below) might change. */ @@ -2095,6 +2136,7 @@ pspp_sheet_view_size_allocate (GtkWidget *widget, else gtk_widget_queue_draw (widget); } + update_childrens_allocation(tree_view); } } @@ -2527,11 +2569,14 @@ pspp_sheet_view_button_press (GtkWidget *widget, { gpointer drag_data; - if (gdk_pointer_grab (column->window, FALSE, - GDK_POINTER_MOTION_HINT_MASK | - GDK_BUTTON1_MOTION_MASK | - GDK_BUTTON_RELEASE_MASK, - NULL, NULL, event->time)) + if (GDK_GRAB_SUCCESS != gdk_device_grab (event->device, + column->window, + GDK_OWNERSHIP_NONE, + FALSE, + GDK_POINTER_MOTION_HINT_MASK | + GDK_BUTTON1_MOTION_MASK | + GDK_BUTTON_RELEASE_MASK, + NULL, event->time)) return FALSE; gtk_grab_add (widget); @@ -2647,8 +2692,8 @@ pspp_sheet_view_button_release_column_resize (GtkWidget *widget, PSPP_SHEET_VIEW_UNSET_FLAG (tree_view, PSPP_SHEET_VIEW_IN_COLUMN_RESIZE); gtk_grab_remove (widget); - gdk_display_pointer_ungrab (gdk_window_get_display (event->window), - event->time); + gdk_device_ungrab (event->device, event->time); + return TRUE; } @@ -3525,14 +3570,16 @@ pspp_sheet_view_update_rubber_band_selection (PsppSheetView *tree_view) 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); @@ -3550,13 +3597,14 @@ pspp_sheet_view_update_rubber_band (PsppSheetView *tree_view) 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; @@ -3564,15 +3612,26 @@ pspp_sheet_view_update_rubber_band (PsppSheetView *tree_view) 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; @@ -3588,6 +3647,7 @@ pspp_sheet_view_update_rubber_band (PsppSheetView *tree_view) 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) @@ -3632,6 +3692,8 @@ pspp_sheet_view_paint_rubber_band (PsppSheetView *tree_view, cairo_destroy (cr); } +#endif + static gboolean pspp_sheet_view_motion_bin_window (GtkWidget *widget, @@ -3733,10 +3795,11 @@ invalidate_empty_focus (PsppSheetView *tree_view) * 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; @@ -3749,63 +3812,51 @@ draw_empty_focus (PsppSheetView *tree_view, GdkRectangle *clip_area) 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_vertical_grid_lines (PsppSheetView *tree_view, - GdkEventExpose *event, - gint n_visible_columns, - gint min_y, - gint max_y) + 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 x = 0; if (tree_view->priv->grid_lines != PSPP_SHEET_VIEW_GRID_LINES_VERTICAL && tree_view->priv->grid_lines != PSPP_SHEET_VIEW_GRID_LINES_BOTH) return; /* Only draw the lines for visible rows and columns */ - for (list = tree_view->priv->columns; list; list = list->next, i++) + gboolean rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL); + + for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns)); + list; + list = (rtl ? list->prev : list->next)) { PsppSheetViewColumn *column = list->data; - /* We don't want a line for the last column */ - if (i == n_visible_columns - 1) - break; - if (! column->visible) continue; - current_x += column->width; + if (!rtl) + x += column->width; - if (current_x - 1 >= event->area.x - && current_x - 1 < event->area.x + event->area.width) - { -#if GTK3_TRANSITION - gdk_draw_line (event->window, - tree_view->priv->grid_line_gc[GTK_WIDGET(tree_view)->state], - current_x - 1, min_y, - current_x - 1, max_y - min_y); -#else + 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 - 0.5); + cairo_stroke (cr); - cairo_t *cr = gdk_cairo_create (event->window); - cairo_set_line_width (cr, 1.0); - cairo_set_line_cap (cr, CAIRO_LINE_CAP_SQUARE); - cairo_move_to (cr, current_x - 0.5, min_y); - cairo_line_to (cr, current_x - 0.5 , max_y - min_y); - - cairo_stroke (cr); - cairo_destroy (cr); -#endif - } + if (rtl) + x += column->width; } } @@ -3815,9 +3866,9 @@ pspp_sheet_view_draw_vertical_grid_lines (PsppSheetView *tree_view, * KEEP IN SYNC WITH pspp_sheet_view_create_row_drag_icon()! * FIXME: It's not... */ -static gboolean -pspp_sheet_view_bin_expose (GtkWidget *widget, - GdkEventExpose *event) +static void +pspp_sheet_view_draw_bin (GtkWidget *widget, + cairo_t *cr) { PsppSheetView *tree_view = PSPP_SHEET_VIEW (widget); GtkTreePath *path; @@ -3841,13 +3892,25 @@ pspp_sheet_view_bin_expose (GtkWidget *widget, gint horizontal_separator; gint focus_line_width; gboolean allow_rules; - gboolean has_special_cell; gboolean rtl; gint n_visible_columns; gint grid_line_width; gboolean row_ending_details; gboolean draw_vgrid_lines, draw_hgrid_lines; gint min_y, max_y; + GtkStyleContext *context; + context = gtk_widget_get_style_context (widget); + + GdkRectangle Zarea; + GtkAllocation allocation; + gtk_widget_get_allocation (widget, &allocation); + + GdkRectangle exposed_rect; + gdk_cairo_get_clip_rectangle (cr, &exposed_rect); + + Zarea.x = 0; + Zarea.y = 0; + Zarea.height = allocation.height; rtl = (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL); @@ -3861,17 +3924,19 @@ pspp_sheet_view_bin_expose (GtkWidget *widget, if (tree_view->priv->row_count == 0) { - draw_empty_focus (tree_view, &event->area); - return TRUE; + draw_empty_focus (tree_view); + return; } +#if GTK3_TRANSITION /* clip event->area to the visible area */ - if (event->area.height < 0.5) - return TRUE; + if (Zarea.height < 0.5) + return; +#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; @@ -3886,10 +3951,9 @@ pspp_sheet_view_bin_expose (GtkWidget *widget, if (tree_view->priv->height < bin_window_height) { gtk_paint_flat_box (gtk_widget_get_style (widget), - event->window, + cr, gtk_widget_get_state (widget), GTK_SHADOW_NONE, - &event->area, widget, "cell_even", 0, tree_view->priv->height, @@ -3898,7 +3962,7 @@ pspp_sheet_view_bin_expose (GtkWidget *widget, } if (node < 0) - return TRUE; + return; /* find the path for the node */ path = _pspp_sheet_view_find_path ((PsppSheetView *)widget, node); @@ -3971,7 +4035,7 @@ pspp_sheet_view_bin_expose (GtkWidget *widget, 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; @@ -3984,27 +4048,6 @@ pspp_sheet_view_bin_expose (GtkWidget *widget, parity = node % 2; - if (tree_view->priv->special_cells == PSPP_SHEET_VIEW_SPECIAL_CELLS_DETECT) - { - /* we *need* to set cell data on all cells before the call - * to _has_special_cell, else _has_special_cell() does not - * return a correct value. - */ - for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns)); - list; - list = (rtl ? list->prev : list->next)) - { - PsppSheetViewColumn *column = list->data; - pspp_sheet_view_column_cell_set_cell_data (column, - tree_view->priv->model, - &iter); - } - - has_special_cell = pspp_sheet_view_has_special_cell (tree_view); - } - else - has_special_cell = tree_view->priv->special_cells == PSPP_SHEET_VIEW_SPECIAL_CELLS_YES; - for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns)); list; list = (rtl ? list->prev : list->next)) @@ -4022,12 +4065,14 @@ pspp_sheet_view_bin_expose (GtkWidget *widget, 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; @@ -4077,12 +4122,17 @@ pspp_sheet_view_bin_expose (GtkWidget *widget, cell_area.height -= grid_line_width; } +#if GTK3_TRANSITION if (gdk_region_rect_in (event->region, &background_area) == GDK_OVERLAP_RECTANGLE_OUT) +#else + if (!gdk_rectangle_intersect (&background_area, &exposed_rect, NULL)) +#endif { cell_offset += column->width; continue; } + pspp_sheet_view_column_cell_set_cell_data (column, tree_view->priv->model, &iter); @@ -4130,63 +4180,27 @@ pspp_sheet_view_bin_expose (GtkWidget *widget, g_assert (detail); - 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 - state = GTK_STATE_NORMAL; + gtk_style_context_save (context); + state = gtk_cell_renderer_get_state (NULL, widget, flags); + gtk_style_context_set_state (context, state); + gtk_style_context_add_class (context, GTK_STYLE_CLASS_CELL); /* Draw background */ - if (row_ending_details) - { - char new_detail[128]; - - is_first = (rtl ? !list->next : !list->prev); - is_last = (rtl ? !list->prev : !list->next); - - /* (I don't like the snprintfs either, but couldn't find a - * less messy way). - */ - if (is_first && is_last) - g_snprintf (new_detail, 127, "%s", detail); - else if (is_first) - g_snprintf (new_detail, 127, "%s_start", detail); - else if (is_last) - g_snprintf (new_detail, 127, "%s_end", detail); - else - g_snprintf (new_detail, 128, "%s_middle", detail); - - gtk_paint_flat_box (gtk_widget_get_style (widget), - event->window, - state, - GTK_SHADOW_NONE, - &event->area, - widget, - new_detail, - background_area.x, - background_area.y, - background_area.width, - background_area.height); - } - else - { - gtk_paint_flat_box (gtk_widget_get_style (widget), - event->window, - state, - GTK_SHADOW_NONE, - &event->area, - widget, - detail, - background_area.x, - background_area.y, - background_area.width, - background_area.height); - } + gtk_render_background (context, cr, + background_area.x, + background_area.y, + background_area.width, + background_area.height); + + /* Draw frame */ + gtk_render_frame (context, cr, + background_area.x, + background_area.y, + background_area.width, + background_area.height); if (draw_hgrid_lines) { - cairo_t *cr = gdk_cairo_create (event->window); cairo_set_line_width (cr, 1.0); cairo_set_line_cap (cr, CAIRO_LINE_CAP_SQUARE); @@ -4205,7 +4219,7 @@ pspp_sheet_view_bin_expose (GtkWidget *widget, #endif } - if (y_offset + max_height >= event->area.height - 0.5) + if (y_offset + max_height <= Zarea.height - 0.5) { #if GTK3_TRANSITION gdk_draw_line (event->window, @@ -4221,48 +4235,19 @@ pspp_sheet_view_bin_expose (GtkWidget *widget, #endif } cairo_stroke (cr); - cairo_destroy (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->focus_column && - PSPP_SHEET_VIEW_FLAG_SET (tree_view, PSPP_SHEET_VIEW_DRAW_KEYFOCUS) && - gtk_widget_has_focus (widget)) || - (column == tree_view->priv->edited_column))) - { - _pspp_sheet_view_column_cell_draw_focus (column, - event->window, - &background_area, - &cell_area, - &event->area, - flags); - } cell_offset += column->width; + gtk_style_context_restore (context); } - if (cell_offset < event->area.x) - { - gtk_paint_flat_box (gtk_widget_get_style (widget), - event->window, - GTK_STATE_NORMAL, - GTK_SHADOW_NONE, - &event->area, - widget, - "base", - cell_offset, - background_area.y, - event->area.x - cell_offset, - background_area.height); - } - if (node == drag_highlight) { /* Draw indicator for the drop @@ -4293,9 +4278,8 @@ pspp_sheet_view_bin_expose (GtkWidget *widget, if (row_ending_details) gtk_paint_focus (gtk_widget_get_style (widget), - tree_view->priv->bin_window, + cr, gtk_widget_get_state (widget), - &event->area, widget, (is_first ? (is_last ? "treeview-drop-indicator" : "treeview-drop-indicator-left" ) @@ -4306,9 +4290,8 @@ pspp_sheet_view_bin_expose (GtkWidget *widget, - focus_line_width + 1); else gtk_paint_focus (gtk_widget_get_style (widget), - tree_view->priv->bin_window, + cr, gtk_widget_get_state (widget), - &event->area, widget, "treeview-drop-indicator", 0, BACKGROUND_FIRST_PIXEL (tree_view, node) @@ -4331,56 +4314,6 @@ pspp_sheet_view_bin_expose (GtkWidget *widget, #endif } - /* draw the big row-spanning focus rectangle, if needed */ - if (!has_special_cell && node == cursor && - PSPP_SHEET_VIEW_FLAG_SET (tree_view, PSPP_SHEET_VIEW_DRAW_KEYFOCUS) && - gtk_widget_has_focus (widget)) - { - gint tmp_y, tmp_height; - gint width; - GtkStateType focus_rect_state; - - focus_rect_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)); - - width = gdk_window_get_width (tree_view->priv->bin_window); - - if (draw_hgrid_lines) - { - tmp_y = BACKGROUND_FIRST_PIXEL (tree_view, node) + grid_line_width / 2; - tmp_height = ROW_HEIGHT (tree_view) - grid_line_width; - } - else - { - tmp_y = BACKGROUND_FIRST_PIXEL (tree_view, node); - tmp_height = ROW_HEIGHT (tree_view); - } - - if (row_ending_details) - gtk_paint_focus (gtk_widget_get_style (widget), - tree_view->priv->bin_window, - focus_rect_state, - &event->area, - widget, - (is_first - ? (is_last ? "treeview" : "treeview-left" ) - : (is_last ? "treeview-right" : "treeview-middle" )), - 0, tmp_y, - width, tmp_height); - else - gtk_paint_focus (gtk_widget_get_style (widget), - tree_view->priv->bin_window, - focus_rect_state, - &event->area, - widget, - "treeview", - 0, tmp_y, - width, tmp_height); - } - y_offset += max_height; do @@ -4392,19 +4325,20 @@ pspp_sheet_view_bin_expose (GtkWidget *widget, done = TRUE; /* Sanity Check! */ - TREE_VIEW_INTERNAL_ASSERT (has_next, FALSE); + TREE_VIEW_INTERNAL_ASSERT_VOID (has_next); } else goto done; } while (!done); } - while (y_offset < event->area.height); + while (y_offset < Zarea.height); done: - pspp_sheet_view_draw_vertical_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; @@ -4419,6 +4353,7 @@ done: g_free (rectangles); } +#endif if (cursor_path) gtk_tree_path_free (cursor_path); @@ -4426,21 +4361,27 @@ done: if (drag_dest_path) gtk_tree_path_free (drag_dest_path); - return FALSE; + return; } + 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); + GtkStyleContext *context; - if (event->window == tree_view->priv->bin_window) + context = gtk_widget_get_style_context (widget); + + 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); + gtk_cairo_transform_to_window(cr,widget,tree_view->priv->bin_window); + pspp_sheet_view_draw_bin (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 @@ -4452,28 +4393,25 @@ pspp_sheet_view_expose (GtkWidget *widget, PsppSheetViewChild *child = tmp_list->data; tmp_list = tmp_list->next; - gtk_container_propagate_expose (GTK_CONTAINER (tree_view), child->widget, event); - } - - return retval; + gtk_container_propagate_draw (GTK_CONTAINER (tree_view), child->widget, cr); + } + } + else + { + gtk_render_background (context, cr, + 0, 0, + gtk_widget_get_allocated_width (widget), + gtk_widget_get_allocated_height (widget)); } - else if (event->window == tree_view->priv->header_window) + + gtk_style_context_save (context); + gtk_style_context_remove_class (context, GTK_STYLE_CLASS_VIEW); + + if (gtk_cairo_should_draw_window (cr, tree_view->priv->header_window)) { gint n_visible_columns; GList *list; - gtk_paint_flat_box (gtk_widget_get_style (widget), - event->window, - GTK_STATE_NORMAL, - GTK_SHADOW_NONE, - &event->area, - widget, - "cell_odd", - event->area.x, - event->area.y, - event->area.width, - event->area.height); - for (list = tree_view->priv->columns; list != NULL; list = list->next) { PsppSheetViewColumn *column = list->data; @@ -4482,10 +4420,11 @@ pspp_sheet_view_expose (GtkWidget *widget, continue; if (span_intersects (column->allocation.x, column->allocation.width, - event->area.x, event->area.width) + (int) gtk_adjustment_get_value (tree_view->priv->hadjustment), + (int) gtk_widget_get_allocated_width (widget)) && 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; @@ -4495,19 +4434,25 @@ pspp_sheet_view_expose (GtkWidget *widget, continue; n_visible_columns ++; } + cairo_save (cr); + gtk_cairo_transform_to_window(cr,widget,tree_view->priv->header_window); pspp_sheet_view_draw_vertical_grid_lines (tree_view, - event, - n_visible_columns, - event->area.y, - event->area.height); + cr, + n_visible_columns, + 0, + TREE_VIEW_HEADER_HEIGHT (tree_view)); + cairo_restore (cr); } - else if (event->window == tree_view->priv->drag_window) + if (tree_view->priv->drag_window && + 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; + + gtk_style_context_restore (context); + return FALSE; } enum @@ -5184,7 +5129,6 @@ validate_visible_area (PsppSheetView *tree_view) GtkTreePath *above_path = NULL; GtkTreeIter iter; int node = -1; - gboolean size_changed = FALSE; gint total_height; gint area_above = 0; gint area_below = 0; @@ -5358,23 +5302,6 @@ validate_visible_area (PsppSheetView *tree_view) pspp_sheet_view_set_top_row (tree_view, above_path, -area_above); pspp_sheet_view_top_row_to_dy (tree_view); - /* update width/height and queue a resize */ - if (size_changed) - { - GtkRequisition requisition; - - /* We temporarily guess a size, under the assumption that it will be the - * same when we get our next size_allocate. If we don't do this, we'll be - * in an inconsistent state if we call top_row_to_dy. */ - - gtk_widget_size_request (GTK_WIDGET (tree_view), &requisition); - 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_tree_row_reference_free (tree_view->priv->scroll_to_path); tree_view->priv->scroll_to_path = NULL; @@ -5445,7 +5372,7 @@ do_presize_handler (PsppSheetView *tree_view) if (! gtk_widget_get_realized (GTK_WIDGET (tree_view))) return FALSE; - gtk_widget_size_request (GTK_WIDGET (tree_view), &requisition); + gtk_widget_get_preferred_size (GTK_WIDGET (tree_view), NULL, &requisition); 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)); @@ -6661,13 +6588,6 @@ pspp_sheet_view_focus_column (PsppSheetView *tree_view, g_return_if_fail (focus_column != NULL); tree_view->priv->focus_column = focus_column; - if (!focus_column->button) - { - pspp_sheet_view_column_set_need_button (focus_column, TRUE); - // g_return_if_fail (focus_column->button != NULL); - if (focus_column->button == NULL) - return; - } if (gtk_container_get_focus_child (GTK_CONTAINER (tree_view)) != focus_column->button) gtk_widget_grab_focus (focus_column->button); @@ -6798,7 +6718,6 @@ pspp_sheet_view_header_focus (PsppSheetView *tree_view, if (column->visible && pspp_sheet_view_column_can_focus (column)) { - pspp_sheet_view_column_set_need_button (column, TRUE); if (column->button) { pspp_sheet_view_focus_column (tree_view, column, @@ -6909,18 +6828,20 @@ pspp_sheet_view_grab_focus (GtkWidget *widget) } static void -pspp_sheet_view_style_set (GtkWidget *widget, - GtkStyle *previous_style) +pspp_sheet_view_style_updated (GtkWidget *widget) { PsppSheetView *tree_view = PSPP_SHEET_VIEW (widget); GList *list; PsppSheetViewColumn *column; + GtkStyleContext *context; + + GTK_WIDGET_CLASS (pspp_sheet_view_parent_class)->style_updated (widget); if (gtk_widget_get_realized (widget)) { - gdk_window_set_back_pixmap (gtk_widget_get_window (widget), NULL, FALSE); - 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); + context = gtk_widget_get_style_context (GTK_WIDGET (tree_view)); + gtk_style_context_set_background (context, gtk_widget_get_window (GTK_WIDGET (tree_view))); + gtk_style_context_set_background (context, tree_view->priv->header_window); pspp_sheet_view_set_grid_lines (tree_view, tree_view->priv->grid_lines); } @@ -7092,12 +7013,9 @@ pspp_sheet_view_real_move_cursor (PsppSheetView *tree_view, static void pspp_sheet_view_put (PsppSheetView *tree_view, - GtkWidget *child_widget, - /* in bin_window coordinates */ - gint x, - gint y, - gint width, - gint height) + GtkWidget *child_widget, + GtkTreePath *path, + PsppSheetViewColumn *column) { PsppSheetViewChild *child; @@ -7107,10 +7025,12 @@ pspp_sheet_view_put (PsppSheetView *tree_view, child = g_slice_new (PsppSheetViewChild); child->widget = child_widget; - child->x = x; - child->y = y; - child->width = width; - child->height = height; + _pspp_sheet_view_find_node (tree_view, path, &child->node); + if (child->node < 0) + { + g_assert_not_reached (); + } + child->column = column; tree_view->priv->children = g_list_append (tree_view->priv->children, child); @@ -7120,43 +7040,6 @@ pspp_sheet_view_put (PsppSheetView *tree_view, gtk_widget_set_parent (child_widget, GTK_WIDGET (tree_view)); } -void -_pspp_sheet_view_child_move_resize (PsppSheetView *tree_view, - GtkWidget *widget, - /* in tree coordinates */ - gint x, - gint y, - gint width, - gint height) -{ - PsppSheetViewChild *child = NULL; - GList *list; - GdkRectangle allocation; - - g_return_if_fail (PSPP_IS_SHEET_VIEW (tree_view)); - g_return_if_fail (GTK_IS_WIDGET (widget)); - - for (list = tree_view->priv->children; list; list = list->next) - { - if (((PsppSheetViewChild *)list->data)->widget == widget) - { - child = list->data; - break; - } - } - if (child == NULL) - return; - - allocation.x = child->x = x; - allocation.y = child->y = y; - allocation.width = child->width = width; - allocation.height = child->height = height; - - if (gtk_widget_get_realized (widget)) - gtk_widget_size_allocate (widget, &allocation); -} - - /* TreeModel Callbacks */ @@ -7686,9 +7569,8 @@ _pspp_sheet_view_column_start_drag (PsppSheetView *tree_view, 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, @@ -7720,7 +7602,9 @@ _pspp_sheet_view_column_start_drag (PsppSheetView *tree_view, 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; @@ -8659,7 +8543,7 @@ pspp_sheet_view_ensure_interactive_directory (PsppSheetView *tree_view) gtk_widget_show (frame); gtk_container_add (GTK_CONTAINER (tree_view->priv->search_window), frame); - vbox = gtk_vbox_new (FALSE, 0); + vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); gtk_widget_show (vbox); gtk_container_add (GTK_CONTAINER (frame), vbox); gtk_container_set_border_width (GTK_CONTAINER (vbox), 3); @@ -8811,79 +8695,6 @@ pspp_sheet_view_new_column_width (PsppSheetView *tree_view, return width; } - -/* FIXME this adjust_allocation is a big cut-and-paste from - * GtkCList, needs to be some "official" way to do this - * factored out. - */ -typedef struct -{ - GdkWindow *window; - int dx; - int dy; -} ScrollData; - -/* The window to which gtk_widget_get_window (widget) is relative */ -#define ALLOCATION_WINDOW(widget) \ - (!gtk_widget_get_has_window (widget) ? \ - 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_realized (widget)) - { - if (gtk_widget_get_visible (widget)) - { - GdkRectangle tmp_rectangle = allocation; - tmp_rectangle.x += scroll_data->dx; - tmp_rectangle.y += scroll_data->dy; - - gtk_widget_size_allocate (widget, &tmp_rectangle); - } - } - else - { - if (ALLOCATION_WINDOW (widget) == scroll_data->window) - { - allocation.x += scroll_data->dx; - allocation.y += scroll_data->dy; - - if (GTK_IS_CONTAINER (widget)) - gtk_container_forall (GTK_CONTAINER (widget), - adjust_allocation_recurse, - data); - } - } -} - -static void -adjust_allocation (GtkWidget *widget, - int dx, - int dy) -{ - ScrollData scroll_data; - - if (gtk_widget_get_realized (widget)) - scroll_data.window = ALLOCATION_WINDOW (widget); - else - scroll_data.window = NULL; - - scroll_data.dx = dx; - scroll_data.dy = dy; - - adjust_allocation_recurse (widget, &scroll_data); -} - void pspp_sheet_view_column_update_button (PsppSheetViewColumn *tree_column); @@ -8894,9 +8705,8 @@ pspp_sheet_view_adjustment_changed (GtkAdjustment *adjustment, { if (gtk_widget_get_realized (GTK_WIDGET (tree_view))) { - GList *list; gint dy; - + gdk_window_move (tree_view->priv->bin_window, - gtk_adjustment_get_value (tree_view->priv->hadjustment), TREE_VIEW_HEADER_HEIGHT (tree_view)); @@ -8904,65 +8714,26 @@ pspp_sheet_view_adjustment_changed (GtkAdjustment *adjustment, - gtk_adjustment_get_value (tree_view->priv->hadjustment), 0); dy = tree_view->priv->dy - (int) gtk_adjustment_get_value (tree_view->priv->vadjustment); - if (dy) - { - update_prelight (tree_view, - tree_view->priv->event_last_x, - tree_view->priv->event_last_y - dy); - - if (tree_view->priv->edited_column && - GTK_IS_WIDGET (tree_view->priv->edited_column->editable_widget)) - { - GList *list; - GtkWidget *widget; - PsppSheetViewChild *child = NULL; - widget = GTK_WIDGET (tree_view->priv->edited_column->editable_widget); - adjust_allocation (widget, 0, dy); - - for (list = tree_view->priv->children; list; list = list->next) - { - child = (PsppSheetViewChild *)list->data; - if (child->widget == widget) - { - child->y += dy; - break; - } - } - } - } gdk_window_scroll (tree_view->priv->bin_window, 0, dy); - if (tree_view->priv->dy != (int) gtk_adjustment_get_value (tree_view->priv->vadjustment)) + if (dy != 0) { /* update our dy and top_row */ tree_view->priv->dy = (int) gtk_adjustment_get_value (tree_view->priv->vadjustment); + update_prelight (tree_view, + tree_view->priv->event_last_x, + tree_view->priv->event_last_y); + 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 *col_allocation = &column->allocation; - GtkAllocation widget_allocation; - gtk_widget_get_allocation (GTK_WIDGET (tree_view), &widget_allocation); - - 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) - pspp_sheet_view_column_update_button (column); - } - } + update_childrens_allocation(tree_view); } } - - /* Public methods */ @@ -9170,9 +8941,12 @@ pspp_sheet_view_get_hadjustment (PsppSheetView *tree_view) { 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; } @@ -9196,23 +8970,60 @@ pspp_sheet_view_set_hadjustment (PsppSheetView *tree_view, 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; } @@ -9222,17 +9033,47 @@ pspp_sheet_view_get_vadjustment (PsppSheetView *tree_view) * @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"); } @@ -12520,7 +12361,7 @@ pspp_sheet_view_event (GtkWidget *widget, 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"); @@ -12558,7 +12399,6 @@ pspp_sheet_view_real_start_editing (PsppSheetView *tree_view, { PsppSheetSelectionMode mode = pspp_sheet_selection_get_mode (tree_view->priv->selection); gint pre_val = gtk_adjustment_get_value (tree_view->priv->vadjustment); - GtkRequisition requisition; gint row; g_return_if_fail (gtk_tree_path_get_depth (path) == 1); @@ -12575,25 +12415,12 @@ pspp_sheet_view_real_start_editing (PsppSheetView *tree_view, pspp_sheet_selection_select_column (tree_view->priv->selection, column); tree_view->priv->anchor_column = column; - gtk_widget_size_request (GTK_WIDGET (cell_editable), &requisition); - PSPP_SHEET_VIEW_SET_FLAG (tree_view, PSPP_SHEET_VIEW_DRAW_KEYFOCUS); - if (requisition.height < cell_area->height) - { - gint diff = cell_area->height - requisition.height; - pspp_sheet_view_put (tree_view, - GTK_WIDGET (cell_editable), - cell_area->x, cell_area->y + diff/2, - cell_area->width, requisition.height); - } - else - { - pspp_sheet_view_put (tree_view, - GTK_WIDGET (cell_editable), - cell_area->x, cell_area->y, - cell_area->width, cell_area->height); - } + pspp_sheet_view_put (tree_view, + GTK_WIDGET (cell_editable), + path, + column); gtk_cell_editable_start_editing (GTK_CELL_EDITABLE (cell_editable), (GdkEvent *)event); @@ -12789,7 +12616,6 @@ pspp_sheet_view_state_changed (GtkWidget *widget, if (gtk_widget_get_realized (widget)) { GtkStyle *style = gtk_widget_get_style (widget); - gdk_window_set_back_pixmap (gtk_widget_get_window (widget), NULL, FALSE); gdk_window_set_background (tree_view->priv->bin_window, &style->base[gtk_widget_get_state (widget)]); }