pintos-os.org Git - pspp/blob - src/ui/gui/pspp-sheet-view.c

   1 /* PSPPIRE - a graphical user interface for PSPP.
   2    Copyright (C) 2011, 2012, 2013, 2015 Free Software Foundation, Inc.
   3
   4    This program is free software: you can redistribute it and/or modify
   5    it under the terms of the GNU General Public License as published by
   6    the Free Software Foundation, either version 3 of the License, or
   7    (at your option) any later version.
   8
   9    This program is distributed in the hope that it will be useful,
  10    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12    GNU General Public License for more details.
  13
  14    You should have received a copy of the GNU General Public License
  15    along with this program.  If not, see <http://www.gnu.org/licenses/>. */
  16
  17 /* gtktreeview.c
  18  * Copyright (C) 2000  Red Hat, Inc.,  Jonathan Blandford <jrb@redhat.com>
  19  *
  20  * This library is free software; you can redistribute it and/or
  21  * modify it under the terms of the GNU Library General Public
  22  * License as published by the Free Software Foundation; either
  23  * version 2 of the License, or (at your option) any later version.
  24  *
  25  * This library is distributed in the hope that it will be useful,
  26  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  27  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  28  * Library General Public License for more details.
  29  *
  30  * You should have received a copy of the GNU Library General Public
  31  * License along with this library; if not, write to the
  32  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  33  * Boston, MA 02111-1307, USA.
  34  */
  35
  36 #include <config.h>
  37
  38 #include "ui/gui/pspp-sheet-private.h"
  39
  40 #include <gtk/gtk.h>
  41 #include <gdk/gdk.h>
  42 #include <gdk/gdkkeysyms.h>
  43 #include <gdk/gdkkeysyms-compat.h>
  44 #include <string.h>
  45
  46 #include "ui/gui/psppire-marshal.h"
  47 #include "ui/gui/pspp-sheet-selection.h"
  48
  49 #define P_(STRING) STRING
  50 #define GTK_PARAM_READABLE G_PARAM_READABLE|G_PARAM_STATIC_NAME|G_PARAM_STATIC_NICK|G_PARAM_STATIC_BLURB
  51 #define GTK_PARAM_READWRITE G_PARAM_READWRITE|G_PARAM_STATIC_NAME|G_PARAM_STATIC_NICK|G_PARAM_STATIC_BLURB
  52
  53 /* Many keyboard shortcuts for Mac are the same as for X
  54  * except they use Command key instead of Control (e.g. Cut,
  55  * Copy, Paste). This symbol is for those simple cases. */
  56 #ifndef GDK_WINDOWING_QUARTZ
  57 #define GTK_DEFAULT_ACCEL_MOD_MASK GDK_CONTROL_MASK
  58 #else
  59 #define GTK_DEFAULT_ACCEL_MOD_MASK GDK_META_MASK
  60 #endif
  61
  62 #define PSPP_SHEET_VIEW_PRIORITY_VALIDATE (GDK_PRIORITY_REDRAW + 5)
  63 #define PSPP_SHEET_VIEW_PRIORITY_SCROLL_SYNC (PSPP_SHEET_VIEW_PRIORITY_VALIDATE + 2)
  64 #define PSPP_SHEET_VIEW_TIME_MS_PER_IDLE 30
  65 #define SCROLL_EDGE_SIZE 15
  66 #define EXPANDER_EXTRA_PADDING 4
  67 #define PSPP_SHEET_VIEW_SEARCH_DIALOG_TIMEOUT 5000
  68
  69 /* The "background" areas of all rows/cells add up to cover the entire tree.
  70  * The background includes all inter-row and inter-cell spacing.
  71  * The "cell" areas are the cell_area passed in to gtk_cell_renderer_render(),
  72  * i.e. just the cells, no spacing.
  73  */
  74
  75 #define BACKGROUND_HEIGHT(tree_view) (tree_view->priv->fixed_height)
  76 #define CELL_HEIGHT(tree_view, separator) ((BACKGROUND_HEIGHT (tree_view)) - (separator))
  77
  78 /* Translate from bin_window coordinates to rbtree (tree coordinates) and
  79  * vice versa.
  80  */
  81 #define TREE_WINDOW_Y_TO_RBTREE_Y(tree_view,y) ((y) + tree_view->priv->dy)
  82 #define RBTREE_Y_TO_TREE_WINDOW_Y(tree_view,y) ((y) - tree_view->priv->dy)
  83
  84 /* This is in bin_window coordinates */
  85 #define BACKGROUND_FIRST_PIXEL(tree_view,node) (RBTREE_Y_TO_TREE_WINDOW_Y (tree_view, pspp_sheet_view_node_find_offset (tree_view, (node))))
  86 #define CELL_FIRST_PIXEL(tree_view,node,separator) (BACKGROUND_FIRST_PIXEL (tree_view,node) + separator/2)
  87
  88 #define ROW_HEIGHT(tree_view) \
  89   ((tree_view->priv->fixed_height > 0) ? (tree_view->priv->fixed_height) : (tree_view)->priv->expander_size)
  90
  91
  92 typedef struct _PsppSheetViewChild PsppSheetViewChild;
  93 struct _PsppSheetViewChild
  94 {
  95   GtkWidget *widget;
  96   PsppSheetViewColumn *column;
  97   int node;
  98 };
  99
 100
 101 typedef struct _TreeViewDragInfo TreeViewDragInfo;
 102 struct _TreeViewDragInfo
 103 {
 104   GdkModifierType start_button_mask;
 105   GtkTargetList *_unused_source_target_list;
 106   GdkDragAction source_actions;
 107
 108   GtkTargetList *_unused_dest_target_list;
 109
 110   guint source_set : 1;
 111   guint dest_set : 1;
 112 };
 113
 114
 115 /* Signals */
 116 enum
 117 {
 118   ROW_ACTIVATED,
 119   COLUMNS_CHANGED,
 120   CURSOR_CHANGED,
 121   MOVE_CURSOR,
 122   SELECT_ALL,
 123   UNSELECT_ALL,
 124   SELECT_CURSOR_ROW,
 125   TOGGLE_CURSOR_ROW,
 126   START_INTERACTIVE_SEARCH,
 127   LAST_SIGNAL
 128 };
 129
 130 /* Properties */
 131 enum {
 132   PROP_0,
 133   PROP_MODEL,
 134   PROP_HADJUSTMENT,
 135   PROP_VADJUSTMENT,
 136   PROP_HSCROLL_POLICY,
 137   PROP_VSCROLL_POLICY,
 138   PROP_HEADERS_VISIBLE,
 139   PROP_HEADERS_CLICKABLE,
 140   PROP_REORDERABLE,
 141   PROP_RULES_HINT,
 142   PROP_ENABLE_SEARCH,
 143   PROP_SEARCH_COLUMN,
 144   PROP_HOVER_SELECTION,
 145   PROP_RUBBER_BANDING,
 146   PROP_ENABLE_GRID_LINES,
 147   PROP_TOOLTIP_COLUMN,
 148   PROP_SPECIAL_CELLS,
 149   PROP_FIXED_HEIGHT,
 150   PROP_FIXED_HEIGHT_SET
 151 };
 152
 153 /* object signals */
 154 static void     pspp_sheet_view_finalize             (GObject          *object);
 155 static void     pspp_sheet_view_set_property         (GObject         *object,
 156                                                     guint            prop_id,
 157                                                     const GValue    *value,
 158                                                     GParamSpec      *pspec);
 159 static void     pspp_sheet_view_get_property         (GObject         *object,
 160                                                     guint            prop_id,
 161                                                     GValue          *value,
 162                                                     GParamSpec      *pspec);
 163
 164 static void     pspp_sheet_view_dispose              (GObject        *object);
 165
 166 /* gtkwidget signals */
 167 static void     pspp_sheet_view_realize              (GtkWidget        *widget);
 168 static void     pspp_sheet_view_unrealize            (GtkWidget        *widget);
 169 static void     pspp_sheet_view_map                  (GtkWidget        *widget);
 170 static void     pspp_sheet_view_size_request         (GtkWidget        *widget,
 171                                                     GtkRequisition   *requisition);
 172 static void     pspp_sheet_view_size_allocate        (GtkWidget        *widget,
 173                                                     GtkAllocation    *allocation);
 174 static gboolean pspp_sheet_view_draw               (GtkWidget        *widget,
 175                                                     cairo_t *cr);
 176 static gboolean pspp_sheet_view_key_press            (GtkWidget        *widget,
 177                                                     GdkEventKey      *event);
 178 static gboolean pspp_sheet_view_key_release          (GtkWidget        *widget,
 179                                                     GdkEventKey      *event);
 180 static gboolean pspp_sheet_view_motion               (GtkWidget        *widget,
 181                                                     GdkEventMotion   *event);
 182 static gboolean pspp_sheet_view_enter_notify         (GtkWidget        *widget,
 183                                                     GdkEventCrossing *event);
 184 static gboolean pspp_sheet_view_leave_notify         (GtkWidget        *widget,
 185                                                     GdkEventCrossing *event);
 186 static gboolean pspp_sheet_view_button_press         (GtkWidget        *widget,
 187                                                     GdkEventButton   *event);
 188 static gboolean pspp_sheet_view_button_release       (GtkWidget        *widget,
 189                                                     GdkEventButton   *event);
 190 static gboolean pspp_sheet_view_grab_broken          (GtkWidget          *widget,
 191                                                     GdkEventGrabBroken *event);
 192
 193 static void     pspp_sheet_view_set_focus_child      (GtkContainer     *container,
 194                                                     GtkWidget        *child);
 195 static gint     pspp_sheet_view_focus_out            (GtkWidget        *widget,
 196                                                     GdkEventFocus    *event);
 197 static gint     pspp_sheet_view_focus                (GtkWidget        *widget,
 198                                                     GtkDirectionType  direction);
 199 static void     pspp_sheet_view_grab_focus           (GtkWidget        *widget);
 200 static void     pspp_sheet_view_style_updated        (GtkWidget        *widget);
 201 static void     pspp_sheet_view_grab_notify          (GtkWidget        *widget,
 202                                                     gboolean          was_grabbed);
 203 static void     pspp_sheet_view_state_changed        (GtkWidget        *widget,
 204                                                     GtkStateType      previous_state);
 205
 206 /* container signals */
 207 static void     pspp_sheet_view_remove               (GtkContainer     *container,
 208                                                     GtkWidget        *widget);
 209 static void     pspp_sheet_view_forall               (GtkContainer     *container,
 210                                                     gboolean          include_internals,
 211                                                     GtkCallback       callback,
 212                                                     gpointer          callback_data);
 213
 214 /* Source side drag signals */
 215 static void pspp_sheet_view_drag_begin       (GtkWidget        *widget,
 216                                             GdkDragContext   *context);
 217 static void pspp_sheet_view_drag_end         (GtkWidget        *widget,
 218                                             GdkDragContext   *context);
 219 static void pspp_sheet_view_drag_data_get    (GtkWidget        *widget,
 220                                             GdkDragContext   *context,
 221                                             GtkSelectionData *selection_data,
 222                                             guint             info,
 223                                             guint             time);
 224 static void pspp_sheet_view_drag_data_delete (GtkWidget        *widget,
 225                                             GdkDragContext   *context);
 226
 227 /* Target side drag signals */
 228 static void     pspp_sheet_view_drag_leave         (GtkWidget        *widget,
 229                                                   GdkDragContext   *context,
 230                                                   guint             time);
 231 static gboolean pspp_sheet_view_drag_motion        (GtkWidget        *widget,
 232                                                   GdkDragContext   *context,
 233                                                   gint              x,
 234                                                   gint              y,
 235                                                   guint             time);
 236 static gboolean pspp_sheet_view_drag_drop          (GtkWidget        *widget,
 237                                                   GdkDragContext   *context,
 238                                                   gint              x,
 239                                                   gint              y,
 240                                                   guint             time);
 241 static void     pspp_sheet_view_drag_data_received (GtkWidget        *widget,
 242                                                   GdkDragContext   *context,
 243                                                   gint              x,
 244                                                   gint              y,
 245                                                   GtkSelectionData *selection_data,
 246                                                   guint             info,
 247                                                   guint             time);
 248
 249 /* tree_model signals */
 250 static void pspp_sheet_view_set_adjustments                 (PsppSheetView     *tree_view,
 251                                                            GtkAdjustment   *hadj,
 252                                                            GtkAdjustment   *vadj);
 253 static gboolean pspp_sheet_view_real_move_cursor            (PsppSheetView     *tree_view,
 254                                                            GtkMovementStep  step,
 255                                                            gint             count);
 256 static gboolean pspp_sheet_view_real_select_all             (PsppSheetView     *tree_view);
 257 static gboolean pspp_sheet_view_real_unselect_all           (PsppSheetView     *tree_view);
 258 static gboolean pspp_sheet_view_real_select_cursor_row      (PsppSheetView     *tree_view,
 259                                                              gboolean         start_editing,
 260                                                              PsppSheetSelectMode mode);
 261 static gboolean pspp_sheet_view_real_toggle_cursor_row      (PsppSheetView     *tree_view);
 262 static void pspp_sheet_view_row_changed                     (GtkTreeModel    *model,
 263                                                            GtkTreePath     *path,
 264                                                            GtkTreeIter     *iter,
 265                                                            gpointer         data);
 266 static void pspp_sheet_view_row_inserted                    (GtkTreeModel    *model,
 267                                                            GtkTreePath     *path,
 268                                                            GtkTreeIter     *iter,
 269                                                            gpointer         data);
 270 static void pspp_sheet_view_row_deleted                     (GtkTreeModel    *model,
 271                                                            GtkTreePath     *path,
 272                                                            gpointer         data);
 273 static void pspp_sheet_view_rows_reordered                  (GtkTreeModel    *model,
 274                                                            GtkTreePath     *parent,
 275                                                            GtkTreeIter     *iter,
 276                                                            gint            *new_order,
 277                                                            gpointer         data);
 278
 279 /* Incremental reflow */
 280 static gint validate_row             (PsppSheetView *tree_view,
 281                                           int node,
 282                                           GtkTreeIter *iter,
 283                                           GtkTreePath *path);
 284 static void     validate_visible_area    (PsppSheetView *tree_view);
 285 static gboolean validate_rows_handler    (PsppSheetView *tree_view);
 286 static gboolean presize_handler_callback (gpointer     data);
 287 static void     install_presize_handler  (PsppSheetView *tree_view);
 288 static void     install_scroll_sync_handler (PsppSheetView *tree_view);
 289 static void     pspp_sheet_view_set_top_row   (PsppSheetView *tree_view,
 290                                              GtkTreePath *path,
 291                                              gint         offset);
 292 static void     pspp_sheet_view_dy_to_top_row (PsppSheetView *tree_view);
 293 static void     pspp_sheet_view_top_row_to_dy (PsppSheetView *tree_view);
 294 static void     invalidate_empty_focus      (PsppSheetView *tree_view);
 295
 296 /* Internal functions */
 297 static GtkAdjustment *pspp_sheet_view_do_get_hadjustment (PsppSheetView *);
 298 static GtkAdjustment *pspp_sheet_view_do_get_vadjustment (PsppSheetView *);
 299 static void pspp_sheet_view_do_set_hadjustment (PsppSheetView   *tree_view,
 300                                               GtkAdjustment *adjustment);
 301 static void pspp_sheet_view_do_set_vadjustment (PsppSheetView   *tree_view,
 302                                               GtkAdjustment *adjustment);
 303 static void     pspp_sheet_view_add_move_binding               (GtkBindingSet      *binding_set,
 304                                                               guint               keyval,
 305                                                               guint               modmask,
 306                                                               gboolean            add_shifted_binding,
 307                                                               GtkMovementStep     step,
 308                                                               gint                count);
 309 static void     pspp_sheet_view_queue_draw_path                (PsppSheetView        *tree_view,
 310                                                               GtkTreePath        *path,
 311                                                               const GdkRectangle *clip_rect);
 312 static gint     pspp_sheet_view_new_column_width               (PsppSheetView        *tree_view,
 313                                                               gint                i,
 314                                                               gint               *x);
 315 static void     pspp_sheet_view_adjustment_changed             (GtkAdjustment      *adjustment,
 316                                                               PsppSheetView        *tree_view);
 317 static void     pspp_sheet_view_clamp_node_visible             (PsppSheetView        *tree_view,
 318                                                               int node);
 319 static void     pspp_sheet_view_clamp_column_visible           (PsppSheetView        *tree_view,
 320                                                               PsppSheetViewColumn  *column,
 321                                                               gboolean            focus_to_cell);
 322 static gboolean pspp_sheet_view_maybe_begin_dragging_row       (PsppSheetView        *tree_view,
 323                                                               GdkEventMotion     *event);
 324 static void     pspp_sheet_view_focus_to_cursor                (PsppSheetView        *tree_view);
 325 static gboolean pspp_sheet_view_move_cursor_up_down            (PsppSheetView        *tree_view,
 326                                                               gint                count,
 327                                                                 PsppSheetSelectMode mode);
 328 static void     pspp_sheet_view_move_cursor_page_up_down       (PsppSheetView        *tree_view,
 329                                                               gint                count,
 330                                                                 PsppSheetSelectMode mode);
 331 static void     pspp_sheet_view_move_cursor_left_right         (PsppSheetView        *tree_view,
 332                                                                 gint                count,
 333                                                                 PsppSheetSelectMode mode);
 334 static void     pspp_sheet_view_move_cursor_line_start_end     (PsppSheetView        *tree_view,
 335                                                                 gint                count,
 336                                                                 PsppSheetSelectMode mode);
 337 static void     pspp_sheet_view_move_cursor_tab                (PsppSheetView        *tree_view,
 338                                                               gint                count);
 339 static void     pspp_sheet_view_move_cursor_start_end          (PsppSheetView        *tree_view,
 340                                                               gint                count,
 341                                                                 PsppSheetSelectMode mode);
 342 static void     pspp_sheet_view_real_set_cursor                (PsppSheetView        *tree_view,
 343                                                               GtkTreePath        *path,
 344                                                               gboolean            clear_and_select,
 345                                                               gboolean            clamp_node,
 346                                                               PsppSheetSelectMode mode);
 347 static gboolean pspp_sheet_view_has_special_cell               (PsppSheetView        *tree_view);
 348 static void     pspp_sheet_view_stop_rubber_band               (PsppSheetView        *tree_view);
 349 static void     update_prelight                              (PsppSheetView        *tree_view,
 350                                                               int                 x,
 351                                                               int                 y);
 352 static void initialize_fixed_height_mode (PsppSheetView *tree_view);
 353
 354 /* interactive search */
 355 static void     pspp_sheet_view_ensure_interactive_directory (PsppSheetView *tree_view);
 356 static void     pspp_sheet_view_search_dialog_hide     (GtkWidget        *search_dialog,
 357                                                          PsppSheetView      *tree_view);
 358 static void     pspp_sheet_view_search_position_func      (PsppSheetView      *tree_view,
 359                                                          GtkWidget        *search_dialog,
 360                                                          gpointer          user_data);
 361 static void     pspp_sheet_view_search_disable_popdown    (GtkEntry         *entry,
 362                                                          GtkMenu          *menu,
 363                                                          gpointer          data);
 364 static void     pspp_sheet_view_search_activate           (GtkEntry         *entry,
 365                                                          PsppSheetView      *tree_view);
 366 static gboolean pspp_sheet_view_real_search_enable_popdown(gpointer          data);
 367 static void     pspp_sheet_view_search_enable_popdown     (GtkWidget        *widget,
 368                                                          gpointer          data);
 369 static gboolean pspp_sheet_view_search_delete_event       (GtkWidget        *widget,
 370                                                          GdkEventAny      *event,
 371                                                          PsppSheetView      *tree_view);
 372 static gboolean pspp_sheet_view_search_button_press_event (GtkWidget        *widget,
 373                                                          GdkEventButton   *event,
 374                                                          PsppSheetView      *tree_view);
 375 static gboolean pspp_sheet_view_search_scroll_event       (GtkWidget        *entry,
 376                                                          GdkEventScroll   *event,
 377                                                          PsppSheetView      *tree_view);
 378 static gboolean pspp_sheet_view_search_key_press_event    (GtkWidget        *entry,
 379                                                          GdkEventKey      *event,
 380                                                          PsppSheetView      *tree_view);
 381 static gboolean pspp_sheet_view_search_move               (GtkWidget        *window,
 382                                                          PsppSheetView      *tree_view,
 383                                                          gboolean          up);
 384 static gboolean pspp_sheet_view_search_equal_func         (GtkTreeModel     *model,
 385                                                          gint              column,
 386                                                          const gchar      *key,
 387                                                          GtkTreeIter      *iter,
 388                                                          gpointer          search_data);
 389 static gboolean pspp_sheet_view_search_iter               (GtkTreeModel     *model,
 390                                                          PsppSheetSelection *selection,
 391                                                          GtkTreeIter      *iter,
 392                                                          const gchar      *text,
 393                                                          gint             *count,
 394                                                          gint              n);
 395 static void     pspp_sheet_view_search_init               (GtkWidget        *entry,
 396                                                          PsppSheetView      *tree_view);
 397 static void     pspp_sheet_view_put                       (PsppSheetView      *tree_view,
 398                                                          GtkWidget        *child_widget,
 399                                                          GtkTreePath *path,
 400                                                          PsppSheetViewColumn *column);
 401 static gboolean pspp_sheet_view_start_editing             (PsppSheetView      *tree_view,
 402                                                          GtkTreePath      *cursor_path);
 403 static gboolean pspp_sheet_view_editable_button_press_event (GtkWidget *,
 404                                                              GdkEventButton *,
 405                                                              PsppSheetView *);
 406 static void pspp_sheet_view_editable_clicked (GtkButton *, PsppSheetView *);
 407 static void pspp_sheet_view_real_start_editing (PsppSheetView       *tree_view,
 408                                               PsppSheetViewColumn *column,
 409                                               GtkTreePath       *path,
 410                                               GtkCellEditable   *cell_editable,
 411                                               GdkRectangle      *cell_area,
 412                                               GdkEvent          *event,
 413                                               guint              flags);
 414 static gboolean pspp_sheet_view_real_start_interactive_search (PsppSheetView *tree_view,
 415                                                              gboolean     keybinding);
 416 static gboolean pspp_sheet_view_start_interactive_search      (PsppSheetView *tree_view);
 417 static PsppSheetViewColumn *pspp_sheet_view_get_drop_column (PsppSheetView       *tree_view,
 418                                                          PsppSheetViewColumn *column,
 419                                                          gint               drop_position);
 420 static void
 421 pspp_sheet_view_adjust_cell_area (PsppSheetView        *tree_view,
 422                                   PsppSheetViewColumn  *column,
 423                                   const GdkRectangle   *background_area,
 424                                   gboolean              subtract_focus_rect,
 425                                   GdkRectangle         *cell_area);
 426 static gint pspp_sheet_view_find_offset (PsppSheetView *tree_view,
 427                                          gint height,
 428                                          int *new_node);
 429
 430 /* GtkBuildable */
 431 static void pspp_sheet_view_buildable_add_child (GtkBuildable *tree_view,
 432                                                GtkBuilder  *builder,
 433                                                GObject     *child,
 434                                                const gchar *type);
 435 static void pspp_sheet_view_buildable_init      (GtkBuildableIface *iface);
 436
 437
 438 static gboolean scroll_row_timeout                   (gpointer     data);
 439 static void     add_scroll_timeout                   (PsppSheetView *tree_view);
 440 static void     remove_scroll_timeout                (PsppSheetView *tree_view);
 441
 442 static guint tree_view_signals [LAST_SIGNAL] = { 0 };
 443
 444 static GtkBindingSet *edit_bindings;
 445
 446 \f
 447
 448 /* GType Methods
 449  */
 450
 451 G_DEFINE_TYPE_WITH_CODE (PsppSheetView, pspp_sheet_view, GTK_TYPE_CONTAINER,
 452                          G_IMPLEMENT_INTERFACE (GTK_TYPE_BUILDABLE,
 453                                                 pspp_sheet_view_buildable_init)
 454                          G_IMPLEMENT_INTERFACE (GTK_TYPE_SCROLLABLE, NULL))
 455
 456 static void
 457 pspp_sheet_view_get_preferred_width (GtkWidget *widget,
 458                                gint      *minimal_width,
 459                                gint      *natural_width)
 460 {
 461   GtkRequisition requisition;
 462
 463   pspp_sheet_view_size_request (widget, &requisition);
 464
 465   *minimal_width = *natural_width = requisition.width;
 466 }
 467
 468 static void
 469 pspp_sheet_view_get_preferred_height (GtkWidget *widget,
 470                                 gint      *minimal_height,
 471                                 gint      *natural_height)
 472 {
 473   GtkRequisition requisition;
 474
 475   pspp_sheet_view_size_request (widget, &requisition);
 476
 477   *minimal_height = *natural_height = requisition.height;
 478 }
 479
 480 static void
 481 pspp_sheet_view_class_init (PsppSheetViewClass *class)
 482 {
 483   GObjectClass *o_class;
 484   GtkWidgetClass *widget_class;
 485   GtkContainerClass *container_class;
 486   GtkBindingSet *binding_set[2];
 487   int i;
 488
 489   binding_set[0] = gtk_binding_set_by_class (class);
 490
 491   binding_set[1] = gtk_binding_set_new ("PsppSheetViewEditing");
 492   edit_bindings = binding_set[1];
 493
 494   o_class = (GObjectClass *) class;
 495   widget_class = (GtkWidgetClass *) class;
 496   container_class = (GtkContainerClass *) class;
 497
 498   /* GObject signals */
 499   o_class->set_property = pspp_sheet_view_set_property;
 500   o_class->get_property = pspp_sheet_view_get_property;
 501   o_class->finalize = pspp_sheet_view_finalize;
 502   o_class->dispose = pspp_sheet_view_dispose;
 503
 504   /* GtkWidget signals */
 505   widget_class->map = pspp_sheet_view_map;
 506   widget_class->realize = pspp_sheet_view_realize;
 507   widget_class->unrealize = pspp_sheet_view_unrealize;
 508   widget_class->get_preferred_width = pspp_sheet_view_get_preferred_width;
 509   widget_class->get_preferred_height = pspp_sheet_view_get_preferred_height;
 510   widget_class->size_allocate = pspp_sheet_view_size_allocate;
 511   widget_class->button_press_event = pspp_sheet_view_button_press;
 512   widget_class->button_release_event = pspp_sheet_view_button_release;
 513   widget_class->grab_broken_event = pspp_sheet_view_grab_broken;
 514   /*widget_class->configure_event = pspp_sheet_view_configure;*/
 515   widget_class->motion_notify_event = pspp_sheet_view_motion;
 516   widget_class->draw = pspp_sheet_view_draw;
 517   widget_class->key_press_event = pspp_sheet_view_key_press;
 518   widget_class->key_release_event = pspp_sheet_view_key_release;
 519   widget_class->enter_notify_event = pspp_sheet_view_enter_notify;
 520   widget_class->leave_notify_event = pspp_sheet_view_leave_notify;
 521   widget_class->focus_out_event = pspp_sheet_view_focus_out;
 522   widget_class->drag_begin = pspp_sheet_view_drag_begin;
 523   widget_class->drag_end = pspp_sheet_view_drag_end;
 524   widget_class->drag_data_get = pspp_sheet_view_drag_data_get;
 525   widget_class->drag_data_delete = pspp_sheet_view_drag_data_delete;
 526   widget_class->drag_leave = pspp_sheet_view_drag_leave;
 527   widget_class->drag_motion = pspp_sheet_view_drag_motion;
 528   widget_class->drag_drop = pspp_sheet_view_drag_drop;
 529   widget_class->drag_data_received = pspp_sheet_view_drag_data_received;
 530   widget_class->focus = pspp_sheet_view_focus;
 531   widget_class->grab_focus = pspp_sheet_view_grab_focus;
 532   widget_class->style_updated = pspp_sheet_view_style_updated;
 533   widget_class->grab_notify = pspp_sheet_view_grab_notify;
 534   widget_class->state_changed = pspp_sheet_view_state_changed;
 535
 536   /* GtkContainer signals */
 537   container_class->remove = pspp_sheet_view_remove;
 538   container_class->forall = pspp_sheet_view_forall;
 539   container_class->set_focus_child = pspp_sheet_view_set_focus_child;
 540
 541   class->set_scroll_adjustments = pspp_sheet_view_set_adjustments;
 542   class->move_cursor = pspp_sheet_view_real_move_cursor;
 543   class->select_all = pspp_sheet_view_real_select_all;
 544   class->unselect_all = pspp_sheet_view_real_unselect_all;
 545   class->select_cursor_row = pspp_sheet_view_real_select_cursor_row;
 546   class->toggle_cursor_row = pspp_sheet_view_real_toggle_cursor_row;
 547   class->start_interactive_search = pspp_sheet_view_start_interactive_search;
 548
 549   /* Properties */
 550
 551   g_object_class_install_property (o_class,
 552                                    PROP_MODEL,
 553                                    g_param_spec_object ("model",
 554                                                         P_("TreeView Model"),
 555                                                         P_("The model for the tree view"),
 556                                                         GTK_TYPE_TREE_MODEL,
 557                                                         GTK_PARAM_READWRITE));
 558
 559   g_object_class_override_property (o_class, PROP_HADJUSTMENT,    "hadjustment");
 560   g_object_class_override_property (o_class, PROP_VADJUSTMENT,    "vadjustment");
 561   g_object_class_override_property (o_class, PROP_HSCROLL_POLICY, "hscroll-policy");
 562   g_object_class_override_property (o_class, PROP_VSCROLL_POLICY, "vscroll-policy");
 563
 564   g_object_class_install_property (o_class,
 565                                    PROP_HEADERS_VISIBLE,
 566                                    g_param_spec_boolean ("headers-visible",
 567                                                          P_("Headers Visible"),
 568                                                          P_("Show the column header buttons"),
 569                                                          TRUE,
 570                                                          GTK_PARAM_READWRITE));
 571
 572   g_object_class_install_property (o_class,
 573                                    PROP_HEADERS_CLICKABLE,
 574                                    g_param_spec_boolean ("headers-clickable",
 575                                                          P_("Headers Clickable"),
 576                                                          P_("Column headers respond to click events"),
 577                                                          TRUE,
 578                                                          GTK_PARAM_READWRITE));
 579
 580   g_object_class_install_property (o_class,
 581                                    PROP_REORDERABLE,
 582                                    g_param_spec_boolean ("reorderable",
 583                                                          P_("Reorderable"),
 584                                                          P_("View is reorderable"),
 585                                                          FALSE,
 586                                                          GTK_PARAM_READWRITE));
 587
 588   g_object_class_install_property (o_class,
 589                                    PROP_RULES_HINT,
 590                                    g_param_spec_boolean ("rules-hint",
 591                                                          P_("Rules Hint"),
 592                                                          P_("Set a hint to the theme engine to draw rows in alternating colors"),
 593                                                          FALSE,
 594                                                          GTK_PARAM_READWRITE));
 595
 596     g_object_class_install_property (o_class,
 597                                      PROP_ENABLE_SEARCH,
 598                                      g_param_spec_boolean ("enable-search",
 599                                                            P_("Enable Search"),
 600                                                            P_("View allows user to search through columns interactively"),
 601                                                            TRUE,
 602                                                            GTK_PARAM_READWRITE));
 603
 604     g_object_class_install_property (o_class,
 605                                      PROP_SEARCH_COLUMN,
 606                                      g_param_spec_int ("search-column",
 607                                                        P_("Search Column"),
 608                                                        P_("Model column to search through during interactive search"),
 609                                                        -1,
 610                                                        G_MAXINT,
 611                                                        -1,
 612                                                        GTK_PARAM_READWRITE));
 613
 614     /**
 615      * PsppSheetView:hover-selection:
 616      *
 617      * Enables of disables the hover selection mode of @tree_view.
 618      * Hover selection makes the selected row follow the pointer.
 619      * Currently, this works only for the selection modes
 620      * %PSPP_SHEET_SELECTION_SINGLE and %PSPP_SHEET_SELECTION_BROWSE.
 621      *
 622      * This mode is primarily intended for treeviews in popups, e.g.
 623      * in #GtkComboBox or #GtkEntryCompletion.
 624      *
 625      * Since: 2.6
 626      */
 627     g_object_class_install_property (o_class,
 628                                      PROP_HOVER_SELECTION,
 629                                      g_param_spec_boolean ("hover-selection",
 630                                                            P_("Hover Selection"),
 631                                                            P_("Whether the selection should follow the pointer"),
 632                                                            FALSE,
 633                                                            GTK_PARAM_READWRITE));
 634
 635     g_object_class_install_property (o_class,
 636                                      PROP_RUBBER_BANDING,
 637                                      g_param_spec_boolean ("rubber-banding",
 638                                                            P_("Rubber Banding"),
 639                                                            P_("Whether to enable selection of multiple items by dragging the mouse pointer"),
 640                                                            FALSE,
 641                                                            GTK_PARAM_READWRITE));
 642
 643     g_object_class_install_property (o_class,
 644                                      PROP_ENABLE_GRID_LINES,
 645                                      g_param_spec_enum ("enable-grid-lines",
 646                                                         P_("Enable Grid Lines"),
 647                                                         P_("Whether grid lines should be drawn in the tree view"),
 648                                                         PSPP_TYPE_SHEET_VIEW_GRID_LINES,
 649                                                         PSPP_SHEET_VIEW_GRID_LINES_NONE,
 650                                                         GTK_PARAM_READWRITE));
 651
 652     g_object_class_install_property (o_class,
 653                                      PROP_TOOLTIP_COLUMN,
 654                                      g_param_spec_int ("tooltip-column",
 655                                                        P_("Tooltip Column"),
 656                                                        P_("The column in the model containing the tooltip texts for the rows"),
 657                                                        -1,
 658                                                        G_MAXINT,
 659                                                        -1,
 660                                                        GTK_PARAM_READWRITE));
 661
 662     g_object_class_install_property (o_class,
 663                                      PROP_SPECIAL_CELLS,
 664                                      g_param_spec_enum ("special-cells",
 665                                                         P_("Special Cells"),
 666                                                         P_("Whether rows have special cells."),
 667                                                         PSPP_TYPE_SHEET_VIEW_SPECIAL_CELLS,
 668                                                         PSPP_SHEET_VIEW_SPECIAL_CELLS_DETECT,
 669                                                         GTK_PARAM_READWRITE));
 670
 671     g_object_class_install_property (o_class,
 672                                      PROP_FIXED_HEIGHT,
 673                                      g_param_spec_int ("fixed-height",
 674                                                        P_("Fixed Height"),
 675                                                        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."),
 676                                                        -1,
 677                                                        G_MAXINT,
 678                                                        -1,
 679                                                        GTK_PARAM_READWRITE));
 680
 681     g_object_class_install_property (o_class,
 682                                      PROP_FIXED_HEIGHT_SET,
 683                                      g_param_spec_boolean ("fixed-height-set",
 684                                                            P_("Fixed Height Set"),
 685                                                            P_("Whether fixed-height was set externally."),
 686                                                            FALSE,
 687                                                            GTK_PARAM_READWRITE));
 688
 689   /* Style properties */
 690 #define _TREE_VIEW_EXPANDER_SIZE 12
 691 #define _TREE_VIEW_VERTICAL_SEPARATOR 2
 692 #define _TREE_VIEW_HORIZONTAL_SEPARATOR 2
 693
 694   gtk_widget_class_install_style_property (widget_class,
 695                                            g_param_spec_int ("expander-size",
 696                                                              P_("Expander Size"),
 697                                                              P_("Size of the expander arrow"),
 698                                                              0,
 699                                                              G_MAXINT,
 700                                                              _TREE_VIEW_EXPANDER_SIZE,
 701                                                              GTK_PARAM_READABLE));
 702
 703   gtk_widget_class_install_style_property (widget_class,
 704                                            g_param_spec_int ("vertical-separator",
 705                                                              P_("Vertical Separator Width"),
 706                                                              P_("Vertical space between cells.  Must be an even number"),
 707                                                              0,
 708                                                              G_MAXINT,
 709                                                              _TREE_VIEW_VERTICAL_SEPARATOR,
 710                                                              GTK_PARAM_READABLE));
 711
 712   gtk_widget_class_install_style_property (widget_class,
 713                                            g_param_spec_int ("horizontal-separator",
 714                                                              P_("Horizontal Separator Width"),
 715                                                              P_("Horizontal space between cells.  Must be an even number"),
 716                                                              0,
 717                                                              G_MAXINT,
 718                                                              _TREE_VIEW_HORIZONTAL_SEPARATOR,
 719                                                              GTK_PARAM_READABLE));
 720
 721   gtk_widget_class_install_style_property (widget_class,
 722                                            g_param_spec_boolean ("allow-rules",
 723                                                                  P_("Allow Rules"),
 724                                                                  P_("Allow drawing of alternating color rows"),
 725                                                                  TRUE,
 726                                                                  GTK_PARAM_READABLE));
 727
 728   gtk_widget_class_install_style_property (widget_class,
 729                                            g_param_spec_boxed ("even-row-color",
 730                                                                P_("Even Row Color"),
 731                                                                P_("Color to use for even rows"),
 732                                                                GDK_TYPE_COLOR,
 733                                                                GTK_PARAM_READABLE));
 734
 735   gtk_widget_class_install_style_property (widget_class,
 736                                            g_param_spec_boxed ("odd-row-color",
 737                                                                P_("Odd Row Color"),
 738                                                                P_("Color to use for odd rows"),
 739                                                                GDK_TYPE_COLOR,
 740                                                                GTK_PARAM_READABLE));
 741
 742   gtk_widget_class_install_style_property (widget_class,
 743                                            g_param_spec_boolean ("row-ending-details",
 744                                                                  P_("Row Ending details"),
 745                                                                  P_("Enable extended row background theming"),
 746                                                                  FALSE,
 747                                                                  GTK_PARAM_READABLE));
 748
 749   gtk_widget_class_install_style_property (widget_class,
 750                                            g_param_spec_int ("grid-line-width",
 751                                                              P_("Grid line width"),
 752                                                              P_("Width, in pixels, of the tree view grid lines"),
 753                                                              0, G_MAXINT, 1,
 754                                                              GTK_PARAM_READABLE));
 755
 756   gtk_widget_class_install_style_property (widget_class,
 757                                            g_param_spec_int ("tree-line-width",
 758                                                              P_("Tree line width"),
 759                                                              P_("Width, in pixels, of the tree view lines"),
 760                                                              0, G_MAXINT, 1,
 761                                                              GTK_PARAM_READABLE));
 762
 763   gtk_widget_class_install_style_property (widget_class,
 764                                            g_param_spec_string ("tree-line-pattern",
 765                                                                 P_("Tree line pattern"),
 766                                                                 P_("Dash pattern used to draw the tree view lines"),
 767                                                                 "\1\1",
 768                                                                 GTK_PARAM_READABLE));
 769
 770   /* Signals */
 771
 772   /**
 773    * PsppSheetView::row-activated:
 774    * @tree_view: the object on which the signal is emitted
 775    * @path: the #GtkTreePath for the activated row
 776    * @column: the #PsppSheetViewColumn in which the activation occurred
 777    *
 778    * The "row-activated" signal is emitted when the method
 779    * pspp_sheet_view_row_activated() is called or the user double clicks
 780    * a treeview row. It is also emitted when a non-editable row is
 781    * selected and one of the keys: Space, Shift+Space, Return or
 782    * Enter is pressed.
 783    *
 784    * For selection handling refer to the <link linkend="TreeWidget">tree
 785    * widget conceptual overview</link> as well as #PsppSheetSelection.
 786    */
 787   tree_view_signals[ROW_ACTIVATED] =
 788     g_signal_new ("row-activated",
 789                   G_TYPE_FROM_CLASS (o_class),
 790                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
 791                   G_STRUCT_OFFSET (PsppSheetViewClass, row_activated),
 792                   NULL, NULL,
 793                   psppire_marshal_VOID__BOXED_OBJECT,
 794                   G_TYPE_NONE, 2,
 795                   GTK_TYPE_TREE_PATH,
 796                   PSPP_TYPE_SHEET_VIEW_COLUMN);
 797
 798   /**
 799    * PsppSheetView::columns-changed:
 800    * @tree_view: the object on which the signal is emitted
 801    *
 802    * The number of columns of the treeview has changed.
 803    */
 804   tree_view_signals[COLUMNS_CHANGED] =
 805     g_signal_new ("columns-changed",
 806                   G_TYPE_FROM_CLASS (o_class),
 807                   G_SIGNAL_RUN_LAST,
 808                   G_STRUCT_OFFSET (PsppSheetViewClass, columns_changed),
 809                   NULL, NULL,
 810                   g_cclosure_marshal_VOID__VOID,
 811                   G_TYPE_NONE, 0);
 812
 813   /**
 814    * PsppSheetView::cursor-changed:
 815    * @tree_view: the object on which the signal is emitted
 816    *
 817    * The position of the cursor (focused cell) has changed.
 818    */
 819   tree_view_signals[CURSOR_CHANGED] =
 820     g_signal_new ("cursor-changed",
 821                   G_TYPE_FROM_CLASS (o_class),
 822                   G_SIGNAL_RUN_LAST,
 823                   G_STRUCT_OFFSET (PsppSheetViewClass, cursor_changed),
 824                   NULL, NULL,
 825                   g_cclosure_marshal_VOID__VOID,
 826                   G_TYPE_NONE, 0);
 827
 828   tree_view_signals[MOVE_CURSOR] =
 829     g_signal_new ("move-cursor",
 830                   G_TYPE_FROM_CLASS (o_class),
 831                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
 832                   G_STRUCT_OFFSET (PsppSheetViewClass, move_cursor),
 833                   NULL, NULL,
 834                   psppire_marshal_BOOLEAN__ENUM_INT,
 835                   G_TYPE_BOOLEAN, 2,
 836                   GTK_TYPE_MOVEMENT_STEP,
 837                   G_TYPE_INT);
 838
 839   tree_view_signals[SELECT_ALL] =
 840     g_signal_new ("select-all",
 841                   G_TYPE_FROM_CLASS (o_class),
 842                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
 843                   G_STRUCT_OFFSET (PsppSheetViewClass, select_all),
 844                   NULL, NULL,
 845                   psppire_marshal_BOOLEAN__VOID,
 846                   G_TYPE_BOOLEAN, 0);
 847
 848   tree_view_signals[UNSELECT_ALL] =
 849     g_signal_new ("unselect-all",
 850                   G_TYPE_FROM_CLASS (o_class),
 851                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
 852                   G_STRUCT_OFFSET (PsppSheetViewClass, unselect_all),
 853                   NULL, NULL,
 854                   psppire_marshal_BOOLEAN__VOID,
 855                   G_TYPE_BOOLEAN, 0);
 856
 857   tree_view_signals[SELECT_CURSOR_ROW] =
 858     g_signal_new ("select-cursor-row",
 859                   G_TYPE_FROM_CLASS (o_class),
 860                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
 861                   G_STRUCT_OFFSET (PsppSheetViewClass, select_cursor_row),
 862                   NULL, NULL,
 863                   psppire_marshal_BOOLEAN__BOOLEAN,
 864                   G_TYPE_BOOLEAN, 2,
 865                   G_TYPE_BOOLEAN, G_TYPE_INT);
 866
 867   tree_view_signals[TOGGLE_CURSOR_ROW] =
 868     g_signal_new ("toggle-cursor-row",
 869                   G_TYPE_FROM_CLASS (o_class),
 870                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
 871                   G_STRUCT_OFFSET (PsppSheetViewClass, toggle_cursor_row),
 872                   NULL, NULL,
 873                   psppire_marshal_BOOLEAN__VOID,
 874                   G_TYPE_BOOLEAN, 0);
 875
 876   tree_view_signals[START_INTERACTIVE_SEARCH] =
 877     g_signal_new ("start-interactive-search",
 878                   G_TYPE_FROM_CLASS (o_class),
 879                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
 880                   G_STRUCT_OFFSET (PsppSheetViewClass, start_interactive_search),
 881                   NULL, NULL,
 882                   psppire_marshal_BOOLEAN__VOID,
 883                   G_TYPE_BOOLEAN, 0);
 884
 885   /* Key bindings */
 886   for (i = 0; i < 2; i++)
 887     {
 888       pspp_sheet_view_add_move_binding (binding_set[i], GDK_Up, 0, TRUE,
 889                                         GTK_MOVEMENT_DISPLAY_LINES, -1);
 890       pspp_sheet_view_add_move_binding (binding_set[i], GDK_KP_Up, 0, TRUE,
 891                                         GTK_MOVEMENT_DISPLAY_LINES, -1);
 892
 893       pspp_sheet_view_add_move_binding (binding_set[i], GDK_Down, 0, TRUE,
 894                                         GTK_MOVEMENT_DISPLAY_LINES, 1);
 895       pspp_sheet_view_add_move_binding (binding_set[i], GDK_KP_Down, 0, TRUE,
 896                                         GTK_MOVEMENT_DISPLAY_LINES, 1);
 897
 898       pspp_sheet_view_add_move_binding (binding_set[i], GDK_p, GDK_CONTROL_MASK, FALSE,
 899                                         GTK_MOVEMENT_DISPLAY_LINES, -1);
 900
 901       pspp_sheet_view_add_move_binding (binding_set[i], GDK_n, GDK_CONTROL_MASK, FALSE,
 902                                         GTK_MOVEMENT_DISPLAY_LINES, 1);
 903
 904       pspp_sheet_view_add_move_binding (binding_set[i], GDK_Home, 0, TRUE,
 905                                         GTK_MOVEMENT_DISPLAY_LINE_ENDS, -1);
 906       pspp_sheet_view_add_move_binding (binding_set[i], GDK_KP_Home, 0, TRUE,
 907                                         GTK_MOVEMENT_DISPLAY_LINE_ENDS, -1);
 908
 909       pspp_sheet_view_add_move_binding (binding_set[i], GDK_End, 0, TRUE,
 910                                         GTK_MOVEMENT_DISPLAY_LINE_ENDS, 1);
 911       pspp_sheet_view_add_move_binding (binding_set[i], GDK_KP_End, 0, TRUE,
 912                                         GTK_MOVEMENT_DISPLAY_LINE_ENDS, 1);
 913
 914       pspp_sheet_view_add_move_binding (binding_set[i], GDK_Page_Up, 0, TRUE,
 915                                         GTK_MOVEMENT_PAGES, -1);
 916       pspp_sheet_view_add_move_binding (binding_set[i], GDK_KP_Page_Up, 0, TRUE,
 917                                         GTK_MOVEMENT_PAGES, -1);
 918
 919       pspp_sheet_view_add_move_binding (binding_set[i], GDK_Page_Down, 0, TRUE,
 920                                         GTK_MOVEMENT_PAGES, 1);
 921       pspp_sheet_view_add_move_binding (binding_set[i], GDK_KP_Page_Down, 0, TRUE,
 922                                         GTK_MOVEMENT_PAGES, 1);
 923
 924
 925       gtk_binding_entry_add_signal (binding_set[i], GDK_Up, GDK_CONTROL_MASK, "move-cursor", 2,
 926                                     G_TYPE_ENUM, GTK_MOVEMENT_BUFFER_ENDS,
 927                                     G_TYPE_INT, -1);
 928
 929       gtk_binding_entry_add_signal (binding_set[i], GDK_Down, GDK_CONTROL_MASK, "move-cursor", 2,
 930                                     G_TYPE_ENUM, GTK_MOVEMENT_BUFFER_ENDS,
 931                                     G_TYPE_INT, 1);
 932
 933       gtk_binding_entry_add_signal (binding_set[i], GDK_Right, 0, "move-cursor", 2,
 934                                     G_TYPE_ENUM, GTK_MOVEMENT_VISUAL_POSITIONS,
 935                                     G_TYPE_INT, 1);
 936
 937       gtk_binding_entry_add_signal (binding_set[i], GDK_Left, 0, "move-cursor", 2,
 938                                     G_TYPE_ENUM, GTK_MOVEMENT_VISUAL_POSITIONS,
 939                                     G_TYPE_INT, -1);
 940
 941       gtk_binding_entry_add_signal (binding_set[i], GDK_Tab, 0, "move-cursor", 2,
 942                                     G_TYPE_ENUM, GTK_MOVEMENT_LOGICAL_POSITIONS,
 943                                     G_TYPE_INT, 1);
 944
 945       gtk_binding_entry_add_signal (binding_set[i], GDK_Tab, GDK_SHIFT_MASK, "move-cursor", 2,
 946                                     G_TYPE_ENUM, GTK_MOVEMENT_LOGICAL_POSITIONS,
 947                                     G_TYPE_INT, -1);
 948
 949       gtk_binding_entry_add_signal (binding_set[i], GDK_KP_Right, 0, "move-cursor", 2,
 950                                     G_TYPE_ENUM, GTK_MOVEMENT_DISPLAY_LINE_ENDS,
 951                                     G_TYPE_INT, 1);
 952
 953       gtk_binding_entry_add_signal (binding_set[i], GDK_KP_Left, 0, "move-cursor", 2,
 954                                     G_TYPE_ENUM, GTK_MOVEMENT_DISPLAY_LINE_ENDS,
 955                                     G_TYPE_INT, -1);
 956
 957       gtk_binding_entry_add_signal (binding_set[i], GDK_Right, GDK_CONTROL_MASK,
 958                                     "move-cursor", 2,
 959                                     G_TYPE_ENUM, GTK_MOVEMENT_DISPLAY_LINE_ENDS,
 960                                     G_TYPE_INT, 1);
 961
 962       gtk_binding_entry_add_signal (binding_set[i], GDK_Left, GDK_CONTROL_MASK,
 963                                     "move-cursor", 2,
 964                                     G_TYPE_ENUM, GTK_MOVEMENT_DISPLAY_LINE_ENDS,
 965                                     G_TYPE_INT, -1);
 966
 967       gtk_binding_entry_add_signal (binding_set[i], GDK_KP_Right, GDK_CONTROL_MASK,
 968                                     "move-cursor", 2,
 969                                     G_TYPE_ENUM, GTK_MOVEMENT_VISUAL_POSITIONS,
 970                                     G_TYPE_INT, 1);
 971
 972       gtk_binding_entry_add_signal (binding_set[i], GDK_KP_Left, GDK_CONTROL_MASK,
 973                                     "move-cursor", 2,
 974                                     G_TYPE_ENUM, GTK_MOVEMENT_VISUAL_POSITIONS,
 975                                     G_TYPE_INT, -1);
 976
 977       gtk_binding_entry_add_signal (binding_set[i], GDK_f, GDK_CONTROL_MASK, "start-interactive-search", 0);
 978
 979       gtk_binding_entry_add_signal (binding_set[i], GDK_F, GDK_CONTROL_MASK, "start-interactive-search", 0);
 980     }
 981
 982   gtk_binding_entry_add_signal (binding_set[0], GDK_space, GDK_CONTROL_MASK, "toggle-cursor-row", 0);
 983   gtk_binding_entry_add_signal (binding_set[0], GDK_KP_Space, GDK_CONTROL_MASK, "toggle-cursor-row", 0);
 984
 985   gtk_binding_entry_add_signal (binding_set[0], GDK_a, GDK_CONTROL_MASK, "select-all", 0);
 986   gtk_binding_entry_add_signal (binding_set[0], GDK_slash, GDK_CONTROL_MASK, "select-all", 0);
 987
 988   gtk_binding_entry_add_signal (binding_set[0], GDK_A, GDK_CONTROL_MASK | GDK_SHIFT_MASK, "unselect-all", 0);
 989   gtk_binding_entry_add_signal (binding_set[0], GDK_backslash, GDK_CONTROL_MASK, "unselect-all", 0);
 990
 991   gtk_binding_entry_add_signal (binding_set[0], GDK_space, GDK_SHIFT_MASK, "select-cursor-row", 1,
 992                                 G_TYPE_BOOLEAN, TRUE,
 993                                 G_TYPE_INT, PSPP_SHEET_SELECT_MODE_EXTEND);
 994   gtk_binding_entry_add_signal (binding_set[0], GDK_KP_Space, GDK_SHIFT_MASK, "select-cursor-row", 1,
 995                                 G_TYPE_BOOLEAN, TRUE,
 996                                 G_TYPE_INT, PSPP_SHEET_SELECT_MODE_EXTEND);
 997
 998   gtk_binding_entry_add_signal (binding_set[0], GDK_space, 0, "select-cursor-row", 1,
 999                                 G_TYPE_BOOLEAN, TRUE,
1000                                 G_TYPE_INT, 0);
1001   gtk_binding_entry_add_signal (binding_set[0], GDK_KP_Space, 0, "select-cursor-row", 1,
1002                                 G_TYPE_BOOLEAN, TRUE,
1003                                 G_TYPE_INT, 0);
1004   gtk_binding_entry_add_signal (binding_set[0], GDK_Return, 0, "select-cursor-row", 1,
1005                                 G_TYPE_BOOLEAN, TRUE,
1006                                 G_TYPE_INT, 0);
1007   gtk_binding_entry_add_signal (binding_set[0], GDK_ISO_Enter, 0, "select-cursor-row", 1,
1008                                 G_TYPE_BOOLEAN, TRUE,
1009                                 G_TYPE_INT, 0);
1010   gtk_binding_entry_add_signal (binding_set[0], GDK_KP_Enter, 0, "select-cursor-row", 1,
1011                                 G_TYPE_BOOLEAN, TRUE,
1012                                 G_TYPE_INT, 0);
1013
1014   gtk_binding_entry_add_signal (binding_set[0], GDK_BackSpace, 0, "select-cursor-parent", 0);
1015   gtk_binding_entry_add_signal (binding_set[0], GDK_BackSpace, GDK_CONTROL_MASK, "select-cursor-parent", 0);
1016
1017   g_type_class_add_private (o_class, sizeof (PsppSheetViewPrivate));
1018 }
1019
1020 static void
1021 pspp_sheet_view_buildable_init (GtkBuildableIface *iface)
1022 {
1023   iface->add_child = pspp_sheet_view_buildable_add_child;
1024 }
1025
1026 static void
1027 pspp_sheet_view_init (PsppSheetView *tree_view)
1028 {
1029   tree_view->priv = G_TYPE_INSTANCE_GET_PRIVATE (tree_view, PSPP_TYPE_SHEET_VIEW, PsppSheetViewPrivate);
1030
1031   gtk_widget_set_can_focus (GTK_WIDGET (tree_view), TRUE);
1032   gtk_widget_set_redraw_on_allocate (GTK_WIDGET (tree_view), FALSE);
1033
1034   tree_view->priv->flags =  PSPP_SHEET_VIEW_DRAW_KEYFOCUS
1035                             | PSPP_SHEET_VIEW_HEADERS_VISIBLE;
1036
1037   /* We need some padding */
1038   tree_view->priv->selected = range_tower_create ();
1039   tree_view->priv->dy = 0;
1040   tree_view->priv->cursor_offset = 0;
1041   tree_view->priv->n_columns = 0;
1042   tree_view->priv->header_height = 1;
1043   tree_view->priv->x_drag = 0;
1044   tree_view->priv->drag_pos = -1;
1045   tree_view->priv->header_has_focus = FALSE;
1046   tree_view->priv->pressed_button = -1;
1047   tree_view->priv->press_start_x = -1;
1048   tree_view->priv->press_start_y = -1;
1049   tree_view->priv->reorderable = FALSE;
1050   tree_view->priv->presize_handler_timer = 0;
1051   tree_view->priv->scroll_sync_timer = 0;
1052   tree_view->priv->fixed_height = -1;
1053   tree_view->priv->fixed_height_set = FALSE;
1054   pspp_sheet_view_set_adjustments (tree_view, NULL, NULL);
1055   tree_view->priv->selection = _pspp_sheet_selection_new_with_tree_view (tree_view);
1056   tree_view->priv->enable_search = TRUE;
1057   tree_view->priv->search_column = -1;
1058   tree_view->priv->search_position_func = pspp_sheet_view_search_position_func;
1059   tree_view->priv->search_equal_func = pspp_sheet_view_search_equal_func;
1060   tree_view->priv->search_custom_entry_set = FALSE;
1061   tree_view->priv->typeselect_flush_timeout = 0;
1062   tree_view->priv->init_hadjust_value = TRUE;
1063   tree_view->priv->width = 0;
1064
1065   tree_view->priv->hover_selection = FALSE;
1066
1067   tree_view->priv->rubber_banding_enable = FALSE;
1068
1069   tree_view->priv->grid_lines = PSPP_SHEET_VIEW_GRID_LINES_NONE;
1070
1071   tree_view->priv->tooltip_column = -1;
1072
1073   tree_view->priv->special_cells = PSPP_SHEET_VIEW_SPECIAL_CELLS_DETECT;
1074
1075   tree_view->priv->post_validation_flag = FALSE;
1076
1077   tree_view->priv->last_button_x = -1;
1078   tree_view->priv->last_button_y = -1;
1079
1080   tree_view->priv->event_last_x = -10000;
1081   tree_view->priv->event_last_y = -10000;
1082
1083   tree_view->priv->prelight_node = -1;
1084   tree_view->priv->rubber_band_start_node = -1;
1085   tree_view->priv->rubber_band_end_node = -1;
1086
1087   tree_view->priv->anchor_column = NULL;
1088
1089   tree_view->priv->button_style = NULL;
1090
1091   tree_view->dispose_has_run = FALSE;
1092
1093   pspp_sheet_view_do_set_vadjustment (tree_view, NULL);
1094   pspp_sheet_view_do_set_hadjustment (tree_view, NULL);
1095   gtk_style_context_add_class (gtk_widget_get_style_context (GTK_WIDGET (tree_view)),
1096                                GTK_STYLE_CLASS_VIEW);
1097 }
1098
1099 \f
1100
1101 /* GObject Methods
1102  */
1103
1104 static void
1105 pspp_sheet_view_set_property (GObject         *object,
1106                             guint            prop_id,
1107                             const GValue    *value,
1108                             GParamSpec      *pspec)
1109 {
1110   PsppSheetView *tree_view;
1111
1112   tree_view = PSPP_SHEET_VIEW (object);
1113
1114   switch (prop_id)
1115     {
1116     case PROP_MODEL:
1117       pspp_sheet_view_set_model (tree_view, g_value_get_object (value));
1118       break;
1119     case PROP_HADJUSTMENT:
1120       pspp_sheet_view_do_set_hadjustment (tree_view, g_value_get_object (value));
1121       break;
1122     case PROP_VADJUSTMENT:
1123       pspp_sheet_view_do_set_vadjustment (tree_view, g_value_get_object (value));
1124       break;
1125     case PROP_HSCROLL_POLICY:
1126       tree_view->priv->hscroll_policy = g_value_get_enum (value);
1127       gtk_widget_queue_resize (GTK_WIDGET (tree_view));
1128       break;
1129     case PROP_VSCROLL_POLICY:
1130       tree_view->priv->vscroll_policy = g_value_get_enum (value);
1131       gtk_widget_queue_resize (GTK_WIDGET (tree_view));
1132       break;
1133      case PROP_HEADERS_VISIBLE:
1134       pspp_sheet_view_set_headers_visible (tree_view, g_value_get_boolean (value));
1135       break;
1136     case PROP_HEADERS_CLICKABLE:
1137       pspp_sheet_view_set_headers_clickable (tree_view, g_value_get_boolean (value));
1138       break;
1139     case PROP_REORDERABLE:
1140       pspp_sheet_view_set_reorderable (tree_view, g_value_get_boolean (value));
1141       break;
1142     case PROP_RULES_HINT:
1143       pspp_sheet_view_set_rules_hint (tree_view, g_value_get_boolean (value));
1144       break;
1145     case PROP_ENABLE_SEARCH:
1146       pspp_sheet_view_set_enable_search (tree_view, g_value_get_boolean (value));
1147       break;
1148     case PROP_SEARCH_COLUMN:
1149       pspp_sheet_view_set_search_column (tree_view, g_value_get_int (value));
1150       break;
1151     case PROP_HOVER_SELECTION:
1152       tree_view->priv->hover_selection = g_value_get_boolean (value);
1153       break;
1154     case PROP_RUBBER_BANDING:
1155       tree_view->priv->rubber_banding_enable = g_value_get_boolean (value);
1156       break;
1157     case PROP_ENABLE_GRID_LINES:
1158       pspp_sheet_view_set_grid_lines (tree_view, g_value_get_enum (value));
1159       break;
1160     case PROP_TOOLTIP_COLUMN:
1161       pspp_sheet_view_set_tooltip_column (tree_view, g_value_get_int (value));
1162       break;
1163     case PROP_SPECIAL_CELLS:
1164       pspp_sheet_view_set_special_cells (tree_view, g_value_get_enum (value));
1165       break;
1166     case PROP_FIXED_HEIGHT:
1167       pspp_sheet_view_set_fixed_height (tree_view, g_value_get_int (value));
1168       break;
1169     case PROP_FIXED_HEIGHT_SET:
1170       if (g_value_get_boolean (value))
1171         {
1172           if (!tree_view->priv->fixed_height_set
1173               && tree_view->priv->fixed_height >= 0)
1174             {
1175               tree_view->priv->fixed_height_set = true;
1176               g_object_notify (G_OBJECT (tree_view), "fixed-height-set");
1177             }
1178         }
1179       else
1180         {
1181           if (tree_view->priv->fixed_height_set)
1182             {
1183               tree_view->priv->fixed_height_set = false;
1184               g_object_notify (G_OBJECT (tree_view), "fixed-height-set");
1185               install_presize_handler (tree_view);
1186             }
1187         }
1188       break;
1189     default:
1190       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
1191       break;
1192     }
1193 }
1194
1195 static void
1196 pspp_sheet_view_get_property (GObject    *object,
1197                             guint       prop_id,
1198                             GValue     *value,
1199                             GParamSpec *pspec)
1200 {
1201   PsppSheetView *tree_view;
1202
1203   tree_view = PSPP_SHEET_VIEW (object);
1204
1205   switch (prop_id)
1206     {
1207     case PROP_MODEL:
1208       g_value_set_object (value, tree_view->priv->model);
1209       break;
1210     case PROP_HADJUSTMENT:
1211       g_value_set_object (value, tree_view->priv->hadjustment);
1212       break;
1213     case PROP_VADJUSTMENT:
1214       g_value_set_object (value, tree_view->priv->vadjustment);
1215       break;
1216     case PROP_HSCROLL_POLICY:
1217       g_value_set_enum (value, tree_view->priv->hscroll_policy);
1218       break;
1219     case PROP_VSCROLL_POLICY:
1220       g_value_set_enum (value, tree_view->priv->vscroll_policy);
1221       break;
1222     case PROP_HEADERS_VISIBLE:
1223       g_value_set_boolean (value, pspp_sheet_view_get_headers_visible (tree_view));
1224       break;
1225     case PROP_HEADERS_CLICKABLE:
1226       g_value_set_boolean (value, pspp_sheet_view_get_headers_clickable (tree_view));
1227       break;
1228     case PROP_REORDERABLE:
1229       g_value_set_boolean (value, tree_view->priv->reorderable);
1230       break;
1231     case PROP_RULES_HINT:
1232       g_value_set_boolean (value, tree_view->priv->has_rules);
1233       break;
1234     case PROP_ENABLE_SEARCH:
1235       g_value_set_boolean (value, tree_view->priv->enable_search);
1236       break;
1237     case PROP_SEARCH_COLUMN:
1238       g_value_set_int (value, tree_view->priv->search_column);
1239       break;
1240     case PROP_HOVER_SELECTION:
1241       g_value_set_boolean (value, tree_view->priv->hover_selection);
1242       break;
1243     case PROP_RUBBER_BANDING:
1244       g_value_set_boolean (value, tree_view->priv->rubber_banding_enable);
1245       break;
1246     case PROP_ENABLE_GRID_LINES:
1247       g_value_set_enum (value, tree_view->priv->grid_lines);
1248       break;
1249     case PROP_TOOLTIP_COLUMN:
1250       g_value_set_int (value, tree_view->priv->tooltip_column);
1251       break;
1252     case PROP_SPECIAL_CELLS:
1253       g_value_set_enum (value, tree_view->priv->special_cells);
1254       break;
1255     case PROP_FIXED_HEIGHT:
1256       g_value_set_int (value, pspp_sheet_view_get_fixed_height (tree_view));
1257       break;
1258     case PROP_FIXED_HEIGHT_SET:
1259       g_value_set_boolean (value, tree_view->priv->fixed_height_set);
1260       break;
1261     default:
1262       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
1263       break;
1264     }
1265 }
1266
1267 static void
1268 pspp_sheet_view_dispose (GObject *object)
1269 {
1270   PsppSheetView *tree_view = PSPP_SHEET_VIEW (object);
1271
1272   if (tree_view->dispose_has_run)
1273     return;
1274
1275   tree_view->dispose_has_run = TRUE;
1276
1277   if (tree_view->priv->selection != NULL)
1278     {
1279       _pspp_sheet_selection_set_tree_view (tree_view->priv->selection, NULL);
1280       g_object_unref (tree_view->priv->selection);
1281       tree_view->priv->selection = NULL;
1282     }
1283
1284   if (tree_view->priv->hadjustment)
1285     {
1286       g_object_unref (tree_view->priv->hadjustment);
1287       tree_view->priv->hadjustment = NULL;
1288     }
1289   if (tree_view->priv->vadjustment)
1290     {
1291       g_object_unref (tree_view->priv->vadjustment);
1292       tree_view->priv->vadjustment = NULL;
1293     }
1294
1295   if (tree_view->priv->button_style)
1296     {
1297       g_object_unref (tree_view->priv->button_style);
1298       tree_view->priv->button_style = NULL;
1299     }
1300
1301
1302   G_OBJECT_CLASS (pspp_sheet_view_parent_class)->dispose (object);
1303 }
1304
1305 \f
1306
1307 static void
1308 pspp_sheet_view_buildable_add_child (GtkBuildable *tree_view,
1309                                    GtkBuilder  *builder,
1310                                    GObject     *child,
1311                                    const gchar *type)
1312 {
1313   pspp_sheet_view_append_column (PSPP_SHEET_VIEW (tree_view), PSPP_SHEET_VIEW_COLUMN (child));
1314 }
1315
1316 static void
1317 pspp_sheet_view_finalize (GObject *object)
1318 {
1319   PsppSheetView *tree_view = PSPP_SHEET_VIEW (object);
1320
1321   pspp_sheet_view_stop_editing (tree_view, TRUE);
1322
1323   if (tree_view->priv->selected != NULL)
1324     {
1325       range_tower_destroy (tree_view->priv->selected);
1326       tree_view->priv->selected = NULL;
1327     }
1328
1329
1330   tree_view->priv->prelight_node = -1;
1331
1332
1333   if (tree_view->priv->scroll_to_path != NULL)
1334     {
1335       gtk_tree_row_reference_free (tree_view->priv->scroll_to_path);
1336       tree_view->priv->scroll_to_path = NULL;
1337     }
1338
1339   if (tree_view->priv->drag_dest_row != NULL)
1340     {
1341       gtk_tree_row_reference_free (tree_view->priv->drag_dest_row);
1342       tree_view->priv->drag_dest_row = NULL;
1343     }
1344
1345   if (tree_view->priv->top_row != NULL)
1346     {
1347       gtk_tree_row_reference_free (tree_view->priv->top_row);
1348       tree_view->priv->top_row = NULL;
1349     }
1350
1351   if (tree_view->priv->column_drop_func_data &&
1352       tree_view->priv->column_drop_func_data_destroy)
1353     {
1354       tree_view->priv->column_drop_func_data_destroy (tree_view->priv->column_drop_func_data);
1355       tree_view->priv->column_drop_func_data = NULL;
1356     }
1357
1358   if (tree_view->priv->destroy_count_destroy &&
1359       tree_view->priv->destroy_count_data)
1360     {
1361       tree_view->priv->destroy_count_destroy (tree_view->priv->destroy_count_data);
1362       tree_view->priv->destroy_count_data = NULL;
1363     }
1364
1365   gtk_tree_row_reference_free (tree_view->priv->cursor);
1366   tree_view->priv->cursor = NULL;
1367
1368   gtk_tree_row_reference_free (tree_view->priv->anchor);
1369   tree_view->priv->anchor = NULL;
1370
1371   /* destroy interactive search dialog */
1372   if (tree_view->priv->search_window)
1373     {
1374       gtk_widget_destroy (tree_view->priv->search_window);
1375       tree_view->priv->search_window = NULL;
1376       tree_view->priv->search_entry = NULL;
1377       if (tree_view->priv->typeselect_flush_timeout)
1378         {
1379           g_source_remove (tree_view->priv->typeselect_flush_timeout);
1380           tree_view->priv->typeselect_flush_timeout = 0;
1381         }
1382     }
1383
1384   if (tree_view->priv->search_destroy && tree_view->priv->search_user_data)
1385     {
1386       tree_view->priv->search_destroy (tree_view->priv->search_user_data);
1387       tree_view->priv->search_user_data = NULL;
1388     }
1389
1390   if (tree_view->priv->search_position_destroy && tree_view->priv->search_position_user_data)
1391     {
1392       tree_view->priv->search_position_destroy (tree_view->priv->search_position_user_data);
1393       tree_view->priv->search_position_user_data = NULL;
1394     }
1395
1396   pspp_sheet_view_set_model (tree_view, NULL);
1397
1398
1399   G_OBJECT_CLASS (pspp_sheet_view_parent_class)->finalize (object);
1400 }
1401
1402 \f
1403
1404 /* GtkWidget Methods
1405  */
1406
1407 /* GtkWidget::map helper */
1408 static void
1409 pspp_sheet_view_map_buttons (PsppSheetView *tree_view)
1410 {
1411   GList *list;
1412
1413   g_return_if_fail (gtk_widget_get_mapped (GTK_WIDGET (tree_view)));
1414
1415   if (PSPP_SHEET_VIEW_FLAG_SET (tree_view, PSPP_SHEET_VIEW_HEADERS_VISIBLE))
1416     {
1417       PsppSheetViewColumn *column;
1418
1419       for (list = tree_view->priv->columns; list; list = list->next)
1420         {
1421           column = list->data;
1422           if (column->button != NULL &&
1423               gtk_widget_get_visible (column->button) &&
1424               !gtk_widget_get_mapped (column->button))
1425             gtk_widget_map (column->button);
1426         }
1427       for (list = tree_view->priv->columns; list; list = list->next)
1428         {
1429           column = list->data;
1430           if (column->visible == FALSE || column->window == NULL)
1431             continue;
1432           if (column->resizable)
1433             {
1434               gdk_window_raise (column->window);
1435               gdk_window_show (column->window);
1436             }
1437           else
1438             gdk_window_hide (column->window);
1439         }
1440       gdk_window_show (tree_view->priv->header_window);
1441     }
1442 }
1443
1444 static void
1445 pspp_sheet_view_map (GtkWidget *widget)
1446 {
1447   PsppSheetView *tree_view = PSPP_SHEET_VIEW (widget);
1448   GList *tmp_list;
1449
1450   gtk_widget_set_mapped (widget, TRUE);
1451
1452   tmp_list = tree_view->priv->children;
1453   while (tmp_list)
1454     {
1455       PsppSheetViewChild *child = tmp_list->data;
1456       tmp_list = tmp_list->next;
1457
1458       if (gtk_widget_get_visible (child->widget))
1459         {
1460           if (!gtk_widget_get_mapped (child->widget))
1461             gtk_widget_map (child->widget);
1462         }
1463     }
1464   gdk_window_show (tree_view->priv->bin_window);
1465
1466   pspp_sheet_view_map_buttons (tree_view);
1467
1468   gdk_window_show (gtk_widget_get_window (widget));
1469 }
1470
1471 static void
1472 pspp_sheet_view_realize (GtkWidget *widget)
1473 {
1474   PsppSheetView *tree_view = PSPP_SHEET_VIEW (widget);
1475   GList *tmp_list;
1476   GdkWindow *window;
1477   GdkWindowAttr attributes;
1478   gint attributes_mask;
1479   GtkAllocation allocation;
1480
1481   gtk_widget_set_realized (widget, TRUE);
1482
1483   gtk_widget_get_allocation (widget, &allocation);
1484
1485   /* Make the main, clipping window */
1486   attributes.window_type = GDK_WINDOW_CHILD;
1487   attributes.x =      allocation.x;
1488   attributes.y =      allocation.y;
1489   attributes.width =  allocation.width;
1490   attributes.height = allocation.height;
1491   attributes.wclass = GDK_INPUT_OUTPUT;
1492   attributes.visual = gtk_widget_get_visual (widget);
1493   attributes.event_mask = GDK_VISIBILITY_NOTIFY_MASK;
1494
1495   attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL;
1496
1497   window = gdk_window_new (gtk_widget_get_parent_window (widget),
1498                            &attributes, attributes_mask);
1499   gtk_widget_set_window (widget, window);
1500
1501   gtk_widget_register_window (widget, window);
1502   gtk_widget_get_allocation (widget, &allocation);
1503
1504   /* Make the window for the tree */
1505   attributes.x = 0;
1506   attributes.y = TREE_VIEW_HEADER_HEIGHT (tree_view);
1507   attributes.width = MAX (tree_view->priv->width, allocation.width);
1508   attributes.height = allocation.height;
1509   attributes.event_mask = (GDK_EXPOSURE_MASK |
1510                            GDK_SCROLL_MASK |
1511                            GDK_POINTER_MOTION_MASK |
1512                            GDK_ENTER_NOTIFY_MASK |
1513                            GDK_LEAVE_NOTIFY_MASK |
1514                            GDK_BUTTON_PRESS_MASK |
1515                            GDK_BUTTON_RELEASE_MASK |
1516                            gtk_widget_get_events (widget));
1517
1518   tree_view->priv->bin_window = gdk_window_new (window,
1519                                                 &attributes, attributes_mask);
1520   gtk_widget_register_window (widget, tree_view->priv->bin_window);
1521   gtk_widget_get_allocation (widget, &allocation);
1522
1523   /* Make the column header window */
1524   attributes.x = 0;
1525   attributes.y = 0;
1526   attributes.width = MAX (tree_view->priv->width, allocation.width);
1527   attributes.height = tree_view->priv->header_height;
1528   attributes.event_mask = (GDK_EXPOSURE_MASK |
1529                            GDK_SCROLL_MASK |
1530                            GDK_BUTTON_PRESS_MASK |
1531                            GDK_BUTTON_RELEASE_MASK |
1532                            GDK_KEY_PRESS_MASK |
1533                            GDK_KEY_RELEASE_MASK |
1534                            gtk_widget_get_events (widget));
1535
1536   tree_view->priv->header_window = gdk_window_new (window,
1537                                                    &attributes, attributes_mask);
1538   gtk_widget_register_window (widget, tree_view->priv->header_window);
1539
1540   { /* Ensure Background */
1541     GtkStyleContext *context;
1542
1543     context = gtk_widget_get_style_context (GTK_WIDGET (tree_view));
1544
1545     gtk_style_context_set_background (context, gtk_widget_get_window (GTK_WIDGET (tree_view)));
1546     gtk_style_context_set_background (context, tree_view->priv->header_window);
1547   }
1548
1549   tmp_list = tree_view->priv->children;
1550   while (tmp_list)
1551     {
1552       PsppSheetViewChild *child = tmp_list->data;
1553       tmp_list = tmp_list->next;
1554
1555       gtk_widget_set_parent_window (child->widget, tree_view->priv->bin_window);
1556     }
1557
1558   for (tmp_list = tree_view->priv->columns; tmp_list; tmp_list = tmp_list->next)
1559     _pspp_sheet_view_column_realize_button (PSPP_SHEET_VIEW_COLUMN (tmp_list->data));
1560
1561   /* Need to call those here, since they create GCs */
1562   pspp_sheet_view_set_grid_lines (tree_view, tree_view->priv->grid_lines);
1563
1564   install_presize_handler (tree_view);
1565 }
1566
1567 static void
1568 pspp_sheet_view_unrealize (GtkWidget *widget)
1569 {
1570   PsppSheetView *tree_view = PSPP_SHEET_VIEW (widget);
1571   PsppSheetViewPrivate *priv = tree_view->priv;
1572   GList *list;
1573
1574   GTK_WIDGET_CLASS (pspp_sheet_view_parent_class)->unrealize (widget);
1575
1576   if (priv->scroll_timeout != 0)
1577     {
1578       g_source_remove (priv->scroll_timeout);
1579       priv->scroll_timeout = 0;
1580     }
1581
1582   if (priv->open_dest_timeout != 0)
1583     {
1584       g_source_remove (priv->open_dest_timeout);
1585       priv->open_dest_timeout = 0;
1586     }
1587
1588   if (priv->presize_handler_timer != 0)
1589     {
1590       g_source_remove (priv->presize_handler_timer);
1591       priv->presize_handler_timer = 0;
1592     }
1593
1594   if (priv->validate_rows_timer != 0)
1595     {
1596       g_source_remove (priv->validate_rows_timer);
1597       priv->validate_rows_timer = 0;
1598     }
1599
1600   if (priv->scroll_sync_timer != 0)
1601     {
1602       g_source_remove (priv->scroll_sync_timer);
1603       priv->scroll_sync_timer = 0;
1604     }
1605
1606   if (priv->typeselect_flush_timeout)
1607     {
1608       g_source_remove (priv->typeselect_flush_timeout);
1609       priv->typeselect_flush_timeout = 0;
1610     }
1611
1612   for (list = priv->columns; list; list = list->next)
1613     _pspp_sheet_view_column_unrealize_button (PSPP_SHEET_VIEW_COLUMN (list->data));
1614
1615   gdk_window_set_user_data (priv->bin_window, NULL);
1616   gdk_window_destroy (priv->bin_window);
1617   priv->bin_window = NULL;
1618
1619   gdk_window_set_user_data (priv->header_window, NULL);
1620   gdk_window_destroy (priv->header_window);
1621   priv->header_window = NULL;
1622
1623   if (priv->drag_window)
1624     {
1625       gdk_window_set_user_data (priv->drag_window, NULL);
1626       gdk_window_destroy (priv->drag_window);
1627       priv->drag_window = NULL;
1628     }
1629
1630   if (priv->drag_highlight_window)
1631     {
1632       gdk_window_set_user_data (priv->drag_highlight_window, NULL);
1633       gdk_window_destroy (priv->drag_highlight_window);
1634       priv->drag_highlight_window = NULL;
1635     }
1636
1637   if (tree_view->priv->columns != NULL)
1638     {
1639       list = tree_view->priv->columns;
1640       while (list)
1641         {
1642           PsppSheetViewColumn *column;
1643           column = PSPP_SHEET_VIEW_COLUMN (list->data);
1644           list = list->next;
1645           pspp_sheet_view_remove_column (tree_view, column);
1646         }
1647       tree_view->priv->columns = NULL;
1648     }
1649 }
1650
1651 /* GtkWidget::size_request helper */
1652 static void
1653 pspp_sheet_view_size_request_columns (PsppSheetView *tree_view)
1654 {
1655   GList *list;
1656
1657   tree_view->priv->header_height = 0;
1658
1659   if (tree_view->priv->model)
1660     {
1661       for (list = tree_view->priv->columns; list; list = list->next)
1662         {
1663           GtkRequisition requisition;
1664           PsppSheetViewColumn *column = list->data;
1665
1666           pspp_sheet_view_column_size_request (column, &requisition);
1667           column->button_request = requisition.width;
1668           tree_view->priv->header_height = MAX (tree_view->priv->header_height, requisition.height);
1669         }
1670     }
1671 }
1672
1673
1674 /* Called only by ::size_request */
1675 static void
1676 pspp_sheet_view_update_size (PsppSheetView *tree_view)
1677 {
1678   GList *list;
1679   PsppSheetViewColumn *column;
1680   gint i;
1681
1682   if (tree_view->priv->model == NULL)
1683     {
1684       tree_view->priv->width = 0;
1685       tree_view->priv->prev_width = 0;
1686       tree_view->priv->height = 0;
1687       return;
1688     }
1689
1690   tree_view->priv->prev_width = tree_view->priv->width;
1691   tree_view->priv->width = 0;
1692
1693   /* keep this in sync with size_allocate below */
1694   for (list = tree_view->priv->columns, i = 0; list; list = list->next, i++)
1695     {
1696       gint real_requested_width = 0;
1697       column = list->data;
1698       if (!column->visible)
1699         continue;
1700
1701       if (column->use_resized_width)
1702         {
1703           real_requested_width = column->resized_width;
1704         }
1705       else
1706         {
1707           real_requested_width = column->fixed_width;
1708         }
1709
1710       if (column->min_width != -1)
1711         real_requested_width = MAX (real_requested_width, column->min_width);
1712       if (column->max_width != -1)
1713         real_requested_width = MIN (real_requested_width, column->max_width);
1714
1715       tree_view->priv->width += real_requested_width;
1716     }
1717
1718   tree_view->priv->height = tree_view->priv->fixed_height * tree_view->priv->row_count;
1719 }
1720
1721 static void
1722 pspp_sheet_view_size_request (GtkWidget      *widget,
1723                             GtkRequisition *requisition)
1724 {
1725   PsppSheetView *tree_view = PSPP_SHEET_VIEW (widget);
1726   GList *tmp_list;
1727
1728   /* we validate some rows initially just to make sure we have some size.
1729    * In practice, with a lot of static lists, this should get a good width.
1730    */
1731   initialize_fixed_height_mode (tree_view);
1732   pspp_sheet_view_size_request_columns (tree_view);
1733   pspp_sheet_view_update_size (PSPP_SHEET_VIEW (widget));
1734
1735   requisition->width = tree_view->priv->width;
1736   requisition->height = tree_view->priv->height + TREE_VIEW_HEADER_HEIGHT (tree_view);
1737
1738   tmp_list = tree_view->priv->children;
1739
1740   while (tmp_list)
1741     {
1742       PsppSheetViewChild *child = tmp_list->data;
1743       GtkRequisition child_requisition;
1744
1745       tmp_list = tmp_list->next;
1746
1747       if (gtk_widget_get_visible (child->widget))
1748         {
1749           gtk_widget_get_preferred_size (child->widget, NULL, &child_requisition);
1750         }
1751     }
1752 }
1753
1754 static void
1755 invalidate_column (PsppSheetView       *tree_view,
1756                    PsppSheetViewColumn *column)
1757 {
1758   gint column_offset = 0;
1759   GList *list;
1760   GtkWidget *widget = GTK_WIDGET (tree_view);
1761   gboolean rtl;
1762
1763   if (!gtk_widget_get_realized (widget))
1764     return;
1765
1766   rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
1767   for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns));
1768        list;
1769        list = (rtl ? list->prev : list->next))
1770     {
1771       PsppSheetViewColumn *tmpcolumn = list->data;
1772       if (tmpcolumn == column)
1773         {
1774           GdkRectangle invalid_rect;
1775           GtkAllocation allocation;
1776
1777           gtk_widget_get_allocation (widget, &allocation);
1778           invalid_rect.x = column_offset;
1779           invalid_rect.y = 0;
1780           invalid_rect.width = column->width;
1781           invalid_rect.height = allocation.height;
1782
1783           gdk_window_invalidate_rect (gtk_widget_get_window (widget), &invalid_rect, TRUE);
1784           break;
1785         }
1786
1787       column_offset += tmpcolumn->width;
1788     }
1789 }
1790
1791 static void
1792 invalidate_last_column (PsppSheetView *tree_view)
1793 {
1794   GList *last_column;
1795   gboolean rtl;
1796
1797   rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
1798
1799   for (last_column = (rtl ? g_list_first (tree_view->priv->columns) : g_list_last (tree_view->priv->columns));
1800        last_column;
1801        last_column = (rtl ? last_column->next : last_column->prev))
1802     {
1803       if (PSPP_SHEET_VIEW_COLUMN (last_column->data)->visible)
1804         {
1805           invalidate_column (tree_view, last_column->data);
1806           return;
1807         }
1808     }
1809 }
1810
1811 static gint
1812 pspp_sheet_view_get_real_requested_width_from_column (PsppSheetView       *tree_view,
1813                                                     PsppSheetViewColumn *column)
1814 {
1815   gint real_requested_width;
1816
1817   if (column->use_resized_width)
1818     {
1819       real_requested_width = column->resized_width;
1820     }
1821   else
1822     {
1823       real_requested_width = column->fixed_width;
1824     }
1825
1826   if (column->min_width != -1)
1827     real_requested_width = MAX (real_requested_width, column->min_width);
1828   if (column->max_width != -1)
1829     real_requested_width = MIN (real_requested_width, column->max_width);
1830
1831   return real_requested_width;
1832 }
1833
1834 static gboolean
1835 span_intersects (int a0, int a_width,
1836                  int b0, int b_width)
1837 {
1838   int a1 = a0 + a_width;
1839   int b1 = b0 + b_width;
1840   return (a0 >= b0 && a0 < b1) || (b0 >= a0 && b0 < a1);
1841 }
1842
1843 /* GtkWidget::size_allocate helper */
1844 static void
1845 pspp_sheet_view_size_allocate_columns (GtkWidget *widget,
1846                                      gboolean  *width_changed)
1847 {
1848   PsppSheetView *tree_view;
1849   GList *list, *first_column, *last_column;
1850   PsppSheetViewColumn *column;
1851   GtkAllocation col_allocation;
1852   GtkAllocation allocation;
1853   gint width = 0;
1854   gint extra, extra_per_column;
1855   gint full_requested_width = 0;
1856   gint number_of_expand_columns = 0;
1857   gboolean column_changed = FALSE;
1858   gboolean rtl;
1859
1860   tree_view = PSPP_SHEET_VIEW (widget);
1861
1862   for (last_column = g_list_last (tree_view->priv->columns);
1863        last_column && !(PSPP_SHEET_VIEW_COLUMN (last_column->data)->visible);
1864        last_column = last_column->prev)
1865     ;
1866
1867   if (last_column == NULL)
1868     return;
1869
1870   for (first_column = g_list_first (tree_view->priv->columns);
1871        first_column && !(PSPP_SHEET_VIEW_COLUMN (first_column->data)->visible);
1872        first_column = first_column->next)
1873     ;
1874
1875   col_allocation.y = 0;
1876   col_allocation.height = tree_view->priv->header_height;
1877
1878   rtl = (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL);
1879
1880   /* find out how many extra space and expandable columns we have */
1881   for (list = tree_view->priv->columns; list != last_column->next; list = list->next)
1882     {
1883       column = (PsppSheetViewColumn *)list->data;
1884
1885       if (!column->visible)
1886         continue;
1887
1888       full_requested_width += pspp_sheet_view_get_real_requested_width_from_column (tree_view, column);
1889
1890       if (column->expand)
1891         number_of_expand_columns++;
1892     }
1893
1894   gtk_widget_get_allocation (widget, &allocation);
1895   extra = MAX (allocation.width - full_requested_width, 0);
1896   if (number_of_expand_columns > 0)
1897     extra_per_column = extra/number_of_expand_columns;
1898   else
1899     extra_per_column = 0;
1900
1901   for (list = (rtl ? last_column : first_column);
1902        list != (rtl ? first_column->prev : last_column->next);
1903        list = (rtl ? list->prev : list->next))
1904     {
1905       gint real_requested_width = 0;
1906       gint old_width;
1907
1908       column = list->data;
1909       old_width = column->width;
1910
1911       if (!column->visible)
1912         continue;
1913
1914       /* We need to handle the dragged button specially.
1915        */
1916       if (column == tree_view->priv->drag_column)
1917         {
1918           GtkAllocation drag_allocation;
1919           drag_allocation.width =  gdk_window_get_width (tree_view->priv->drag_window);
1920           drag_allocation.height = gdk_window_get_height (tree_view->priv->drag_window);
1921           drag_allocation.x = 0;
1922           drag_allocation.y = 0;
1923           pspp_sheet_view_column_size_allocate (tree_view->priv->drag_column,
1924                                                 &drag_allocation);
1925           width += drag_allocation.width;
1926           continue;
1927         }
1928
1929       real_requested_width = pspp_sheet_view_get_real_requested_width_from_column (tree_view, column);
1930
1931       col_allocation.x = width;
1932       column->width = real_requested_width;
1933
1934       if (column->expand)
1935         {
1936           if (number_of_expand_columns == 1)
1937             {
1938               /* We add the remander to the last column as
1939                * */
1940               column->width += extra;
1941             }
1942           else
1943             {
1944               column->width += extra_per_column;
1945               extra -= extra_per_column;
1946               number_of_expand_columns --;
1947             }
1948         }
1949
1950       if (column->width != old_width)
1951         g_object_notify (G_OBJECT (column), "width");
1952
1953       col_allocation.width = column->width;
1954       width += column->width;
1955
1956       if (column->width > old_width)
1957         column_changed = TRUE;
1958
1959       pspp_sheet_view_column_size_allocate (column, &col_allocation);
1960
1961       if (column->window)
1962         gdk_window_move_resize (column->window,
1963                                 col_allocation.x + (rtl ? 0 : col_allocation.width) - TREE_VIEW_DRAG_WIDTH/2,
1964                                 col_allocation.y,
1965                                 TREE_VIEW_DRAG_WIDTH, col_allocation.height);
1966     }
1967
1968   /* We change the width here.  The user might have been resizing columns,
1969    * so the total width of the tree view changes.
1970    */
1971   tree_view->priv->width = width;
1972   if (width_changed)
1973     *width_changed = TRUE;
1974
1975   if (column_changed)
1976     gtk_widget_queue_draw (GTK_WIDGET (tree_view));
1977 }
1978
1979 static void
1980 update_childrens_allocation (PsppSheetView *tree_view)
1981 {
1982   GList *tmp_list;
1983   for (tmp_list = tree_view->priv->children; tmp_list; tmp_list = tmp_list->next)
1984     {
1985       PsppSheetViewChild *child = tmp_list->data;
1986       GtkAllocation allocation;
1987       GtkTreePath *path;
1988
1989       /* totally ignore our child's requisition */
1990       path = _pspp_sheet_view_find_path (tree_view, child->node);
1991       pspp_sheet_view_get_cell_area (tree_view, path, child->column, &allocation);
1992       gtk_tree_path_free (path);
1993       gtk_widget_size_allocate (child->widget, &allocation);
1994     }
1995 }
1996
1997 static void
1998 pspp_sheet_view_size_allocate (GtkWidget     *widget,
1999                              GtkAllocation *allocation)
2000 {
2001   PsppSheetView *tree_view = PSPP_SHEET_VIEW (widget);
2002   GList *tmp_list;
2003   gboolean width_changed = FALSE;
2004   GtkAllocation old_allocation;
2005   gtk_widget_get_allocation (widget, &old_allocation);
2006
2007   if (allocation->width != old_allocation.width)
2008     width_changed = TRUE;
2009
2010   if (gtk_widget_get_direction(widget) == GTK_TEXT_DIR_RTL)
2011     allocation->x += allocation->width - tree_view->priv->width ;
2012
2013   gtk_widget_set_allocation (widget, allocation);
2014
2015   /* We size-allocate the columns first because the width of the
2016    * tree view (used in updating the adjustments below) might change.
2017    */
2018   pspp_sheet_view_size_allocate_columns (widget, &width_changed);
2019
2020   gtk_adjustment_set_page_size (tree_view->priv->hadjustment, allocation->width);
2021   gtk_adjustment_set_page_increment (tree_view->priv->hadjustment, allocation->width * 0.9);
2022   gtk_adjustment_set_step_increment (tree_view->priv->hadjustment, allocation->width * 0.1);
2023   gtk_adjustment_set_lower (tree_view->priv->hadjustment, 0);
2024   gtk_adjustment_set_upper (tree_view->priv->hadjustment, MAX (gtk_adjustment_get_page_size (tree_view->priv->hadjustment), tree_view->priv->width));
2025
2026   if (gtk_widget_get_direction(widget) == GTK_TEXT_DIR_RTL)
2027     {
2028       if (allocation->width < tree_view->priv->width)
2029         {
2030           if (tree_view->priv->init_hadjust_value)
2031             {
2032               gtk_adjustment_set_value (tree_view->priv->hadjustment, MAX (tree_view->priv->width - allocation->width, 0));
2033               tree_view->priv->init_hadjust_value = FALSE;
2034             }
2035           else if (allocation->width != old_allocation.width)
2036             {
2037               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));
2038             }
2039           else
2040             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));
2041         }
2042       else
2043         {
2044           gtk_adjustment_set_value (tree_view->priv->hadjustment, 0);
2045           tree_view->priv->init_hadjust_value = TRUE;
2046         }
2047     }
2048   else
2049     if (gtk_adjustment_get_value (tree_view->priv->hadjustment) + allocation->width > tree_view->priv->width)
2050       gtk_adjustment_set_value (tree_view->priv->hadjustment, MAX (tree_view->priv->width - allocation->width, 0));
2051
2052   gtk_adjustment_changed (tree_view->priv->hadjustment);
2053
2054   gtk_adjustment_set_page_size (tree_view->priv->vadjustment, allocation->height - TREE_VIEW_HEADER_HEIGHT (tree_view));
2055   gtk_adjustment_set_step_increment (tree_view->priv->vadjustment, gtk_adjustment_get_page_size (tree_view->priv->vadjustment) * 0.1);
2056   gtk_adjustment_set_page_increment (tree_view->priv->vadjustment, gtk_adjustment_get_page_size (tree_view->priv->vadjustment) * 0.9);
2057   gtk_adjustment_set_lower (tree_view->priv->vadjustment, 0);
2058   gtk_adjustment_set_upper (tree_view->priv->vadjustment, MAX (gtk_adjustment_get_page_size (tree_view->priv->vadjustment), tree_view->priv->height));
2059
2060   gtk_adjustment_changed (tree_view->priv->vadjustment);
2061
2062   /* now the adjustments and window sizes are in sync, we can sync toprow/dy again */
2063   if (tree_view->priv->height <= gtk_adjustment_get_page_size (tree_view->priv->vadjustment))
2064     gtk_adjustment_set_value (GTK_ADJUSTMENT (tree_view->priv->vadjustment), 0);
2065   else if (gtk_adjustment_get_value (tree_view->priv->vadjustment) + gtk_adjustment_get_page_size (tree_view->priv->vadjustment) > tree_view->priv->height)
2066     gtk_adjustment_set_value (GTK_ADJUSTMENT (tree_view->priv->vadjustment),
2067                               tree_view->priv->height - gtk_adjustment_get_page_size (tree_view->priv->vadjustment));
2068   else if (gtk_tree_row_reference_valid (tree_view->priv->top_row))
2069     pspp_sheet_view_top_row_to_dy (tree_view);
2070   else
2071     pspp_sheet_view_dy_to_top_row (tree_view);
2072
2073   if (gtk_widget_get_realized (widget))
2074     {
2075       gdk_window_move_resize (gtk_widget_get_window (widget),
2076                               allocation->x, allocation->y,
2077                               allocation->width, allocation->height);
2078       gdk_window_move_resize (tree_view->priv->header_window,
2079                               - (gint) gtk_adjustment_get_value (tree_view->priv->hadjustment),
2080                               0,
2081                               MAX (tree_view->priv->width, allocation->width),
2082                               tree_view->priv->header_height);
2083       gdk_window_move_resize (tree_view->priv->bin_window,
2084                               - (gint) gtk_adjustment_get_value (tree_view->priv->hadjustment),
2085                               TREE_VIEW_HEADER_HEIGHT (tree_view),
2086                               MAX (tree_view->priv->width, allocation->width),
2087                               allocation->height - TREE_VIEW_HEADER_HEIGHT (tree_view));
2088     }
2089
2090   if (tree_view->priv->row_count == 0)
2091     invalidate_empty_focus (tree_view);
2092
2093   if (gtk_widget_get_realized (widget))
2094     {
2095       gboolean has_expand_column = FALSE;
2096       for (tmp_list = tree_view->priv->columns; tmp_list; tmp_list = tmp_list->next)
2097         {
2098           if (pspp_sheet_view_column_get_expand (PSPP_SHEET_VIEW_COLUMN (tmp_list->data)))
2099             {
2100               has_expand_column = TRUE;
2101               break;
2102             }
2103         }
2104
2105       /* This little hack only works if we have an LTR locale, and no column has the  */
2106       if (width_changed)
2107         {
2108           if (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_LTR &&
2109               ! has_expand_column)
2110             invalidate_last_column (tree_view);
2111           else
2112             gtk_widget_queue_draw (widget);
2113         }
2114       update_childrens_allocation(tree_view);
2115     }
2116 }
2117
2118 /* Grabs the focus and unsets the PSPP_SHEET_VIEW_DRAW_KEYFOCUS flag */
2119 static void
2120 grab_focus_and_unset_draw_keyfocus (PsppSheetView *tree_view)
2121 {
2122   GtkWidget *widget = GTK_WIDGET (tree_view);
2123
2124   if (gtk_widget_get_can_focus (widget) && !gtk_widget_has_focus (widget))
2125     gtk_widget_grab_focus (widget);
2126   PSPP_SHEET_VIEW_UNSET_FLAG (tree_view, PSPP_SHEET_VIEW_DRAW_KEYFOCUS);
2127 }
2128
2129 gboolean
2130 pspp_sheet_view_node_is_selected (PsppSheetView *tree_view,
2131                                   int node)
2132 {
2133   return node >= 0 && range_tower_contains (tree_view->priv->selected, node);
2134 }
2135
2136 void
2137 pspp_sheet_view_node_select (PsppSheetView *tree_view,
2138                              int node)
2139 {
2140   range_tower_set1 (tree_view->priv->selected, node, 1);
2141 }
2142
2143 void
2144 pspp_sheet_view_node_unselect (PsppSheetView *tree_view,
2145                                int node)
2146 {
2147   range_tower_set0 (tree_view->priv->selected, node, 1);
2148 }
2149
2150 gint
2151 pspp_sheet_view_node_next (PsppSheetView *tree_view,
2152                            gint node)
2153 {
2154   return node + 1 < tree_view->priv->row_count ? node + 1 : -1;
2155 }
2156
2157 gint
2158 pspp_sheet_view_node_prev (PsppSheetView *tree_view,
2159                            gint node)
2160 {
2161   return node > 0 ? node - 1 : -1;
2162 }
2163
2164 static gboolean
2165 all_columns_selected (PsppSheetView *tree_view)
2166 {
2167   GList *list;
2168
2169   for (list = tree_view->priv->columns; list; list = list->next)
2170     {
2171       PsppSheetViewColumn *column = list->data;
2172       if (column->selectable && !column->selected)
2173         return FALSE;
2174     }
2175
2176   return TRUE;
2177 }
2178
2179 static gboolean
2180 pspp_sheet_view_row_head_clicked (PsppSheetView *tree_view,
2181                                   gint node,
2182                                   PsppSheetViewColumn *column,
2183                                   GdkEventButton *event)
2184 {
2185   PsppSheetSelection *selection;
2186   PsppSheetSelectionMode mode;
2187   GtkTreePath *path;
2188   gboolean update_anchor;
2189   gboolean handled;
2190   guint modifiers;
2191
2192   g_return_val_if_fail (tree_view != NULL, FALSE);
2193   g_return_val_if_fail (column != NULL, FALSE);
2194
2195   selection = tree_view->priv->selection;
2196   mode = pspp_sheet_selection_get_mode (selection);
2197   if (mode != PSPP_SHEET_SELECTION_RECTANGLE)
2198     return FALSE;
2199
2200   if (!column->row_head)
2201     return FALSE;
2202
2203   if (event)
2204     {
2205       modifiers = event->state & gtk_accelerator_get_default_mod_mask ();
2206       if (event->type != GDK_BUTTON_PRESS
2207           || (modifiers != GDK_CONTROL_MASK && modifiers != GDK_SHIFT_MASK))
2208         return FALSE;
2209     }
2210   else
2211     modifiers = 0;
2212
2213   path = gtk_tree_path_new_from_indices (node, -1);
2214   if (event == NULL)
2215     {
2216       pspp_sheet_selection_unselect_all (selection);
2217       pspp_sheet_selection_select_path (selection, path);
2218       pspp_sheet_selection_select_all_columns (selection);
2219       update_anchor = TRUE;
2220       handled = TRUE;
2221     }
2222   else if (event->type == GDK_BUTTON_PRESS && event->button == 3)
2223     {
2224       if (pspp_sheet_selection_count_selected_rows (selection) <= 1
2225           || !all_columns_selected (tree_view))
2226         {
2227           pspp_sheet_selection_unselect_all (selection);
2228           pspp_sheet_selection_select_path (selection, path);
2229           pspp_sheet_selection_select_all_columns (selection);
2230           update_anchor = TRUE;
2231           handled = FALSE;
2232         }
2233       else
2234         update_anchor = handled = FALSE;
2235     }
2236   else if (event->type == GDK_BUTTON_PRESS && event->button == 1
2237            && modifiers == GDK_CONTROL_MASK)
2238     {
2239       if (!all_columns_selected (tree_view))
2240         {
2241           pspp_sheet_selection_unselect_all (selection);
2242           pspp_sheet_selection_select_all_columns (selection);
2243         }
2244
2245       if (pspp_sheet_selection_path_is_selected (selection, path))
2246         pspp_sheet_selection_unselect_path (selection, path);
2247       else
2248         pspp_sheet_selection_select_path (selection, path);
2249       update_anchor = TRUE;
2250       handled = TRUE;
2251     }
2252   else if (event->type == GDK_BUTTON_PRESS && event->button == 1
2253            && modifiers == GDK_SHIFT_MASK)
2254     {
2255       GtkTreeRowReference *anchor = tree_view->priv->anchor;
2256       GtkTreePath *anchor_path;
2257
2258       if (all_columns_selected (tree_view)
2259           && gtk_tree_row_reference_valid (anchor))
2260         {
2261           update_anchor = FALSE;
2262           anchor_path = gtk_tree_row_reference_get_path (anchor);
2263         }
2264       else
2265         {
2266           update_anchor = TRUE;
2267           anchor_path = gtk_tree_path_copy (path);
2268         }
2269
2270       pspp_sheet_selection_unselect_all (selection);
2271       pspp_sheet_selection_select_range (selection, anchor_path, path);
2272       pspp_sheet_selection_select_all_columns (selection);
2273
2274       gtk_tree_path_free (anchor_path);
2275
2276       handled = TRUE;
2277     }
2278   else
2279     update_anchor = handled = FALSE;
2280
2281   if (update_anchor)
2282     {
2283       if (tree_view->priv->anchor)
2284         gtk_tree_row_reference_free (tree_view->priv->anchor);
2285       tree_view->priv->anchor =
2286         gtk_tree_row_reference_new_proxy (G_OBJECT (tree_view),
2287                                           tree_view->priv->model,
2288                                           path);
2289     }
2290
2291   gtk_tree_path_free (path);
2292   return handled;
2293 }
2294
2295 static gboolean
2296 find_click (PsppSheetView *tree_view,
2297             gint x, gint y,
2298             gint *node,
2299             PsppSheetViewColumn **column,
2300             GdkRectangle *background_area,
2301             GdkRectangle *cell_area)
2302 {
2303   gint y_offset;
2304   gboolean rtl;
2305   GList *list;
2306   gint new_y;
2307
2308   /* find the node that was clicked */
2309   new_y = TREE_WINDOW_Y_TO_RBTREE_Y(tree_view, y);
2310   if (new_y < 0)
2311     new_y = 0;
2312   y_offset = -pspp_sheet_view_find_offset (tree_view, new_y, node);
2313
2314   if (*node < 0)
2315     return FALSE;
2316
2317   background_area->y = y_offset + y;
2318   background_area->height = ROW_HEIGHT (tree_view);
2319   background_area->x = 0;
2320
2321   /* Let the column have a chance at selecting it. */
2322   rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
2323   for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns));
2324        list; list = (rtl ? list->prev : list->next))
2325     {
2326       PsppSheetViewColumn *candidate = list->data;
2327
2328       if (!candidate->visible)
2329         continue;
2330
2331       background_area->width = candidate->width;
2332       if ((background_area->x > x) ||
2333           (background_area->x + background_area->width <= x))
2334         {
2335           background_area->x += background_area->width;
2336           continue;
2337         }
2338
2339       /* we found the focus column */
2340
2341       pspp_sheet_view_adjust_cell_area (tree_view, candidate, background_area,
2342                                         TRUE, cell_area);
2343       *column = candidate;
2344       return TRUE;
2345     }
2346
2347   return FALSE;
2348 }
2349
2350 static gboolean
2351 pspp_sheet_view_button_press (GtkWidget      *widget,
2352                             GdkEventButton *event)
2353 {
2354   PsppSheetView *tree_view = PSPP_SHEET_VIEW (widget);
2355   GList *list;
2356   PsppSheetViewColumn *column = NULL;
2357   gint i;
2358   GdkRectangle background_area;
2359   GdkRectangle cell_area;
2360   gboolean rtl;
2361
2362   rtl = (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL);
2363   pspp_sheet_view_stop_editing (tree_view, FALSE);
2364
2365
2366   /* Because grab_focus can cause reentrancy, we delay grab_focus until after
2367    * we're done handling the button press.
2368    */
2369
2370   if (event->window == tree_view->priv->bin_window)
2371     {
2372       int node;
2373       GtkTreePath *path;
2374       gint dval;
2375       gint pre_val, aft_val;
2376       PsppSheetViewColumn *column = NULL;
2377       GtkCellRenderer *focus_cell = NULL;
2378       gboolean row_double_click = FALSE;
2379
2380       /* Empty tree? */
2381       if (tree_view->priv->row_count == 0)
2382         {
2383           grab_focus_and_unset_draw_keyfocus (tree_view);
2384           return TRUE;
2385         }
2386
2387       if (!find_click (tree_view, event->x, event->y, &node, &column,
2388                        &background_area, &cell_area))
2389         {
2390           grab_focus_and_unset_draw_keyfocus (tree_view);
2391           return FALSE;
2392         }
2393
2394       tree_view->priv->focus_column = column;
2395
2396       if (pspp_sheet_view_row_head_clicked (tree_view, node, column, event))
2397         return TRUE;
2398
2399       /* select */
2400       pre_val = gtk_adjustment_get_value (tree_view->priv->vadjustment);
2401
2402       path = _pspp_sheet_view_find_path (tree_view, node);
2403
2404       /* we only handle selection modifications on the first button press
2405        */
2406       if (event->type == GDK_BUTTON_PRESS)
2407         {
2408           PsppSheetSelectionMode mode = 0;
2409
2410           if ((event->state & GDK_CONTROL_MASK) == GDK_CONTROL_MASK)
2411             mode |= PSPP_SHEET_SELECT_MODE_TOGGLE;
2412           if ((event->state & GDK_SHIFT_MASK) == GDK_SHIFT_MASK)
2413             mode |= PSPP_SHEET_SELECT_MODE_EXTEND;
2414
2415           focus_cell = _pspp_sheet_view_column_get_cell_at_pos (column, event->x - background_area.x);
2416           if (focus_cell)
2417             pspp_sheet_view_column_focus_cell (column, focus_cell);
2418
2419           if (event->state & GDK_CONTROL_MASK)
2420             {
2421               pspp_sheet_view_real_set_cursor (tree_view, path, FALSE, TRUE, mode);
2422               pspp_sheet_view_real_toggle_cursor_row (tree_view);
2423             }
2424           else if (event->state & GDK_SHIFT_MASK)
2425             {
2426               pspp_sheet_view_real_set_cursor (tree_view, path, TRUE, TRUE, mode);
2427               pspp_sheet_view_real_select_cursor_row (tree_view, FALSE, mode);
2428             }
2429           else
2430             {
2431               pspp_sheet_view_real_set_cursor (tree_view, path, TRUE, TRUE, 0);
2432             }
2433
2434           if (tree_view->priv->anchor_column == NULL ||
2435               !(event->state & GDK_SHIFT_MASK))
2436             tree_view->priv->anchor_column = column;
2437           pspp_sheet_selection_unselect_all_columns (tree_view->priv->selection);
2438           pspp_sheet_selection_select_column_range (tree_view->priv->selection,
2439                                                     tree_view->priv->anchor_column,
2440                                                     column);
2441         }
2442
2443       /* the treeview may have been scrolled because of _set_cursor,
2444        * correct here
2445        */
2446
2447       aft_val = gtk_adjustment_get_value (tree_view->priv->vadjustment);
2448       dval = pre_val - aft_val;
2449
2450       cell_area.y += dval;
2451       background_area.y += dval;
2452
2453       /* Save press to possibly begin a drag
2454        */
2455       if (!tree_view->priv->in_grab &&
2456           tree_view->priv->pressed_button < 0)
2457         {
2458           tree_view->priv->pressed_button = event->button;
2459           tree_view->priv->press_start_x = event->x;
2460           tree_view->priv->press_start_y = event->y;
2461           tree_view->priv->press_start_node = node;
2462
2463           if (tree_view->priv->rubber_banding_enable
2464               && (tree_view->priv->selection->type == PSPP_SHEET_SELECTION_MULTIPLE ||
2465                   tree_view->priv->selection->type == PSPP_SHEET_SELECTION_RECTANGLE))
2466             {
2467               tree_view->priv->press_start_y += tree_view->priv->dy;
2468               tree_view->priv->rubber_band_x = event->x;
2469               tree_view->priv->rubber_band_y = event->y + tree_view->priv->dy;
2470               tree_view->priv->rubber_band_status = RUBBER_BAND_MAYBE_START;
2471
2472               if ((event->state & GDK_CONTROL_MASK) == GDK_CONTROL_MASK)
2473                 tree_view->priv->rubber_band_ctrl = TRUE;
2474               if ((event->state & GDK_SHIFT_MASK) == GDK_SHIFT_MASK)
2475                 tree_view->priv->rubber_band_shift = TRUE;
2476
2477             }
2478         }
2479
2480       /* Test if a double click happened on the same row. */
2481       if (event->button == 1 && event->type == GDK_BUTTON_PRESS)
2482         {
2483           int double_click_time, double_click_distance;
2484
2485           g_object_get (gtk_settings_get_for_screen (
2486                           gtk_widget_get_screen (widget)),
2487                         "gtk-double-click-time", &double_click_time,
2488                         "gtk-double-click-distance", &double_click_distance,
2489                         NULL);
2490
2491           /* Same conditions as _gdk_event_button_generate */
2492           if (tree_view->priv->last_button_x != -1 &&
2493               (event->time < tree_view->priv->last_button_time + double_click_time) &&
2494               (ABS (event->x - tree_view->priv->last_button_x) <= double_click_distance) &&
2495               (ABS (event->y - tree_view->priv->last_button_y) <= double_click_distance))
2496             {
2497               /* We do no longer compare paths of this row and the
2498                * row clicked previously.  We use the double click
2499                * distance to decide whether this is a valid click,
2500                * allowing the mouse to slightly move over another row.
2501                */
2502               row_double_click = TRUE;
2503
2504               tree_view->priv->last_button_time = 0;
2505               tree_view->priv->last_button_x = -1;
2506               tree_view->priv->last_button_y = -1;
2507             }
2508           else
2509             {
2510               tree_view->priv->last_button_time = event->time;
2511               tree_view->priv->last_button_x = event->x;
2512               tree_view->priv->last_button_y = event->y;
2513             }
2514         }
2515
2516       if (row_double_click)
2517         {
2518           gtk_grab_remove (widget);
2519           pspp_sheet_view_row_activated (tree_view, path, column);
2520
2521           if (tree_view->priv->pressed_button == event->button)
2522             tree_view->priv->pressed_button = -1;
2523         }
2524
2525       gtk_tree_path_free (path);
2526
2527       /* If we activated the row through a double click we don't want to grab
2528        * focus back, as moving focus to another widget is pretty common.
2529        */
2530       if (!row_double_click)
2531         grab_focus_and_unset_draw_keyfocus (tree_view);
2532
2533       return TRUE;
2534     }
2535
2536   /* We didn't click in the window.  Let's check to see if we clicked on a column resize window.
2537    */
2538   for (i = 0, list = tree_view->priv->columns; list; list = list->next, i++)
2539     {
2540       column = list->data;
2541       if (event->window == column->window &&
2542           column->resizable &&
2543           column->window)
2544         {
2545           gpointer drag_data;
2546
2547           if (GDK_GRAB_SUCCESS != gdk_device_grab (event->device,
2548                                                    column->window,
2549                                                    GDK_OWNERSHIP_NONE,
2550                                                    FALSE,
2551                                                    GDK_POINTER_MOTION_HINT_MASK |
2552                                                    GDK_BUTTON1_MOTION_MASK |
2553                                                    GDK_BUTTON_RELEASE_MASK,
2554                                                    NULL, event->time))
2555             return FALSE;
2556
2557           gtk_grab_add (widget);
2558           PSPP_SHEET_VIEW_SET_FLAG (tree_view, PSPP_SHEET_VIEW_IN_COLUMN_RESIZE);
2559           column->resized_width = column->width;
2560
2561           /* block attached dnd signal handler */
2562           drag_data = g_object_get_data (G_OBJECT (widget), "gtk-site-data");
2563           if (drag_data)
2564             g_signal_handlers_block_matched (widget,
2565                                              G_SIGNAL_MATCH_DATA,
2566                                              0, 0, NULL, NULL,
2567                                              drag_data);
2568
2569           tree_view->priv->drag_pos = i;
2570           tree_view->priv->x_drag = column->allocation.x + (rtl ? 0 : column->allocation.width);
2571
2572           if (!gtk_widget_has_focus (widget))
2573             gtk_widget_grab_focus (widget);
2574
2575           return TRUE;
2576         }
2577     }
2578   return FALSE;
2579 }
2580
2581 /* GtkWidget::button_release_event helper */
2582 static gboolean
2583 pspp_sheet_view_button_release_drag_column (GtkWidget      *widget,
2584                                           GdkEventButton *event)
2585 {
2586   PsppSheetView *tree_view;
2587   GList *l;
2588   gboolean rtl;
2589
2590   tree_view = PSPP_SHEET_VIEW (widget);
2591
2592   rtl = (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL);
2593   gdk_display_pointer_ungrab (gtk_widget_get_display (widget), GDK_CURRENT_TIME);
2594   gdk_display_keyboard_ungrab (gtk_widget_get_display (widget), GDK_CURRENT_TIME);
2595
2596   /* Move the button back */
2597   g_return_val_if_fail (tree_view->priv->drag_column->button, FALSE);
2598
2599   g_object_ref (tree_view->priv->drag_column->button);
2600   gtk_container_remove (GTK_CONTAINER (tree_view), tree_view->priv->drag_column->button);
2601   gtk_widget_set_parent_window (tree_view->priv->drag_column->button, tree_view->priv->header_window);
2602   gtk_widget_set_parent (tree_view->priv->drag_column->button, GTK_WIDGET (tree_view));
2603   g_object_unref (tree_view->priv->drag_column->button);
2604   gtk_widget_queue_resize (widget);
2605   if (tree_view->priv->drag_column->resizable)
2606     {
2607       gdk_window_raise (tree_view->priv->drag_column->window);
2608       gdk_window_show (tree_view->priv->drag_column->window);
2609     }
2610   else
2611     gdk_window_hide (tree_view->priv->drag_column->window);
2612
2613   gtk_widget_grab_focus (tree_view->priv->drag_column->button);
2614
2615   if (rtl)
2616     {
2617       if (tree_view->priv->cur_reorder &&
2618           tree_view->priv->cur_reorder->right_column != tree_view->priv->drag_column)
2619         pspp_sheet_view_move_column_after (tree_view, tree_view->priv->drag_column,
2620                                          tree_view->priv->cur_reorder->right_column);
2621     }
2622   else
2623     {
2624       if (tree_view->priv->cur_reorder &&
2625           tree_view->priv->cur_reorder->left_column != tree_view->priv->drag_column)
2626         pspp_sheet_view_move_column_after (tree_view, tree_view->priv->drag_column,
2627                                          tree_view->priv->cur_reorder->left_column);
2628     }
2629   tree_view->priv->drag_column = NULL;
2630   gdk_window_hide (tree_view->priv->drag_window);
2631
2632   for (l = tree_view->priv->column_drag_info; l != NULL; l = l->next)
2633     g_slice_free (PsppSheetViewColumnReorder, l->data);
2634   g_list_free (tree_view->priv->column_drag_info);
2635   tree_view->priv->column_drag_info = NULL;
2636   tree_view->priv->cur_reorder = NULL;
2637
2638   if (tree_view->priv->drag_highlight_window)
2639     gdk_window_hide (tree_view->priv->drag_highlight_window);
2640
2641   /* Reset our flags */
2642   tree_view->priv->drag_column_window_state = DRAG_COLUMN_WINDOW_STATE_UNSET;
2643   PSPP_SHEET_VIEW_UNSET_FLAG (tree_view, PSPP_SHEET_VIEW_IN_COLUMN_DRAG);
2644
2645   return TRUE;
2646 }
2647
2648 /* GtkWidget::button_release_event helper */
2649 static gboolean
2650 pspp_sheet_view_button_release_column_resize (GtkWidget      *widget,
2651                                             GdkEventButton *event)
2652 {
2653   PsppSheetView *tree_view;
2654   gpointer drag_data;
2655
2656   tree_view = PSPP_SHEET_VIEW (widget);
2657
2658   tree_view->priv->drag_pos = -1;
2659
2660   /* unblock attached dnd signal handler */
2661   drag_data = g_object_get_data (G_OBJECT (widget), "gtk-site-data");
2662   if (drag_data)
2663     g_signal_handlers_unblock_matched (widget,
2664                                        G_SIGNAL_MATCH_DATA,
2665                                        0, 0, NULL, NULL,
2666                                        drag_data);
2667
2668   PSPP_SHEET_VIEW_UNSET_FLAG (tree_view, PSPP_SHEET_VIEW_IN_COLUMN_RESIZE);
2669   gtk_grab_remove (widget);
2670   gdk_device_ungrab (event->device, event->time);
2671
2672   return TRUE;
2673 }
2674
2675 static gboolean
2676 pspp_sheet_view_button_release_edit (PsppSheetView *tree_view,
2677                                      GdkEventButton *event)
2678 {
2679   GtkCellEditable *cell_editable;
2680   gchar *path_string;
2681   GtkTreePath *path;
2682   gint left, right;
2683   GtkTreeIter iter;
2684   PsppSheetViewColumn *column;
2685   GdkRectangle background_area;
2686   GdkRectangle cell_area;
2687   GdkRectangle area;
2688   guint modifiers;
2689   guint flags;
2690   int node;
2691
2692   if (event->window != tree_view->priv->bin_window)
2693     return FALSE;
2694
2695   /* Ignore a released button, if that button wasn't depressed */
2696   if (tree_view->priv->pressed_button != event->button)
2697     return FALSE;
2698
2699   if (!find_click (tree_view, event->x, event->y, &node, &column, &background_area,
2700                    &cell_area))
2701     return FALSE;
2702
2703   /* decide if we edit */
2704   path = _pspp_sheet_view_find_path (tree_view, node);
2705   modifiers = event->state & gtk_accelerator_get_default_mod_mask ();
2706   if (event->button != 1 || modifiers)
2707     return FALSE;
2708
2709   gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
2710   pspp_sheet_view_column_cell_set_cell_data (column,
2711                                              tree_view->priv->model,
2712                                              &iter);
2713
2714   if (!pspp_sheet_view_column_get_quick_edit (column)
2715       && _pspp_sheet_view_column_has_editable_cell (column))
2716     return FALSE;
2717
2718   flags = 0;                    /* FIXME: get the right flags */
2719   path_string = gtk_tree_path_to_string (path);
2720
2721   if (!_pspp_sheet_view_column_cell_event (column,
2722                                            &cell_editable,
2723                                            (GdkEvent *)event,
2724                                            path_string,
2725                                            &background_area,
2726                                            &cell_area, flags))
2727     return FALSE;
2728
2729   if (cell_editable == NULL)
2730     return FALSE;
2731
2732   pspp_sheet_view_real_set_cursor (tree_view, path,
2733                                    TRUE, TRUE, 0); /* XXX mode? */
2734   gtk_widget_queue_draw (GTK_WIDGET (tree_view));
2735
2736   area = cell_area;
2737   _pspp_sheet_view_column_get_neighbor_sizes (
2738     column, _pspp_sheet_view_column_get_edited_cell (column), &left, &right);
2739
2740   area.x += left;
2741   area.width -= right + left;
2742
2743   pspp_sheet_view_real_start_editing (tree_view,
2744                                       column,
2745                                       path,
2746                                       cell_editable,
2747                                       &area,
2748                                       (GdkEvent *)event,
2749                                       flags);
2750   g_free (path_string);
2751   gtk_tree_path_free (path);
2752   return TRUE;
2753 }
2754
2755 static gboolean
2756 pspp_sheet_view_button_release (GtkWidget      *widget,
2757                               GdkEventButton *event)
2758 {
2759   PsppSheetView *tree_view = PSPP_SHEET_VIEW (widget);
2760
2761   pspp_sheet_view_stop_editing (tree_view, FALSE);
2762   if (tree_view->priv->rubber_band_status != RUBBER_BAND_ACTIVE
2763       && pspp_sheet_view_button_release_edit (tree_view, event))
2764     {
2765       if (tree_view->priv->pressed_button == event->button)
2766         tree_view->priv->pressed_button = -1;
2767
2768       tree_view->priv->rubber_band_status = RUBBER_BAND_OFF;
2769       return TRUE;
2770     }
2771
2772   if (PSPP_SHEET_VIEW_FLAG_SET (tree_view, PSPP_SHEET_VIEW_IN_COLUMN_DRAG))
2773     return pspp_sheet_view_button_release_drag_column (widget, event);
2774
2775   if (tree_view->priv->rubber_band_status)
2776     pspp_sheet_view_stop_rubber_band (tree_view);
2777
2778   if (tree_view->priv->pressed_button == event->button)
2779     tree_view->priv->pressed_button = -1;
2780
2781   if (PSPP_SHEET_VIEW_FLAG_SET (tree_view, PSPP_SHEET_VIEW_IN_COLUMN_RESIZE))
2782     return pspp_sheet_view_button_release_column_resize (widget, event);
2783
2784   return FALSE;
2785 }
2786
2787 static gboolean
2788 pspp_sheet_view_grab_broken (GtkWidget          *widget,
2789                            GdkEventGrabBroken *event)
2790 {
2791   PsppSheetView *tree_view = PSPP_SHEET_VIEW (widget);
2792
2793   if (PSPP_SHEET_VIEW_FLAG_SET (tree_view, PSPP_SHEET_VIEW_IN_COLUMN_DRAG))
2794     pspp_sheet_view_button_release_drag_column (widget, (GdkEventButton *)event);
2795
2796   if (PSPP_SHEET_VIEW_FLAG_SET (tree_view, PSPP_SHEET_VIEW_IN_COLUMN_RESIZE))
2797     pspp_sheet_view_button_release_column_resize (widget, (GdkEventButton *)event);
2798
2799   return TRUE;
2800 }
2801
2802 /* GtkWidget::motion_event function set.
2803  */
2804
2805 static void
2806 do_prelight (PsppSheetView *tree_view,
2807              int node,
2808              /* these are in bin_window coords */
2809              gint         x,
2810              gint         y)
2811 {
2812   int prev_node = tree_view->priv->prelight_node;
2813
2814   if (prev_node != node)
2815     {
2816       tree_view->priv->prelight_node = node;
2817
2818       if (prev_node >= 0)
2819         _pspp_sheet_view_queue_draw_node (tree_view, prev_node, NULL);
2820
2821       if (node >= 0)
2822         _pspp_sheet_view_queue_draw_node (tree_view, node, NULL);
2823     }
2824 }
2825
2826
2827 static void
2828 prelight_or_select (PsppSheetView *tree_view,
2829                     int node,
2830                     /* these are in bin_window coords */
2831                     gint         x,
2832                     gint         y)
2833 {
2834   PsppSheetSelectionMode mode = pspp_sheet_selection_get_mode (tree_view->priv->selection);
2835
2836   if (tree_view->priv->hover_selection &&
2837       (mode == PSPP_SHEET_SELECTION_SINGLE || mode == PSPP_SHEET_SELECTION_BROWSE) &&
2838       !(tree_view->priv->edited_column &&
2839         tree_view->priv->edited_column->editable_widget))
2840     {
2841       if (node >= 0)
2842         {
2843           if (!pspp_sheet_view_node_is_selected (tree_view, node))
2844             {
2845               GtkTreePath *path;
2846
2847               path = _pspp_sheet_view_find_path (tree_view, node);
2848               pspp_sheet_selection_select_path (tree_view->priv->selection, path);
2849               if (pspp_sheet_view_node_is_selected (tree_view, node))
2850                 {
2851                   PSPP_SHEET_VIEW_UNSET_FLAG (tree_view, PSPP_SHEET_VIEW_DRAW_KEYFOCUS);
2852                   pspp_sheet_view_real_set_cursor (tree_view, path, FALSE, FALSE, 0); /* XXX mode? */
2853                 }
2854               gtk_tree_path_free (path);
2855             }
2856         }
2857
2858       else if (mode == PSPP_SHEET_SELECTION_SINGLE)
2859         pspp_sheet_selection_unselect_all (tree_view->priv->selection);
2860     }
2861
2862     do_prelight (tree_view, node, x, y);
2863 }
2864
2865 static void
2866 ensure_unprelighted (PsppSheetView *tree_view)
2867 {
2868   do_prelight (tree_view,
2869                -1,
2870                -1000, -1000); /* coords not possibly over an arrow */
2871
2872   g_assert (tree_view->priv->prelight_node < 0);
2873 }
2874
2875 static void
2876 update_prelight (PsppSheetView *tree_view,
2877                  gint         x,
2878                  gint         y)
2879 {
2880   int new_y;
2881   int node;
2882
2883   if (tree_view->priv->row_count == 0)
2884     return;
2885
2886   if (x == -10000)
2887     {
2888       ensure_unprelighted (tree_view);
2889       return;
2890     }
2891
2892   new_y = TREE_WINDOW_Y_TO_RBTREE_Y (tree_view, y);
2893   if (new_y < 0)
2894     new_y = 0;
2895
2896   pspp_sheet_view_find_offset (tree_view, new_y, &node);
2897
2898   if (node >= 0)
2899     prelight_or_select (tree_view, node, x, y);
2900 }
2901
2902
2903
2904
2905 /* Our motion arrow is either a box (in the case of the original spot)
2906  * or an arrow.  It is expander_size wide.
2907  */
2908 /*
2909  * 11111111111111
2910  * 01111111111110
2911  * 00111111111100
2912  * 00011111111000
2913  * 00001111110000
2914  * 00000111100000
2915  * 00000111100000
2916  * 00000111100000
2917  * ~ ~ ~ ~ ~ ~ ~
2918  * 00000111100000
2919  * 00000111100000
2920  * 00000111100000
2921  * 00001111110000
2922  * 00011111111000
2923  * 00111111111100
2924  * 01111111111110
2925  * 11111111111111
2926  */
2927
2928 static void
2929 pspp_sheet_view_motion_draw_column_motion_arrow (PsppSheetView *tree_view)
2930 {
2931 }
2932
2933 static gboolean
2934 pspp_sheet_view_motion_resize_column (GtkWidget      *widget,
2935                                     GdkEventMotion *event)
2936 {
2937   gint x;
2938   gint new_width;
2939   PsppSheetViewColumn *column;
2940   PsppSheetView *tree_view = PSPP_SHEET_VIEW (widget);
2941
2942   column = pspp_sheet_view_get_column (tree_view, tree_view->priv->drag_pos);
2943
2944   if (event->is_hint || event->window != gtk_widget_get_window (widget))
2945     gtk_widget_get_pointer (widget, &x, NULL);
2946   else
2947     x = event->x;
2948
2949   if (tree_view->priv->hadjustment)
2950     x += gtk_adjustment_get_value (tree_view->priv->hadjustment);
2951
2952   new_width = pspp_sheet_view_new_column_width (tree_view,
2953                                               tree_view->priv->drag_pos, &x);
2954   if (x != tree_view->priv->x_drag &&
2955       (new_width != column->fixed_width))
2956     {
2957       column->use_resized_width = TRUE;
2958       column->resized_width = new_width;
2959 #if 0
2960       if (column->expand)
2961         column->resized_width -= tree_view->priv->last_extra_space_per_column;
2962 #endif
2963       gtk_widget_queue_resize (widget);
2964     }
2965
2966   return FALSE;
2967 }
2968
2969
2970 static void
2971 pspp_sheet_view_update_current_reorder (PsppSheetView *tree_view)
2972 {
2973   PsppSheetViewColumnReorder *reorder = NULL;
2974   GList *list;
2975   gint mouse_x;
2976
2977   gdk_window_get_pointer (tree_view->priv->header_window, &mouse_x, NULL, NULL);
2978   for (list = tree_view->priv->column_drag_info; list; list = list->next)
2979     {
2980       reorder = (PsppSheetViewColumnReorder *) list->data;
2981       if (mouse_x >= reorder->left_align && mouse_x < reorder->right_align)
2982         break;
2983       reorder = NULL;
2984     }
2985
2986   /*  if (reorder && reorder == tree_view->priv->cur_reorder)
2987       return;*/
2988
2989   tree_view->priv->cur_reorder = reorder;
2990   pspp_sheet_view_motion_draw_column_motion_arrow (tree_view);
2991 }
2992
2993 static void
2994 pspp_sheet_view_vertical_autoscroll (PsppSheetView *tree_view)
2995 {
2996   GdkRectangle visible_rect;
2997   gint y;
2998   gint offset;
2999   gfloat value;
3000
3001   gdk_window_get_pointer (tree_view->priv->bin_window, NULL, &y, NULL);
3002   y += tree_view->priv->dy;
3003
3004   pspp_sheet_view_get_visible_rect (tree_view, &visible_rect);
3005
3006   /* see if we are near the edge. */
3007   offset = y - (visible_rect.y + 2 * SCROLL_EDGE_SIZE);
3008   if (offset > 0)
3009     {
3010       offset = y - (visible_rect.y + visible_rect.height - 2 * SCROLL_EDGE_SIZE);
3011       if (offset < 0)
3012         return;
3013     }
3014
3015   value = CLAMP (gtk_adjustment_get_value (tree_view->priv->vadjustment) + offset, 0.0,
3016                  gtk_adjustment_get_upper (tree_view->priv->vadjustment) - gtk_adjustment_get_page_size (tree_view->priv->vadjustment));
3017   gtk_adjustment_set_value (tree_view->priv->vadjustment, value);
3018 }
3019
3020 static gboolean
3021 pspp_sheet_view_horizontal_autoscroll (PsppSheetView *tree_view)
3022 {
3023   GdkRectangle visible_rect;
3024   gint x;
3025   gint offset;
3026   gfloat value;
3027
3028   gdk_window_get_pointer (tree_view->priv->bin_window, &x, NULL, NULL);
3029
3030   pspp_sheet_view_get_visible_rect (tree_view, &visible_rect);
3031
3032   /* See if we are near the edge. */
3033   offset = x - (visible_rect.x + SCROLL_EDGE_SIZE);
3034   if (offset > 0)
3035     {
3036       offset = x - (visible_rect.x + visible_rect.width - SCROLL_EDGE_SIZE);
3037       if (offset < 0)
3038         return TRUE;
3039     }
3040   offset = offset/3;
3041
3042   value = CLAMP (gtk_adjustment_get_value (tree_view->priv->hadjustment) + offset,
3043                  0.0, gtk_adjustment_get_upper (tree_view->priv->hadjustment) - gtk_adjustment_get_page_size (tree_view->priv->hadjustment));
3044   gtk_adjustment_set_value (tree_view->priv->hadjustment, value);
3045
3046   return TRUE;
3047
3048 }
3049
3050 static gboolean
3051 pspp_sheet_view_motion_drag_column (GtkWidget      *widget,
3052                                   GdkEventMotion *event)
3053 {
3054   PsppSheetView *tree_view = (PsppSheetView *) widget;
3055   PsppSheetViewColumn *column = tree_view->priv->drag_column;
3056   gint x, y;
3057   GtkAllocation allocation;
3058
3059   /* Sanity Check */
3060   if ((column == NULL) ||
3061       (event->window != tree_view->priv->drag_window))
3062     return FALSE;
3063
3064   /* Handle moving the header */
3065   gdk_window_get_position (tree_view->priv->drag_window, &x, &y);
3066   gtk_widget_get_allocation (GTK_WIDGET (tree_view), &allocation);
3067   x = CLAMP (x + (gint)event->x - column->drag_x, 0,
3068              MAX (tree_view->priv->width, allocation.width) - column->allocation.width);
3069   gdk_window_move (tree_view->priv->drag_window, x, y);
3070
3071   /* autoscroll, if needed */
3072   pspp_sheet_view_horizontal_autoscroll (tree_view);
3073   /* Update the current reorder position and arrow; */
3074   pspp_sheet_view_update_current_reorder (tree_view);
3075
3076   return TRUE;
3077 }
3078
3079 static void
3080 pspp_sheet_view_stop_rubber_band (PsppSheetView *tree_view)
3081 {
3082   remove_scroll_timeout (tree_view);
3083   gtk_grab_remove (GTK_WIDGET (tree_view));
3084
3085   if (tree_view->priv->rubber_band_status == RUBBER_BAND_ACTIVE)
3086     {
3087       GtkTreePath *tmp_path;
3088
3089       gtk_widget_queue_draw (GTK_WIDGET (tree_view));
3090
3091       /* The anchor path should be set to the start path */
3092       tmp_path = _pspp_sheet_view_find_path (tree_view,
3093                                            tree_view->priv->rubber_band_start_node);
3094
3095       if (tree_view->priv->anchor)
3096         gtk_tree_row_reference_free (tree_view->priv->anchor);
3097
3098       tree_view->priv->anchor =
3099         gtk_tree_row_reference_new_proxy (G_OBJECT (tree_view),
3100                                           tree_view->priv->model,
3101                                           tmp_path);
3102
3103       gtk_tree_path_free (tmp_path);
3104
3105       /* ... and the cursor to the end path */
3106       tmp_path = _pspp_sheet_view_find_path (tree_view,
3107                                            tree_view->priv->rubber_band_end_node);
3108       pspp_sheet_view_real_set_cursor (PSPP_SHEET_VIEW (tree_view), tmp_path, FALSE, FALSE, 0); /* XXX mode? */
3109       gtk_tree_path_free (tmp_path);
3110
3111       _pspp_sheet_selection_emit_changed (tree_view->priv->selection);
3112     }
3113
3114   /* Clear status variables */
3115   tree_view->priv->rubber_band_status = RUBBER_BAND_OFF;
3116   tree_view->priv->rubber_band_shift = 0;
3117   tree_view->priv->rubber_band_ctrl = 0;
3118
3119   tree_view->priv->rubber_band_start_node = -1;
3120   tree_view->priv->rubber_band_end_node = -1;
3121 }
3122
3123 static void
3124 pspp_sheet_view_update_rubber_band_selection_range (PsppSheetView *tree_view,
3125                                                  int start_node,
3126                                                  int end_node,
3127                                                  gboolean     select,
3128                                                  gboolean     skip_start,
3129                                                  gboolean     skip_end)
3130 {
3131   if (start_node == end_node)
3132     return;
3133
3134   /* We skip the first node and jump inside the loop */
3135   if (skip_start)
3136     goto skip_first;
3137
3138   do
3139     {
3140       /* Small optimization by assuming insensitive nodes are never
3141        * selected.
3142        */
3143       if (select)
3144         {
3145           if (tree_view->priv->rubber_band_shift)
3146             pspp_sheet_view_node_select (tree_view, start_node);
3147           else if (tree_view->priv->rubber_band_ctrl)
3148             {
3149               /* Toggle the selection state */
3150               if (pspp_sheet_view_node_is_selected (tree_view, start_node))
3151                 pspp_sheet_view_node_unselect (tree_view, start_node);
3152               else
3153                 pspp_sheet_view_node_select (tree_view, start_node);
3154             }
3155           else
3156             pspp_sheet_view_node_select (tree_view, start_node);
3157         }
3158       else
3159         {
3160           /* Mirror the above */
3161           if (tree_view->priv->rubber_band_shift)
3162                 pspp_sheet_view_node_unselect (tree_view, start_node);
3163           else if (tree_view->priv->rubber_band_ctrl)
3164             {
3165               /* Toggle the selection state */
3166               if (pspp_sheet_view_node_is_selected (tree_view, start_node))
3167                 pspp_sheet_view_node_unselect (tree_view, start_node);
3168               else
3169                 pspp_sheet_view_node_select (tree_view, start_node);
3170             }
3171           else
3172             pspp_sheet_view_node_unselect (tree_view, start_node);
3173         }
3174
3175       _pspp_sheet_view_queue_draw_node (tree_view, start_node, NULL);
3176
3177       if (start_node == end_node)
3178         break;
3179
3180 skip_first:
3181
3182       start_node = pspp_sheet_view_node_next (tree_view, start_node);
3183
3184       if (start_node < 0)
3185         /* Ran out of tree */
3186         break;
3187
3188       if (skip_end && start_node == end_node)
3189         break;
3190     }
3191   while (TRUE);
3192 }
3193
3194 static gint
3195 pspp_sheet_view_node_find_offset (PsppSheetView *tree_view,
3196                                   int node)
3197 {
3198   return node * tree_view->priv->fixed_height;
3199 }
3200
3201 static gint
3202 pspp_sheet_view_find_offset (PsppSheetView *tree_view,
3203                              gint height,
3204                              int *new_node)
3205 {
3206   int fixed_height = tree_view->priv->fixed_height;
3207   if (fixed_height <= 0
3208       || height < 0
3209       || height >= tree_view->priv->row_count * fixed_height)
3210     {
3211       *new_node = -1;
3212       return 0;
3213     }
3214   else
3215     {
3216       *new_node = height / fixed_height;
3217       return height % fixed_height;
3218     }
3219 }
3220
3221 static void
3222 pspp_sheet_view_update_rubber_band_selection (PsppSheetView *tree_view)
3223 {
3224   int start_node;
3225   int end_node;
3226
3227   pspp_sheet_view_find_offset (tree_view, MIN (tree_view->priv->press_start_y, tree_view->priv->rubber_band_y), &start_node);
3228   pspp_sheet_view_find_offset (tree_view, MAX (tree_view->priv->press_start_y, tree_view->priv->rubber_band_y), &end_node);
3229
3230   /* Handle the start area first */
3231   if (tree_view->priv->rubber_band_start_node < 0)
3232     {
3233       pspp_sheet_view_update_rubber_band_selection_range (tree_view,
3234                                                        start_node,
3235                                                        end_node,
3236                                                        TRUE,
3237                                                        FALSE,
3238                                                        FALSE);
3239     }
3240   else if (start_node < tree_view->priv->rubber_band_start_node)
3241     {
3242       /* New node is above the old one; selection became bigger */
3243       pspp_sheet_view_update_rubber_band_selection_range (tree_view,
3244                                                        start_node,
3245                                                        tree_view->priv->rubber_band_start_node,
3246                                                        TRUE,
3247                                                        FALSE,
3248                                                        TRUE);
3249     }
3250   else if (start_node > tree_view->priv->rubber_band_start_node)
3251     {
3252       /* New node is below the old one; selection became smaller */
3253       pspp_sheet_view_update_rubber_band_selection_range (tree_view,
3254                                                        tree_view->priv->rubber_band_start_node,
3255                                                        start_node,
3256                                                        FALSE,
3257                                                        FALSE,
3258                                                        TRUE);
3259     }
3260
3261   tree_view->priv->rubber_band_start_node = start_node;
3262
3263   /* Next, handle the end area */
3264   if (tree_view->priv->rubber_band_end_node < 0)
3265     {
3266       /* In the event this happens, start_node was also -1; this case is
3267        * handled above.
3268        */
3269     }
3270   else if (end_node < 0)
3271     {
3272       /* Find the last node in the tree */
3273       pspp_sheet_view_find_offset (tree_view, tree_view->priv->height - 1,
3274                                &end_node);
3275
3276       /* Selection reached end of the tree */
3277       pspp_sheet_view_update_rubber_band_selection_range (tree_view,
3278                                                        tree_view->priv->rubber_band_end_node,
3279                                                        end_node,
3280                                                        TRUE,
3281                                                        TRUE,
3282                                                        FALSE);
3283     }
3284   else if (end_node > tree_view->priv->rubber_band_end_node)
3285     {
3286       /* New node is below the old one; selection became bigger */
3287       pspp_sheet_view_update_rubber_band_selection_range (tree_view,
3288                                                        tree_view->priv->rubber_band_end_node,
3289                                                        end_node,
3290                                                        TRUE,
3291                                                        TRUE,
3292                                                        FALSE);
3293     }
3294   else if (end_node < tree_view->priv->rubber_band_end_node)
3295     {
3296       /* New node is above the old one; selection became smaller */
3297       pspp_sheet_view_update_rubber_band_selection_range (tree_view,
3298                                                        end_node,
3299                                                        tree_view->priv->rubber_band_end_node,
3300                                                        FALSE,
3301                                                        TRUE,
3302                                                        FALSE);
3303     }
3304
3305   tree_view->priv->rubber_band_end_node = end_node;
3306 }
3307
3308 #define GDK_RECTANGLE_PTR(X) ((GdkRectangle *)(X))
3309
3310 static void
3311 pspp_sheet_view_update_rubber_band (PsppSheetView *tree_view)
3312 {
3313   gint x, y;
3314   cairo_rectangle_int_t old_area;
3315   cairo_rectangle_int_t new_area;
3316   cairo_rectangle_int_t common;
3317   cairo_region_t *invalid_region;
3318   PsppSheetViewColumn *column;
3319
3320   old_area.x = MIN (tree_view->priv->press_start_x, tree_view->priv->rubber_band_x);
3321   old_area.y = MIN (tree_view->priv->press_start_y, tree_view->priv->rubber_band_y) - tree_view->priv->dy;
3322   old_area.width = ABS (tree_view->priv->rubber_band_x - tree_view->priv->press_start_x) + 1;
3323   old_area.height = ABS (tree_view->priv->rubber_band_y - tree_view->priv->press_start_y) + 1;
3324
3325   gdk_window_get_pointer (tree_view->priv->bin_window, &x, &y, NULL);
3326
3327   x = MAX (x, 0);
3328   y = MAX (y, 0) + tree_view->priv->dy;
3329
3330   new_area.x = MIN (tree_view->priv->press_start_x, x);
3331   new_area.y = MIN (tree_view->priv->press_start_y, y) - tree_view->priv->dy;
3332   new_area.width = ABS (x - tree_view->priv->press_start_x) + 1;
3333   new_area.height = ABS (y - tree_view->priv->press_start_y) + 1;
3334
3335   invalid_region = cairo_region_create_rectangle (&old_area);
3336   cairo_region_union_rectangle (invalid_region, &new_area);
3337
3338   gdk_rectangle_intersect (GDK_RECTANGLE_PTR (&old_area),
3339                            GDK_RECTANGLE_PTR (&new_area), GDK_RECTANGLE_PTR (&common));
3340   if (common.width > 2 && common.height > 2)
3341     {
3342       cairo_region_t *common_region;
3343
3344       /* make sure the border is invalidated */
3345       common.x += 1;
3346       common.y += 1;
3347       common.width -= 2;
3348       common.height -= 2;
3349
3350       common_region = cairo_region_create_rectangle (&common);
3351
3352       cairo_region_subtract (invalid_region, common_region);
3353       cairo_region_destroy (common_region);
3354     }
3355
3356 #if GTK_MAJOR_VERSION == 3
3357   gdk_window_invalidate_region (tree_view->priv->bin_window, invalid_region, TRUE);
3358 #else
3359   {
3360     cairo_rectangle_int_t extents;
3361     GdkRegion *ereg;
3362     cairo_region_get_extents (invalid_region, &extents);
3363     ereg = gdk_region_rectangle (GDK_RECTANGLE_PTR (&extents));
3364     gdk_window_invalidate_region (tree_view->priv->bin_window, ereg, TRUE);
3365     gdk_region_destroy (ereg);
3366   }
3367 #endif
3368
3369   cairo_region_destroy (invalid_region);
3370
3371   tree_view->priv->rubber_band_x = x;
3372   tree_view->priv->rubber_band_y = y;
3373   pspp_sheet_view_get_path_at_pos (tree_view, x, y, NULL, &column, NULL, NULL);
3374
3375   pspp_sheet_selection_unselect_all_columns (tree_view->priv->selection);
3376   pspp_sheet_selection_select_column_range (tree_view->priv->selection,
3377                                             tree_view->priv->anchor_column,
3378                                             column);
3379
3380   gtk_widget_queue_draw (GTK_WIDGET (tree_view));
3381
3382   pspp_sheet_view_update_rubber_band_selection (tree_view);
3383 }
3384
3385
3386
3387 static gboolean
3388 pspp_sheet_view_motion_bin_window (GtkWidget      *widget,
3389                                  GdkEventMotion *event)
3390 {
3391   PsppSheetView *tree_view;
3392   int node;
3393   gint new_y;
3394
3395   tree_view = (PsppSheetView *) widget;
3396
3397   if (tree_view->priv->row_count == 0)
3398     return FALSE;
3399
3400   if (tree_view->priv->rubber_band_status == RUBBER_BAND_MAYBE_START)
3401     {
3402       GdkRectangle background_area, cell_area;
3403       PsppSheetViewColumn *column;
3404
3405       if (find_click (tree_view, event->x, event->y, &node, &column,
3406                       &background_area, &cell_area)
3407           && tree_view->priv->focus_column == column
3408           && tree_view->priv->press_start_node == node)
3409         return FALSE;
3410
3411       gtk_grab_add (GTK_WIDGET (tree_view));
3412       pspp_sheet_view_update_rubber_band (tree_view);
3413
3414       tree_view->priv->rubber_band_status = RUBBER_BAND_ACTIVE;
3415     }
3416   else if (tree_view->priv->rubber_band_status == RUBBER_BAND_ACTIVE)
3417     {
3418       pspp_sheet_view_update_rubber_band (tree_view);
3419
3420       add_scroll_timeout (tree_view);
3421     }
3422
3423   /* only check for an initiated drag when a button is pressed */
3424   if (tree_view->priv->pressed_button >= 0
3425       && !tree_view->priv->rubber_band_status)
3426     pspp_sheet_view_maybe_begin_dragging_row (tree_view, event);
3427
3428   new_y = TREE_WINDOW_Y_TO_RBTREE_Y(tree_view, event->y);
3429   if (new_y < 0)
3430     new_y = 0;
3431
3432   pspp_sheet_view_find_offset (tree_view, new_y, &node);
3433
3434   tree_view->priv->event_last_x = event->x;
3435   tree_view->priv->event_last_y = event->y;
3436
3437   prelight_or_select (tree_view, node, event->x, event->y);
3438
3439   return TRUE;
3440 }
3441
3442 static gboolean
3443 pspp_sheet_view_motion (GtkWidget      *widget,
3444                       GdkEventMotion *event)
3445 {
3446   PsppSheetView *tree_view;
3447
3448   tree_view = (PsppSheetView *) widget;
3449
3450   /* Resizing a column */
3451   if (PSPP_SHEET_VIEW_FLAG_SET (tree_view, PSPP_SHEET_VIEW_IN_COLUMN_RESIZE))
3452     return pspp_sheet_view_motion_resize_column (widget, event);
3453
3454   /* Drag column */
3455   if (PSPP_SHEET_VIEW_FLAG_SET (tree_view, PSPP_SHEET_VIEW_IN_COLUMN_DRAG))
3456     return pspp_sheet_view_motion_drag_column (widget, event);
3457
3458   /* Sanity check it */
3459   if (event->window == tree_view->priv->bin_window)
3460     return pspp_sheet_view_motion_bin_window (widget, event);
3461
3462   return FALSE;
3463 }
3464
3465 /* Invalidate the focus rectangle near the edge of the bin_window; used when
3466  * the tree is empty.
3467  */
3468 static void
3469 invalidate_empty_focus (PsppSheetView *tree_view)
3470 {
3471   GdkRectangle area;
3472
3473   if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
3474     return;
3475
3476   area.x = 0;
3477   area.y = 0;
3478   area.width = gdk_window_get_width (tree_view->priv->bin_window);
3479   area.height = gdk_window_get_height (tree_view->priv->bin_window);
3480   gdk_window_invalidate_rect (tree_view->priv->bin_window, &area, FALSE);
3481 }
3482
3483 /* Draws a focus rectangle near the edge of the bin_window; used when the tree
3484  * is empty.
3485  */
3486 static void
3487 draw_empty_focus (PsppSheetView *tree_view)
3488 {
3489   GtkWidget *widget = GTK_WIDGET (tree_view);
3490   gint w, h;
3491   cairo_t *cr = gdk_cairo_create (tree_view->priv->bin_window);
3492
3493   if (!gtk_widget_has_focus (widget))
3494     return;
3495
3496   w = gdk_window_get_width (tree_view->priv->bin_window);
3497   h = gdk_window_get_height (tree_view->priv->bin_window);
3498
3499   w -= 2;
3500   h -= 2;
3501
3502   if (w > 0 && h > 0)
3503     gtk_paint_focus (gtk_widget_get_style (widget),
3504                      cr,
3505                      gtk_widget_get_state (widget),
3506                      widget,
3507                      NULL,
3508                      1, 1, w, h);
3509   cairo_destroy (cr);
3510 }
3511
3512 static void
3513 pspp_sheet_view_draw_vertical_grid_lines (PsppSheetView    *tree_view,
3514                                           cairo_t *cr,
3515                                           gint n_visible_columns,
3516                                           gint min_y,
3517                                           gint max_y)
3518 {
3519   GList *list = tree_view->priv->columns;
3520   gint x = 0;
3521
3522   if (tree_view->priv->grid_lines != PSPP_SHEET_VIEW_GRID_LINES_VERTICAL
3523       && tree_view->priv->grid_lines != PSPP_SHEET_VIEW_GRID_LINES_BOTH)
3524     return;
3525
3526   /* Only draw the lines for visible rows and columns */
3527   gboolean rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
3528
3529   for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns));
3530        list;
3531        list = (rtl ? list->prev : list->next))
3532     {
3533       PsppSheetViewColumn *column = list->data;
3534
3535       if (! column->visible)
3536         continue;
3537
3538       if (!rtl)
3539         x += column->width;
3540
3541       cairo_set_line_width (cr, 1.0);
3542       cairo_set_line_cap (cr, CAIRO_LINE_CAP_SQUARE);
3543       cairo_move_to (cr, x + 0.5, min_y);
3544       cairo_line_to (cr, x + 0.5, max_y - min_y - 0.5);
3545       cairo_stroke (cr);
3546
3547       if (rtl)
3548         x += column->width;
3549     }
3550 }
3551
3552 /* Warning: Very scary function.
3553  * Modify at your own risk
3554  *
3555  * KEEP IN SYNC WITH pspp_sheet_view_create_row_drag_icon()!
3556  * FIXME: It's not...
3557  */
3558 static void
3559 pspp_sheet_view_draw_bin (GtkWidget      *widget,
3560                           cairo_t *cr)
3561 {
3562   PsppSheetView *tree_view = PSPP_SHEET_VIEW (widget);
3563   GtkTreePath *path;
3564   GList *list;
3565   int node;
3566   int cursor = -1;
3567   int drag_highlight = -1;
3568   GtkTreeIter iter;
3569   gint new_y;
3570   gint y_offset, cell_offset;
3571   gint max_height;
3572   GdkRectangle background_area;
3573   GdkRectangle cell_area;
3574   guint flags;
3575   gint bin_window_width;
3576   gint bin_window_height;
3577   GtkTreePath *cursor_path;
3578   GtkTreePath *drag_dest_path;
3579   GList *first_column, *last_column;
3580   gint vertical_separator;
3581   gint horizontal_separator;
3582   gint focus_line_width;
3583   gboolean allow_rules;
3584   gboolean rtl;
3585   gint n_visible_columns;
3586   gint grid_line_width;
3587   gboolean row_ending_details;
3588   gboolean draw_vgrid_lines, draw_hgrid_lines;
3589   gint min_y, max_y;
3590   GtkStyleContext *context;
3591   context = gtk_widget_get_style_context (widget);
3592
3593   GdkRectangle Zarea;
3594   GtkAllocation allocation;
3595   gtk_widget_get_allocation (widget, &allocation);
3596
3597   GdkRectangle exposed_rect;
3598   gdk_cairo_get_clip_rectangle (cr, &exposed_rect);
3599
3600   Zarea.x =      0;
3601   Zarea.y =      0;
3602   Zarea.height = allocation.height;
3603
3604   rtl = (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL);
3605
3606   gtk_widget_style_get (widget,
3607                         "horizontal-separator", &horizontal_separator,
3608                         "vertical-separator", &vertical_separator,
3609                         "allow-rules", &allow_rules,
3610                         "focus-line-width", &focus_line_width,
3611                         "row-ending-details", &row_ending_details,
3612                         NULL);
3613
3614   if (tree_view->priv->row_count == 0)
3615     {
3616       draw_empty_focus (tree_view);
3617       return;
3618     }
3619
3620   validate_visible_area (tree_view);
3621
3622   new_y = TREE_WINDOW_Y_TO_RBTREE_Y (tree_view, Zarea.y);
3623
3624   if (new_y < 0)
3625     new_y = 0;
3626   y_offset = -pspp_sheet_view_find_offset (tree_view, new_y, &node);
3627   bin_window_width =
3628     gdk_window_get_width (tree_view->priv->bin_window);
3629
3630   bin_window_height =
3631     gdk_window_get_height (tree_view->priv->bin_window);
3632
3633
3634   if (tree_view->priv->height < bin_window_height)
3635     {
3636       gtk_paint_flat_box (gtk_widget_get_style (widget),
3637                           cr,
3638                           gtk_widget_get_state (widget),
3639                           GTK_SHADOW_NONE,
3640                           widget,
3641                           "cell_even",
3642                           0, tree_view->priv->height,
3643                           bin_window_width,
3644                           bin_window_height - tree_view->priv->height);
3645     }
3646
3647   if (node < 0)
3648     return;
3649
3650   /* find the path for the node */
3651   path = _pspp_sheet_view_find_path ((PsppSheetView *)widget, node);
3652   gtk_tree_model_get_iter (tree_view->priv->model,
3653                            &iter,
3654                            path);
3655   gtk_tree_path_free (path);
3656
3657   cursor_path = NULL;
3658   drag_dest_path = NULL;
3659
3660   if (tree_view->priv->cursor)
3661     cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
3662
3663   if (cursor_path)
3664     _pspp_sheet_view_find_node (tree_view, cursor_path, &cursor);
3665
3666   if (tree_view->priv->drag_dest_row)
3667     drag_dest_path = gtk_tree_row_reference_get_path (tree_view->priv->drag_dest_row);
3668
3669   if (drag_dest_path)
3670     _pspp_sheet_view_find_node (tree_view, drag_dest_path,
3671                                 &drag_highlight);
3672
3673   draw_vgrid_lines =
3674     tree_view->priv->grid_lines == PSPP_SHEET_VIEW_GRID_LINES_VERTICAL
3675     || tree_view->priv->grid_lines == PSPP_SHEET_VIEW_GRID_LINES_BOTH;
3676   draw_hgrid_lines =
3677     tree_view->priv->grid_lines == PSPP_SHEET_VIEW_GRID_LINES_HORIZONTAL
3678     || tree_view->priv->grid_lines == PSPP_SHEET_VIEW_GRID_LINES_BOTH;
3679
3680   if (draw_vgrid_lines || draw_hgrid_lines)
3681     gtk_widget_style_get (widget, "grid-line-width", &grid_line_width, NULL);
3682
3683   n_visible_columns = 0;
3684   for (list = tree_view->priv->columns; list; list = list->next)
3685     {
3686       if (! PSPP_SHEET_VIEW_COLUMN (list->data)->visible)
3687         continue;
3688       n_visible_columns ++;
3689     }
3690
3691   /* Find the last column */
3692   for (last_column = g_list_last (tree_view->priv->columns);
3693        last_column && !(PSPP_SHEET_VIEW_COLUMN (last_column->data)->visible);
3694        last_column = last_column->prev)
3695     ;
3696
3697   /* and the first */
3698   for (first_column = g_list_first (tree_view->priv->columns);
3699        first_column && !(PSPP_SHEET_VIEW_COLUMN (first_column->data)->visible);
3700        first_column = first_column->next)
3701     ;
3702
3703   /* Actually process the expose event.  To do this, we want to
3704    * start at the first node of the event, and walk the tree in
3705    * order, drawing each successive node.
3706    */
3707
3708   min_y = y_offset;
3709   do
3710     {
3711       gboolean parity;
3712       gboolean is_first = FALSE;
3713       gboolean is_last = FALSE;
3714       gboolean done = FALSE;
3715       gboolean selected;
3716
3717       max_height = ROW_HEIGHT (tree_view);
3718
3719       cell_offset = 0;
3720
3721       background_area.y = y_offset + Zarea.y;
3722       background_area.height = max_height;
3723       max_y = background_area.y + max_height;
3724
3725       flags = 0;
3726
3727       if (node == tree_view->priv->prelight_node)
3728         flags |= GTK_CELL_RENDERER_PRELIT;
3729
3730       selected = pspp_sheet_view_node_is_selected (tree_view, node);
3731
3732       parity = node % 2;
3733
3734       for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns));
3735            list;
3736            list = (rtl ? list->prev : list->next))
3737         {
3738           PsppSheetViewColumn *column = list->data;
3739           const gchar *detail = NULL;
3740           gboolean selected_column;
3741           GtkStateType state;
3742
3743           if (!column->visible)
3744             continue;
3745
3746           if (tree_view->priv->selection->type == PSPP_SHEET_SELECTION_RECTANGLE)
3747             selected_column = column->selected && column->selectable;
3748           else
3749             selected_column = TRUE;
3750
3751           if (selected && selected_column)
3752             flags |= GTK_CELL_RENDERER_SELECTED;
3753           else
3754             flags &= ~GTK_CELL_RENDERER_SELECTED;
3755
3756           if (column->show_sort_indicator)
3757             flags |= GTK_CELL_RENDERER_SORTED;
3758           else
3759             flags &= ~GTK_CELL_RENDERER_SORTED;
3760
3761           if (cursor == node)
3762             flags |= GTK_CELL_RENDERER_FOCUSED;
3763           else
3764             flags &= ~GTK_CELL_RENDERER_FOCUSED;
3765
3766           background_area.x = cell_offset;
3767           background_area.width = column->width;
3768
3769           cell_area = background_area;
3770           cell_area.y += vertical_separator / 2;
3771           cell_area.x += horizontal_separator / 2;
3772           cell_area.height -= vertical_separator;
3773           cell_area.width -= horizontal_separator;
3774
3775           if (draw_vgrid_lines)
3776             {
3777               if (list == first_column)
3778                 {
3779                   cell_area.width -= grid_line_width / 2;
3780                 }
3781               else if (list == last_column)
3782                 {
3783                   cell_area.x += grid_line_width / 2;
3784                   cell_area.width -= grid_line_width / 2;
3785                 }
3786               else
3787                 {
3788                   cell_area.x += grid_line_width / 2;
3789                   cell_area.width -= grid_line_width;
3790                 }
3791             }
3792
3793           if (draw_hgrid_lines)
3794             {
3795               cell_area.y += grid_line_width / 2;
3796               cell_area.height -= grid_line_width;
3797             }
3798
3799           if (!gdk_rectangle_intersect (&background_area, &exposed_rect, NULL))
3800             {
3801               cell_offset += column->width;
3802               continue;
3803             }
3804
3805
3806           pspp_sheet_view_column_cell_set_cell_data (column,
3807                                                      tree_view->priv->model,
3808                                                      &iter);
3809
3810           /* Select the detail for drawing the cell.  relevant
3811            * factors are parity, sortedness, and whether to
3812            * display rules.
3813            */
3814           if (allow_rules && tree_view->priv->has_rules)
3815             {
3816               if ((flags & GTK_CELL_RENDERER_SORTED) &&
3817                   n_visible_columns >= 3)
3818                 {
3819                   if (parity)
3820                     detail = "cell_odd_ruled_sorted";
3821                   else
3822                     detail = "cell_even_ruled_sorted";
3823                 }
3824               else
3825                 {
3826                   if (parity)
3827                     detail = "cell_odd_ruled";
3828                   else
3829                     detail = "cell_even_ruled";
3830                 }
3831             }
3832           else
3833             {
3834               if ((flags & GTK_CELL_RENDERER_SORTED) &&
3835                   n_visible_columns >= 3)
3836                 {
3837                   if (parity)
3838                     detail = "cell_odd_sorted";
3839                   else
3840                     detail = "cell_even_sorted";
3841                 }
3842               else
3843                 {
3844                   if (parity)
3845                     detail = "cell_odd";
3846                   else
3847                     detail = "cell_even";
3848                 }
3849             }
3850
3851           g_assert (detail);
3852
3853           gtk_style_context_save (context);
3854           state = gtk_cell_renderer_get_state (NULL, widget, flags);
3855           gtk_style_context_set_state (context, state);
3856           gtk_style_context_add_class (context, GTK_STYLE_CLASS_CELL);
3857
3858           /* Draw background */
3859           gtk_render_background (context, cr,
3860                                  background_area.x,
3861                                  background_area.y,
3862                                  background_area.width,
3863                                  background_area.height);
3864
3865           /* Draw frame */
3866           gtk_render_frame (context, cr,
3867                             background_area.x,
3868                             background_area.y,
3869                             background_area.width,
3870                             background_area.height);
3871
3872           if (draw_hgrid_lines)
3873             {
3874               cairo_set_line_width (cr, 1.0);
3875               cairo_set_line_cap (cr, CAIRO_LINE_CAP_SQUARE);
3876
3877               if (background_area.y >= 0)
3878                 {
3879                   cairo_move_to (cr, background_area.x, background_area.y - 0.5);
3880                   cairo_line_to (cr, background_area.x + background_area.width,
3881                                  background_area.y - 0.5);
3882                 }
3883
3884               if (y_offset + max_height <= Zarea.height - 0.5)
3885                 {
3886                   cairo_move_to (cr, background_area.x, background_area.y + max_height - 0.5);
3887                   cairo_line_to (cr, background_area.x + background_area.width,
3888                                  background_area.y + max_height - 0.5);
3889                 }
3890               cairo_stroke (cr);
3891             }
3892
3893           _pspp_sheet_view_column_cell_render (column,
3894                                                cr,
3895                                                &background_area,
3896                                                &cell_area,
3897                                                flags);
3898
3899
3900           cell_offset += column->width;
3901           gtk_style_context_restore (context);
3902         }
3903
3904       if (node == drag_highlight)
3905         {
3906           /* Draw indicator for the drop
3907            */
3908           gint highlight_y = -1;
3909           int node = -1;
3910           gint width;
3911
3912           switch (tree_view->priv->drag_dest_pos)
3913             {
3914             case PSPP_SHEET_VIEW_DROP_BEFORE:
3915               highlight_y = background_area.y - 1;
3916               if (highlight_y < 0)
3917                       highlight_y = 0;
3918               break;
3919
3920             case PSPP_SHEET_VIEW_DROP_AFTER:
3921               highlight_y = background_area.y + background_area.height - 1;
3922               break;
3923
3924             case PSPP_SHEET_VIEW_DROP_INTO_OR_BEFORE:
3925             case PSPP_SHEET_VIEW_DROP_INTO_OR_AFTER:
3926               _pspp_sheet_view_find_node (tree_view, drag_dest_path, &node);
3927
3928               if (node < 0)
3929                 break;
3930               width = gdk_window_get_width (tree_view->priv->bin_window);
3931
3932               if (row_ending_details)
3933                 gtk_paint_focus (gtk_widget_get_style (widget),
3934                                  cr,
3935                                  gtk_widget_get_state (widget),
3936                                  widget,
3937                                  (is_first
3938                                   ? (is_last ? "treeview-drop-indicator" : "treeview-drop-indicator-left" )
3939                                   : (is_last ? "treeview-drop-indicator-right" : "tree-view-drop-indicator-middle" )),
3940                                  0, BACKGROUND_FIRST_PIXEL (tree_view, node)
3941                                  - focus_line_width / 2,
3942                                  width, ROW_HEIGHT (tree_view)
3943                                - focus_line_width + 1);
3944               else
3945                 gtk_paint_focus (gtk_widget_get_style (widget),
3946                                  cr,
3947                                  gtk_widget_get_state (widget),
3948                                  widget,
3949                                  "treeview-drop-indicator",
3950                                  0, BACKGROUND_FIRST_PIXEL (tree_view, node)
3951                                  - focus_line_width / 2,
3952                                  width, ROW_HEIGHT (tree_view)
3953                                  - focus_line_width + 1);
3954               break;
3955             }
3956
3957         }
3958
3959       y_offset += max_height;
3960
3961       do
3962         {
3963           node = pspp_sheet_view_node_next (tree_view, node);
3964           if (node >= 0)
3965             {
3966               gboolean has_next = gtk_tree_model_iter_next (tree_view->priv->model, &iter);
3967               done = TRUE;
3968
3969               /* Sanity Check! */
3970               TREE_VIEW_INTERNAL_ASSERT_VOID (has_next);
3971             }
3972           else
3973             goto done;
3974         }
3975       while (!done);
3976     }
3977   while (y_offset < Zarea.height);
3978
3979 done:
3980   pspp_sheet_view_draw_vertical_grid_lines (tree_view, cr, n_visible_columns,
3981                                    min_y, max_y);
3982
3983   if (cursor_path)
3984     gtk_tree_path_free (cursor_path);
3985
3986   if (drag_dest_path)
3987     gtk_tree_path_free (drag_dest_path);
3988
3989   return;
3990 }
3991
3992
3993 static gboolean
3994 pspp_sheet_view_draw (GtkWidget      *widget,
3995                       cairo_t *cr)
3996 {
3997   PsppSheetView *tree_view = PSPP_SHEET_VIEW (widget);
3998   GtkStyleContext *context;
3999
4000   context = gtk_widget_get_style_context (widget);
4001
4002   if (gtk_cairo_should_draw_window (cr, tree_view->priv->bin_window))
4003     {
4004       GList *tmp_list;
4005
4006       cairo_save (cr);
4007       gtk_cairo_transform_to_window(cr,widget,tree_view->priv->bin_window);
4008       pspp_sheet_view_draw_bin (widget, cr);
4009       cairo_restore (cr);
4010
4011       /* We can't just chain up to Container::expose as it will try to send the
4012        * event to the headers, so we handle propagating it to our children
4013        * (eg. widgets being edited) ourselves.
4014        */
4015       tmp_list = tree_view->priv->children;
4016       while (tmp_list)
4017         {
4018           PsppSheetViewChild *child = tmp_list->data;
4019           tmp_list = tmp_list->next;
4020
4021           gtk_container_propagate_draw (GTK_CONTAINER (tree_view), child->widget, cr);
4022         }
4023     }
4024   else
4025     {
4026       gtk_render_background (context, cr,
4027                              0, 0,
4028                              gtk_widget_get_allocated_width (widget),
4029                              gtk_widget_get_allocated_height (widget));
4030     }
4031
4032   gtk_style_context_save (context);
4033   gtk_style_context_remove_class (context, GTK_STYLE_CLASS_VIEW);
4034
4035   if (gtk_cairo_should_draw_window (cr, tree_view->priv->header_window))
4036     {
4037       gint n_visible_columns;
4038       GList *list;
4039
4040       for (list = tree_view->priv->columns; list != NULL; list = list->next)
4041         {
4042           PsppSheetViewColumn *column = list->data;
4043
4044           if (column == tree_view->priv->drag_column || !column->visible)
4045             continue;
4046
4047           if (span_intersects (column->allocation.x, column->allocation.width,
4048                                (int) gtk_adjustment_get_value (tree_view->priv->hadjustment),
4049                                (int) gtk_widget_get_allocated_width (widget))
4050               && column->button != NULL)
4051             gtk_container_propagate_draw (GTK_CONTAINER (tree_view),
4052                                           column->button, cr);
4053         }
4054
4055       n_visible_columns = 0;
4056       for (list = tree_view->priv->columns; list; list = list->next)
4057         {
4058           if (! PSPP_SHEET_VIEW_COLUMN (list->data)->visible)
4059             continue;
4060           n_visible_columns ++;
4061         }
4062       cairo_save (cr);
4063       gtk_cairo_transform_to_window(cr,widget,tree_view->priv->header_window);
4064       pspp_sheet_view_draw_vertical_grid_lines (tree_view,
4065                                                 cr,
4066                                                 n_visible_columns,
4067                                                 0,
4068                                                 TREE_VIEW_HEADER_HEIGHT (tree_view));
4069       cairo_restore (cr);
4070     }
4071   if (tree_view->priv->drag_window &&
4072       gtk_cairo_should_draw_window (cr, tree_view->priv->drag_window))
4073     {
4074       gtk_container_propagate_draw (GTK_CONTAINER (tree_view),
4075                                     tree_view->priv->drag_column->button,
4076                                     cr);
4077     }
4078
4079   gtk_style_context_restore (context);
4080   return FALSE;
4081 }
4082
4083 enum
4084 {
4085   DROP_HOME,
4086   DROP_RIGHT,
4087   DROP_LEFT,
4088   DROP_END
4089 };
4090
4091 /* returns 0x1 when no column has been found -- yes it's hackish */
4092 static PsppSheetViewColumn *
4093 pspp_sheet_view_get_drop_column (PsppSheetView       *tree_view,
4094                                PsppSheetViewColumn *column,
4095                                gint               drop_position)
4096 {
4097   PsppSheetViewColumn *left_column = NULL;
4098   PsppSheetViewColumn *cur_column = NULL;
4099   GList *tmp_list;
4100
4101   if (!column->reorderable)
4102     return (PsppSheetViewColumn *)0x1;
4103
4104   switch (drop_position)
4105     {
4106       case DROP_HOME:
4107         /* find first column where we can drop */
4108         tmp_list = tree_view->priv->columns;
4109         if (column == PSPP_SHEET_VIEW_COLUMN (tmp_list->data))
4110           return (PsppSheetViewColumn *)0x1;
4111
4112         while (tmp_list)
4113           {
4114             g_assert (tmp_list);
4115
4116             cur_column = PSPP_SHEET_VIEW_COLUMN (tmp_list->data);
4117             tmp_list = tmp_list->next;
4118
4119             if (left_column && left_column->visible == FALSE)
4120               continue;
4121
4122             if (!tree_view->priv->column_drop_func)
4123               return left_column;
4124
4125             if (!tree_view->priv->column_drop_func (tree_view, column, left_column, cur_column, tree_view->priv->column_drop_func_data))
4126               {
4127                 left_column = cur_column;
4128                 continue;
4129               }
4130
4131             return left_column;
4132           }
4133
4134         if (!tree_view->priv->column_drop_func)
4135           return left_column;
4136
4137         if (tree_view->priv->column_drop_func (tree_view, column, left_column, NULL, tree_view->priv->column_drop_func_data))
4138           return left_column;
4139         else
4140           return (PsppSheetViewColumn *)0x1;
4141         break;
4142
4143       case DROP_RIGHT:
4144         /* find first column after column where we can drop */
4145         tmp_list = tree_view->priv->columns;
4146
4147         for (; tmp_list; tmp_list = tmp_list->next)
4148           if (PSPP_SHEET_VIEW_COLUMN (tmp_list->data) == column)
4149             break;
4150
4151         if (!tmp_list || !tmp_list->next)
4152           return (PsppSheetViewColumn *)0x1;
4153
4154         tmp_list = tmp_list->next;
4155         left_column = PSPP_SHEET_VIEW_COLUMN (tmp_list->data);
4156         tmp_list = tmp_list->next;
4157
4158         while (tmp_list)
4159           {
4160             g_assert (tmp_list);
4161
4162             cur_column = PSPP_SHEET_VIEW_COLUMN (tmp_list->data);
4163             tmp_list = tmp_list->next;
4164
4165             if (left_column && left_column->visible == FALSE)
4166               {
4167                 left_column = cur_column;
4168                 if (tmp_list)
4169                   tmp_list = tmp_list->next;
4170                 continue;
4171               }
4172
4173             if (!tree_view->priv->column_drop_func)
4174               return left_column;
4175
4176             if (!tree_view->priv->column_drop_func (tree_view, column, left_column, cur_column, tree_view->priv->column_drop_func_data))
4177               {
4178                 left_column = cur_column;
4179                 continue;
4180               }
4181
4182             return left_column;
4183           }
4184
4185         if (!tree_view->priv->column_drop_func)
4186           return left_column;
4187
4188         if (tree_view->priv->column_drop_func (tree_view, column, left_column, NULL, tree_view->priv->column_drop_func_data))
4189           return left_column;
4190         else
4191           return (PsppSheetViewColumn *)0x1;
4192         break;
4193
4194       case DROP_LEFT:
4195         /* find first column before column where we can drop */
4196         tmp_list = tree_view->priv->columns;
4197
4198         for (; tmp_list; tmp_list = tmp_list->next)
4199           if (PSPP_SHEET_VIEW_COLUMN (tmp_list->data) == column)
4200             break;
4201
4202         if (!tmp_list || !tmp_list->prev)
4203           return (PsppSheetViewColumn *)0x1;
4204
4205         tmp_list = tmp_list->prev;
4206         cur_column = PSPP_SHEET_VIEW_COLUMN (tmp_list->data);
4207         tmp_list = tmp_list->prev;
4208
4209         while (tmp_list)
4210           {
4211             g_assert (tmp_list);
4212
4213             left_column = PSPP_SHEET_VIEW_COLUMN (tmp_list->data);
4214
4215             if (left_column && !left_column->visible)
4216               {
4217                 /*if (!tmp_list->prev)
4218                   return (PsppSheetViewColumn *)0x1;
4219                   */
4220 /*
4221                 cur_column = PSPP_SHEET_VIEW_COLUMN (tmp_list->prev->data);
4222                 tmp_list = tmp_list->prev->prev;
4223                 continue;*/
4224
4225                 cur_column = left_column;
4226                 if (tmp_list)
4227                   tmp_list = tmp_list->prev;
4228                 continue;
4229               }
4230
4231             if (!tree_view->priv->column_drop_func)
4232               return left_column;
4233
4234             if (tree_view->priv->column_drop_func (tree_view, column, left_column, cur_column, tree_view->priv->column_drop_func_data))
4235               return left_column;
4236
4237             cur_column = left_column;
4238             tmp_list = tmp_list->prev;
4239           }
4240
4241         if (!tree_view->priv->column_drop_func)
4242           return NULL;
4243
4244         if (tree_view->priv->column_drop_func (tree_view, column, NULL, cur_column, tree_view->priv->column_drop_func_data))
4245           return NULL;
4246         else
4247           return (PsppSheetViewColumn *)0x1;
4248         break;
4249
4250       case DROP_END:
4251         /* same as DROP_HOME case, but doing it backwards */
4252         tmp_list = g_list_last (tree_view->priv->columns);
4253         cur_column = NULL;
4254
4255         if (column == PSPP_SHEET_VIEW_COLUMN (tmp_list->data))
4256           return (PsppSheetViewColumn *)0x1;
4257
4258         while (tmp_list)
4259           {
4260             g_assert (tmp_list);
4261
4262             left_column = PSPP_SHEET_VIEW_COLUMN (tmp_list->data);
4263
4264             if (left_column && !left_column->visible)
4265               {
4266                 cur_column = left_column;
4267                 tmp_list = tmp_list->prev;
4268               }
4269
4270             if (!tree_view->priv->column_drop_func)
4271               return left_column;
4272
4273             if (tree_view->priv->column_drop_func (tree_view, column, left_column, cur_column, tree_view->priv->column_drop_func_data))
4274               return left_column;
4275
4276             cur_column = left_column;
4277             tmp_list = tmp_list->prev;
4278           }
4279
4280         if (!tree_view->priv->column_drop_func)
4281           return NULL;
4282
4283         if (tree_view->priv->column_drop_func (tree_view, column, NULL, cur_column, tree_view->priv->column_drop_func_data))
4284           return NULL;
4285         else
4286           return (PsppSheetViewColumn *)0x1;
4287         break;
4288     }
4289
4290   return (PsppSheetViewColumn *)0x1;
4291 }
4292
4293 static gboolean
4294 pspp_sheet_view_key_press (GtkWidget   *widget,
4295                          GdkEventKey *event)
4296 {
4297   PsppSheetView *tree_view = (PsppSheetView *) widget;
4298
4299   if (tree_view->priv->rubber_band_status)
4300     {
4301       if (event->keyval == GDK_Escape)
4302         pspp_sheet_view_stop_rubber_band (tree_view);
4303
4304       return TRUE;
4305     }
4306
4307   if (PSPP_SHEET_VIEW_FLAG_SET (tree_view, PSPP_SHEET_VIEW_IN_COLUMN_DRAG))
4308     {
4309       if (event->keyval == GDK_Escape)
4310         {
4311           tree_view->priv->cur_reorder = NULL;
4312           pspp_sheet_view_button_release_drag_column (widget, NULL);
4313         }
4314       return TRUE;
4315     }
4316
4317   if (PSPP_SHEET_VIEW_FLAG_SET (tree_view, PSPP_SHEET_VIEW_HEADERS_VISIBLE))
4318     {
4319       GList *focus_column;
4320       gboolean rtl;
4321
4322       rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
4323
4324       for (focus_column = tree_view->priv->columns;
4325            focus_column;
4326            focus_column = focus_column->next)
4327         {
4328           PsppSheetViewColumn *column = PSPP_SHEET_VIEW_COLUMN (focus_column->data);
4329
4330           if (column->button && gtk_widget_has_focus (column->button))
4331             break;
4332         }
4333
4334       if (focus_column &&
4335           (event->state & GDK_SHIFT_MASK) && (event->state & GDK_MOD1_MASK) &&
4336           (event->keyval == GDK_Left || event->keyval == GDK_KP_Left
4337            || event->keyval == GDK_Right || event->keyval == GDK_KP_Right))
4338         {
4339           PsppSheetViewColumn *column = PSPP_SHEET_VIEW_COLUMN (focus_column->data);
4340
4341           if (!column->resizable)
4342             {
4343               gtk_widget_error_bell (widget);
4344               return TRUE;
4345             }
4346
4347           if (event->keyval == (rtl ? GDK_Right : GDK_Left)
4348               || event->keyval == (rtl ? GDK_KP_Right : GDK_KP_Left))
4349             {
4350               gint old_width = column->resized_width;
4351
4352               column->resized_width = MAX (column->resized_width,
4353                                            column->width);
4354               column->resized_width -= 2;
4355               if (column->resized_width < 0)
4356                 column->resized_width = 0;
4357
4358               if (column->min_width == -1)
4359                 column->resized_width = MAX (column->button_request,
4360                                              column->resized_width);
4361               else
4362                 column->resized_width = MAX (column->min_width,
4363                                              column->resized_width);
4364
4365               if (column->max_width != -1)
4366                 column->resized_width = MIN (column->resized_width,
4367                                              column->max_width);
4368
4369               column->use_resized_width = TRUE;
4370
4371               if (column->resized_width != old_width)
4372                 gtk_widget_queue_resize (widget);
4373               else
4374                 gtk_widget_error_bell (widget);
4375             }
4376           else if (event->keyval == (rtl ? GDK_Left : GDK_Right)
4377                    || event->keyval == (rtl ? GDK_KP_Left : GDK_KP_Right))
4378             {
4379               gint old_width = column->resized_width;
4380
4381               column->resized_width = MAX (column->resized_width,
4382                                            column->width);
4383               column->resized_width += 2;
4384
4385               if (column->max_width != -1)
4386                 column->resized_width = MIN (column->resized_width,
4387                                              column->max_width);
4388
4389               column->use_resized_width = TRUE;
4390
4391               if (column->resized_width != old_width)
4392                 gtk_widget_queue_resize (widget);
4393               else
4394                 gtk_widget_error_bell (widget);
4395             }
4396
4397           return TRUE;
4398         }
4399
4400       if (focus_column &&
4401           (event->state & GDK_MOD1_MASK) &&
4402           (event->keyval == GDK_Left || event->keyval == GDK_KP_Left
4403            || event->keyval == GDK_Right || event->keyval == GDK_KP_Right
4404            || event->keyval == GDK_Home || event->keyval == GDK_KP_Home
4405            || event->keyval == GDK_End || event->keyval == GDK_KP_End))
4406         {
4407           PsppSheetViewColumn *column = PSPP_SHEET_VIEW_COLUMN (focus_column->data);
4408
4409           if (event->keyval == (rtl ? GDK_Right : GDK_Left)
4410               || event->keyval == (rtl ? GDK_KP_Right : GDK_KP_Left))
4411             {
4412               PsppSheetViewColumn *col;
4413               col = pspp_sheet_view_get_drop_column (tree_view, column, DROP_LEFT);
4414               if (col != (PsppSheetViewColumn *)0x1)
4415                 pspp_sheet_view_move_column_after (tree_view, column, col);
4416               else
4417                 gtk_widget_error_bell (widget);
4418             }
4419           else if (event->keyval == (rtl ? GDK_Left : GDK_Right)
4420                    || event->keyval == (rtl ? GDK_KP_Left : GDK_KP_Right))
4421             {
4422               PsppSheetViewColumn *col;
4423               col = pspp_sheet_view_get_drop_column (tree_view, column, DROP_RIGHT);
4424               if (col != (PsppSheetViewColumn *)0x1)
4425                 pspp_sheet_view_move_column_after (tree_view, column, col);
4426               else
4427                 gtk_widget_error_bell (widget);
4428             }
4429           else if (event->keyval == GDK_Home || event->keyval == GDK_KP_Home)
4430             {
4431               PsppSheetViewColumn *col;
4432               col = pspp_sheet_view_get_drop_column (tree_view, column, DROP_HOME);
4433               if (col != (PsppSheetViewColumn *)0x1)
4434                 pspp_sheet_view_move_column_after (tree_view, column, col);
4435               else
4436                 gtk_widget_error_bell (widget);
4437             }
4438           else if (event->keyval == GDK_End || event->keyval == GDK_KP_End)
4439             {
4440               PsppSheetViewColumn *col;
4441               col = pspp_sheet_view_get_drop_column (tree_view, column, DROP_END);
4442               if (col != (PsppSheetViewColumn *)0x1)
4443                 pspp_sheet_view_move_column_after (tree_view, column, col);
4444               else
4445                 gtk_widget_error_bell (widget);
4446             }
4447
4448           return TRUE;
4449         }
4450     }
4451
4452   /* Chain up to the parent class.  It handles the keybindings. */
4453   if (GTK_WIDGET_CLASS (pspp_sheet_view_parent_class)->key_press_event (widget, event))
4454     return TRUE;
4455
4456   if (tree_view->priv->search_entry_avoid_unhandled_binding)
4457     {
4458       tree_view->priv->search_entry_avoid_unhandled_binding = FALSE;
4459       return FALSE;
4460     }
4461
4462   /* We pass the event to the search_entry.  If its text changes, then we start
4463    * the typeahead find capabilities. */
4464   if (gtk_widget_has_focus (GTK_WIDGET (tree_view))
4465       && tree_view->priv->enable_search
4466       && !tree_view->priv->search_custom_entry_set)
4467     {
4468       GdkEvent *new_event;
4469       char *old_text;
4470       const char *new_text;
4471       gboolean retval;
4472       GdkScreen *screen;
4473       gboolean text_modified;
4474       gulong popup_menu_id;
4475
4476       pspp_sheet_view_ensure_interactive_directory (tree_view);
4477
4478       /* Make a copy of the current text */
4479       old_text = g_strdup (gtk_entry_get_text (GTK_ENTRY (tree_view->priv->search_entry)));
4480       new_event = gdk_event_copy ((GdkEvent *) event);
4481       g_object_unref (((GdkEventKey *) new_event)->window);
4482       ((GdkEventKey *) new_event)->window = g_object_ref (gtk_widget_get_window (tree_view->priv->search_window));
4483       gtk_widget_realize (tree_view->priv->search_window);
4484
4485       popup_menu_id = g_signal_connect (tree_view->priv->search_entry,
4486                                         "popup-menu", G_CALLBACK (gtk_true),
4487                                         NULL);
4488
4489       /* Move the entry off screen */
4490       screen = gtk_widget_get_screen (GTK_WIDGET (tree_view));
4491       gtk_window_move (GTK_WINDOW (tree_view->priv->search_window),
4492                        gdk_screen_get_width (screen) + 1,
4493                        gdk_screen_get_height (screen) + 1);
4494       gtk_widget_show (tree_view->priv->search_window);
4495
4496       /* Send the event to the window.  If the preedit_changed signal is emitted
4497        * during this event, we will set priv->imcontext_changed  */
4498       tree_view->priv->imcontext_changed = FALSE;
4499       retval = gtk_widget_event (tree_view->priv->search_window, new_event);
4500       gdk_event_free (new_event);
4501       gtk_widget_hide (tree_view->priv->search_window);
4502
4503       g_signal_handler_disconnect (tree_view->priv->search_entry,
4504                                    popup_menu_id);
4505
4506       /* We check to make sure that the entry tried to handle the text, and that
4507        * the text has changed.
4508        */
4509       new_text = gtk_entry_get_text (GTK_ENTRY (tree_view->priv->search_entry));
4510       text_modified = strcmp (old_text, new_text) != 0;
4511       g_free (old_text);
4512       if (tree_view->priv->imcontext_changed ||    /* we're in a preedit */
4513           (retval && text_modified))               /* ...or the text was modified */
4514         {
4515           if (pspp_sheet_view_real_start_interactive_search (tree_view, FALSE))
4516             {
4517               gtk_widget_grab_focus (GTK_WIDGET (tree_view));
4518               return TRUE;
4519             }
4520           else
4521             {
4522               gtk_entry_set_text (GTK_ENTRY (tree_view->priv->search_entry), "");
4523               return FALSE;
4524             }
4525         }
4526     }
4527
4528   return FALSE;
4529 }
4530
4531 static gboolean
4532 pspp_sheet_view_key_release (GtkWidget   *widget,
4533                            GdkEventKey *event)
4534 {
4535   PsppSheetView *tree_view = PSPP_SHEET_VIEW (widget);
4536
4537   if (tree_view->priv->rubber_band_status)
4538     return TRUE;
4539
4540   return GTK_WIDGET_CLASS (pspp_sheet_view_parent_class)->key_release_event (widget, event);
4541 }
4542
4543 /* FIXME Is this function necessary? Can I get an enter_notify event
4544  * w/o either an expose event or a mouse motion event?
4545  */
4546 static gboolean
4547 pspp_sheet_view_enter_notify (GtkWidget        *widget,
4548                             GdkEventCrossing *event)
4549 {
4550   PsppSheetView *tree_view = PSPP_SHEET_VIEW (widget);
4551   int node;
4552   gint new_y;
4553
4554   /* Sanity check it */
4555   if (event->window != tree_view->priv->bin_window)
4556     return FALSE;
4557
4558   if (tree_view->priv->row_count == 0)
4559     return FALSE;
4560
4561   if (event->mode == GDK_CROSSING_GRAB ||
4562       event->mode == GDK_CROSSING_GTK_GRAB ||
4563       event->mode == GDK_CROSSING_GTK_UNGRAB ||
4564       event->mode == GDK_CROSSING_STATE_CHANGED)
4565     return TRUE;
4566
4567   /* find the node internally */
4568   new_y = TREE_WINDOW_Y_TO_RBTREE_Y(tree_view, event->y);
4569   if (new_y < 0)
4570     new_y = 0;
4571   pspp_sheet_view_find_offset (tree_view, new_y, &node);
4572
4573   tree_view->priv->event_last_x = event->x;
4574   tree_view->priv->event_last_y = event->y;
4575
4576   prelight_or_select (tree_view, node, event->x, event->y);
4577
4578   return TRUE;
4579 }
4580
4581 static gboolean
4582 pspp_sheet_view_leave_notify (GtkWidget        *widget,
4583                             GdkEventCrossing *event)
4584 {
4585   PsppSheetView *tree_view;
4586
4587   if (event->mode == GDK_CROSSING_GRAB)
4588     return TRUE;
4589
4590   tree_view = PSPP_SHEET_VIEW (widget);
4591
4592   if (tree_view->priv->prelight_node >= 0)
4593     _pspp_sheet_view_queue_draw_node (tree_view,
4594                                    tree_view->priv->prelight_node,
4595                                    NULL);
4596
4597   tree_view->priv->event_last_x = -10000;
4598   tree_view->priv->event_last_y = -10000;
4599
4600   prelight_or_select (tree_view,
4601                       -1,
4602                       -1000, -1000); /* coords not possibly over an arrow */
4603
4604   return TRUE;
4605 }
4606
4607
4608 static gint
4609 pspp_sheet_view_focus_out (GtkWidget     *widget,
4610                          GdkEventFocus *event)
4611 {
4612   PsppSheetView *tree_view;
4613
4614   tree_view = PSPP_SHEET_VIEW (widget);
4615
4616   gtk_widget_queue_draw (widget);
4617
4618   /* destroy interactive search dialog */
4619   if (tree_view->priv->search_window)
4620     pspp_sheet_view_search_dialog_hide (tree_view->priv->search_window, tree_view);
4621
4622   return FALSE;
4623 }
4624
4625
4626 /* Incremental Reflow
4627  */
4628
4629 static void
4630 pspp_sheet_view_node_queue_redraw (PsppSheetView *tree_view,
4631                                  int node)
4632 {
4633   GtkAllocation allocation;
4634   gint y = pspp_sheet_view_node_find_offset (tree_view, node)
4635     - gtk_adjustment_get_value (tree_view->priv->vadjustment)
4636     + TREE_VIEW_HEADER_HEIGHT (tree_view);
4637
4638   gtk_widget_get_allocation (GTK_WIDGET (tree_view), &allocation);
4639
4640   gtk_widget_queue_draw_area (GTK_WIDGET (tree_view),
4641                               0, y,
4642                               allocation.width,
4643                               tree_view->priv->fixed_height);
4644 }
4645
4646 static gboolean
4647 node_is_visible (PsppSheetView *tree_view,
4648                  int node)
4649 {
4650   int y;
4651   int height;
4652
4653   y = pspp_sheet_view_node_find_offset (tree_view, node);
4654   height = ROW_HEIGHT (tree_view);
4655
4656   if (y >= gtk_adjustment_get_value (tree_view->priv->vadjustment) &&
4657       y + height <= (gtk_adjustment_get_value (tree_view->priv->vadjustment)
4658                      + gtk_adjustment_get_page_size (tree_view->priv->vadjustment)))
4659     return TRUE;
4660
4661   return FALSE;
4662 }
4663
4664 /* Returns the row height. */
4665 static gint
4666 validate_row (PsppSheetView *tree_view,
4667               int node,
4668               GtkTreeIter *iter,
4669               GtkTreePath *path)
4670 {
4671   PsppSheetViewColumn *column;
4672   GList *list, *first_column, *last_column;
4673   gint height = 0;
4674   gint horizontal_separator;
4675   gint vertical_separator;
4676   gint focus_line_width;
4677   gboolean draw_vgrid_lines, draw_hgrid_lines;
4678   gint focus_pad;
4679   gint grid_line_width;
4680   gboolean wide_separators;
4681   gint separator_height;
4682
4683   gtk_widget_style_get (GTK_WIDGET (tree_view),
4684                         "focus-padding", &focus_pad,
4685                         "focus-line-width", &focus_line_width,
4686                         "horizontal-separator", &horizontal_separator,
4687                         "vertical-separator", &vertical_separator,
4688                         "grid-line-width", &grid_line_width,
4689                         "wide-separators",  &wide_separators,
4690                         "separator-height", &separator_height,
4691                         NULL);
4692
4693   draw_vgrid_lines =
4694     tree_view->priv->grid_lines == PSPP_SHEET_VIEW_GRID_LINES_VERTICAL
4695     || tree_view->priv->grid_lines == PSPP_SHEET_VIEW_GRID_LINES_BOTH;
4696   draw_hgrid_lines =
4697     tree_view->priv->grid_lines == PSPP_SHEET_VIEW_GRID_LINES_HORIZONTAL
4698     || tree_view->priv->grid_lines == PSPP_SHEET_VIEW_GRID_LINES_BOTH;
4699
4700   for (last_column = g_list_last (tree_view->priv->columns);
4701        last_column && !(PSPP_SHEET_VIEW_COLUMN (last_column->data)->visible);
4702        last_column = last_column->prev)
4703     ;
4704
4705   for (first_column = g_list_first (tree_view->priv->columns);
4706        first_column && !(PSPP_SHEET_VIEW_COLUMN (first_column->data)->visible);
4707        first_column = first_column->next)
4708     ;
4709
4710   for (list = tree_view->priv->columns; list; list = list->next)
4711     {
4712       gint tmp_width;
4713       gint tmp_height;
4714
4715       column = list->data;
4716
4717       if (! column->visible)
4718         continue;
4719
4720       pspp_sheet_view_column_cell_set_cell_data (column, tree_view->priv->model, iter);
4721       pspp_sheet_view_column_cell_get_size (column,
4722                                           NULL, NULL, NULL,
4723                                           &tmp_width, &tmp_height);
4724
4725       tmp_height += vertical_separator;
4726       height = MAX (height, tmp_height);
4727
4728       tmp_width = tmp_width + horizontal_separator;
4729
4730       if (draw_vgrid_lines)
4731         {
4732           if (list->data == first_column || list->data == last_column)
4733             tmp_width += grid_line_width / 2.0;
4734           else
4735             tmp_width += grid_line_width;
4736         }
4737
4738       if (tmp_width > column->requested_width)
4739         column->requested_width = tmp_width;
4740     }
4741
4742   if (draw_hgrid_lines)
4743     height += grid_line_width;
4744
4745   tree_view->priv->post_validation_flag = TRUE;
4746   return height;
4747 }
4748
4749
4750 static void
4751 validate_visible_area (PsppSheetView *tree_view)
4752 {
4753   GtkTreePath *path = NULL;
4754   GtkTreePath *above_path = NULL;
4755   GtkTreeIter iter;
4756   int node = -1;
4757   gint total_height;
4758   gint area_above = 0;
4759   gint area_below = 0;
4760   GtkAllocation allocation;
4761
4762   if (tree_view->priv->row_count == 0)
4763     return;
4764
4765   if (tree_view->priv->scroll_to_path == NULL)
4766     return;
4767
4768   gtk_widget_get_allocation (GTK_WIDGET (tree_view), &allocation);
4769
4770   total_height = allocation.height - TREE_VIEW_HEADER_HEIGHT (tree_view);
4771
4772   if (total_height == 0)
4773     return;
4774
4775   path = gtk_tree_row_reference_get_path (tree_view->priv->scroll_to_path);
4776   if (path)
4777     {
4778       /* we are going to scroll, and will update dy */
4779       _pspp_sheet_view_find_node (tree_view, path, &node);
4780       gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
4781
4782       if (tree_view->priv->scroll_to_use_align)
4783         {
4784           gint height = ROW_HEIGHT (tree_view);
4785           area_above = (total_height - height) *
4786             tree_view->priv->scroll_to_row_align;
4787           area_below = total_height - area_above - height;
4788           area_above = MAX (area_above, 0);
4789           area_below = MAX (area_below, 0);
4790         }
4791       else
4792         {
4793           /* two cases:
4794            * 1) row not visible
4795            * 2) row visible
4796            */
4797           gint dy;
4798           gint height = ROW_HEIGHT (tree_view);
4799
4800           dy = pspp_sheet_view_node_find_offset (tree_view, node);
4801
4802           if (dy >= gtk_adjustment_get_value (tree_view->priv->vadjustment) &&
4803               dy + height <= (gtk_adjustment_get_value (tree_view->priv->vadjustment)
4804                               + gtk_adjustment_get_page_size (tree_view->priv->vadjustment)))
4805             {
4806               /* row visible: keep the row at the same position */
4807               area_above = dy - gtk_adjustment_get_value (tree_view->priv->vadjustment);
4808               area_below = (gtk_adjustment_get_value (tree_view->priv->vadjustment) +
4809                             gtk_adjustment_get_page_size (tree_view->priv->vadjustment))
4810                 - dy - height;
4811             }
4812           else
4813             {
4814               /* row not visible */
4815               if (dy >= 0
4816                   && dy + height <= gtk_adjustment_get_page_size (tree_view->priv->vadjustment))
4817                 {
4818                   /* row at the beginning -- fixed */
4819                   area_above = dy;
4820                   area_below = gtk_adjustment_get_page_size (tree_view->priv->vadjustment)
4821                     - area_above - height;
4822                 }
4823               else if (dy >= (gtk_adjustment_get_upper (tree_view->priv->vadjustment) -
4824                               gtk_adjustment_get_page_size (tree_view->priv->vadjustment)))
4825                 {
4826                   /* row at the end -- fixed */
4827                   area_above = dy - (gtk_adjustment_get_upper (tree_view->priv->vadjustment) -
4828                                      gtk_adjustment_get_page_size (tree_view->priv->vadjustment));
4829                   area_below = gtk_adjustment_get_page_size (tree_view->priv->vadjustment) -
4830                     area_above - height;
4831
4832                   if (area_below < 0)
4833                     {
4834                       area_above = gtk_adjustment_get_page_size (tree_view->priv->vadjustment) - height;
4835                       area_below = 0;
4836                     }
4837                 }
4838               else
4839                 {
4840                   /* row somewhere in the middle, bring it to the top
4841                    * of the view
4842                    */
4843                   area_above = 0;
4844                   area_below = total_height - height;
4845                 }
4846             }
4847         }
4848     }
4849   else
4850     /* the scroll to isn't valid; ignore it.
4851      */
4852     {
4853       gtk_tree_row_reference_free (tree_view->priv->scroll_to_path);
4854       tree_view->priv->scroll_to_path = NULL;
4855       return;
4856     }
4857
4858   above_path = gtk_tree_path_copy (path);
4859
4860   /* Now, we walk forwards and backwards, measuring rows. Unfortunately,
4861    * backwards is much slower then forward, as there is no iter_prev function.
4862    * We go forwards first in case we run out of tree.  Then we go backwards to
4863    * fill out the top.
4864    */
4865   while (node >= 0 && area_below > 0)
4866     {
4867       gboolean done = FALSE;
4868       do
4869         {
4870           node = pspp_sheet_view_node_next (tree_view, node);
4871           if (node >= 0)
4872             {
4873               gboolean has_next = gtk_tree_model_iter_next (tree_view->priv->model, &iter);
4874               done = TRUE;
4875               gtk_tree_path_next (path);
4876
4877               /* Sanity Check! */
4878               TREE_VIEW_INTERNAL_ASSERT_VOID (has_next);
4879             }
4880           else
4881             break;
4882         }
4883       while (!done);
4884
4885       if (node < 0)
4886         break;
4887
4888       area_below -= ROW_HEIGHT (tree_view);
4889     }
4890   gtk_tree_path_free (path);
4891
4892   /* If we ran out of tree, and have extra area_below left, we need to add it
4893    * to area_above */
4894   if (area_below > 0)
4895     area_above += area_below;
4896
4897   _pspp_sheet_view_find_node (tree_view, above_path, &node);
4898
4899   /* We walk backwards */
4900   while (area_above > 0)
4901     {
4902       node = pspp_sheet_view_node_prev (tree_view, node);
4903
4904       /* Always find the new path in the tree.  We cannot just assume
4905        * a gtk_tree_path_prev() is enough here, as there might be children
4906        * in between this node and the previous sibling node.  If this
4907        * appears to be a performance hotspot in profiles, we can look into
4908        * intrigate logic for keeping path, node and iter in sync like
4909        * we do for forward walks.  (Which will be hard because of the lacking
4910        * iter_prev).
4911        */
4912
4913       if (node < 0)
4914         break;
4915
4916       gtk_tree_path_free (above_path);
4917       above_path = _pspp_sheet_view_find_path (tree_view, node);
4918
4919       gtk_tree_model_get_iter (tree_view->priv->model, &iter, above_path);
4920
4921       area_above -= ROW_HEIGHT (tree_view);
4922     }
4923
4924   /* set the dy here to scroll to the path,
4925    * and sync the top row accordingly
4926    */
4927   pspp_sheet_view_set_top_row (tree_view, above_path, -area_above);
4928   pspp_sheet_view_top_row_to_dy (tree_view);
4929
4930   gtk_tree_row_reference_free (tree_view->priv->scroll_to_path);
4931   tree_view->priv->scroll_to_path = NULL;
4932
4933   if (above_path)
4934     gtk_tree_path_free (above_path);
4935
4936   if (tree_view->priv->scroll_to_column)
4937     {
4938       tree_view->priv->scroll_to_column = NULL;
4939     }
4940   gtk_widget_queue_draw (GTK_WIDGET (tree_view));
4941 }
4942
4943 static void
4944 initialize_fixed_height_mode (PsppSheetView *tree_view)
4945 {
4946   if (!tree_view->priv->row_count)
4947     return;
4948
4949   if (tree_view->priv->fixed_height_set)
4950     return;
4951
4952   if (tree_view->priv->fixed_height < 0)
4953     {
4954       GtkTreeIter iter;
4955       GtkTreePath *path;
4956
4957       int node = 0;
4958
4959       path = _pspp_sheet_view_find_path (tree_view, node);
4960       gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
4961
4962       tree_view->priv->fixed_height = validate_row (tree_view, node, &iter, path);
4963
4964       gtk_tree_path_free (path);
4965
4966       g_object_notify (G_OBJECT (tree_view), "fixed-height");
4967     }
4968 }
4969
4970 /* Our strategy for finding nodes to validate is a little convoluted.  We find
4971  * the left-most uninvalidated node.  We then try walking right, validating
4972  * nodes.  Once we find a valid node, we repeat the previous process of finding
4973  * the first invalid node.
4974  */
4975
4976 static gboolean
4977 validate_rows_handler (PsppSheetView *tree_view)
4978 {
4979   initialize_fixed_height_mode (tree_view);
4980   if (tree_view->priv->validate_rows_timer)
4981     {
4982       g_source_remove (tree_view->priv->validate_rows_timer);
4983       tree_view->priv->validate_rows_timer = 0;
4984     }
4985
4986   return FALSE;
4987 }
4988
4989 static gboolean
4990 do_presize_handler (PsppSheetView *tree_view)
4991 {
4992   GtkRequisition requisition;
4993
4994   validate_visible_area (tree_view);
4995   tree_view->priv->presize_handler_timer = 0;
4996
4997   if (! gtk_widget_get_realized (GTK_WIDGET (tree_view)))
4998     return FALSE;
4999
5000   gtk_widget_get_preferred_size (GTK_WIDGET (tree_view), NULL, &requisition);
5001
5002   gtk_adjustment_set_upper (tree_view->priv->hadjustment, MAX (gtk_adjustment_get_upper (tree_view->priv->hadjustment), (gfloat)requisition.width));
5003   gtk_adjustment_set_upper (tree_view->priv->vadjustment, MAX (gtk_adjustment_get_upper (tree_view->priv->vadjustment), (gfloat)requisition.height));
5004   gtk_adjustment_changed (tree_view->priv->hadjustment);
5005   gtk_adjustment_changed (tree_view->priv->vadjustment);
5006   gtk_widget_queue_resize (GTK_WIDGET (tree_view));
5007
5008   return FALSE;
5009 }
5010
5011 static gboolean
5012 presize_handler_callback (gpointer data)
5013 {
5014   do_presize_handler (PSPP_SHEET_VIEW (data));
5015
5016   return FALSE;
5017 }
5018
5019 static void
5020 install_presize_handler (PsppSheetView *tree_view)
5021 {
5022   if (! gtk_widget_get_realized (GTK_WIDGET (tree_view)))
5023     return;
5024
5025   if (! tree_view->priv->presize_handler_timer)
5026     {
5027       tree_view->priv->presize_handler_timer =
5028         gdk_threads_add_idle_full (GTK_PRIORITY_RESIZE - 2, presize_handler_callback, tree_view, NULL);
5029     }
5030   if (! tree_view->priv->validate_rows_timer)
5031     {
5032       tree_view->priv->validate_rows_timer =
5033         gdk_threads_add_idle_full (PSPP_SHEET_VIEW_PRIORITY_VALIDATE, (GSourceFunc) validate_rows_handler, tree_view, NULL);
5034     }
5035 }
5036
5037 static gboolean
5038 scroll_sync_handler (PsppSheetView *tree_view)
5039 {
5040   if (tree_view->priv->height <= gtk_adjustment_get_page_size (tree_view->priv->vadjustment))
5041     gtk_adjustment_set_value (GTK_ADJUSTMENT (tree_view->priv->vadjustment), 0);
5042   else if (gtk_tree_row_reference_valid (tree_view->priv->top_row))
5043     pspp_sheet_view_top_row_to_dy (tree_view);
5044   else
5045     pspp_sheet_view_dy_to_top_row (tree_view);
5046
5047   tree_view->priv->scroll_sync_timer = 0;
5048
5049   return FALSE;
5050 }
5051
5052 static void
5053 install_scroll_sync_handler (PsppSheetView *tree_view)
5054 {
5055   if (!gtk_widget_get_realized (GTK_WIDGET (tree_view)))
5056     return;
5057
5058   if (!tree_view->priv->scroll_sync_timer)
5059     {
5060       tree_view->priv->scroll_sync_timer =
5061         gdk_threads_add_idle_full (PSPP_SHEET_VIEW_PRIORITY_SCROLL_SYNC, (GSourceFunc) scroll_sync_handler, tree_view, NULL);
5062     }
5063 }
5064
5065 static void
5066 pspp_sheet_view_set_top_row (PsppSheetView *tree_view,
5067                            GtkTreePath *path,
5068                            gint         offset)
5069 {
5070   gtk_tree_row_reference_free (tree_view->priv->top_row);
5071
5072   if (!path)
5073     {
5074       tree_view->priv->top_row = NULL;
5075       tree_view->priv->top_row_dy = 0;
5076     }
5077   else
5078     {
5079       tree_view->priv->top_row = gtk_tree_row_reference_new_proxy (G_OBJECT (tree_view), tree_view->priv->model, path);
5080       tree_view->priv->top_row_dy = offset;
5081     }
5082 }
5083
5084 /* Always call this iff dy is in the visible range.  If the tree is empty, then
5085  * it's set to be NULL, and top_row_dy is 0;
5086  */
5087 static void
5088 pspp_sheet_view_dy_to_top_row (PsppSheetView *tree_view)
5089 {
5090   gint offset;
5091   GtkTreePath *path;
5092   int node;
5093
5094   if (tree_view->priv->row_count == 0)
5095     {
5096       pspp_sheet_view_set_top_row (tree_view, NULL, 0);
5097     }
5098   else
5099     {
5100       offset = pspp_sheet_view_find_offset (tree_view,
5101                                             tree_view->priv->dy,
5102                                             &node);
5103
5104       if (node < 0)
5105         {
5106           pspp_sheet_view_set_top_row (tree_view, NULL, 0);
5107         }
5108       else
5109         {
5110           path = _pspp_sheet_view_find_path (tree_view, node);
5111           pspp_sheet_view_set_top_row (tree_view, path, offset);
5112           gtk_tree_path_free (path);
5113         }
5114     }
5115 }
5116
5117 static void
5118 pspp_sheet_view_top_row_to_dy (PsppSheetView *tree_view)
5119 {
5120   GtkTreePath *path;
5121   int node;
5122   int new_dy;
5123
5124   /* Avoid recursive calls */
5125   if (tree_view->priv->in_top_row_to_dy)
5126     return;
5127
5128   if (tree_view->priv->top_row)
5129     path = gtk_tree_row_reference_get_path (tree_view->priv->top_row);
5130   else
5131     path = NULL;
5132
5133   if (!path)
5134     node = -1;
5135   else
5136     _pspp_sheet_view_find_node (tree_view, path, &node);
5137
5138   if (path)
5139     gtk_tree_path_free (path);
5140
5141   if (node < 0)
5142     {
5143       /* keep dy and set new toprow */
5144       gtk_tree_row_reference_free (tree_view->priv->top_row);
5145       tree_view->priv->top_row = NULL;
5146       tree_view->priv->top_row_dy = 0;
5147       /* DO NOT install the idle handler */
5148       pspp_sheet_view_dy_to_top_row (tree_view);
5149       return;
5150     }
5151
5152   if (ROW_HEIGHT (tree_view) < tree_view->priv->top_row_dy)
5153     {
5154       /* new top row -- do NOT install the idle handler */
5155       pspp_sheet_view_dy_to_top_row (tree_view);
5156       return;
5157     }
5158
5159   new_dy = pspp_sheet_view_node_find_offset (tree_view, node);
5160   new_dy += tree_view->priv->top_row_dy;
5161
5162   if (new_dy + gtk_adjustment_get_page_size (tree_view->priv->vadjustment) > tree_view->priv->height)
5163     new_dy = tree_view->priv->height - gtk_adjustment_get_page_size (tree_view->priv->vadjustment);
5164
5165   new_dy = MAX (0, new_dy);
5166
5167   tree_view->priv->in_top_row_to_dy = TRUE;
5168   gtk_adjustment_set_value (tree_view->priv->vadjustment, (gdouble)new_dy);
5169   tree_view->priv->in_top_row_to_dy = FALSE;
5170 }
5171
5172
5173 void
5174 _pspp_sheet_view_install_mark_rows_col_dirty (PsppSheetView *tree_view)
5175 {
5176   install_presize_handler (tree_view);
5177 }
5178
5179 /* Drag-and-drop */
5180
5181 static void
5182 set_source_row (GdkDragContext *context,
5183                 GtkTreeModel   *model,
5184                 GtkTreePath    *source_row)
5185 {
5186   g_object_set_data_full (G_OBJECT (context),
5187                           "gtk-tree-view-source-row",
5188                           source_row ? gtk_tree_row_reference_new (model, source_row) : NULL,
5189                           (GDestroyNotify) (source_row ? gtk_tree_row_reference_free : NULL));
5190 }
5191
5192 static GtkTreePath*
5193 get_source_row (GdkDragContext *context)
5194 {
5195   GtkTreeRowReference *ref =
5196     g_object_get_data (G_OBJECT (context), "gtk-tree-view-source-row");
5197
5198   if (ref)
5199     return gtk_tree_row_reference_get_path (ref);
5200   else
5201     return NULL;
5202 }
5203
5204 typedef struct
5205 {
5206   GtkTreeRowReference *dest_row;
5207   guint                path_down_mode   : 1;
5208   guint                empty_view_drop  : 1;
5209   guint                drop_append_mode : 1;
5210 }
5211 DestRow;
5212
5213 static void
5214 dest_row_free (gpointer data)
5215 {
5216   DestRow *dr = (DestRow *)data;
5217
5218   gtk_tree_row_reference_free (dr->dest_row);
5219   g_slice_free (DestRow, dr);
5220 }
5221
5222 static void
5223 set_dest_row (GdkDragContext *context,
5224               GtkTreeModel   *model,
5225               GtkTreePath    *dest_row,
5226               gboolean        path_down_mode,
5227               gboolean        empty_view_drop,
5228               gboolean        drop_append_mode)
5229 {
5230   DestRow *dr;
5231
5232   if (!dest_row)
5233     {
5234       g_object_set_data_full (G_OBJECT (context), "gtk-tree-view-dest-row",
5235                               NULL, NULL);
5236       return;
5237     }
5238
5239   dr = g_slice_new (DestRow);
5240
5241   dr->dest_row = gtk_tree_row_reference_new (model, dest_row);
5242   dr->path_down_mode = path_down_mode != FALSE;
5243   dr->empty_view_drop = empty_view_drop != FALSE;
5244   dr->drop_append_mode = drop_append_mode != FALSE;
5245
5246   g_object_set_data_full (G_OBJECT (context), "gtk-tree-view-dest-row",
5247                           dr, (GDestroyNotify) dest_row_free);
5248 }
5249
5250 static GtkTreePath*
5251 get_dest_row (GdkDragContext *context,
5252               gboolean       *path_down_mode)
5253 {
5254   DestRow *dr =
5255     g_object_get_data (G_OBJECT (context), "gtk-tree-view-dest-row");
5256
5257   if (dr)
5258     {
5259       GtkTreePath *path = NULL;
5260
5261       if (path_down_mode)
5262         *path_down_mode = dr->path_down_mode;
5263
5264       if (dr->dest_row)
5265         path = gtk_tree_row_reference_get_path (dr->dest_row);
5266       else if (dr->empty_view_drop)
5267         path = gtk_tree_path_new_from_indices (0, -1);
5268       else
5269         path = NULL;
5270
5271       if (path && dr->drop_append_mode)
5272         gtk_tree_path_next (path);
5273
5274       return path;
5275     }
5276   else
5277     return NULL;
5278 }
5279
5280 /* Get/set whether drag_motion requested the drag data and
5281  * drag_data_received should thus not actually insert the data,
5282  * since the data doesn't result from a drop.
5283  */
5284 static void
5285 set_status_pending (GdkDragContext *context,
5286                     GdkDragAction   suggested_action)
5287 {
5288   g_object_set_data (G_OBJECT (context),
5289                      "gtk-tree-view-status-pending",
5290                      GINT_TO_POINTER (suggested_action));
5291 }
5292
5293 static GdkDragAction
5294 get_status_pending (GdkDragContext *context)
5295 {
5296   return GPOINTER_TO_INT (g_object_get_data (G_OBJECT (context),
5297                                              "gtk-tree-view-status-pending"));
5298 }
5299
5300 static TreeViewDragInfo*
5301 get_info (PsppSheetView *tree_view)
5302 {
5303   return g_object_get_data (G_OBJECT (tree_view), "gtk-tree-view-drag-info");
5304 }
5305
5306 static void
5307 destroy_info (TreeViewDragInfo *di)
5308 {
5309   g_slice_free (TreeViewDragInfo, di);
5310 }
5311
5312 static TreeViewDragInfo*
5313 ensure_info (PsppSheetView *tree_view)
5314 {
5315   TreeViewDragInfo *di;
5316
5317   di = get_info (tree_view);
5318
5319   if (di == NULL)
5320     {
5321       di = g_slice_new0 (TreeViewDragInfo);
5322
5323       g_object_set_data_full (G_OBJECT (tree_view),
5324                               "gtk-tree-view-drag-info",
5325                               di,
5326                               (GDestroyNotify) destroy_info);
5327     }
5328
5329   return di;
5330 }
5331
5332 static void
5333 remove_info (PsppSheetView *tree_view)
5334 {
5335   g_object_set_data (G_OBJECT (tree_view), "gtk-tree-view-drag-info", NULL);
5336 }
5337
5338 #if 0
5339 static gint
5340 drag_scan_timeout (gpointer data)
5341 {
5342   PsppSheetView *tree_view;
5343   gint x, y;
5344   GdkModifierType state;
5345   GtkTreePath *path = NULL;
5346   PsppSheetViewColumn *column = NULL;
5347   GdkRectangle visible_rect;
5348
5349   GDK_THREADS_ENTER ();
5350
5351   tree_view = PSPP_SHEET_VIEW (data);
5352
5353   gdk_window_get_pointer (tree_view->priv->bin_window,
5354                           &x, &y, &state);
5355
5356   pspp_sheet_view_get_visible_rect (tree_view, &visible_rect);
5357
5358   /* See if we are near the edge. */
5359   if ((x - visible_rect.x) < SCROLL_EDGE_SIZE ||
5360       (visible_rect.x + visible_rect.width - x) < SCROLL_EDGE_SIZE ||
5361       (y - visible_rect.y) < SCROLL_EDGE_SIZE ||
5362       (visible_rect.y + visible_rect.height - y) < SCROLL_EDGE_SIZE)
5363     {
5364       pspp_sheet_view_get_path_at_pos (tree_view,
5365                                      tree_view->priv->bin_window,
5366                                      x, y,
5367                                      &path,
5368                                      &column,
5369                                      NULL,
5370                                      NULL);
5371
5372       if (path != NULL)
5373         {
5374           pspp_sheet_view_scroll_to_cell (tree_view,
5375                                         path,
5376                                         column,
5377                                         TRUE,
5378                                         0.5, 0.5);
5379
5380           gtk_tree_path_free (path);
5381         }
5382     }
5383
5384   GDK_THREADS_LEAVE ();
5385
5386   return TRUE;
5387 }
5388 #endif /* 0 */
5389
5390 static void
5391 add_scroll_timeout (PsppSheetView *tree_view)
5392 {
5393   if (tree_view->priv->scroll_timeout == 0)
5394     {
5395       tree_view->priv->scroll_timeout =
5396         gdk_threads_add_timeout (150, scroll_row_timeout, tree_view);
5397     }
5398 }
5399
5400 static void
5401 remove_scroll_timeout (PsppSheetView *tree_view)
5402 {
5403   if (tree_view->priv->scroll_timeout != 0)
5404     {
5405       g_source_remove (tree_view->priv->scroll_timeout);
5406       tree_view->priv->scroll_timeout = 0;
5407     }
5408 }
5409
5410 static gboolean
5411 check_model_dnd (GtkTreeModel *model,
5412                  GType         required_iface,
5413                  const gchar  *signal)
5414 {
5415   if (model == NULL || !G_TYPE_CHECK_INSTANCE_TYPE ((model), required_iface))
5416     {
5417       g_warning ("You must override the default '%s' handler "
5418                  "on PsppSheetView when using models that don't support "
5419                  "the %s interface and enabling drag-and-drop. The simplest way to do this "
5420                  "is to connect to '%s' and call "
5421                  "g_signal_stop_emission_by_name() in your signal handler to prevent "
5422                  "the default handler from running. Look at the source code "
5423                  "for the default handler in gtktreeview.c to get an idea what "
5424                  "your handler should do. (gtktreeview.c is in the GTK source "
5425                  "code.) If you're using GTK from a language other than C, "
5426                  "there may be a more natural way to override default handlers, e.g. via derivation.",
5427                  signal, g_type_name (required_iface), signal);
5428       return FALSE;
5429     }
5430   else
5431     return TRUE;
5432 }
5433
5434 static gboolean
5435 scroll_row_timeout (gpointer data)
5436 {
5437   PsppSheetView *tree_view = data;
5438
5439   pspp_sheet_view_horizontal_autoscroll (tree_view);
5440   pspp_sheet_view_vertical_autoscroll (tree_view);
5441
5442   if (tree_view->priv->rubber_band_status == RUBBER_BAND_ACTIVE)
5443     pspp_sheet_view_update_rubber_band (tree_view);
5444
5445   return TRUE;
5446 }
5447
5448 /* Returns TRUE if event should not be propagated to parent widgets */
5449 static gboolean
5450 set_destination_row (PsppSheetView    *tree_view,
5451                      GdkDragContext *context,
5452                      /* coordinates relative to the widget */
5453                      gint            x,
5454                      gint            y,
5455                      GdkDragAction  *suggested_action,
5456                      GdkAtom        *target)
5457 {
5458   GtkTreePath *path = NULL;
5459   PsppSheetViewDropPosition pos;
5460   PsppSheetViewDropPosition old_pos;
5461   TreeViewDragInfo *di;
5462   GtkWidget *widget;
5463   GtkTreePath *old_dest_path = NULL;
5464   gboolean can_drop = FALSE;
5465
5466   *suggested_action = 0;
5467   *target = GDK_NONE;
5468
5469   widget = GTK_WIDGET (tree_view);
5470
5471   di = get_info (tree_view);
5472
5473   if (di == NULL || y - TREE_VIEW_HEADER_HEIGHT (tree_view) < 0)
5474     {
5475       /* someone unset us as a drag dest, note that if
5476        * we return FALSE drag_leave isn't called
5477        */
5478
5479       pspp_sheet_view_set_drag_dest_row (tree_view,
5480                                        NULL,
5481                                        PSPP_SHEET_VIEW_DROP_BEFORE);
5482
5483       remove_scroll_timeout (PSPP_SHEET_VIEW (widget));
5484
5485       return FALSE; /* no longer a drop site */
5486     }
5487
5488   *target = gtk_drag_dest_find_target (widget, context,
5489                                        gtk_drag_dest_get_target_list (widget));
5490   if (*target == GDK_NONE)
5491     {
5492       return FALSE;
5493     }
5494
5495   if (!pspp_sheet_view_get_dest_row_at_pos (tree_view,
5496                                           x, y,
5497                                           &path,
5498                                           &pos))
5499     {
5500       gint n_children;
5501       GtkTreeModel *model;
5502
5503       /* the row got dropped on empty space, let's setup a special case
5504        */
5505
5506       if (path)
5507         gtk_tree_path_free (path);
5508
5509       model = pspp_sheet_view_get_model (tree_view);
5510
5511       n_children = gtk_tree_model_iter_n_children (model, NULL);
5512       if (n_children)
5513         {
5514           pos = PSPP_SHEET_VIEW_DROP_AFTER;
5515           path = gtk_tree_path_new_from_indices (n_children - 1, -1);
5516         }
5517       else
5518         {
5519           pos = PSPP_SHEET_VIEW_DROP_BEFORE;
5520           path = gtk_tree_path_new_from_indices (0, -1);
5521         }
5522
5523       can_drop = TRUE;
5524
5525       goto out;
5526     }
5527
5528   g_assert (path);
5529
5530   /* If we left the current row's "open" zone, unset the timeout for
5531    * opening the row
5532    */
5533   pspp_sheet_view_get_drag_dest_row (tree_view,
5534                                    &old_dest_path,
5535                                    &old_pos);
5536
5537   if (old_dest_path)
5538     gtk_tree_path_free (old_dest_path);
5539
5540   if (TRUE /* FIXME if the location droppable predicate */)
5541     {
5542       can_drop = TRUE;
5543     }
5544
5545 out:
5546   if (can_drop)
5547     {
5548       GtkWidget *source_widget;
5549
5550       *suggested_action = gdk_drag_context_get_suggested_action (context);
5551       source_widget = gtk_drag_get_source_widget (context);
5552
5553       if (source_widget == widget)
5554         {
5555           /* Default to MOVE, unless the user has
5556            * pressed ctrl or shift to affect available actions
5557            */
5558           if ((gdk_drag_context_get_actions (context) & GDK_ACTION_MOVE) != 0)
5559             *suggested_action = GDK_ACTION_MOVE;
5560         }
5561
5562       pspp_sheet_view_set_drag_dest_row (PSPP_SHEET_VIEW (widget),
5563                                        path, pos);
5564     }
5565   else
5566     {
5567       /* can't drop here */
5568       pspp_sheet_view_set_drag_dest_row (PSPP_SHEET_VIEW (widget),
5569                                        NULL,
5570                                        PSPP_SHEET_VIEW_DROP_BEFORE);
5571     }
5572
5573   if (path)
5574     gtk_tree_path_free (path);
5575
5576   return TRUE;
5577 }
5578
5579 static GtkTreePath*
5580 get_logical_dest_row (PsppSheetView *tree_view,
5581                       gboolean    *path_down_mode,
5582                       gboolean    *drop_append_mode)
5583 {
5584   /* adjust path to point to the row the drop goes in front of */
5585   GtkTreePath *path = NULL;
5586   PsppSheetViewDropPosition pos;
5587
5588   g_return_val_if_fail (path_down_mode != NULL, NULL);
5589   g_return_val_if_fail (drop_append_mode != NULL, NULL);
5590
5591   *path_down_mode = FALSE;
5592   *drop_append_mode = 0;
5593
5594   pspp_sheet_view_get_drag_dest_row (tree_view, &path, &pos);
5595
5596   if (path == NULL)
5597     return NULL;
5598
5599   if (pos == PSPP_SHEET_VIEW_DROP_BEFORE)
5600     ; /* do nothing */
5601   else if (pos == PSPP_SHEET_VIEW_DROP_INTO_OR_BEFORE ||
5602            pos == PSPP_SHEET_VIEW_DROP_INTO_OR_AFTER)
5603     *path_down_mode = TRUE;
5604   else
5605     {
5606       GtkTreeIter iter;
5607       GtkTreeModel *model = pspp_sheet_view_get_model (tree_view);
5608
5609       g_assert (pos == PSPP_SHEET_VIEW_DROP_AFTER);
5610
5611       if (!gtk_tree_model_get_iter (model, &iter, path) ||
5612           !gtk_tree_model_iter_next (model, &iter))
5613         *drop_append_mode = 1;
5614       else
5615         {
5616           *drop_append_mode = 0;
5617           gtk_tree_path_next (path);
5618         }
5619     }
5620
5621   return path;
5622 }
5623
5624 static gboolean
5625 pspp_sheet_view_maybe_begin_dragging_row (PsppSheetView      *tree_view,
5626                                         GdkEventMotion   *event)
5627 {
5628   GtkWidget *widget = GTK_WIDGET (tree_view);
5629   GdkDragContext *context;
5630   TreeViewDragInfo *di;
5631   GtkTreePath *path = NULL;
5632   gint button;
5633   gint cell_x, cell_y;
5634   GtkTreeModel *model;
5635   gboolean retval = FALSE;
5636
5637   di = get_info (tree_view);
5638
5639   if (di == NULL || !di->source_set)
5640     goto out;
5641
5642   if (tree_view->priv->pressed_button < 0)
5643     goto out;
5644
5645   if (!gtk_drag_check_threshold (widget,
5646                                  tree_view->priv->press_start_x,
5647                                  tree_view->priv->press_start_y,
5648                                  event->x, event->y))
5649     goto out;
5650
5651   model = pspp_sheet_view_get_model (tree_view);
5652
5653   if (model == NULL)
5654     goto out;
5655
5656   button = tree_view->priv->pressed_button;
5657   tree_view->priv->pressed_button = -1;
5658
5659   pspp_sheet_view_get_path_at_pos (tree_view,
5660                                  tree_view->priv->press_start_x,
5661                                  tree_view->priv->press_start_y,
5662                                  &path,
5663                                  NULL,
5664                                  &cell_x,
5665                                  &cell_y);
5666
5667   if (path == NULL)
5668     goto out;
5669
5670   if (!GTK_IS_TREE_DRAG_SOURCE (model) ||
5671       !gtk_tree_drag_source_row_draggable (GTK_TREE_DRAG_SOURCE (model),
5672                                            path))
5673     goto out;
5674
5675   if (!(GDK_BUTTON1_MASK << (button - 1) & di->start_button_mask))
5676     goto out;
5677
5678   /* Now we can begin the drag */
5679
5680   retval = TRUE;
5681
5682   context = gtk_drag_begin (widget,
5683                             gtk_drag_source_get_target_list (widget),
5684                             di->source_actions,
5685                             button,
5686                             (GdkEvent*)event);
5687
5688   set_source_row (context, model, path);
5689
5690  out:
5691   if (path)
5692     gtk_tree_path_free (path);
5693
5694   return retval;
5695 }
5696
5697
5698
5699 static void
5700 pspp_sheet_view_drag_begin (GtkWidget      *widget,
5701                           GdkDragContext *context)
5702 {
5703 }
5704
5705
5706 static void
5707 pspp_sheet_view_drag_end (GtkWidget      *widget,
5708                         GdkDragContext *context)
5709 {
5710   /* do nothing */
5711 }
5712
5713 /* Default signal implementations for the drag signals */
5714 static void
5715 pspp_sheet_view_drag_data_get (GtkWidget        *widget,
5716                              GdkDragContext   *context,
5717                              GtkSelectionData *selection_data,
5718                              guint             info,
5719                              guint             time)
5720 {
5721   PsppSheetView *tree_view;
5722   GtkTreeModel *model;
5723   TreeViewDragInfo *di;
5724   GtkTreePath *source_row;
5725
5726   tree_view = PSPP_SHEET_VIEW (widget);
5727
5728   model = pspp_sheet_view_get_model (tree_view);
5729
5730   if (model == NULL)
5731     return;
5732
5733   di = get_info (PSPP_SHEET_VIEW (widget));
5734
5735   if (di == NULL)
5736     return;
5737
5738   source_row = get_source_row (context);
5739
5740   if (source_row == NULL)
5741     return;
5742
5743   /* We can implement the GTK_TREE_MODEL_ROW target generically for
5744    * any model; for DragSource models there are some other targets
5745    * we also support.
5746    */
5747
5748   if (GTK_IS_TREE_DRAG_SOURCE (model) &&
5749       gtk_tree_drag_source_drag_data_get (GTK_TREE_DRAG_SOURCE (model),
5750                                           source_row,
5751                                           selection_data))
5752     goto done;
5753
5754   /* If drag_data_get does nothing, try providing row data. */
5755   if (gtk_selection_data_get_target (selection_data) == gdk_atom_intern_static_string ("GTK_TREE_MODEL_ROW"))
5756     {
5757       gtk_tree_set_row_drag_data (selection_data,
5758                                   model,
5759                                   source_row);
5760     }
5761
5762  done:
5763   gtk_tree_path_free (source_row);
5764 }
5765
5766
5767 static void
5768 pspp_sheet_view_drag_data_delete (GtkWidget      *widget,
5769                                 GdkDragContext *context)
5770 {
5771   TreeViewDragInfo *di;
5772   GtkTreeModel *model;
5773   PsppSheetView *tree_view;
5774   GtkTreePath *source_row;
5775
5776   tree_view = PSPP_SHEET_VIEW (widget);
5777   model = pspp_sheet_view_get_model (tree_view);
5778
5779   if (!check_model_dnd (model, GTK_TYPE_TREE_DRAG_SOURCE, "drag_data_delete"))
5780     return;
5781
5782   di = get_info (tree_view);
5783
5784   if (di == NULL)
5785     return;
5786
5787   source_row = get_source_row (context);
5788
5789   if (source_row == NULL)
5790     return;
5791
5792   gtk_tree_drag_source_drag_data_delete (GTK_TREE_DRAG_SOURCE (model),
5793                                          source_row);
5794
5795   gtk_tree_path_free (source_row);
5796
5797   set_source_row (context, NULL, NULL);
5798 }
5799
5800 static void
5801 pspp_sheet_view_drag_leave (GtkWidget      *widget,
5802                           GdkDragContext *context,
5803                           guint             time)
5804 {
5805   /* unset any highlight row */
5806   pspp_sheet_view_set_drag_dest_row (PSPP_SHEET_VIEW (widget),
5807                                    NULL,
5808                                    PSPP_SHEET_VIEW_DROP_BEFORE);
5809
5810   remove_scroll_timeout (PSPP_SHEET_VIEW (widget));
5811 }
5812
5813
5814 static gboolean
5815 pspp_sheet_view_drag_motion (GtkWidget        *widget,
5816                            GdkDragContext   *context,
5817                            /* coordinates relative to the widget */
5818                            gint              x,
5819                            gint              y,
5820                            guint             time)
5821 {
5822   gboolean empty;
5823   GtkTreePath *path = NULL;
5824   PsppSheetViewDropPosition pos;
5825   PsppSheetView *tree_view;
5826   GdkDragAction suggested_action = 0;
5827   GdkAtom target;
5828
5829   tree_view = PSPP_SHEET_VIEW (widget);
5830
5831   if (!set_destination_row (tree_view, context, x, y, &suggested_action, &target))
5832     return FALSE;
5833
5834   pspp_sheet_view_get_drag_dest_row (tree_view, &path, &pos);
5835
5836   /* we only know this *after* set_desination_row */
5837   empty = tree_view->priv->empty_view_drop;
5838
5839   if (path == NULL && !empty)
5840     {
5841       /* Can't drop here. */
5842       gdk_drag_status (context, 0, time);
5843     }
5844   else
5845     {
5846       if (tree_view->priv->open_dest_timeout == 0 &&
5847           (pos == PSPP_SHEET_VIEW_DROP_INTO_OR_AFTER ||
5848            pos == PSPP_SHEET_VIEW_DROP_INTO_OR_BEFORE))
5849         {
5850           /* Nothing. */
5851         }
5852       else
5853         {
5854           add_scroll_timeout (tree_view);
5855         }
5856
5857       if (target == gdk_atom_intern_static_string ("GTK_TREE_MODEL_ROW"))
5858         {
5859           /* Request data so we can use the source row when
5860            * determining whether to accept the drop
5861            */
5862           set_status_pending (context, suggested_action);
5863           gtk_drag_get_data (widget, context, target, time);
5864         }
5865       else
5866         {
5867           set_status_pending (context, 0);
5868           gdk_drag_status (context, suggested_action, time);
5869         }
5870     }
5871
5872   if (path)
5873     gtk_tree_path_free (path);
5874
5875   return TRUE;
5876 }
5877
5878
5879 static gboolean
5880 pspp_sheet_view_drag_drop (GtkWidget        *widget,
5881                          GdkDragContext   *context,
5882                          /* coordinates relative to the widget */
5883                          gint              x,
5884                          gint              y,
5885                          guint             time)
5886 {
5887   PsppSheetView *tree_view;
5888   GtkTreePath *path;
5889   GdkDragAction suggested_action = 0;
5890   GdkAtom target = GDK_NONE;
5891   TreeViewDragInfo *di;
5892   GtkTreeModel *model;
5893   gboolean path_down_mode;
5894   gboolean drop_append_mode;
5895
5896   tree_view = PSPP_SHEET_VIEW (widget);
5897
5898   model = pspp_sheet_view_get_model (tree_view);
5899
5900   remove_scroll_timeout (PSPP_SHEET_VIEW (widget));
5901
5902   di = get_info (tree_view);
5903
5904   if (di == NULL)
5905     return FALSE;
5906
5907   if (!check_model_dnd (model, GTK_TYPE_TREE_DRAG_DEST, "drag_drop"))
5908     return FALSE;
5909
5910   if (!set_destination_row (tree_view, context, x, y, &suggested_action, &target))
5911     return FALSE;
5912
5913   path = get_logical_dest_row (tree_view, &path_down_mode, &drop_append_mode);
5914
5915   if (target != GDK_NONE && path != NULL)
5916     {
5917       /* in case a motion had requested drag data, change things so we
5918        * treat drag data receives as a drop.
5919        */
5920       set_status_pending (context, 0);
5921       set_dest_row (context, model, path,
5922                     path_down_mode, tree_view->priv->empty_view_drop,
5923                     drop_append_mode);
5924     }
5925
5926   if (path)
5927     gtk_tree_path_free (path);
5928
5929   /* Unset this thing */
5930   pspp_sheet_view_set_drag_dest_row (PSPP_SHEET_VIEW (widget),
5931                                    NULL,
5932                                    PSPP_SHEET_VIEW_DROP_BEFORE);
5933
5934   if (target != GDK_NONE)
5935     {
5936       gtk_drag_get_data (widget, context, target, time);
5937       return TRUE;
5938     }
5939   else
5940     return FALSE;
5941 }
5942
5943 static void
5944 pspp_sheet_view_drag_data_received (GtkWidget        *widget,
5945                                   GdkDragContext   *context,
5946                                   /* coordinates relative to the widget */
5947                                   gint              x,
5948                                   gint              y,
5949                                   GtkSelectionData *selection_data,
5950                                   guint             info,
5951                                   guint             time)
5952 {
5953   GtkTreePath *path;
5954   TreeViewDragInfo *di;
5955   gboolean accepted = FALSE;
5956   GtkTreeModel *model;
5957   PsppSheetView *tree_view;
5958   GtkTreePath *dest_row;
5959   GdkDragAction suggested_action;
5960   gboolean path_down_mode;
5961   gboolean drop_append_mode;
5962
5963   tree_view = PSPP_SHEET_VIEW (widget);
5964
5965   model = pspp_sheet_view_get_model (tree_view);
5966
5967   if (!check_model_dnd (model, GTK_TYPE_TREE_DRAG_DEST, "drag_data_received"))
5968     return;
5969
5970   di = get_info (tree_view);
5971
5972   if (di == NULL)
5973     return;
5974
5975   suggested_action = get_status_pending (context);
5976
5977   if (suggested_action)
5978     {
5979       /* We are getting this data due to a request in drag_motion,
5980        * rather than due to a request in drag_drop, so we are just
5981        * supposed to call drag_status, not actually paste in the
5982        * data.
5983        */
5984       path = get_logical_dest_row (tree_view, &path_down_mode,
5985                                    &drop_append_mode);
5986
5987       if (path == NULL)
5988         suggested_action = 0;
5989       else if (path_down_mode)
5990         gtk_tree_path_down (path);
5991
5992       if (suggested_action)
5993         {
5994           if (!gtk_tree_drag_dest_row_drop_possible (GTK_TREE_DRAG_DEST (model),
5995                                                      path,
5996                                                      selection_data))
5997             {
5998               if (path_down_mode)
5999                 {
6000                   path_down_mode = FALSE;
6001                   gtk_tree_path_up (path);
6002
6003                   if (!gtk_tree_drag_dest_row_drop_possible (GTK_TREE_DRAG_DEST (model),
6004                                                              path,
6005                                                              selection_data))
6006                     suggested_action = 0;
6007                 }
6008               else
6009                 suggested_action = 0;
6010             }
6011         }
6012
6013       gdk_drag_status (context, suggested_action, time);
6014
6015       if (path)
6016         gtk_tree_path_free (path);
6017
6018       /* If you can't drop, remove user drop indicator until the next motion */
6019       if (suggested_action == 0)
6020         pspp_sheet_view_set_drag_dest_row (PSPP_SHEET_VIEW (widget),
6021                                          NULL,
6022                                          PSPP_SHEET_VIEW_DROP_BEFORE);
6023
6024       return;
6025     }
6026
6027   dest_row = get_dest_row (context, &path_down_mode);
6028
6029   if (dest_row == NULL)
6030     return;
6031
6032   if (gtk_selection_data_get_length (selection_data) >= 0)
6033     {
6034       if (path_down_mode)
6035         {
6036           gtk_tree_path_down (dest_row);
6037           if (!gtk_tree_drag_dest_row_drop_possible (GTK_TREE_DRAG_DEST (model),
6038                                                      dest_row, selection_data))
6039             gtk_tree_path_up (dest_row);
6040         }
6041     }
6042
6043   if (gtk_selection_data_get_length (selection_data) >= 0)
6044     {
6045       if (gtk_tree_drag_dest_drag_data_received (GTK_TREE_DRAG_DEST (model),
6046                                                  dest_row,
6047                                                  selection_data))
6048         accepted = TRUE;
6049     }
6050
6051   gtk_drag_finish (context,
6052                    accepted,
6053                    (gdk_drag_context_get_actions (context) == GDK_ACTION_MOVE),
6054                    time);
6055
6056   if (gtk_tree_path_get_depth (dest_row) == 1
6057       && gtk_tree_path_get_indices (dest_row)[0] == 0)
6058     {
6059       /* special special case drag to "0", scroll to first item */
6060       if (!tree_view->priv->scroll_to_path)
6061         pspp_sheet_view_scroll_to_cell (tree_view, dest_row, NULL, FALSE, 0.0, 0.0);
6062     }
6063
6064   gtk_tree_path_free (dest_row);
6065
6066   /* drop dest_row */
6067   set_dest_row (context, NULL, NULL, FALSE, FALSE, FALSE);
6068 }
6069
6070
6071
6072 /* GtkContainer Methods
6073  */
6074
6075
6076 static void
6077 pspp_sheet_view_remove (GtkContainer *container,
6078                       GtkWidget    *widget)
6079 {
6080   PsppSheetView *tree_view = PSPP_SHEET_VIEW (container);
6081   PsppSheetViewChild *child = NULL;
6082   GList *tmp_list;
6083
6084   tmp_list = tree_view->priv->children;
6085   while (tmp_list)
6086     {
6087       child = tmp_list->data;
6088       if (child->widget == widget)
6089         {
6090           gtk_widget_unparent (widget);
6091
6092           tree_view->priv->children = g_list_remove_link (tree_view->priv->children, tmp_list);
6093           g_list_free_1 (tmp_list);
6094           g_slice_free (PsppSheetViewChild, child);
6095           return;
6096         }
6097
6098       tmp_list = tmp_list->next;
6099     }
6100
6101   tmp_list = tree_view->priv->columns;
6102
6103   while (tmp_list)
6104     {
6105       PsppSheetViewColumn *column;
6106       column = tmp_list->data;
6107       if (column->button == widget)
6108         {
6109           gtk_widget_unparent (widget);
6110           return;
6111         }
6112       tmp_list = tmp_list->next;
6113     }
6114 }
6115
6116 static void
6117 pspp_sheet_view_forall (GtkContainer *container,
6118                       gboolean      include_internals,
6119                       GtkCallback   callback,
6120                       gpointer      callback_data)
6121 {
6122   PsppSheetView *tree_view = PSPP_SHEET_VIEW (container);
6123   PsppSheetViewChild *child = NULL;
6124   PsppSheetViewColumn *column;
6125   GList *tmp_list;
6126
6127   tmp_list = tree_view->priv->children;
6128   while (tmp_list)
6129     {
6130       child = tmp_list->data;
6131       tmp_list = tmp_list->next;
6132
6133       (* callback) (child->widget, callback_data);
6134     }
6135   if (include_internals == FALSE)
6136     return;
6137
6138   for (tmp_list = tree_view->priv->columns; tmp_list; tmp_list = tmp_list->next)
6139     {
6140       column = tmp_list->data;
6141
6142       if (column->button)
6143         (* callback) (column->button, callback_data);
6144     }
6145 }
6146
6147 /* Returns TRUE if the treeview contains no "special" (editable or activatable)
6148  * cells. If so we draw one big row-spanning focus rectangle.
6149  */
6150 static gboolean
6151 pspp_sheet_view_has_special_cell (PsppSheetView *tree_view)
6152 {
6153   GList *list;
6154
6155   if (tree_view->priv->special_cells != PSPP_SHEET_VIEW_SPECIAL_CELLS_DETECT)
6156     return tree_view->priv->special_cells = PSPP_SHEET_VIEW_SPECIAL_CELLS_YES;
6157
6158   for (list = tree_view->priv->columns; list; list = list->next)
6159     {
6160       if (!((PsppSheetViewColumn *)list->data)->visible)
6161         continue;
6162       if (_pspp_sheet_view_column_count_special_cells (list->data))
6163         return TRUE;
6164     }
6165
6166   return FALSE;
6167 }
6168
6169 static void
6170 pspp_sheet_view_focus_column (PsppSheetView *tree_view,
6171                               PsppSheetViewColumn *focus_column,
6172                               gboolean clamp_column_visible)
6173 {
6174   g_return_if_fail (focus_column != NULL);
6175
6176   tree_view->priv->focus_column = focus_column;
6177
6178   if (gtk_container_get_focus_child (GTK_CONTAINER (tree_view)) != focus_column->button)
6179     gtk_widget_grab_focus (focus_column->button);
6180
6181   if (clamp_column_visible)
6182     pspp_sheet_view_clamp_column_visible (tree_view, focus_column, FALSE);
6183 }
6184
6185 /* Returns TRUE if the focus is within the headers, after the focus operation is
6186  * done
6187  */
6188 static gboolean
6189 pspp_sheet_view_header_focus (PsppSheetView      *tree_view,
6190                             GtkDirectionType  dir,
6191                             gboolean          clamp_column_visible)
6192 {
6193   GtkWidget *focus_child;
6194   PsppSheetViewColumn *focus_column;
6195   GList *last_column, *first_column;
6196   GList *tmp_list;
6197   gboolean rtl;
6198
6199   if (! PSPP_SHEET_VIEW_FLAG_SET (tree_view, PSPP_SHEET_VIEW_HEADERS_VISIBLE))
6200     return FALSE;
6201
6202   focus_child = gtk_container_get_focus_child (GTK_CONTAINER (tree_view));
6203
6204   first_column = tree_view->priv->columns;
6205   while (first_column)
6206     {
6207       PsppSheetViewColumn *c = PSPP_SHEET_VIEW_COLUMN (first_column->data);
6208
6209       if (pspp_sheet_view_column_can_focus (c) && c->visible)
6210         break;
6211       first_column = first_column->next;
6212     }
6213
6214   /* No headers are visible, or are focusable.  We can't focus in or out.
6215    */
6216   if (first_column == NULL)
6217     return FALSE;
6218
6219   last_column = g_list_last (tree_view->priv->columns);
6220   while (last_column)
6221     {
6222       PsppSheetViewColumn *c = PSPP_SHEET_VIEW_COLUMN (last_column->data);
6223
6224       if (pspp_sheet_view_column_can_focus (c) && c->visible)
6225         break;
6226       last_column = last_column->prev;
6227     }
6228
6229
6230   rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
6231
6232   switch (dir)
6233     {
6234     case GTK_DIR_TAB_BACKWARD:
6235     case GTK_DIR_TAB_FORWARD:
6236     case GTK_DIR_UP:
6237     case GTK_DIR_DOWN:
6238       if (focus_child == NULL)
6239         {
6240           if (tree_view->priv->focus_column != NULL &&
6241               pspp_sheet_view_column_can_focus (tree_view->priv->focus_column))
6242             focus_column = tree_view->priv->focus_column;
6243           else
6244             focus_column = first_column->data;
6245           pspp_sheet_view_focus_column (tree_view, focus_column,
6246                                         clamp_column_visible);
6247           return TRUE;
6248         }
6249       return FALSE;
6250
6251     case GTK_DIR_LEFT:
6252     case GTK_DIR_RIGHT:
6253       if (focus_child == NULL)
6254         {
6255           if (tree_view->priv->focus_column != NULL)
6256             focus_column = tree_view->priv->focus_column;
6257           else if (dir == GTK_DIR_LEFT)
6258             focus_column = last_column->data;
6259           else
6260             focus_column = first_column->data;
6261           pspp_sheet_view_focus_column (tree_view, focus_column,
6262                                         clamp_column_visible);
6263           return TRUE;
6264         }
6265
6266       if (gtk_widget_child_focus (focus_child, dir))
6267         {
6268           /* The focus moves inside the button. */
6269           /* This is probably a great example of bad UI */
6270           if (clamp_column_visible)
6271             pspp_sheet_view_clamp_column_visible (tree_view,
6272                                                   tree_view->priv->focus_column,
6273                                                   FALSE);
6274           return TRUE;
6275         }
6276
6277       /* We need to move the focus among the row of buttons. */
6278       for (tmp_list = tree_view->priv->columns; tmp_list; tmp_list = tmp_list->next)
6279         if (PSPP_SHEET_VIEW_COLUMN (tmp_list->data)->button == focus_child)
6280           break;
6281
6282       if ((tmp_list == first_column && dir == (rtl ? GTK_DIR_RIGHT : GTK_DIR_LEFT))
6283           || (tmp_list == last_column && dir == (rtl ? GTK_DIR_LEFT : GTK_DIR_RIGHT)))
6284         {
6285           gtk_widget_error_bell (GTK_WIDGET (tree_view));
6286           return TRUE;
6287         }
6288
6289       while (tmp_list)
6290         {
6291           PsppSheetViewColumn *column;
6292
6293           if (dir == (rtl ? GTK_DIR_LEFT : GTK_DIR_RIGHT))
6294             tmp_list = tmp_list->next;
6295           else
6296             tmp_list = tmp_list->prev;
6297
6298           if (tmp_list == NULL)
6299             {
6300               g_warning ("Internal button not found");
6301               break;
6302             }
6303           column = tmp_list->data;
6304           if (column->visible &&
6305               pspp_sheet_view_column_can_focus (column))
6306             {
6307               if (column->button)
6308                 {
6309                   pspp_sheet_view_focus_column (tree_view, column,
6310                                                 clamp_column_visible);
6311                   return TRUE;
6312                 }
6313             }
6314         }
6315       return FALSE;
6316
6317     default:
6318       g_assert_not_reached ();
6319       break;
6320     }
6321
6322   return FALSE;
6323 }
6324
6325 /* This function returns in 'path' the first focusable path, if the given path
6326  * is already focusable, it's the returned one.
6327  *
6328  */
6329 static gboolean
6330 search_first_focusable_path (PsppSheetView  *tree_view,
6331                              GtkTreePath **path,
6332                              gboolean      search_forward,
6333                              int *new_node)
6334 {
6335   /* XXX this function is trivial given that the sheetview doesn't support
6336      separator rows */
6337   int node = -1;
6338
6339   if (!path || !*path)
6340     return FALSE;
6341
6342   _pspp_sheet_view_find_node (tree_view, *path, &node);
6343
6344   if (node < 0)
6345     return FALSE;
6346
6347   if (new_node)
6348     *new_node = node;
6349
6350   return (*path != NULL);
6351 }
6352
6353 static gint
6354 pspp_sheet_view_focus (GtkWidget        *widget,
6355                      GtkDirectionType  direction)
6356 {
6357   PsppSheetView *tree_view = PSPP_SHEET_VIEW (widget);
6358   GtkContainer *container = GTK_CONTAINER (widget);
6359   GtkWidget *focus_child;
6360
6361   if (!gtk_widget_is_sensitive (widget) || !gtk_widget_get_can_focus (widget))
6362     return FALSE;
6363
6364   focus_child = gtk_container_get_focus_child (container);
6365
6366   pspp_sheet_view_stop_editing (PSPP_SHEET_VIEW (widget), FALSE);
6367   /* Case 1.  Headers currently have focus. */
6368   if (focus_child)
6369     {
6370       switch (direction)
6371         {
6372         case GTK_DIR_LEFT:
6373         case GTK_DIR_RIGHT:
6374           pspp_sheet_view_header_focus (tree_view, direction, TRUE);
6375           return TRUE;
6376         case GTK_DIR_TAB_BACKWARD:
6377         case GTK_DIR_UP:
6378           return FALSE;
6379         case GTK_DIR_TAB_FORWARD:
6380         case GTK_DIR_DOWN:
6381           gtk_widget_grab_focus (widget);
6382           return TRUE;
6383         default:
6384           g_assert_not_reached ();
6385           return FALSE;
6386         }
6387     }
6388
6389   /* Case 2. We don't have focus at all. */
6390   if (!gtk_widget_has_focus (widget))
6391     {
6392       if (!pspp_sheet_view_header_focus (tree_view, direction, FALSE))
6393         gtk_widget_grab_focus (widget);
6394       return TRUE;
6395     }
6396
6397   /* Case 3. We have focus already. */
6398   if (direction == GTK_DIR_TAB_BACKWARD)
6399     return (pspp_sheet_view_header_focus (tree_view, direction, FALSE));
6400   else if (direction == GTK_DIR_TAB_FORWARD)
6401     return FALSE;
6402
6403   /* Other directions caught by the keybindings */
6404   gtk_widget_grab_focus (widget);
6405   return TRUE;
6406 }
6407
6408 static void
6409 pspp_sheet_view_grab_focus (GtkWidget *widget)
6410 {
6411   GTK_WIDGET_CLASS (pspp_sheet_view_parent_class)->grab_focus (widget);
6412
6413   pspp_sheet_view_focus_to_cursor (PSPP_SHEET_VIEW (widget));
6414 }
6415
6416 static void
6417 pspp_sheet_view_style_updated (GtkWidget *widget)
6418 {
6419   PsppSheetView *tree_view = PSPP_SHEET_VIEW (widget);
6420   GList *list;
6421   PsppSheetViewColumn *column;
6422   GtkStyleContext *context;
6423
6424   GTK_WIDGET_CLASS (pspp_sheet_view_parent_class)->style_updated (widget);
6425
6426   if (gtk_widget_get_realized (widget))
6427     {
6428       context = gtk_widget_get_style_context (GTK_WIDGET (tree_view));
6429       gtk_style_context_set_background (context, gtk_widget_get_window (GTK_WIDGET (tree_view)));
6430       gtk_style_context_set_background (context, tree_view->priv->header_window);
6431       pspp_sheet_view_set_grid_lines (tree_view, tree_view->priv->grid_lines);
6432     }
6433
6434   gtk_widget_style_get (widget,
6435                         "expander-size", &tree_view->priv->expander_size,
6436                         NULL);
6437   tree_view->priv->expander_size += EXPANDER_EXTRA_PADDING;
6438
6439   for (list = tree_view->priv->columns; list; list = list->next)
6440     {
6441       column = list->data;
6442       _pspp_sheet_view_column_cell_set_dirty (column);
6443     }
6444
6445   tree_view->priv->fixed_height = -1;
6446
6447   /* Invalidate cached button style. */
6448   if (tree_view->priv->button_style)
6449     {
6450       g_object_unref (tree_view->priv->button_style);
6451       tree_view->priv->button_style = NULL;
6452     }
6453
6454   gtk_widget_queue_resize (widget);
6455 }
6456
6457
6458 static void
6459 pspp_sheet_view_set_focus_child (GtkContainer *container,
6460                                GtkWidget    *child)
6461 {
6462   PsppSheetView *tree_view = PSPP_SHEET_VIEW (container);
6463   GList *list;
6464
6465   for (list = tree_view->priv->columns; list; list = list->next)
6466     {
6467       if (PSPP_SHEET_VIEW_COLUMN (list->data)->button == child)
6468         {
6469           tree_view->priv->focus_column = PSPP_SHEET_VIEW_COLUMN (list->data);
6470           break;
6471         }
6472     }
6473
6474   GTK_CONTAINER_CLASS (pspp_sheet_view_parent_class)->set_focus_child (container, child);
6475 }
6476
6477 static void
6478 pspp_sheet_view_set_adjustments (PsppSheetView   *tree_view,
6479                                GtkAdjustment *hadj,
6480                                GtkAdjustment *vadj)
6481 {
6482   gboolean need_adjust = FALSE;
6483
6484   g_return_if_fail (PSPP_IS_SHEET_VIEW (tree_view));
6485
6486   if (hadj)
6487     g_return_if_fail (GTK_IS_ADJUSTMENT (hadj));
6488   else
6489     hadj = GTK_ADJUSTMENT (gtk_adjustment_new (0.0, 0.0, 0.0, 0.0, 0.0, 0.0));
6490   if (vadj)
6491     g_return_if_fail (GTK_IS_ADJUSTMENT (vadj));
6492   else
6493     vadj = GTK_ADJUSTMENT (gtk_adjustment_new (0.0, 0.0, 0.0, 0.0, 0.0, 0.0));
6494
6495   if (tree_view->priv->hadjustment && (tree_view->priv->hadjustment != hadj))
6496     {
6497       g_signal_handlers_disconnect_by_func (tree_view->priv->hadjustment,
6498                                             pspp_sheet_view_adjustment_changed,
6499                                             tree_view);
6500       g_object_unref (tree_view->priv->hadjustment);
6501     }
6502
6503   if (tree_view->priv->vadjustment && (tree_view->priv->vadjustment != vadj))
6504     {
6505       g_signal_handlers_disconnect_by_func (tree_view->priv->vadjustment,
6506                                             pspp_sheet_view_adjustment_changed,
6507                                             tree_view);
6508       g_object_unref (tree_view->priv->vadjustment);
6509     }
6510
6511   if (tree_view->priv->hadjustment != hadj)
6512     {
6513       tree_view->priv->hadjustment = hadj;
6514       g_object_ref_sink (tree_view->priv->hadjustment);
6515
6516       g_signal_connect (tree_view->priv->hadjustment, "value-changed",
6517                         G_CALLBACK (pspp_sheet_view_adjustment_changed),
6518                         tree_view);
6519       need_adjust = TRUE;
6520     }
6521
6522   if (tree_view->priv->vadjustment != vadj)
6523     {
6524       tree_view->priv->vadjustment = vadj;
6525       g_object_ref_sink (tree_view->priv->vadjustment);
6526
6527       g_signal_connect (tree_view->priv->vadjustment, "value-changed",
6528                         G_CALLBACK (pspp_sheet_view_adjustment_changed),
6529                         tree_view);
6530       need_adjust = TRUE;
6531     }
6532
6533   if (need_adjust)
6534     pspp_sheet_view_adjustment_changed (NULL, tree_view);
6535 }
6536
6537
6538 static gboolean
6539 pspp_sheet_view_real_move_cursor (PsppSheetView       *tree_view,
6540                                 GtkMovementStep    step,
6541                                 gint               count)
6542 {
6543   PsppSheetSelectMode mode;
6544   GdkModifierType state;
6545
6546   g_return_val_if_fail (PSPP_IS_SHEET_VIEW (tree_view), FALSE);
6547   g_return_val_if_fail (step == GTK_MOVEMENT_LOGICAL_POSITIONS ||
6548                         step == GTK_MOVEMENT_VISUAL_POSITIONS ||
6549                         step == GTK_MOVEMENT_DISPLAY_LINES ||
6550                         step == GTK_MOVEMENT_PAGES ||
6551                         step == GTK_MOVEMENT_BUFFER_ENDS ||
6552                         step == GTK_MOVEMENT_DISPLAY_LINE_ENDS, FALSE);
6553
6554   if (tree_view->priv->row_count == 0)
6555     return FALSE;
6556   if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
6557     return FALSE;
6558
6559   pspp_sheet_view_stop_editing (tree_view, FALSE);
6560   PSPP_SHEET_VIEW_SET_FLAG (tree_view, PSPP_SHEET_VIEW_DRAW_KEYFOCUS);
6561   gtk_widget_grab_focus (GTK_WIDGET (tree_view));
6562
6563   mode = 0;
6564   if (gtk_get_current_event_state (&state))
6565     {
6566       if ((state & GDK_CONTROL_MASK) == GDK_CONTROL_MASK)
6567         mode |= PSPP_SHEET_SELECT_MODE_TOGGLE;
6568       if ((state & GDK_SHIFT_MASK) == GDK_SHIFT_MASK)
6569         mode |= PSPP_SHEET_SELECT_MODE_EXTEND;
6570     }
6571   /* else we assume not pressed */
6572
6573   switch (step)
6574     {
6575     case GTK_MOVEMENT_LOGICAL_POSITIONS:
6576       pspp_sheet_view_move_cursor_tab (tree_view, count);
6577       break;
6578     case GTK_MOVEMENT_VISUAL_POSITIONS:
6579       pspp_sheet_view_move_cursor_left_right (tree_view, count, mode);
6580       break;
6581     case GTK_MOVEMENT_DISPLAY_LINES:
6582       pspp_sheet_view_move_cursor_up_down (tree_view, count, mode);
6583       break;
6584     case GTK_MOVEMENT_PAGES:
6585       pspp_sheet_view_move_cursor_page_up_down (tree_view, count, mode);
6586       break;
6587     case GTK_MOVEMENT_BUFFER_ENDS:
6588       pspp_sheet_view_move_cursor_start_end (tree_view, count, mode);
6589       break;
6590     case GTK_MOVEMENT_DISPLAY_LINE_ENDS:
6591       pspp_sheet_view_move_cursor_line_start_end (tree_view, count, mode);
6592       break;
6593     default:
6594       g_assert_not_reached ();
6595     }
6596
6597   return TRUE;
6598 }
6599
6600 static void
6601 pspp_sheet_view_put (PsppSheetView *tree_view,
6602                      GtkWidget   *child_widget,
6603                      GtkTreePath *path,
6604                      PsppSheetViewColumn *column)
6605 {
6606   PsppSheetViewChild *child;
6607
6608   g_return_if_fail (PSPP_IS_SHEET_VIEW (tree_view));
6609   g_return_if_fail (GTK_IS_WIDGET (child_widget));
6610
6611   child = g_slice_new (PsppSheetViewChild);
6612
6613   child->widget = child_widget;
6614   _pspp_sheet_view_find_node (tree_view, path, &child->node);
6615   if (child->node < 0)
6616     {
6617       g_assert_not_reached ();
6618     }
6619   child->column = column;
6620
6621   tree_view->priv->children = g_list_append (tree_view->priv->children, child);
6622
6623   if (gtk_widget_get_realized (GTK_WIDGET (tree_view)))
6624     gtk_widget_set_parent_window (child->widget, tree_view->priv->bin_window);
6625
6626   gtk_widget_set_parent (child_widget, GTK_WIDGET (tree_view));
6627 }
6628
6629 /* TreeModel Callbacks
6630  */
6631
6632 static void
6633 pspp_sheet_view_row_changed (GtkTreeModel *model,
6634                            GtkTreePath  *path,
6635                            GtkTreeIter  *iter,
6636                            gpointer      data)
6637 {
6638   PsppSheetView *tree_view = (PsppSheetView *)data;
6639   int node;
6640   gboolean free_path = FALSE;
6641   GtkTreePath *cursor_path;
6642
6643   g_return_if_fail (path != NULL || iter != NULL);
6644
6645   if (tree_view->priv->cursor != NULL)
6646     cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
6647   else
6648     cursor_path = NULL;
6649
6650   if (tree_view->priv->edited_column &&
6651       (cursor_path == NULL || gtk_tree_path_compare (cursor_path, path) == 0))
6652     pspp_sheet_view_stop_editing (tree_view, TRUE);
6653
6654   if (cursor_path != NULL)
6655     gtk_tree_path_free (cursor_path);
6656
6657   if (path == NULL)
6658     {
6659       path = gtk_tree_model_get_path (model, iter);
6660       free_path = TRUE;
6661     }
6662   else if (iter == NULL)
6663     gtk_tree_model_get_iter (model, iter, path);
6664
6665   _pspp_sheet_view_find_node (tree_view,
6666                               path,
6667                               &node);
6668
6669   if (node >= 0)
6670     {
6671       if (gtk_widget_get_realized (GTK_WIDGET (tree_view)))
6672         pspp_sheet_view_node_queue_redraw (tree_view, node);
6673     }
6674
6675   if (free_path)
6676     gtk_tree_path_free (path);
6677 }
6678
6679 static void
6680 pspp_sheet_view_row_inserted (GtkTreeModel *model,
6681                             GtkTreePath  *path,
6682                             GtkTreeIter  *iter,
6683                             gpointer      data)
6684 {
6685   PsppSheetView *tree_view = (PsppSheetView *) data;
6686   gint *indices;
6687   int tmpnode = -1;
6688   gint height = tree_view->priv->fixed_height;
6689   gboolean free_path = FALSE;
6690   gboolean node_visible = TRUE;
6691
6692   g_return_if_fail (path != NULL || iter != NULL);
6693
6694   if (path == NULL)
6695     {
6696       path = gtk_tree_model_get_path (model, iter);
6697       free_path = TRUE;
6698     }
6699   else if (iter == NULL)
6700     gtk_tree_model_get_iter (model, iter, path);
6701
6702   tree_view->priv->row_count = gtk_tree_model_iter_n_children (model, NULL);
6703
6704   /* Update all row-references */
6705   gtk_tree_row_reference_inserted (G_OBJECT (data), path);
6706   indices = gtk_tree_path_get_indices (path);
6707   tmpnode = indices[0];
6708
6709   range_tower_insert0 (tree_view->priv->selected, tmpnode, 1);
6710
6711   if (height > 0)
6712     {
6713       if (node_visible && node_is_visible (tree_view, tmpnode))
6714         gtk_widget_queue_resize (GTK_WIDGET (tree_view));
6715       else
6716         gtk_widget_queue_resize_no_redraw (GTK_WIDGET (tree_view));
6717     }
6718   else
6719     install_presize_handler (tree_view);
6720   if (free_path)
6721     gtk_tree_path_free (path);
6722 }
6723
6724 static void
6725 pspp_sheet_view_row_deleted (GtkTreeModel *model,
6726                            GtkTreePath  *path,
6727                            gpointer      data)
6728 {
6729   PsppSheetView *tree_view = (PsppSheetView *)data;
6730   int node;
6731
6732   g_return_if_fail (path != NULL);
6733
6734   gtk_tree_row_reference_deleted (G_OBJECT (data), path);
6735
6736   _pspp_sheet_view_find_node (tree_view, path, &node);
6737
6738   if (node < 0)
6739     return;
6740
6741   range_tower_delete (tree_view->priv->selected, node, 1);
6742
6743   /* Ensure we don't have a dangling pointer to a dead node */
6744   ensure_unprelighted (tree_view);
6745
6746   /* Cancel editting if we've started */
6747   pspp_sheet_view_stop_editing (tree_view, TRUE);
6748
6749   if (tree_view->priv->destroy_count_func)
6750     {
6751       gint child_count = 0;
6752       tree_view->priv->destroy_count_func (tree_view, path, child_count, tree_view->priv->destroy_count_data);
6753     }
6754
6755   tree_view->priv->row_count = gtk_tree_model_iter_n_children (model, NULL);
6756
6757   if (! gtk_tree_row_reference_valid (tree_view->priv->top_row))
6758     {
6759       gtk_tree_row_reference_free (tree_view->priv->top_row);
6760       tree_view->priv->top_row = NULL;
6761     }
6762
6763   install_scroll_sync_handler (tree_view);
6764
6765   gtk_widget_queue_resize (GTK_WIDGET (tree_view));
6766
6767 #if 0
6768   if (helper_data.changed)
6769     g_signal_emit_by_name (tree_view->priv->selection, "changed");
6770 #endif
6771 }
6772
6773 static void
6774 pspp_sheet_view_rows_reordered (GtkTreeModel *model,
6775                               GtkTreePath  *parent,
6776                               GtkTreeIter  *iter,
6777                               gint         *new_order,
6778                               gpointer      data)
6779 {
6780   PsppSheetView *tree_view = PSPP_SHEET_VIEW (data);
6781   gint len;
6782
6783   /* XXX need to adjust selection */
6784   len = gtk_tree_model_iter_n_children (model, iter);
6785
6786   if (len < 2)
6787     return;
6788
6789   gtk_tree_row_reference_reordered (G_OBJECT (data),
6790                                     parent,
6791                                     iter,
6792                                     new_order);
6793
6794   if (gtk_tree_path_get_depth (parent) != 0)
6795     return;
6796
6797   if (tree_view->priv->edited_column)
6798     pspp_sheet_view_stop_editing (tree_view, TRUE);
6799
6800   /* we need to be unprelighted */
6801   ensure_unprelighted (tree_view);
6802
6803   gtk_widget_queue_draw (GTK_WIDGET (tree_view));
6804
6805   pspp_sheet_view_dy_to_top_row (tree_view);
6806 }
6807
6808
6809 /* Internal tree functions
6810  */
6811
6812
6813 static void
6814 pspp_sheet_view_get_background_xrange (PsppSheetView       *tree_view,
6815                                      PsppSheetViewColumn *column,
6816                                      gint              *x1,
6817                                      gint              *x2)
6818 {
6819   PsppSheetViewColumn *tmp_column = NULL;
6820   gint total_width;
6821   GList *list;
6822   gboolean rtl;
6823
6824   if (x1)
6825     *x1 = 0;
6826
6827   if (x2)
6828     *x2 = 0;
6829
6830   rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
6831
6832   total_width = 0;
6833   for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns));
6834        list;
6835        list = (rtl ? list->prev : list->next))
6836     {
6837       tmp_column = list->data;
6838
6839       if (tmp_column == column)
6840         break;
6841
6842       if (tmp_column->visible)
6843         total_width += tmp_column->width;
6844     }
6845
6846   if (tmp_column != column)
6847     {
6848       g_warning (G_STRLOC": passed-in column isn't in the tree");
6849       return;
6850     }
6851
6852   if (x1)
6853     *x1 = total_width;
6854
6855   if (x2)
6856     {
6857       if (column->visible)
6858         *x2 = total_width + column->width;
6859       else
6860         *x2 = total_width; /* width of 0 */
6861     }
6862 }
6863
6864 /* Make sure the node is visible vertically */
6865 static void
6866 pspp_sheet_view_clamp_node_visible (PsppSheetView *tree_view,
6867                                     int node)
6868 {
6869   gint node_dy, height;
6870   GtkTreePath *path = NULL;
6871
6872   if (!gtk_widget_get_realized (GTK_WIDGET (tree_view)))
6873     return;
6874
6875   /* just return if the node is visible, avoiding a costly expose */
6876   node_dy = pspp_sheet_view_node_find_offset (tree_view, node);
6877   height = ROW_HEIGHT (tree_view);
6878   if (node_dy >= gtk_adjustment_get_value (tree_view->priv->vadjustment)
6879       && node_dy + height <= (gtk_adjustment_get_value (tree_view->priv->vadjustment)
6880                               + gtk_adjustment_get_page_size (tree_view->priv->vadjustment)))
6881     return;
6882
6883   path = _pspp_sheet_view_find_path (tree_view, node);
6884   if (path)
6885     {
6886       /* We process updates because we want to clear old selected items when we scroll.
6887        * if this is removed, we get a "selection streak" at the bottom. */
6888       gdk_window_process_updates (tree_view->priv->bin_window, TRUE);
6889       pspp_sheet_view_scroll_to_cell (tree_view, path, NULL, FALSE, 0.0, 0.0);
6890       gtk_tree_path_free (path);
6891     }
6892 }
6893
6894 static void
6895 pspp_sheet_view_clamp_column_visible (PsppSheetView       *tree_view,
6896                                     PsppSheetViewColumn *column,
6897                                     gboolean           focus_to_cell)
6898 {
6899   gint x, width;
6900
6901   if (column == NULL)
6902     return;
6903
6904   x = column->allocation.x;
6905   width = column->allocation.width;
6906
6907   if (width > gtk_adjustment_get_page_size (tree_view->priv->hadjustment))
6908     {
6909       /* The column is larger than the horizontal page size.  If the
6910        * column has cells which can be focussed individually, then we make
6911        * sure the cell which gets focus is fully visible (if even the
6912        * focus cell is bigger than the page size, we make sure the
6913        * left-hand side of the cell is visible).
6914        *
6915        * If the column does not have those so-called special cells, we
6916        * make sure the left-hand side of the column is visible.
6917        */
6918
6919       if (focus_to_cell && pspp_sheet_view_has_special_cell (tree_view))
6920         {
6921           GtkTreePath *cursor_path;
6922           GdkRectangle background_area, cell_area, focus_area;
6923
6924           cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
6925
6926           pspp_sheet_view_get_cell_area (tree_view,
6927                                        cursor_path, column, &cell_area);
6928           pspp_sheet_view_get_background_area (tree_view,
6929                                              cursor_path, column,
6930                                              &background_area);
6931
6932           gtk_tree_path_free (cursor_path);
6933
6934           _pspp_sheet_view_column_get_focus_area (column,
6935                                                 &background_area,
6936                                                 &cell_area,
6937                                                 &focus_area);
6938
6939           x = focus_area.x;
6940           width = focus_area.width;
6941
6942           if (width < gtk_adjustment_get_page_size (tree_view->priv->hadjustment))
6943             {
6944               if ((gtk_adjustment_get_value (tree_view->priv->hadjustment) + gtk_adjustment_get_page_size (tree_view->priv->hadjustment)) < (x + width))
6945                 gtk_adjustment_set_value (tree_view->priv->hadjustment,
6946                                           x + width - gtk_adjustment_get_page_size (tree_view->priv->hadjustment));
6947               else if (gtk_adjustment_get_value (tree_view->priv->hadjustment) > x)
6948                 gtk_adjustment_set_value (tree_view->priv->hadjustment, x);
6949             }
6950         }
6951
6952       gtk_adjustment_set_value (tree_view->priv->hadjustment,
6953                                 CLAMP (x,
6954                                        gtk_adjustment_get_lower (tree_view->priv->hadjustment),
6955                                        gtk_adjustment_get_upper (tree_view->priv->hadjustment)
6956                                        - gtk_adjustment_get_page_size (tree_view->priv->hadjustment)));
6957     }
6958   else
6959     {
6960       if ((gtk_adjustment_get_value (tree_view->priv->hadjustment) + gtk_adjustment_get_page_size (tree_view->priv->hadjustment)) < (x + width))
6961           gtk_adjustment_set_value (tree_view->priv->hadjustment,
6962                                     x + width - gtk_adjustment_get_page_size (tree_view->priv->hadjustment));
6963       else if (gtk_adjustment_get_value (tree_view->priv->hadjustment) > x)
6964         gtk_adjustment_set_value (tree_view->priv->hadjustment, x);
6965   }
6966 }
6967
6968 GtkTreePath *
6969 _pspp_sheet_view_find_path (PsppSheetView *tree_view,
6970                             int node)
6971 {
6972   GtkTreePath *path;
6973
6974   path = gtk_tree_path_new ();
6975   if (node >= 0)
6976     gtk_tree_path_append_index (path, node);
6977   return path;
6978 }
6979
6980 void
6981 _pspp_sheet_view_find_node (PsppSheetView  *tree_view,
6982                           GtkTreePath  *path,
6983                           int *node)
6984 {
6985   gint *indices = gtk_tree_path_get_indices (path);
6986   gint depth = gtk_tree_path_get_depth (path);
6987
6988   *node = -1;
6989   if (depth == 0 || indices[0] < 0 || indices[0] >= tree_view->priv->row_count)
6990     return;
6991   *node = indices[0];
6992 }
6993
6994 static void
6995 pspp_sheet_view_add_move_binding (GtkBindingSet  *binding_set,
6996                                 guint           keyval,
6997                                 guint           modmask,
6998                                 gboolean        add_shifted_binding,
6999                                 GtkMovementStep step,
7000                                 gint            count)
7001 {
7002
7003   gtk_binding_entry_add_signal (binding_set, keyval, modmask,
7004                                 "move-cursor", 2,
7005                                 G_TYPE_ENUM, step,
7006                                 G_TYPE_INT, count);
7007
7008   if (add_shifted_binding)
7009     gtk_binding_entry_add_signal (binding_set, keyval, GDK_SHIFT_MASK,
7010                                   "move-cursor", 2,
7011                                   G_TYPE_ENUM, step,
7012                                   G_TYPE_INT, count);
7013
7014   if ((modmask & GDK_CONTROL_MASK) == GDK_CONTROL_MASK)
7015    return;
7016
7017   gtk_binding_entry_add_signal (binding_set, keyval, GDK_CONTROL_MASK | GDK_SHIFT_MASK,
7018                                 "move-cursor", 2,
7019                                 G_TYPE_ENUM, step,
7020                                 G_TYPE_INT, count);
7021
7022   gtk_binding_entry_add_signal (binding_set, keyval, GDK_CONTROL_MASK,
7023                                 "move-cursor", 2,
7024                                 G_TYPE_ENUM, step,
7025                                 G_TYPE_INT, count);
7026 }
7027
7028 static void
7029 pspp_sheet_view_set_column_drag_info (PsppSheetView       *tree_view,
7030                                     PsppSheetViewColumn *column)
7031 {
7032   PsppSheetViewColumn *left_column;
7033   PsppSheetViewColumn *cur_column = NULL;
7034   PsppSheetViewColumnReorder *reorder;
7035   gboolean rtl;
7036   GList *tmp_list;
7037   gint left;
7038
7039   /* We want to precalculate the motion list such that we know what column slots
7040    * are available.
7041    */
7042   left_column = NULL;
7043   rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
7044
7045   /* First, identify all possible drop spots */
7046   if (rtl)
7047     tmp_list = g_list_last (tree_view->priv->columns);
7048   else
7049     tmp_list = g_list_first (tree_view->priv->columns);
7050
7051   while (tmp_list)
7052     {
7053       cur_column = PSPP_SHEET_VIEW_COLUMN (tmp_list->data);
7054       tmp_list = rtl?g_list_previous (tmp_list):g_list_next (tmp_list);
7055
7056       if (cur_column->visible == FALSE)
7057         continue;
7058
7059       /* If it's not the column moving and func tells us to skip over the column, we continue. */
7060       if (left_column != column && cur_column != column &&
7061           tree_view->priv->column_drop_func &&
7062           ! tree_view->priv->column_drop_func (tree_view, column, left_column, cur_column, tree_view->priv->column_drop_func_data))
7063         {
7064           left_column = cur_column;
7065           continue;
7066         }
7067       reorder = g_slice_new0 (PsppSheetViewColumnReorder);
7068       reorder->left_column = left_column;
7069       left_column = reorder->right_column = cur_column;
7070
7071       tree_view->priv->column_drag_info = g_list_append (tree_view->priv->column_drag_info, reorder);
7072     }
7073
7074   /* Add the last one */
7075   if (tree_view->priv->column_drop_func == NULL ||
7076       ((left_column != column) &&
7077        tree_view->priv->column_drop_func (tree_view, column, left_column, NULL, tree_view->priv->column_drop_func_data)))
7078     {
7079       reorder = g_slice_new0 (PsppSheetViewColumnReorder);
7080       reorder->left_column = left_column;
7081       reorder->right_column = NULL;
7082       tree_view->priv->column_drag_info = g_list_append (tree_view->priv->column_drag_info, reorder);
7083     }
7084
7085   /* We quickly check to see if it even makes sense to reorder columns. */
7086   /* If there is nothing that can be moved, then we return */
7087
7088   if (tree_view->priv->column_drag_info == NULL)
7089     return;
7090
7091   /* We know there are always 2 slots possbile, as you can always return column. */
7092   /* If that's all there is, return */
7093   if (tree_view->priv->column_drag_info->next == NULL ||
7094       (tree_view->priv->column_drag_info->next->next == NULL &&
7095        ((PsppSheetViewColumnReorder *)tree_view->priv->column_drag_info->data)->right_column == column &&
7096        ((PsppSheetViewColumnReorder *)tree_view->priv->column_drag_info->next->data)->left_column == column))
7097     {
7098       for (tmp_list = tree_view->priv->column_drag_info; tmp_list; tmp_list = tmp_list->next)
7099         g_slice_free (PsppSheetViewColumnReorder, tmp_list->data);
7100       g_list_free (tree_view->priv->column_drag_info);
7101       tree_view->priv->column_drag_info = NULL;
7102       return;
7103     }
7104   /* We fill in the ranges for the columns, now that we've isolated them */
7105   left = - TREE_VIEW_COLUMN_DRAG_DEAD_MULTIPLIER (tree_view);
7106
7107   for (tmp_list = tree_view->priv->column_drag_info; tmp_list; tmp_list = tmp_list->next)
7108     {
7109       reorder = (PsppSheetViewColumnReorder *) tmp_list->data;
7110
7111       reorder->left_align = left;
7112       if (tmp_list->next != NULL)
7113         {
7114           g_assert (tmp_list->next->data);
7115           left = reorder->right_align = (reorder->right_column->allocation.x +
7116                                          reorder->right_column->allocation.width +
7117                                          ((PsppSheetViewColumnReorder *)tmp_list->next->data)->left_column->allocation.x)/2;
7118         }
7119       else
7120         {
7121           gint width = gdk_window_get_width (tree_view->priv->header_window);
7122           reorder->right_align = width + TREE_VIEW_COLUMN_DRAG_DEAD_MULTIPLIER (tree_view);
7123         }
7124     }
7125 }
7126
7127 void
7128 _pspp_sheet_view_column_start_drag (PsppSheetView       *tree_view,
7129                                   PsppSheetViewColumn *column)
7130 {
7131   GdkEvent *send_event;
7132   GtkAllocation allocation;
7133   gint x, y;
7134   GdkScreen *screen = gtk_widget_get_screen (GTK_WIDGET (tree_view));
7135   GdkDisplay *display = gdk_screen_get_display (screen);
7136
7137   g_return_if_fail (tree_view->priv->column_drag_info == NULL);
7138   g_return_if_fail (tree_view->priv->cur_reorder == NULL);
7139   g_return_if_fail (column->button);
7140
7141   pspp_sheet_view_set_column_drag_info (tree_view, column);
7142
7143   if (tree_view->priv->column_drag_info == NULL)
7144     return;
7145
7146   if (tree_view->priv->drag_window == NULL)
7147     {
7148       GdkWindowAttr attributes;
7149       guint attributes_mask;
7150
7151       attributes.window_type = GDK_WINDOW_CHILD;
7152       attributes.wclass = GDK_INPUT_OUTPUT;
7153       attributes.x = column->allocation.x;
7154       attributes.y = 0;
7155       attributes.width = column->allocation.width;
7156       attributes.height = column->allocation.height;
7157       attributes.visual = gtk_widget_get_visual (GTK_WIDGET (tree_view));
7158       attributes.event_mask = GDK_VISIBILITY_NOTIFY_MASK | GDK_EXPOSURE_MASK | GDK_POINTER_MOTION_MASK;
7159       attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL ;
7160
7161       tree_view->priv->drag_window = gdk_window_new (tree_view->priv->bin_window,
7162                                                      &attributes,
7163                                                      attributes_mask);
7164       gdk_window_set_user_data (tree_view->priv->drag_window, GTK_WIDGET (tree_view));
7165     }
7166
7167   gdk_display_pointer_ungrab (display, GDK_CURRENT_TIME);
7168   gdk_display_keyboard_ungrab (display, GDK_CURRENT_TIME);
7169
7170   gtk_grab_remove (column->button);
7171
7172   send_event = gdk_event_new (GDK_LEAVE_NOTIFY);
7173   send_event->crossing.send_event = TRUE;
7174   send_event->crossing.window = g_object_ref (gtk_button_get_event_window (GTK_BUTTON (column->button)));
7175   send_event->crossing.subwindow = NULL;
7176   send_event->crossing.detail = GDK_NOTIFY_ANCESTOR;
7177   send_event->crossing.time = GDK_CURRENT_TIME;
7178
7179   gtk_propagate_event (column->button, send_event);
7180   gdk_event_free (send_event);
7181
7182   send_event = gdk_event_new (GDK_BUTTON_RELEASE);
7183   send_event->button.window = g_object_ref (gdk_screen_get_root_window (screen));
7184   send_event->button.send_event = TRUE;
7185   send_event->button.time = GDK_CURRENT_TIME;
7186   send_event->button.x = -1;
7187   send_event->button.y = -1;
7188   send_event->button.axes = NULL;
7189   send_event->button.state = 0;
7190   send_event->button.button = 1;
7191   send_event->button.device =
7192     gdk_device_manager_get_client_pointer (gdk_display_get_device_manager (display));
7193
7194   send_event->button.x_root = 0;
7195   send_event->button.y_root = 0;
7196
7197   gtk_propagate_event (column->button, send_event);
7198   gdk_event_free (send_event);
7199
7200   /* Kids, don't try this at home */
7201   g_object_ref (column->button);
7202   gtk_container_remove (GTK_CONTAINER (tree_view), column->button);
7203   gtk_widget_set_parent_window (column->button, tree_view->priv->drag_window);
7204   gtk_widget_set_parent (column->button, GTK_WIDGET (tree_view));
7205   g_object_unref (column->button);
7206
7207   tree_view->priv->drag_column_x = column->allocation.x;
7208   allocation = column->allocation;
7209   allocation.x = 0;
7210   gtk_widget_size_allocate (column->button, &allocation);
7211   gtk_widget_set_parent_window (column->button, tree_view->priv->drag_window);
7212
7213   tree_view->priv->drag_column = column;
7214   gdk_window_show (tree_view->priv->drag_window);
7215
7216   gdk_window_get_origin (tree_view->priv->header_window, &x, &y);
7217
7218   gtk_widget_grab_focus (GTK_WIDGET (tree_view));
7219   while (gtk_events_pending ())
7220     gtk_main_iteration ();
7221
7222   PSPP_SHEET_VIEW_SET_FLAG (tree_view, PSPP_SHEET_VIEW_IN_COLUMN_DRAG);
7223   gdk_pointer_grab (tree_view->priv->drag_window,
7224                     FALSE,
7225                     GDK_POINTER_MOTION_MASK|GDK_BUTTON_RELEASE_MASK,
7226                     NULL, NULL, GDK_CURRENT_TIME);
7227   gdk_keyboard_grab (tree_view->priv->drag_window,
7228                      FALSE,
7229                      GDK_CURRENT_TIME);
7230 }
7231
7232 void
7233 _pspp_sheet_view_queue_draw_node (PsppSheetView        *tree_view,
7234                                 int node,
7235                                 const GdkRectangle *clip_rect)
7236 {
7237   GdkRectangle rect;
7238   GtkAllocation allocation;
7239
7240   if (!gtk_widget_get_realized (GTK_WIDGET (tree_view)))
7241     return;
7242
7243   gtk_widget_get_allocation (GTK_WIDGET (tree_view), &allocation);
7244   rect.x = 0;
7245   rect.width = MAX (tree_view->priv->width, allocation.width);
7246
7247   rect.y = BACKGROUND_FIRST_PIXEL (tree_view, node);
7248   rect.height = ROW_HEIGHT (tree_view);
7249
7250   if (clip_rect)
7251     {
7252       GdkRectangle new_rect;
7253
7254       gdk_rectangle_intersect (clip_rect, &rect, &new_rect);
7255
7256       gdk_window_invalidate_rect (tree_view->priv->bin_window, &new_rect, TRUE);
7257     }
7258   else
7259     {
7260       gdk_window_invalidate_rect (tree_view->priv->bin_window, &rect, TRUE);
7261     }
7262 }
7263
7264 static void
7265 pspp_sheet_view_queue_draw_path (PsppSheetView        *tree_view,
7266                                GtkTreePath        *path,
7267                                const GdkRectangle *clip_rect)
7268 {
7269   int node = -1;
7270
7271   _pspp_sheet_view_find_node (tree_view, path, &node);
7272
7273   if (node)
7274     _pspp_sheet_view_queue_draw_node (tree_view, node, clip_rect);
7275 }
7276
7277 static void
7278 pspp_sheet_view_focus_to_cursor (PsppSheetView *tree_view)
7279
7280 {
7281   GtkTreePath *cursor_path;
7282
7283   if ((tree_view->priv->row_count == 0) ||
7284       (! gtk_widget_get_realized (GTK_WIDGET (tree_view))))
7285     return;
7286
7287   cursor_path = NULL;
7288   if (tree_view->priv->cursor)
7289     cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
7290
7291   if (cursor_path == NULL)
7292     {
7293       /* There's no cursor.  Move the cursor to the first selected row, if any
7294        * are selected, otherwise to the first row in the sheetview.
7295        */
7296       GList *selected_rows;
7297       GtkTreeModel *model;
7298       PsppSheetSelection *selection;
7299
7300       selection = pspp_sheet_view_get_selection (tree_view);
7301       selected_rows = pspp_sheet_selection_get_selected_rows (selection, &model);
7302
7303       if (selected_rows)
7304         {
7305           /* XXX we could avoid doing O(n) work to get this result */
7306           cursor_path = gtk_tree_path_copy((const GtkTreePath *)(selected_rows->data));
7307           g_list_foreach (selected_rows, (GFunc)gtk_tree_path_free, NULL);
7308           g_list_free (selected_rows);
7309         }
7310       else
7311         {
7312           cursor_path = gtk_tree_path_new_first ();
7313           search_first_focusable_path (tree_view, &cursor_path,
7314                                        TRUE, NULL);
7315         }
7316
7317       gtk_tree_row_reference_free (tree_view->priv->cursor);
7318       tree_view->priv->cursor = NULL;
7319
7320       if (cursor_path)
7321         {
7322           if (tree_view->priv->selection->type == PSPP_SHEET_SELECTION_MULTIPLE ||
7323               tree_view->priv->selection->type == PSPP_SHEET_SELECTION_RECTANGLE)
7324             pspp_sheet_view_real_set_cursor (tree_view, cursor_path, FALSE, FALSE, 0);
7325           else
7326             pspp_sheet_view_real_set_cursor (tree_view, cursor_path, TRUE, FALSE, 0);
7327         }
7328     }
7329
7330   if (cursor_path)
7331     {
7332       /* Now find a column for the cursor. */
7333       PSPP_SHEET_VIEW_SET_FLAG (tree_view, PSPP_SHEET_VIEW_DRAW_KEYFOCUS);
7334
7335       pspp_sheet_view_queue_draw_path (tree_view, cursor_path, NULL);
7336       gtk_tree_path_free (cursor_path);
7337
7338       if (tree_view->priv->focus_column == NULL)
7339         {
7340           GList *list;
7341           for (list = tree_view->priv->columns; list; list = list->next)
7342             {
7343               if (PSPP_SHEET_VIEW_COLUMN (list->data)->visible)
7344                 {
7345                   tree_view->priv->focus_column = PSPP_SHEET_VIEW_COLUMN (list->data);
7346                   pspp_sheet_selection_unselect_all_columns (tree_view->priv->selection);
7347                   pspp_sheet_selection_select_column (tree_view->priv->selection, tree_view->priv->focus_column);
7348                   break;
7349                 }
7350             }
7351
7352         }
7353     }
7354 }
7355
7356 static gboolean
7357 pspp_sheet_view_move_cursor_up_down (PsppSheetView *tree_view,
7358                                    gint         count,
7359                                    PsppSheetSelectMode mode)
7360 {
7361   gint selection_count;
7362   int cursor_node = -1;
7363   int new_cursor_node = -1;
7364   GtkTreePath *cursor_path = NULL;
7365   gboolean grab_focus = TRUE;
7366
7367   if (! gtk_widget_has_focus (GTK_WIDGET (tree_view)))
7368     return FALSE;
7369
7370   cursor_path = NULL;
7371   if (!gtk_tree_row_reference_valid (tree_view->priv->cursor))
7372     /* FIXME: we lost the cursor; should we get the first? */
7373     return FALSE;
7374
7375   cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
7376   _pspp_sheet_view_find_node (tree_view, cursor_path, &cursor_node);
7377
7378   if (cursor_node < 0)
7379     /* FIXME: we lost the cursor; should we get the first? */
7380     return FALSE;
7381
7382   selection_count = pspp_sheet_selection_count_selected_rows (tree_view->priv->selection);
7383
7384   if (selection_count == 0
7385       && tree_view->priv->selection->type != PSPP_SHEET_SELECTION_NONE
7386       && !(mode & PSPP_SHEET_SELECT_MODE_TOGGLE))
7387     {
7388       /* Don't move the cursor, but just select the current node */
7389       new_cursor_node = cursor_node;
7390     }
7391   else
7392     {
7393       if (count == -1)
7394         new_cursor_node = pspp_sheet_view_node_prev (tree_view, cursor_node);
7395       else
7396         new_cursor_node = pspp_sheet_view_node_next (tree_view, cursor_node);
7397     }
7398
7399   gtk_tree_path_free (cursor_path);
7400
7401   if (new_cursor_node)
7402     {
7403       cursor_path = _pspp_sheet_view_find_path (tree_view, new_cursor_node);
7404
7405       search_first_focusable_path (tree_view, &cursor_path,
7406                                    (count != -1),
7407                                    &new_cursor_node);
7408
7409       if (cursor_path)
7410         gtk_tree_path_free (cursor_path);
7411     }
7412
7413   /*
7414    * If the list has only one item and multi-selection is set then select
7415    * the row (if not yet selected).
7416    */
7417   if ((tree_view->priv->selection->type == PSPP_SHEET_SELECTION_MULTIPLE ||
7418        tree_view->priv->selection->type == PSPP_SHEET_SELECTION_RECTANGLE) &&
7419       new_cursor_node < 0)
7420     {
7421       if (count == -1)
7422         new_cursor_node = pspp_sheet_view_node_next (tree_view, cursor_node);
7423       else
7424         new_cursor_node = pspp_sheet_view_node_prev (tree_view, cursor_node);
7425
7426       if (new_cursor_node < 0
7427           && !pspp_sheet_view_node_is_selected (tree_view, cursor_node))
7428         {
7429           new_cursor_node = cursor_node;
7430         }
7431       else
7432         {
7433           new_cursor_node = -1;
7434         }
7435     }
7436
7437   if (new_cursor_node >= 0)
7438     {
7439       cursor_path = _pspp_sheet_view_find_path (tree_view, new_cursor_node);
7440       pspp_sheet_view_real_set_cursor (tree_view, cursor_path, TRUE, TRUE, mode);
7441       gtk_tree_path_free (cursor_path);
7442     }
7443   else
7444     {
7445       pspp_sheet_view_clamp_node_visible (tree_view, cursor_node);
7446
7447       if (!(mode & PSPP_SHEET_SELECT_MODE_EXTEND))
7448         {
7449           if (! gtk_widget_keynav_failed (GTK_WIDGET (tree_view),
7450                                           count < 0 ?
7451                                           GTK_DIR_UP : GTK_DIR_DOWN))
7452             {
7453               GtkWidget *toplevel = gtk_widget_get_toplevel (GTK_WIDGET (tree_view));
7454
7455               if (toplevel)
7456                 gtk_widget_child_focus (toplevel,
7457                                         count < 0 ?
7458                                         GTK_DIR_TAB_BACKWARD :
7459                                         GTK_DIR_TAB_FORWARD);
7460
7461               grab_focus = FALSE;
7462             }
7463         }
7464       else
7465         {
7466           gtk_widget_error_bell (GTK_WIDGET (tree_view));
7467         }
7468     }
7469
7470   if (grab_focus)
7471     gtk_widget_grab_focus (GTK_WIDGET (tree_view));
7472
7473   return new_cursor_node >= 0;
7474 }
7475
7476 static void
7477 pspp_sheet_view_move_cursor_page_up_down (PsppSheetView *tree_view,
7478                                           gint         count,
7479                                           PsppSheetSelectMode mode)
7480 {
7481   int cursor_node = -1;
7482   GtkTreePath *old_cursor_path = NULL;
7483   GtkTreePath *cursor_path = NULL;
7484   int start_cursor_node = -1;
7485   gint y;
7486   gint window_y;
7487   gint vertical_separator;
7488
7489   if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
7490     return;
7491
7492   if (gtk_tree_row_reference_valid (tree_view->priv->cursor))
7493     old_cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
7494   else
7495     /* This is sorta weird.  Focus in should give us a cursor */
7496     return;
7497
7498   gtk_widget_style_get (GTK_WIDGET (tree_view), "vertical-separator", &vertical_separator, NULL);
7499   _pspp_sheet_view_find_node (tree_view, old_cursor_path, &cursor_node);
7500
7501   if (cursor_node < 0)
7502     {
7503       /* FIXME: we lost the cursor.  Should we try to get one? */
7504       gtk_tree_path_free (old_cursor_path);
7505       return;
7506     }
7507
7508   y = pspp_sheet_view_node_find_offset (tree_view, cursor_node);
7509   window_y = RBTREE_Y_TO_TREE_WINDOW_Y (tree_view, y);
7510   y += tree_view->priv->cursor_offset;
7511   y += count * (int)gtk_adjustment_get_page_increment (tree_view->priv->vadjustment);
7512   y = CLAMP (y, (gint)gtk_adjustment_get_lower (tree_view->priv->vadjustment),  (gint)gtk_adjustment_get_upper (tree_view->priv->vadjustment) - vertical_separator);
7513
7514   if (y >= tree_view->priv->height)
7515     y = tree_view->priv->height - 1;
7516
7517   tree_view->priv->cursor_offset =
7518     pspp_sheet_view_find_offset (tree_view, y, &cursor_node);
7519
7520   if (tree_view->priv->cursor_offset > BACKGROUND_HEIGHT (tree_view))
7521     {
7522       cursor_node = pspp_sheet_view_node_next (tree_view, cursor_node);
7523       tree_view->priv->cursor_offset -= BACKGROUND_HEIGHT (tree_view);
7524     }
7525
7526   y -= tree_view->priv->cursor_offset;
7527   cursor_path = _pspp_sheet_view_find_path (tree_view, cursor_node);
7528
7529   start_cursor_node = cursor_node;
7530
7531   if (! search_first_focusable_path (tree_view, &cursor_path,
7532                                      (count != -1),
7533                                      &cursor_node))
7534     {
7535       /* It looks like we reached the end of the view without finding
7536        * a focusable row.  We will step backwards to find the last
7537        * focusable row.
7538        */
7539       cursor_node = start_cursor_node;
7540       cursor_path = _pspp_sheet_view_find_path (tree_view, cursor_node);
7541
7542       search_first_focusable_path (tree_view, &cursor_path,
7543                                    (count == -1),
7544                                    &cursor_node);
7545     }
7546
7547   if (!cursor_path)
7548     goto cleanup;
7549
7550   /* update y */
7551   y = pspp_sheet_view_node_find_offset (tree_view, cursor_node);
7552
7553   pspp_sheet_view_real_set_cursor (tree_view, cursor_path, TRUE, FALSE, mode);
7554
7555   y -= window_y;
7556   pspp_sheet_view_scroll_to_point (tree_view, -1, y);
7557   pspp_sheet_view_clamp_node_visible (tree_view, cursor_node);
7558   _pspp_sheet_view_queue_draw_node (tree_view, cursor_node, NULL);
7559
7560   if (!gtk_tree_path_compare (old_cursor_path, cursor_path))
7561     gtk_widget_error_bell (GTK_WIDGET (tree_view));
7562
7563   gtk_widget_grab_focus (GTK_WIDGET (tree_view));
7564
7565 cleanup:
7566   gtk_tree_path_free (old_cursor_path);
7567   gtk_tree_path_free (cursor_path);
7568 }
7569
7570 static void
7571 pspp_sheet_view_move_cursor_left_right (PsppSheetView *tree_view,
7572                                         gint         count,
7573                                         PsppSheetSelectMode mode)
7574 {
7575   int cursor_node = -1;
7576   GtkTreePath *cursor_path = NULL;
7577   PsppSheetViewColumn *column;
7578   GtkTreeIter iter;
7579   GList *list;
7580   gboolean found_column = FALSE;
7581   gboolean rtl;
7582
7583   rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
7584
7585   if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
7586     return;
7587
7588   if (gtk_tree_row_reference_valid (tree_view->priv->cursor))
7589     cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
7590   else
7591     return;
7592
7593   _pspp_sheet_view_find_node (tree_view, cursor_path, &cursor_node);
7594   if (cursor_node < 0)
7595     return;
7596   if (gtk_tree_model_get_iter (tree_view->priv->model, &iter, cursor_path) == FALSE)
7597     {
7598       gtk_tree_path_free (cursor_path);
7599       return;
7600     }
7601   gtk_tree_path_free (cursor_path);
7602
7603   list = rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns);
7604   if (tree_view->priv->focus_column)
7605     {
7606       for (; list; list = (rtl ? list->prev : list->next))
7607         {
7608           if (list->data == tree_view->priv->focus_column)
7609             break;
7610         }
7611     }
7612
7613   while (list)
7614     {
7615       gboolean left, right;
7616
7617       column = list->data;
7618       if (column->visible == FALSE || column->row_head)
7619         goto loop_end;
7620
7621       pspp_sheet_view_column_cell_set_cell_data (column,
7622                                                tree_view->priv->model,
7623                                                &iter);
7624
7625       if (rtl)
7626         {
7627           right = list->prev ? TRUE : FALSE;
7628           left = list->next ? TRUE : FALSE;
7629         }
7630       else
7631         {
7632           left = list->prev ? TRUE : FALSE;
7633           right = list->next ? TRUE : FALSE;
7634         }
7635
7636       if (_pspp_sheet_view_column_cell_focus (column, count, left, right))
7637         {
7638           tree_view->priv->focus_column = column;
7639           found_column = TRUE;
7640           break;
7641         }
7642     loop_end:
7643       if (count == 1)
7644         list = rtl ? list->prev : list->next;
7645       else
7646         list = rtl ? list->next : list->prev;
7647     }
7648
7649   if (found_column)
7650     {
7651       _pspp_sheet_view_queue_draw_node (tree_view, cursor_node, NULL);
7652       g_signal_emit (tree_view, tree_view_signals[CURSOR_CHANGED], 0);
7653       gtk_widget_grab_focus (GTK_WIDGET (tree_view));
7654     }
7655   else
7656     {
7657       gtk_widget_error_bell (GTK_WIDGET (tree_view));
7658     }
7659
7660   pspp_sheet_view_clamp_column_visible (tree_view,
7661                                       tree_view->priv->focus_column, TRUE);
7662 }
7663
7664 static void
7665 pspp_sheet_view_move_cursor_line_start_end (PsppSheetView *tree_view,
7666                                             gint         count,
7667                                             PsppSheetSelectMode mode)
7668 {
7669   int cursor_node = -1;
7670   GtkTreePath *cursor_path = NULL;
7671   PsppSheetViewColumn *column;
7672   PsppSheetViewColumn *found_column;
7673   GtkTreeIter iter;
7674   GList *list;
7675   gboolean rtl;
7676
7677   rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
7678
7679   if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
7680     return;
7681
7682   if (gtk_tree_row_reference_valid (tree_view->priv->cursor))
7683     cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
7684   else
7685     return;
7686
7687   _pspp_sheet_view_find_node (tree_view, cursor_path, &cursor_node);
7688   if (cursor_node < 0)
7689     return;
7690   if (gtk_tree_model_get_iter (tree_view->priv->model, &iter, cursor_path) == FALSE)
7691     {
7692       gtk_tree_path_free (cursor_path);
7693       return;
7694     }
7695   gtk_tree_path_free (cursor_path);
7696
7697   list = rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns);
7698   if (tree_view->priv->focus_column)
7699     {
7700       for (; list; list = (rtl ? list->prev : list->next))
7701         {
7702           if (list->data == tree_view->priv->focus_column)
7703             break;
7704         }
7705     }
7706
7707   found_column = NULL;
7708   while (list)
7709     {
7710       gboolean left, right;
7711
7712       column = list->data;
7713       if (column->visible == FALSE || column->row_head)
7714         goto loop_end;
7715
7716       pspp_sheet_view_column_cell_set_cell_data (column,
7717                                                tree_view->priv->model,
7718                                                &iter);
7719
7720       if (rtl)
7721         {
7722           right = list->prev ? TRUE : FALSE;
7723           left = list->next ? TRUE : FALSE;
7724         }
7725       else
7726         {
7727           left = list->prev ? TRUE : FALSE;
7728           right = list->next ? TRUE : FALSE;
7729         }
7730
7731       if (column->tabbable
7732           && _pspp_sheet_view_column_cell_focus (column, count, left, right))
7733         found_column = column;
7734
7735     loop_end:
7736       if (count == 1)
7737         list = rtl ? list->prev : list->next;
7738       else
7739         list = rtl ? list->next : list->prev;
7740     }
7741
7742   if (found_column)
7743     {
7744       tree_view->priv->focus_column = found_column;
7745       _pspp_sheet_view_queue_draw_node (tree_view, cursor_node, NULL);
7746       g_signal_emit (tree_view, tree_view_signals[CURSOR_CHANGED], 0);
7747       gtk_widget_grab_focus (GTK_WIDGET (tree_view));
7748     }
7749
7750   pspp_sheet_view_clamp_column_visible (tree_view,
7751                                       tree_view->priv->focus_column, TRUE);
7752 }
7753
7754 static gboolean
7755 try_move_cursor_tab (PsppSheetView *tree_view,
7756                      gboolean start_at_focus_column,
7757                      gint count)
7758 {
7759   PsppSheetViewColumn *column;
7760   GtkTreeIter iter;
7761   int cursor_node = -1;
7762   GtkTreePath *cursor_path = NULL;
7763   gboolean rtl;
7764   GList *list;
7765
7766   if (gtk_tree_row_reference_valid (tree_view->priv->cursor))
7767     cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
7768   else
7769     return TRUE;
7770
7771   _pspp_sheet_view_find_node (tree_view, cursor_path, &cursor_node);
7772   if (cursor_node < 0)
7773     return TRUE;
7774   if (gtk_tree_model_get_iter (tree_view->priv->model, &iter, cursor_path) == FALSE)
7775     {
7776       gtk_tree_path_free (cursor_path);
7777       return TRUE;
7778     }
7779   gtk_tree_path_free (cursor_path);
7780
7781   rtl = gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL;
7782   if (start_at_focus_column)
7783     {
7784       list = (rtl
7785               ? g_list_last (tree_view->priv->columns)
7786               : g_list_first (tree_view->priv->columns));
7787       if (tree_view->priv->focus_column)
7788         {
7789           for (; list; list = (rtl ? list->prev : list->next))
7790             {
7791               if (list->data == tree_view->priv->focus_column)
7792                 break;
7793             }
7794         }
7795     }
7796   else
7797     {
7798       list = (rtl ^ (count == 1)
7799               ? g_list_first (tree_view->priv->columns)
7800               : g_list_last (tree_view->priv->columns));
7801     }
7802
7803   while (list)
7804     {
7805       gboolean left, right;
7806
7807       column = list->data;
7808       if (column->visible == FALSE || !column->tabbable)
7809         goto loop_end;
7810
7811       pspp_sheet_view_column_cell_set_cell_data (column,
7812                                                  tree_view->priv->model,
7813                                                  &iter);
7814
7815       if (rtl)
7816         {
7817           right = list->prev ? TRUE : FALSE;
7818           left = list->next ? TRUE : FALSE;
7819         }
7820       else
7821         {
7822           left = list->prev ? TRUE : FALSE;
7823           right = list->next ? TRUE : FALSE;
7824         }
7825
7826       if (column->tabbable
7827           && _pspp_sheet_view_column_cell_focus (column, count, left, right))
7828         {
7829           tree_view->priv->focus_column = column;
7830           _pspp_sheet_view_queue_draw_node (tree_view, cursor_node, NULL);
7831           g_signal_emit (tree_view, tree_view_signals[CURSOR_CHANGED], 0);
7832           gtk_widget_grab_focus (GTK_WIDGET (tree_view));
7833           return TRUE;
7834         }
7835     loop_end:
7836       if (count == 1)
7837         list = rtl ? list->prev : list->next;
7838       else
7839         list = rtl ? list->next : list->prev;
7840     }
7841
7842   return FALSE;
7843 }
7844
7845 static void
7846 pspp_sheet_view_move_cursor_tab (PsppSheetView *tree_view,
7847                                  gint         count)
7848 {
7849   if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
7850     return;
7851
7852   if (!try_move_cursor_tab (tree_view, TRUE, count))
7853     {
7854       if (pspp_sheet_view_move_cursor_up_down (tree_view, count, 0)
7855           && !try_move_cursor_tab (tree_view, FALSE, count))
7856         gtk_widget_error_bell (GTK_WIDGET (tree_view));
7857     }
7858
7859   pspp_sheet_view_clamp_column_visible (tree_view,
7860                                         tree_view->priv->focus_column, TRUE);
7861 }
7862
7863 static void
7864 pspp_sheet_view_move_cursor_start_end (PsppSheetView *tree_view,
7865                                        gint         count,
7866                                        PsppSheetSelectMode mode)
7867 {
7868   int cursor_node;
7869   GtkTreePath *path;
7870   GtkTreePath *old_path;
7871
7872   if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
7873     return;
7874
7875   g_return_if_fail (tree_view->priv->row_count > 0);
7876
7877   pspp_sheet_view_get_cursor (tree_view, &old_path, NULL);
7878
7879   if (count == -1)
7880     {
7881       /* Now go forward to find the first focusable row. */
7882       path = _pspp_sheet_view_find_path (tree_view, 0);
7883       search_first_focusable_path (tree_view, &path,
7884                                    TRUE, &cursor_node);
7885     }
7886   else
7887     {
7888       /* Now go backwards to find last focusable row. */
7889       path = _pspp_sheet_view_find_path (tree_view, tree_view->priv->row_count - 1);
7890       search_first_focusable_path (tree_view, &path,
7891                                    FALSE, &cursor_node);
7892     }
7893
7894   if (!path)
7895     goto cleanup;
7896
7897   if (gtk_tree_path_compare (old_path, path))
7898     {
7899       pspp_sheet_view_real_set_cursor (tree_view, path, TRUE, TRUE, mode);
7900       gtk_widget_grab_focus (GTK_WIDGET (tree_view));
7901     }
7902   else
7903     {
7904       gtk_widget_error_bell (GTK_WIDGET (tree_view));
7905     }
7906
7907 cleanup:
7908   gtk_tree_path_free (old_path);
7909   gtk_tree_path_free (path);
7910 }
7911
7912 static gboolean
7913 pspp_sheet_view_real_select_all (PsppSheetView *tree_view)
7914 {
7915   if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
7916     return FALSE;
7917
7918   if (tree_view->priv->selection->type != PSPP_SHEET_SELECTION_MULTIPLE &&
7919       tree_view->priv->selection->type != PSPP_SHEET_SELECTION_RECTANGLE)
7920     return FALSE;
7921
7922   pspp_sheet_selection_select_all (tree_view->priv->selection);
7923
7924   return TRUE;
7925 }
7926
7927 static gboolean
7928 pspp_sheet_view_real_unselect_all (PsppSheetView *tree_view)
7929 {
7930   if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
7931     return FALSE;
7932
7933   if (tree_view->priv->selection->type != PSPP_SHEET_SELECTION_MULTIPLE &&
7934       tree_view->priv->selection->type != PSPP_SHEET_SELECTION_RECTANGLE)
7935     return FALSE;
7936
7937   pspp_sheet_selection_unselect_all (tree_view->priv->selection);
7938
7939   return TRUE;
7940 }
7941
7942 static gboolean
7943 pspp_sheet_view_real_select_cursor_row (PsppSheetView *tree_view,
7944                                         gboolean     start_editing,
7945                                         PsppSheetSelectMode mode)
7946 {
7947   int new_node = -1;
7948   int cursor_node = -1;
7949   GtkTreePath *cursor_path = NULL;
7950
7951   if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
7952     return FALSE;
7953
7954   if (tree_view->priv->cursor)
7955     cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
7956
7957   if (cursor_path == NULL)
7958     return FALSE;
7959
7960   _pspp_sheet_view_find_node (tree_view, cursor_path,
7961                               &cursor_node);
7962
7963   if (cursor_node < 0)
7964     {
7965       gtk_tree_path_free (cursor_path);
7966       return FALSE;
7967     }
7968
7969   if (!(mode & PSPP_SHEET_SELECT_MODE_EXTEND) && start_editing &&
7970       tree_view->priv->focus_column)
7971     {
7972       if (pspp_sheet_view_start_editing (tree_view, cursor_path))
7973         {
7974           gtk_tree_path_free (cursor_path);
7975           return TRUE;
7976         }
7977     }
7978
7979   _pspp_sheet_selection_internal_select_node (tree_view->priv->selection,
7980                                             cursor_node,
7981                                             cursor_path,
7982                                             mode,
7983                                             FALSE);
7984
7985   /* We bail out if the original (tree, node) don't exist anymore after
7986    * handling the selection-changed callback.  We do return TRUE because
7987    * the key press has been handled at this point.
7988    */
7989   _pspp_sheet_view_find_node (tree_view, cursor_path, &new_node);
7990
7991   if (cursor_node != new_node)
7992     return FALSE;
7993
7994   pspp_sheet_view_clamp_node_visible (tree_view, cursor_node);
7995
7996   gtk_widget_grab_focus (GTK_WIDGET (tree_view));
7997   _pspp_sheet_view_queue_draw_node (tree_view, cursor_node, NULL);
7998
7999   if (!(mode & PSPP_SHEET_SELECT_MODE_EXTEND))
8000     pspp_sheet_view_row_activated (tree_view, cursor_path,
8001                                  tree_view->priv->focus_column);
8002
8003   gtk_tree_path_free (cursor_path);
8004
8005   return TRUE;
8006 }
8007
8008 static gboolean
8009 pspp_sheet_view_real_toggle_cursor_row (PsppSheetView *tree_view)
8010 {
8011   int new_node = -1;
8012   int cursor_node = -1;
8013   GtkTreePath *cursor_path = NULL;
8014
8015   if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
8016     return FALSE;
8017
8018   cursor_path = NULL;
8019   if (tree_view->priv->cursor)
8020     cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
8021
8022   if (cursor_path == NULL)
8023     return FALSE;
8024
8025   _pspp_sheet_view_find_node (tree_view, cursor_path, &cursor_node);
8026   if (cursor_node < 0)
8027     {
8028       gtk_tree_path_free (cursor_path);
8029       return FALSE;
8030     }
8031
8032   _pspp_sheet_selection_internal_select_node (tree_view->priv->selection,
8033                                             cursor_node,
8034                                             cursor_path,
8035                                             PSPP_SHEET_SELECT_MODE_TOGGLE,
8036                                             FALSE);
8037
8038   /* We bail out if the original (tree, node) don't exist anymore after
8039    * handling the selection-changed callback.  We do return TRUE because
8040    * the key press has been handled at this point.
8041    */
8042   _pspp_sheet_view_find_node (tree_view, cursor_path, &new_node);
8043
8044   if (cursor_node != new_node)
8045     return FALSE;
8046
8047   pspp_sheet_view_clamp_node_visible (tree_view, cursor_node);
8048
8049   gtk_widget_grab_focus (GTK_WIDGET (tree_view));
8050   pspp_sheet_view_queue_draw_path (tree_view, cursor_path, NULL);
8051   gtk_tree_path_free (cursor_path);
8052
8053   return TRUE;
8054 }
8055
8056 static gboolean
8057 pspp_sheet_view_search_entry_flush_timeout (PsppSheetView *tree_view)
8058 {
8059   pspp_sheet_view_search_dialog_hide (tree_view->priv->search_window, tree_view);
8060   tree_view->priv->typeselect_flush_timeout = 0;
8061
8062   return FALSE;
8063 }
8064
8065 /* Cut and paste from gtkwindow.c */
8066 static void
8067 send_focus_change (GtkWidget *widget,
8068                    gboolean   in)
8069 {
8070   GdkEvent *fevent = gdk_event_new (GDK_FOCUS_CHANGE);
8071
8072   fevent->focus_change.type = GDK_FOCUS_CHANGE;
8073   fevent->focus_change.window = g_object_ref (gtk_widget_get_window (widget));
8074   fevent->focus_change.in = in;
8075
8076   gtk_widget_send_focus_change (widget, fevent);
8077   gdk_event_free (fevent);
8078 }
8079
8080 static void
8081 pspp_sheet_view_ensure_interactive_directory (PsppSheetView *tree_view)
8082 {
8083   GtkWidget *frame, *vbox, *toplevel;
8084   GdkScreen *screen;
8085
8086   if (tree_view->priv->search_custom_entry_set)
8087     return;
8088
8089   toplevel = gtk_widget_get_toplevel (GTK_WIDGET (tree_view));
8090   screen = gtk_widget_get_screen (GTK_WIDGET (tree_view));
8091
8092    if (tree_view->priv->search_window != NULL)
8093      {
8094        if (gtk_window_get_group (GTK_WINDOW (toplevel)))
8095          gtk_window_group_add_window (gtk_window_get_group (GTK_WINDOW (toplevel)),
8096                                       GTK_WINDOW (tree_view->priv->search_window));
8097        else if (gtk_window_get_group (GTK_WINDOW (tree_view->priv->search_window)))
8098          gtk_window_group_remove_window (gtk_window_get_group (GTK_WINDOW (tree_view->priv->search_window)),
8099                                          GTK_WINDOW (tree_view->priv->search_window));
8100        gtk_window_set_screen (GTK_WINDOW (tree_view->priv->search_window), screen);
8101        return;
8102      }
8103
8104   tree_view->priv->search_window = gtk_window_new (GTK_WINDOW_POPUP);
8105   gtk_window_set_screen (GTK_WINDOW (tree_view->priv->search_window), screen);
8106
8107   if (gtk_window_get_group (GTK_WINDOW (toplevel)))
8108     gtk_window_group_add_window (gtk_window_get_group (GTK_WINDOW (toplevel)),
8109                                  GTK_WINDOW (tree_view->priv->search_window));
8110
8111   gtk_window_set_type_hint (GTK_WINDOW (tree_view->priv->search_window),
8112                             GDK_WINDOW_TYPE_HINT_UTILITY);
8113   gtk_window_set_modal (GTK_WINDOW (tree_view->priv->search_window), TRUE);
8114   g_signal_connect (tree_view->priv->search_window, "delete-event",
8115                     G_CALLBACK (pspp_sheet_view_search_delete_event),
8116                     tree_view);
8117   g_signal_connect (tree_view->priv->search_window, "key-press-event",
8118                     G_CALLBACK (pspp_sheet_view_search_key_press_event),
8119                     tree_view);
8120   g_signal_connect (tree_view->priv->search_window, "button-press-event",
8121                     G_CALLBACK (pspp_sheet_view_search_button_press_event),
8122                     tree_view);
8123   g_signal_connect (tree_view->priv->search_window, "scroll-event",
8124                     G_CALLBACK (pspp_sheet_view_search_scroll_event),
8125                     tree_view);
8126
8127   frame = gtk_frame_new (NULL);
8128   gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_ETCHED_IN);
8129   gtk_widget_show (frame);
8130   gtk_container_add (GTK_CONTAINER (tree_view->priv->search_window), frame);
8131
8132   vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
8133   gtk_widget_show (vbox);
8134   gtk_container_add (GTK_CONTAINER (frame), vbox);
8135   gtk_container_set_border_width (GTK_CONTAINER (vbox), 3);
8136
8137   /* add entry */
8138   tree_view->priv->search_entry = gtk_entry_new ();
8139   gtk_widget_show (tree_view->priv->search_entry);
8140   g_signal_connect (tree_view->priv->search_entry, "populate-popup",
8141                     G_CALLBACK (pspp_sheet_view_search_disable_popdown),
8142                     tree_view);
8143   g_signal_connect (tree_view->priv->search_entry,
8144                     "activate", G_CALLBACK (pspp_sheet_view_search_activate),
8145                     tree_view);
8146
8147   gtk_container_add (GTK_CONTAINER (vbox),
8148                      tree_view->priv->search_entry);
8149
8150   gtk_widget_realize (tree_view->priv->search_entry);
8151 }
8152
8153 /* Pops up the interactive search entry.  If keybinding is TRUE then the user
8154  * started this by typing the start_interactive_search keybinding.  Otherwise, it came from
8155  */
8156 static gboolean
8157 pspp_sheet_view_real_start_interactive_search (PsppSheetView *tree_view,
8158                                              gboolean     keybinding)
8159 {
8160   /* We only start interactive search if we have focus or the columns
8161    * have focus.  If one of our children have focus, we don't want to
8162    * start the search.
8163    */
8164   GList *list;
8165   gboolean found_focus = FALSE;
8166   GtkWidgetClass *entry_parent_class;
8167
8168   if (!tree_view->priv->enable_search && !keybinding)
8169     return FALSE;
8170
8171   if (tree_view->priv->search_custom_entry_set)
8172     return FALSE;
8173
8174   if (tree_view->priv->search_window != NULL &&
8175       gtk_widget_get_visible (tree_view->priv->search_window))
8176     return TRUE;
8177
8178   for (list = tree_view->priv->columns; list; list = list->next)
8179     {
8180       PsppSheetViewColumn *column;
8181
8182       column = list->data;
8183       if (! column->visible)
8184         continue;
8185
8186       if (column->button && gtk_widget_has_focus (column->button))
8187         {
8188           found_focus = TRUE;
8189           break;
8190         }
8191     }
8192
8193   if (gtk_widget_has_focus (GTK_WIDGET (tree_view)))
8194     found_focus = TRUE;
8195
8196   if (!found_focus)
8197     return FALSE;
8198
8199   if (tree_view->priv->search_column < 0)
8200     return FALSE;
8201
8202   pspp_sheet_view_ensure_interactive_directory (tree_view);
8203
8204   if (keybinding)
8205     gtk_entry_set_text (GTK_ENTRY (tree_view->priv->search_entry), "");
8206
8207   /* done, show it */
8208   tree_view->priv->search_position_func (tree_view, tree_view->priv->search_window, tree_view->priv->search_position_user_data);
8209   gtk_widget_show (tree_view->priv->search_window);
8210   if (tree_view->priv->search_entry_changed_id == 0)
8211     {
8212       tree_view->priv->search_entry_changed_id =
8213         g_signal_connect (tree_view->priv->search_entry, "changed",
8214                           G_CALLBACK (pspp_sheet_view_search_init),
8215                           tree_view);
8216     }
8217
8218   tree_view->priv->typeselect_flush_timeout =
8219     gdk_threads_add_timeout (PSPP_SHEET_VIEW_SEARCH_DIALOG_TIMEOUT,
8220                    (GSourceFunc) pspp_sheet_view_search_entry_flush_timeout,
8221                    tree_view);
8222
8223   /* Grab focus will select all the text.  We don't want that to happen, so we
8224    * call the parent instance and bypass the selection change.  This is probably
8225    * really non-kosher. */
8226   entry_parent_class = g_type_class_peek_parent (GTK_ENTRY_GET_CLASS (tree_view->priv->search_entry));
8227   (entry_parent_class->grab_focus) (tree_view->priv->search_entry);
8228
8229   /* send focus-in event */
8230   send_focus_change (tree_view->priv->search_entry, TRUE);
8231
8232   /* search first matching iter */
8233   pspp_sheet_view_search_init (tree_view->priv->search_entry, tree_view);
8234
8235   return TRUE;
8236 }
8237
8238 static gboolean
8239 pspp_sheet_view_start_interactive_search (PsppSheetView *tree_view)
8240 {
8241   return pspp_sheet_view_real_start_interactive_search (tree_view, TRUE);
8242 }
8243
8244 /* this function returns the new width of the column being resized given
8245  * the column and x position of the cursor; the x cursor position is passed
8246  * in as a pointer and automagicly corrected if it's beyond min/max limits
8247  */
8248 static gint
8249 pspp_sheet_view_new_column_width (PsppSheetView *tree_view,
8250                                 gint       i,
8251                                 gint      *x)
8252 {
8253   PsppSheetViewColumn *column;
8254   gint width;
8255   gboolean rtl;
8256
8257   /* first translate the x position from gtk_widget_get_window (widget)
8258    * to clist->clist_window
8259    */
8260   rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
8261   column = g_list_nth (tree_view->priv->columns, i)->data;
8262   width = rtl ? (column->allocation.x + column->allocation.width - *x) : (*x - column->allocation.x);
8263
8264   /* Clamp down the value */
8265   if (column->min_width == -1)
8266     width = MAX (column->button_request, width);
8267   else
8268     width = MAX (column->min_width, width);
8269   if (column->max_width != -1)
8270     width = MIN (width, column->max_width);
8271
8272   *x = rtl ? (column->allocation.x + column->allocation.width - width) : (column->allocation.x + width);
8273
8274   return width;
8275 }
8276
8277 void
8278 pspp_sheet_view_column_update_button (PsppSheetViewColumn *tree_column);
8279
8280 /* Callbacks */
8281 static void
8282 pspp_sheet_view_adjustment_changed (GtkAdjustment *adjustment,
8283                                   PsppSheetView   *tree_view)
8284 {
8285   if (gtk_widget_get_realized (GTK_WIDGET (tree_view)))
8286     {
8287       gint dy;
8288
8289       gdk_window_move (tree_view->priv->bin_window,
8290                        - gtk_adjustment_get_value (tree_view->priv->hadjustment),
8291                        TREE_VIEW_HEADER_HEIGHT (tree_view));
8292       gdk_window_move (tree_view->priv->header_window,
8293                        - gtk_adjustment_get_value (tree_view->priv->hadjustment),
8294                        0);
8295       dy = tree_view->priv->dy - (int) gtk_adjustment_get_value (tree_view->priv->vadjustment);
8296
8297       gdk_window_scroll (tree_view->priv->bin_window, 0, dy);
8298
8299       if (dy != 0)
8300         {
8301           /* update our dy and top_row */
8302           tree_view->priv->dy = (int) gtk_adjustment_get_value (tree_view->priv->vadjustment);
8303
8304           update_prelight (tree_view,
8305                            tree_view->priv->event_last_x,
8306                            tree_view->priv->event_last_y);
8307
8308           if (!tree_view->priv->in_top_row_to_dy)
8309             pspp_sheet_view_dy_to_top_row (tree_view);
8310         }
8311
8312       update_childrens_allocation(tree_view);
8313     }
8314 }
8315
8316 /* Public methods
8317  */
8318
8319 /**
8320  * pspp_sheet_view_new:
8321  *
8322  * Creates a new #PsppSheetView widget.
8323  *
8324  * Return value: A newly created #PsppSheetView widget.
8325  **/
8326 GtkWidget *
8327 pspp_sheet_view_new (void)
8328 {
8329   return g_object_new (PSPP_TYPE_SHEET_VIEW, NULL);
8330 }
8331
8332 /**
8333  * pspp_sheet_view_new_with_model:
8334  * @model: the model.
8335  *
8336  * Creates a new #PsppSheetView widget with the model initialized to @model.
8337  *
8338  * Return value: A newly created #PsppSheetView widget.
8339  **/
8340 GtkWidget *
8341 pspp_sheet_view_new_with_model (GtkTreeModel *model)
8342 {
8343   return g_object_new (PSPP_TYPE_SHEET_VIEW, "model", model, NULL);
8344 }
8345
8346 /* Public Accessors
8347  */
8348
8349 /**
8350  * pspp_sheet_view_get_model:
8351  * @tree_view: a #PsppSheetView
8352  *
8353  * Returns the model the #PsppSheetView is based on.  Returns %NULL if the
8354  * model is unset.
8355  *
8356  * Return value: A #GtkTreeModel, or %NULL if none is currently being used.
8357  **/
8358 GtkTreeModel *
8359 pspp_sheet_view_get_model (PsppSheetView *tree_view)
8360 {
8361   g_return_val_if_fail (PSPP_IS_SHEET_VIEW (tree_view), NULL);
8362
8363   return tree_view->priv->model;
8364 }
8365
8366 /**
8367  * pspp_sheet_view_set_model:
8368  * @tree_view: A #GtkTreeNode.
8369  * @model: (allow-none): The model.
8370  *
8371  * Sets the model for a #PsppSheetView.  If the @tree_view already has a model
8372  * set, it will remove it before setting the new model.  If @model is %NULL,
8373  * then it will unset the old model.
8374  **/
8375 void
8376 pspp_sheet_view_set_model (PsppSheetView  *tree_view,
8377                          GtkTreeModel *model)
8378 {
8379   g_return_if_fail (PSPP_IS_SHEET_VIEW (tree_view));
8380   g_return_if_fail (model == NULL || GTK_IS_TREE_MODEL (model));
8381
8382   if (model == tree_view->priv->model)
8383     return;
8384
8385   if (tree_view->priv->scroll_to_path)
8386     {
8387       gtk_tree_row_reference_free (tree_view->priv->scroll_to_path);
8388       tree_view->priv->scroll_to_path = NULL;
8389     }
8390
8391   if (tree_view->priv->model)
8392     {
8393       GList *tmplist = tree_view->priv->columns;
8394
8395       if (tree_view->priv->selected)
8396         range_tower_set0 (tree_view->priv->selected, 0, ULONG_MAX);
8397       pspp_sheet_view_stop_editing (tree_view, TRUE);
8398
8399       g_signal_handlers_disconnect_by_func (tree_view->priv->model,
8400                                             pspp_sheet_view_row_changed,
8401                                             tree_view);
8402       g_signal_handlers_disconnect_by_func (tree_view->priv->model,
8403                                             pspp_sheet_view_row_inserted,
8404                                             tree_view);
8405       g_signal_handlers_disconnect_by_func (tree_view->priv->model,
8406                                             pspp_sheet_view_row_deleted,
8407                                             tree_view);
8408       g_signal_handlers_disconnect_by_func (tree_view->priv->model,
8409                                             pspp_sheet_view_rows_reordered,
8410                                             tree_view);
8411
8412       for (; tmplist; tmplist = tmplist->next)
8413         _pspp_sheet_view_column_unset_model (tmplist->data,
8414                                            tree_view->priv->model);
8415
8416       tree_view->priv->prelight_node = -1;
8417
8418       gtk_tree_row_reference_free (tree_view->priv->drag_dest_row);
8419       tree_view->priv->drag_dest_row = NULL;
8420       gtk_tree_row_reference_free (tree_view->priv->cursor);
8421       tree_view->priv->cursor = NULL;
8422       gtk_tree_row_reference_free (tree_view->priv->anchor);
8423       tree_view->priv->anchor = NULL;
8424       gtk_tree_row_reference_free (tree_view->priv->top_row);
8425       tree_view->priv->top_row = NULL;
8426       gtk_tree_row_reference_free (tree_view->priv->scroll_to_path);
8427       tree_view->priv->scroll_to_path = NULL;
8428
8429       tree_view->priv->scroll_to_column = NULL;
8430
8431       g_object_unref (tree_view->priv->model);
8432
8433       tree_view->priv->search_column = -1;
8434       tree_view->priv->fixed_height = -1;
8435       tree_view->priv->dy = tree_view->priv->top_row_dy = 0;
8436       tree_view->priv->last_button_x = -1;
8437       tree_view->priv->last_button_y = -1;
8438     }
8439
8440   tree_view->priv->model = model;
8441
8442   if (tree_view->priv->model)
8443     {
8444       gint i;
8445
8446       if (tree_view->priv->search_column == -1)
8447         {
8448           for (i = 0; i < gtk_tree_model_get_n_columns (model); i++)
8449             {
8450               GType type = gtk_tree_model_get_column_type (model, i);
8451
8452               if (g_value_type_transformable (type, G_TYPE_STRING))
8453                 {
8454                   tree_view->priv->search_column = i;
8455                   break;
8456                 }
8457             }
8458         }
8459
8460       g_object_ref (tree_view->priv->model);
8461       g_signal_connect (tree_view->priv->model,
8462                         "row-changed",
8463                         G_CALLBACK (pspp_sheet_view_row_changed),
8464                         tree_view);
8465       g_signal_connect (tree_view->priv->model,
8466                         "row-inserted",
8467                         G_CALLBACK (pspp_sheet_view_row_inserted),
8468                         tree_view);
8469       g_signal_connect (tree_view->priv->model,
8470                         "row-deleted",
8471                         G_CALLBACK (pspp_sheet_view_row_deleted),
8472                         tree_view);
8473       g_signal_connect (tree_view->priv->model,
8474                         "rows-reordered",
8475                         G_CALLBACK (pspp_sheet_view_rows_reordered),
8476                         tree_view);
8477
8478       tree_view->priv->row_count = gtk_tree_model_iter_n_children (tree_view->priv->model, NULL);
8479
8480       /*  FIXME: do I need to do this? pspp_sheet_view_create_buttons (tree_view); */
8481       install_presize_handler (tree_view);
8482     }
8483
8484   g_object_notify (G_OBJECT (tree_view), "model");
8485
8486   if (tree_view->priv->selection)
8487     _pspp_sheet_selection_emit_changed (tree_view->priv->selection);
8488
8489   if (gtk_widget_get_realized (GTK_WIDGET (tree_view)))
8490     gtk_widget_queue_resize (GTK_WIDGET (tree_view));
8491 }
8492
8493 /**
8494  * pspp_sheet_view_get_selection:
8495  * @tree_view: A #PsppSheetView.
8496  *
8497  * Gets the #PsppSheetSelection associated with @tree_view.
8498  *
8499  * Return value: A #PsppSheetSelection object.
8500  **/
8501 PsppSheetSelection *
8502 pspp_sheet_view_get_selection (PsppSheetView *tree_view)
8503 {
8504   g_return_val_if_fail (PSPP_IS_SHEET_VIEW (tree_view), NULL);
8505
8506   return tree_view->priv->selection;
8507 }
8508
8509 /**
8510  * pspp_sheet_view_get_hadjustment:
8511  * @tree_view: A #PsppSheetView
8512  *
8513  * Gets the #GtkAdjustment currently being used for the horizontal aspect.
8514  *
8515  * Return value: A #GtkAdjustment object, or %NULL if none is currently being
8516  * used.
8517  **/
8518 GtkAdjustment *
8519 pspp_sheet_view_get_hadjustment (PsppSheetView *tree_view)
8520 {
8521   g_return_val_if_fail (PSPP_IS_SHEET_VIEW (tree_view), NULL);
8522
8523   return pspp_sheet_view_do_get_hadjustment (tree_view);
8524 }
8525
8526 static GtkAdjustment *
8527 pspp_sheet_view_do_get_hadjustment (PsppSheetView *tree_view)
8528 {
8529   return tree_view->priv->hadjustment;
8530 }
8531
8532 /**
8533  * pspp_sheet_view_set_hadjustment:
8534  * @tree_view: A #PsppSheetView
8535  * @adjustment: (allow-none): The #GtkAdjustment to set, or %NULL
8536  *
8537  * Sets the #GtkAdjustment for the current horizontal aspect.
8538  **/
8539 void
8540 pspp_sheet_view_set_hadjustment (PsppSheetView   *tree_view,
8541                                GtkAdjustment *adjustment)
8542 {
8543   g_return_if_fail (PSPP_IS_SHEET_VIEW (tree_view));
8544
8545   pspp_sheet_view_set_adjustments (tree_view,
8546                                  adjustment,
8547                                  tree_view->priv->vadjustment);
8548
8549   g_object_notify (G_OBJECT (tree_view), "hadjustment");
8550 }
8551
8552 static void
8553 pspp_sheet_view_do_set_hadjustment (PsppSheetView   *tree_view,
8554                                   GtkAdjustment *adjustment)
8555 {
8556   PsppSheetViewPrivate *priv = tree_view->priv;
8557
8558   if (adjustment && priv->hadjustment == adjustment)
8559     return;
8560
8561   if (priv->hadjustment != NULL)
8562     {
8563       g_signal_handlers_disconnect_by_func (priv->hadjustment,
8564                                             pspp_sheet_view_adjustment_changed,
8565                                             tree_view);
8566       g_object_unref (priv->hadjustment);
8567     }
8568
8569   if (adjustment == NULL)
8570     adjustment = gtk_adjustment_new (0.0, 0.0, 0.0,
8571                                      0.0, 0.0, 0.0);
8572
8573   g_signal_connect (adjustment, "value-changed",
8574                     G_CALLBACK (pspp_sheet_view_adjustment_changed), tree_view);
8575   priv->hadjustment = g_object_ref_sink (adjustment);
8576   /* FIXME: Adjustment should probably be populated here with fresh values, but
8577    * internal details are too complicated for me to decipher right now.
8578    */
8579   pspp_sheet_view_adjustment_changed (NULL, tree_view);
8580
8581   g_object_notify (G_OBJECT (tree_view), "hadjustment");
8582 }
8583
8584 /**
8585  * pspp_sheet_view_get_vadjustment:
8586  * @tree_view: A #PsppSheetView
8587  *
8588  * Gets the #GtkAdjustment currently being used for the vertical aspect.
8589  *
8590  * Return value: (transfer none): A #GtkAdjustment object, or %NULL
8591  *     if none is currently being used.
8592  *
8593  * Deprecated: 3.0: Use gtk_scrollable_get_vadjustment()
8594  **/
8595 GtkAdjustment *
8596 pspp_sheet_view_get_vadjustment (PsppSheetView *tree_view)
8597 {
8598   g_return_val_if_fail (PSPP_IS_SHEET_VIEW (tree_view), NULL);
8599
8600   return pspp_sheet_view_do_get_vadjustment (tree_view);
8601 }
8602
8603 static GtkAdjustment *
8604 pspp_sheet_view_do_get_vadjustment (PsppSheetView *tree_view)
8605 {
8606   return tree_view->priv->vadjustment;
8607 }
8608
8609 /**
8610  * pspp_sheet_view_set_vadjustment:
8611  * @tree_view: A #PsppSheetView
8612  * @adjustment: (allow-none): The #GtkAdjustment to set, or %NULL
8613  *
8614  * Sets the #GtkAdjustment for the current vertical aspect.
8615  *
8616  * Deprecated: 3.0: Use gtk_scrollable_set_vadjustment()
8617  **/
8618 void
8619 pspp_sheet_view_set_vadjustment (PsppSheetView   *tree_view,
8620                                GtkAdjustment *adjustment)
8621 {
8622   g_return_if_fail (PSPP_IS_SHEET_VIEW (tree_view));
8623   g_return_if_fail (adjustment == NULL || GTK_IS_ADJUSTMENT (adjustment));
8624
8625   pspp_sheet_view_do_set_vadjustment (tree_view, adjustment);
8626 }
8627
8628 static void
8629 pspp_sheet_view_do_set_vadjustment (PsppSheetView   *tree_view,
8630                                   GtkAdjustment *adjustment)
8631 {
8632   PsppSheetViewPrivate *priv = tree_view->priv;
8633
8634   if (adjustment && priv->vadjustment == adjustment)
8635     return;
8636
8637   if (priv->vadjustment != NULL)
8638     {
8639       g_signal_handlers_disconnect_by_func (priv->vadjustment,
8640                                             pspp_sheet_view_adjustment_changed,
8641                                             tree_view);
8642       g_object_unref (priv->vadjustment);
8643     }
8644
8645   if (adjustment == NULL)
8646     adjustment = gtk_adjustment_new (0.0, 0.0, 0.0,
8647                                      0.0, 0.0, 0.0);
8648
8649   g_signal_connect (adjustment, "value-changed",
8650                     G_CALLBACK (pspp_sheet_view_adjustment_changed), tree_view);
8651   priv->vadjustment = g_object_ref_sink (adjustment);
8652   /* FIXME: Adjustment should probably be populated here with fresh values, but
8653    * internal details are too complicated for me to decipher right now.
8654    */
8655   pspp_sheet_view_adjustment_changed (NULL, tree_view);
8656   g_object_notify (G_OBJECT (tree_view), "vadjustment");
8657 }
8658
8659 /* Column and header operations */
8660
8661 /**
8662  * pspp_sheet_view_get_headers_visible:
8663  * @tree_view: A #PsppSheetView.
8664  *
8665  * Returns %TRUE if the headers on the @tree_view are visible.
8666  *
8667  * Return value: Whether the headers are visible or not.
8668  **/
8669 gboolean
8670 pspp_sheet_view_get_headers_visible (PsppSheetView *tree_view)
8671 {
8672   g_return_val_if_fail (PSPP_IS_SHEET_VIEW (tree_view), FALSE);
8673
8674   return PSPP_SHEET_VIEW_FLAG_SET (tree_view, PSPP_SHEET_VIEW_HEADERS_VISIBLE);
8675 }
8676
8677 /**
8678  * pspp_sheet_view_set_headers_visible:
8679  * @tree_view: A #PsppSheetView.
8680  * @headers_visible: %TRUE if the headers are visible
8681  *
8682  * Sets the visibility state of the headers.
8683  **/
8684 void
8685 pspp_sheet_view_set_headers_visible (PsppSheetView *tree_view,
8686                                    gboolean     headers_visible)
8687 {
8688   gint x, y;
8689   GList *list;
8690   PsppSheetViewColumn *column;
8691   GtkAllocation allocation;
8692
8693   g_return_if_fail (PSPP_IS_SHEET_VIEW (tree_view));
8694
8695   gtk_widget_get_allocation (GTK_WIDGET (tree_view), &allocation);
8696
8697   headers_visible = !! headers_visible;
8698
8699   if (PSPP_SHEET_VIEW_FLAG_SET (tree_view, PSPP_SHEET_VIEW_HEADERS_VISIBLE) == headers_visible)
8700     return;
8701
8702   if (headers_visible)
8703     PSPP_SHEET_VIEW_SET_FLAG (tree_view, PSPP_SHEET_VIEW_HEADERS_VISIBLE);
8704   else
8705     PSPP_SHEET_VIEW_UNSET_FLAG (tree_view, PSPP_SHEET_VIEW_HEADERS_VISIBLE);
8706
8707   if (gtk_widget_get_realized (GTK_WIDGET (tree_view)))
8708     {
8709       gdk_window_get_position (tree_view->priv->bin_window, &x, &y);
8710       if (headers_visible)
8711         {
8712           gdk_window_move_resize (tree_view->priv->bin_window, x, y  + TREE_VIEW_HEADER_HEIGHT (tree_view),
8713                                   tree_view->priv->width, allocation.height -  + TREE_VIEW_HEADER_HEIGHT (tree_view));
8714
8715           if (gtk_widget_get_mapped (GTK_WIDGET (tree_view)))
8716             pspp_sheet_view_map_buttons (tree_view);
8717         }
8718       else
8719         {
8720           gdk_window_move_resize (tree_view->priv->bin_window, x, y, tree_view->priv->width, tree_view->priv->height);
8721
8722           for (list = tree_view->priv->columns; list; list = list->next)
8723             {
8724               column = list->data;
8725               if (column->button)
8726                 gtk_widget_unmap (column->button);
8727             }
8728           gdk_window_hide (tree_view->priv->header_window);
8729         }
8730     }
8731
8732   gtk_adjustment_set_page_size (tree_view->priv->vadjustment, allocation.height - TREE_VIEW_HEADER_HEIGHT (tree_view));
8733   gtk_adjustment_set_page_increment (tree_view->priv->vadjustment, (allocation.height - TREE_VIEW_HEADER_HEIGHT (tree_view)) / 2);
8734   gtk_adjustment_set_lower (tree_view->priv->vadjustment, 0);
8735   gtk_adjustment_set_upper (tree_view->priv->vadjustment, tree_view->priv->height);
8736   gtk_adjustment_changed (tree_view->priv->vadjustment);
8737
8738   gtk_widget_queue_resize (GTK_WIDGET (tree_view));
8739
8740   g_object_notify (G_OBJECT (tree_view), "headers-visible");
8741 }
8742
8743 /**
8744  * pspp_sheet_view_columns_autosize:
8745  * @tree_view: A #PsppSheetView.
8746  *
8747  * Resizes all columns to their optimal width. Only works after the
8748  * treeview has been realized.
8749  **/
8750 void
8751 pspp_sheet_view_columns_autosize (PsppSheetView *tree_view)
8752 {
8753   gboolean dirty = FALSE;
8754   GList *list;
8755   PsppSheetViewColumn *column;
8756
8757   g_return_if_fail (PSPP_IS_SHEET_VIEW (tree_view));
8758
8759   for (list = tree_view->priv->columns; list; list = list->next)
8760     {
8761       column = list->data;
8762       _pspp_sheet_view_column_cell_set_dirty (column);
8763       dirty = TRUE;
8764     }
8765
8766   if (dirty)
8767     gtk_widget_queue_resize (GTK_WIDGET (tree_view));
8768 }
8769
8770 /**
8771  * pspp_sheet_view_set_headers_clickable:
8772  * @tree_view: A #PsppSheetView.
8773  * @setting: %TRUE if the columns are clickable.
8774  *
8775  * Allow the column title buttons to be clicked.
8776  **/
8777 void
8778 pspp_sheet_view_set_headers_clickable (PsppSheetView *tree_view,
8779                                      gboolean   setting)
8780 {
8781   GList *list;
8782
8783   g_return_if_fail (PSPP_IS_SHEET_VIEW (tree_view));
8784
8785   for (list = tree_view->priv->columns; list; list = list->next)
8786     pspp_sheet_view_column_set_clickable (PSPP_SHEET_VIEW_COLUMN (list->data), setting);
8787
8788   g_object_notify (G_OBJECT (tree_view), "headers-clickable");
8789 }
8790
8791
8792 /**
8793  * pspp_sheet_view_get_headers_clickable:
8794  * @tree_view: A #PsppSheetView.
8795  *
8796  * Returns whether all header columns are clickable.
8797  *
8798  * Return value: %TRUE if all header columns are clickable, otherwise %FALSE
8799  *
8800  * Since: 2.10
8801  **/
8802 gboolean
8803 pspp_sheet_view_get_headers_clickable (PsppSheetView *tree_view)
8804 {
8805   GList *list;
8806
8807   g_return_val_if_fail (PSPP_IS_SHEET_VIEW (tree_view), FALSE);
8808
8809   for (list = tree_view->priv->columns; list; list = list->next)
8810     if (!PSPP_SHEET_VIEW_COLUMN (list->data)->clickable)
8811       return FALSE;
8812
8813   return TRUE;
8814 }
8815
8816 /**
8817  * pspp_sheet_view_set_rules_hint
8818  * @tree_view: a #PsppSheetView
8819  * @setting: %TRUE if the tree requires reading across rows
8820  *
8821  * This function tells GTK+ that the user interface for your
8822  * application requires users to read across tree rows and associate
8823  * cells with one another. By default, GTK+ will then render the tree
8824  * with alternating row colors. Do <emphasis>not</emphasis> use it
8825  * just because you prefer the appearance of the ruled tree; that's a
8826  * question for the theme. Some themes will draw tree rows in
8827  * alternating colors even when rules are turned off, and users who
8828  * prefer that appearance all the time can choose those themes. You
8829  * should call this function only as a <emphasis>semantic</emphasis>
8830  * hint to the theme engine that your tree makes alternating colors
8831  * useful from a functional standpoint (since it has lots of columns,
8832  * generally).
8833  *
8834  **/
8835 void
8836 pspp_sheet_view_set_rules_hint (PsppSheetView  *tree_view,
8837                               gboolean      setting)
8838 {
8839   g_return_if_fail (PSPP_IS_SHEET_VIEW (tree_view));
8840
8841   setting = setting != FALSE;
8842
8843   if (tree_view->priv->has_rules != setting)
8844     {
8845       tree_view->priv->has_rules = setting;
8846       gtk_widget_queue_draw (GTK_WIDGET (tree_view));
8847     }
8848
8849   g_object_notify (G_OBJECT (tree_view), "rules-hint");
8850 }
8851
8852 /**
8853  * pspp_sheet_view_get_rules_hint
8854  * @tree_view: a #PsppSheetView
8855  *
8856  * Gets the setting set by pspp_sheet_view_set_rules_hint().
8857  *
8858  * Return value: %TRUE if rules are useful for the user of this tree
8859  **/
8860 gboolean
8861 pspp_sheet_view_get_rules_hint (PsppSheetView  *tree_view)
8862 {
8863   g_return_val_if_fail (PSPP_IS_SHEET_VIEW (tree_view), FALSE);
8864
8865   return tree_view->priv->has_rules;
8866 }
8867
8868 /* Public Column functions
8869  */
8870
8871 /**
8872  * pspp_sheet_view_append_column:
8873  * @tree_view: A #PsppSheetView.
8874  * @column: The #PsppSheetViewColumn to add.
8875  *
8876  * Appends @column to the list of columns.
8877  *
8878  * Return value: The number of columns in @tree_view after appending.
8879  **/
8880 gint
8881 pspp_sheet_view_append_column (PsppSheetView       *tree_view,
8882                              PsppSheetViewColumn *column)
8883 {
8884   g_return_val_if_fail (PSPP_IS_SHEET_VIEW (tree_view), -1);
8885   g_return_val_if_fail (PSPP_IS_SHEET_VIEW_COLUMN (column), -1);
8886   g_return_val_if_fail (column->tree_view == NULL, -1);
8887
8888   return pspp_sheet_view_insert_column (tree_view, column, -1);
8889 }
8890
8891
8892 /**
8893  * pspp_sheet_view_remove_column:
8894  * @tree_view: A #PsppSheetView.
8895  * @column: The #PsppSheetViewColumn to remove.
8896  *
8897  * Removes @column from @tree_view.
8898  *
8899  * Return value: The number of columns in @tree_view after removing.
8900  **/
8901 gint
8902 pspp_sheet_view_remove_column (PsppSheetView       *tree_view,
8903                              PsppSheetViewColumn *column)
8904 {
8905   g_return_val_if_fail (PSPP_IS_SHEET_VIEW (tree_view), -1);
8906   g_return_val_if_fail (PSPP_IS_SHEET_VIEW_COLUMN (column), -1);
8907   g_return_val_if_fail (column->tree_view == GTK_WIDGET (tree_view), -1);
8908
8909   if (tree_view->priv->focus_column == column)
8910     tree_view->priv->focus_column = NULL;
8911
8912   if (tree_view->priv->edited_column == column)
8913     {
8914       pspp_sheet_view_stop_editing (tree_view, TRUE);
8915
8916       /* no need to, but just to be sure ... */
8917       tree_view->priv->edited_column = NULL;
8918     }
8919
8920   _pspp_sheet_view_column_unset_tree_view (column);
8921
8922   tree_view->priv->columns = g_list_remove (tree_view->priv->columns, column);
8923   tree_view->priv->n_columns--;
8924
8925   if (gtk_widget_get_realized (GTK_WIDGET (tree_view)))
8926     {
8927       GList *list;
8928
8929       _pspp_sheet_view_column_unrealize_button (column);
8930       for (list = tree_view->priv->columns; list; list = list->next)
8931         {
8932           PsppSheetViewColumn *tmp_column;
8933
8934           tmp_column = PSPP_SHEET_VIEW_COLUMN (list->data);
8935           if (tmp_column->visible)
8936             _pspp_sheet_view_column_cell_set_dirty (tmp_column);
8937         }
8938
8939       if (tree_view->priv->n_columns == 0 &&
8940           pspp_sheet_view_get_headers_visible (tree_view) &&
8941           tree_view->priv->header_window)
8942         gdk_window_hide (tree_view->priv->header_window);
8943
8944       gtk_widget_queue_resize (GTK_WIDGET (tree_view));
8945     }
8946
8947   g_object_unref (column);
8948   g_signal_emit (tree_view, tree_view_signals[COLUMNS_CHANGED], 0);
8949
8950   return tree_view->priv->n_columns;
8951 }
8952
8953 /**
8954  * pspp_sheet_view_insert_column:
8955  * @tree_view: A #PsppSheetView.
8956  * @column: The #PsppSheetViewColumn to be inserted.
8957  * @position: The position to insert @column in.
8958  *
8959  * This inserts the @column into the @tree_view at @position.  If @position is
8960  * -1, then the column is inserted at the end.
8961  *
8962  * Return value: The number of columns in @tree_view after insertion.
8963  **/
8964 gint
8965 pspp_sheet_view_insert_column (PsppSheetView       *tree_view,
8966                              PsppSheetViewColumn *column,
8967                              gint               position)
8968 {
8969   g_return_val_if_fail (PSPP_IS_SHEET_VIEW (tree_view), -1);
8970   g_return_val_if_fail (PSPP_IS_SHEET_VIEW_COLUMN (column), -1);
8971   g_return_val_if_fail (column->tree_view == NULL, -1);
8972
8973   g_object_ref_sink (column);
8974
8975   if (tree_view->priv->n_columns == 0 &&
8976       gtk_widget_get_realized (GTK_WIDGET (tree_view)) &&
8977       pspp_sheet_view_get_headers_visible (tree_view))
8978     {
8979       gdk_window_show (tree_view->priv->header_window);
8980     }
8981
8982   tree_view->priv->columns = g_list_insert (tree_view->priv->columns,
8983                                             column, position);
8984   tree_view->priv->n_columns++;
8985
8986   _pspp_sheet_view_column_set_tree_view (column, tree_view);
8987
8988   if (gtk_widget_get_realized (GTK_WIDGET (tree_view)))
8989     {
8990       GList *list;
8991
8992       _pspp_sheet_view_column_realize_button (column);
8993
8994       for (list = tree_view->priv->columns; list; list = list->next)
8995         {
8996           column = PSPP_SHEET_VIEW_COLUMN (list->data);
8997           if (column->visible)
8998             _pspp_sheet_view_column_cell_set_dirty (column);
8999         }
9000       gtk_widget_queue_resize (GTK_WIDGET (tree_view));
9001     }
9002
9003   g_signal_emit (tree_view, tree_view_signals[COLUMNS_CHANGED], 0);
9004
9005   return tree_view->priv->n_columns;
9006 }
9007
9008 /**
9009  * pspp_sheet_view_insert_column_with_attributes:
9010  * @tree_view: A #PsppSheetView
9011  * @position: The position to insert the new column in.
9012  * @title: The title to set the header to.
9013  * @cell: The #GtkCellRenderer.
9014  * @Varargs: A %NULL-terminated list of attributes.
9015  *
9016  * Creates a new #PsppSheetViewColumn and inserts it into the @tree_view at
9017  * @position.  If @position is -1, then the newly created column is inserted at
9018  * the end.  The column is initialized with the attributes given.
9019  *
9020  * Return value: The number of columns in @tree_view after insertion.
9021  **/
9022 gint
9023 pspp_sheet_view_insert_column_with_attributes (PsppSheetView     *tree_view,
9024                                              gint             position,
9025                                              const gchar     *title,
9026                                              GtkCellRenderer *cell,
9027                                              ...)
9028 {
9029   PsppSheetViewColumn *column;
9030   gchar *attribute;
9031   va_list args;
9032   gint column_id;
9033
9034   g_return_val_if_fail (PSPP_IS_SHEET_VIEW (tree_view), -1);
9035
9036   column = pspp_sheet_view_column_new ();
9037   pspp_sheet_view_column_set_title (column, title);
9038   pspp_sheet_view_column_pack_start (column, cell, TRUE);
9039
9040   va_start (args, cell);
9041
9042   attribute = va_arg (args, gchar *);
9043
9044   while (attribute != NULL)
9045     {
9046       column_id = va_arg (args, gint);
9047       pspp_sheet_view_column_add_attribute (column, cell, attribute, column_id);
9048       attribute = va_arg (args, gchar *);
9049     }
9050
9051   va_end (args);
9052
9053   pspp_sheet_view_insert_column (tree_view, column, position);
9054
9055   return tree_view->priv->n_columns;
9056 }
9057
9058 /**
9059  * pspp_sheet_view_insert_column_with_data_func:
9060  * @tree_view: a #PsppSheetView
9061  * @position: Position to insert, -1 for append
9062  * @title: column title
9063  * @cell: cell renderer for column
9064  * @func: function to set attributes of cell renderer
9065  * @data: data for @func
9066  * @dnotify: destroy notifier for @data
9067  *
9068  * Convenience function that inserts a new column into the #PsppSheetView
9069  * with the given cell renderer and a #GtkCellDataFunc to set cell renderer
9070  * attributes (normally using data from the model). See also
9071  * pspp_sheet_view_column_set_cell_data_func(), pspp_sheet_view_column_pack_start().
9072  *
9073  * Return value: number of columns in the tree view post-insert
9074  **/
9075 gint
9076 pspp_sheet_view_insert_column_with_data_func  (PsppSheetView               *tree_view,
9077                                              gint                       position,
9078                                              const gchar               *title,
9079                                              GtkCellRenderer           *cell,
9080                                              PsppSheetCellDataFunc        func,
9081                                              gpointer                   data,
9082                                              GDestroyNotify             dnotify)
9083 {
9084   PsppSheetViewColumn *column;
9085
9086   g_return_val_if_fail (PSPP_IS_SHEET_VIEW (tree_view), -1);
9087
9088   column = pspp_sheet_view_column_new ();
9089   pspp_sheet_view_column_set_title (column, title);
9090   pspp_sheet_view_column_pack_start (column, cell, TRUE);
9091   pspp_sheet_view_column_set_cell_data_func (column, cell, func, data, dnotify);
9092
9093   pspp_sheet_view_insert_column (tree_view, column, position);
9094
9095   return tree_view->priv->n_columns;
9096 }
9097
9098 /**
9099  * pspp_sheet_view_get_column:
9100  * @tree_view: A #PsppSheetView.
9101  * @n: The position of the column, counting from 0.
9102  *
9103  * Gets the #PsppSheetViewColumn at the given position in the #tree_view.
9104  *
9105  * Return value: The #PsppSheetViewColumn, or %NULL if the position is outside the
9106  * range of columns.
9107  **/
9108 PsppSheetViewColumn *
9109 pspp_sheet_view_get_column (PsppSheetView *tree_view,
9110                           gint         n)
9111 {
9112   g_return_val_if_fail (PSPP_IS_SHEET_VIEW (tree_view), NULL);
9113
9114   if (n < 0 || n >= tree_view->priv->n_columns)
9115     return NULL;
9116
9117   if (tree_view->priv->columns == NULL)
9118     return NULL;
9119
9120   return PSPP_SHEET_VIEW_COLUMN (g_list_nth (tree_view->priv->columns, n)->data);
9121 }
9122
9123 /**
9124  * pspp_sheet_view_get_columns:
9125  * @tree_view: A #PsppSheetView
9126  *
9127  * Returns a #GList of all the #PsppSheetViewColumn s currently in @tree_view.
9128  * The returned list must be freed with g_list_free ().
9129  *
9130  * Return value: (element-type PsppSheetViewColumn) (transfer container): A list of #PsppSheetViewColumn s
9131  **/
9132 GList *
9133 pspp_sheet_view_get_columns (PsppSheetView *tree_view)
9134 {
9135   g_return_val_if_fail (PSPP_IS_SHEET_VIEW (tree_view), NULL);
9136
9137   return g_list_copy (tree_view->priv->columns);
9138 }
9139
9140 /**
9141  * pspp_sheet_view_move_column_after:
9142  * @tree_view: A #PsppSheetView
9143  * @column: The #PsppSheetViewColumn to be moved.
9144  * @base_column: (allow-none): The #PsppSheetViewColumn to be moved relative to, or %NULL.
9145  *
9146  * Moves @column to be after to @base_column.  If @base_column is %NULL, then
9147  * @column is placed in the first position.
9148  **/
9149 void
9150 pspp_sheet_view_move_column_after (PsppSheetView       *tree_view,
9151                                  PsppSheetViewColumn *column,
9152                                  PsppSheetViewColumn *base_column)
9153 {
9154   GList *column_list_el, *base_el = NULL;
9155
9156   g_return_if_fail (PSPP_IS_SHEET_VIEW (tree_view));
9157
9158   column_list_el = g_list_find (tree_view->priv->columns, column);
9159   g_return_if_fail (column_list_el != NULL);
9160
9161   if (base_column)
9162     {
9163       base_el = g_list_find (tree_view->priv->columns, base_column);
9164       g_return_if_fail (base_el != NULL);
9165     }
9166
9167   if (column_list_el->prev == base_el)
9168     return;
9169
9170   tree_view->priv->columns = g_list_remove_link (tree_view->priv->columns, column_list_el);
9171   if (base_el == NULL)
9172     {
9173       column_list_el->prev = NULL;
9174       column_list_el->next = tree_view->priv->columns;
9175       if (column_list_el->next)
9176         column_list_el->next->prev = column_list_el;
9177       tree_view->priv->columns = column_list_el;
9178     }
9179   else
9180     {
9181       column_list_el->prev = base_el;
9182       column_list_el->next = base_el->next;
9183       if (column_list_el->next)
9184         column_list_el->next->prev = column_list_el;
9185       base_el->next = column_list_el;
9186     }
9187
9188   if (gtk_widget_get_realized (GTK_WIDGET (tree_view)))
9189     {
9190       gtk_widget_queue_resize (GTK_WIDGET (tree_view));
9191       pspp_sheet_view_size_allocate_columns (GTK_WIDGET (tree_view), NULL);
9192     }
9193
9194   g_signal_emit (tree_view, tree_view_signals[COLUMNS_CHANGED], 0);
9195 }
9196
9197 /**
9198  * pspp_sheet_view_set_column_drag_function:
9199  * @tree_view: A #PsppSheetView.
9200  * @func: (allow-none): A function to determine which columns are reorderable, or %NULL.
9201  * @user_data: (allow-none): User data to be passed to @func, or %NULL
9202  * @destroy: (allow-none): Destroy notifier for @user_data, or %NULL
9203  *
9204  * Sets a user function for determining where a column may be dropped when
9205  * dragged.  This function is called on every column pair in turn at the
9206  * beginning of a column drag to determine where a drop can take place.  The
9207  * arguments passed to @func are: the @tree_view, the #PsppSheetViewColumn being
9208  * dragged, the two #PsppSheetViewColumn s determining the drop spot, and
9209  * @user_data.  If either of the #PsppSheetViewColumn arguments for the drop spot
9210  * are %NULL, then they indicate an edge.  If @func is set to be %NULL, then
9211  * @tree_view reverts to the default behavior of allowing all columns to be
9212  * dropped everywhere.
9213  **/
9214 void
9215 pspp_sheet_view_set_column_drag_function (PsppSheetView               *tree_view,
9216                                         PsppSheetViewColumnDropFunc  func,
9217                                         gpointer                   user_data,
9218                                         GDestroyNotify             destroy)
9219 {
9220   g_return_if_fail (PSPP_IS_SHEET_VIEW (tree_view));
9221
9222   if (tree_view->priv->column_drop_func_data_destroy)
9223     tree_view->priv->column_drop_func_data_destroy (tree_view->priv->column_drop_func_data);
9224
9225   tree_view->priv->column_drop_func = func;
9226   tree_view->priv->column_drop_func_data = user_data;
9227   tree_view->priv->column_drop_func_data_destroy = destroy;
9228 }
9229
9230 /**
9231  * pspp_sheet_view_scroll_to_point:
9232  * @tree_view: a #PsppSheetView
9233  * @tree_x: X coordinate of new top-left pixel of visible area, or -1
9234  * @tree_y: Y coordinate of new top-left pixel of visible area, or -1
9235  *
9236  * Scrolls the tree view such that the top-left corner of the visible
9237  * area is @tree_x, @tree_y, where @tree_x and @tree_y are specified
9238  * in tree coordinates.  The @tree_view must be realized before
9239  * this function is called.  If it isn't, you probably want to be
9240  * using pspp_sheet_view_scroll_to_cell().
9241  *
9242  * If either @tree_x or @tree_y are -1, then that direction isn't scrolled.
9243  **/
9244 void
9245 pspp_sheet_view_scroll_to_point (PsppSheetView *tree_view,
9246                                gint         tree_x,
9247                                gint         tree_y)
9248 {
9249   GtkAdjustment *hadj;
9250   GtkAdjustment *vadj;
9251
9252   g_return_if_fail (PSPP_IS_SHEET_VIEW (tree_view));
9253   g_return_if_fail (gtk_widget_get_realized (GTK_WIDGET (tree_view)));
9254
9255   hadj = tree_view->priv->hadjustment;
9256   vadj = tree_view->priv->vadjustment;
9257
9258   if (tree_x != -1)
9259     gtk_adjustment_set_value (hadj, CLAMP (tree_x, gtk_adjustment_get_lower (hadj), gtk_adjustment_get_upper (hadj) - gtk_adjustment_get_page_size (hadj)));
9260   if (tree_y != -1)
9261     gtk_adjustment_set_value (vadj, CLAMP (tree_y, gtk_adjustment_get_lower (vadj), gtk_adjustment_get_upper (vadj) - gtk_adjustment_get_page_size (vadj)));
9262 }
9263
9264 /**
9265  * pspp_sheet_view_scroll_to_cell:
9266  * @tree_view: A #PsppSheetView.
9267  * @path: (allow-none): The path of the row to move to, or %NULL.
9268  * @column: (allow-none): The #PsppSheetViewColumn to move horizontally to, or %NULL.
9269  * @use_align: whether to use alignment arguments, or %FALSE.
9270  * @row_align: The vertical alignment of the row specified by @path.
9271  * @col_align: The horizontal alignment of the column specified by @column.
9272  *
9273  * Moves the alignments of @tree_view to the position specified by @column and
9274  * @path.  If @column is %NULL, then no horizontal scrolling occurs.  Likewise,
9275  * if @path is %NULL no vertical scrolling occurs.  At a minimum, one of @column
9276  * or @path need to be non-%NULL.  @row_align determines where the row is
9277  * placed, and @col_align determines where @column is placed.  Both are expected
9278  * to be between 0.0 and 1.0. 0.0 means left/top alignment, 1.0 means
9279  * right/bottom alignment, 0.5 means center.
9280  *
9281  * If @use_align is %FALSE, then the alignment arguments are ignored, and the
9282  * tree does the minimum amount of work to scroll the cell onto the screen.
9283  * This means that the cell will be scrolled to the edge closest to its current
9284  * position.  If the cell is currently visible on the screen, nothing is done.
9285  *
9286  * This function only works if the model is set, and @path is a valid row on the
9287  * model.  If the model changes before the @tree_view is realized, the centered
9288  * path will be modified to reflect this change.
9289  **/
9290 void
9291 pspp_sheet_view_scroll_to_cell (PsppSheetView       *tree_view,
9292                               GtkTreePath       *path,
9293                               PsppSheetViewColumn *column,
9294                               gboolean           use_align,
9295                               gfloat             row_align,
9296                               gfloat             col_align)
9297 {
9298   g_return_if_fail (PSPP_IS_SHEET_VIEW (tree_view));
9299   g_return_if_fail (tree_view->priv->model != NULL);
9300   g_return_if_fail (row_align >= 0.0 && row_align <= 1.0);
9301   g_return_if_fail (col_align >= 0.0 && col_align <= 1.0);
9302   g_return_if_fail (path != NULL || column != NULL);
9303
9304 #if 0
9305   g_print ("pspp_sheet_view_scroll_to_cell:\npath: %s\ncolumn: %s\nuse_align: %d\nrow_align: %f\ncol_align: %f\n",
9306            gtk_tree_path_to_string (path), column?"non-null":"null", use_align, row_align, col_align);
9307 #endif
9308   row_align = CLAMP (row_align, 0.0, 1.0);
9309   col_align = CLAMP (col_align, 0.0, 1.0);
9310
9311
9312   /* Note: Despite the benefits that come from having one code path for the
9313    * scrolling code, we short-circuit validate_visible_area's immplementation as
9314    * it is much slower than just going to the point.
9315    */
9316   if (!gtk_widget_get_visible (GTK_WIDGET (tree_view)) ||
9317       !gtk_widget_get_realized (GTK_WIDGET (tree_view))
9318       /* XXX || GTK_WIDGET_ALLOC_NEEDED (tree_view) */)
9319     {
9320       if (tree_view->priv->scroll_to_path)
9321         gtk_tree_row_reference_free (tree_view->priv->scroll_to_path);
9322
9323       tree_view->priv->scroll_to_path = NULL;
9324       tree_view->priv->scroll_to_column = NULL;
9325
9326       if (path)
9327         tree_view->priv->scroll_to_path = gtk_tree_row_reference_new_proxy (G_OBJECT (tree_view), tree_view->priv->model, path);
9328       if (column)
9329         tree_view->priv->scroll_to_column = column;
9330       tree_view->priv->scroll_to_use_align = use_align;
9331       tree_view->priv->scroll_to_row_align = row_align;
9332       tree_view->priv->scroll_to_col_align = col_align;
9333
9334       install_presize_handler (tree_view);
9335     }
9336   else
9337     {
9338       GdkRectangle cell_rect;
9339       GdkRectangle vis_rect;
9340       gint dest_x, dest_y;
9341
9342       pspp_sheet_view_get_background_area (tree_view, path, column, &cell_rect);
9343       pspp_sheet_view_get_visible_rect (tree_view, &vis_rect);
9344
9345       cell_rect.y = TREE_WINDOW_Y_TO_RBTREE_Y (tree_view, cell_rect.y);
9346
9347       dest_x = vis_rect.x;
9348       dest_y = vis_rect.y;
9349
9350       if (column)
9351         {
9352           if (use_align)
9353             {
9354               dest_x = cell_rect.x - ((vis_rect.width - cell_rect.width) * col_align);
9355             }
9356           else
9357             {
9358               if (cell_rect.x < vis_rect.x)
9359                 dest_x = cell_rect.x;
9360               if (cell_rect.x + cell_rect.width > vis_rect.x + vis_rect.width)
9361                 dest_x = cell_rect.x + cell_rect.width - vis_rect.width;
9362             }
9363         }
9364
9365       if (path)
9366         {
9367           if (use_align)
9368             {
9369               dest_y = cell_rect.y - ((vis_rect.height - cell_rect.height) * row_align);
9370               dest_y = MAX (dest_y, 0);
9371             }
9372           else
9373             {
9374               if (cell_rect.y < vis_rect.y)
9375                 dest_y = cell_rect.y;
9376               if (cell_rect.y + cell_rect.height > vis_rect.y + vis_rect.height)
9377                 dest_y = cell_rect.y + cell_rect.height - vis_rect.height;
9378             }
9379         }
9380
9381       pspp_sheet_view_scroll_to_point (tree_view, dest_x, dest_y);
9382     }
9383 }
9384
9385 /**
9386  * pspp_sheet_view_row_activated:
9387  * @tree_view: A #PsppSheetView
9388  * @path: The #GtkTreePath to be activated.
9389  * @column: The #PsppSheetViewColumn to be activated.
9390  *
9391  * Activates the cell determined by @path and @column.
9392  **/
9393 void
9394 pspp_sheet_view_row_activated (PsppSheetView       *tree_view,
9395                              GtkTreePath       *path,
9396                              PsppSheetViewColumn *column)
9397 {
9398   g_return_if_fail (PSPP_IS_SHEET_VIEW (tree_view));
9399
9400   g_signal_emit (tree_view, tree_view_signals[ROW_ACTIVATED], 0, path, column);
9401 }
9402
9403
9404 /**
9405  * pspp_sheet_view_get_reorderable:
9406  * @tree_view: a #PsppSheetView
9407  *
9408  * Retrieves whether the user can reorder the tree via drag-and-drop. See
9409  * pspp_sheet_view_set_reorderable().
9410  *
9411  * Return value: %TRUE if the tree can be reordered.
9412  **/
9413 gboolean
9414 pspp_sheet_view_get_reorderable (PsppSheetView *tree_view)
9415 {
9416   g_return_val_if_fail (PSPP_IS_SHEET_VIEW (tree_view), FALSE);
9417
9418   return tree_view->priv->reorderable;
9419 }
9420
9421 /**
9422  * pspp_sheet_view_set_reorderable:
9423  * @tree_view: A #PsppSheetView.
9424  * @reorderable: %TRUE, if the tree can be reordered.
9425  *
9426  * This function is a convenience function to allow you to reorder
9427  * models that support the #GtkDragSourceIface and the
9428  * #GtkDragDestIface.  Both #GtkTreeStore and #GtkListStore support
9429  * these.  If @reorderable is %TRUE, then the user can reorder the
9430  * model by dragging and dropping rows. The developer can listen to
9431  * these changes by connecting to the model's row_inserted and
9432  * row_deleted signals. The reordering is implemented by setting up
9433  * the tree view as a drag source and destination. Therefore, drag and
9434  * drop can not be used in a reorderable view for any other purpose.
9435  *
9436  * This function does not give you any degree of control over the order -- any
9437  * reordering is allowed.  If more control is needed, you should probably
9438  * handle drag and drop manually.
9439  **/
9440 void
9441 pspp_sheet_view_set_reorderable (PsppSheetView *tree_view,
9442                                gboolean     reorderable)
9443 {
9444   g_return_if_fail (PSPP_IS_SHEET_VIEW (tree_view));
9445
9446   reorderable = reorderable != FALSE;
9447
9448   if (tree_view->priv->reorderable == reorderable)
9449     return;
9450
9451   if (reorderable)
9452     {
9453       const GtkTargetEntry row_targets[] = {
9454         { "GTK_TREE_MODEL_ROW", GTK_TARGET_SAME_WIDGET, 0 }
9455       };
9456
9457       pspp_sheet_view_enable_model_drag_source (tree_view,
9458                                               GDK_BUTTON1_MASK,
9459                                               row_targets,
9460                                               G_N_ELEMENTS (row_targets),
9461                                               GDK_ACTION_MOVE);
9462       pspp_sheet_view_enable_model_drag_dest (tree_view,
9463                                             row_targets,
9464                                             G_N_ELEMENTS (row_targets),
9465                                             GDK_ACTION_MOVE);
9466     }
9467   else
9468     {
9469       pspp_sheet_view_unset_rows_drag_source (tree_view);
9470       pspp_sheet_view_unset_rows_drag_dest (tree_view);
9471     }
9472
9473   tree_view->priv->reorderable = reorderable;
9474
9475   g_object_notify (G_OBJECT (tree_view), "reorderable");
9476 }
9477
9478 /* If CLEAR_AND_SELECT is true, then the row will be selected and, unless Shift
9479    is pressed, other rows will be unselected.
9480
9481    If CLAMP_NODE is true, then the sheetview will scroll to make the row
9482    visible. */
9483 static void
9484 pspp_sheet_view_real_set_cursor (PsppSheetView     *tree_view,
9485                                GtkTreePath     *path,
9486                                gboolean         clear_and_select,
9487                                gboolean         clamp_node,
9488                                PsppSheetSelectMode mode)
9489 {
9490   int node = -1;
9491
9492   if (gtk_tree_row_reference_valid (tree_view->priv->cursor))
9493     {
9494       GtkTreePath *cursor_path;
9495       cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
9496       pspp_sheet_view_queue_draw_path (tree_view, cursor_path, NULL);
9497       gtk_tree_path_free (cursor_path);
9498     }
9499
9500   gtk_tree_row_reference_free (tree_view->priv->cursor);
9501   tree_view->priv->cursor = NULL;
9502
9503   _pspp_sheet_view_find_node (tree_view, path, &node);
9504   tree_view->priv->cursor =
9505     gtk_tree_row_reference_new_proxy (G_OBJECT (tree_view),
9506                                       tree_view->priv->model,
9507                                       path);
9508
9509   if (tree_view->priv->row_count > 0)
9510     {
9511       int new_node = -1;
9512
9513       if (clear_and_select && !(mode & PSPP_SHEET_SELECT_MODE_TOGGLE))
9514         _pspp_sheet_selection_internal_select_node (tree_view->priv->selection,
9515                                                     node, path, mode,
9516                                                     FALSE);
9517
9518       /* We have to re-find tree and node here again, somebody might have
9519        * cleared the node or the whole tree in the PsppSheetSelection::changed
9520        * callback. If the nodes differ we bail out here.
9521        */
9522       _pspp_sheet_view_find_node (tree_view, path, &new_node);
9523
9524       if (node != new_node)
9525         return;
9526
9527       if (clamp_node)
9528         {
9529           pspp_sheet_view_clamp_node_visible (tree_view, node);
9530           _pspp_sheet_view_queue_draw_node (tree_view, node, NULL);
9531         }
9532     }
9533
9534   g_signal_emit (tree_view, tree_view_signals[CURSOR_CHANGED], 0);
9535 }
9536
9537 /**
9538  * pspp_sheet_view_get_cursor:
9539  * @tree_view: A #PsppSheetView
9540  * @path: (allow-none): A pointer to be filled with the current cursor path, or %NULL
9541  * @focus_column: (allow-none): A pointer to be filled with the current focus column, or %NULL
9542  *
9543  * Fills in @path and @focus_column with the current path and focus column.  If
9544  * the cursor isn't currently set, then *@path will be %NULL.  If no column
9545  * currently has focus, then *@focus_column will be %NULL.
9546  *
9547  * The returned #GtkTreePath must be freed with gtk_tree_path_free() when
9548  * you are done with it.
9549  **/
9550 void
9551 pspp_sheet_view_get_cursor (PsppSheetView        *tree_view,
9552                           GtkTreePath       **path,
9553                           PsppSheetViewColumn **focus_column)
9554 {
9555   g_return_if_fail (PSPP_IS_SHEET_VIEW (tree_view));
9556
9557   if (path)
9558     {
9559       if (gtk_tree_row_reference_valid (tree_view->priv->cursor))
9560         *path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
9561       else
9562         *path = NULL;
9563     }
9564
9565   if (focus_column)
9566     {
9567       *focus_column = tree_view->priv->focus_column;
9568     }
9569 }
9570
9571 /**
9572  * pspp_sheet_view_set_cursor:
9573  * @tree_view: A #PsppSheetView
9574  * @path: A #GtkTreePath
9575  * @focus_column: (allow-none): A #PsppSheetViewColumn, or %NULL
9576  * @start_editing: %TRUE if the specified cell should start being edited.
9577  *
9578  * Sets the current keyboard focus to be at @path, and selects it.  This is
9579  * useful when you want to focus the user's attention on a particular row.  If
9580  * @focus_column is not %NULL, then focus is given to the column specified by
9581  * it. Additionally, if @focus_column is specified, and @start_editing is
9582  * %TRUE, then editing should be started in the specified cell.
9583  * This function is often followed by @gtk_widget_grab_focus (@tree_view)
9584  * in order to give keyboard focus to the widget.  Please note that editing
9585  * can only happen when the widget is realized.
9586  *
9587  * If @path is invalid for @model, the current cursor (if any) will be unset
9588  * and the function will return without failing.
9589  **/
9590 void
9591 pspp_sheet_view_set_cursor (PsppSheetView       *tree_view,
9592                           GtkTreePath       *path,
9593                           PsppSheetViewColumn *focus_column,
9594                           gboolean           start_editing)
9595 {
9596   pspp_sheet_view_set_cursor_on_cell (tree_view, path, focus_column,
9597                                     NULL, start_editing);
9598 }
9599
9600 /**
9601  * pspp_sheet_view_set_cursor_on_cell:
9602  * @tree_view: A #PsppSheetView
9603  * @path: A #GtkTreePath
9604  * @focus_column: (allow-none): A #PsppSheetViewColumn, or %NULL
9605  * @focus_cell: (allow-none): A #GtkCellRenderer, or %NULL
9606  * @start_editing: %TRUE if the specified cell should start being edited.
9607  *
9608  * Sets the current keyboard focus to be at @path, and selects it.  This is
9609  * useful when you want to focus the user's attention on a particular row.  If
9610  * @focus_column is not %NULL, then focus is given to the column specified by
9611  * it. If @focus_column and @focus_cell are not %NULL, and @focus_column
9612  * contains 2 or more editable or activatable cells, then focus is given to
9613  * the cell specified by @focus_cell. Additionally, if @focus_column is
9614  * specified, and @start_editing is %TRUE, then editing should be started in
9615  * the specified cell.  This function is often followed by
9616  * @gtk_widget_grab_focus (@tree_view) in order to give keyboard focus to the
9617  * widget.  Please note that editing can only happen when the widget is
9618  * realized.
9619  *
9620  * If @path is invalid for @model, the current cursor (if any) will be unset
9621  * and the function will return without failing.
9622  *
9623  * Since: 2.2
9624  **/
9625 void
9626 pspp_sheet_view_set_cursor_on_cell (PsppSheetView       *tree_view,
9627                                   GtkTreePath       *path,
9628                                   PsppSheetViewColumn *focus_column,
9629                                   GtkCellRenderer   *focus_cell,
9630                                   gboolean           start_editing)
9631 {
9632   g_return_if_fail (PSPP_IS_SHEET_VIEW (tree_view));
9633   g_return_if_fail (path != NULL);
9634   g_return_if_fail (focus_column == NULL || PSPP_IS_SHEET_VIEW_COLUMN (focus_column));
9635
9636   if (!tree_view->priv->model)
9637     return;
9638
9639   if (focus_cell)
9640     {
9641       g_return_if_fail (focus_column);
9642       g_return_if_fail (GTK_IS_CELL_RENDERER (focus_cell));
9643     }
9644
9645   /* cancel the current editing, if it exists */
9646   if (tree_view->priv->edited_column &&
9647       tree_view->priv->edited_column->editable_widget)
9648     pspp_sheet_view_stop_editing (tree_view, TRUE);
9649
9650   pspp_sheet_view_real_set_cursor (tree_view, path, TRUE, TRUE, 0);
9651
9652   if (focus_column && focus_column->visible)
9653     {
9654       GList *list;
9655       gboolean column_in_tree = FALSE;
9656
9657       for (list = tree_view->priv->columns; list; list = list->next)
9658         if (list->data == focus_column)
9659           {
9660             column_in_tree = TRUE;
9661             break;
9662           }
9663       g_return_if_fail (column_in_tree);
9664       tree_view->priv->focus_column = focus_column;
9665       if (focus_cell)
9666         pspp_sheet_view_column_focus_cell (focus_column, focus_cell);
9667       if (start_editing)
9668         pspp_sheet_view_start_editing (tree_view, path);
9669
9670       pspp_sheet_selection_unselect_all_columns (tree_view->priv->selection);
9671       pspp_sheet_selection_select_column (tree_view->priv->selection, focus_column);
9672
9673     }
9674 }
9675
9676 /**
9677  * pspp_sheet_view_get_bin_window:
9678  * @tree_view: A #PsppSheetView
9679  *
9680  * Returns the window that @tree_view renders to.  This is used primarily to
9681  * compare to <literal>event->window</literal> to confirm that the event on
9682  * @tree_view is on the right window.
9683  *
9684  * Return value: A #GdkWindow, or %NULL when @tree_view hasn't been realized yet
9685  **/
9686 GdkWindow *
9687 pspp_sheet_view_get_bin_window (PsppSheetView *tree_view)
9688 {
9689   g_return_val_if_fail (PSPP_IS_SHEET_VIEW (tree_view), NULL);
9690
9691   return tree_view->priv->bin_window;
9692 }
9693
9694 /**
9695  * pspp_sheet_view_get_path_at_pos:
9696  * @tree_view: A #PsppSheetView.
9697  * @x: The x position to be identified (relative to bin_window).
9698  * @y: The y position to be identified (relative to bin_window).
9699  * @path: (out) (allow-none): A pointer to a #GtkTreePath pointer to be filled in, or %NULL
9700  * @column: (out) (allow-none): A pointer to a #PsppSheetViewColumn pointer to be filled in, or %NULL
9701  * @cell_x: (out) (allow-none): A pointer where the X coordinate relative to the cell can be placed, or %NULL
9702  * @cell_y: (out) (allow-none): A pointer where the Y coordinate relative to the cell can be placed, or %NULL
9703  *
9704  * Finds the path at the point (@x, @y), relative to bin_window coordinates
9705  * (please see pspp_sheet_view_get_bin_window()).
9706  * That is, @x and @y are relative to an events coordinates. @x and @y must
9707  * come from an event on the @tree_view only where <literal>event->window ==
9708  * pspp_sheet_view_get_bin_window (<!-- -->)</literal>. It is primarily for
9709  * things like popup menus. If @path is non-%NULL, then it will be filled
9710  * with the #GtkTreePath at that point.  This path should be freed with
9711  * gtk_tree_path_free().  If @column is non-%NULL, then it will be filled
9712  * with the column at that point.  @cell_x and @cell_y return the coordinates
9713  * relative to the cell background (i.e. the @background_area passed to
9714  * gtk_cell_renderer_render()).  This function is only meaningful if
9715  * @tree_view is realized.  Therefore this function will always return %FALSE
9716  * if @tree_view is not realized or does not have a model.
9717  *
9718  * For converting widget coordinates (eg. the ones you get from
9719  * GtkWidget::query-tooltip), please see
9720  * pspp_sheet_view_convert_widget_to_bin_window_coords().
9721  *
9722  * Return value: %TRUE if a row exists at that coordinate.
9723  **/
9724 gboolean
9725 pspp_sheet_view_get_path_at_pos (PsppSheetView        *tree_view,
9726                                gint                x,
9727                                gint                y,
9728                                GtkTreePath       **path,
9729                                PsppSheetViewColumn **column,
9730                                gint               *cell_x,
9731                                gint               *cell_y)
9732 {
9733   int node;
9734   gint y_offset;
9735
9736   g_return_val_if_fail (tree_view != NULL, FALSE);
9737
9738   if (path)
9739     *path = NULL;
9740   if (column)
9741     *column = NULL;
9742
9743   if (tree_view->priv->bin_window == NULL)
9744     return FALSE;
9745
9746   if (tree_view->priv->row_count == 0)
9747     return FALSE;
9748
9749   if (x > gtk_adjustment_get_upper (tree_view->priv->hadjustment))
9750     return FALSE;
9751
9752   if (x < 0 || y < 0)
9753     return FALSE;
9754
9755   if (column || cell_x)
9756     {
9757       PsppSheetViewColumn *tmp_column;
9758       PsppSheetViewColumn *last_column = NULL;
9759       GList *list;
9760       gint remaining_x = x;
9761       gboolean found = FALSE;
9762       gboolean rtl;
9763
9764       rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
9765       for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns));
9766            list;
9767            list = (rtl ? list->prev : list->next))
9768         {
9769           tmp_column = list->data;
9770
9771           if (tmp_column->visible == FALSE)
9772             continue;
9773
9774           last_column = tmp_column;
9775           if (remaining_x <= tmp_column->width)
9776             {
9777               found = TRUE;
9778
9779               if (column)
9780                 *column = tmp_column;
9781
9782               if (cell_x)
9783                 *cell_x = remaining_x;
9784
9785               break;
9786             }
9787           remaining_x -= tmp_column->width;
9788         }
9789
9790       /* If found is FALSE and there is a last_column, then it the remainder
9791        * space is in that area
9792        */
9793       if (!found)
9794         {
9795           if (last_column)
9796             {
9797               if (column)
9798                 *column = last_column;
9799
9800               if (cell_x)
9801                 *cell_x = last_column->width + remaining_x;
9802             }
9803           else
9804             {
9805               return FALSE;
9806             }
9807         }
9808     }
9809
9810   y_offset = pspp_sheet_view_find_offset (tree_view,
9811                                           TREE_WINDOW_Y_TO_RBTREE_Y (tree_view, y),
9812                                           &node);
9813
9814   if (node < 0)
9815     return FALSE;
9816
9817   if (cell_y)
9818     *cell_y = y_offset;
9819
9820   if (path)
9821     *path = _pspp_sheet_view_find_path (tree_view, node);
9822
9823   return TRUE;
9824 }
9825
9826 /* Computes 'cell_area' from 'background_area', which must be the background
9827    area for a cell.  Set 'subtract_focus_rect' to TRUE to compute the cell area
9828    as passed to a GtkCellRenderer's "render" function, or to FALSE to compute
9829    the cell area as passed to _pspp_sheet_view_column_cell_render().
9830
9831    'column' is required to properly adjust 'cell_area->x' and
9832    'cell_area->width'.  It may be set to NULL if these values are not of
9833    interest.  In this case 'cell_area->x' and 'cell_area->width' will be
9834    returned as 0. */
9835 static void
9836 pspp_sheet_view_adjust_cell_area (PsppSheetView        *tree_view,
9837                                   PsppSheetViewColumn  *column,
9838                                   const GdkRectangle   *background_area,
9839                                   gboolean              subtract_focus_rect,
9840                                   GdkRectangle         *cell_area)
9841 {
9842   gint vertical_separator;
9843   gint horizontal_separator;
9844
9845   *cell_area = *background_area;
9846
9847   gtk_widget_style_get (GTK_WIDGET (tree_view),
9848                         "vertical-separator", &vertical_separator,
9849                         "horizontal-separator", &horizontal_separator,
9850                         NULL);
9851   cell_area->x += horizontal_separator / 2;
9852   cell_area->y += vertical_separator / 2;
9853   cell_area->width -= horizontal_separator;
9854   cell_area->height -= vertical_separator;
9855
9856   if (subtract_focus_rect)
9857     {
9858       int focus_line_width;
9859
9860       gtk_widget_style_get (GTK_WIDGET (tree_view),
9861                             "focus-line-width", &focus_line_width,
9862                             NULL);
9863       cell_area->x += focus_line_width;
9864       cell_area->y += focus_line_width;
9865       cell_area->width -= 2 * focus_line_width;
9866       cell_area->height -= 2 * focus_line_width;
9867     }
9868
9869   if (tree_view->priv->grid_lines != PSPP_SHEET_VIEW_GRID_LINES_NONE)
9870     {
9871       gint grid_line_width;
9872       gtk_widget_style_get (GTK_WIDGET (tree_view),
9873                             "grid-line-width", &grid_line_width,
9874                             NULL);
9875
9876       if ((tree_view->priv->grid_lines == PSPP_SHEET_VIEW_GRID_LINES_VERTICAL
9877            || tree_view->priv->grid_lines == PSPP_SHEET_VIEW_GRID_LINES_BOTH)
9878           && column != NULL)
9879         {
9880           PsppSheetViewColumn *first_column, *last_column;
9881           GList *list;
9882
9883           /* Find the last visible column. */
9884           last_column = NULL;
9885           for (list = g_list_last (tree_view->priv->columns);
9886                list;
9887                list = list->prev)
9888             {
9889               PsppSheetViewColumn *c = list->data;
9890               if (c->visible)
9891                 {
9892                   last_column = c;
9893                   break;
9894                 }
9895             }
9896
9897           /* Find the first visible column. */
9898           first_column = NULL;
9899           for (list = g_list_first (tree_view->priv->columns);
9900                list;
9901                list = list->next)
9902             {
9903               PsppSheetViewColumn *c = list->data;
9904               if (c->visible)
9905                 {
9906                   first_column = c;
9907                   break;
9908                 }
9909             }
9910
9911           if (column == first_column)
9912             {
9913               cell_area->width -= grid_line_width / 2;
9914             }
9915           else if (column == last_column)
9916             {
9917               cell_area->x += grid_line_width / 2;
9918               cell_area->width -= grid_line_width / 2;
9919             }
9920           else
9921             {
9922               cell_area->x += grid_line_width / 2;
9923               cell_area->width -= grid_line_width;
9924             }
9925         }
9926
9927       if (tree_view->priv->grid_lines == PSPP_SHEET_VIEW_GRID_LINES_HORIZONTAL
9928           || tree_view->priv->grid_lines == PSPP_SHEET_VIEW_GRID_LINES_BOTH)
9929         {
9930           cell_area->y += grid_line_width / 2;
9931           cell_area->height -= grid_line_width;
9932         }
9933     }
9934
9935   if (column == NULL)
9936     {
9937       cell_area->x = 0;
9938       cell_area->width = 0;
9939     }
9940 }
9941
9942 /**
9943  * pspp_sheet_view_get_cell_area:
9944  * @tree_view: a #PsppSheetView
9945  * @path: (allow-none): a #GtkTreePath for the row, or %NULL to get only horizontal coordinates
9946  * @column: (allow-none): a #PsppSheetViewColumn for the column, or %NULL to get only vertical coordinates
9947  * @rect: rectangle to fill with cell rect
9948  *
9949  * Fills the bounding rectangle in bin_window coordinates for the cell at the
9950  * row specified by @path and the column specified by @column.  If @path is
9951  * %NULL, or points to a path not currently displayed, the @y and @height fields
9952  * of the rectangle will be filled with 0. If @column is %NULL, the @x and @width
9953  * fields will be filled with 0.  The sum of all cell rects does not cover the
9954  * entire tree; there are extra pixels in between rows, for example. The
9955  * returned rectangle is equivalent to the @cell_area passed to
9956  * gtk_cell_renderer_render().  This function is only valid if @tree_view is
9957  * realized.
9958  **/
9959 void
9960 pspp_sheet_view_get_cell_area (PsppSheetView        *tree_view,
9961                              GtkTreePath        *path,
9962                              PsppSheetViewColumn  *column,
9963                              GdkRectangle       *rect)
9964 {
9965   GdkRectangle background_area;
9966
9967   g_return_if_fail (PSPP_IS_SHEET_VIEW (tree_view));
9968   g_return_if_fail (column == NULL || PSPP_IS_SHEET_VIEW_COLUMN (column));
9969   g_return_if_fail (rect != NULL);
9970   g_return_if_fail (!column || column->tree_view == (GtkWidget *) tree_view);
9971   g_return_if_fail (gtk_widget_get_realized (GTK_WIDGET (tree_view)));
9972
9973   pspp_sheet_view_get_background_area (tree_view, path, column,
9974                                        &background_area);
9975   pspp_sheet_view_adjust_cell_area (tree_view, column, &background_area,
9976                                     FALSE, rect);
9977 }
9978
9979 /**
9980  * pspp_sheet_view_get_background_area:
9981  * @tree_view: a #PsppSheetView
9982  * @path: (allow-none): a #GtkTreePath for the row, or %NULL to get only horizontal coordinates
9983  * @column: (allow-none): a #PsppSheetViewColumn for the column, or %NULL to get only vertical coordiantes
9984  * @rect: rectangle to fill with cell background rect
9985  *
9986  * Fills the bounding rectangle in bin_window coordinates for the cell at the
9987  * row specified by @path and the column specified by @column.  If @path is
9988  * %NULL, or points to a node not found in the tree, the @y and @height fields of
9989  * the rectangle will be filled with 0. If @column is %NULL, the @x and @width
9990  * fields will be filled with 0.  The returned rectangle is equivalent to the
9991  * @background_area passed to gtk_cell_renderer_render().  These background
9992  * areas tile to cover the entire bin window.  Contrast with the @cell_area,
9993  * returned by pspp_sheet_view_get_cell_area(), which returns only the cell
9994  * itself, excluding surrounding borders.
9995  *
9996  **/
9997 void
9998 pspp_sheet_view_get_background_area (PsppSheetView        *tree_view,
9999                                    GtkTreePath        *path,
10000                                    PsppSheetViewColumn  *column,
10001                                    GdkRectangle       *rect)
10002 {
10003   int node = -1;
10004
10005   g_return_if_fail (PSPP_IS_SHEET_VIEW (tree_view));
10006   g_return_if_fail (column == NULL || PSPP_IS_SHEET_VIEW_COLUMN (column));
10007   g_return_if_fail (rect != NULL);
10008
10009   rect->x = 0;
10010   rect->y = 0;
10011   rect->width = 0;
10012   rect->height = 0;
10013
10014   if (path)
10015     {
10016       /* Get vertical coords */
10017
10018       _pspp_sheet_view_find_node (tree_view, path, &node);
10019       if (node < 0)
10020         return;
10021
10022       rect->y = BACKGROUND_FIRST_PIXEL (tree_view, node);
10023
10024       rect->height = ROW_HEIGHT (tree_view);
10025     }
10026
10027   if (column)
10028     {
10029       gint x2 = 0;
10030
10031       pspp_sheet_view_get_background_xrange (tree_view, column, &rect->x, &x2);
10032       rect->width = x2 - rect->x;
10033     }
10034 }
10035
10036 /**
10037  * pspp_sheet_view_get_visible_rect:
10038  * @tree_view: a #PsppSheetView
10039  * @visible_rect: rectangle to fill
10040  *
10041  * Fills @visible_rect with the currently-visible region of the
10042  * buffer, in tree coordinates. Convert to bin_window coordinates with
10043  * pspp_sheet_view_convert_tree_to_bin_window_coords().
10044  * Tree coordinates start at 0,0 for row 0 of the tree, and cover the entire
10045  * scrollable area of the tree.
10046  **/
10047 void
10048 pspp_sheet_view_get_visible_rect (PsppSheetView  *tree_view,
10049                                 GdkRectangle *visible_rect)
10050 {
10051   GtkWidget *widget;
10052
10053   g_return_if_fail (PSPP_IS_SHEET_VIEW (tree_view));
10054
10055   widget = GTK_WIDGET (tree_view);
10056
10057   if (visible_rect)
10058     {
10059       GtkAllocation allocation;
10060       gtk_widget_get_allocation (widget, &allocation);
10061       visible_rect->x = gtk_adjustment_get_value (tree_view->priv->hadjustment);
10062       visible_rect->y = gtk_adjustment_get_value (tree_view->priv->vadjustment);
10063       visible_rect->width  = allocation.width;
10064       visible_rect->height = allocation.height - TREE_VIEW_HEADER_HEIGHT (tree_view);
10065     }
10066 }
10067
10068 /**
10069  * pspp_sheet_view_widget_to_tree_coords:
10070  * @tree_view: a #PsppSheetView
10071  * @wx: X coordinate relative to bin_window
10072  * @wy: Y coordinate relative to bin_window
10073  * @tx: return location for tree X coordinate
10074  * @ty: return location for tree Y coordinate
10075  *
10076  * Converts bin_window coordinates to coordinates for the
10077  * tree (the full scrollable area of the tree).
10078  *
10079  * Deprecated: 2.12: Due to historial reasons the name of this function is
10080  * incorrect.  For converting coordinates relative to the widget to
10081  * bin_window coordinates, please see
10082  * pspp_sheet_view_convert_widget_to_bin_window_coords().
10083  *
10084  **/
10085 void
10086 pspp_sheet_view_widget_to_tree_coords (PsppSheetView *tree_view,
10087                                       gint         wx,
10088                                       gint         wy,
10089                                       gint        *tx,
10090                                       gint        *ty)
10091 {
10092   g_return_if_fail (PSPP_IS_SHEET_VIEW (tree_view));
10093
10094   if (tx)
10095     *tx = wx + gtk_adjustment_get_value (tree_view->priv->hadjustment);
10096   if (ty)
10097     *ty = wy + tree_view->priv->dy;
10098 }
10099
10100 /**
10101  * pspp_sheet_view_tree_to_widget_coords:
10102  * @tree_view: a #PsppSheetView
10103  * @tx: tree X coordinate
10104  * @ty: tree Y coordinate
10105  * @wx: return location for X coordinate relative to bin_window
10106  * @wy: return location for Y coordinate relative to bin_window
10107  *
10108  * Converts tree coordinates (coordinates in full scrollable area of the tree)
10109  * to bin_window coordinates.
10110  *
10111  * Deprecated: 2.12: Due to historial reasons the name of this function is
10112  * incorrect.  For converting bin_window coordinates to coordinates relative
10113  * to bin_window, please see
10114  * pspp_sheet_view_convert_bin_window_to_widget_coords().
10115  *
10116  **/
10117 void
10118 pspp_sheet_view_tree_to_widget_coords (PsppSheetView *tree_view,
10119                                      gint         tx,
10120                                      gint         ty,
10121                                      gint        *wx,
10122                                      gint        *wy)
10123 {
10124   g_return_if_fail (PSPP_IS_SHEET_VIEW (tree_view));
10125
10126   if (wx)
10127     *wx = tx - gtk_adjustment_get_value (tree_view->priv->hadjustment);
10128   if (wy)
10129     *wy = ty - tree_view->priv->dy;
10130 }
10131
10132
10133 /**
10134  * pspp_sheet_view_convert_widget_to_tree_coords:
10135  * @tree_view: a #PsppSheetView
10136  * @wx: X coordinate relative to the widget
10137  * @wy: Y coordinate relative to the widget
10138  * @tx: return location for tree X coordinate
10139  * @ty: return location for tree Y coordinate
10140  *
10141  * Converts widget coordinates to coordinates for the
10142  * tree (the full scrollable area of the tree).
10143  *
10144  * Since: 2.12
10145  **/
10146 void
10147 pspp_sheet_view_convert_widget_to_tree_coords (PsppSheetView *tree_view,
10148                                              gint         wx,
10149                                              gint         wy,
10150                                              gint        *tx,
10151                                              gint        *ty)
10152 {
10153   gint x, y;
10154
10155   g_return_if_fail (PSPP_IS_SHEET_VIEW (tree_view));
10156
10157   pspp_sheet_view_convert_widget_to_bin_window_coords (tree_view,
10158                                                      wx, wy,
10159                                                      &x, &y);
10160   pspp_sheet_view_convert_bin_window_to_tree_coords (tree_view,
10161                                                    x, y,
10162                                                    tx, ty);
10163 }
10164
10165 /**
10166  * pspp_sheet_view_convert_tree_to_widget_coords:
10167  * @tree_view: a #PsppSheetView
10168  * @tx: X coordinate relative to the tree
10169  * @ty: Y coordinate relative to the tree
10170  * @wx: return location for widget X coordinate
10171  * @wy: return location for widget Y coordinate
10172  *
10173  * Converts tree coordinates (coordinates in full scrollable area of the tree)
10174  * to widget coordinates.
10175  *
10176  * Since: 2.12
10177  **/
10178 void
10179 pspp_sheet_view_convert_tree_to_widget_coords (PsppSheetView *tree_view,
10180                                              gint         tx,
10181                                              gint         ty,
10182                                              gint        *wx,
10183                                              gint        *wy)
10184 {
10185   gint x, y;
10186
10187   g_return_if_fail (PSPP_IS_SHEET_VIEW (tree_view));
10188
10189   pspp_sheet_view_convert_tree_to_bin_window_coords (tree_view,
10190                                                    tx, ty,
10191                                                    &x, &y);
10192   pspp_sheet_view_convert_bin_window_to_widget_coords (tree_view,
10193                                                      x, y,
10194                                                      wx, wy);
10195 }
10196
10197 /**
10198  * pspp_sheet_view_convert_widget_to_bin_window_coords:
10199  * @tree_view: a #PsppSheetView
10200  * @wx: X coordinate relative to the widget
10201  * @wy: Y coordinate relative to the widget
10202  * @bx: return location for bin_window X coordinate
10203  * @by: return location for bin_window Y coordinate
10204  *
10205  * Converts widget coordinates to coordinates for the bin_window
10206  * (see pspp_sheet_view_get_bin_window()).
10207  *
10208  * Since: 2.12
10209  **/
10210 void
10211 pspp_sheet_view_convert_widget_to_bin_window_coords (PsppSheetView *tree_view,
10212                                                    gint         wx,
10213                                                    gint         wy,
10214                                                    gint        *bx,
10215                                                    gint        *by)
10216 {
10217   g_return_if_fail (PSPP_IS_SHEET_VIEW (tree_view));
10218
10219   if (bx)
10220     *bx = wx + gtk_adjustment_get_value (tree_view->priv->hadjustment);
10221   if (by)
10222     *by = wy - TREE_VIEW_HEADER_HEIGHT (tree_view);
10223 }
10224
10225 /**
10226  * pspp_sheet_view_convert_bin_window_to_widget_coords:
10227  * @tree_view: a #PsppSheetView
10228  * @bx: bin_window X coordinate
10229  * @by: bin_window Y coordinate
10230  * @wx: return location for widget X coordinate
10231  * @wy: return location for widget Y coordinate
10232  *
10233  * Converts bin_window coordinates (see pspp_sheet_view_get_bin_window())
10234  * to widget relative coordinates.
10235  *
10236  * Since: 2.12
10237  **/
10238 void
10239 pspp_sheet_view_convert_bin_window_to_widget_coords (PsppSheetView *tree_view,
10240                                                    gint         bx,
10241                                                    gint         by,
10242                                                    gint        *wx,
10243                                                    gint        *wy)
10244 {
10245   g_return_if_fail (PSPP_IS_SHEET_VIEW (tree_view));
10246
10247   if (wx)
10248     *wx = bx - gtk_adjustment_get_value (tree_view->priv->hadjustment);
10249   if (wy)
10250     *wy = by + TREE_VIEW_HEADER_HEIGHT (tree_view);
10251 }
10252
10253 /**
10254  * pspp_sheet_view_convert_tree_to_bin_window_coords:
10255  * @tree_view: a #PsppSheetView
10256  * @tx: tree X coordinate
10257  * @ty: tree Y coordinate
10258  * @bx: return location for X coordinate relative to bin_window
10259  * @by: return location for Y coordinate relative to bin_window
10260  *
10261  * Converts tree coordinates (coordinates in full scrollable area of the tree)
10262  * to bin_window coordinates.
10263  *
10264  * Since: 2.12
10265  **/
10266 void
10267 pspp_sheet_view_convert_tree_to_bin_window_coords (PsppSheetView *tree_view,
10268                                                  gint         tx,
10269                                                  gint         ty,
10270                                                  gint        *bx,
10271                                                  gint        *by)
10272 {
10273   g_return_if_fail (PSPP_IS_SHEET_VIEW (tree_view));
10274
10275   if (bx)
10276     *bx = tx;
10277   if (by)
10278     *by = ty - tree_view->priv->dy;
10279 }
10280
10281 /**
10282  * pspp_sheet_view_convert_bin_window_to_tree_coords:
10283  * @tree_view: a #PsppSheetView
10284  * @bx: X coordinate relative to bin_window
10285  * @by: Y coordinate relative to bin_window
10286  * @tx: return location for tree X coordinate
10287  * @ty: return location for tree Y coordinate
10288  *
10289  * Converts bin_window coordinates to coordinates for the
10290  * tree (the full scrollable area of the tree).
10291  *
10292  * Since: 2.12
10293  **/
10294 void
10295 pspp_sheet_view_convert_bin_window_to_tree_coords (PsppSheetView *tree_view,
10296                                                  gint         bx,
10297                                                  gint         by,
10298                                                  gint        *tx,
10299                                                  gint        *ty)
10300 {
10301   g_return_if_fail (PSPP_IS_SHEET_VIEW (tree_view));
10302
10303   if (tx)
10304     *tx = bx;
10305   if (ty)
10306     *ty = by + tree_view->priv->dy;
10307 }
10308
10309
10310
10311 /**
10312  * pspp_sheet_view_get_visible_range:
10313  * @tree_view: A #PsppSheetView
10314  * @start_path: (allow-none): Return location for start of region, or %NULL.
10315  * @end_path: (allow-none): Return location for end of region, or %NULL.
10316  *
10317  * Sets @start_path and @end_path to be the first and last visible path.
10318  * Note that there may be invisible paths in between.
10319  *
10320  * The paths should be freed with gtk_tree_path_free() after use.
10321  *
10322  * Returns: %TRUE, if valid paths were placed in @start_path and @end_path.
10323  *
10324  * Since: 2.8
10325  **/
10326 gboolean
10327 pspp_sheet_view_get_visible_range (PsppSheetView  *tree_view,
10328                                  GtkTreePath **start_path,
10329                                  GtkTreePath **end_path)
10330 {
10331   int node;
10332   gboolean retval;
10333
10334   g_return_val_if_fail (PSPP_IS_SHEET_VIEW (tree_view), FALSE);
10335
10336   if (!tree_view->priv->row_count)
10337     return FALSE;
10338
10339   retval = TRUE;
10340
10341   if (start_path)
10342     {
10343       pspp_sheet_view_find_offset (tree_view,
10344                                    TREE_WINDOW_Y_TO_RBTREE_Y (tree_view, 0),
10345                                    &node);
10346       if (node >= 0)
10347         *start_path = _pspp_sheet_view_find_path (tree_view, node);
10348       else
10349         retval = FALSE;
10350     }
10351
10352   if (end_path)
10353     {
10354       gint y;
10355
10356       if (tree_view->priv->height < gtk_adjustment_get_page_size (tree_view->priv->vadjustment))
10357         y = tree_view->priv->height - 1;
10358       else
10359         y = TREE_WINDOW_Y_TO_RBTREE_Y (tree_view, gtk_adjustment_get_page_size (tree_view->priv->vadjustment)) - 1;
10360
10361       pspp_sheet_view_find_offset (tree_view, y, &node);
10362       if (node >= 0)
10363         *end_path = _pspp_sheet_view_find_path (tree_view, node);
10364       else
10365         retval = FALSE;
10366     }
10367
10368   return retval;
10369 }
10370
10371 static void
10372 unset_reorderable (PsppSheetView *tree_view)
10373 {
10374   if (tree_view->priv->reorderable)
10375     {
10376       tree_view->priv->reorderable = FALSE;
10377       g_object_notify (G_OBJECT (tree_view), "reorderable");
10378     }
10379 }
10380
10381 /**
10382  * pspp_sheet_view_enable_model_drag_source:
10383  * @tree_view: a #PsppSheetView
10384  * @start_button_mask: Mask of allowed buttons to start drag
10385  * @targets: the table of targets that the drag will support
10386  * @n_targets: the number of items in @targets
10387  * @actions: the bitmask of possible actions for a drag from this
10388  *    widget
10389  *
10390  * Turns @tree_view into a drag source for automatic DND. Calling this
10391  * method sets #PsppSheetView:reorderable to %FALSE.
10392  **/
10393 void
10394 pspp_sheet_view_enable_model_drag_source (PsppSheetView              *tree_view,
10395                                         GdkModifierType           start_button_mask,
10396                                         const GtkTargetEntry     *targets,
10397                                         gint                      n_targets,
10398                                         GdkDragAction             actions)
10399 {
10400   TreeViewDragInfo *di;
10401
10402   g_return_if_fail (PSPP_IS_SHEET_VIEW (tree_view));
10403
10404   gtk_drag_source_set (GTK_WIDGET (tree_view),
10405                        0,
10406                        targets,
10407                        n_targets,
10408                        actions);
10409
10410   di = ensure_info (tree_view);
10411
10412   di->start_button_mask = start_button_mask;
10413   di->source_actions = actions;
10414   di->source_set = TRUE;
10415
10416   unset_reorderable (tree_view);
10417 }
10418
10419 /**
10420  * pspp_sheet_view_enable_model_drag_dest:
10421  * @tree_view: a #PsppSheetView
10422  * @targets: the table of targets that the drag will support
10423  * @n_targets: the number of items in @targets
10424  * @actions: the bitmask of possible actions for a drag from this
10425  *    widget
10426  *
10427  * Turns @tree_view into a drop destination for automatic DND. Calling
10428  * this method sets #PsppSheetView:reorderable to %FALSE.
10429  **/
10430 void
10431 pspp_sheet_view_enable_model_drag_dest (PsppSheetView              *tree_view,
10432                                       const GtkTargetEntry     *targets,
10433                                       gint                      n_targets,
10434                                       GdkDragAction             actions)
10435 {
10436   TreeViewDragInfo *di;
10437
10438   g_return_if_fail (PSPP_IS_SHEET_VIEW (tree_view));
10439
10440   gtk_drag_dest_set (GTK_WIDGET (tree_view),
10441                      0,
10442                      targets,
10443                      n_targets,
10444                      actions);
10445
10446   di = ensure_info (tree_view);
10447   di->dest_set = TRUE;
10448
10449   unset_reorderable (tree_view);
10450 }
10451
10452 /**
10453  * pspp_sheet_view_unset_rows_drag_source:
10454  * @tree_view: a #PsppSheetView
10455  *
10456  * Undoes the effect of
10457  * pspp_sheet_view_enable_model_drag_source(). Calling this method sets
10458  * #PsppSheetView:reorderable to %FALSE.
10459  **/
10460 void
10461 pspp_sheet_view_unset_rows_drag_source (PsppSheetView *tree_view)
10462 {
10463   TreeViewDragInfo *di;
10464
10465   g_return_if_fail (PSPP_IS_SHEET_VIEW (tree_view));
10466
10467   di = get_info (tree_view);
10468
10469   if (di)
10470     {
10471       if (di->source_set)
10472         {
10473           gtk_drag_source_unset (GTK_WIDGET (tree_view));
10474           di->source_set = FALSE;
10475         }
10476
10477       if (!di->dest_set && !di->source_set)
10478         remove_info (tree_view);
10479     }
10480
10481   unset_reorderable (tree_view);
10482 }
10483
10484 /**
10485  * pspp_sheet_view_unset_rows_drag_dest:
10486  * @tree_view: a #PsppSheetView
10487  *
10488  * Undoes the effect of
10489  * pspp_sheet_view_enable_model_drag_dest(). Calling this method sets
10490  * #PsppSheetView:reorderable to %FALSE.
10491  **/
10492 void
10493 pspp_sheet_view_unset_rows_drag_dest (PsppSheetView *tree_view)
10494 {
10495   TreeViewDragInfo *di;
10496
10497   g_return_if_fail (PSPP_IS_SHEET_VIEW (tree_view));
10498
10499   di = get_info (tree_view);
10500
10501   if (di)
10502     {
10503       if (di->dest_set)
10504         {
10505           gtk_drag_dest_unset (GTK_WIDGET (tree_view));
10506           di->dest_set = FALSE;
10507         }
10508
10509       if (!di->dest_set && !di->source_set)
10510         remove_info (tree_view);
10511     }
10512
10513   unset_reorderable (tree_view);
10514 }
10515
10516 /**
10517  * pspp_sheet_view_set_drag_dest_row:
10518  * @tree_view: a #PsppSheetView
10519  * @path: (allow-none): The path of the row to highlight, or %NULL.
10520  * @pos: Specifies whether to drop before, after or into the row
10521  *
10522  * Sets the row that is highlighted for feedback.
10523  **/
10524 void
10525 pspp_sheet_view_set_drag_dest_row (PsppSheetView            *tree_view,
10526                                  GtkTreePath            *path,
10527                                  PsppSheetViewDropPosition pos)
10528 {
10529   GtkTreePath *current_dest;
10530
10531   /* Note; this function is exported to allow a custom DND
10532    * implementation, so it can't touch TreeViewDragInfo
10533    */
10534
10535   g_return_if_fail (PSPP_IS_SHEET_VIEW (tree_view));
10536
10537   current_dest = NULL;
10538
10539   if (tree_view->priv->drag_dest_row)
10540     {
10541       current_dest = gtk_tree_row_reference_get_path (tree_view->priv->drag_dest_row);
10542       gtk_tree_row_reference_free (tree_view->priv->drag_dest_row);
10543     }
10544
10545   /* special case a drop on an empty model */
10546   tree_view->priv->empty_view_drop = 0;
10547
10548   if (pos == PSPP_SHEET_VIEW_DROP_BEFORE && path
10549       && gtk_tree_path_get_depth (path) == 1
10550       && gtk_tree_path_get_indices (path)[0] == 0)
10551     {
10552       gint n_children;
10553
10554       n_children = gtk_tree_model_iter_n_children (tree_view->priv->model,
10555                                                    NULL);
10556
10557       if (!n_children)
10558         tree_view->priv->empty_view_drop = 1;
10559     }
10560
10561   tree_view->priv->drag_dest_pos = pos;
10562
10563   if (path)
10564     {
10565       tree_view->priv->drag_dest_row =
10566         gtk_tree_row_reference_new_proxy (G_OBJECT (tree_view), tree_view->priv->model, path);
10567       pspp_sheet_view_queue_draw_path (tree_view, path, NULL);
10568     }
10569   else
10570     tree_view->priv->drag_dest_row = NULL;
10571
10572   if (current_dest)
10573     {
10574       int node, new_node;
10575
10576       _pspp_sheet_view_find_node (tree_view, current_dest, &node);
10577       _pspp_sheet_view_queue_draw_node (tree_view, node, NULL);
10578
10579       if (node >= 0)
10580         {
10581           new_node = pspp_sheet_view_node_next (tree_view, node);
10582           if (new_node >= 0)
10583             _pspp_sheet_view_queue_draw_node (tree_view, new_node, NULL);
10584
10585           new_node = pspp_sheet_view_node_prev (tree_view, node);
10586           if (new_node >= 0)
10587             _pspp_sheet_view_queue_draw_node (tree_view, new_node, NULL);
10588         }
10589       gtk_tree_path_free (current_dest);
10590     }
10591 }
10592
10593 /**
10594  * pspp_sheet_view_get_drag_dest_row:
10595  * @tree_view: a #PsppSheetView
10596  * @path: (allow-none): Return location for the path of the highlighted row, or %NULL.
10597  * @pos: (allow-none): Return location for the drop position, or %NULL
10598  *
10599  * Gets information about the row that is highlighted for feedback.
10600  **/
10601 void
10602 pspp_sheet_view_get_drag_dest_row (PsppSheetView              *tree_view,
10603                                  GtkTreePath             **path,
10604                                  PsppSheetViewDropPosition  *pos)
10605 {
10606   g_return_if_fail (PSPP_IS_SHEET_VIEW (tree_view));
10607
10608   if (path)
10609     {
10610       if (tree_view->priv->drag_dest_row)
10611         *path = gtk_tree_row_reference_get_path (tree_view->priv->drag_dest_row);
10612       else
10613         {
10614           if (tree_view->priv->empty_view_drop)
10615             *path = gtk_tree_path_new_from_indices (0, -1);
10616           else
10617             *path = NULL;
10618         }
10619     }
10620
10621   if (pos)
10622     *pos = tree_view->priv->drag_dest_pos;
10623 }
10624
10625 /**
10626  * pspp_sheet_view_get_dest_row_at_pos:
10627  * @tree_view: a #PsppSheetView
10628  * @drag_x: the position to determine the destination row for
10629  * @drag_y: the position to determine the destination row for
10630  * @path: (allow-none): Return location for the path of the highlighted row, or %NULL.
10631  * @pos: (allow-none): Return location for the drop position, or %NULL
10632  *
10633  * Determines the destination row for a given position.  @drag_x and
10634  * @drag_y are expected to be in widget coordinates.  This function is only
10635  * meaningful if @tree_view is realized.  Therefore this function will always
10636  * return %FALSE if @tree_view is not realized or does not have a model.
10637  *
10638  * Return value: whether there is a row at the given position, %TRUE if this
10639  * is indeed the case.
10640  **/
10641 gboolean
10642 pspp_sheet_view_get_dest_row_at_pos (PsppSheetView             *tree_view,
10643                                    gint                     drag_x,
10644                                    gint                     drag_y,
10645                                    GtkTreePath            **path,
10646                                    PsppSheetViewDropPosition *pos)
10647 {
10648   gint cell_y;
10649   gint bin_x, bin_y;
10650   gdouble offset_into_row;
10651   gdouble third;
10652   GdkRectangle cell;
10653   PsppSheetViewColumn *column = NULL;
10654   GtkTreePath *tmp_path = NULL;
10655
10656   /* Note; this function is exported to allow a custom DND
10657    * implementation, so it can't touch TreeViewDragInfo
10658    */
10659
10660   g_return_val_if_fail (tree_view != NULL, FALSE);
10661   g_return_val_if_fail (drag_x >= 0, FALSE);
10662   g_return_val_if_fail (drag_y >= 0, FALSE);
10663
10664   if (path)
10665     *path = NULL;
10666
10667   if (tree_view->priv->bin_window == NULL)
10668     return FALSE;
10669
10670   if (tree_view->priv->row_count == 0)
10671     return FALSE;
10672
10673   /* If in the top third of a row, we drop before that row; if
10674    * in the bottom third, drop after that row; if in the middle,
10675    * and the row has children, drop into the row.
10676    */
10677   pspp_sheet_view_convert_widget_to_bin_window_coords (tree_view, drag_x, drag_y,
10678                                                      &bin_x, &bin_y);
10679
10680   if (!pspp_sheet_view_get_path_at_pos (tree_view,
10681                                       bin_x,
10682                                       bin_y,
10683                                       &tmp_path,
10684                                       &column,
10685                                       NULL,
10686                                       &cell_y))
10687     return FALSE;
10688
10689   pspp_sheet_view_get_background_area (tree_view, tmp_path, column,
10690                                      &cell);
10691
10692   offset_into_row = cell_y;
10693
10694   if (path)
10695     *path = tmp_path;
10696   else
10697     gtk_tree_path_free (tmp_path);
10698
10699   tmp_path = NULL;
10700
10701   third = cell.height / 3.0;
10702
10703   if (pos)
10704     {
10705       if (offset_into_row < third)
10706         {
10707           *pos = PSPP_SHEET_VIEW_DROP_BEFORE;
10708         }
10709       else if (offset_into_row < (cell.height / 2.0))
10710         {
10711           *pos = PSPP_SHEET_VIEW_DROP_INTO_OR_BEFORE;
10712         }
10713       else if (offset_into_row < third * 2.0)
10714         {
10715           *pos = PSPP_SHEET_VIEW_DROP_INTO_OR_AFTER;
10716         }
10717       else
10718         {
10719           *pos = PSPP_SHEET_VIEW_DROP_AFTER;
10720         }
10721     }
10722
10723   return TRUE;
10724 }
10725
10726
10727
10728 /**
10729  * pspp_sheet_view_set_destroy_count_func:
10730  * @tree_view: A #PsppSheetView
10731  * @func: (allow-none): Function to be called when a view row is destroyed, or %NULL
10732  * @data: (allow-none): User data to be passed to @func, or %NULL
10733  * @destroy: (allow-none): Destroy notifier for @data, or %NULL
10734  *
10735  * This function should almost never be used.  It is meant for private use by
10736  * ATK for determining the number of visible children that are removed when a row is deleted.
10737  **/
10738 void
10739 pspp_sheet_view_set_destroy_count_func (PsppSheetView             *tree_view,
10740                                       PsppSheetDestroyCountFunc  func,
10741                                       gpointer                 data,
10742                                       GDestroyNotify           destroy)
10743 {
10744   g_return_if_fail (PSPP_IS_SHEET_VIEW (tree_view));
10745
10746   if (tree_view->priv->destroy_count_destroy)
10747     tree_view->priv->destroy_count_destroy (tree_view->priv->destroy_count_data);
10748
10749   tree_view->priv->destroy_count_func = func;
10750   tree_view->priv->destroy_count_data = data;
10751   tree_view->priv->destroy_count_destroy = destroy;
10752 }
10753
10754
10755 /*
10756  * Interactive search
10757  */
10758
10759 /**
10760  * pspp_sheet_view_set_enable_search:
10761  * @tree_view: A #PsppSheetView
10762  * @enable_search: %TRUE, if the user can search interactively
10763  *
10764  * If @enable_search is set, then the user can type in text to search through
10765  * the tree interactively (this is sometimes called "typeahead find").
10766  *
10767  * Note that even if this is %FALSE, the user can still initiate a search
10768  * using the "start-interactive-search" key binding.
10769  */
10770 void
10771 pspp_sheet_view_set_enable_search (PsppSheetView *tree_view,
10772                                  gboolean     enable_search)
10773 {
10774   g_return_if_fail (PSPP_IS_SHEET_VIEW (tree_view));
10775
10776   enable_search = !!enable_search;
10777
10778   if (tree_view->priv->enable_search != enable_search)
10779     {
10780        tree_view->priv->enable_search = enable_search;
10781        g_object_notify (G_OBJECT (tree_view), "enable-search");
10782     }
10783 }
10784
10785 /**
10786  * pspp_sheet_view_get_enable_search:
10787  * @tree_view: A #PsppSheetView
10788  *
10789  * Returns whether or not the tree allows to start interactive searching
10790  * by typing in text.
10791  *
10792  * Return value: whether or not to let the user search interactively
10793  */
10794 gboolean
10795 pspp_sheet_view_get_enable_search (PsppSheetView *tree_view)
10796 {
10797   g_return_val_if_fail (PSPP_IS_SHEET_VIEW (tree_view), FALSE);
10798
10799   return tree_view->priv->enable_search;
10800 }
10801
10802
10803 /**
10804  * pspp_sheet_view_get_search_column:
10805  * @tree_view: A #PsppSheetView
10806  *
10807  * Gets the column searched on by the interactive search code.
10808  *
10809  * Return value: the column the interactive search code searches in.
10810  */
10811 gint
10812 pspp_sheet_view_get_search_column (PsppSheetView *tree_view)
10813 {
10814   g_return_val_if_fail (PSPP_IS_SHEET_VIEW (tree_view), -1);
10815
10816   return (tree_view->priv->search_column);
10817 }
10818
10819 /**
10820  * pspp_sheet_view_set_search_column:
10821  * @tree_view: A #PsppSheetView
10822  * @column: the column of the model to search in, or -1 to disable searching
10823  *
10824  * Sets @column as the column where the interactive search code should
10825  * search in for the current model.
10826  *
10827  * If the search column is set, users can use the "start-interactive-search"
10828  * key binding to bring up search popup. The enable-search property controls
10829  * whether simply typing text will also start an interactive search.
10830  *
10831  * Note that @column refers to a column of the current model. The search
10832  * column is reset to -1 when the model is changed.
10833  */
10834 void
10835 pspp_sheet_view_set_search_column (PsppSheetView *tree_view,
10836                                  gint         column)
10837 {
10838   g_return_if_fail (PSPP_IS_SHEET_VIEW (tree_view));
10839   g_return_if_fail (column >= -1);
10840
10841   if (tree_view->priv->search_column == column)
10842     return;
10843
10844   tree_view->priv->search_column = column;
10845   g_object_notify (G_OBJECT (tree_view), "search-column");
10846 }
10847
10848 /**
10849  * pspp_sheet_view_get_search_equal_func:
10850  * @tree_view: A #PsppSheetView
10851  *
10852  * Returns the compare function currently in use.
10853  *
10854  * Return value: the currently used compare function for the search code.
10855  */
10856
10857 PsppSheetViewSearchEqualFunc
10858 pspp_sheet_view_get_search_equal_func (PsppSheetView *tree_view)
10859 {
10860   g_return_val_if_fail (PSPP_IS_SHEET_VIEW (tree_view), NULL);
10861
10862   return tree_view->priv->search_equal_func;
10863 }
10864
10865 /**
10866  * pspp_sheet_view_set_search_equal_func:
10867  * @tree_view: A #PsppSheetView
10868  * @search_equal_func: the compare function to use during the search
10869  * @search_user_data: (allow-none): user data to pass to @search_equal_func, or %NULL
10870  * @search_destroy: (allow-none): Destroy notifier for @search_user_data, or %NULL
10871  *
10872  * Sets the compare function for the interactive search capabilities; note
10873  * that somewhat like strcmp() returning 0 for equality
10874  * #PsppSheetViewSearchEqualFunc returns %FALSE on matches.
10875  **/
10876 void
10877 pspp_sheet_view_set_search_equal_func (PsppSheetView                *tree_view,
10878                                      PsppSheetViewSearchEqualFunc  search_equal_func,
10879                                      gpointer                    search_user_data,
10880                                      GDestroyNotify              search_destroy)
10881 {
10882   g_return_if_fail (PSPP_IS_SHEET_VIEW (tree_view));
10883   g_return_if_fail (search_equal_func != NULL);
10884
10885   if (tree_view->priv->search_destroy)
10886     tree_view->priv->search_destroy (tree_view->priv->search_user_data);
10887
10888   tree_view->priv->search_equal_func = search_equal_func;
10889   tree_view->priv->search_user_data = search_user_data;
10890   tree_view->priv->search_destroy = search_destroy;
10891   if (tree_view->priv->search_equal_func == NULL)
10892     tree_view->priv->search_equal_func = pspp_sheet_view_search_equal_func;
10893 }
10894
10895 /**
10896  * pspp_sheet_view_get_search_entry:
10897  * @tree_view: A #PsppSheetView
10898  *
10899  * Returns the #GtkEntry which is currently in use as interactive search
10900  * entry for @tree_view.  In case the built-in entry is being used, %NULL
10901  * will be returned.
10902  *
10903  * Return value: the entry currently in use as search entry.
10904  *
10905  * Since: 2.10
10906  */
10907 GtkEntry *
10908 pspp_sheet_view_get_search_entry (PsppSheetView *tree_view)
10909 {
10910   g_return_val_if_fail (PSPP_IS_SHEET_VIEW (tree_view), NULL);
10911
10912   if (tree_view->priv->search_custom_entry_set)
10913     return GTK_ENTRY (tree_view->priv->search_entry);
10914
10915   return NULL;
10916 }
10917
10918 /**
10919  * pspp_sheet_view_set_search_entry:
10920  * @tree_view: A #PsppSheetView
10921  * @entry: (allow-none): the entry the interactive search code of @tree_view should use or %NULL
10922  *
10923  * Sets the entry which the interactive search code will use for this
10924  * @tree_view.  This is useful when you want to provide a search entry
10925  * in our interface at all time at a fixed position.  Passing %NULL for
10926  * @entry will make the interactive search code use the built-in popup
10927  * entry again.
10928  *
10929  * Since: 2.10
10930  */
10931 void
10932 pspp_sheet_view_set_search_entry (PsppSheetView *tree_view,
10933                                 GtkEntry    *entry)
10934 {
10935   g_return_if_fail (PSPP_IS_SHEET_VIEW (tree_view));
10936   g_return_if_fail (entry == NULL || GTK_IS_ENTRY (entry));
10937
10938   if (tree_view->priv->search_custom_entry_set)
10939     {
10940       if (tree_view->priv->search_entry_changed_id)
10941         {
10942           g_signal_handler_disconnect (tree_view->priv->search_entry,
10943                                        tree_view->priv->search_entry_changed_id);
10944           tree_view->priv->search_entry_changed_id = 0;
10945         }
10946       g_signal_handlers_disconnect_by_func (tree_view->priv->search_entry,
10947                                             G_CALLBACK (pspp_sheet_view_search_key_press_event),
10948                                             tree_view);
10949
10950       g_object_unref (tree_view->priv->search_entry);
10951     }
10952   else if (tree_view->priv->search_window)
10953     {
10954       gtk_widget_destroy (tree_view->priv->search_window);
10955
10956       tree_view->priv->search_window = NULL;
10957     }
10958
10959   if (entry)
10960     {
10961       tree_view->priv->search_entry = g_object_ref (entry);
10962       tree_view->priv->search_custom_entry_set = TRUE;
10963
10964       if (tree_view->priv->search_entry_changed_id == 0)
10965         {
10966           tree_view->priv->search_entry_changed_id =
10967             g_signal_connect (tree_view->priv->search_entry, "changed",
10968                               G_CALLBACK (pspp_sheet_view_search_init),
10969                               tree_view);
10970         }
10971
10972         g_signal_connect (tree_view->priv->search_entry, "key-press-event",
10973                           G_CALLBACK (pspp_sheet_view_search_key_press_event),
10974                           tree_view);
10975
10976         pspp_sheet_view_search_init (tree_view->priv->search_entry, tree_view);
10977     }
10978   else
10979     {
10980       tree_view->priv->search_entry = NULL;
10981       tree_view->priv->search_custom_entry_set = FALSE;
10982     }
10983 }
10984
10985 /**
10986  * pspp_sheet_view_set_search_position_func:
10987  * @tree_view: A #PsppSheetView
10988  * @func: (allow-none): the function to use to position the search dialog, or %NULL
10989  *    to use the default search position function
10990  * @data: (allow-none): user data to pass to @func, or %NULL
10991  * @destroy: (allow-none): Destroy notifier for @data, or %NULL
10992  *
10993  * Sets the function to use when positioning the search dialog.
10994  *
10995  * Since: 2.10
10996  **/
10997 void
10998 pspp_sheet_view_set_search_position_func (PsppSheetView                   *tree_view,
10999                                         PsppSheetViewSearchPositionFunc  func,
11000                                         gpointer                       user_data,
11001                                         GDestroyNotify                 destroy)
11002 {
11003   g_return_if_fail (PSPP_IS_SHEET_VIEW (tree_view));
11004
11005   if (tree_view->priv->search_position_destroy)
11006     tree_view->priv->search_position_destroy (tree_view->priv->search_position_user_data);
11007
11008   tree_view->priv->search_position_func = func;
11009   tree_view->priv->search_position_user_data = user_data;
11010   tree_view->priv->search_position_destroy = destroy;
11011   if (tree_view->priv->search_position_func == NULL)
11012     tree_view->priv->search_position_func = pspp_sheet_view_search_position_func;
11013 }
11014
11015 /**
11016  * pspp_sheet_view_get_search_position_func:
11017  * @tree_view: A #PsppSheetView
11018  *
11019  * Returns the positioning function currently in use.
11020  *
11021  * Return value: the currently used function for positioning the search dialog.
11022  *
11023  * Since: 2.10
11024  */
11025 PsppSheetViewSearchPositionFunc
11026 pspp_sheet_view_get_search_position_func (PsppSheetView *tree_view)
11027 {
11028   g_return_val_if_fail (PSPP_IS_SHEET_VIEW (tree_view), NULL);
11029
11030   return tree_view->priv->search_position_func;
11031 }
11032
11033
11034 static void
11035 pspp_sheet_view_search_dialog_hide (GtkWidget   *search_dialog,
11036                                   PsppSheetView *tree_view)
11037 {
11038   if (tree_view->priv->disable_popdown)
11039     return;
11040
11041   if (tree_view->priv->search_entry_changed_id)
11042     {
11043       g_signal_handler_disconnect (tree_view->priv->search_entry,
11044                                    tree_view->priv->search_entry_changed_id);
11045       tree_view->priv->search_entry_changed_id = 0;
11046     }
11047   if (tree_view->priv->typeselect_flush_timeout)
11048     {
11049       g_source_remove (tree_view->priv->typeselect_flush_timeout);
11050       tree_view->priv->typeselect_flush_timeout = 0;
11051     }
11052
11053   if (gtk_widget_get_visible (search_dialog))
11054     {
11055       /* send focus-in event */
11056       send_focus_change (GTK_WIDGET (tree_view->priv->search_entry), FALSE);
11057       gtk_widget_hide (search_dialog);
11058       gtk_entry_set_text (GTK_ENTRY (tree_view->priv->search_entry), "");
11059       send_focus_change (GTK_WIDGET (tree_view), TRUE);
11060     }
11061 }
11062
11063 static void
11064 pspp_sheet_view_search_position_func (PsppSheetView *tree_view,
11065                                     GtkWidget   *search_dialog,
11066                                     gpointer     user_data)
11067 {
11068   gint x, y;
11069   gint tree_x, tree_y;
11070   gint tree_width, tree_height;
11071   GdkWindow *tree_window = gtk_widget_get_window (GTK_WIDGET (tree_view));
11072   GdkScreen *screen = gdk_window_get_screen (tree_window);
11073   GtkRequisition requisition;
11074   gint monitor_num;
11075   GdkRectangle monitor;
11076
11077   monitor_num = gdk_screen_get_monitor_at_window (screen, tree_window);
11078   gdk_screen_get_monitor_geometry (screen, monitor_num, &monitor);
11079
11080   gtk_widget_realize (search_dialog);
11081
11082   gdk_window_get_origin (tree_window, &tree_x, &tree_y);
11083   tree_width = gdk_window_get_width (tree_window);
11084   tree_height = gdk_window_get_height (tree_window);
11085
11086   gtk_widget_size_request (search_dialog, &requisition);
11087
11088   if (tree_x + tree_width > gdk_screen_get_width (screen))
11089     x = gdk_screen_get_width (screen) - requisition.width;
11090   else if (tree_x + tree_width - requisition.width < 0)
11091     x = 0;
11092   else
11093     x = tree_x + tree_width - requisition.width;
11094
11095   if (tree_y + tree_height + requisition.height > gdk_screen_get_height (screen))
11096     y = gdk_screen_get_height (screen) - requisition.height;
11097   else if (tree_y + tree_height < 0) /* isn't really possible ... */
11098     y = 0;
11099   else
11100     y = tree_y + tree_height;
11101
11102   gtk_window_move (GTK_WINDOW (search_dialog), x, y);
11103 }
11104
11105 static void
11106 pspp_sheet_view_search_disable_popdown (GtkEntry *entry,
11107                                       GtkMenu  *menu,
11108                                       gpointer  data)
11109 {
11110   PsppSheetView *tree_view = (PsppSheetView *)data;
11111
11112   tree_view->priv->disable_popdown = 1;
11113   g_signal_connect (menu, "hide",
11114                     G_CALLBACK (pspp_sheet_view_search_enable_popdown), data);
11115 }
11116
11117
11118 static void
11119 pspp_sheet_view_search_activate (GtkEntry    *entry,
11120                                PsppSheetView *tree_view)
11121 {
11122   GtkTreePath *path;
11123   int node;
11124
11125   pspp_sheet_view_search_dialog_hide (tree_view->priv->search_window,
11126                                     tree_view);
11127
11128   /* If we have a row selected and it's the cursor row, we activate
11129    * the row XXX */
11130   if (gtk_tree_row_reference_valid (tree_view->priv->cursor))
11131     {
11132       path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
11133
11134       _pspp_sheet_view_find_node (tree_view, path, &node);
11135
11136       if (node >= 0 && pspp_sheet_view_node_is_selected (tree_view, node))
11137         pspp_sheet_view_row_activated (tree_view, path, tree_view->priv->focus_column);
11138
11139       gtk_tree_path_free (path);
11140     }
11141 }
11142
11143 static gboolean
11144 pspp_sheet_view_real_search_enable_popdown (gpointer data)
11145 {
11146   PsppSheetView *tree_view = (PsppSheetView *)data;
11147
11148   tree_view->priv->disable_popdown = 0;
11149
11150   return FALSE;
11151 }
11152
11153 static void
11154 pspp_sheet_view_search_enable_popdown (GtkWidget *widget,
11155                                      gpointer   data)
11156 {
11157   gdk_threads_add_timeout_full (G_PRIORITY_HIGH, 200, pspp_sheet_view_real_search_enable_popdown, g_object_ref (data), g_object_unref);
11158 }
11159
11160 static gboolean
11161 pspp_sheet_view_search_delete_event (GtkWidget *widget,
11162                                    GdkEventAny *event,
11163                                    PsppSheetView *tree_view)
11164 {
11165   g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
11166
11167   pspp_sheet_view_search_dialog_hide (widget, tree_view);
11168
11169   return TRUE;
11170 }
11171
11172 static gboolean
11173 pspp_sheet_view_search_button_press_event (GtkWidget *widget,
11174                                          GdkEventButton *event,
11175                                          PsppSheetView *tree_view)
11176 {
11177   g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
11178
11179   pspp_sheet_view_search_dialog_hide (widget, tree_view);
11180
11181   if (event->window == tree_view->priv->bin_window)
11182     pspp_sheet_view_button_press (GTK_WIDGET (tree_view), event);
11183
11184   return TRUE;
11185 }
11186
11187 static gboolean
11188 pspp_sheet_view_search_scroll_event (GtkWidget *widget,
11189                                    GdkEventScroll *event,
11190                                    PsppSheetView *tree_view)
11191 {
11192   gboolean retval = FALSE;
11193
11194   if (event->direction == GDK_SCROLL_UP)
11195     {
11196       pspp_sheet_view_search_move (widget, tree_view, TRUE);
11197       retval = TRUE;
11198     }
11199   else if (event->direction == GDK_SCROLL_DOWN)
11200     {
11201       pspp_sheet_view_search_move (widget, tree_view, FALSE);
11202       retval = TRUE;
11203     }
11204
11205   /* renew the flush timeout */
11206   if (retval && tree_view->priv->typeselect_flush_timeout
11207       && !tree_view->priv->search_custom_entry_set)
11208     {
11209       g_source_remove (tree_view->priv->typeselect_flush_timeout);
11210       tree_view->priv->typeselect_flush_timeout =
11211         gdk_threads_add_timeout (PSPP_SHEET_VIEW_SEARCH_DIALOG_TIMEOUT,
11212                        (GSourceFunc) pspp_sheet_view_search_entry_flush_timeout,
11213                        tree_view);
11214     }
11215
11216   return retval;
11217 }
11218
11219 static gboolean
11220 pspp_sheet_view_search_key_press_event (GtkWidget *widget,
11221                                       GdkEventKey *event,
11222                                       PsppSheetView *tree_view)
11223 {
11224   gboolean retval = FALSE;
11225
11226   g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
11227   g_return_val_if_fail (PSPP_IS_SHEET_VIEW (tree_view), FALSE);
11228
11229   /* close window and cancel the search */
11230   if (!tree_view->priv->search_custom_entry_set
11231       && (event->keyval == GDK_Escape ||
11232           event->keyval == GDK_Tab ||
11233             event->keyval == GDK_KP_Tab ||
11234             event->keyval == GDK_ISO_Left_Tab))
11235     {
11236       pspp_sheet_view_search_dialog_hide (widget, tree_view);
11237       return TRUE;
11238     }
11239
11240   /* select previous matching iter */
11241   if (event->keyval == GDK_Up || event->keyval == GDK_KP_Up)
11242     {
11243       if (!pspp_sheet_view_search_move (widget, tree_view, TRUE))
11244         gtk_widget_error_bell (widget);
11245
11246       retval = TRUE;
11247     }
11248
11249   if (((event->state & (GTK_DEFAULT_ACCEL_MOD_MASK | GDK_SHIFT_MASK)) == (GTK_DEFAULT_ACCEL_MOD_MASK | GDK_SHIFT_MASK))
11250       && (event->keyval == GDK_g || event->keyval == GDK_G))
11251     {
11252       if (!pspp_sheet_view_search_move (widget, tree_view, TRUE))
11253         gtk_widget_error_bell (widget);
11254
11255       retval = TRUE;
11256     }
11257
11258   /* select next matching iter */
11259   if (event->keyval == GDK_Down || event->keyval == GDK_KP_Down)
11260     {
11261       if (!pspp_sheet_view_search_move (widget, tree_view, FALSE))
11262         gtk_widget_error_bell (widget);
11263
11264       retval = TRUE;
11265     }
11266
11267   if (((event->state & (GTK_DEFAULT_ACCEL_MOD_MASK | GDK_SHIFT_MASK)) == GTK_DEFAULT_ACCEL_MOD_MASK)
11268       && (event->keyval == GDK_g || event->keyval == GDK_G))
11269     {
11270       if (!pspp_sheet_view_search_move (widget, tree_view, FALSE))
11271         gtk_widget_error_bell (widget);
11272
11273       retval = TRUE;
11274     }
11275
11276   /* renew the flush timeout */
11277   if (retval && tree_view->priv->typeselect_flush_timeout
11278       && !tree_view->priv->search_custom_entry_set)
11279     {
11280       g_source_remove (tree_view->priv->typeselect_flush_timeout);
11281       tree_view->priv->typeselect_flush_timeout =
11282         gdk_threads_add_timeout (PSPP_SHEET_VIEW_SEARCH_DIALOG_TIMEOUT,
11283                        (GSourceFunc) pspp_sheet_view_search_entry_flush_timeout,
11284                        tree_view);
11285     }
11286
11287   return retval;
11288 }
11289
11290 /*  this function returns FALSE if there is a search string but
11291  *  nothing was found, and TRUE otherwise.
11292  */
11293 static gboolean
11294 pspp_sheet_view_search_move (GtkWidget   *window,
11295                            PsppSheetView *tree_view,
11296                            gboolean     up)
11297 {
11298   gboolean ret;
11299   gint len;
11300   gint count = 0;
11301   const gchar *text;
11302   GtkTreeIter iter;
11303   GtkTreeModel *model;
11304   PsppSheetSelection *selection;
11305
11306   text = gtk_entry_get_text (GTK_ENTRY (tree_view->priv->search_entry));
11307
11308   g_return_val_if_fail (text != NULL, FALSE);
11309
11310   len = strlen (text);
11311
11312   if (up && tree_view->priv->selected_iter == 1)
11313     return strlen (text) < 1;
11314
11315   len = strlen (text);
11316
11317   if (len < 1)
11318     return TRUE;
11319
11320   model = pspp_sheet_view_get_model (tree_view);
11321   selection = pspp_sheet_view_get_selection (tree_view);
11322
11323   /* search */
11324   pspp_sheet_selection_unselect_all (selection);
11325   if (!gtk_tree_model_get_iter_first (model, &iter))
11326     return TRUE;
11327
11328   ret = pspp_sheet_view_search_iter (model, selection, &iter, text,
11329                                    &count, up?((tree_view->priv->selected_iter) - 1):((tree_view->priv->selected_iter + 1)));
11330
11331   if (ret)
11332     {
11333       /* found */
11334       tree_view->priv->selected_iter += up?(-1):(1);
11335       return TRUE;
11336     }
11337   else
11338     {
11339       /* return to old iter */
11340       count = 0;
11341       gtk_tree_model_get_iter_first (model, &iter);
11342       pspp_sheet_view_search_iter (model, selection,
11343                                  &iter, text,
11344                                  &count, tree_view->priv->selected_iter);
11345       return FALSE;
11346     }
11347 }
11348
11349 static gboolean
11350 pspp_sheet_view_search_equal_func (GtkTreeModel *model,
11351                                  gint          column,
11352                                  const gchar  *key,
11353                                  GtkTreeIter  *iter,
11354                                  gpointer      search_data)
11355 {
11356   gboolean retval = TRUE;
11357   const gchar *str;
11358   gchar *normalized_string;
11359   gchar *normalized_key;
11360   gchar *case_normalized_string = NULL;
11361   gchar *case_normalized_key = NULL;
11362   GValue value = {0,};
11363   GValue transformed = {0,};
11364
11365   gtk_tree_model_get_value (model, iter, column, &value);
11366
11367   g_value_init (&transformed, G_TYPE_STRING);
11368
11369   if (!g_value_transform (&value, &transformed))
11370     {
11371       g_value_unset (&value);
11372       return TRUE;
11373     }
11374
11375   g_value_unset (&value);
11376
11377   str = g_value_get_string (&transformed);
11378   if (!str)
11379     {
11380       g_value_unset (&transformed);
11381       return TRUE;
11382     }
11383
11384   normalized_string = g_utf8_normalize (str, -1, G_NORMALIZE_ALL);
11385   normalized_key = g_utf8_normalize (key, -1, G_NORMALIZE_ALL);
11386
11387   if (normalized_string && normalized_key)
11388     {
11389       case_normalized_string = g_utf8_casefold (normalized_string, -1);
11390       case_normalized_key = g_utf8_casefold (normalized_key, -1);
11391
11392       if (strncmp (case_normalized_key, case_normalized_string, strlen (case_normalized_key)) == 0)
11393         retval = FALSE;
11394     }
11395
11396   g_value_unset (&transformed);
11397   g_free (normalized_key);
11398   g_free (normalized_string);
11399   g_free (case_normalized_key);
11400   g_free (case_normalized_string);
11401
11402   return retval;
11403 }
11404
11405 static gboolean
11406 pspp_sheet_view_search_iter (GtkTreeModel     *model,
11407                              PsppSheetSelection *selection,
11408                              GtkTreeIter      *iter,
11409                              const gchar      *text,
11410                              gint             *count,
11411                              gint              n)
11412 {
11413   int node = -1;
11414   GtkTreePath *path;
11415
11416   PsppSheetView *tree_view = pspp_sheet_selection_get_tree_view (selection);
11417
11418   path = gtk_tree_model_get_path (model, iter);
11419   _pspp_sheet_view_find_node (tree_view, path, &node);
11420
11421   do
11422     {
11423       gboolean done = FALSE;
11424
11425       if (! tree_view->priv->search_equal_func (model, tree_view->priv->search_column, text, iter, tree_view->priv->search_user_data))
11426         {
11427           (*count)++;
11428           if (*count == n)
11429             {
11430               pspp_sheet_view_scroll_to_cell (tree_view, path, NULL,
11431                                               TRUE, 0.5, 0.0);
11432               pspp_sheet_selection_select_iter (selection, iter);
11433               pspp_sheet_view_real_set_cursor (tree_view, path, FALSE, TRUE, 0);
11434
11435               if (path)
11436                 gtk_tree_path_free (path);
11437
11438               return TRUE;
11439             }
11440         }
11441
11442
11443       do
11444         {
11445           node = pspp_sheet_view_node_next (tree_view, node);
11446
11447           if (node >= 0)
11448             {
11449               gboolean has_next;
11450
11451               has_next = gtk_tree_model_iter_next (model, iter);
11452
11453               done = TRUE;
11454               gtk_tree_path_next (path);
11455
11456               /* sanity check */
11457               TREE_VIEW_INTERNAL_ASSERT (has_next, FALSE);
11458             }
11459           else
11460             {
11461               if (path)
11462                 gtk_tree_path_free (path);
11463
11464               /* we've run out of tree, done with this func */
11465               return FALSE;
11466             }
11467         }
11468       while (!done);
11469     }
11470   while (1);
11471
11472   return FALSE;
11473 }
11474
11475 static void
11476 pspp_sheet_view_search_init (GtkWidget   *entry,
11477                            PsppSheetView *tree_view)
11478 {
11479   gint ret;
11480   gint count = 0;
11481   const gchar *text;
11482   GtkTreeIter iter;
11483   GtkTreeModel *model;
11484   PsppSheetSelection *selection;
11485
11486   g_return_if_fail (GTK_IS_ENTRY (entry));
11487   g_return_if_fail (PSPP_IS_SHEET_VIEW (tree_view));
11488
11489   text = gtk_entry_get_text (GTK_ENTRY (entry));
11490
11491   model = pspp_sheet_view_get_model (tree_view);
11492   selection = pspp_sheet_view_get_selection (tree_view);
11493
11494   /* search */
11495   pspp_sheet_selection_unselect_all (selection);
11496   if (tree_view->priv->typeselect_flush_timeout
11497       && !tree_view->priv->search_custom_entry_set)
11498     {
11499       g_source_remove (tree_view->priv->typeselect_flush_timeout);
11500       tree_view->priv->typeselect_flush_timeout =
11501         gdk_threads_add_timeout (PSPP_SHEET_VIEW_SEARCH_DIALOG_TIMEOUT,
11502                        (GSourceFunc) pspp_sheet_view_search_entry_flush_timeout,
11503                        tree_view);
11504     }
11505
11506   if (*text == '\0')
11507     return;
11508
11509   if (!gtk_tree_model_get_iter_first (model, &iter))
11510     return;
11511
11512   ret = pspp_sheet_view_search_iter (model, selection,
11513                                    &iter, text,
11514                                    &count, 1);
11515
11516   if (ret)
11517     tree_view->priv->selected_iter = 1;
11518 }
11519
11520 static void
11521 pspp_sheet_view_remove_widget (GtkCellEditable *cell_editable,
11522                              PsppSheetView     *tree_view)
11523 {
11524   if (tree_view->priv->edited_column == NULL)
11525     return;
11526
11527   _pspp_sheet_view_column_stop_editing (tree_view->priv->edited_column);
11528   tree_view->priv->edited_column = NULL;
11529
11530   if (gtk_widget_has_focus (GTK_WIDGET (cell_editable)))
11531     gtk_widget_grab_focus (GTK_WIDGET (tree_view));
11532
11533   g_signal_handlers_disconnect_by_func (cell_editable,
11534                                         pspp_sheet_view_remove_widget,
11535                                         tree_view);
11536   g_signal_handlers_disconnect_by_func (cell_editable,
11537                                         pspp_sheet_view_editable_button_press_event,
11538                                         tree_view);
11539   g_signal_handlers_disconnect_by_func (cell_editable,
11540                                         pspp_sheet_view_editable_clicked,
11541                                         tree_view);
11542
11543   gtk_container_remove (GTK_CONTAINER (tree_view),
11544                         GTK_WIDGET (cell_editable));
11545
11546   /* FIXME should only redraw a single node */
11547   gtk_widget_queue_draw (GTK_WIDGET (tree_view));
11548 }
11549
11550 static gboolean
11551 pspp_sheet_view_start_editing (PsppSheetView *tree_view,
11552                              GtkTreePath *cursor_path)
11553 {
11554   GtkTreeIter iter;
11555   GdkRectangle background_area;
11556   GdkRectangle cell_area;
11557   GtkCellEditable *editable_widget = NULL;
11558   gchar *path_string;
11559   guint flags = 0; /* can be 0, as the flags are primarily for rendering */
11560   gint retval = FALSE;
11561   int cursor_node;
11562
11563   g_assert (tree_view->priv->focus_column);
11564
11565   if (!gtk_widget_get_realized (GTK_WIDGET (tree_view)))
11566     return FALSE;
11567
11568   _pspp_sheet_view_find_node (tree_view, cursor_path, &cursor_node);
11569   if (cursor_node < 0)
11570     return FALSE;
11571
11572   path_string = gtk_tree_path_to_string (cursor_path);
11573   gtk_tree_model_get_iter (tree_view->priv->model, &iter, cursor_path);
11574
11575   pspp_sheet_view_column_cell_set_cell_data (tree_view->priv->focus_column,
11576                                            tree_view->priv->model,
11577                                            &iter);
11578   pspp_sheet_view_get_background_area (tree_view,
11579                                      cursor_path,
11580                                      tree_view->priv->focus_column,
11581                                      &background_area);
11582   pspp_sheet_view_get_cell_area (tree_view,
11583                                cursor_path,
11584                                tree_view->priv->focus_column,
11585                                &cell_area);
11586
11587   if (_pspp_sheet_view_column_cell_event (tree_view->priv->focus_column,
11588                                         &editable_widget,
11589                                         NULL,
11590                                         path_string,
11591                                         &background_area,
11592                                         &cell_area,
11593                                         flags))
11594     {
11595       retval = TRUE;
11596       if (editable_widget != NULL)
11597         {
11598           gint left, right;
11599           GdkRectangle area;
11600           GtkCellRenderer *cell;
11601
11602           area = cell_area;
11603           cell = _pspp_sheet_view_column_get_edited_cell (tree_view->priv->focus_column);
11604
11605           _pspp_sheet_view_column_get_neighbor_sizes (tree_view->priv->focus_column, cell, &left, &right);
11606
11607           area.x += left;
11608           area.width -= right + left;
11609
11610           pspp_sheet_view_real_start_editing (tree_view,
11611                                             tree_view->priv->focus_column,
11612                                             cursor_path,
11613                                             editable_widget,
11614                                             &area,
11615                                             NULL,
11616                                             flags);
11617         }
11618
11619     }
11620   g_free (path_string);
11621   return retval;
11622 }
11623
11624 static gboolean
11625 pspp_sheet_view_editable_button_press_event (GtkWidget *widget,
11626                                              GdkEventButton *event,
11627                                              PsppSheetView *sheet_view)
11628 {
11629   gint node;
11630
11631   node = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (widget),
11632                                              "pspp-sheet-view-node"));
11633   return pspp_sheet_view_row_head_clicked (sheet_view,
11634                                            node,
11635                                            sheet_view->priv->edited_column,
11636                                            event);
11637 }
11638
11639 static void
11640 pspp_sheet_view_editable_clicked (GtkButton *button,
11641                                   PsppSheetView *sheet_view)
11642 {
11643   pspp_sheet_view_editable_button_press_event (GTK_WIDGET (button), NULL,
11644                                                sheet_view);
11645 }
11646
11647 static gboolean
11648 is_all_selected (GtkWidget *widget)
11649 {
11650   GtkEntryBuffer *buffer;
11651   gint start_pos, end_pos;
11652
11653   if (!GTK_IS_ENTRY (widget))
11654     return FALSE;
11655
11656   buffer = gtk_entry_get_buffer (GTK_ENTRY (widget));
11657   return (gtk_editable_get_selection_bounds (GTK_EDITABLE (widget),
11658                                              &start_pos, &end_pos)
11659           && start_pos == 0
11660           && end_pos == gtk_entry_buffer_get_length (buffer));
11661 }
11662
11663 static gboolean
11664 is_at_left (GtkWidget *widget)
11665 {
11666   return (GTK_IS_ENTRY (widget)
11667           && gtk_editable_get_position (GTK_EDITABLE (widget)) == 0);
11668 }
11669
11670 static gboolean
11671 is_at_right (GtkWidget *widget)
11672 {
11673   GtkEntryBuffer *buffer;
11674   gint length;
11675
11676   if (!GTK_IS_ENTRY (widget))
11677     return FALSE;
11678
11679   buffer = gtk_entry_get_buffer (GTK_ENTRY (widget));
11680   length = gtk_entry_buffer_get_length (buffer);
11681   return gtk_editable_get_position (GTK_EDITABLE (widget)) == length;
11682 }
11683
11684 static gboolean
11685 pspp_sheet_view_event (GtkWidget *widget,
11686                        GdkEventKey *event,
11687                        PsppSheetView *tree_view)
11688 {
11689   PsppSheetViewColumn *column;
11690   GtkTreePath *path;
11691   gboolean handled;
11692   gboolean cancel;
11693   guint keyval;
11694   gint row;
11695
11696   /* Intercept only key press events.
11697      It would make sense to use "key-press-event" instead of "event", but
11698      GtkEntry attaches its own signal handler to "key-press-event" that runs
11699      before ours and overrides our desired behavior for GDK_Up and GDK_Down.
11700   */
11701   if (event->type != GDK_KEY_PRESS)
11702     return FALSE;
11703
11704   keyval = event->keyval;
11705   cancel = FALSE;
11706   switch (event->state & (GDK_CONTROL_MASK | GDK_SHIFT_MASK | GDK_MOD1_MASK))
11707     {
11708     case 0:
11709       switch (event->keyval)
11710         {
11711         case GDK_Left:      case GDK_KP_Left:
11712         case GDK_Home:      case GDK_KP_Home:
11713           if (!is_all_selected (widget) && !is_at_left (widget))
11714             return FALSE;
11715           break;
11716
11717         case GDK_Right:     case GDK_KP_Right:
11718         case GDK_End:       case GDK_KP_End:
11719           if (!is_all_selected (widget) && !is_at_right (widget))
11720             return FALSE;
11721           break;
11722
11723         case GDK_Up:        case GDK_KP_Up:
11724         case GDK_Down:      case GDK_KP_Down:
11725           break;
11726
11727         case GDK_Page_Up:   case GDK_KP_Page_Up:
11728         case GDK_Page_Down: case GDK_KP_Page_Down:
11729           break;
11730
11731         case GDK_Escape:
11732           cancel = TRUE;
11733           break;
11734
11735         case GDK_Return:
11736           keyval = GDK_Down;
11737           break;
11738
11739         case GDK_Tab:       case GDK_KP_Tab:
11740         case GDK_ISO_Left_Tab:
11741           keyval = GDK_Tab;
11742           break;
11743
11744         default:
11745           return FALSE;
11746         }
11747       break;
11748
11749     case GDK_SHIFT_MASK:
11750       switch (event->keyval)
11751         {
11752         case GDK_Tab:
11753         case GDK_ISO_Left_Tab:
11754           keyval = GDK_Tab;
11755           break;
11756
11757         default:
11758           return FALSE;
11759         }
11760       break;
11761
11762     case GDK_CONTROL_MASK:
11763       switch (event->keyval)
11764         {
11765         case GDK_Left:      case GDK_KP_Left:
11766           if (!is_all_selected (widget) && !is_at_left (widget))
11767             return FALSE;
11768           break;
11769
11770         case GDK_Right:     case GDK_KP_Right:
11771           if (!is_all_selected (widget) && !is_at_right (widget))
11772             return FALSE;
11773           break;
11774
11775         case GDK_Up:        case GDK_KP_Up:
11776         case GDK_Down:      case GDK_KP_Down:
11777           break;
11778
11779         default:
11780           return FALSE;
11781         }
11782       break;
11783
11784     default:
11785       return FALSE;
11786     }
11787
11788   row = tree_view->priv->edited_row;
11789   column = tree_view->priv->edited_column;
11790   path = gtk_tree_path_new_from_indices (row, -1);
11791
11792   pspp_sheet_view_stop_editing (tree_view, cancel);
11793   gtk_widget_grab_focus (GTK_WIDGET (tree_view));
11794
11795   pspp_sheet_view_set_cursor (tree_view, path, column, FALSE);
11796   gtk_tree_path_free (path);
11797
11798   handled = gtk_binding_set_activate (edit_bindings, keyval, event->state,
11799                                       G_OBJECT (tree_view));
11800   if (handled)
11801     g_signal_stop_emission_by_name (widget, "event");
11802
11803   pspp_sheet_view_get_cursor (tree_view, &path, NULL);
11804   pspp_sheet_view_start_editing (tree_view, path);
11805   gtk_tree_path_free (path);
11806
11807   return handled;
11808 }
11809
11810 static void
11811 pspp_sheet_view_override_cell_keypresses (GtkWidget *widget,
11812                                           gpointer data)
11813 {
11814   PsppSheetView *sheet_view = data;
11815
11816   g_signal_connect (widget, "event",
11817                     G_CALLBACK (pspp_sheet_view_event),
11818                     sheet_view);
11819
11820   if (GTK_IS_CONTAINER (widget))
11821     gtk_container_foreach (GTK_CONTAINER (widget),
11822                            pspp_sheet_view_override_cell_keypresses,
11823                            data);
11824 }
11825
11826 static void
11827 pspp_sheet_view_real_start_editing (PsppSheetView       *tree_view,
11828                                   PsppSheetViewColumn *column,
11829                                   GtkTreePath       *path,
11830                                   GtkCellEditable   *cell_editable,
11831                                   GdkRectangle      *cell_area,
11832                                   GdkEvent          *event,
11833                                   guint              flags)
11834 {
11835   PsppSheetSelectionMode mode = pspp_sheet_selection_get_mode (tree_view->priv->selection);
11836   gint pre_val = gtk_adjustment_get_value (tree_view->priv->vadjustment);
11837   gint row;
11838
11839   g_return_if_fail (gtk_tree_path_get_depth (path) == 1);
11840
11841   tree_view->priv->edited_column = column;
11842   _pspp_sheet_view_column_start_editing (column, GTK_CELL_EDITABLE (cell_editable));
11843
11844   row = gtk_tree_path_get_indices (path)[0];
11845   tree_view->priv->edited_row = row;
11846   pspp_sheet_view_real_set_cursor (tree_view, path, FALSE, TRUE, 0);
11847   cell_area->y += pre_val - (int)gtk_adjustment_get_value (tree_view->priv->vadjustment);
11848
11849   pspp_sheet_selection_unselect_all_columns (tree_view->priv->selection);
11850   pspp_sheet_selection_select_column (tree_view->priv->selection, column);
11851   tree_view->priv->anchor_column = column;
11852
11853   PSPP_SHEET_VIEW_SET_FLAG (tree_view, PSPP_SHEET_VIEW_DRAW_KEYFOCUS);
11854
11855   pspp_sheet_view_put (tree_view,
11856                        GTK_WIDGET (cell_editable),
11857                        path,
11858                        column);
11859
11860   gtk_cell_editable_start_editing (GTK_CELL_EDITABLE (cell_editable),
11861                                    (GdkEvent *)event);
11862
11863   gtk_widget_grab_focus (GTK_WIDGET (cell_editable));
11864   g_signal_connect (cell_editable, "remove-widget",
11865                     G_CALLBACK (pspp_sheet_view_remove_widget), tree_view);
11866   if (mode == PSPP_SHEET_SELECTION_RECTANGLE && column->row_head &&
11867       GTK_IS_BUTTON (cell_editable))
11868     {
11869       g_signal_connect (cell_editable, "button-press-event",
11870                         G_CALLBACK (pspp_sheet_view_editable_button_press_event),
11871                         tree_view);
11872       g_object_set_data (G_OBJECT (cell_editable), "pspp-sheet-view-node",
11873                          GINT_TO_POINTER (row));
11874       g_signal_connect (cell_editable, "clicked",
11875                         G_CALLBACK (pspp_sheet_view_editable_clicked),
11876                         tree_view);
11877     }
11878
11879   pspp_sheet_view_override_cell_keypresses (GTK_WIDGET (cell_editable),
11880                                             tree_view);
11881 }
11882
11883 void
11884 pspp_sheet_view_stop_editing (PsppSheetView *tree_view,
11885                               gboolean     cancel_editing)
11886 {
11887   PsppSheetViewColumn *column;
11888   GtkCellRenderer *cell;
11889
11890   if (tree_view->priv->edited_column == NULL)
11891     return;
11892
11893   /*
11894    * This is very evil. We need to do this, because
11895    * gtk_cell_editable_editing_done may trigger pspp_sheet_view_row_changed
11896    * later on. If pspp_sheet_view_row_changed notices
11897    * tree_view->priv->edited_column != NULL, it'll call
11898    * pspp_sheet_view_stop_editing again. Bad things will happen then.
11899    *
11900    * Please read that again if you intend to modify anything here.
11901    */
11902
11903   column = tree_view->priv->edited_column;
11904   tree_view->priv->edited_column = NULL;
11905
11906   cell = _pspp_sheet_view_column_get_edited_cell (column);
11907   gtk_cell_renderer_stop_editing (cell, cancel_editing);
11908
11909   if (!cancel_editing)
11910     gtk_cell_editable_editing_done (column->editable_widget);
11911
11912   tree_view->priv->edited_column = column;
11913
11914   gtk_cell_editable_remove_widget (column->editable_widget);
11915 }
11916
11917
11918 /**
11919  * pspp_sheet_view_set_hover_selection:
11920  * @tree_view: a #PsppSheetView
11921  * @hover: %TRUE to enable hover selection mode
11922  *
11923  * Enables of disables the hover selection mode of @tree_view.
11924  * Hover selection makes the selected row follow the pointer.
11925  * Currently, this works only for the selection modes
11926  * %PSPP_SHEET_SELECTION_SINGLE and %PSPP_SHEET_SELECTION_BROWSE.
11927  *
11928  * Since: 2.6
11929  **/
11930 void
11931 pspp_sheet_view_set_hover_selection (PsppSheetView *tree_view,
11932                                    gboolean     hover)
11933 {
11934   hover = hover != FALSE;
11935
11936   if (hover != tree_view->priv->hover_selection)
11937     {
11938       tree_view->priv->hover_selection = hover;
11939
11940       g_object_notify (G_OBJECT (tree_view), "hover-selection");
11941     }
11942 }
11943
11944 /**
11945  * pspp_sheet_view_get_hover_selection:
11946  * @tree_view: a #PsppSheetView
11947  *
11948  * Returns whether hover selection mode is turned on for @tree_view.
11949  *
11950  * Return value: %TRUE if @tree_view is in hover selection mode
11951  *
11952  * Since: 2.6
11953  **/
11954 gboolean
11955 pspp_sheet_view_get_hover_selection (PsppSheetView *tree_view)
11956 {
11957   return tree_view->priv->hover_selection;
11958 }
11959
11960 /**
11961  * pspp_sheet_view_set_rubber_banding:
11962  * @tree_view: a #PsppSheetView
11963  * @enable: %TRUE to enable rubber banding
11964  *
11965  * Enables or disables rubber banding in @tree_view.  If the selection mode is
11966  * #PSPP_SHEET_SELECTION_MULTIPLE or #PSPP_SHEET_SELECTION_RECTANGLE, rubber
11967  * banding will allow the user to select multiple rows by dragging the mouse.
11968  *
11969  * Since: 2.10
11970  **/
11971 void
11972 pspp_sheet_view_set_rubber_banding (PsppSheetView *tree_view,
11973                                   gboolean     enable)
11974 {
11975   enable = enable != FALSE;
11976
11977   if (enable != tree_view->priv->rubber_banding_enable)
11978     {
11979       tree_view->priv->rubber_banding_enable = enable;
11980
11981       g_object_notify (G_OBJECT (tree_view), "rubber-banding");
11982     }
11983 }
11984
11985 /**
11986  * pspp_sheet_view_get_rubber_banding:
11987  * @tree_view: a #PsppSheetView
11988  *
11989  * Returns whether rubber banding is turned on for @tree_view.  If the
11990  * selection mode is #PSPP_SHEET_SELECTION_MULTIPLE or
11991  * #PSPP_SHEET_SELECTION_RECTANGLE, rubber banding will allow the user to
11992  * select multiple rows by dragging the mouse.
11993  *
11994  * Return value: %TRUE if rubber banding in @tree_view is enabled.
11995  *
11996  * Since: 2.10
11997  **/
11998 gboolean
11999 pspp_sheet_view_get_rubber_banding (PsppSheetView *tree_view)
12000 {
12001   return tree_view->priv->rubber_banding_enable;
12002 }
12003
12004 /**
12005  * pspp_sheet_view_is_rubber_banding_active:
12006  * @tree_view: a #PsppSheetView
12007  *
12008  * Returns whether a rubber banding operation is currently being done
12009  * in @tree_view.
12010  *
12011  * Return value: %TRUE if a rubber banding operation is currently being
12012  * done in @tree_view.
12013  *
12014  * Since: 2.12
12015  **/
12016 gboolean
12017 pspp_sheet_view_is_rubber_banding_active (PsppSheetView *tree_view)
12018 {
12019   g_return_val_if_fail (PSPP_IS_SHEET_VIEW (tree_view), FALSE);
12020
12021   if (tree_view->priv->rubber_banding_enable
12022       && tree_view->priv->rubber_band_status == RUBBER_BAND_ACTIVE)
12023     return TRUE;
12024
12025   return FALSE;
12026 }
12027
12028 static void
12029 pspp_sheet_view_grab_notify (GtkWidget *widget,
12030                            gboolean   was_grabbed)
12031 {
12032   PsppSheetView *tree_view = PSPP_SHEET_VIEW (widget);
12033
12034   tree_view->priv->in_grab = !was_grabbed;
12035
12036   if (!was_grabbed)
12037     {
12038       tree_view->priv->pressed_button = -1;
12039
12040       if (tree_view->priv->rubber_band_status)
12041         pspp_sheet_view_stop_rubber_band (tree_view);
12042     }
12043 }
12044
12045 static void
12046 pspp_sheet_view_state_changed (GtkWidget      *widget,
12047                              GtkStateType    previous_state)
12048 {
12049   PsppSheetView *tree_view = PSPP_SHEET_VIEW (widget);
12050
12051   if (gtk_widget_get_realized (widget))
12052     {
12053       GtkStyle *style = gtk_widget_get_style (widget);
12054       gdk_window_set_background (tree_view->priv->bin_window, &style->base[gtk_widget_get_state (widget)]);
12055     }
12056
12057   gtk_widget_queue_draw (widget);
12058 }
12059
12060 /**
12061  * pspp_sheet_view_get_grid_lines:
12062  * @tree_view: a #PsppSheetView
12063  *
12064  * Returns which grid lines are enabled in @tree_view.
12065  *
12066  * Return value: a #PsppSheetViewGridLines value indicating which grid lines
12067  * are enabled.
12068  *
12069  * Since: 2.10
12070  */
12071 PsppSheetViewGridLines
12072 pspp_sheet_view_get_grid_lines (PsppSheetView *tree_view)
12073 {
12074   g_return_val_if_fail (PSPP_IS_SHEET_VIEW (tree_view), 0);
12075
12076   return tree_view->priv->grid_lines;
12077 }
12078
12079 /**
12080  * pspp_sheet_view_set_grid_lines:
12081  * @tree_view: a #PsppSheetView
12082  * @grid_lines: a #PsppSheetViewGridLines value indicating which grid lines to
12083  * enable.
12084  *
12085  * Sets which grid lines to draw in @tree_view.
12086  *
12087  * Since: 2.10
12088  */
12089 void
12090 pspp_sheet_view_set_grid_lines (PsppSheetView           *tree_view,
12091                               PsppSheetViewGridLines   grid_lines)
12092 {
12093   PsppSheetViewPrivate *priv;
12094   PsppSheetViewGridLines old_grid_lines;
12095
12096   g_return_if_fail (PSPP_IS_SHEET_VIEW (tree_view));
12097
12098   priv = tree_view->priv;
12099
12100   old_grid_lines = priv->grid_lines;
12101   priv->grid_lines = grid_lines;
12102
12103   if (old_grid_lines != grid_lines)
12104     {
12105       gtk_widget_queue_draw (GTK_WIDGET (tree_view));
12106
12107       g_object_notify (G_OBJECT (tree_view), "enable-grid-lines");
12108     }
12109 }
12110
12111 /**
12112  * pspp_sheet_view_get_special_cells:
12113  * @tree_view: a #PsppSheetView
12114  *
12115  * Returns which grid lines are enabled in @tree_view.
12116  *
12117  * Return value: a #PsppSheetViewSpecialCells value indicating whether rows in
12118  * the sheet view contain special cells.
12119  */
12120 PsppSheetViewSpecialCells
12121 pspp_sheet_view_get_special_cells (PsppSheetView *tree_view)
12122 {
12123   g_return_val_if_fail (PSPP_IS_SHEET_VIEW (tree_view), 0);
12124
12125   return tree_view->priv->special_cells;
12126 }
12127
12128 /**
12129  * pspp_sheet_view_set_special_cells:
12130  * @tree_view: a #PsppSheetView
12131  * @special_cells: a #PsppSheetViewSpecialCells value indicating whether rows in
12132  * the sheet view contain special cells.
12133  *
12134  * Sets whether rows in the sheet view contain special cells, controlling the
12135  * rendering of row selections.
12136  */
12137 void
12138 pspp_sheet_view_set_special_cells (PsppSheetView           *tree_view,
12139                               PsppSheetViewSpecialCells   special_cells)
12140 {
12141   PsppSheetViewPrivate *priv;
12142
12143   g_return_if_fail (PSPP_IS_SHEET_VIEW (tree_view));
12144
12145   priv = tree_view->priv;
12146
12147   if (priv->special_cells != special_cells)
12148     {
12149       priv->special_cells = special_cells;
12150       gtk_widget_queue_draw (GTK_WIDGET (tree_view));
12151       g_object_notify (G_OBJECT (tree_view), "special-cells");
12152     }
12153 }
12154
12155 int
12156 pspp_sheet_view_get_fixed_height (const PsppSheetView *tree_view)
12157 {
12158   /* XXX (re)calculate fixed_height if necessary */
12159   return tree_view->priv->fixed_height;
12160 }
12161
12162 void
12163 pspp_sheet_view_set_fixed_height (PsppSheetView *tree_view,
12164                                   int fixed_height)
12165 {
12166   g_return_if_fail (fixed_height > 0);
12167
12168   if (tree_view->priv->fixed_height != fixed_height)
12169     {
12170       tree_view->priv->fixed_height = fixed_height;
12171       g_object_notify (G_OBJECT (tree_view), "fixed-height");
12172     }
12173   if (!tree_view->priv->fixed_height_set)
12174     {
12175       tree_view->priv->fixed_height_set = TRUE;
12176       g_object_notify (G_OBJECT (tree_view), "fixed-height-set");
12177     }
12178 }
12179
12180 /**
12181  * pspp_sheet_view_set_tooltip_row:
12182  * @tree_view: a #PsppSheetView
12183  * @tooltip: a #GtkTooltip
12184  * @path: a #GtkTreePath
12185  *
12186  * Sets the tip area of @tooltip to be the area covered by the row at @path.
12187  * See also pspp_sheet_view_set_tooltip_column() for a simpler alternative.
12188  * See also gtk_tooltip_set_tip_area().
12189  *
12190  * Since: 2.12
12191  */
12192 void
12193 pspp_sheet_view_set_tooltip_row (PsppSheetView *tree_view,
12194                                GtkTooltip  *tooltip,
12195                                GtkTreePath *path)
12196 {
12197   g_return_if_fail (PSPP_IS_SHEET_VIEW (tree_view));
12198   g_return_if_fail (GTK_IS_TOOLTIP (tooltip));
12199
12200   pspp_sheet_view_set_tooltip_cell (tree_view, tooltip, path, NULL, NULL);
12201 }
12202
12203 /**
12204  * pspp_sheet_view_set_tooltip_cell:
12205  * @tree_view: a #PsppSheetView
12206  * @tooltip: a #GtkTooltip
12207  * @path: (allow-none): a #GtkTreePath or %NULL
12208  * @column: (allow-none): a #PsppSheetViewColumn or %NULL
12209  * @cell: (allow-none): a #GtkCellRenderer or %NULL
12210  *
12211  * Sets the tip area of @tooltip to the area @path, @column and @cell have
12212  * in common.  For example if @path is %NULL and @column is set, the tip
12213  * area will be set to the full area covered by @column.  See also
12214  * gtk_tooltip_set_tip_area().
12215  *
12216  * See also pspp_sheet_view_set_tooltip_column() for a simpler alternative.
12217  *
12218  * Since: 2.12
12219  */
12220 void
12221 pspp_sheet_view_set_tooltip_cell (PsppSheetView       *tree_view,
12222                                 GtkTooltip        *tooltip,
12223                                 GtkTreePath       *path,
12224                                 PsppSheetViewColumn *column,
12225                                 GtkCellRenderer   *cell)
12226 {
12227   GdkRectangle rect;
12228
12229   g_return_if_fail (PSPP_IS_SHEET_VIEW (tree_view));
12230   g_return_if_fail (GTK_IS_TOOLTIP (tooltip));
12231   g_return_if_fail (column == NULL || PSPP_IS_SHEET_VIEW_COLUMN (column));
12232   g_return_if_fail (cell == NULL || GTK_IS_CELL_RENDERER (cell));
12233
12234   /* Determine x values. */
12235   if (column && cell)
12236     {
12237       GdkRectangle tmp;
12238       gint start, width;
12239
12240       pspp_sheet_view_get_cell_area (tree_view, path, column, &tmp);
12241       pspp_sheet_view_column_cell_get_position (column, cell, &start, &width);
12242
12243       pspp_sheet_view_convert_bin_window_to_widget_coords (tree_view,
12244                                                          tmp.x + start, 0,
12245                                                          &rect.x, NULL);
12246       rect.width = width;
12247     }
12248   else if (column)
12249     {
12250       GdkRectangle tmp;
12251
12252       pspp_sheet_view_get_background_area (tree_view, NULL, column, &tmp);
12253       pspp_sheet_view_convert_bin_window_to_widget_coords (tree_view,
12254                                                          tmp.x, 0,
12255                                                          &rect.x, NULL);
12256       rect.width = tmp.width;
12257     }
12258   else
12259     {
12260       GtkAllocation allocation;
12261       gtk_widget_get_allocation (GTK_WIDGET (tree_view), &allocation);
12262       rect.x = 0;
12263       rect.width = allocation.width;
12264     }
12265
12266   /* Determine y values. */
12267   if (path)
12268     {
12269       GdkRectangle tmp;
12270
12271       pspp_sheet_view_get_background_area (tree_view, path, NULL, &tmp);
12272       pspp_sheet_view_convert_bin_window_to_widget_coords (tree_view,
12273                                                          0, tmp.y,
12274                                                          NULL, &rect.y);
12275       rect.height = tmp.height;
12276     }
12277   else
12278     {
12279       rect.y = 0;
12280       rect.height = gtk_adjustment_get_page_size (tree_view->priv->vadjustment);
12281     }
12282
12283   gtk_tooltip_set_tip_area (tooltip, &rect);
12284 }
12285
12286 /**
12287  * pspp_sheet_view_get_tooltip_context:
12288  * @tree_view: a #PsppSheetView
12289  * @x: the x coordinate (relative to widget coordinates)
12290  * @y: the y coordinate (relative to widget coordinates)
12291  * @keyboard_tip: whether this is a keyboard tooltip or not
12292  * @model: (allow-none): a pointer to receive a #GtkTreeModel or %NULL
12293  * @path: (allow-none): a pointer to receive a #GtkTreePath or %NULL
12294  * @iter: (allow-none): a pointer to receive a #GtkTreeIter or %NULL
12295  *
12296  * This function is supposed to be used in a #GtkWidget::query-tooltip
12297  * signal handler for #PsppSheetView.  The @x, @y and @keyboard_tip values
12298  * which are received in the signal handler, should be passed to this
12299  * function without modification.
12300  *
12301  * The return value indicates whether there is a tree view row at the given
12302  * coordinates (%TRUE) or not (%FALSE) for mouse tooltips.  For keyboard
12303  * tooltips the row returned will be the cursor row.  When %TRUE, then any of
12304  * @model, @path and @iter which have been provided will be set to point to
12305  * that row and the corresponding model.  @x and @y will always be converted
12306  * to be relative to @tree_view's bin_window if @keyboard_tooltip is %FALSE.
12307  *
12308  * Return value: whether or not the given tooltip context points to a row.
12309  *
12310  * Since: 2.12
12311  */
12312 gboolean
12313 pspp_sheet_view_get_tooltip_context (PsppSheetView   *tree_view,
12314                                    gint          *x,
12315                                    gint          *y,
12316                                    gboolean       keyboard_tip,
12317                                    GtkTreeModel **model,
12318                                    GtkTreePath  **path,
12319                                    GtkTreeIter   *iter)
12320 {
12321   GtkTreePath *tmppath = NULL;
12322
12323   g_return_val_if_fail (PSPP_IS_SHEET_VIEW (tree_view), FALSE);
12324   g_return_val_if_fail (x != NULL, FALSE);
12325   g_return_val_if_fail (y != NULL, FALSE);
12326
12327   if (keyboard_tip)
12328     {
12329       pspp_sheet_view_get_cursor (tree_view, &tmppath, NULL);
12330
12331       if (!tmppath)
12332         return FALSE;
12333     }
12334   else
12335     {
12336       pspp_sheet_view_convert_widget_to_bin_window_coords (tree_view, *x, *y,
12337                                                          x, y);
12338
12339       if (!pspp_sheet_view_get_path_at_pos (tree_view, *x, *y,
12340                                           &tmppath, NULL, NULL, NULL))
12341         return FALSE;
12342     }
12343
12344   if (model)
12345     *model = pspp_sheet_view_get_model (tree_view);
12346
12347   if (iter)
12348     gtk_tree_model_get_iter (pspp_sheet_view_get_model (tree_view),
12349                              iter, tmppath);
12350
12351   if (path)
12352     *path = tmppath;
12353   else
12354     gtk_tree_path_free (tmppath);
12355
12356   return TRUE;
12357 }
12358
12359 static gboolean
12360 pspp_sheet_view_set_tooltip_query_cb (GtkWidget  *widget,
12361                                     gint        x,
12362                                     gint        y,
12363                                     gboolean    keyboard_tip,
12364                                     GtkTooltip *tooltip,
12365                                     gpointer    data)
12366 {
12367   GValue value = { 0, };
12368   GValue transformed = { 0, };
12369   GtkTreeIter iter;
12370   GtkTreePath *path;
12371   GtkTreeModel *model;
12372   PsppSheetView *tree_view = PSPP_SHEET_VIEW (widget);
12373
12374   if (!pspp_sheet_view_get_tooltip_context (PSPP_SHEET_VIEW (widget),
12375                                           &x, &y,
12376                                           keyboard_tip,
12377                                           &model, &path, &iter))
12378     return FALSE;
12379
12380   gtk_tree_model_get_value (model, &iter,
12381                             tree_view->priv->tooltip_column, &value);
12382
12383   g_value_init (&transformed, G_TYPE_STRING);
12384
12385   if (!g_value_transform (&value, &transformed))
12386     {
12387       g_value_unset (&value);
12388       gtk_tree_path_free (path);
12389
12390       return FALSE;
12391     }
12392
12393   g_value_unset (&value);
12394
12395   if (!g_value_get_string (&transformed))
12396     {
12397       g_value_unset (&transformed);
12398       gtk_tree_path_free (path);
12399
12400       return FALSE;
12401     }
12402
12403   gtk_tooltip_set_markup (tooltip, g_value_get_string (&transformed));
12404   pspp_sheet_view_set_tooltip_row (tree_view, tooltip, path);
12405
12406   gtk_tree_path_free (path);
12407   g_value_unset (&transformed);
12408
12409   return TRUE;
12410 }
12411
12412 /**
12413  * pspp_sheet_view_set_tooltip_column:
12414  * @tree_view: a #PsppSheetView
12415  * @column: an integer, which is a valid column number for @tree_view's model
12416  *
12417  * If you only plan to have simple (text-only) tooltips on full rows, you
12418  * can use this function to have #PsppSheetView handle these automatically
12419  * for you. @column should be set to the column in @tree_view's model
12420  * containing the tooltip texts, or -1 to disable this feature.
12421  *
12422  * When enabled, #GtkWidget::has-tooltip will be set to %TRUE and
12423  * @tree_view will connect a #GtkWidget::query-tooltip signal handler.
12424  *
12425  * Note that the signal handler sets the text with gtk_tooltip_set_markup(),
12426  * so &amp;, &lt;, etc have to be escaped in the text.
12427  *
12428  * Since: 2.12
12429  */
12430 void
12431 pspp_sheet_view_set_tooltip_column (PsppSheetView *tree_view,
12432                                   gint         column)
12433 {
12434   g_return_if_fail (PSPP_IS_SHEET_VIEW (tree_view));
12435
12436   if (column == tree_view->priv->tooltip_column)
12437     return;
12438
12439   if (column == -1)
12440     {
12441       g_signal_handlers_disconnect_by_func (tree_view,
12442                                             pspp_sheet_view_set_tooltip_query_cb,
12443                                             NULL);
12444       gtk_widget_set_has_tooltip (GTK_WIDGET (tree_view), FALSE);
12445     }
12446   else
12447     {
12448       if (tree_view->priv->tooltip_column == -1)
12449         {
12450           g_signal_connect (tree_view, "query-tooltip",
12451                             G_CALLBACK (pspp_sheet_view_set_tooltip_query_cb), NULL);
12452           gtk_widget_set_has_tooltip (GTK_WIDGET (tree_view), TRUE);
12453         }
12454     }
12455
12456   tree_view->priv->tooltip_column = column;
12457   g_object_notify (G_OBJECT (tree_view), "tooltip-column");
12458 }
12459
12460 /**
12461  * pspp_sheet_view_get_tooltip_column:
12462  * @tree_view: a #PsppSheetView
12463  *
12464  * Returns the column of @tree_view's model which is being used for
12465  * displaying tooltips on @tree_view's rows.
12466  *
12467  * Return value: the index of the tooltip column that is currently being
12468  * used, or -1 if this is disabled.
12469  *
12470  * Since: 2.12
12471  */
12472 gint
12473 pspp_sheet_view_get_tooltip_column (PsppSheetView *tree_view)
12474 {
12475   g_return_val_if_fail (PSPP_IS_SHEET_VIEW (tree_view), 0);
12476
12477   return tree_view->priv->tooltip_column;
12478 }
12479
12480 gboolean
12481 _gtk_boolean_handled_accumulator (GSignalInvocationHint *ihint,
12482                                   GValue                *return_accu,
12483                                   const GValue          *handler_return,
12484                                   gpointer               dummy)
12485 {
12486   gboolean continue_emission;
12487   gboolean signal_handled;
12488
12489   signal_handled = g_value_get_boolean (handler_return);
12490   g_value_set_boolean (return_accu, signal_handled);
12491   continue_emission = !signal_handled;
12492
12493   return continue_emission;
12494 }
12495
12496
12497 GType
12498 pspp_sheet_view_grid_lines_get_type (void)
12499 {
12500     static GType etype = 0;
12501     if (G_UNLIKELY(etype == 0)) {
12502         static const GEnumValue values[] = {
12503             { PSPP_SHEET_VIEW_GRID_LINES_NONE, "PSPP_SHEET_VIEW_GRID_LINES_NONE", "none" },
12504             { PSPP_SHEET_VIEW_GRID_LINES_HORIZONTAL, "PSPP_SHEET_VIEW_GRID_LINES_HORIZONTAL", "horizontal" },
12505             { PSPP_SHEET_VIEW_GRID_LINES_VERTICAL, "PSPP_SHEET_VIEW_GRID_LINES_VERTICAL", "vertical" },
12506             { PSPP_SHEET_VIEW_GRID_LINES_BOTH, "PSPP_SHEET_VIEW_GRID_LINES_BOTH", "both" },
12507             { 0, NULL, NULL }
12508         };
12509         etype = g_enum_register_static (g_intern_static_string ("PsppSheetViewGridLines"), values);
12510     }
12511     return etype;
12512 }
12513
12514 GType
12515 pspp_sheet_view_special_cells_get_type (void)
12516 {
12517     static GType etype = 0;
12518     if (G_UNLIKELY(etype == 0)) {
12519         static const GEnumValue values[] = {
12520             { PSPP_SHEET_VIEW_SPECIAL_CELLS_DETECT, "PSPP_SHEET_VIEW_SPECIAL_CELLS_DETECT", "detect" },
12521             { PSPP_SHEET_VIEW_SPECIAL_CELLS_YES, "PSPP_SHEET_VIEW_SPECIAL_CELLS_YES", "yes" },
12522             { PSPP_SHEET_VIEW_SPECIAL_CELLS_NO, "PSPP_SHEET_VIEW_SPECIAL_CELLS_NO", "no" },
12523             { 0, NULL, NULL }
12524         };
12525         etype = g_enum_register_static (g_intern_static_string ("PsppSheetViewSpecialCells"), values);
12526     }
12527     return etype;
12528 }