X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Fui%2Fgui%2Fpspp-sheet-view.c;h=d13d995efd3547c5a2825120894a9a630a691dfc;hb=766df5faec86f167a9dd9dbc90bd511ad1567b3b;hp=0b708ab2709a6237323c901b65509d9165de9b7d;hpb=33d73243b99b3ff585184e819f41ca2205449752;p=pspp diff --git a/src/ui/gui/pspp-sheet-view.c b/src/ui/gui/pspp-sheet-view.c index 0b708ab270..d13d995efd 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 Free Software Foundation, Inc. + Copyright (C) 2011, 2012, 2013 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 @@ -40,6 +40,7 @@ #include #include #include +#include #include #include "ui/gui/psppire-marshal.h" @@ -134,6 +135,8 @@ enum { PROP_MODEL, PROP_HADJUSTMENT, PROP_VADJUSTMENT, + PROP_HSCROLL_POLICY, + PROP_VSCROLL_POLICY, PROP_HEADERS_VISIBLE, PROP_HEADERS_CLICKABLE, PROP_REORDERABLE, @@ -143,7 +146,10 @@ enum { PROP_HOVER_SELECTION, PROP_RUBBER_BANDING, PROP_ENABLE_GRID_LINES, - PROP_TOOLTIP_COLUMN + PROP_TOOLTIP_COLUMN, + PROP_SPECIAL_CELLS, + PROP_FIXED_HEIGHT, + PROP_FIXED_HEIGHT_SET }; /* object signals */ @@ -157,8 +163,7 @@ static void pspp_sheet_view_get_property (GObject *object, GValue *value, GParamSpec *pspec); -/* gtkobject signals */ -static void pspp_sheet_view_destroy (GtkObject *object); +static void pspp_sheet_view_dispose (GObject *object); /* gtkwidget signals */ static void pspp_sheet_view_realize (GtkWidget *widget); @@ -168,8 +173,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, @@ -254,7 +259,8 @@ static gboolean pspp_sheet_view_real_move_cursor (PsppSheetView * static gboolean pspp_sheet_view_real_select_all (PsppSheetView *tree_view); static gboolean pspp_sheet_view_real_unselect_all (PsppSheetView *tree_view); static gboolean pspp_sheet_view_real_select_cursor_row (PsppSheetView *tree_view, - gboolean start_editing); + gboolean start_editing, + PsppSheetSelectMode mode); static gboolean pspp_sheet_view_real_toggle_cursor_row (PsppSheetView *tree_view); static void pspp_sheet_view_row_changed (GtkTreeModel *model, GtkTreePath *path, @@ -291,6 +297,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, @@ -313,18 +325,28 @@ static void pspp_sheet_view_clamp_column_visible (PsppSheetView static gboolean pspp_sheet_view_maybe_begin_dragging_row (PsppSheetView *tree_view, GdkEventMotion *event); static void pspp_sheet_view_focus_to_cursor (PsppSheetView *tree_view); -static void pspp_sheet_view_move_cursor_up_down (PsppSheetView *tree_view, - gint count); +static gboolean pspp_sheet_view_move_cursor_up_down (PsppSheetView *tree_view, + gint count, + PsppSheetSelectMode mode); static void pspp_sheet_view_move_cursor_page_up_down (PsppSheetView *tree_view, - gint count); + gint count, + PsppSheetSelectMode mode); static void pspp_sheet_view_move_cursor_left_right (PsppSheetView *tree_view, + gint count, + PsppSheetSelectMode mode); +static void pspp_sheet_view_move_cursor_line_start_end (PsppSheetView *tree_view, + gint count, + PsppSheetSelectMode mode); +static void pspp_sheet_view_move_cursor_tab (PsppSheetView *tree_view, gint count); static void pspp_sheet_view_move_cursor_start_end (PsppSheetView *tree_view, - gint count); + gint count, + PsppSheetSelectMode mode); static void pspp_sheet_view_real_set_cursor (PsppSheetView *tree_view, GtkTreePath *path, gboolean clear_and_select, - gboolean clamp_node); + gboolean clamp_node, + PsppSheetSelectMode mode); static gboolean pspp_sheet_view_has_special_cell (PsppSheetView *tree_view); static void pspp_sheet_view_stop_rubber_band (PsppSheetView *tree_view); static void update_prelight (PsppSheetView *tree_view, @@ -342,8 +364,10 @@ static void pspp_sheet_view_search_position_func (PsppSheetView *t 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); @@ -385,6 +409,10 @@ static void pspp_sheet_view_put (PsppSheetView *t gint height); static gboolean pspp_sheet_view_start_editing (PsppSheetView *tree_view, GtkTreePath *cursor_path); +static gboolean pspp_sheet_view_editable_button_press_event (GtkWidget *, + GdkEventButton *, + PsppSheetView *); +static void pspp_sheet_view_editable_clicked (GtkButton *, PsppSheetView *); static void pspp_sheet_view_real_start_editing (PsppSheetView *tree_view, PsppSheetViewColumn *column, GtkTreePath *path, @@ -392,14 +420,18 @@ static void pspp_sheet_view_real_start_editing (PsppSheetView *tree_view, GdkRectangle *cell_area, GdkEvent *event, guint flags); -static void pspp_sheet_view_stop_editing (PsppSheetView *tree_view, - gboolean cancel_editing); static gboolean pspp_sheet_view_real_start_interactive_search (PsppSheetView *tree_view, gboolean keybinding); static gboolean pspp_sheet_view_start_interactive_search (PsppSheetView *tree_view); static PsppSheetViewColumn *pspp_sheet_view_get_drop_column (PsppSheetView *tree_view, PsppSheetViewColumn *column, gint drop_position); +static void +pspp_sheet_view_adjust_cell_area (PsppSheetView *tree_view, + PsppSheetViewColumn *column, + const GdkRectangle *background_area, + gboolean subtract_focus_rect, + GdkRectangle *cell_area); static gint pspp_sheet_view_find_offset (PsppSheetView *tree_view, gint height, int *new_node); @@ -418,6 +450,8 @@ static void remove_scroll_timeout (PsppSheetView *tree_view); static guint tree_view_signals [LAST_SIGNAL] = { 0 }; +static GtkBindingSet *edit_bindings; + /* GType Methods @@ -425,21 +459,48 @@ static guint tree_view_signals [LAST_SIGNAL] = { 0 }; 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) { GObjectClass *o_class; - GtkObjectClass *object_class; GtkWidgetClass *widget_class; GtkContainerClass *container_class; - GtkBindingSet *binding_set; + GtkBindingSet *binding_set[2]; + int i; + + binding_set[0] = gtk_binding_set_by_class (class); - binding_set = gtk_binding_set_by_class (class); + binding_set[1] = gtk_binding_set_new ("PsppSheetViewEditing"); + edit_bindings = binding_set[1]; o_class = (GObjectClass *) class; - object_class = (GtkObjectClass *) class; widget_class = (GtkWidgetClass *) class; container_class = (GtkContainerClass *) class; @@ -447,22 +508,21 @@ pspp_sheet_view_class_init (PsppSheetViewClass *class) o_class->set_property = pspp_sheet_view_set_property; o_class->get_property = pspp_sheet_view_get_property; o_class->finalize = pspp_sheet_view_finalize; - - /* GtkObject signals */ - object_class->destroy = pspp_sheet_view_destroy; + o_class->dispose = pspp_sheet_view_dispose; /* GtkWidget signals */ 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; @@ -505,21 +565,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, @@ -577,7 +626,7 @@ pspp_sheet_view_class_init (PsppSheetViewClass *class) * Enables of disables the hover selection mode of @tree_view. * Hover selection makes the selected row follow the pointer. * Currently, this works only for the selection modes - * %GTK_SELECTION_SINGLE and %GTK_SELECTION_BROWSE. + * %PSPP_SHEET_SELECTION_SINGLE and %PSPP_SHEET_SELECTION_BROWSE. * * This mode is primarily intended for treeviews in popups, e.g. * in #GtkComboBox or #GtkEntryCompletion. @@ -619,6 +668,33 @@ pspp_sheet_view_class_init (PsppSheetViewClass *class) -1, GTK_PARAM_READWRITE)); + g_object_class_install_property (o_class, + PROP_SPECIAL_CELLS, + g_param_spec_enum ("special-cells", + P_("Special Cells"), + P_("Whether rows have special cells."), + PSPP_TYPE_SHEET_VIEW_SPECIAL_CELLS, + PSPP_SHEET_VIEW_SPECIAL_CELLS_DETECT, + GTK_PARAM_READWRITE)); + + g_object_class_install_property (o_class, + PROP_FIXED_HEIGHT, + g_param_spec_int ("fixed-height", + P_("Fixed Height"), + P_("Height of a single row. Normally the height of a row is determined automatically. Writing this property sets fixed-height-set to true, preventing this property's value from changing."), + -1, + G_MAXINT, + -1, + GTK_PARAM_READWRITE)); + + g_object_class_install_property (o_class, + PROP_FIXED_HEIGHT_SET, + g_param_spec_boolean ("fixed-height-set", + P_("Fixed Height Set"), + P_("Whether fixed-height was set externally."), + FALSE, + GTK_PARAM_READWRITE)); + /* Style properties */ #define _TREE_VIEW_EXPANDER_SIZE 12 #define _TREE_VIEW_VERTICAL_SEPARATOR 2 @@ -701,6 +777,7 @@ pspp_sheet_view_class_init (PsppSheetViewClass *class) GTK_PARAM_READABLE)); /* Signals */ +#if GTK3_TRANSITION /** * PsppSheetView::set-scroll-adjustments * @horizontal: the horizontal #GtkAdjustment @@ -720,6 +797,7 @@ pspp_sheet_view_class_init (PsppSheetViewClass *class) G_TYPE_NONE, 2, GTK_TYPE_ADJUSTMENT, GTK_TYPE_ADJUSTMENT); +#endif /** * PsppSheetView::row-activated: @@ -779,7 +857,7 @@ pspp_sheet_view_class_init (PsppSheetViewClass *class) tree_view_signals[MOVE_CURSOR] = g_signal_new ("move-cursor", - G_TYPE_FROM_CLASS (object_class), + G_TYPE_FROM_CLASS (o_class), G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION, G_STRUCT_OFFSET (PsppSheetViewClass, move_cursor), NULL, NULL, @@ -790,7 +868,7 @@ pspp_sheet_view_class_init (PsppSheetViewClass *class) tree_view_signals[SELECT_ALL] = g_signal_new ("select-all", - G_TYPE_FROM_CLASS (object_class), + G_TYPE_FROM_CLASS (o_class), G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION, G_STRUCT_OFFSET (PsppSheetViewClass, select_all), NULL, NULL, @@ -799,7 +877,7 @@ pspp_sheet_view_class_init (PsppSheetViewClass *class) tree_view_signals[UNSELECT_ALL] = g_signal_new ("unselect-all", - G_TYPE_FROM_CLASS (object_class), + G_TYPE_FROM_CLASS (o_class), G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION, G_STRUCT_OFFSET (PsppSheetViewClass, unselect_all), NULL, NULL, @@ -808,17 +886,17 @@ pspp_sheet_view_class_init (PsppSheetViewClass *class) tree_view_signals[SELECT_CURSOR_ROW] = g_signal_new ("select-cursor-row", - G_TYPE_FROM_CLASS (object_class), + G_TYPE_FROM_CLASS (o_class), G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION, G_STRUCT_OFFSET (PsppSheetViewClass, select_cursor_row), NULL, NULL, psppire_marshal_BOOLEAN__BOOLEAN, - G_TYPE_BOOLEAN, 1, - G_TYPE_BOOLEAN); + G_TYPE_BOOLEAN, 2, + G_TYPE_BOOLEAN, G_TYPE_INT); tree_view_signals[TOGGLE_CURSOR_ROW] = g_signal_new ("toggle-cursor-row", - G_TYPE_FROM_CLASS (object_class), + G_TYPE_FROM_CLASS (o_class), G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION, G_STRUCT_OFFSET (PsppSheetViewClass, toggle_cursor_row), NULL, NULL, @@ -827,7 +905,7 @@ pspp_sheet_view_class_init (PsppSheetViewClass *class) tree_view_signals[START_INTERACTIVE_SEARCH] = g_signal_new ("start-interactive-search", - G_TYPE_FROM_CLASS (object_class), + G_TYPE_FROM_CLASS (o_class), G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION, G_STRUCT_OFFSET (PsppSheetViewClass, start_interactive_search), NULL, NULL, @@ -835,110 +913,136 @@ pspp_sheet_view_class_init (PsppSheetViewClass *class) G_TYPE_BOOLEAN, 0); /* Key bindings */ - pspp_sheet_view_add_move_binding (binding_set, GDK_Up, 0, TRUE, - GTK_MOVEMENT_DISPLAY_LINES, -1); - pspp_sheet_view_add_move_binding (binding_set, GDK_KP_Up, 0, TRUE, - GTK_MOVEMENT_DISPLAY_LINES, -1); - - pspp_sheet_view_add_move_binding (binding_set, GDK_Down, 0, TRUE, - GTK_MOVEMENT_DISPLAY_LINES, 1); - pspp_sheet_view_add_move_binding (binding_set, GDK_KP_Down, 0, TRUE, - GTK_MOVEMENT_DISPLAY_LINES, 1); - - pspp_sheet_view_add_move_binding (binding_set, GDK_p, GDK_CONTROL_MASK, FALSE, - GTK_MOVEMENT_DISPLAY_LINES, -1); - - pspp_sheet_view_add_move_binding (binding_set, GDK_n, GDK_CONTROL_MASK, FALSE, - GTK_MOVEMENT_DISPLAY_LINES, 1); - - pspp_sheet_view_add_move_binding (binding_set, GDK_Home, 0, TRUE, - GTK_MOVEMENT_BUFFER_ENDS, -1); - pspp_sheet_view_add_move_binding (binding_set, GDK_KP_Home, 0, TRUE, - GTK_MOVEMENT_BUFFER_ENDS, -1); - - pspp_sheet_view_add_move_binding (binding_set, GDK_End, 0, TRUE, - GTK_MOVEMENT_BUFFER_ENDS, 1); - pspp_sheet_view_add_move_binding (binding_set, GDK_KP_End, 0, TRUE, - GTK_MOVEMENT_BUFFER_ENDS, 1); - - pspp_sheet_view_add_move_binding (binding_set, GDK_Page_Up, 0, TRUE, - GTK_MOVEMENT_PAGES, -1); - pspp_sheet_view_add_move_binding (binding_set, GDK_KP_Page_Up, 0, TRUE, - GTK_MOVEMENT_PAGES, -1); - - pspp_sheet_view_add_move_binding (binding_set, GDK_Page_Down, 0, TRUE, - GTK_MOVEMENT_PAGES, 1); - pspp_sheet_view_add_move_binding (binding_set, GDK_KP_Page_Down, 0, TRUE, - GTK_MOVEMENT_PAGES, 1); - - - gtk_binding_entry_add_signal (binding_set, GDK_Right, 0, "move-cursor", 2, - G_TYPE_ENUM, GTK_MOVEMENT_VISUAL_POSITIONS, - G_TYPE_INT, 1); - - gtk_binding_entry_add_signal (binding_set, GDK_Left, 0, "move-cursor", 2, - G_TYPE_ENUM, GTK_MOVEMENT_VISUAL_POSITIONS, - G_TYPE_INT, -1); - - gtk_binding_entry_add_signal (binding_set, GDK_KP_Right, 0, "move-cursor", 2, - G_TYPE_ENUM, GTK_MOVEMENT_VISUAL_POSITIONS, - G_TYPE_INT, 1); - - gtk_binding_entry_add_signal (binding_set, GDK_KP_Left, 0, "move-cursor", 2, - G_TYPE_ENUM, GTK_MOVEMENT_VISUAL_POSITIONS, - G_TYPE_INT, -1); - - gtk_binding_entry_add_signal (binding_set, GDK_Right, GDK_CONTROL_MASK, - "move-cursor", 2, - G_TYPE_ENUM, GTK_MOVEMENT_VISUAL_POSITIONS, - G_TYPE_INT, 1); - - gtk_binding_entry_add_signal (binding_set, GDK_Left, GDK_CONTROL_MASK, - "move-cursor", 2, - G_TYPE_ENUM, GTK_MOVEMENT_VISUAL_POSITIONS, - G_TYPE_INT, -1); - - gtk_binding_entry_add_signal (binding_set, GDK_KP_Right, GDK_CONTROL_MASK, - "move-cursor", 2, - G_TYPE_ENUM, GTK_MOVEMENT_VISUAL_POSITIONS, - G_TYPE_INT, 1); - - gtk_binding_entry_add_signal (binding_set, GDK_KP_Left, GDK_CONTROL_MASK, - "move-cursor", 2, - G_TYPE_ENUM, GTK_MOVEMENT_VISUAL_POSITIONS, - G_TYPE_INT, -1); - - gtk_binding_entry_add_signal (binding_set, GDK_space, GDK_CONTROL_MASK, "toggle-cursor-row", 0); - gtk_binding_entry_add_signal (binding_set, GDK_KP_Space, GDK_CONTROL_MASK, "toggle-cursor-row", 0); - - gtk_binding_entry_add_signal (binding_set, GDK_a, GDK_CONTROL_MASK, "select-all", 0); - gtk_binding_entry_add_signal (binding_set, GDK_slash, GDK_CONTROL_MASK, "select-all", 0); - - gtk_binding_entry_add_signal (binding_set, GDK_A, GDK_CONTROL_MASK | GDK_SHIFT_MASK, "unselect-all", 0); - gtk_binding_entry_add_signal (binding_set, GDK_backslash, GDK_CONTROL_MASK, "unselect-all", 0); - - gtk_binding_entry_add_signal (binding_set, GDK_space, GDK_SHIFT_MASK, "select-cursor-row", 1, - G_TYPE_BOOLEAN, TRUE); - gtk_binding_entry_add_signal (binding_set, GDK_KP_Space, GDK_SHIFT_MASK, "select-cursor-row", 1, - G_TYPE_BOOLEAN, TRUE); + for (i = 0; i < 2; i++) + { + pspp_sheet_view_add_move_binding (binding_set[i], GDK_Up, 0, TRUE, + GTK_MOVEMENT_DISPLAY_LINES, -1); + pspp_sheet_view_add_move_binding (binding_set[i], GDK_KP_Up, 0, TRUE, + GTK_MOVEMENT_DISPLAY_LINES, -1); - gtk_binding_entry_add_signal (binding_set, GDK_space, 0, "select-cursor-row", 1, - G_TYPE_BOOLEAN, TRUE); - gtk_binding_entry_add_signal (binding_set, GDK_KP_Space, 0, "select-cursor-row", 1, - G_TYPE_BOOLEAN, TRUE); - gtk_binding_entry_add_signal (binding_set, GDK_Return, 0, "select-cursor-row", 1, - G_TYPE_BOOLEAN, TRUE); - gtk_binding_entry_add_signal (binding_set, GDK_ISO_Enter, 0, "select-cursor-row", 1, - G_TYPE_BOOLEAN, TRUE); - gtk_binding_entry_add_signal (binding_set, GDK_KP_Enter, 0, "select-cursor-row", 1, - G_TYPE_BOOLEAN, TRUE); + pspp_sheet_view_add_move_binding (binding_set[i], GDK_Down, 0, TRUE, + GTK_MOVEMENT_DISPLAY_LINES, 1); + pspp_sheet_view_add_move_binding (binding_set[i], GDK_KP_Down, 0, TRUE, + GTK_MOVEMENT_DISPLAY_LINES, 1); - gtk_binding_entry_add_signal (binding_set, GDK_BackSpace, 0, "select-cursor-parent", 0); - gtk_binding_entry_add_signal (binding_set, GDK_BackSpace, GDK_CONTROL_MASK, "select-cursor-parent", 0); + pspp_sheet_view_add_move_binding (binding_set[i], GDK_p, GDK_CONTROL_MASK, FALSE, + GTK_MOVEMENT_DISPLAY_LINES, -1); - gtk_binding_entry_add_signal (binding_set, GDK_f, GDK_CONTROL_MASK, "start-interactive-search", 0); + pspp_sheet_view_add_move_binding (binding_set[i], GDK_n, GDK_CONTROL_MASK, FALSE, + GTK_MOVEMENT_DISPLAY_LINES, 1); - gtk_binding_entry_add_signal (binding_set, GDK_F, GDK_CONTROL_MASK, "start-interactive-search", 0); + pspp_sheet_view_add_move_binding (binding_set[i], GDK_Home, 0, TRUE, + GTK_MOVEMENT_DISPLAY_LINE_ENDS, -1); + pspp_sheet_view_add_move_binding (binding_set[i], GDK_KP_Home, 0, TRUE, + GTK_MOVEMENT_DISPLAY_LINE_ENDS, -1); + + pspp_sheet_view_add_move_binding (binding_set[i], GDK_End, 0, TRUE, + GTK_MOVEMENT_DISPLAY_LINE_ENDS, 1); + pspp_sheet_view_add_move_binding (binding_set[i], GDK_KP_End, 0, TRUE, + GTK_MOVEMENT_DISPLAY_LINE_ENDS, 1); + + pspp_sheet_view_add_move_binding (binding_set[i], GDK_Page_Up, 0, TRUE, + GTK_MOVEMENT_PAGES, -1); + pspp_sheet_view_add_move_binding (binding_set[i], GDK_KP_Page_Up, 0, TRUE, + GTK_MOVEMENT_PAGES, -1); + + pspp_sheet_view_add_move_binding (binding_set[i], GDK_Page_Down, 0, TRUE, + GTK_MOVEMENT_PAGES, 1); + pspp_sheet_view_add_move_binding (binding_set[i], GDK_KP_Page_Down, 0, TRUE, + GTK_MOVEMENT_PAGES, 1); + + + gtk_binding_entry_add_signal (binding_set[i], GDK_Up, GDK_CONTROL_MASK, "move-cursor", 2, + G_TYPE_ENUM, GTK_MOVEMENT_BUFFER_ENDS, + G_TYPE_INT, -1); + + gtk_binding_entry_add_signal (binding_set[i], GDK_Down, GDK_CONTROL_MASK, "move-cursor", 2, + G_TYPE_ENUM, GTK_MOVEMENT_BUFFER_ENDS, + G_TYPE_INT, 1); + + gtk_binding_entry_add_signal (binding_set[i], GDK_Right, 0, "move-cursor", 2, + G_TYPE_ENUM, GTK_MOVEMENT_VISUAL_POSITIONS, + G_TYPE_INT, 1); + + gtk_binding_entry_add_signal (binding_set[i], GDK_Left, 0, "move-cursor", 2, + G_TYPE_ENUM, GTK_MOVEMENT_VISUAL_POSITIONS, + G_TYPE_INT, -1); + + gtk_binding_entry_add_signal (binding_set[i], GDK_Tab, 0, "move-cursor", 2, + G_TYPE_ENUM, GTK_MOVEMENT_LOGICAL_POSITIONS, + G_TYPE_INT, 1); + + gtk_binding_entry_add_signal (binding_set[i], GDK_Tab, GDK_SHIFT_MASK, "move-cursor", 2, + G_TYPE_ENUM, GTK_MOVEMENT_LOGICAL_POSITIONS, + G_TYPE_INT, -1); + + gtk_binding_entry_add_signal (binding_set[i], GDK_KP_Right, 0, "move-cursor", 2, + G_TYPE_ENUM, GTK_MOVEMENT_DISPLAY_LINE_ENDS, + G_TYPE_INT, 1); + + gtk_binding_entry_add_signal (binding_set[i], GDK_KP_Left, 0, "move-cursor", 2, + G_TYPE_ENUM, GTK_MOVEMENT_DISPLAY_LINE_ENDS, + G_TYPE_INT, -1); + + gtk_binding_entry_add_signal (binding_set[i], GDK_Right, GDK_CONTROL_MASK, + "move-cursor", 2, + G_TYPE_ENUM, GTK_MOVEMENT_DISPLAY_LINE_ENDS, + G_TYPE_INT, 1); + + gtk_binding_entry_add_signal (binding_set[i], GDK_Left, GDK_CONTROL_MASK, + "move-cursor", 2, + G_TYPE_ENUM, GTK_MOVEMENT_DISPLAY_LINE_ENDS, + G_TYPE_INT, -1); + + gtk_binding_entry_add_signal (binding_set[i], GDK_KP_Right, GDK_CONTROL_MASK, + "move-cursor", 2, + G_TYPE_ENUM, GTK_MOVEMENT_VISUAL_POSITIONS, + G_TYPE_INT, 1); + + gtk_binding_entry_add_signal (binding_set[i], GDK_KP_Left, GDK_CONTROL_MASK, + "move-cursor", 2, + G_TYPE_ENUM, GTK_MOVEMENT_VISUAL_POSITIONS, + G_TYPE_INT, -1); + + gtk_binding_entry_add_signal (binding_set[i], GDK_f, GDK_CONTROL_MASK, "start-interactive-search", 0); + + gtk_binding_entry_add_signal (binding_set[i], GDK_F, GDK_CONTROL_MASK, "start-interactive-search", 0); + } + + gtk_binding_entry_add_signal (binding_set[0], GDK_space, GDK_CONTROL_MASK, "toggle-cursor-row", 0); + gtk_binding_entry_add_signal (binding_set[0], GDK_KP_Space, GDK_CONTROL_MASK, "toggle-cursor-row", 0); + + gtk_binding_entry_add_signal (binding_set[0], GDK_a, GDK_CONTROL_MASK, "select-all", 0); + gtk_binding_entry_add_signal (binding_set[0], GDK_slash, GDK_CONTROL_MASK, "select-all", 0); + + gtk_binding_entry_add_signal (binding_set[0], GDK_A, GDK_CONTROL_MASK | GDK_SHIFT_MASK, "unselect-all", 0); + gtk_binding_entry_add_signal (binding_set[0], GDK_backslash, GDK_CONTROL_MASK, "unselect-all", 0); + + gtk_binding_entry_add_signal (binding_set[0], GDK_space, GDK_SHIFT_MASK, "select-cursor-row", 1, + G_TYPE_BOOLEAN, TRUE, + G_TYPE_INT, PSPP_SHEET_SELECT_MODE_EXTEND); + gtk_binding_entry_add_signal (binding_set[0], GDK_KP_Space, GDK_SHIFT_MASK, "select-cursor-row", 1, + G_TYPE_BOOLEAN, TRUE, + G_TYPE_INT, PSPP_SHEET_SELECT_MODE_EXTEND); + + gtk_binding_entry_add_signal (binding_set[0], GDK_space, 0, "select-cursor-row", 1, + G_TYPE_BOOLEAN, TRUE, + G_TYPE_INT, 0); + gtk_binding_entry_add_signal (binding_set[0], GDK_KP_Space, 0, "select-cursor-row", 1, + G_TYPE_BOOLEAN, TRUE, + G_TYPE_INT, 0); + gtk_binding_entry_add_signal (binding_set[0], GDK_Return, 0, "select-cursor-row", 1, + G_TYPE_BOOLEAN, TRUE, + G_TYPE_INT, 0); + gtk_binding_entry_add_signal (binding_set[0], GDK_ISO_Enter, 0, "select-cursor-row", 1, + G_TYPE_BOOLEAN, TRUE, + G_TYPE_INT, 0); + gtk_binding_entry_add_signal (binding_set[0], GDK_KP_Enter, 0, "select-cursor-row", 1, + G_TYPE_BOOLEAN, TRUE, + G_TYPE_INT, 0); + + gtk_binding_entry_add_signal (binding_set[0], GDK_BackSpace, 0, "select-cursor-parent", 0); + gtk_binding_entry_add_signal (binding_set[0], GDK_BackSpace, GDK_CONTROL_MASK, "select-cursor-parent", 0); g_type_class_add_private (o_class, sizeof (PsppSheetViewPrivate)); } @@ -976,6 +1080,7 @@ pspp_sheet_view_init (PsppSheetView *tree_view) tree_view->priv->presize_handler_timer = 0; tree_view->priv->scroll_sync_timer = 0; tree_view->priv->fixed_height = -1; + tree_view->priv->fixed_height_set = FALSE; pspp_sheet_view_set_adjustments (tree_view, NULL, NULL); tree_view->priv->selection = _pspp_sheet_selection_new_with_tree_view (tree_view); tree_view->priv->enable_search = TRUE; @@ -995,6 +1100,8 @@ pspp_sheet_view_init (PsppSheetView *tree_view) tree_view->priv->tooltip_column = -1; + tree_view->priv->special_cells = PSPP_SHEET_VIEW_SPECIAL_CELLS_DETECT; + tree_view->priv->post_validation_flag = FALSE; tree_view->priv->last_button_x = -1; @@ -1006,6 +1113,15 @@ pspp_sheet_view_init (PsppSheetView *tree_view) tree_view->priv->prelight_node = -1; tree_view->priv->rubber_band_start_node = -1; tree_view->priv->rubber_band_end_node = -1; + + tree_view->priv->anchor_column = NULL; + + 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); } @@ -1029,12 +1145,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: @@ -1064,6 +1188,32 @@ pspp_sheet_view_set_property (GObject *object, case PROP_TOOLTIP_COLUMN: pspp_sheet_view_set_tooltip_column (tree_view, g_value_get_int (value)); break; + case PROP_SPECIAL_CELLS: + pspp_sheet_view_set_special_cells (tree_view, g_value_get_enum (value)); + break; + case PROP_FIXED_HEIGHT: + pspp_sheet_view_set_fixed_height (tree_view, g_value_get_int (value)); + break; + case PROP_FIXED_HEIGHT_SET: + if (g_value_get_boolean (value)) + { + if (!tree_view->priv->fixed_height_set + && tree_view->priv->fixed_height >= 0) + { + tree_view->priv->fixed_height_set = true; + g_object_notify (G_OBJECT (tree_view), "fixed-height-set"); + } + } + else + { + if (tree_view->priv->fixed_height_set) + { + tree_view->priv->fixed_height_set = false; + g_object_notify (G_OBJECT (tree_view), "fixed-height-set"); + install_presize_handler (tree_view); + } + } + break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; @@ -1091,6 +1241,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; @@ -1121,6 +1277,15 @@ pspp_sheet_view_get_property (GObject *object, case PROP_TOOLTIP_COLUMN: g_value_set_int (value, tree_view->priv->tooltip_column); break; + case PROP_SPECIAL_CELLS: + g_value_set_enum (value, tree_view->priv->special_cells); + break; + case PROP_FIXED_HEIGHT: + g_value_set_int (value, pspp_sheet_view_get_fixed_height (tree_view)); + break; + case PROP_FIXED_HEIGHT_SET: + g_value_set_boolean (value, tree_view->priv->fixed_height_set); + break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; @@ -1128,9 +1293,41 @@ pspp_sheet_view_get_property (GObject *object, } static void -pspp_sheet_view_finalize (GObject *object) +pspp_sheet_view_dispose (GObject *object) { - G_OBJECT_CLASS (pspp_sheet_view_parent_class)->finalize (object); + PsppSheetView *tree_view = PSPP_SHEET_VIEW (object); + + if (tree_view->dispose_has_run) + return; + + tree_view->dispose_has_run = TRUE; + + if (tree_view->priv->selection != NULL) + { + _pspp_sheet_selection_set_tree_view (tree_view->priv->selection, NULL); + g_object_unref (tree_view->priv->selection); + tree_view->priv->selection = NULL; + } + + if (tree_view->priv->hadjustment) + { + g_object_unref (tree_view->priv->hadjustment); + tree_view->priv->hadjustment = NULL; + } + if (tree_view->priv->vadjustment) + { + g_object_unref (tree_view->priv->vadjustment); + tree_view->priv->vadjustment = NULL; + } + + if (tree_view->priv->button_style) + { + g_object_unref (tree_view->priv->button_style); + tree_view->priv->button_style = NULL; + } + + + G_OBJECT_CLASS (pspp_sheet_view_parent_class)->dispose (object); } @@ -1144,14 +1341,10 @@ pspp_sheet_view_buildable_add_child (GtkBuildable *tree_view, pspp_sheet_view_append_column (PSPP_SHEET_VIEW (tree_view), PSPP_SHEET_VIEW_COLUMN (child)); } -/* GtkObject Methods - */ - static void -pspp_sheet_view_destroy (GtkObject *object) +pspp_sheet_view_finalize (GObject *object) { PsppSheetView *tree_view = PSPP_SHEET_VIEW (object); - GList *list; pspp_sheet_view_stop_editing (tree_view, TRUE); @@ -1161,27 +1354,9 @@ pspp_sheet_view_destroy (GtkObject *object) tree_view->priv->selected = NULL; } - if (tree_view->priv->columns != NULL) - { - list = tree_view->priv->columns; - while (list) - { - PsppSheetViewColumn *column; - column = PSPP_SHEET_VIEW_COLUMN (list->data); - list = list->next; - pspp_sheet_view_remove_column (tree_view, column); - } - tree_view->priv->columns = NULL; - } tree_view->priv->prelight_node = -1; - if (tree_view->priv->selection != NULL) - { - _pspp_sheet_selection_set_tree_view (tree_view->priv->selection, NULL); - g_object_unref (tree_view->priv->selection); - tree_view->priv->selection = NULL; - } if (tree_view->priv->scroll_to_path != NULL) { @@ -1248,18 +1423,8 @@ pspp_sheet_view_destroy (GtkObject *object) pspp_sheet_view_set_model (tree_view, NULL); - if (tree_view->priv->hadjustment) - { - g_object_unref (tree_view->priv->hadjustment); - tree_view->priv->hadjustment = NULL; - } - if (tree_view->priv->vadjustment) - { - g_object_unref (tree_view->priv->vadjustment); - tree_view->priv->vadjustment = NULL; - } - GTK_OBJECT_CLASS (pspp_sheet_view_parent_class)->destroy (object); + G_OBJECT_CLASS (pspp_sheet_view_parent_class)->finalize (object); } @@ -1282,14 +1447,15 @@ pspp_sheet_view_map_buttons (PsppSheetView *tree_view) for (list = tree_view->priv->columns; list; list = list->next) { column = list->data; - if (gtk_widget_get_visible (column->button) && + if (column->button != NULL && + gtk_widget_get_visible (column->button) && !gtk_widget_get_mapped (column->button)) gtk_widget_map (column->button); } for (list = tree_view->priv->columns; list; list = list->next) { column = list->data; - if (column->visible == FALSE) + if (column->visible == FALSE || column->window == NULL) continue; if (column->resizable) { @@ -1327,7 +1493,7 @@ pspp_sheet_view_map (GtkWidget *widget) pspp_sheet_view_map_buttons (tree_view); - gdk_window_show (widget->window); + gdk_window_show (gtk_widget_get_window (widget)); } static void @@ -1337,31 +1503,36 @@ pspp_sheet_view_realize (GtkWidget *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 | @@ -1371,14 +1542,14 @@ pspp_sheet_view_realize (GtkWidget *widget) 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 | @@ -1388,15 +1559,15 @@ pspp_sheet_view_realize (GtkWidget *widget) 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) @@ -1423,6 +1594,8 @@ pspp_sheet_view_unrealize (GtkWidget *widget) PsppSheetViewPrivate *priv = tree_view->priv; GList *list; + GTK_WIDGET_CLASS (pspp_sheet_view_parent_class)->unrealize (widget); + if (priv->scroll_timeout != 0) { g_source_remove (priv->scroll_timeout); @@ -1484,13 +1657,18 @@ pspp_sheet_view_unrealize (GtkWidget *widget) priv->drag_highlight_window = NULL; } - if (priv->grid_line_gc) + if (tree_view->priv->columns != NULL) { - g_object_unref (priv->grid_line_gc); - priv->grid_line_gc = NULL; + list = tree_view->priv->columns; + while (list) + { + PsppSheetViewColumn *column; + column = PSPP_SHEET_VIEW_COLUMN (list->data); + list = list->next; + pspp_sheet_view_remove_column (tree_view, column); + } + tree_view->priv->columns = NULL; } - - GTK_WIDGET_CLASS (pspp_sheet_view_parent_class)->unrealize (widget); } /* GtkWidget::size_request helper */ @@ -1508,12 +1686,7 @@ pspp_sheet_view_size_request_columns (PsppSheetView *tree_view) GtkRequisition requisition; PsppSheetViewColumn *column = list->data; - if (column->button == NULL) - continue; - - column = list->data; - - gtk_widget_size_request (column->button, &requisition); + pspp_sheet_view_column_size_request (column, &requisition); column->button_request = requisition.width; tree_view->priv->header_height = MAX (tree_view->priv->header_height, requisition.height); } @@ -1620,13 +1793,15 @@ invalidate_column (PsppSheetView *tree_view, 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; } @@ -1677,6 +1852,15 @@ pspp_sheet_view_get_real_requested_width_from_column (PsppSheetView *tree_ return real_requested_width; } +static gboolean +span_intersects (int a0, int a_width, + int b0, int b_width) +{ + int a1 = a0 + a_width; + int b1 = b0 + b_width; + return (a0 >= b0 && a0 < b1) || (b0 >= a0 && b0 < a1); +} + /* GtkWidget::size_allocate helper */ static void pspp_sheet_view_size_allocate_columns (GtkWidget *widget, @@ -1685,21 +1869,22 @@ pspp_sheet_view_size_allocate_columns (GtkWidget *widget, PsppSheetView *tree_view; GList *list, *first_column, *last_column; PsppSheetViewColumn *column; + GtkAllocation col_allocation; GtkAllocation allocation; gint width = 0; - gint extra, extra_per_column, extra_for_last; + gint extra, extra_per_column; gint full_requested_width = 0; gint number_of_expand_columns = 0; gboolean column_changed = FALSE; gboolean rtl; - gboolean update_expand; - + tree_view = PSPP_SHEET_VIEW (widget); for (last_column = g_list_last (tree_view->priv->columns); last_column && !(PSPP_SHEET_VIEW_COLUMN (last_column->data)->visible); last_column = last_column->prev) ; + if (last_column == NULL) return; @@ -1708,8 +1893,8 @@ pspp_sheet_view_size_allocate_columns (GtkWidget *widget, 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); @@ -1727,42 +1912,13 @@ pspp_sheet_view_size_allocate_columns (GtkWidget *widget, number_of_expand_columns++; } - /* Only update the expand value if the width of the widget has changed, - * or the number of expand columns has changed, or if there are no expand - * columns, or if we didn't have an size-allocation yet after the - * last validated node. - */ - update_expand = (width_changed && *width_changed == TRUE) - || number_of_expand_columns != tree_view->priv->last_number_of_expand_columns - || number_of_expand_columns == 0 - || tree_view->priv->post_validation_flag == TRUE; - - tree_view->priv->post_validation_flag = FALSE; - - if (!update_expand) - { - extra = tree_view->priv->last_extra_space; - extra_for_last = MAX (widget->allocation.width - full_requested_width - extra, 0); - } - else - { - extra = MAX (widget->allocation.width - full_requested_width, 0); - extra_for_last = 0; - - tree_view->priv->last_extra_space = extra; - } - + 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 extra_per_column = 0; - if (update_expand) - { - tree_view->priv->last_extra_space_per_column = extra_per_column; - tree_view->priv->last_number_of_expand_columns = number_of_expand_columns; - } - for (list = (rtl ? last_column : first_column); list != (rtl ? first_column->prev : last_column->next); list = (rtl ? list->prev : list->next)) @@ -1781,20 +1937,19 @@ pspp_sheet_view_size_allocate_columns (GtkWidget *widget, 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; - gtk_widget_size_allocate (tree_view->priv->drag_column->button, - &drag_allocation); + pspp_sheet_view_column_size_allocate (tree_view->priv->drag_column, + &drag_allocation); width += drag_allocation.width; continue; } 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) @@ -1812,33 +1967,23 @@ pspp_sheet_view_size_allocate_columns (GtkWidget *widget, number_of_expand_columns --; } } - else if (number_of_expand_columns == 0 && - list == last_column) - { - column->width += extra; - } - /* In addition to expand, the last column can get even more - * extra space so all available space is filled up. - */ - if (extra_for_last > 0 && list == last_column) - column->width += extra_for_last; + if (column->width != old_width) + g_object_notify (G_OBJECT (column), "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; - gtk_widget_size_allocate (column->button, &allocation); + pspp_sheet_view_column_size_allocate (column, &col_allocation); 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, @@ -1852,7 +1997,6 @@ pspp_sheet_view_size_allocate_columns (GtkWidget *widget, gtk_widget_queue_draw (GTK_WIDGET (tree_view)); } - static void pspp_sheet_view_size_allocate (GtkWidget *widget, GtkAllocation *allocation) @@ -1860,12 +2004,14 @@ pspp_sheet_view_size_allocate (GtkWidget *widget, 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; @@ -1889,11 +2035,11 @@ pspp_sheet_view_size_allocate (GtkWidget *widget, */ 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) { @@ -1901,42 +2047,42 @@ pspp_sheet_view_size_allocate (GtkWidget *widget, { 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 @@ -1944,16 +2090,16 @@ pspp_sheet_view_size_allocate (GtkWidget *widget, 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)); @@ -2011,25 +2157,211 @@ pspp_sheet_view_node_select (PsppSheetView *tree_view, range_tower_set1 (tree_view->priv->selected, node, 1); } -void -pspp_sheet_view_node_unselect (PsppSheetView *tree_view, - int node) +void +pspp_sheet_view_node_unselect (PsppSheetView *tree_view, + int node) +{ + range_tower_set0 (tree_view->priv->selected, node, 1); +} + +gint +pspp_sheet_view_node_next (PsppSheetView *tree_view, + gint node) +{ + return node + 1 < tree_view->priv->row_count ? node + 1 : -1; +} + +gint +pspp_sheet_view_node_prev (PsppSheetView *tree_view, + gint node) +{ + return node > 0 ? node - 1 : -1; +} + +static gboolean +all_columns_selected (PsppSheetView *tree_view) +{ + GList *list; + + for (list = tree_view->priv->columns; list; list = list->next) + { + PsppSheetViewColumn *column = list->data; + if (column->selectable && !column->selected) + return FALSE; + } + + return TRUE; +} + +static gboolean +pspp_sheet_view_row_head_clicked (PsppSheetView *tree_view, + gint node, + PsppSheetViewColumn *column, + GdkEventButton *event) +{ + PsppSheetSelection *selection; + PsppSheetSelectionMode mode; + GtkTreePath *path; + gboolean update_anchor; + gboolean handled; + guint modifiers; + + g_return_val_if_fail (tree_view != NULL, FALSE); + g_return_val_if_fail (column != NULL, FALSE); + + selection = tree_view->priv->selection; + mode = pspp_sheet_selection_get_mode (selection); + if (mode != PSPP_SHEET_SELECTION_RECTANGLE) + return FALSE; + + if (!column->row_head) + return FALSE; + + if (event) + { + modifiers = event->state & gtk_accelerator_get_default_mod_mask (); + if (event->type != GDK_BUTTON_PRESS + || (modifiers != GDK_CONTROL_MASK && modifiers != GDK_SHIFT_MASK)) + return FALSE; + } + else + modifiers = 0; + + path = gtk_tree_path_new_from_indices (node, -1); + if (event == NULL) + { + pspp_sheet_selection_unselect_all (selection); + pspp_sheet_selection_select_path (selection, path); + pspp_sheet_selection_select_all_columns (selection); + update_anchor = TRUE; + handled = TRUE; + } + else if (event->type == GDK_BUTTON_PRESS && event->button == 3) + { + if (pspp_sheet_selection_count_selected_rows (selection) <= 1 + || !all_columns_selected (tree_view)) + { + pspp_sheet_selection_unselect_all (selection); + pspp_sheet_selection_select_path (selection, path); + pspp_sheet_selection_select_all_columns (selection); + update_anchor = TRUE; + handled = FALSE; + } + else + update_anchor = handled = FALSE; + } + else if (event->type == GDK_BUTTON_PRESS && event->button == 1 + && modifiers == GDK_CONTROL_MASK) + { + if (!all_columns_selected (tree_view)) + { + pspp_sheet_selection_unselect_all (selection); + pspp_sheet_selection_select_all_columns (selection); + } + + if (pspp_sheet_selection_path_is_selected (selection, path)) + pspp_sheet_selection_unselect_path (selection, path); + else + pspp_sheet_selection_select_path (selection, path); + update_anchor = TRUE; + handled = TRUE; + } + else if (event->type == GDK_BUTTON_PRESS && event->button == 1 + && modifiers == GDK_SHIFT_MASK) + { + GtkTreeRowReference *anchor = tree_view->priv->anchor; + GtkTreePath *anchor_path; + + if (all_columns_selected (tree_view) + && gtk_tree_row_reference_valid (anchor)) + { + update_anchor = FALSE; + anchor_path = gtk_tree_row_reference_get_path (anchor); + } + else + { + update_anchor = TRUE; + anchor_path = gtk_tree_path_copy (path); + } + + pspp_sheet_selection_unselect_all (selection); + pspp_sheet_selection_select_range (selection, anchor_path, path); + pspp_sheet_selection_select_all_columns (selection); + + gtk_tree_path_free (anchor_path); + + handled = TRUE; + } + else + update_anchor = handled = FALSE; + + if (update_anchor) + { + if (tree_view->priv->anchor) + gtk_tree_row_reference_free (tree_view->priv->anchor); + tree_view->priv->anchor = + gtk_tree_row_reference_new_proxy (G_OBJECT (tree_view), + tree_view->priv->model, + path); + } + + gtk_tree_path_free (path); + return handled; +} + +static gboolean +find_click (PsppSheetView *tree_view, + gint x, gint y, + gint *node, + PsppSheetViewColumn **column, + GdkRectangle *background_area, + GdkRectangle *cell_area) { - range_tower_set0 (tree_view->priv->selected, node, 1); -} + gint y_offset; + gboolean rtl; + GList *list; + gint new_y; -gint -pspp_sheet_view_node_next (PsppSheetView *tree_view, - gint node) -{ - return node + 1 < tree_view->priv->row_count ? node + 1 : -1; -} + /* find the node that was clicked */ + new_y = TREE_WINDOW_Y_TO_RBTREE_Y(tree_view, y); + if (new_y < 0) + new_y = 0; + y_offset = -pspp_sheet_view_find_offset (tree_view, new_y, node); -gint -pspp_sheet_view_node_prev (PsppSheetView *tree_view, - gint node) -{ - return node > 0 ? node - 1 : -1; + if (*node < 0) + return FALSE; + + background_area->y = y_offset + y; + background_area->height = ROW_HEIGHT (tree_view); + background_area->x = 0; + + /* Let the column have a chance at selecting it. */ + 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 *candidate = list->data; + + if (!candidate->visible) + continue; + + background_area->width = candidate->width; + if ((background_area->x > x) || + (background_area->x + background_area->width <= x)) + { + background_area->x += background_area->width; + continue; + } + + /* we found the focus column */ + + pspp_sheet_view_adjust_cell_area (tree_view, candidate, background_area, + TRUE, cell_area); + *column = candidate; + return TRUE; + } + + return FALSE; } static gboolean @@ -2042,16 +2374,10 @@ pspp_sheet_view_button_press (GtkWidget *widget, gint i; GdkRectangle background_area; GdkRectangle cell_area; - gint vertical_separator; - gint horizontal_separator; gboolean rtl; rtl = (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL); pspp_sheet_view_stop_editing (tree_view, FALSE); - gtk_widget_style_get (widget, - "vertical-separator", &vertical_separator, - "horizontal-separator", &horizontal_separator, - NULL); /* Because grab_focus can cause reentrancy, we delay grab_focus until after @@ -2062,18 +2388,11 @@ pspp_sheet_view_button_press (GtkWidget *widget, { int node; GtkTreePath *path; - gchar *path_string; - gint depth; - gint new_y; - gint y_offset; gint dval; gint pre_val, aft_val; PsppSheetViewColumn *column = NULL; GtkCellRenderer *focus_cell = NULL; - gint column_handled_click = FALSE; gboolean row_double_click = FALSE; - gboolean rtl; - gboolean node_selected; /* Empty tree? */ if (tree_view->priv->row_count == 0) @@ -2082,142 +2401,33 @@ pspp_sheet_view_button_press (GtkWidget *widget, return TRUE; } - /* find the node that was clicked */ - new_y = TREE_WINDOW_Y_TO_RBTREE_Y(tree_view, event->y); - if (new_y < 0) - new_y = 0; - y_offset = -pspp_sheet_view_find_offset (tree_view, new_y, &node); - - if (node < 0) - { - /* We clicked in dead space */ - grab_focus_and_unset_draw_keyfocus (tree_view); - return TRUE; - } - - /* Get the path and the node */ - path = _pspp_sheet_view_find_path (tree_view, node); - - depth = gtk_tree_path_get_depth (path); - background_area.y = y_offset + event->y; - background_area.height = ROW_HEIGHT (tree_view); - background_area.x = 0; - - - /* Let the column have a chance at selecting it. */ - 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 *candidate = list->data; - - if (!candidate->visible) - continue; - - background_area.width = candidate->width; - if ((background_area.x > (gint) event->x) || - (background_area.x + background_area.width <= (gint) event->x)) - { - background_area.x += background_area.width; - continue; - } - - /* we found the focus column */ - column = candidate; - cell_area = background_area; - cell_area.width -= horizontal_separator; - cell_area.height -= vertical_separator; - cell_area.x += horizontal_separator/2; - cell_area.y += vertical_separator/2; - break; - } - - if (column == NULL) - { - gtk_tree_path_free (path); + if (!find_click (tree_view, event->x, event->y, &node, &column, + &background_area, &cell_area)) + { grab_focus_and_unset_draw_keyfocus (tree_view); - return FALSE; - } + return FALSE; + } tree_view->priv->focus_column = column; - /* decide if we edit */ - if (event->type == GDK_BUTTON_PRESS && event->button == 1 && - !(event->state & gtk_accelerator_get_default_mod_mask ())) - { - GtkTreePath *anchor; - GtkTreeIter iter; - - gtk_tree_model_get_iter (tree_view->priv->model, &iter, path); - pspp_sheet_view_column_cell_set_cell_data (column, - tree_view->priv->model, - &iter); - - if (tree_view->priv->anchor) - anchor = gtk_tree_row_reference_get_path (tree_view->priv->anchor); - else - anchor = NULL; - - if ((anchor && !gtk_tree_path_compare (anchor, path)) - || !_pspp_sheet_view_column_has_editable_cell (column)) - { - GtkCellEditable *cell_editable = NULL; - - /* FIXME: get the right flags */ - guint flags = 0; - - path_string = gtk_tree_path_to_string (path); - - if (_pspp_sheet_view_column_cell_event (column, - &cell_editable, - (GdkEvent *)event, - path_string, - &background_area, - &cell_area, flags)) - { - if (cell_editable != NULL) - { - gint left, right; - GdkRectangle area; - - area = cell_area; - _pspp_sheet_view_column_get_neighbor_sizes (column, _pspp_sheet_view_column_get_edited_cell (column), &left, &right); - - area.x += left; - area.width -= right + left; - - pspp_sheet_view_real_start_editing (tree_view, - column, - path, - cell_editable, - &area, - (GdkEvent *)event, - flags); - g_free (path_string); - gtk_tree_path_free (path); - gtk_tree_path_free (anchor); - return TRUE; - } - column_handled_click = TRUE; - } - g_free (path_string); - } - if (anchor) - gtk_tree_path_free (anchor); - } + if (pspp_sheet_view_row_head_clicked (tree_view, node, column, event)) + return TRUE; /* select */ - node_selected = pspp_sheet_view_node_is_selected (tree_view, node); - 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); /* we only handle selection modifications on the first button press */ if (event->type == GDK_BUTTON_PRESS) { + PsppSheetSelectionMode mode = 0; + if ((event->state & GDK_CONTROL_MASK) == GDK_CONTROL_MASK) - tree_view->priv->ctrl_pressed = TRUE; + mode |= PSPP_SHEET_SELECT_MODE_TOGGLE; if ((event->state & GDK_SHIFT_MASK) == GDK_SHIFT_MASK) - tree_view->priv->shift_pressed = TRUE; + mode |= PSPP_SHEET_SELECT_MODE_EXTEND; focus_cell = _pspp_sheet_view_column_get_cell_at_pos (column, event->x - background_area.x); if (focus_cell) @@ -2225,28 +2435,33 @@ pspp_sheet_view_button_press (GtkWidget *widget, if (event->state & GDK_CONTROL_MASK) { - pspp_sheet_view_real_set_cursor (tree_view, path, FALSE, TRUE); + pspp_sheet_view_real_set_cursor (tree_view, path, FALSE, TRUE, mode); pspp_sheet_view_real_toggle_cursor_row (tree_view); } else if (event->state & GDK_SHIFT_MASK) { - pspp_sheet_view_real_set_cursor (tree_view, path, FALSE, TRUE); - pspp_sheet_view_real_select_cursor_row (tree_view, FALSE); + pspp_sheet_view_real_set_cursor (tree_view, path, TRUE, TRUE, mode); + pspp_sheet_view_real_select_cursor_row (tree_view, FALSE, mode); } else { - pspp_sheet_view_real_set_cursor (tree_view, path, TRUE, TRUE); + pspp_sheet_view_real_set_cursor (tree_view, path, TRUE, TRUE, 0); } - tree_view->priv->ctrl_pressed = FALSE; - tree_view->priv->shift_pressed = FALSE; + if (tree_view->priv->anchor_column == NULL || + !(event->state & GDK_SHIFT_MASK)) + tree_view->priv->anchor_column = column; + pspp_sheet_selection_unselect_all_columns (tree_view->priv->selection); + pspp_sheet_selection_select_column_range (tree_view->priv->selection, + tree_view->priv->anchor_column, + column); } /* the treeview may have been scrolled because of _set_cursor, * 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; @@ -2254,17 +2469,17 @@ pspp_sheet_view_button_press (GtkWidget *widget, /* Save press to possibly begin a drag */ - if (!column_handled_click && - !tree_view->priv->in_grab && + if (!tree_view->priv->in_grab && tree_view->priv->pressed_button < 0) { tree_view->priv->pressed_button = event->button; tree_view->priv->press_start_x = event->x; tree_view->priv->press_start_y = event->y; + tree_view->priv->press_start_node = node; if (tree_view->priv->rubber_banding_enable - && !node_selected - && tree_view->priv->selection->type == GTK_SELECTION_MULTIPLE) + && (tree_view->priv->selection->type == PSPP_SHEET_SELECTION_MULTIPLE || + tree_view->priv->selection->type == PSPP_SHEET_SELECTION_RECTANGLE)) { tree_view->priv->press_start_y += tree_view->priv->dy; tree_view->priv->rubber_band_x = event->x; @@ -2275,6 +2490,7 @@ pspp_sheet_view_button_press (GtkWidget *widget, tree_view->priv->rubber_band_ctrl = TRUE; if ((event->state & GDK_SHIFT_MASK) == GDK_SHIFT_MASK) tree_view->priv->rubber_band_shift = TRUE; + } } @@ -2354,7 +2570,7 @@ pspp_sheet_view_button_press (GtkWidget *widget, gtk_grab_add (widget); PSPP_SHEET_VIEW_SET_FLAG (tree_view, PSPP_SHEET_VIEW_IN_COLUMN_RESIZE); - column->resized_width = column->width - tree_view->priv->last_extra_space_per_column; + column->resized_width = column->width; /* block attached dnd signal handler */ drag_data = g_object_get_data (G_OBJECT (widget), "gtk-site-data"); @@ -2365,7 +2581,7 @@ pspp_sheet_view_button_press (GtkWidget *widget, drag_data); tree_view->priv->drag_pos = i; - tree_view->priv->x_drag = column->button->allocation.x + (rtl ? 0 : column->button->allocation.width); + tree_view->priv->x_drag = column->allocation.x + (rtl ? 0 : column->allocation.width); if (!gtk_widget_has_focus (widget)) gtk_widget_grab_focus (widget); @@ -2392,6 +2608,8 @@ pspp_sheet_view_button_release_drag_column (GtkWidget *widget, gdk_display_keyboard_ungrab (gtk_widget_get_display (widget), GDK_CURRENT_TIME); /* Move the button back */ + g_return_val_if_fail (tree_view->priv->drag_column->button, FALSE); + g_object_ref (tree_view->priv->drag_column->button); gtk_container_remove (GTK_CONTAINER (tree_view), tree_view->priv->drag_column->button); gtk_widget_set_parent_window (tree_view->priv->drag_column->button, tree_view->priv->header_window); @@ -2463,17 +2681,108 @@ 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_drawable_get_display (event->window), + gdk_display_pointer_ungrab (gdk_window_get_display (event->window), event->time); return TRUE; } +static gboolean +pspp_sheet_view_button_release_edit (PsppSheetView *tree_view, + GdkEventButton *event) +{ + GtkCellEditable *cell_editable; + gchar *path_string; + GtkTreePath *path; + gint left, right; + GtkTreeIter iter; + PsppSheetViewColumn *column; + GdkRectangle background_area; + GdkRectangle cell_area; + GdkRectangle area; + guint modifiers; + guint flags; + int node; + + if (event->window != tree_view->priv->bin_window) + return FALSE; + + /* Ignore a released button, if that button wasn't depressed */ + if (tree_view->priv->pressed_button != event->button) + return FALSE; + + if (!find_click (tree_view, event->x, event->y, &node, &column, &background_area, + &cell_area)) + return FALSE; + + /* decide if we edit */ + path = _pspp_sheet_view_find_path (tree_view, node); + modifiers = event->state & gtk_accelerator_get_default_mod_mask (); + if (event->button != 1 || modifiers) + return FALSE; + + gtk_tree_model_get_iter (tree_view->priv->model, &iter, path); + pspp_sheet_view_column_cell_set_cell_data (column, + tree_view->priv->model, + &iter); + + if (!pspp_sheet_view_column_get_quick_edit (column) + && _pspp_sheet_view_column_has_editable_cell (column)) + return FALSE; + + flags = 0; /* FIXME: get the right flags */ + path_string = gtk_tree_path_to_string (path); + + if (!_pspp_sheet_view_column_cell_event (column, + &cell_editable, + (GdkEvent *)event, + path_string, + &background_area, + &cell_area, flags)) + return FALSE; + + if (cell_editable == NULL) + return FALSE; + + pspp_sheet_view_real_set_cursor (tree_view, path, + TRUE, TRUE, 0); /* XXX mode? */ + gtk_widget_queue_draw (GTK_WIDGET (tree_view)); + + area = cell_area; + _pspp_sheet_view_column_get_neighbor_sizes ( + column, _pspp_sheet_view_column_get_edited_cell (column), &left, &right); + + area.x += left; + area.width -= right + left; + + pspp_sheet_view_real_start_editing (tree_view, + column, + path, + cell_editable, + &area, + (GdkEvent *)event, + flags); + g_free (path_string); + gtk_tree_path_free (path); + return TRUE; +} + static gboolean pspp_sheet_view_button_release (GtkWidget *widget, GdkEventButton *event) { PsppSheetView *tree_view = PSPP_SHEET_VIEW (widget); + pspp_sheet_view_stop_editing (tree_view, FALSE); + if (tree_view->priv->rubber_band_status != RUBBER_BAND_ACTIVE + && pspp_sheet_view_button_release_edit (tree_view, event)) + { + if (tree_view->priv->pressed_button == event->button) + tree_view->priv->pressed_button = -1; + + tree_view->priv->rubber_band_status = RUBBER_BAND_OFF; + return TRUE; + } + if (PSPP_SHEET_VIEW_FLAG_SET (tree_view, PSPP_SHEET_VIEW_IN_COLUMN_DRAG)) return pspp_sheet_view_button_release_drag_column (widget, event); @@ -2528,6 +2837,7 @@ do_prelight (PsppSheetView *tree_view, } } + static void prelight_or_select (PsppSheetView *tree_view, int node, @@ -2535,10 +2845,10 @@ prelight_or_select (PsppSheetView *tree_view, gint x, gint y) { - GtkSelectionMode mode = pspp_sheet_selection_get_mode (tree_view->priv->selection); + PsppSheetSelectionMode mode = pspp_sheet_selection_get_mode (tree_view->priv->selection); if (tree_view->priv->hover_selection && - (mode == GTK_SELECTION_SINGLE || mode == GTK_SELECTION_BROWSE) && + (mode == PSPP_SHEET_SELECTION_SINGLE || mode == PSPP_SHEET_SELECTION_BROWSE) && !(tree_view->priv->edited_column && tree_view->priv->edited_column->editable_widget)) { @@ -2553,13 +2863,13 @@ prelight_or_select (PsppSheetView *tree_view, if (pspp_sheet_view_node_is_selected (tree_view, node)) { PSPP_SHEET_VIEW_UNSET_FLAG (tree_view, PSPP_SHEET_VIEW_DRAW_KEYFOCUS); - pspp_sheet_view_real_set_cursor (tree_view, path, FALSE, FALSE); + pspp_sheet_view_real_set_cursor (tree_view, path, FALSE, FALSE, 0); /* XXX mode? */ } gtk_tree_path_free (path); } } - else if (mode == GTK_SELECTION_SINGLE) + else if (mode == PSPP_SHEET_SELECTION_SINGLE) pspp_sheet_selection_unselect_all (tree_view->priv->selection); } @@ -2632,6 +2942,7 @@ update_prelight (PsppSheetView *tree_view, 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; @@ -2652,9 +2963,9 @@ pspp_sheet_view_motion_draw_column_motion_arrow (PsppSheetView *tree_view) GdkRectangle visible_rect; pspp_sheet_view_get_visible_rect (tree_view, &visible_rect); if (reorder->left_column) - x = reorder->left_column->button->allocation.x + reorder->left_column->button->allocation.width; + x = reorder->left_column->allocation.x + reorder->left_column->allocation.width; else - x = reorder->right_column->button->allocation.x; + x = reorder->right_column->allocation.x; if (x < visible_rect.x) arrow_type = DRAG_COLUMN_WINDOW_STATE_ARROW_LEFT; @@ -2683,8 +2994,8 @@ pspp_sheet_view_motion_draw_column_motion_arrow (PsppSheetView *tree_view) attributes.wclass = GDK_INPUT_OUTPUT; attributes.x = tree_view->priv->drag_column_x; attributes.y = 0; - width = attributes.width = tree_view->priv->drag_column->button->allocation.width; - height = attributes.height = tree_view->priv->drag_column->button->allocation.height; + width = attributes.width = tree_view->priv->drag_column->allocation.width; + height = attributes.height = tree_view->priv->drag_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; @@ -2720,13 +3031,13 @@ pspp_sheet_view_motion_draw_column_motion_arrow (PsppSheetView *tree_view) gdk_window_get_origin (tree_view->priv->header_window, &x, &y); if (reorder->left_column) { - x += reorder->left_column->button->allocation.x + reorder->left_column->button->allocation.width - width/2; - height = reorder->left_column->button->allocation.height; + x += reorder->left_column->allocation.x + reorder->left_column->allocation.width - width/2; + height = reorder->left_column->allocation.height; } else { - x += reorder->right_column->button->allocation.x - width/2; - height = reorder->right_column->button->allocation.height; + x += reorder->right_column->allocation.x - width/2; + height = reorder->right_column->allocation.height; } y -= tree_view->priv->expander_size/2; /* The arrow takes up only half the space */ height += tree_view->priv->expander_size; @@ -2794,14 +3105,14 @@ pspp_sheet_view_motion_draw_column_motion_arrow (PsppSheetView *tree_view) /* 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; if (reorder->left_column) - height = reorder->left_column->button->allocation.height; + height = reorder->left_column->allocation.height; else - height = reorder->right_column->button->allocation.height; + height = reorder->right_column->allocation.height; y -= tree_view->priv->expander_size; height += 2*tree_view->priv->expander_size; @@ -2870,6 +3181,7 @@ pspp_sheet_view_motion_draw_column_motion_arrow (PsppSheetView *tree_view) gdk_window_show (tree_view->priv->drag_highlight_window); gdk_window_raise (tree_view->priv->drag_highlight_window); +#endif } static gboolean @@ -2883,13 +3195,13 @@ pspp_sheet_view_motion_resize_column (GtkWidget *widget, 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); @@ -2898,8 +3210,10 @@ pspp_sheet_view_motion_resize_column (GtkWidget *widget, { column->use_resized_width = TRUE; column->resized_width = new_width; +#if 0 if (column->expand) column->resized_width -= tree_view->priv->last_extra_space_per_column; +#endif gtk_widget_queue_resize (widget); } @@ -2952,8 +3266,8 @@ pspp_sheet_view_vertical_autoscroll (PsppSheetView *tree_view) 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); } @@ -2979,8 +3293,8 @@ pspp_sheet_view_horizontal_autoscroll (PsppSheetView *tree_view) } 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; @@ -2994,6 +3308,7 @@ pspp_sheet_view_motion_drag_column (GtkWidget *widget, PsppSheetView *tree_view = (PsppSheetView *) widget; PsppSheetViewColumn *column = tree_view->priv->drag_column; gint x, y; + GtkAllocation allocation; /* Sanity Check */ if ((column == NULL) || @@ -3002,8 +3317,9 @@ pspp_sheet_view_motion_drag_column (GtkWidget *widget, /* 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->button->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 */ @@ -3043,7 +3359,7 @@ pspp_sheet_view_stop_rubber_band (PsppSheetView *tree_view) /* ... and the cursor to the end path */ tmp_path = _pspp_sheet_view_find_path (tree_view, tree_view->priv->rubber_band_end_node); - pspp_sheet_view_real_set_cursor (PSPP_SHEET_VIEW (tree_view), tmp_path, FALSE, FALSE); + pspp_sheet_view_real_set_cursor (PSPP_SHEET_VIEW (tree_view), tmp_path, FALSE, FALSE, 0); /* XXX mode? */ gtk_tree_path_free (tmp_path); _pspp_sheet_selection_emit_changed (tree_view->priv->selection); @@ -3243,14 +3559,17 @@ 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); old_area.y = MIN (tree_view->priv->press_start_y, tree_view->priv->rubber_band_y) - tree_view->priv->dy; @@ -3267,13 +3586,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; @@ -3281,22 +3601,42 @@ 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; + pspp_sheet_view_get_path_at_pos (tree_view, x, y, NULL, &column, NULL, NULL); + + pspp_sheet_selection_unselect_all_columns (tree_view->priv->selection); + pspp_sheet_selection_select_column_range (tree_view->priv->selection, + tree_view->priv->anchor_column, + column); + + gtk_widget_queue_draw (GTK_WIDGET (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) @@ -3304,7 +3644,9 @@ pspp_sheet_view_paint_rubber_band (PsppSheetView *tree_view, 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); rubber_rect.y = MIN (tree_view->priv->press_start_y, tree_view->priv->rubber_band_y) - tree_view->priv->dy; rubber_rect.width = ABS (tree_view->priv->press_start_x - tree_view->priv->rubber_band_x) + 1; @@ -3316,10 +3658,11 @@ pspp_sheet_view_paint_rubber_band (PsppSheetView *tree_view, 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); @@ -3327,9 +3670,9 @@ pspp_sheet_view_paint_rubber_band (PsppSheetView *tree_view, 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, @@ -3338,6 +3681,8 @@ pspp_sheet_view_paint_rubber_band (PsppSheetView *tree_view, cairo_destroy (cr); } +#endif + static gboolean pspp_sheet_view_motion_bin_window (GtkWidget *widget, @@ -3354,6 +3699,15 @@ pspp_sheet_view_motion_bin_window (GtkWidget *widget, if (tree_view->priv->rubber_band_status == RUBBER_BAND_MAYBE_START) { + GdkRectangle background_area, cell_area; + PsppSheetViewColumn *column; + + if (find_click (tree_view, event->x, event->y, &node, &column, + &background_area, &cell_area) + && tree_view->priv->focus_column == column + && tree_view->priv->press_start_node == node) + return FALSE; + gtk_grab_add (GTK_WIDGET (tree_view)); pspp_sheet_view_update_rubber_band (tree_view); @@ -3421,7 +3775,8 @@ invalidate_empty_focus (PsppSheetView *tree_view) 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); } @@ -3429,65 +3784,69 @@ 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; - 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) +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++) { PsppSheetViewColumn *column = list->data; - - /* We don't want a line for the last column */ - if (i == n_visible_columns - 1) - break; + gint x; if (! column->visible) continue; current_x += column->width; - if (current_x - 1 >= event->area.x - && current_x - 1 < event->area.x + event->area.width) - gdk_draw_line (event->window, - tree_view->priv->grid_line_gc, - current_x - 1, 0, - current_x - 1, height); + /* Generally the grid lines should fit within the column, but for the + last visible column we put it just past the end of the column. + (Otherwise horizontal grid lines sometimes stick out by one pixel.) */ + x = current_x; + if (i != n_visible_columns - 1) + x--; + + 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); } } @@ -3497,9 +3856,9 @@ pspp_sheet_view_draw_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; @@ -3511,7 +3870,6 @@ pspp_sheet_view_bin_expose (GtkWidget *widget, gint new_y; gint y_offset, cell_offset; gint max_height; - gint depth; GdkRectangle background_area; GdkRectangle cell_area; guint flags; @@ -3530,6 +3888,18 @@ pspp_sheet_view_bin_expose (GtkWidget *widget, gint grid_line_width; gboolean row_ending_details; gboolean draw_vgrid_lines, draw_hgrid_lines; + gint min_y, max_y; + + 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); @@ -3543,31 +3913,36 @@ 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) - 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; 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, @@ -3576,14 +3951,13 @@ 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); gtk_tree_model_get_iter (tree_view->priv->model, &iter, path); - depth = gtk_tree_path_get_depth (path); gtk_tree_path_free (path); cursor_path = NULL; @@ -3637,45 +4011,52 @@ pspp_sheet_view_bin_expose (GtkWidget *widget, * order, drawing each successive node. */ + min_y = y_offset; do { gboolean parity; gboolean is_first = FALSE; gboolean is_last = FALSE; gboolean done = FALSE; + gboolean selected; max_height = ROW_HEIGHT (tree_view); 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; flags = 0; if (node == tree_view->priv->prelight_node) flags |= GTK_CELL_RENDERER_PRELIT; - if (pspp_sheet_view_node_is_selected (tree_view, node)) - flags |= GTK_CELL_RENDERER_SELECTED; + selected = pspp_sheet_view_node_is_selected (tree_view, node); parity = node % 2; - /* 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)) + if (tree_view->priv->special_cells == PSPP_SHEET_VIEW_SPECIAL_CELLS_DETECT) { - PsppSheetViewColumn *column = list->data; - pspp_sheet_view_column_cell_set_cell_data (column, - tree_view->priv->model, - &iter); - } + /* 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); + 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; @@ -3683,17 +4064,30 @@ pspp_sheet_view_bin_expose (GtkWidget *widget, { PsppSheetViewColumn *column = list->data; const gchar *detail = NULL; + gboolean selected_column; GtkStateType state; if (!column->visible) continue; - if (cell_offset > event->area.x + event->area.width || - cell_offset + column->width < event->area.x) + if (tree_view->priv->selection->type == PSPP_SHEET_SELECTION_RECTANGLE) + selected_column = column->selected && column->selectable; + else + selected_column = TRUE; + +#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; + else + flags &= ~GTK_CELL_RENDERER_SELECTED; if (column->show_sort_indicator) flags |= GTK_CELL_RENDERER_SORTED; @@ -3738,12 +4132,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); @@ -3791,7 +4190,7 @@ pspp_sheet_view_bin_expose (GtkWidget *widget, 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; @@ -3818,11 +4217,10 @@ pspp_sheet_view_bin_expose (GtkWidget *widget, 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, @@ -3832,11 +4230,10 @@ pspp_sheet_view_bin_expose (GtkWidget *widget, } 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, @@ -3847,26 +4244,46 @@ pspp_sheet_view_bin_expose (GtkWidget *widget, if (draw_hgrid_lines) { - if (background_area.y > 0) - gdk_draw_line (event->window, - tree_view->priv->grid_line_gc, - 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, - 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 && @@ -3876,16 +4293,29 @@ pspp_sheet_view_bin_expose (GtkWidget *widget, (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 < Zarea.x) + { + gtk_paint_flat_box (gtk_widget_get_style (widget), + cr, + GTK_STATE_NORMAL, + GTK_SHADOW_NONE, + widget, + "base", + cell_offset, + background_area.y, + Zarea.x - cell_offset, + background_area.height); + } + if (node == drag_highlight) { /* Draw indicator for the drop @@ -3912,14 +4342,12 @@ pspp_sheet_view_bin_expose (GtkWidget *widget, 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" ) @@ -3929,10 +4357,9 @@ pspp_sheet_view_bin_expose (GtkWidget *widget, 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) @@ -3942,6 +4369,7 @@ pspp_sheet_view_bin_expose (GtkWidget *widget, break; } +#if GTK3_TRANSITION if (highlight_y >= 0) { gdk_draw_line (event->window, @@ -3951,6 +4379,7 @@ pspp_sheet_view_bin_expose (GtkWidget *widget, rtl ? 0 : bin_window_width, highlight_y); } +#endif } /* draw the big row-spanning focus rectangle, if needed */ @@ -3968,8 +4397,7 @@ pspp_sheet_view_bin_expose (GtkWidget *widget, (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) { @@ -3983,10 +4411,9 @@ pspp_sheet_view_bin_expose (GtkWidget *widget, } 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" ) @@ -3994,10 +4421,9 @@ pspp_sheet_view_bin_expose (GtkWidget *widget, 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, @@ -4015,18 +4441,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_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; @@ -4041,6 +4469,7 @@ done: g_free (rectangles); } +#endif if (cursor_path) gtk_tree_path_free (cursor_path); @@ -4048,21 +4477,24 @@ 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); - - if (event->window == tree_view->priv->bin_window) + + 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 @@ -4074,36 +4506,54 @@ 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); + gtk_container_propagate_draw (GTK_CONTAINER (tree_view), child->widget, cr); } - - return retval; } - - else if (event->window == tree_view->priv->header_window) + if (gtk_cairo_should_draw_window (cr, tree_view->priv->header_window)) { + gint n_visible_columns; GList *list; - + for (list = tree_view->priv->columns; list != NULL; list = list->next) { PsppSheetViewColumn *column = list->data; - if (column == tree_view->priv->drag_column) + if (column == tree_view->priv->drag_column || !column->visible) continue; - if (column->visible) - gtk_container_propagate_expose (GTK_CONTAINER (tree_view), - column->button, - event); + if (span_intersects (column->allocation.x, column->allocation.width, + (int) gtk_adjustment_get_value (tree_view->priv->hadjustment), + (int) gtk_widget_get_allocated_width (widget)) + && column->button != NULL) + gtk_container_propagate_draw (GTK_CONTAINER (tree_view), + column->button, cr); } + + n_visible_columns = 0; + for (list = tree_view->priv->columns; list; list = list->next) + { + if (! PSPP_SHEET_VIEW_COLUMN (list->data)->visible) + 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, + 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; + + return FALSE; } enum @@ -4353,7 +4803,7 @@ pspp_sheet_view_key_press (GtkWidget *widget, { PsppSheetViewColumn *column = PSPP_SHEET_VIEW_COLUMN (focus_column->data); - if (gtk_widget_has_focus (column->button)) + if (column->button && gtk_widget_has_focus (column->button)) break; } @@ -4382,7 +4832,7 @@ pspp_sheet_view_key_press (GtkWidget *widget, column->resized_width = 0; if (column->min_width == -1) - column->resized_width = MAX (column->button->requisition.width, + column->resized_width = MAX (column->button_request, column->resized_width); else column->resized_width = MAX (column->min_width, @@ -4505,7 +4955,7 @@ pspp_sheet_view_key_press (GtkWidget *widget, 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, @@ -4656,15 +5106,16 @@ static void 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); } @@ -4678,9 +5129,9 @@ node_is_visible (PsppSheetView *tree_view, 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; @@ -4699,7 +5150,6 @@ validate_row (PsppSheetView *tree_view, gint horizontal_separator; gint vertical_separator; gint focus_line_width; - gboolean retval = FALSE; gboolean draw_vgrid_lines, draw_hgrid_lines; gint focus_pad; gint grid_line_width; @@ -4762,10 +5212,7 @@ validate_row (PsppSheetView *tree_view, } if (tmp_width > column->requested_width) - { - retval = TRUE; - column->requested_width = tmp_width; - } + column->requested_width = tmp_width; } if (draw_hgrid_lines) @@ -4787,6 +5234,7 @@ validate_visible_area (PsppSheetView *tree_view) gint total_height; gint area_above = 0; gint area_below = 0; + GtkAllocation allocation; if (tree_view->priv->row_count == 0) return; @@ -4794,7 +5242,9 @@ validate_visible_area (PsppSheetView *tree_view) 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; @@ -4826,39 +5276,39 @@ validate_visible_area (PsppSheetView *tree_view) 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; } } @@ -4964,8 +5414,8 @@ validate_visible_area (PsppSheetView *tree_view) * 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)); @@ -4990,6 +5440,9 @@ initialize_fixed_height_mode (PsppSheetView *tree_view) if (!tree_view->priv->row_count) return; + if (tree_view->priv->fixed_height_set) + return; + if (tree_view->priv->fixed_height < 0) { GtkTreeIter iter; @@ -5003,6 +5456,8 @@ initialize_fixed_height_mode (PsppSheetView *tree_view) tree_view->priv->fixed_height = validate_row (tree_view, node, &iter, path); gtk_tree_path_free (path); + + g_object_notify (G_OBJECT (tree_view), "fixed-height"); } } @@ -5033,10 +5488,13 @@ do_presize_handler (PsppSheetView *tree_view) validate_visible_area (tree_view); tree_view->priv->presize_handler_timer = 0; + if (! gtk_widget_get_realized (GTK_WIDGET (tree_view))) + return FALSE; + 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)); @@ -5073,7 +5531,7 @@ install_presize_handler (PsppSheetView *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); @@ -5195,8 +5653,8 @@ pspp_sheet_view_top_row_to_dy (PsppSheetView *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); @@ -5472,6 +5930,7 @@ scroll_row_timeout (gpointer data) { PsppSheetView *tree_view = data; + pspp_sheet_view_horizontal_autoscroll (tree_view); pspp_sheet_view_vertical_autoscroll (tree_view); if (tree_view->priv->rubber_band_status == RUBBER_BAND_ACTIVE) @@ -5582,7 +6041,7 @@ out: { 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) @@ -5590,7 +6049,7 @@ out: /* 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; } @@ -5730,10 +6189,12 @@ pspp_sheet_view_maybe_begin_dragging_row (PsppSheetView *tree_view, } + 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; @@ -5771,8 +6232,10 @@ pspp_sheet_view_drag_begin (GtkWidget *widget, g_object_unref (row_pix); gtk_tree_path_free (path); +#endif } + static void pspp_sheet_view_drag_end (GtkWidget *widget, GdkDragContext *context) @@ -5822,7 +6285,7 @@ pspp_sheet_view_drag_data_get (GtkWidget *widget, 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, @@ -6099,7 +6562,7 @@ pspp_sheet_view_drag_data_received (GtkWidget *widget, if (dest_row == NULL) return; - if (selection_data->length >= 0) + if (gtk_selection_data_get_length (selection_data) >= 0) { if (path_down_mode) { @@ -6110,7 +6573,7 @@ pspp_sheet_view_drag_data_received (GtkWidget *widget, } } - 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, @@ -6120,7 +6583,7 @@ pspp_sheet_view_drag_data_received (GtkWidget *widget, 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 @@ -6222,6 +6685,9 @@ pspp_sheet_view_has_special_cell (PsppSheetView *tree_view) { GList *list; + if (tree_view->priv->special_cells != PSPP_SHEET_VIEW_SPECIAL_CELLS_DETECT) + return tree_view->priv->special_cells = PSPP_SHEET_VIEW_SPECIAL_CELLS_YES; + for (list = tree_view->priv->columns; list; list = list->next) { if (!((PsppSheetViewColumn *)list->data)->visible) @@ -6233,6 +6699,22 @@ pspp_sheet_view_has_special_cell (PsppSheetView *tree_view) return FALSE; } +static void +pspp_sheet_view_focus_column (PsppSheetView *tree_view, + PsppSheetViewColumn *focus_column, + gboolean clamp_column_visible) +{ + g_return_if_fail (focus_column != NULL); + + tree_view->priv->focus_column = focus_column; + + if (gtk_container_get_focus_child (GTK_CONTAINER (tree_view)) != focus_column->button) + gtk_widget_grab_focus (focus_column->button); + + if (clamp_column_visible) + pspp_sheet_view_clamp_column_visible (tree_view, focus_column, FALSE); +} + /* Returns TRUE if the focus is within the headers, after the focus operation is * done */ @@ -6242,7 +6724,7 @@ pspp_sheet_view_header_focus (PsppSheetView *tree_view, gboolean clamp_column_visible) { GtkWidget *focus_child; - + PsppSheetViewColumn *focus_column; GList *last_column, *first_column; GList *tmp_list; gboolean rtl; @@ -6250,15 +6732,14 @@ pspp_sheet_view_header_focus (PsppSheetView *tree_view, 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_get_can_focus (PSPP_SHEET_VIEW_COLUMN (first_column->data)->button) && - PSPP_SHEET_VIEW_COLUMN (first_column->data)->visible && - (PSPP_SHEET_VIEW_COLUMN (first_column->data)->clickable || - PSPP_SHEET_VIEW_COLUMN (first_column->data)->reorderable)) + PsppSheetViewColumn *c = PSPP_SHEET_VIEW_COLUMN (first_column->data); + + if (pspp_sheet_view_column_can_focus (c) && c->visible) break; first_column = first_column->next; } @@ -6271,10 +6752,9 @@ pspp_sheet_view_header_focus (PsppSheetView *tree_view, last_column = g_list_last (tree_view->priv->columns); while (last_column) { - if (gtk_widget_get_can_focus (PSPP_SHEET_VIEW_COLUMN (last_column->data)->button) && - PSPP_SHEET_VIEW_COLUMN (last_column->data)->visible && - (PSPP_SHEET_VIEW_COLUMN (last_column->data)->clickable || - PSPP_SHEET_VIEW_COLUMN (last_column->data)->reorderable)) + PsppSheetViewColumn *c = PSPP_SHEET_VIEW_COLUMN (last_column->data); + + if (pspp_sheet_view_column_can_focus (c) && c->visible) break; last_column = last_column->prev; } @@ -6291,12 +6771,13 @@ pspp_sheet_view_header_focus (PsppSheetView *tree_view, if (focus_child == NULL) { if (tree_view->priv->focus_column != NULL && - gtk_widget_get_can_focus (tree_view->priv->focus_column->button)) - focus_child = tree_view->priv->focus_column->button; + pspp_sheet_view_column_can_focus (tree_view->priv->focus_column)) + focus_column = tree_view->priv->focus_column; else - focus_child = PSPP_SHEET_VIEW_COLUMN (first_column->data)->button; - gtk_widget_grab_focus (focus_child); - break; + focus_column = first_column->data; + pspp_sheet_view_focus_column (tree_view, focus_column, + clamp_column_visible); + return TRUE; } return FALSE; @@ -6305,20 +6786,25 @@ pspp_sheet_view_header_focus (PsppSheetView *tree_view, if (focus_child == NULL) { if (tree_view->priv->focus_column != NULL) - focus_child = tree_view->priv->focus_column->button; + focus_column = tree_view->priv->focus_column; else if (dir == GTK_DIR_LEFT) - focus_child = PSPP_SHEET_VIEW_COLUMN (last_column->data)->button; + focus_column = last_column->data; else - focus_child = PSPP_SHEET_VIEW_COLUMN (first_column->data)->button; - gtk_widget_grab_focus (focus_child); - break; + focus_column = first_column->data; + pspp_sheet_view_focus_column (tree_view, focus_column, + clamp_column_visible); + return TRUE; } if (gtk_widget_child_focus (focus_child, dir)) { /* The focus moves inside the button. */ /* This is probably a great example of bad UI */ - break; + if (clamp_column_visible) + pspp_sheet_view_clamp_column_visible (tree_view, + tree_view->priv->focus_column, + FALSE); + return TRUE; } /* We need to move the focus among the row of buttons. */ @@ -6330,7 +6816,7 @@ pspp_sheet_view_header_focus (PsppSheetView *tree_view, || (tmp_list == last_column && dir == (rtl ? GTK_DIR_LEFT : GTK_DIR_RIGHT))) { gtk_widget_error_bell (GTK_WIDGET (tree_view)); - break; + return TRUE; } while (tmp_list) @@ -6348,45 +6834,30 @@ pspp_sheet_view_header_focus (PsppSheetView *tree_view, break; } column = tmp_list->data; - if (column->button && - column->visible && - gtk_widget_get_can_focus (column->button)) - { - focus_child = column->button; - gtk_widget_grab_focus (column->button); - break; + if (column->visible && + pspp_sheet_view_column_can_focus (column)) + { + if (column->button) + { + pspp_sheet_view_focus_column (tree_view, column, + clamp_column_visible); + return TRUE; + } } } - break; + return FALSE; + default: g_assert_not_reached (); break; } - /* if focus child is non-null, we assume it's been set to the current focus child - */ - if (focus_child) - { - for (tmp_list = tree_view->priv->columns; tmp_list; tmp_list = tmp_list->next) - if (PSPP_SHEET_VIEW_COLUMN (tmp_list->data)->button == focus_child) - { - tree_view->priv->focus_column = PSPP_SHEET_VIEW_COLUMN (tmp_list->data); - break; - } - - if (clamp_column_visible) - { - pspp_sheet_view_clamp_column_visible (tree_view, - tree_view->priv->focus_column, - FALSE); - } - } - - return (focus_child != NULL); + return FALSE; } /* This function returns in 'path' the first focusable path, if the given path * is already focusable, it's the returned one. + * */ static gboolean search_first_focusable_path (PsppSheetView *tree_view, @@ -6394,6 +6865,8 @@ search_first_focusable_path (PsppSheetView *tree_view, gboolean search_forward, int *new_node) { + /* XXX this function is trivial given that the sheetview doesn't support + separator rows */ int node = -1; if (!path || !*path) @@ -6421,7 +6894,7 @@ pspp_sheet_view_focus (GtkWidget *widget, 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. */ @@ -6483,10 +6956,8 @@ pspp_sheet_view_style_set (GtkWidget *widget, 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]); - gtk_style_set_background (widget->style, tree_view->priv->header_window, GTK_STATE_NORMAL); - + 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); } @@ -6503,6 +6974,13 @@ pspp_sheet_view_style_set (GtkWidget *widget, tree_view->priv->fixed_height = -1; + /* Invalidate cached button style. */ + if (tree_view->priv->button_style) + { + g_object_unref (tree_view->priv->button_style); + tree_view->priv->button_style = NULL; + } + gtk_widget_queue_resize (widget); } @@ -6592,6 +7070,7 @@ pspp_sheet_view_real_move_cursor (PsppSheetView *tree_view, GtkMovementStep step, gint count) { + PsppSheetSelectMode mode; GdkModifierType state; g_return_val_if_fail (PSPP_IS_SHEET_VIEW (tree_view), FALSE); @@ -6599,7 +7078,8 @@ pspp_sheet_view_real_move_cursor (PsppSheetView *tree_view, step == GTK_MOVEMENT_VISUAL_POSITIONS || step == GTK_MOVEMENT_DISPLAY_LINES || step == GTK_MOVEMENT_PAGES || - step == GTK_MOVEMENT_BUFFER_ENDS, FALSE); + step == GTK_MOVEMENT_BUFFER_ENDS || + step == GTK_MOVEMENT_DISPLAY_LINE_ENDS, FALSE); if (tree_view->priv->row_count == 0) return FALSE; @@ -6610,38 +7090,40 @@ pspp_sheet_view_real_move_cursor (PsppSheetView *tree_view, PSPP_SHEET_VIEW_SET_FLAG (tree_view, PSPP_SHEET_VIEW_DRAW_KEYFOCUS); gtk_widget_grab_focus (GTK_WIDGET (tree_view)); + mode = 0; if (gtk_get_current_event_state (&state)) { if ((state & GDK_CONTROL_MASK) == GDK_CONTROL_MASK) - tree_view->priv->ctrl_pressed = TRUE; + mode |= PSPP_SHEET_SELECT_MODE_TOGGLE; if ((state & GDK_SHIFT_MASK) == GDK_SHIFT_MASK) - tree_view->priv->shift_pressed = TRUE; + mode |= PSPP_SHEET_SELECT_MODE_EXTEND; } /* else we assume not pressed */ switch (step) { - /* currently we make no distinction. When we go bi-di, we need to */ case GTK_MOVEMENT_LOGICAL_POSITIONS: + pspp_sheet_view_move_cursor_tab (tree_view, count); + break; case GTK_MOVEMENT_VISUAL_POSITIONS: - pspp_sheet_view_move_cursor_left_right (tree_view, count); + pspp_sheet_view_move_cursor_left_right (tree_view, count, mode); break; case GTK_MOVEMENT_DISPLAY_LINES: - pspp_sheet_view_move_cursor_up_down (tree_view, count); + pspp_sheet_view_move_cursor_up_down (tree_view, count, mode); break; case GTK_MOVEMENT_PAGES: - pspp_sheet_view_move_cursor_page_up_down (tree_view, count); + pspp_sheet_view_move_cursor_page_up_down (tree_view, count, mode); break; case GTK_MOVEMENT_BUFFER_ENDS: - pspp_sheet_view_move_cursor_start_end (tree_view, count); + pspp_sheet_view_move_cursor_start_end (tree_view, count, mode); + break; + case GTK_MOVEMENT_DISPLAY_LINE_ENDS: + pspp_sheet_view_move_cursor_line_start_end (tree_view, count, mode); break; default: g_assert_not_reached (); } - tree_view->priv->ctrl_pressed = FALSE; - tree_view->priv->shift_pressed = FALSE; - return TRUE; } @@ -6961,9 +7443,9 @@ pspp_sheet_view_clamp_node_visible (PsppSheetView *tree_view, /* 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); @@ -6987,10 +7469,10 @@ pspp_sheet_view_clamp_column_visible (PsppSheetView *tree_view, if (column == NULL) return; - x = column->button->allocation.x; - width = column->button->allocation.width; + 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 @@ -7025,28 +7507,28 @@ pspp_sheet_view_clamp_column_visible (PsppSheetView *tree_view, 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); } } @@ -7198,15 +7680,13 @@ pspp_sheet_view_set_column_drag_info (PsppSheetView *tree_view, if (tmp_list->next != NULL) { g_assert (tmp_list->next->data); - left = reorder->right_align = (reorder->right_column->button->allocation.x + - reorder->right_column->button->allocation.width + - ((PsppSheetViewColumnReorder *)tmp_list->next->data)->left_column->button->allocation.x)/2; + left = reorder->right_align = (reorder->right_column->allocation.x + + reorder->right_column->allocation.width + + ((PsppSheetViewColumnReorder *)tmp_list->next->data)->left_column->allocation.x)/2; } 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); } } @@ -7218,12 +7698,13 @@ _pspp_sheet_view_column_start_drag (PsppSheetView *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); g_return_if_fail (tree_view->priv->column_drag_info == NULL); g_return_if_fail (tree_view->priv->cur_reorder == NULL); + g_return_if_fail (column->button); pspp_sheet_view_set_column_drag_info (tree_view, column); @@ -7237,14 +7718,13 @@ _pspp_sheet_view_column_start_drag (PsppSheetView *tree_view, attributes.window_type = GDK_WINDOW_CHILD; attributes.wclass = GDK_INPUT_OUTPUT; - attributes.x = column->button->allocation.x; + attributes.x = column->allocation.x; attributes.y = 0; - attributes.width = column->button->allocation.width; - attributes.height = column->button->allocation.height; + 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, @@ -7259,7 +7739,7 @@ _pspp_sheet_view_column_start_drag (PsppSheetView *tree_view, 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; @@ -7276,7 +7756,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; @@ -7290,8 +7772,8 @@ _pspp_sheet_view_column_start_drag (PsppSheetView *tree_view, gtk_widget_set_parent (column->button, GTK_WIDGET (tree_view)); g_object_unref (column->button); - tree_view->priv->drag_column_x = column->button->allocation.x; - allocation = column->button->allocation; + tree_view->priv->drag_column_x = column->allocation.x; + allocation = column->allocation; allocation.x = 0; gtk_widget_size_allocate (column->button, &allocation); gtk_widget_set_parent_window (column->button, tree_view->priv->drag_window); @@ -7300,7 +7782,6 @@ _pspp_sheet_view_column_start_drag (PsppSheetView *tree_view, 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 ()) @@ -7322,12 +7803,14 @@ _pspp_sheet_view_queue_draw_node (PsppSheetView *tree_view, 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); @@ -7375,8 +7858,8 @@ pspp_sheet_view_focus_to_cursor (PsppSheetView *tree_view) if (cursor_path == NULL) { - /* Consult the selection before defaulting to the - * first focusable element + /* There's no cursor. Move the cursor to the first selected row, if any + * are selected, otherwise to the first row in the sheetview. */ GList *selected_rows; GtkTreeModel *model; @@ -7387,6 +7870,7 @@ pspp_sheet_view_focus_to_cursor (PsppSheetView *tree_view) if (selected_rows) { + /* XXX we could avoid doing O(n) work to get this result */ cursor_path = gtk_tree_path_copy((const GtkTreePath *)(selected_rows->data)); g_list_foreach (selected_rows, (GFunc)gtk_tree_path_free, NULL); g_list_free (selected_rows); @@ -7403,15 +7887,17 @@ pspp_sheet_view_focus_to_cursor (PsppSheetView *tree_view) if (cursor_path) { - if (tree_view->priv->selection->type == GTK_SELECTION_MULTIPLE) - pspp_sheet_view_real_set_cursor (tree_view, cursor_path, FALSE, FALSE); + if (tree_view->priv->selection->type == PSPP_SHEET_SELECTION_MULTIPLE || + tree_view->priv->selection->type == PSPP_SHEET_SELECTION_RECTANGLE) + pspp_sheet_view_real_set_cursor (tree_view, cursor_path, FALSE, FALSE, 0); else - pspp_sheet_view_real_set_cursor (tree_view, cursor_path, TRUE, FALSE); + pspp_sheet_view_real_set_cursor (tree_view, cursor_path, TRUE, FALSE, 0); } } if (cursor_path) { + /* Now find a column for the cursor. */ PSPP_SHEET_VIEW_SET_FLAG (tree_view, PSPP_SHEET_VIEW_DRAW_KEYFOCUS); pspp_sheet_view_queue_draw_path (tree_view, cursor_path, NULL); @@ -7425,16 +7911,20 @@ pspp_sheet_view_focus_to_cursor (PsppSheetView *tree_view) if (PSPP_SHEET_VIEW_COLUMN (list->data)->visible) { tree_view->priv->focus_column = PSPP_SHEET_VIEW_COLUMN (list->data); + pspp_sheet_selection_unselect_all_columns (tree_view->priv->selection); + pspp_sheet_selection_select_column (tree_view->priv->selection, tree_view->priv->focus_column); break; } } + } } } -static void +static gboolean pspp_sheet_view_move_cursor_up_down (PsppSheetView *tree_view, - gint count) + gint count, + PsppSheetSelectMode mode) { gint selection_count; int cursor_node = -1; @@ -7443,25 +7933,25 @@ pspp_sheet_view_move_cursor_up_down (PsppSheetView *tree_view, gboolean grab_focus = TRUE; if (! gtk_widget_has_focus (GTK_WIDGET (tree_view))) - return; + return FALSE; cursor_path = NULL; if (!gtk_tree_row_reference_valid (tree_view->priv->cursor)) /* FIXME: we lost the cursor; should we get the first? */ - return; + return FALSE; cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor); _pspp_sheet_view_find_node (tree_view, cursor_path, &cursor_node); if (cursor_node < 0) /* FIXME: we lost the cursor; should we get the first? */ - return; + return FALSE; selection_count = pspp_sheet_selection_count_selected_rows (tree_view->priv->selection); if (selection_count == 0 - && tree_view->priv->selection->type != GTK_SELECTION_NONE - && !tree_view->priv->ctrl_pressed) + && tree_view->priv->selection->type != PSPP_SHEET_SELECTION_NONE + && !(mode & PSPP_SHEET_SELECT_MODE_TOGGLE)) { /* Don't move the cursor, but just select the current node */ new_cursor_node = cursor_node; @@ -7492,7 +7982,8 @@ pspp_sheet_view_move_cursor_up_down (PsppSheetView *tree_view, * If the list has only one item and multi-selection is set then select * the row (if not yet selected). */ - if (tree_view->priv->selection->type == GTK_SELECTION_MULTIPLE && + if ((tree_view->priv->selection->type == PSPP_SHEET_SELECTION_MULTIPLE || + tree_view->priv->selection->type == PSPP_SHEET_SELECTION_RECTANGLE) && new_cursor_node < 0) { if (count == -1) @@ -7514,14 +8005,14 @@ pspp_sheet_view_move_cursor_up_down (PsppSheetView *tree_view, if (new_cursor_node >= 0) { cursor_path = _pspp_sheet_view_find_path (tree_view, new_cursor_node); - pspp_sheet_view_real_set_cursor (tree_view, cursor_path, TRUE, TRUE); + pspp_sheet_view_real_set_cursor (tree_view, cursor_path, TRUE, TRUE, mode); gtk_tree_path_free (cursor_path); } else { pspp_sheet_view_clamp_node_visible (tree_view, cursor_node); - if (!tree_view->priv->shift_pressed) + if (!(mode & PSPP_SHEET_SELECT_MODE_EXTEND)) { if (! gtk_widget_keynav_failed (GTK_WIDGET (tree_view), count < 0 ? @@ -7546,11 +8037,14 @@ pspp_sheet_view_move_cursor_up_down (PsppSheetView *tree_view, if (grab_focus) gtk_widget_grab_focus (GTK_WIDGET (tree_view)); + + return new_cursor_node >= 0; } static void pspp_sheet_view_move_cursor_page_up_down (PsppSheetView *tree_view, - gint count) + gint count, + PsppSheetSelectMode mode) { int cursor_node = -1; GtkTreePath *old_cursor_path = NULL; @@ -7582,8 +8076,8 @@ pspp_sheet_view_move_cursor_page_up_down (PsppSheetView *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; @@ -7624,7 +8118,7 @@ pspp_sheet_view_move_cursor_page_up_down (PsppSheetView *tree_view, /* update y */ y = pspp_sheet_view_node_find_offset (tree_view, cursor_node); - pspp_sheet_view_real_set_cursor (tree_view, cursor_path, TRUE, FALSE); + pspp_sheet_view_real_set_cursor (tree_view, cursor_path, TRUE, FALSE, mode); y -= window_y; pspp_sheet_view_scroll_to_point (tree_view, -1, y); @@ -7643,7 +8137,8 @@ cleanup: static void pspp_sheet_view_move_cursor_left_right (PsppSheetView *tree_view, - gint count) + gint count, + PsppSheetSelectMode mode) { int cursor_node = -1; GtkTreePath *cursor_path = NULL; @@ -7688,7 +8183,7 @@ pspp_sheet_view_move_cursor_left_right (PsppSheetView *tree_view, gboolean left, right; column = list->data; - if (column->visible == FALSE) + if (column->visible == FALSE || column->row_head) goto loop_end; pspp_sheet_view_column_cell_set_cell_data (column, @@ -7721,10 +8216,7 @@ pspp_sheet_view_move_cursor_left_right (PsppSheetView *tree_view, if (found_column) { - if (!pspp_sheet_view_has_special_cell (tree_view)) - _pspp_sheet_view_queue_draw_node (tree_view, - cursor_node, - NULL); + _pspp_sheet_view_queue_draw_node (tree_view, cursor_node, NULL); g_signal_emit (tree_view, tree_view_signals[CURSOR_CHANGED], 0); gtk_widget_grab_focus (GTK_WIDGET (tree_view)); } @@ -7737,9 +8229,209 @@ pspp_sheet_view_move_cursor_left_right (PsppSheetView *tree_view, tree_view->priv->focus_column, TRUE); } +static void +pspp_sheet_view_move_cursor_line_start_end (PsppSheetView *tree_view, + gint count, + PsppSheetSelectMode mode) +{ + int cursor_node = -1; + GtkTreePath *cursor_path = NULL; + PsppSheetViewColumn *column; + PsppSheetViewColumn *found_column; + GtkTreeIter iter; + GList *list; + gboolean rtl; + + rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL); + + if (!gtk_widget_has_focus (GTK_WIDGET (tree_view))) + return; + + if (gtk_tree_row_reference_valid (tree_view->priv->cursor)) + cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor); + else + return; + + _pspp_sheet_view_find_node (tree_view, cursor_path, &cursor_node); + if (cursor_node < 0) + return; + if (gtk_tree_model_get_iter (tree_view->priv->model, &iter, cursor_path) == FALSE) + { + gtk_tree_path_free (cursor_path); + return; + } + gtk_tree_path_free (cursor_path); + + list = rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns); + if (tree_view->priv->focus_column) + { + for (; list; list = (rtl ? list->prev : list->next)) + { + if (list->data == tree_view->priv->focus_column) + break; + } + } + + found_column = NULL; + while (list) + { + gboolean left, right; + + column = list->data; + if (column->visible == FALSE || column->row_head) + goto loop_end; + + pspp_sheet_view_column_cell_set_cell_data (column, + tree_view->priv->model, + &iter); + + if (rtl) + { + right = list->prev ? TRUE : FALSE; + left = list->next ? TRUE : FALSE; + } + else + { + left = list->prev ? TRUE : FALSE; + right = list->next ? TRUE : FALSE; + } + + if (column->tabbable + && _pspp_sheet_view_column_cell_focus (column, count, left, right)) + found_column = column; + + loop_end: + if (count == 1) + list = rtl ? list->prev : list->next; + else + list = rtl ? list->next : list->prev; + } + + if (found_column) + { + tree_view->priv->focus_column = found_column; + _pspp_sheet_view_queue_draw_node (tree_view, cursor_node, NULL); + g_signal_emit (tree_view, tree_view_signals[CURSOR_CHANGED], 0); + gtk_widget_grab_focus (GTK_WIDGET (tree_view)); + } + + pspp_sheet_view_clamp_column_visible (tree_view, + tree_view->priv->focus_column, TRUE); +} + +static gboolean +try_move_cursor_tab (PsppSheetView *tree_view, + gboolean start_at_focus_column, + gint count) +{ + PsppSheetViewColumn *column; + GtkTreeIter iter; + int cursor_node = -1; + GtkTreePath *cursor_path = NULL; + gboolean rtl; + GList *list; + + if (gtk_tree_row_reference_valid (tree_view->priv->cursor)) + cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor); + else + return TRUE; + + _pspp_sheet_view_find_node (tree_view, cursor_path, &cursor_node); + if (cursor_node < 0) + return TRUE; + if (gtk_tree_model_get_iter (tree_view->priv->model, &iter, cursor_path) == FALSE) + { + gtk_tree_path_free (cursor_path); + return TRUE; + } + gtk_tree_path_free (cursor_path); + + rtl = gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL; + if (start_at_focus_column) + { + list = (rtl + ? g_list_last (tree_view->priv->columns) + : g_list_first (tree_view->priv->columns)); + if (tree_view->priv->focus_column) + { + for (; list; list = (rtl ? list->prev : list->next)) + { + if (list->data == tree_view->priv->focus_column) + break; + } + } + } + else + { + list = (rtl ^ (count == 1) + ? g_list_first (tree_view->priv->columns) + : g_list_last (tree_view->priv->columns)); + } + + while (list) + { + gboolean left, right; + + column = list->data; + if (column->visible == FALSE || !column->tabbable) + goto loop_end; + + pspp_sheet_view_column_cell_set_cell_data (column, + tree_view->priv->model, + &iter); + + if (rtl) + { + right = list->prev ? TRUE : FALSE; + left = list->next ? TRUE : FALSE; + } + else + { + left = list->prev ? TRUE : FALSE; + right = list->next ? TRUE : FALSE; + } + + if (column->tabbable + && _pspp_sheet_view_column_cell_focus (column, count, left, right)) + { + tree_view->priv->focus_column = column; + _pspp_sheet_view_queue_draw_node (tree_view, cursor_node, NULL); + g_signal_emit (tree_view, tree_view_signals[CURSOR_CHANGED], 0); + gtk_widget_grab_focus (GTK_WIDGET (tree_view)); + return TRUE; + } + loop_end: + if (count == 1) + list = rtl ? list->prev : list->next; + else + list = rtl ? list->next : list->prev; + } + + return FALSE; +} + +static void +pspp_sheet_view_move_cursor_tab (PsppSheetView *tree_view, + gint count) +{ + if (!gtk_widget_has_focus (GTK_WIDGET (tree_view))) + return; + + if (!try_move_cursor_tab (tree_view, TRUE, count)) + { + if (pspp_sheet_view_move_cursor_up_down (tree_view, count, 0) + && !try_move_cursor_tab (tree_view, FALSE, count)) + gtk_widget_error_bell (GTK_WIDGET (tree_view)); + } + + pspp_sheet_view_clamp_column_visible (tree_view, + tree_view->priv->focus_column, TRUE); +} + static void pspp_sheet_view_move_cursor_start_end (PsppSheetView *tree_view, - gint count) + gint count, + PsppSheetSelectMode mode) { int cursor_node; GtkTreePath *path; @@ -7772,7 +8464,7 @@ pspp_sheet_view_move_cursor_start_end (PsppSheetView *tree_view, if (gtk_tree_path_compare (old_path, path)) { - pspp_sheet_view_real_set_cursor (tree_view, path, TRUE, TRUE); + pspp_sheet_view_real_set_cursor (tree_view, path, TRUE, TRUE, mode); gtk_widget_grab_focus (GTK_WIDGET (tree_view)); } else @@ -7791,7 +8483,8 @@ pspp_sheet_view_real_select_all (PsppSheetView *tree_view) if (!gtk_widget_has_focus (GTK_WIDGET (tree_view))) return FALSE; - if (tree_view->priv->selection->type != GTK_SELECTION_MULTIPLE) + if (tree_view->priv->selection->type != PSPP_SHEET_SELECTION_MULTIPLE && + tree_view->priv->selection->type != PSPP_SHEET_SELECTION_RECTANGLE) return FALSE; pspp_sheet_selection_select_all (tree_view->priv->selection); @@ -7805,7 +8498,8 @@ pspp_sheet_view_real_unselect_all (PsppSheetView *tree_view) if (!gtk_widget_has_focus (GTK_WIDGET (tree_view))) return FALSE; - if (tree_view->priv->selection->type != GTK_SELECTION_MULTIPLE) + if (tree_view->priv->selection->type != PSPP_SHEET_SELECTION_MULTIPLE && + tree_view->priv->selection->type != PSPP_SHEET_SELECTION_RECTANGLE) return FALSE; pspp_sheet_selection_unselect_all (tree_view->priv->selection); @@ -7815,12 +8509,12 @@ pspp_sheet_view_real_unselect_all (PsppSheetView *tree_view) static gboolean pspp_sheet_view_real_select_cursor_row (PsppSheetView *tree_view, - gboolean start_editing) + gboolean start_editing, + PsppSheetSelectMode mode) { int new_node = -1; int cursor_node = -1; GtkTreePath *cursor_path = NULL; - GtkTreeSelectMode mode = 0; if (!gtk_widget_has_focus (GTK_WIDGET (tree_view))) return FALSE; @@ -7840,7 +8534,7 @@ pspp_sheet_view_real_select_cursor_row (PsppSheetView *tree_view, return FALSE; } - if (!tree_view->priv->shift_pressed && start_editing && + if (!(mode & PSPP_SHEET_SELECT_MODE_EXTEND) && start_editing && tree_view->priv->focus_column) { if (pspp_sheet_view_start_editing (tree_view, cursor_path)) @@ -7850,11 +8544,6 @@ pspp_sheet_view_real_select_cursor_row (PsppSheetView *tree_view, } } - if (tree_view->priv->ctrl_pressed) - mode |= GTK_TREE_SELECT_MODE_TOGGLE; - if (tree_view->priv->shift_pressed) - mode |= GTK_TREE_SELECT_MODE_EXTEND; - _pspp_sheet_selection_internal_select_node (tree_view->priv->selection, cursor_node, cursor_path, @@ -7875,7 +8564,7 @@ pspp_sheet_view_real_select_cursor_row (PsppSheetView *tree_view, gtk_widget_grab_focus (GTK_WIDGET (tree_view)); _pspp_sheet_view_queue_draw_node (tree_view, cursor_node, NULL); - if (!tree_view->priv->shift_pressed) + if (!(mode & PSPP_SHEET_SELECT_MODE_EXTEND)) pspp_sheet_view_row_activated (tree_view, cursor_path, tree_view->priv->focus_column); @@ -7911,7 +8600,7 @@ pspp_sheet_view_real_toggle_cursor_row (PsppSheetView *tree_view) _pspp_sheet_selection_internal_select_node (tree_view->priv->selection, cursor_node, cursor_path, - GTK_TREE_SELECT_MODE_TOGGLE, + PSPP_SHEET_SELECT_MODE_TOGGLE, FALSE); /* We bail out if the original (tree, node) don't exist anymore after @@ -7948,22 +8637,11 @@ send_focus_change (GtkWidget *widget, { 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); } @@ -7981,11 +8659,11 @@ pspp_sheet_view_ensure_interactive_directory (PsppSheetView *tree_view) 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; @@ -7994,8 +8672,8 @@ pspp_sheet_view_ensure_interactive_directory (PsppSheetView *tree_view) 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), @@ -8033,10 +8711,14 @@ pspp_sheet_view_ensure_interactive_directory (PsppSheetView *tree_view) 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); @@ -8076,7 +8758,7 @@ pspp_sheet_view_real_start_interactive_search (PsppSheetView *tree_view, if (! column->visible) continue; - if (gtk_widget_has_focus (column->button)) + if (column->button && gtk_widget_has_focus (column->button)) { found_focus = TRUE; break; @@ -8147,24 +8829,22 @@ pspp_sheet_view_new_column_width (PsppSheetView *tree_view, 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); column = g_list_nth (tree_view->priv->columns, i)->data; - width = rtl ? (column->button->allocation.x + column->button->allocation.width - *x) : (*x - column->button->allocation.x); + width = rtl ? (column->allocation.x + column->allocation.width - *x) : (*x - column->allocation.x); /* Clamp down the value */ if (column->min_width == -1) - width = MAX (column->button->requisition.width, - width); + width = MAX (column->button_request, width); else - width = MAX (column->min_width, - width); + width = MAX (column->min_width, width); if (column->max_width != -1) width = MIN (width, column->max_width); - *x = rtl ? (column->button->allocation.x + column->button->allocation.width - width) : (column->button->allocation.x + width); + *x = rtl ? (column->allocation.x + column->allocation.width - width) : (column->allocation.x + width); return width; } @@ -8181,18 +8861,19 @@ typedef struct 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. @@ -8201,7 +8882,7 @@ adjust_allocation_recurse (GtkWidget *widget, { 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; @@ -8212,8 +8893,8 @@ adjust_allocation_recurse (GtkWidget *widget, { 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), @@ -8241,6 +8922,9 @@ adjust_allocation (GtkWidget *widget, adjust_allocation_recurse (widget, &scroll_data); } +void +pspp_sheet_view_column_update_button (PsppSheetViewColumn *tree_column); + /* Callbacks */ static void pspp_sheet_view_adjustment_changed (GtkAdjustment *adjustment, @@ -8248,15 +8932,16 @@ 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, - - 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, @@ -8286,17 +8971,14 @@ pspp_sheet_view_adjustment_changed (GtkAdjustment *adjustment, } 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); } - - gdk_window_process_updates (tree_view->priv->header_window, TRUE); - gdk_window_process_updates (tree_view->priv->bin_window, TRUE); } } @@ -8431,7 +9113,6 @@ pspp_sheet_view_set_model (PsppSheetView *tree_view, if (tree_view->priv->model) { gint i; - GtkTreeModelFlags flags; if (tree_view->priv->search_column == -1) { @@ -8465,8 +9146,6 @@ pspp_sheet_view_set_model (PsppSheetView *tree_view, G_CALLBACK (pspp_sheet_view_rows_reordered), tree_view); - flags = gtk_tree_model_get_flags (tree_view->priv->model); - tree_view->priv->row_count = gtk_tree_model_iter_n_children (tree_view->priv->model, NULL); /* FIXME: do I need to do this? pspp_sheet_view_create_buttons (tree_view); */ @@ -8512,9 +9191,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; } @@ -8538,23 +9220,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; } @@ -8564,17 +9283,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"); } @@ -8610,9 +9359,12 @@ pspp_sheet_view_set_headers_visible (PsppSheetView *tree_view, 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) @@ -8628,7 +9380,8 @@ pspp_sheet_view_set_headers_visible (PsppSheetView *tree_view, 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); @@ -8640,16 +9393,17 @@ pspp_sheet_view_set_headers_visible (PsppSheetView *tree_view, for (list = tree_view->priv->columns; list; list = list->next) { column = list->data; - gtk_widget_unmap (column->button); + if (column->button) + gtk_widget_unmap (column->button); } gdk_window_hide (tree_view->priv->header_window); } } - 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)); @@ -8854,7 +9608,8 @@ pspp_sheet_view_remove_column (PsppSheetView *tree_view, } if (tree_view->priv->n_columns == 0 && - pspp_sheet_view_get_headers_visible (tree_view)) + pspp_sheet_view_get_headers_visible (tree_view) && + tree_view->priv->header_window) gdk_window_hide (tree_view->priv->header_window); gtk_widget_queue_resize (GTK_WIDGET (tree_view)); @@ -9172,9 +9927,9 @@ pspp_sheet_view_scroll_to_point (PsppSheetView *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))); } /** @@ -9391,11 +10146,17 @@ pspp_sheet_view_set_reorderable (PsppSheetView *tree_view, g_object_notify (G_OBJECT (tree_view), "reorderable"); } +/* If CLEAR_AND_SELECT is true, then the row will be selected and, unless Shift + is pressed, other rows will be unselected. + + If CLAMP_NODE is true, then the sheetview will scroll to make the row + visible. */ static void pspp_sheet_view_real_set_cursor (PsppSheetView *tree_view, GtkTreePath *path, gboolean clear_and_select, - gboolean clamp_node) + gboolean clamp_node, + PsppSheetSelectMode mode) { int node = -1; @@ -9420,19 +10181,10 @@ pspp_sheet_view_real_set_cursor (PsppSheetView *tree_view, { int new_node = -1; - if (clear_and_select && !tree_view->priv->ctrl_pressed) - { - GtkTreeSelectMode mode = 0; - - if (tree_view->priv->ctrl_pressed) - mode |= GTK_TREE_SELECT_MODE_TOGGLE; - if (tree_view->priv->shift_pressed) - mode |= GTK_TREE_SELECT_MODE_EXTEND; - - _pspp_sheet_selection_internal_select_node (tree_view->priv->selection, + if (clear_and_select && !(mode & PSPP_SHEET_SELECT_MODE_TOGGLE)) + _pspp_sheet_selection_internal_select_node (tree_view->priv->selection, node, path, mode, FALSE); - } /* We have to re-find tree and node here again, somebody might have * cleared the node or the whole tree in the PsppSheetSelection::changed @@ -9566,7 +10318,7 @@ pspp_sheet_view_set_cursor_on_cell (PsppSheetView *tree_view, tree_view->priv->edited_column->editable_widget) pspp_sheet_view_stop_editing (tree_view, TRUE); - pspp_sheet_view_real_set_cursor (tree_view, path, TRUE, TRUE); + pspp_sheet_view_real_set_cursor (tree_view, path, TRUE, TRUE, 0); if (focus_column && focus_column->visible) { @@ -9585,6 +10337,10 @@ pspp_sheet_view_set_cursor_on_cell (PsppSheetView *tree_view, pspp_sheet_view_column_focus_cell (focus_column, focus_cell); if (start_editing) pspp_sheet_view_start_editing (tree_view, path); + + pspp_sheet_selection_unselect_all_columns (tree_view->priv->selection); + pspp_sheet_selection_select_column (tree_view->priv->selection, focus_column); + } } @@ -9661,7 +10417,7 @@ pspp_sheet_view_get_path_at_pos (PsppSheetView *tree_view, 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) @@ -9738,6 +10494,121 @@ pspp_sheet_view_get_path_at_pos (PsppSheetView *tree_view, return TRUE; } +/* Computes 'cell_area' from 'background_area', which must be the background + area for a cell. Set 'subtract_focus_rect' to TRUE to compute the cell area + as passed to a GtkCellRenderer's "render" function, or to FALSE to compute + the cell area as passed to _pspp_sheet_view_column_cell_render(). + + 'column' is required to properly adjust 'cell_area->x' and + 'cell_area->width'. It may be set to NULL if these values are not of + interest. In this case 'cell_area->x' and 'cell_area->width' will be + returned as 0. */ +static void +pspp_sheet_view_adjust_cell_area (PsppSheetView *tree_view, + PsppSheetViewColumn *column, + const GdkRectangle *background_area, + gboolean subtract_focus_rect, + GdkRectangle *cell_area) +{ + gint vertical_separator; + gint horizontal_separator; + + *cell_area = *background_area; + + gtk_widget_style_get (GTK_WIDGET (tree_view), + "vertical-separator", &vertical_separator, + "horizontal-separator", &horizontal_separator, + NULL); + cell_area->x += horizontal_separator / 2; + cell_area->y += vertical_separator / 2; + cell_area->width -= horizontal_separator; + cell_area->height -= vertical_separator; + + if (subtract_focus_rect) + { + int focus_line_width; + + gtk_widget_style_get (GTK_WIDGET (tree_view), + "focus-line-width", &focus_line_width, + NULL); + cell_area->x += focus_line_width; + cell_area->y += focus_line_width; + cell_area->width -= 2 * focus_line_width; + cell_area->height -= 2 * focus_line_width; + } + + if (tree_view->priv->grid_lines != PSPP_SHEET_VIEW_GRID_LINES_NONE) + { + gint grid_line_width; + gtk_widget_style_get (GTK_WIDGET (tree_view), + "grid-line-width", &grid_line_width, + NULL); + + if ((tree_view->priv->grid_lines == PSPP_SHEET_VIEW_GRID_LINES_VERTICAL + || tree_view->priv->grid_lines == PSPP_SHEET_VIEW_GRID_LINES_BOTH) + && column != NULL) + { + PsppSheetViewColumn *first_column, *last_column; + GList *list; + + /* Find the last visible column. */ + last_column = NULL; + for (list = g_list_last (tree_view->priv->columns); + list; + list = list->prev) + { + PsppSheetViewColumn *c = list->data; + if (c->visible) + { + last_column = c; + break; + } + } + + /* Find the first visible column. */ + first_column = NULL; + for (list = g_list_first (tree_view->priv->columns); + list; + list = list->next) + { + PsppSheetViewColumn *c = list->data; + if (c->visible) + { + first_column = c; + break; + } + } + + if (column == first_column) + { + cell_area->width -= grid_line_width / 2; + } + else if (column == last_column) + { + cell_area->x += grid_line_width / 2; + cell_area->width -= grid_line_width / 2; + } + else + { + cell_area->x += grid_line_width / 2; + cell_area->width -= grid_line_width; + } + } + + if (tree_view->priv->grid_lines == PSPP_SHEET_VIEW_GRID_LINES_HORIZONTAL + || tree_view->priv->grid_lines == PSPP_SHEET_VIEW_GRID_LINES_BOTH) + { + cell_area->y += grid_line_width / 2; + cell_area->height -= grid_line_width; + } + } + + if (column == NULL) + { + cell_area->x = 0; + cell_area->width = 0; + } +} /** * pspp_sheet_view_get_cell_area: @@ -9762,9 +10633,7 @@ pspp_sheet_view_get_cell_area (PsppSheetView *tree_view, PsppSheetViewColumn *column, GdkRectangle *rect) { - int node = -1; - gint vertical_separator; - gint horizontal_separator; + GdkRectangle background_area; g_return_if_fail (PSPP_IS_SHEET_VIEW (tree_view)); g_return_if_fail (column == NULL || PSPP_IS_SHEET_VIEW_COLUMN (column)); @@ -9772,33 +10641,10 @@ pspp_sheet_view_get_cell_area (PsppSheetView *tree_view, g_return_if_fail (!column || column->tree_view == (GtkWidget *) tree_view); g_return_if_fail (gtk_widget_get_realized (GTK_WIDGET (tree_view))); - gtk_widget_style_get (GTK_WIDGET (tree_view), - "vertical-separator", &vertical_separator, - "horizontal-separator", &horizontal_separator, - NULL); - - rect->x = 0; - rect->y = 0; - rect->width = 0; - rect->height = 0; - - if (column) - { - rect->x = column->button->allocation.x + horizontal_separator/2; - rect->width = column->button->allocation.width - horizontal_separator; - } - - if (path) - { - _pspp_sheet_view_find_node (tree_view, path, &node); - - /* Get vertical coords */ - if (node < 0) - return; - - rect->y = CELL_FIRST_PIXEL (tree_view, node, vertical_separator); - rect->height = MAX (CELL_HEIGHT (tree_view, vertical_separator), tree_view->priv->expander_size - vertical_separator); - } + pspp_sheet_view_get_background_area (tree_view, path, column, + &background_area); + pspp_sheet_view_adjust_cell_area (tree_view, column, &background_area, + FALSE, rect); } /** @@ -9881,10 +10727,12 @@ pspp_sheet_view_get_visible_rect (PsppSheetView *tree_view, 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); } } @@ -9915,7 +10763,7 @@ pspp_sheet_view_widget_to_tree_coords (PsppSheetView *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; } @@ -9947,7 +10795,7 @@ pspp_sheet_view_tree_to_widget_coords (PsppSheetView *tree_view, 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; } @@ -10040,7 +10888,7 @@ pspp_sheet_view_convert_widget_to_bin_window_coords (PsppSheetView *tree_view, 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); } @@ -10068,7 +10916,7 @@ pspp_sheet_view_convert_bin_window_to_widget_coords (PsppSheetView *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); } @@ -10176,10 +11024,10 @@ pspp_sheet_view_get_visible_range (PsppSheetView *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) @@ -10547,7 +11395,7 @@ pspp_sheet_view_get_dest_row_at_pos (PsppSheetView *tree_view, } - +#if GTK3_TRANSITION /* KEEP IN SYNC WITH PSPP_SHEET_VIEW_BIN_EXPOSE */ /** * pspp_sheet_view_create_row_drag_icon: @@ -10570,7 +11418,6 @@ pspp_sheet_view_create_row_drag_icon (PsppSheetView *tree_view, GdkRectangle background_area; GdkRectangle expose_area; GtkWidget *widget; - gint depth; /* start drawing inside the black outline */ gint x = 1, y = 1; GdkDrawable *drawable; @@ -10585,8 +11432,6 @@ pspp_sheet_view_create_row_drag_icon (PsppSheetView *tree_view, if (!gtk_widget_get_realized (widget)) return NULL; - depth = gtk_tree_path_get_depth (path); - _pspp_sheet_view_find_node (tree_view, path, &node); @@ -10604,8 +11449,7 @@ pspp_sheet_view_create_row_drag_icon (PsppSheetView *tree_view, 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, @@ -10617,12 +11461,14 @@ pspp_sheet_view_create_row_drag_icon (PsppSheetView *tree_view, 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; @@ -10661,16 +11507,18 @@ pspp_sheet_view_create_row_drag_icon (PsppSheetView *tree_view, 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: @@ -11015,8 +11863,8 @@ pspp_sheet_view_search_position_func (PsppSheetView *tree_view, 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; @@ -11027,9 +11875,9 @@ pspp_sheet_view_search_position_func (PsppSheetView *tree_view, 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)) @@ -11061,6 +11909,7 @@ pspp_sheet_view_search_disable_popdown (GtkEntry *entry, 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. */ @@ -11079,6 +11928,7 @@ pspp_sheet_view_search_preedit_changed (GtkIMContext *im_context, } } +#endif static void pspp_sheet_view_search_activate (GtkEntry *entry, @@ -11395,7 +12245,7 @@ pspp_sheet_view_search_iter (GtkTreeModel *model, pspp_sheet_view_scroll_to_cell (tree_view, path, NULL, TRUE, 0.5, 0.0); pspp_sheet_selection_select_iter (selection, iter); - pspp_sheet_view_real_set_cursor (tree_view, path, FALSE, TRUE); + pspp_sheet_view_real_set_cursor (tree_view, path, FALSE, TRUE, 0); if (path) gtk_tree_path_free (path); @@ -11498,6 +12348,12 @@ pspp_sheet_view_remove_widget (GtkCellEditable *cell_editable, g_signal_handlers_disconnect_by_func (cell_editable, pspp_sheet_view_remove_widget, tree_view); + g_signal_handlers_disconnect_by_func (cell_editable, + pspp_sheet_view_editable_button_press_event, + tree_view); + g_signal_handlers_disconnect_by_func (cell_editable, + pspp_sheet_view_editable_clicked, + tree_view); gtk_container_remove (GTK_CONTAINER (tree_view), GTK_WIDGET (cell_editable)); @@ -11580,6 +12436,208 @@ pspp_sheet_view_start_editing (PsppSheetView *tree_view, return retval; } +static gboolean +pspp_sheet_view_editable_button_press_event (GtkWidget *widget, + GdkEventButton *event, + PsppSheetView *sheet_view) +{ + gint node; + + node = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (widget), + "pspp-sheet-view-node")); + return pspp_sheet_view_row_head_clicked (sheet_view, + node, + sheet_view->priv->edited_column, + event); +} + +static void +pspp_sheet_view_editable_clicked (GtkButton *button, + PsppSheetView *sheet_view) +{ + pspp_sheet_view_editable_button_press_event (GTK_WIDGET (button), NULL, + sheet_view); +} + +static gboolean +is_all_selected (GtkWidget *widget) +{ + GtkEntryBuffer *buffer; + gint start_pos, end_pos; + + if (!GTK_IS_ENTRY (widget)) + return FALSE; + + buffer = gtk_entry_get_buffer (GTK_ENTRY (widget)); + return (gtk_editable_get_selection_bounds (GTK_EDITABLE (widget), + &start_pos, &end_pos) + && start_pos == 0 + && end_pos == gtk_entry_buffer_get_length (buffer)); +} + +static gboolean +is_at_left (GtkWidget *widget) +{ + return (GTK_IS_ENTRY (widget) + && gtk_editable_get_position (GTK_EDITABLE (widget)) == 0); +} + +static gboolean +is_at_right (GtkWidget *widget) +{ + GtkEntryBuffer *buffer; + gint length; + + if (!GTK_IS_ENTRY (widget)) + return FALSE; + + buffer = gtk_entry_get_buffer (GTK_ENTRY (widget)); + length = gtk_entry_buffer_get_length (buffer); + return gtk_editable_get_position (GTK_EDITABLE (widget)) == length; +} + +static gboolean +pspp_sheet_view_event (GtkWidget *widget, + GdkEventKey *event, + PsppSheetView *tree_view) +{ + PsppSheetViewColumn *column; + GtkTreePath *path; + gboolean handled; + gboolean cancel; + guint keyval; + gint row; + + /* Intercept only key press events. + It would make sense to use "key-press-event" instead of "event", but + GtkEntry attaches its own signal handler to "key-press-event" that runs + before ours and overrides our desired behavior for GDK_Up and GDK_Down. + */ + if (event->type != GDK_KEY_PRESS) + return FALSE; + + keyval = event->keyval; + cancel = FALSE; + switch (event->state & (GDK_CONTROL_MASK | GDK_SHIFT_MASK | GDK_MOD1_MASK)) + { + case 0: + switch (event->keyval) + { + case GDK_Left: case GDK_KP_Left: + case GDK_Home: case GDK_KP_Home: + if (!is_all_selected (widget) && !is_at_left (widget)) + return FALSE; + break; + + case GDK_Right: case GDK_KP_Right: + case GDK_End: case GDK_KP_End: + if (!is_all_selected (widget) && !is_at_right (widget)) + return FALSE; + break; + + case GDK_Up: case GDK_KP_Up: + case GDK_Down: case GDK_KP_Down: + break; + + case GDK_Page_Up: case GDK_KP_Page_Up: + case GDK_Page_Down: case GDK_KP_Page_Down: + break; + + case GDK_Escape: + cancel = TRUE; + break; + + case GDK_Return: + keyval = GDK_Down; + break; + + case GDK_Tab: case GDK_KP_Tab: + case GDK_ISO_Left_Tab: + keyval = GDK_Tab; + break; + + default: + return FALSE; + } + break; + + case GDK_SHIFT_MASK: + switch (event->keyval) + { + case GDK_Tab: + case GDK_ISO_Left_Tab: + keyval = GDK_Tab; + break; + + default: + return FALSE; + } + break; + + case GDK_CONTROL_MASK: + switch (event->keyval) + { + case GDK_Left: case GDK_KP_Left: + if (!is_all_selected (widget) && !is_at_left (widget)) + return FALSE; + break; + + case GDK_Right: case GDK_KP_Right: + if (!is_all_selected (widget) && !is_at_right (widget)) + return FALSE; + break; + + case GDK_Up: case GDK_KP_Up: + case GDK_Down: case GDK_KP_Down: + break; + + default: + return FALSE; + } + break; + + default: + return FALSE; + } + + row = tree_view->priv->edited_row; + column = tree_view->priv->edited_column; + path = gtk_tree_path_new_from_indices (row, -1); + + pspp_sheet_view_stop_editing (tree_view, cancel); + gtk_widget_grab_focus (GTK_WIDGET (tree_view)); + + pspp_sheet_view_set_cursor (tree_view, path, column, FALSE); + gtk_tree_path_free (path); + + handled = gtk_binding_set_activate (edit_bindings, keyval, event->state, + G_OBJECT (tree_view)); + if (handled) + g_signal_stop_emission_by_name (widget, "event"); + + pspp_sheet_view_get_cursor (tree_view, &path, NULL); + pspp_sheet_view_start_editing (tree_view, path); + gtk_tree_path_free (path); + + return handled; +} + +static void +pspp_sheet_view_override_cell_keypresses (GtkWidget *widget, + gpointer data) +{ + PsppSheetView *sheet_view = data; + + g_signal_connect (widget, "event", + G_CALLBACK (pspp_sheet_view_event), + sheet_view); + + if (GTK_IS_CONTAINER (widget)) + gtk_container_foreach (GTK_CONTAINER (widget), + pspp_sheet_view_override_cell_keypresses, + data); +} + static void pspp_sheet_view_real_start_editing (PsppSheetView *tree_view, PsppSheetViewColumn *column, @@ -11589,14 +12647,24 @@ pspp_sheet_view_real_start_editing (PsppSheetView *tree_view, GdkEvent *event, guint flags) { - gint pre_val = tree_view->priv->vadjustment->value; + 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); tree_view->priv->edited_column = column; _pspp_sheet_view_column_start_editing (column, GTK_CELL_EDITABLE (cell_editable)); - pspp_sheet_view_real_set_cursor (tree_view, path, FALSE, TRUE); - cell_area->y += pre_val - (int)tree_view->priv->vadjustment->value; + 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)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); + tree_view->priv->anchor_column = column; gtk_widget_size_request (GTK_WIDGET (cell_editable), &requisition); @@ -11624,11 +12692,26 @@ pspp_sheet_view_real_start_editing (PsppSheetView *tree_view, gtk_widget_grab_focus (GTK_WIDGET (cell_editable)); g_signal_connect (cell_editable, "remove-widget", G_CALLBACK (pspp_sheet_view_remove_widget), tree_view); + if (mode == PSPP_SHEET_SELECTION_RECTANGLE && column->row_head && + GTK_IS_BUTTON (cell_editable)) + { + g_signal_connect (cell_editable, "button-press-event", + G_CALLBACK (pspp_sheet_view_editable_button_press_event), + tree_view); + g_object_set_data (G_OBJECT (cell_editable), "pspp-sheet-view-node", + GINT_TO_POINTER (row)); + g_signal_connect (cell_editable, "clicked", + G_CALLBACK (pspp_sheet_view_editable_clicked), + tree_view); + } + + pspp_sheet_view_override_cell_keypresses (GTK_WIDGET (cell_editable), + tree_view); } -static void +void pspp_sheet_view_stop_editing (PsppSheetView *tree_view, - gboolean cancel_editing) + gboolean cancel_editing) { PsppSheetViewColumn *column; GtkCellRenderer *cell; @@ -11669,7 +12752,7 @@ pspp_sheet_view_stop_editing (PsppSheetView *tree_view, * Enables of disables the hover selection mode of @tree_view. * Hover selection makes the selected row follow the pointer. * Currently, this works only for the selection modes - * %GTK_SELECTION_SINGLE and %GTK_SELECTION_BROWSE. + * %PSPP_SHEET_SELECTION_SINGLE and %PSPP_SHEET_SELECTION_BROWSE. * * Since: 2.6 **/ @@ -11708,9 +12791,9 @@ pspp_sheet_view_get_hover_selection (PsppSheetView *tree_view) * @tree_view: a #PsppSheetView * @enable: %TRUE to enable rubber banding * - * Enables or disables rubber banding in @tree_view. If the selection mode - * is #GTK_SELECTION_MULTIPLE, rubber banding will allow the user to select - * multiple rows by dragging the mouse. + * Enables or disables rubber banding in @tree_view. If the selection mode is + * #PSPP_SHEET_SELECTION_MULTIPLE or #PSPP_SHEET_SELECTION_RECTANGLE, rubber + * banding will allow the user to select multiple rows by dragging the mouse. * * Since: 2.10 **/ @@ -11733,8 +12816,9 @@ pspp_sheet_view_set_rubber_banding (PsppSheetView *tree_view, * @tree_view: a #PsppSheetView * * Returns whether rubber banding is turned on for @tree_view. If the - * selection mode is #GTK_SELECTION_MULTIPLE, rubber banding will allow the - * user to select multiple rows by dragging the mouse. + * selection mode is #PSPP_SHEET_SELECTION_MULTIPLE or + * #PSPP_SHEET_SELECTION_RECTANGLE, rubber banding will allow the user to + * select multiple rows by dragging the mouse. * * Return value: %TRUE if rubber banding in @tree_view is enabled. * @@ -11795,8 +12879,8 @@ pspp_sheet_view_state_changed (GtkWidget *widget, 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); @@ -11836,45 +12920,89 @@ pspp_sheet_view_set_grid_lines (PsppSheetView *tree_view, PsppSheetViewGridLines grid_lines) { PsppSheetViewPrivate *priv; - GtkWidget *widget; PsppSheetViewGridLines old_grid_lines; g_return_if_fail (PSPP_IS_SHEET_VIEW (tree_view)); priv = tree_view->priv; - widget = GTK_WIDGET (tree_view); old_grid_lines = priv->grid_lines; priv->grid_lines = grid_lines; - if (gtk_widget_get_realized (widget)) + if (old_grid_lines != grid_lines) { - if (grid_lines == PSPP_SHEET_VIEW_GRID_LINES_NONE && - priv->grid_line_gc) - { - g_object_unref (priv->grid_line_gc); - priv->grid_line_gc = NULL; - } - - if (grid_lines != PSPP_SHEET_VIEW_GRID_LINES_NONE && - !priv->grid_line_gc) - { - gint line_width; - - gtk_widget_style_get (widget, - "grid-line-width", &line_width, - NULL); + gtk_widget_queue_draw (GTK_WIDGET (tree_view)); - priv->grid_line_gc = gdk_gc_new (widget->window); - gdk_gc_copy (priv->grid_line_gc, widget->style->black_gc); - } + g_object_notify (G_OBJECT (tree_view), "enable-grid-lines"); } +} - if (old_grid_lines != grid_lines) +/** + * pspp_sheet_view_get_special_cells: + * @tree_view: a #PsppSheetView + * + * Returns which grid lines are enabled in @tree_view. + * + * Return value: a #PsppSheetViewSpecialCells value indicating whether rows in + * the sheet view contain special cells. + */ +PsppSheetViewSpecialCells +pspp_sheet_view_get_special_cells (PsppSheetView *tree_view) +{ + g_return_val_if_fail (PSPP_IS_SHEET_VIEW (tree_view), 0); + + return tree_view->priv->special_cells; +} + +/** + * pspp_sheet_view_set_special_cells: + * @tree_view: a #PsppSheetView + * @special_cells: a #PsppSheetViewSpecialCells value indicating whether rows in + * the sheet view contain special cells. + * + * Sets whether rows in the sheet view contain special cells, controlling the + * rendering of row selections. + */ +void +pspp_sheet_view_set_special_cells (PsppSheetView *tree_view, + PsppSheetViewSpecialCells special_cells) +{ + PsppSheetViewPrivate *priv; + + g_return_if_fail (PSPP_IS_SHEET_VIEW (tree_view)); + + priv = tree_view->priv; + + if (priv->special_cells != special_cells) { + priv->special_cells = special_cells; gtk_widget_queue_draw (GTK_WIDGET (tree_view)); - - g_object_notify (G_OBJECT (tree_view), "enable-grid-lines"); + g_object_notify (G_OBJECT (tree_view), "special-cells"); + } +} + +int +pspp_sheet_view_get_fixed_height (const PsppSheetView *tree_view) +{ + /* XXX (re)calculate fixed_height if necessary */ + return tree_view->priv->fixed_height; +} + +void +pspp_sheet_view_set_fixed_height (PsppSheetView *tree_view, + int fixed_height) +{ + g_return_if_fail (fixed_height > 0); + + if (tree_view->priv->fixed_height != fixed_height) + { + tree_view->priv->fixed_height = fixed_height; + g_object_notify (G_OBJECT (tree_view), "fixed-height"); + } + if (!tree_view->priv->fixed_height_set) + { + tree_view->priv->fixed_height_set = TRUE; + g_object_notify (G_OBJECT (tree_view), "fixed-height-set"); } } @@ -11958,8 +13086,10 @@ pspp_sheet_view_set_tooltip_cell (PsppSheetView *tree_view, } 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. */ @@ -11976,7 +13106,7 @@ pspp_sheet_view_set_tooltip_cell (PsppSheetView *tree_view, 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); @@ -12192,6 +13322,7 @@ _gtk_boolean_handled_accumulator (GSignalInvocationHint *ihint, return continue_emission; } + GType pspp_sheet_view_grid_lines_get_type (void) { @@ -12208,3 +13339,19 @@ pspp_sheet_view_grid_lines_get_type (void) } return etype; } + +GType +pspp_sheet_view_special_cells_get_type (void) +{ + static GType etype = 0; + if (G_UNLIKELY(etype == 0)) { + static const GEnumValue values[] = { + { PSPP_SHEET_VIEW_SPECIAL_CELLS_DETECT, "PSPP_SHEET_VIEW_SPECIAL_CELLS_DETECT", "detect" }, + { PSPP_SHEET_VIEW_SPECIAL_CELLS_YES, "PSPP_SHEET_VIEW_SPECIAL_CELLS_YES", "yes" }, + { PSPP_SHEET_VIEW_SPECIAL_CELLS_NO, "PSPP_SHEET_VIEW_SPECIAL_CELLS_NO", "no" }, + { 0, NULL, NULL } + }; + etype = g_enum_register_static (g_intern_static_string ("PsppSheetViewSpecialCells"), values); + } + return etype; +}