Pileus Git - ~andy/gtk/blob - gtk/gtktreeview.c

   1 /* gtktreeview.c
   2  * Copyright (C) 2000  Red Hat, Inc.,  Jonathan Blandford <jrb@redhat.com>
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Library General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library 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 GNU
  12  * Library General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Library General Public
  15  * License along with this library; if not, write to the
  16  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17  * Boston, MA 02111-1307, USA.
  18  */
  19
  20
  21 #include "config.h"
  22 #include <math.h>
  23 #include <string.h>
  24 #include <gdk/gdkkeysyms.h>
  25
  26 #include "gtktreeview.h"
  27 #include "gtkrbtree.h"
  28 #include "gtktreednd.h"
  29 #include "gtktreeprivate.h"
  30 #include "gtkcellrenderer.h"
  31 #include "gtkmain.h"
  32 #include "gtkmarshalers.h"
  33 #include "gtkbuildable.h"
  34 #include "gtkbutton.h"
  35 #include "gtkalignment.h"
  36 #include "gtklabel.h"
  37 #include "gtkhbox.h"
  38 #include "gtkvbox.h"
  39 #include "gtkarrow.h"
  40 #include "gtkintl.h"
  41 #include "gtkbindings.h"
  42 #include "gtkcontainer.h"
  43 #include "gtkentry.h"
  44 #include "gtkframe.h"
  45 #include "gtktreemodelsort.h"
  46 #include "gtktooltip.h"
  47 #include "gtkprivate.h"
  48
  49 #define GTK_TREE_VIEW_PRIORITY_VALIDATE (GDK_PRIORITY_REDRAW + 5)
  50 #define GTK_TREE_VIEW_PRIORITY_SCROLL_SYNC (GTK_TREE_VIEW_PRIORITY_VALIDATE + 2)
  51 #define GTK_TREE_VIEW_TIME_MS_PER_IDLE 30
  52 #define SCROLL_EDGE_SIZE 15
  53 #define EXPANDER_EXTRA_PADDING 4
  54 #define GTK_TREE_VIEW_SEARCH_DIALOG_TIMEOUT 5000
  55 #define AUTO_EXPAND_TIMEOUT 500
  56
  57 /* The "background" areas of all rows/cells add up to cover the entire tree.
  58  * The background includes all inter-row and inter-cell spacing.
  59  * The "cell" areas are the cell_area passed in to gtk_cell_renderer_render(),
  60  * i.e. just the cells, no spacing.
  61  */
  62
  63 #define BACKGROUND_HEIGHT(node) (GTK_RBNODE_GET_HEIGHT (node))
  64 #define CELL_HEIGHT(node, separator) ((BACKGROUND_HEIGHT (node)) - (separator))
  65
  66 /* Translate from bin_window coordinates to rbtree (tree coordinates) and
  67  * vice versa.
  68  */
  69 #define TREE_WINDOW_Y_TO_RBTREE_Y(tree_view,y) ((y) + tree_view->priv->dy)
  70 #define RBTREE_Y_TO_TREE_WINDOW_Y(tree_view,y) ((y) - tree_view->priv->dy)
  71
  72 /* This is in bin_window coordinates */
  73 #define BACKGROUND_FIRST_PIXEL(tree_view,tree,node) (RBTREE_Y_TO_TREE_WINDOW_Y (tree_view, _gtk_rbtree_node_find_offset ((tree), (node))))
  74 #define CELL_FIRST_PIXEL(tree_view,tree,node,separator) (BACKGROUND_FIRST_PIXEL (tree_view,tree,node) + separator/2)
  75
  76 #define ROW_HEIGHT(tree_view,height) \
  77   ((height > 0) ? (height) : (tree_view)->priv->expander_size)
  78
  79
  80 typedef struct _GtkTreeViewChild GtkTreeViewChild;
  81 struct _GtkTreeViewChild
  82 {
  83   GtkWidget *widget;
  84   gint x;
  85   gint y;
  86   gint width;
  87   gint height;
  88 };
  89
  90
  91 typedef struct _TreeViewDragInfo TreeViewDragInfo;
  92 struct _TreeViewDragInfo
  93 {
  94   GdkModifierType start_button_mask;
  95   GtkTargetList *_unused_source_target_list;
  96   GdkDragAction source_actions;
  97
  98   GtkTargetList *_unused_dest_target_list;
  99
 100   guint source_set : 1;
 101   guint dest_set : 1;
 102 };
 103
 104
 105 /* Signals */
 106 enum
 107 {
 108   ROW_ACTIVATED,
 109   TEST_EXPAND_ROW,
 110   TEST_COLLAPSE_ROW,
 111   ROW_EXPANDED,
 112   ROW_COLLAPSED,
 113   COLUMNS_CHANGED,
 114   CURSOR_CHANGED,
 115   MOVE_CURSOR,
 116   SELECT_ALL,
 117   UNSELECT_ALL,
 118   SELECT_CURSOR_ROW,
 119   TOGGLE_CURSOR_ROW,
 120   EXPAND_COLLAPSE_CURSOR_ROW,
 121   SELECT_CURSOR_PARENT,
 122   START_INTERACTIVE_SEARCH,
 123   LAST_SIGNAL
 124 };
 125
 126 /* Properties */
 127 enum {
 128   PROP_0,
 129   PROP_MODEL,
 130   PROP_HADJUSTMENT,
 131   PROP_VADJUSTMENT,
 132   PROP_HEADERS_VISIBLE,
 133   PROP_HEADERS_CLICKABLE,
 134   PROP_EXPANDER_COLUMN,
 135   PROP_REORDERABLE,
 136   PROP_RULES_HINT,
 137   PROP_ENABLE_SEARCH,
 138   PROP_SEARCH_COLUMN,
 139   PROP_FIXED_HEIGHT_MODE,
 140   PROP_HOVER_SELECTION,
 141   PROP_HOVER_EXPAND,
 142   PROP_SHOW_EXPANDERS,
 143   PROP_LEVEL_INDENTATION,
 144   PROP_RUBBER_BANDING,
 145   PROP_ENABLE_GRID_LINES,
 146   PROP_ENABLE_TREE_LINES,
 147   PROP_TOOLTIP_COLUMN
 148 };
 149
 150 /* object signals */
 151 static void     gtk_tree_view_finalize             (GObject          *object);
 152 static void     gtk_tree_view_set_property         (GObject         *object,
 153                                                     guint            prop_id,
 154                                                     const GValue    *value,
 155                                                     GParamSpec      *pspec);
 156 static void     gtk_tree_view_get_property         (GObject         *object,
 157                                                     guint            prop_id,
 158                                                     GValue          *value,
 159                                                     GParamSpec      *pspec);
 160
 161 /* gtkobject signals */
 162 static void     gtk_tree_view_destroy              (GtkObject        *object);
 163
 164 /* gtkwidget signals */
 165 static void     gtk_tree_view_realize              (GtkWidget        *widget);
 166 static void     gtk_tree_view_unrealize            (GtkWidget        *widget);
 167 static void     gtk_tree_view_map                  (GtkWidget        *widget);
 168 static void     gtk_tree_view_size_request         (GtkWidget        *widget,
 169                                                     GtkRequisition   *requisition);
 170 static void     gtk_tree_view_size_allocate        (GtkWidget        *widget,
 171                                                     GtkAllocation    *allocation);
 172 static gboolean gtk_tree_view_draw                 (GtkWidget        *widget,
 173                                                     cairo_t          *cr);
 174 static gboolean gtk_tree_view_key_press            (GtkWidget        *widget,
 175                                                     GdkEventKey      *event);
 176 static gboolean gtk_tree_view_key_release          (GtkWidget        *widget,
 177                                                     GdkEventKey      *event);
 178 static gboolean gtk_tree_view_motion               (GtkWidget        *widget,
 179                                                     GdkEventMotion   *event);
 180 static gboolean gtk_tree_view_enter_notify         (GtkWidget        *widget,
 181                                                     GdkEventCrossing *event);
 182 static gboolean gtk_tree_view_leave_notify         (GtkWidget        *widget,
 183                                                     GdkEventCrossing *event);
 184 static gboolean gtk_tree_view_button_press         (GtkWidget        *widget,
 185                                                     GdkEventButton   *event);
 186 static gboolean gtk_tree_view_button_release       (GtkWidget        *widget,
 187                                                     GdkEventButton   *event);
 188 static gboolean gtk_tree_view_grab_broken          (GtkWidget          *widget,
 189                                                     GdkEventGrabBroken *event);
 190 #if 0
 191 static gboolean gtk_tree_view_configure            (GtkWidget         *widget,
 192                                                     GdkEventConfigure *event);
 193 #endif
 194
 195 static void     gtk_tree_view_set_focus_child      (GtkContainer     *container,
 196                                                     GtkWidget        *child);
 197 static gint     gtk_tree_view_focus_out            (GtkWidget        *widget,
 198                                                     GdkEventFocus    *event);
 199 static gint     gtk_tree_view_focus                (GtkWidget        *widget,
 200                                                     GtkDirectionType  direction);
 201 static void     gtk_tree_view_grab_focus           (GtkWidget        *widget);
 202 static void     gtk_tree_view_style_set            (GtkWidget        *widget,
 203                                                     GtkStyle         *previous_style);
 204 static void     gtk_tree_view_grab_notify          (GtkWidget        *widget,
 205                                                     gboolean          was_grabbed);
 206 static void     gtk_tree_view_state_changed        (GtkWidget        *widget,
 207                                                     GtkStateType      previous_state);
 208
 209 /* container signals */
 210 static void     gtk_tree_view_remove               (GtkContainer     *container,
 211                                                     GtkWidget        *widget);
 212 static void     gtk_tree_view_forall               (GtkContainer     *container,
 213                                                     gboolean          include_internals,
 214                                                     GtkCallback       callback,
 215                                                     gpointer          callback_data);
 216
 217 /* Source side drag signals */
 218 static void gtk_tree_view_drag_begin       (GtkWidget        *widget,
 219                                             GdkDragContext   *context);
 220 static void gtk_tree_view_drag_end         (GtkWidget        *widget,
 221                                             GdkDragContext   *context);
 222 static void gtk_tree_view_drag_data_get    (GtkWidget        *widget,
 223                                             GdkDragContext   *context,
 224                                             GtkSelectionData *selection_data,
 225                                             guint             info,
 226                                             guint             time);
 227 static void gtk_tree_view_drag_data_delete (GtkWidget        *widget,
 228                                             GdkDragContext   *context);
 229
 230 /* Target side drag signals */
 231 static void     gtk_tree_view_drag_leave         (GtkWidget        *widget,
 232                                                   GdkDragContext   *context,
 233                                                   guint             time);
 234 static gboolean gtk_tree_view_drag_motion        (GtkWidget        *widget,
 235                                                   GdkDragContext   *context,
 236                                                   gint              x,
 237                                                   gint              y,
 238                                                   guint             time);
 239 static gboolean gtk_tree_view_drag_drop          (GtkWidget        *widget,
 240                                                   GdkDragContext   *context,
 241                                                   gint              x,
 242                                                   gint              y,
 243                                                   guint             time);
 244 static void     gtk_tree_view_drag_data_received (GtkWidget        *widget,
 245                                                   GdkDragContext   *context,
 246                                                   gint              x,
 247                                                   gint              y,
 248                                                   GtkSelectionData *selection_data,
 249                                                   guint             info,
 250                                                   guint             time);
 251
 252 /* tree_model signals */
 253 static void gtk_tree_view_set_adjustments                 (GtkTreeView     *tree_view,
 254                                                            GtkAdjustment   *hadj,
 255                                                            GtkAdjustment   *vadj);
 256 static gboolean gtk_tree_view_real_move_cursor            (GtkTreeView     *tree_view,
 257                                                            GtkMovementStep  step,
 258                                                            gint             count);
 259 static gboolean gtk_tree_view_real_select_all             (GtkTreeView     *tree_view);
 260 static gboolean gtk_tree_view_real_unselect_all           (GtkTreeView     *tree_view);
 261 static gboolean gtk_tree_view_real_select_cursor_row      (GtkTreeView     *tree_view,
 262                                                            gboolean         start_editing);
 263 static gboolean gtk_tree_view_real_toggle_cursor_row      (GtkTreeView     *tree_view);
 264 static gboolean gtk_tree_view_real_expand_collapse_cursor_row (GtkTreeView     *tree_view,
 265                                                                gboolean         logical,
 266                                                                gboolean         expand,
 267                                                                gboolean         open_all);
 268 static gboolean gtk_tree_view_real_select_cursor_parent   (GtkTreeView     *tree_view);
 269 static void gtk_tree_view_row_changed                     (GtkTreeModel    *model,
 270                                                            GtkTreePath     *path,
 271                                                            GtkTreeIter     *iter,
 272                                                            gpointer         data);
 273 static void gtk_tree_view_row_inserted                    (GtkTreeModel    *model,
 274                                                            GtkTreePath     *path,
 275                                                            GtkTreeIter     *iter,
 276                                                            gpointer         data);
 277 static void gtk_tree_view_row_has_child_toggled           (GtkTreeModel    *model,
 278                                                            GtkTreePath     *path,
 279                                                            GtkTreeIter     *iter,
 280                                                            gpointer         data);
 281 static void gtk_tree_view_row_deleted                     (GtkTreeModel    *model,
 282                                                            GtkTreePath     *path,
 283                                                            gpointer         data);
 284 static void gtk_tree_view_rows_reordered                  (GtkTreeModel    *model,
 285                                                            GtkTreePath     *parent,
 286                                                            GtkTreeIter     *iter,
 287                                                            gint            *new_order,
 288                                                            gpointer         data);
 289
 290 /* Incremental reflow */
 291 static gboolean validate_row             (GtkTreeView *tree_view,
 292                                           GtkRBTree   *tree,
 293                                           GtkRBNode   *node,
 294                                           GtkTreeIter *iter,
 295                                           GtkTreePath *path);
 296 static void     validate_visible_area    (GtkTreeView *tree_view);
 297 static gboolean validate_rows_handler    (GtkTreeView *tree_view);
 298 static gboolean do_validate_rows         (GtkTreeView *tree_view,
 299                                           gboolean     size_request);
 300 static gboolean validate_rows            (GtkTreeView *tree_view);
 301 static gboolean presize_handler_callback (gpointer     data);
 302 static void     install_presize_handler  (GtkTreeView *tree_view);
 303 static void     install_scroll_sync_handler (GtkTreeView *tree_view);
 304 static void     gtk_tree_view_set_top_row   (GtkTreeView *tree_view,
 305                                              GtkTreePath *path,
 306                                              gint         offset);
 307 static void     gtk_tree_view_dy_to_top_row (GtkTreeView *tree_view);
 308 static void     gtk_tree_view_top_row_to_dy (GtkTreeView *tree_view);
 309 static void     invalidate_empty_focus      (GtkTreeView *tree_view);
 310
 311 /* Internal functions */
 312 static gboolean gtk_tree_view_is_expander_column             (GtkTreeView        *tree_view,
 313                                                               GtkTreeViewColumn  *column);
 314 static void     gtk_tree_view_add_move_binding               (GtkBindingSet      *binding_set,
 315                                                               guint               keyval,
 316                                                               guint               modmask,
 317                                                               gboolean            add_shifted_binding,
 318                                                               GtkMovementStep     step,
 319                                                               gint                count);
 320 static gint     gtk_tree_view_unref_and_check_selection_tree (GtkTreeView        *tree_view,
 321                                                               GtkRBTree          *tree);
 322 static void     gtk_tree_view_queue_draw_path                (GtkTreeView        *tree_view,
 323                                                               GtkTreePath        *path,
 324                                                               const GdkRectangle *clip_rect);
 325 static void     gtk_tree_view_queue_draw_arrow               (GtkTreeView        *tree_view,
 326                                                               GtkRBTree          *tree,
 327                                                               GtkRBNode          *node);
 328 static void     gtk_tree_view_draw_arrow                     (GtkTreeView        *tree_view,
 329                                                               cairo_t            *cr,
 330                                                               GtkRBTree          *tree,
 331                                                               GtkRBNode          *node,
 332                                                               gint                x,
 333                                                               gint                y);
 334 static void     gtk_tree_view_get_arrow_xrange               (GtkTreeView        *tree_view,
 335                                                               GtkRBTree          *tree,
 336                                                               gint               *x1,
 337                                                               gint               *x2);
 338 static gint     gtk_tree_view_new_column_width               (GtkTreeView        *tree_view,
 339                                                               gint                i,
 340                                                               gint               *x);
 341 static void     gtk_tree_view_adjustment_changed             (GtkAdjustment      *adjustment,
 342                                                               GtkTreeView        *tree_view);
 343 static void     gtk_tree_view_build_tree                     (GtkTreeView        *tree_view,
 344                                                               GtkRBTree          *tree,
 345                                                               GtkTreeIter        *iter,
 346                                                               gint                depth,
 347                                                               gboolean            recurse);
 348 static void     gtk_tree_view_clamp_node_visible             (GtkTreeView        *tree_view,
 349                                                               GtkRBTree          *tree,
 350                                                               GtkRBNode          *node);
 351 static void     gtk_tree_view_clamp_column_visible           (GtkTreeView        *tree_view,
 352                                                               GtkTreeViewColumn  *column,
 353                                                               gboolean            focus_to_cell);
 354 static gboolean gtk_tree_view_maybe_begin_dragging_row       (GtkTreeView        *tree_view,
 355                                                               GdkEventMotion     *event);
 356 static void     gtk_tree_view_focus_to_cursor                (GtkTreeView        *tree_view);
 357 static void     gtk_tree_view_move_cursor_up_down            (GtkTreeView        *tree_view,
 358                                                               gint                count);
 359 static void     gtk_tree_view_move_cursor_page_up_down       (GtkTreeView        *tree_view,
 360                                                               gint                count);
 361 static void     gtk_tree_view_move_cursor_left_right         (GtkTreeView        *tree_view,
 362                                                               gint                count);
 363 static void     gtk_tree_view_move_cursor_start_end          (GtkTreeView        *tree_view,
 364                                                               gint                count);
 365 static gboolean gtk_tree_view_real_collapse_row              (GtkTreeView        *tree_view,
 366                                                               GtkTreePath        *path,
 367                                                               GtkRBTree          *tree,
 368                                                               GtkRBNode          *node,
 369                                                               gboolean            animate);
 370 static gboolean gtk_tree_view_real_expand_row                (GtkTreeView        *tree_view,
 371                                                               GtkTreePath        *path,
 372                                                               GtkRBTree          *tree,
 373                                                               GtkRBNode          *node,
 374                                                               gboolean            open_all,
 375                                                               gboolean            animate);
 376 static void     gtk_tree_view_real_set_cursor                (GtkTreeView        *tree_view,
 377                                                               GtkTreePath        *path,
 378                                                               gboolean            clear_and_select,
 379                                                               gboolean            clamp_node);
 380 static gboolean gtk_tree_view_has_special_cell               (GtkTreeView        *tree_view);
 381 static void     column_sizing_notify                         (GObject            *object,
 382                                                               GParamSpec         *pspec,
 383                                                               gpointer            data);
 384 static gboolean expand_collapse_timeout                      (gpointer            data);
 385 static void     add_expand_collapse_timeout                  (GtkTreeView        *tree_view,
 386                                                               GtkRBTree          *tree,
 387                                                               GtkRBNode          *node,
 388                                                               gboolean            expand);
 389 static void     remove_expand_collapse_timeout               (GtkTreeView        *tree_view);
 390 static void     cancel_arrow_animation                       (GtkTreeView        *tree_view);
 391 static gboolean do_expand_collapse                           (GtkTreeView        *tree_view);
 392 static void     gtk_tree_view_stop_rubber_band               (GtkTreeView        *tree_view);
 393 static void     update_prelight                              (GtkTreeView        *tree_view,
 394                                                               int                 x,
 395                                                               int                 y);
 396
 397 /* interactive search */
 398 static void     gtk_tree_view_ensure_interactive_directory (GtkTreeView *tree_view);
 399 static void     gtk_tree_view_search_dialog_hide        (GtkWidget        *search_dialog,
 400                                                          GtkTreeView      *tree_view,
 401                                                          GdkDevice        *device);
 402 static void     gtk_tree_view_search_position_func      (GtkTreeView      *tree_view,
 403                                                          GtkWidget        *search_dialog,
 404                                                          gpointer          user_data);
 405 static void     gtk_tree_view_search_disable_popdown    (GtkEntry         *entry,
 406                                                          GtkMenu          *menu,
 407                                                          gpointer          data);
 408 static void     gtk_tree_view_search_preedit_changed    (GtkIMContext     *im_context,
 409                                                          GtkTreeView      *tree_view);
 410 static void     gtk_tree_view_search_activate           (GtkEntry         *entry,
 411                                                          GtkTreeView      *tree_view);
 412 static gboolean gtk_tree_view_real_search_enable_popdown(gpointer          data);
 413 static void     gtk_tree_view_search_enable_popdown     (GtkWidget        *widget,
 414                                                          gpointer          data);
 415 static gboolean gtk_tree_view_search_delete_event       (GtkWidget        *widget,
 416                                                          GdkEventAny      *event,
 417                                                          GtkTreeView      *tree_view);
 418 static gboolean gtk_tree_view_search_button_press_event (GtkWidget        *widget,
 419                                                          GdkEventButton   *event,
 420                                                          GtkTreeView      *tree_view);
 421 static gboolean gtk_tree_view_search_scroll_event       (GtkWidget        *entry,
 422                                                          GdkEventScroll   *event,
 423                                                          GtkTreeView      *tree_view);
 424 static gboolean gtk_tree_view_search_key_press_event    (GtkWidget        *entry,
 425                                                          GdkEventKey      *event,
 426                                                          GtkTreeView      *tree_view);
 427 static gboolean gtk_tree_view_search_move               (GtkWidget        *window,
 428                                                          GtkTreeView      *tree_view,
 429                                                          gboolean          up);
 430 static gboolean gtk_tree_view_search_equal_func         (GtkTreeModel     *model,
 431                                                          gint              column,
 432                                                          const gchar      *key,
 433                                                          GtkTreeIter      *iter,
 434                                                          gpointer          search_data);
 435 static gboolean gtk_tree_view_search_iter               (GtkTreeModel     *model,
 436                                                          GtkTreeSelection *selection,
 437                                                          GtkTreeIter      *iter,
 438                                                          const gchar      *text,
 439                                                          gint             *count,
 440                                                          gint              n);
 441 static void     gtk_tree_view_search_init               (GtkWidget        *entry,
 442                                                          GtkTreeView      *tree_view);
 443 static void     gtk_tree_view_put                       (GtkTreeView      *tree_view,
 444                                                          GtkWidget        *child_widget,
 445                                                          gint              x,
 446                                                          gint              y,
 447                                                          gint              width,
 448                                                          gint              height);
 449 static gboolean gtk_tree_view_start_editing             (GtkTreeView      *tree_view,
 450                                                          GtkTreePath      *cursor_path);
 451 static void gtk_tree_view_real_start_editing (GtkTreeView       *tree_view,
 452                                               GtkTreeViewColumn *column,
 453                                               GtkTreePath       *path,
 454                                               GtkCellEditable   *cell_editable,
 455                                               GdkRectangle      *cell_area,
 456                                               GdkEvent          *event,
 457                                               guint              flags);
 458 static void gtk_tree_view_stop_editing                  (GtkTreeView *tree_view,
 459                                                          gboolean     cancel_editing);
 460 static gboolean gtk_tree_view_real_start_interactive_search (GtkTreeView *tree_view,
 461                                                              GdkDevice   *device,
 462                                                              gboolean     keybinding);
 463 static gboolean gtk_tree_view_start_interactive_search      (GtkTreeView *tree_view);
 464 static GtkTreeViewColumn *gtk_tree_view_get_drop_column (GtkTreeView       *tree_view,
 465                                                          GtkTreeViewColumn *column,
 466                                                          gint               drop_position);
 467
 468 /* GtkBuildable */
 469 static void     gtk_tree_view_buildable_add_child          (GtkBuildable      *tree_view,
 470                                                             GtkBuilder        *builder,
 471                                                             GObject           *child,
 472                                                             const gchar       *type);
 473 static GObject *gtk_tree_view_buildable_get_internal_child (GtkBuildable      *buildable,
 474                                                             GtkBuilder        *builder,
 475                                                             const gchar       *childname);
 476 static void     gtk_tree_view_buildable_init               (GtkBuildableIface *iface);
 477
 478
 479 static gboolean scroll_row_timeout                   (gpointer     data);
 480 static void     add_scroll_timeout                   (GtkTreeView *tree_view);
 481 static void     remove_scroll_timeout                (GtkTreeView *tree_view);
 482
 483 static guint tree_view_signals [LAST_SIGNAL] = { 0 };
 484
 485 \f
 486
 487 /* GType Methods
 488  */
 489
 490 G_DEFINE_TYPE_WITH_CODE (GtkTreeView, gtk_tree_view, GTK_TYPE_CONTAINER,
 491                          G_IMPLEMENT_INTERFACE (GTK_TYPE_BUILDABLE,
 492                                                 gtk_tree_view_buildable_init))
 493
 494 static void
 495 gtk_tree_view_class_init (GtkTreeViewClass *class)
 496 {
 497   GObjectClass *o_class;
 498   GtkObjectClass *object_class;
 499   GtkWidgetClass *widget_class;
 500   GtkContainerClass *container_class;
 501   GtkBindingSet *binding_set;
 502
 503   binding_set = gtk_binding_set_by_class (class);
 504
 505   o_class = (GObjectClass *) class;
 506   object_class = (GtkObjectClass *) class;
 507   widget_class = (GtkWidgetClass *) class;
 508   container_class = (GtkContainerClass *) class;
 509
 510   /* GObject signals */
 511   o_class->set_property = gtk_tree_view_set_property;
 512   o_class->get_property = gtk_tree_view_get_property;
 513   o_class->finalize = gtk_tree_view_finalize;
 514
 515   /* GtkObject signals */
 516   object_class->destroy = gtk_tree_view_destroy;
 517
 518   /* GtkWidget signals */
 519   widget_class->map = gtk_tree_view_map;
 520   widget_class->realize = gtk_tree_view_realize;
 521   widget_class->unrealize = gtk_tree_view_unrealize;
 522   widget_class->size_request = gtk_tree_view_size_request;
 523   widget_class->size_allocate = gtk_tree_view_size_allocate;
 524   widget_class->button_press_event = gtk_tree_view_button_press;
 525   widget_class->button_release_event = gtk_tree_view_button_release;
 526   widget_class->grab_broken_event = gtk_tree_view_grab_broken;
 527   /*widget_class->configure_event = gtk_tree_view_configure;*/
 528   widget_class->motion_notify_event = gtk_tree_view_motion;
 529   widget_class->draw = gtk_tree_view_draw;
 530   widget_class->key_press_event = gtk_tree_view_key_press;
 531   widget_class->key_release_event = gtk_tree_view_key_release;
 532   widget_class->enter_notify_event = gtk_tree_view_enter_notify;
 533   widget_class->leave_notify_event = gtk_tree_view_leave_notify;
 534   widget_class->focus_out_event = gtk_tree_view_focus_out;
 535   widget_class->drag_begin = gtk_tree_view_drag_begin;
 536   widget_class->drag_end = gtk_tree_view_drag_end;
 537   widget_class->drag_data_get = gtk_tree_view_drag_data_get;
 538   widget_class->drag_data_delete = gtk_tree_view_drag_data_delete;
 539   widget_class->drag_leave = gtk_tree_view_drag_leave;
 540   widget_class->drag_motion = gtk_tree_view_drag_motion;
 541   widget_class->drag_drop = gtk_tree_view_drag_drop;
 542   widget_class->drag_data_received = gtk_tree_view_drag_data_received;
 543   widget_class->focus = gtk_tree_view_focus;
 544   widget_class->grab_focus = gtk_tree_view_grab_focus;
 545   widget_class->style_set = gtk_tree_view_style_set;
 546   widget_class->grab_notify = gtk_tree_view_grab_notify;
 547   widget_class->state_changed = gtk_tree_view_state_changed;
 548
 549   /* GtkContainer signals */
 550   container_class->remove = gtk_tree_view_remove;
 551   container_class->forall = gtk_tree_view_forall;
 552   container_class->set_focus_child = gtk_tree_view_set_focus_child;
 553
 554   class->set_scroll_adjustments = gtk_tree_view_set_adjustments;
 555   class->move_cursor = gtk_tree_view_real_move_cursor;
 556   class->select_all = gtk_tree_view_real_select_all;
 557   class->unselect_all = gtk_tree_view_real_unselect_all;
 558   class->select_cursor_row = gtk_tree_view_real_select_cursor_row;
 559   class->toggle_cursor_row = gtk_tree_view_real_toggle_cursor_row;
 560   class->expand_collapse_cursor_row = gtk_tree_view_real_expand_collapse_cursor_row;
 561   class->select_cursor_parent = gtk_tree_view_real_select_cursor_parent;
 562   class->start_interactive_search = gtk_tree_view_start_interactive_search;
 563
 564   /* Properties */
 565
 566   g_object_class_install_property (o_class,
 567                                    PROP_MODEL,
 568                                    g_param_spec_object ("model",
 569                                                         P_("TreeView Model"),
 570                                                         P_("The model for the tree view"),
 571                                                         GTK_TYPE_TREE_MODEL,
 572                                                         GTK_PARAM_READWRITE));
 573
 574   g_object_class_install_property (o_class,
 575                                    PROP_HADJUSTMENT,
 576                                    g_param_spec_object ("hadjustment",
 577                                                         P_("Horizontal Adjustment"),
 578                                                         P_("Horizontal Adjustment for the widget"),
 579                                                         GTK_TYPE_ADJUSTMENT,
 580                                                         GTK_PARAM_READWRITE));
 581
 582   g_object_class_install_property (o_class,
 583                                    PROP_VADJUSTMENT,
 584                                    g_param_spec_object ("vadjustment",
 585                                                         P_("Vertical Adjustment"),
 586                                                         P_("Vertical Adjustment for the widget"),
 587                                                         GTK_TYPE_ADJUSTMENT,
 588                                                         GTK_PARAM_READWRITE));
 589
 590   g_object_class_install_property (o_class,
 591                                    PROP_HEADERS_VISIBLE,
 592                                    g_param_spec_boolean ("headers-visible",
 593                                                          P_("Headers Visible"),
 594                                                          P_("Show the column header buttons"),
 595                                                          TRUE,
 596                                                          GTK_PARAM_READWRITE));
 597
 598   g_object_class_install_property (o_class,
 599                                    PROP_HEADERS_CLICKABLE,
 600                                    g_param_spec_boolean ("headers-clickable",
 601                                                          P_("Headers Clickable"),
 602                                                          P_("Column headers respond to click events"),
 603                                                          TRUE,
 604                                                          GTK_PARAM_READWRITE));
 605
 606   g_object_class_install_property (o_class,
 607                                    PROP_EXPANDER_COLUMN,
 608                                    g_param_spec_object ("expander-column",
 609                                                         P_("Expander Column"),
 610                                                         P_("Set the column for the expander column"),
 611                                                         GTK_TYPE_TREE_VIEW_COLUMN,
 612                                                         GTK_PARAM_READWRITE));
 613
 614   g_object_class_install_property (o_class,
 615                                    PROP_REORDERABLE,
 616                                    g_param_spec_boolean ("reorderable",
 617                                                          P_("Reorderable"),
 618                                                          P_("View is reorderable"),
 619                                                          FALSE,
 620                                                          GTK_PARAM_READWRITE));
 621
 622   g_object_class_install_property (o_class,
 623                                    PROP_RULES_HINT,
 624                                    g_param_spec_boolean ("rules-hint",
 625                                                          P_("Rules Hint"),
 626                                                          P_("Set a hint to the theme engine to draw rows in alternating colors"),
 627                                                          FALSE,
 628                                                          GTK_PARAM_READWRITE));
 629
 630     g_object_class_install_property (o_class,
 631                                      PROP_ENABLE_SEARCH,
 632                                      g_param_spec_boolean ("enable-search",
 633                                                            P_("Enable Search"),
 634                                                            P_("View allows user to search through columns interactively"),
 635                                                            TRUE,
 636                                                            GTK_PARAM_READWRITE));
 637
 638     g_object_class_install_property (o_class,
 639                                      PROP_SEARCH_COLUMN,
 640                                      g_param_spec_int ("search-column",
 641                                                        P_("Search Column"),
 642                                                        P_("Model column to search through during interactive search"),
 643                                                        -1,
 644                                                        G_MAXINT,
 645                                                        -1,
 646                                                        GTK_PARAM_READWRITE));
 647
 648     /**
 649      * GtkTreeView:fixed-height-mode:
 650      *
 651      * Setting the ::fixed-height-mode property to %TRUE speeds up
 652      * #GtkTreeView by assuming that all rows have the same height.
 653      * Only enable this option if all rows are the same height.
 654      * Please see gtk_tree_view_set_fixed_height_mode() for more
 655      * information on this option.
 656      *
 657      * Since: 2.4
 658      **/
 659     g_object_class_install_property (o_class,
 660                                      PROP_FIXED_HEIGHT_MODE,
 661                                      g_param_spec_boolean ("fixed-height-mode",
 662                                                            P_("Fixed Height Mode"),
 663                                                            P_("Speeds up GtkTreeView by assuming that all rows have the same height"),
 664                                                            FALSE,
 665                                                            GTK_PARAM_READWRITE));
 666
 667     /**
 668      * GtkTreeView:hover-selection:
 669      *
 670      * Enables or disables the hover selection mode of @tree_view.
 671      * Hover selection makes the selected row follow the pointer.
 672      * Currently, this works only for the selection modes
 673      * %GTK_SELECTION_SINGLE and %GTK_SELECTION_BROWSE.
 674      *
 675      * This mode is primarily intended for treeviews in popups, e.g.
 676      * in #GtkComboBox or #GtkEntryCompletion.
 677      *
 678      * Since: 2.6
 679      */
 680     g_object_class_install_property (o_class,
 681                                      PROP_HOVER_SELECTION,
 682                                      g_param_spec_boolean ("hover-selection",
 683                                                            P_("Hover Selection"),
 684                                                            P_("Whether the selection should follow the pointer"),
 685                                                            FALSE,
 686                                                            GTK_PARAM_READWRITE));
 687
 688     /**
 689      * GtkTreeView:hover-expand:
 690      *
 691      * Enables or disables the hover expansion mode of @tree_view.
 692      * Hover expansion makes rows expand or collapse if the pointer moves
 693      * over them.
 694      *
 695      * This mode is primarily intended for treeviews in popups, e.g.
 696      * in #GtkComboBox or #GtkEntryCompletion.
 697      *
 698      * Since: 2.6
 699      */
 700     g_object_class_install_property (o_class,
 701                                      PROP_HOVER_EXPAND,
 702                                      g_param_spec_boolean ("hover-expand",
 703                                                            P_("Hover Expand"),
 704                                                            P_("Whether rows should be expanded/collapsed when the pointer moves over them"),
 705                                                            FALSE,
 706                                                            GTK_PARAM_READWRITE));
 707
 708     /**
 709      * GtkTreeView:show-expanders:
 710      *
 711      * %TRUE if the view has expanders.
 712      *
 713      * Since: 2.12
 714      */
 715     g_object_class_install_property (o_class,
 716                                      PROP_SHOW_EXPANDERS,
 717                                      g_param_spec_boolean ("show-expanders",
 718                                                            P_("Show Expanders"),
 719                                                            P_("View has expanders"),
 720                                                            TRUE,
 721                                                            GTK_PARAM_READWRITE));
 722
 723     /**
 724      * GtkTreeView:level-indentation:
 725      *
 726      * Extra indentation for each level.
 727      *
 728      * Since: 2.12
 729      */
 730     g_object_class_install_property (o_class,
 731                                      PROP_LEVEL_INDENTATION,
 732                                      g_param_spec_int ("level-indentation",
 733                                                        P_("Level Indentation"),
 734                                                        P_("Extra indentation for each level"),
 735                                                        0,
 736                                                        G_MAXINT,
 737                                                        0,
 738                                                        GTK_PARAM_READWRITE));
 739
 740     g_object_class_install_property (o_class,
 741                                      PROP_RUBBER_BANDING,
 742                                      g_param_spec_boolean ("rubber-banding",
 743                                                            P_("Rubber Banding"),
 744                                                            P_("Whether to enable selection of multiple items by dragging the mouse pointer"),
 745                                                            FALSE,
 746                                                            GTK_PARAM_READWRITE));
 747
 748     g_object_class_install_property (o_class,
 749                                      PROP_ENABLE_GRID_LINES,
 750                                      g_param_spec_enum ("enable-grid-lines",
 751                                                         P_("Enable Grid Lines"),
 752                                                         P_("Whether grid lines should be drawn in the tree view"),
 753                                                         GTK_TYPE_TREE_VIEW_GRID_LINES,
 754                                                         GTK_TREE_VIEW_GRID_LINES_NONE,
 755                                                         GTK_PARAM_READWRITE));
 756
 757     g_object_class_install_property (o_class,
 758                                      PROP_ENABLE_TREE_LINES,
 759                                      g_param_spec_boolean ("enable-tree-lines",
 760                                                            P_("Enable Tree Lines"),
 761                                                            P_("Whether tree lines should be drawn in the tree view"),
 762                                                            FALSE,
 763                                                            GTK_PARAM_READWRITE));
 764
 765     g_object_class_install_property (o_class,
 766                                      PROP_TOOLTIP_COLUMN,
 767                                      g_param_spec_int ("tooltip-column",
 768                                                        P_("Tooltip Column"),
 769                                                        P_("The column in the model containing the tooltip texts for the rows"),
 770                                                        -1,
 771                                                        G_MAXINT,
 772                                                        -1,
 773                                                        GTK_PARAM_READWRITE));
 774
 775   /* Style properties */
 776 #define _TREE_VIEW_EXPANDER_SIZE 12
 777 #define _TREE_VIEW_VERTICAL_SEPARATOR 2
 778 #define _TREE_VIEW_HORIZONTAL_SEPARATOR 2
 779
 780   gtk_widget_class_install_style_property (widget_class,
 781                                            g_param_spec_int ("expander-size",
 782                                                              P_("Expander Size"),
 783                                                              P_("Size of the expander arrow"),
 784                                                              0,
 785                                                              G_MAXINT,
 786                                                              _TREE_VIEW_EXPANDER_SIZE,
 787                                                              GTK_PARAM_READABLE));
 788
 789   gtk_widget_class_install_style_property (widget_class,
 790                                            g_param_spec_int ("vertical-separator",
 791                                                              P_("Vertical Separator Width"),
 792                                                              P_("Vertical space between cells.  Must be an even number"),
 793                                                              0,
 794                                                              G_MAXINT,
 795                                                              _TREE_VIEW_VERTICAL_SEPARATOR,
 796                                                              GTK_PARAM_READABLE));
 797
 798   gtk_widget_class_install_style_property (widget_class,
 799                                            g_param_spec_int ("horizontal-separator",
 800                                                              P_("Horizontal Separator Width"),
 801                                                              P_("Horizontal space between cells.  Must be an even number"),
 802                                                              0,
 803                                                              G_MAXINT,
 804                                                              _TREE_VIEW_HORIZONTAL_SEPARATOR,
 805                                                              GTK_PARAM_READABLE));
 806
 807   gtk_widget_class_install_style_property (widget_class,
 808                                            g_param_spec_boolean ("allow-rules",
 809                                                                  P_("Allow Rules"),
 810                                                                  P_("Allow drawing of alternating color rows"),
 811                                                                  TRUE,
 812                                                                  GTK_PARAM_READABLE));
 813
 814   gtk_widget_class_install_style_property (widget_class,
 815                                            g_param_spec_boolean ("indent-expanders",
 816                                                                  P_("Indent Expanders"),
 817                                                                  P_("Make the expanders indented"),
 818                                                                  TRUE,
 819                                                                  GTK_PARAM_READABLE));
 820
 821   gtk_widget_class_install_style_property (widget_class,
 822                                            g_param_spec_boxed ("even-row-color",
 823                                                                P_("Even Row Color"),
 824                                                                P_("Color to use for even rows"),
 825                                                                GDK_TYPE_COLOR,
 826                                                                GTK_PARAM_READABLE));
 827
 828   gtk_widget_class_install_style_property (widget_class,
 829                                            g_param_spec_boxed ("odd-row-color",
 830                                                                P_("Odd Row Color"),
 831                                                                P_("Color to use for odd rows"),
 832                                                                GDK_TYPE_COLOR,
 833                                                                GTK_PARAM_READABLE));
 834
 835   gtk_widget_class_install_style_property (widget_class,
 836                                            g_param_spec_int ("grid-line-width",
 837                                                              P_("Grid line width"),
 838                                                              P_("Width, in pixels, of the tree view grid lines"),
 839                                                              0, G_MAXINT, 1,
 840                                                              GTK_PARAM_READABLE));
 841
 842   gtk_widget_class_install_style_property (widget_class,
 843                                            g_param_spec_int ("tree-line-width",
 844                                                              P_("Tree line width"),
 845                                                              P_("Width, in pixels, of the tree view lines"),
 846                                                              0, G_MAXINT, 1,
 847                                                              GTK_PARAM_READABLE));
 848
 849   gtk_widget_class_install_style_property (widget_class,
 850                                            g_param_spec_string ("grid-line-pattern",
 851                                                                 P_("Grid line pattern"),
 852                                                                 P_("Dash pattern used to draw the tree view grid lines"),
 853                                                                 "\1\1",
 854                                                                 GTK_PARAM_READABLE));
 855
 856   gtk_widget_class_install_style_property (widget_class,
 857                                            g_param_spec_string ("tree-line-pattern",
 858                                                                 P_("Tree line pattern"),
 859                                                                 P_("Dash pattern used to draw the tree view lines"),
 860                                                                 "\1\1",
 861                                                                 GTK_PARAM_READABLE));
 862
 863   /* Signals */
 864   /**
 865    * GtkTreeView::set-scroll-adjustments
 866    * @horizontal: the horizontal #GtkAdjustment
 867    * @vertical: the vertical #GtkAdjustment
 868    *
 869    * Set the scroll adjustments for the tree view. Usually scrolled containers
 870    * like #GtkScrolledWindow will emit this signal to connect two instances
 871    * of #GtkScrollbar to the scroll directions of the #GtkTreeView.
 872    */
 873   widget_class->set_scroll_adjustments_signal =
 874     g_signal_new (I_("set-scroll-adjustments"),
 875                   G_TYPE_FROM_CLASS (o_class),
 876                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
 877                   G_STRUCT_OFFSET (GtkTreeViewClass, set_scroll_adjustments),
 878                   NULL, NULL,
 879                   _gtk_marshal_VOID__OBJECT_OBJECT,
 880                   G_TYPE_NONE, 2,
 881                   GTK_TYPE_ADJUSTMENT,
 882                   GTK_TYPE_ADJUSTMENT);
 883
 884   /**
 885    * GtkTreeView::row-activated:
 886    * @tree_view: the object on which the signal is emitted
 887    * @path: the #GtkTreePath for the activated row
 888    * @column: the #GtkTreeViewColumn in which the activation occurred
 889    *
 890    * The "row-activated" signal is emitted when the method
 891    * gtk_tree_view_row_activated() is called or the user double clicks
 892    * a treeview row. It is also emitted when a non-editable row is
 893    * selected and one of the keys: Space, Shift+Space, Return or
 894    * Enter is pressed.
 895    *
 896    * For selection handling refer to the <link linkend="TreeWidget">tree
 897    * widget conceptual overview</link> as well as #GtkTreeSelection.
 898    */
 899   tree_view_signals[ROW_ACTIVATED] =
 900     g_signal_new (I_("row-activated"),
 901                   G_TYPE_FROM_CLASS (o_class),
 902                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
 903                   G_STRUCT_OFFSET (GtkTreeViewClass, row_activated),
 904                   NULL, NULL,
 905                   _gtk_marshal_VOID__BOXED_OBJECT,
 906                   G_TYPE_NONE, 2,
 907                   GTK_TYPE_TREE_PATH,
 908                   GTK_TYPE_TREE_VIEW_COLUMN);
 909
 910   /**
 911    * GtkTreeView::test-expand-row:
 912    * @tree_view: the object on which the signal is emitted
 913    * @iter: the tree iter of the row to expand
 914    * @path: a tree path that points to the row
 915    *
 916    * The given row is about to be expanded (show its children nodes). Use this
 917    * signal if you need to control the expandability of individual rows.
 918    *
 919    * Returns: %FALSE to allow expansion, %TRUE to reject
 920    */
 921   tree_view_signals[TEST_EXPAND_ROW] =
 922     g_signal_new (I_("test-expand-row"),
 923                   G_TYPE_FROM_CLASS (o_class),
 924                   G_SIGNAL_RUN_LAST,
 925                   G_STRUCT_OFFSET (GtkTreeViewClass, test_expand_row),
 926                   _gtk_boolean_handled_accumulator, NULL,
 927                   _gtk_marshal_BOOLEAN__BOXED_BOXED,
 928                   G_TYPE_BOOLEAN, 2,
 929                   GTK_TYPE_TREE_ITER,
 930                   GTK_TYPE_TREE_PATH);
 931
 932   /**
 933    * GtkTreeView::test-collapse-row:
 934    * @tree_view: the object on which the signal is emitted
 935    * @iter: the tree iter of the row to collapse
 936    * @path: a tree path that points to the row
 937    *
 938    * The given row is about to be collapsed (hide its children nodes). Use this
 939    * signal if you need to control the collapsibility of individual rows.
 940    *
 941    * Returns: %FALSE to allow collapsing, %TRUE to reject
 942    */
 943   tree_view_signals[TEST_COLLAPSE_ROW] =
 944     g_signal_new (I_("test-collapse-row"),
 945                   G_TYPE_FROM_CLASS (o_class),
 946                   G_SIGNAL_RUN_LAST,
 947                   G_STRUCT_OFFSET (GtkTreeViewClass, test_collapse_row),
 948                   _gtk_boolean_handled_accumulator, NULL,
 949                   _gtk_marshal_BOOLEAN__BOXED_BOXED,
 950                   G_TYPE_BOOLEAN, 2,
 951                   GTK_TYPE_TREE_ITER,
 952                   GTK_TYPE_TREE_PATH);
 953
 954   /**
 955    * GtkTreeView::row-expanded:
 956    * @tree_view: the object on which the signal is emitted
 957    * @iter: the tree iter of the expanded row
 958    * @path: a tree path that points to the row
 959    *
 960    * The given row has been expanded (child nodes are shown).
 961    */
 962   tree_view_signals[ROW_EXPANDED] =
 963     g_signal_new (I_("row-expanded"),
 964                   G_TYPE_FROM_CLASS (o_class),
 965                   G_SIGNAL_RUN_LAST,
 966                   G_STRUCT_OFFSET (GtkTreeViewClass, row_expanded),
 967                   NULL, NULL,
 968                   _gtk_marshal_VOID__BOXED_BOXED,
 969                   G_TYPE_NONE, 2,
 970                   GTK_TYPE_TREE_ITER,
 971                   GTK_TYPE_TREE_PATH);
 972
 973   /**
 974    * GtkTreeView::row-collapsed:
 975    * @tree_view: the object on which the signal is emitted
 976    * @iter: the tree iter of the collapsed row
 977    * @path: a tree path that points to the row
 978    *
 979    * The given row has been collapsed (child nodes are hidden).
 980    */
 981   tree_view_signals[ROW_COLLAPSED] =
 982     g_signal_new (I_("row-collapsed"),
 983                   G_TYPE_FROM_CLASS (o_class),
 984                   G_SIGNAL_RUN_LAST,
 985                   G_STRUCT_OFFSET (GtkTreeViewClass, row_collapsed),
 986                   NULL, NULL,
 987                   _gtk_marshal_VOID__BOXED_BOXED,
 988                   G_TYPE_NONE, 2,
 989                   GTK_TYPE_TREE_ITER,
 990                   GTK_TYPE_TREE_PATH);
 991
 992   /**
 993    * GtkTreeView::columns-changed:
 994    * @tree_view: the object on which the signal is emitted
 995    *
 996    * The number of columns of the treeview has changed.
 997    */
 998   tree_view_signals[COLUMNS_CHANGED] =
 999     g_signal_new (I_("columns-changed"),
1000                   G_TYPE_FROM_CLASS (o_class),
1001                   G_SIGNAL_RUN_LAST,
1002                   G_STRUCT_OFFSET (GtkTreeViewClass, columns_changed),
1003                   NULL, NULL,
1004                   _gtk_marshal_VOID__VOID,
1005                   G_TYPE_NONE, 0);
1006
1007   /**
1008    * GtkTreeView::cursor-changed:
1009    * @tree_view: the object on which the signal is emitted
1010    *
1011    * The position of the cursor (focused cell) has changed.
1012    */
1013   tree_view_signals[CURSOR_CHANGED] =
1014     g_signal_new (I_("cursor-changed"),
1015                   G_TYPE_FROM_CLASS (o_class),
1016                   G_SIGNAL_RUN_LAST,
1017                   G_STRUCT_OFFSET (GtkTreeViewClass, cursor_changed),
1018                   NULL, NULL,
1019                   _gtk_marshal_VOID__VOID,
1020                   G_TYPE_NONE, 0);
1021
1022   tree_view_signals[MOVE_CURSOR] =
1023     g_signal_new (I_("move-cursor"),
1024                   G_TYPE_FROM_CLASS (object_class),
1025                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
1026                   G_STRUCT_OFFSET (GtkTreeViewClass, move_cursor),
1027                   NULL, NULL,
1028                   _gtk_marshal_BOOLEAN__ENUM_INT,
1029                   G_TYPE_BOOLEAN, 2,
1030                   GTK_TYPE_MOVEMENT_STEP,
1031                   G_TYPE_INT);
1032
1033   tree_view_signals[SELECT_ALL] =
1034     g_signal_new (I_("select-all"),
1035                   G_TYPE_FROM_CLASS (object_class),
1036                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
1037                   G_STRUCT_OFFSET (GtkTreeViewClass, select_all),
1038                   NULL, NULL,
1039                   _gtk_marshal_BOOLEAN__VOID,
1040                   G_TYPE_BOOLEAN, 0);
1041
1042   tree_view_signals[UNSELECT_ALL] =
1043     g_signal_new (I_("unselect-all"),
1044                   G_TYPE_FROM_CLASS (object_class),
1045                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
1046                   G_STRUCT_OFFSET (GtkTreeViewClass, unselect_all),
1047                   NULL, NULL,
1048                   _gtk_marshal_BOOLEAN__VOID,
1049                   G_TYPE_BOOLEAN, 0);
1050
1051   tree_view_signals[SELECT_CURSOR_ROW] =
1052     g_signal_new (I_("select-cursor-row"),
1053                   G_TYPE_FROM_CLASS (object_class),
1054                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
1055                   G_STRUCT_OFFSET (GtkTreeViewClass, select_cursor_row),
1056                   NULL, NULL,
1057                   _gtk_marshal_BOOLEAN__BOOLEAN,
1058                   G_TYPE_BOOLEAN, 1,
1059                   G_TYPE_BOOLEAN);
1060
1061   tree_view_signals[TOGGLE_CURSOR_ROW] =
1062     g_signal_new (I_("toggle-cursor-row"),
1063                   G_TYPE_FROM_CLASS (object_class),
1064                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
1065                   G_STRUCT_OFFSET (GtkTreeViewClass, toggle_cursor_row),
1066                   NULL, NULL,
1067                   _gtk_marshal_BOOLEAN__VOID,
1068                   G_TYPE_BOOLEAN, 0);
1069
1070   tree_view_signals[EXPAND_COLLAPSE_CURSOR_ROW] =
1071     g_signal_new (I_("expand-collapse-cursor-row"),
1072                   G_TYPE_FROM_CLASS (object_class),
1073                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
1074                   G_STRUCT_OFFSET (GtkTreeViewClass, expand_collapse_cursor_row),
1075                   NULL, NULL,
1076                   _gtk_marshal_BOOLEAN__BOOLEAN_BOOLEAN_BOOLEAN,
1077                   G_TYPE_BOOLEAN, 3,
1078                   G_TYPE_BOOLEAN,
1079                   G_TYPE_BOOLEAN,
1080                   G_TYPE_BOOLEAN);
1081
1082   tree_view_signals[SELECT_CURSOR_PARENT] =
1083     g_signal_new (I_("select-cursor-parent"),
1084                   G_TYPE_FROM_CLASS (object_class),
1085                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
1086                   G_STRUCT_OFFSET (GtkTreeViewClass, select_cursor_parent),
1087                   NULL, NULL,
1088                   _gtk_marshal_BOOLEAN__VOID,
1089                   G_TYPE_BOOLEAN, 0);
1090
1091   tree_view_signals[START_INTERACTIVE_SEARCH] =
1092     g_signal_new (I_("start-interactive-search"),
1093                   G_TYPE_FROM_CLASS (object_class),
1094                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
1095                   G_STRUCT_OFFSET (GtkTreeViewClass, start_interactive_search),
1096                   NULL, NULL,
1097                   _gtk_marshal_BOOLEAN__VOID,
1098                   G_TYPE_BOOLEAN, 0);
1099
1100   /* Key bindings */
1101   gtk_tree_view_add_move_binding (binding_set, GDK_KEY_Up, 0, TRUE,
1102                                   GTK_MOVEMENT_DISPLAY_LINES, -1);
1103   gtk_tree_view_add_move_binding (binding_set, GDK_KEY_KP_Up, 0, TRUE,
1104                                   GTK_MOVEMENT_DISPLAY_LINES, -1);
1105
1106   gtk_tree_view_add_move_binding (binding_set, GDK_KEY_Down, 0, TRUE,
1107                                   GTK_MOVEMENT_DISPLAY_LINES, 1);
1108   gtk_tree_view_add_move_binding (binding_set, GDK_KEY_KP_Down, 0, TRUE,
1109                                   GTK_MOVEMENT_DISPLAY_LINES, 1);
1110
1111   gtk_tree_view_add_move_binding (binding_set, GDK_KEY_p, GDK_CONTROL_MASK, FALSE,
1112                                   GTK_MOVEMENT_DISPLAY_LINES, -1);
1113
1114   gtk_tree_view_add_move_binding (binding_set, GDK_KEY_n, GDK_CONTROL_MASK, FALSE,
1115                                   GTK_MOVEMENT_DISPLAY_LINES, 1);
1116
1117   gtk_tree_view_add_move_binding (binding_set, GDK_KEY_Home, 0, TRUE,
1118                                   GTK_MOVEMENT_BUFFER_ENDS, -1);
1119   gtk_tree_view_add_move_binding (binding_set, GDK_KEY_KP_Home, 0, TRUE,
1120                                   GTK_MOVEMENT_BUFFER_ENDS, -1);
1121
1122   gtk_tree_view_add_move_binding (binding_set, GDK_KEY_End, 0, TRUE,
1123                                   GTK_MOVEMENT_BUFFER_ENDS, 1);
1124   gtk_tree_view_add_move_binding (binding_set, GDK_KEY_KP_End, 0, TRUE,
1125                                   GTK_MOVEMENT_BUFFER_ENDS, 1);
1126
1127   gtk_tree_view_add_move_binding (binding_set, GDK_KEY_Page_Up, 0, TRUE,
1128                                   GTK_MOVEMENT_PAGES, -1);
1129   gtk_tree_view_add_move_binding (binding_set, GDK_KEY_KP_Page_Up, 0, TRUE,
1130                                   GTK_MOVEMENT_PAGES, -1);
1131
1132   gtk_tree_view_add_move_binding (binding_set, GDK_KEY_Page_Down, 0, TRUE,
1133                                   GTK_MOVEMENT_PAGES, 1);
1134   gtk_tree_view_add_move_binding (binding_set, GDK_KEY_KP_Page_Down, 0, TRUE,
1135                                   GTK_MOVEMENT_PAGES, 1);
1136
1137
1138   gtk_binding_entry_add_signal (binding_set, GDK_KEY_Right, 0, "move-cursor", 2,
1139                                 G_TYPE_ENUM, GTK_MOVEMENT_VISUAL_POSITIONS,
1140                                 G_TYPE_INT, 1);
1141
1142   gtk_binding_entry_add_signal (binding_set, GDK_KEY_Left, 0, "move-cursor", 2,
1143                                 G_TYPE_ENUM, GTK_MOVEMENT_VISUAL_POSITIONS,
1144                                 G_TYPE_INT, -1);
1145
1146   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Right, 0, "move-cursor", 2,
1147                                 G_TYPE_ENUM, GTK_MOVEMENT_VISUAL_POSITIONS,
1148                                 G_TYPE_INT, 1);
1149
1150   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Left, 0, "move-cursor", 2,
1151                                 G_TYPE_ENUM, GTK_MOVEMENT_VISUAL_POSITIONS,
1152                                 G_TYPE_INT, -1);
1153
1154   gtk_binding_entry_add_signal (binding_set, GDK_KEY_Right, GDK_CONTROL_MASK,
1155                                 "move-cursor", 2,
1156                                 G_TYPE_ENUM, GTK_MOVEMENT_VISUAL_POSITIONS,
1157                                 G_TYPE_INT, 1);
1158
1159   gtk_binding_entry_add_signal (binding_set, GDK_KEY_Left, GDK_CONTROL_MASK,
1160                                 "move-cursor", 2,
1161                                 G_TYPE_ENUM, GTK_MOVEMENT_VISUAL_POSITIONS,
1162                                 G_TYPE_INT, -1);
1163
1164   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Right, GDK_CONTROL_MASK,
1165                                 "move-cursor", 2,
1166                                 G_TYPE_ENUM, GTK_MOVEMENT_VISUAL_POSITIONS,
1167                                 G_TYPE_INT, 1);
1168
1169   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Left, GDK_CONTROL_MASK,
1170                                 "move-cursor", 2,
1171                                 G_TYPE_ENUM, GTK_MOVEMENT_VISUAL_POSITIONS,
1172                                 G_TYPE_INT, -1);
1173
1174   gtk_binding_entry_add_signal (binding_set, GDK_KEY_space, GDK_CONTROL_MASK, "toggle-cursor-row", 0);
1175   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Space, GDK_CONTROL_MASK, "toggle-cursor-row", 0);
1176
1177   gtk_binding_entry_add_signal (binding_set, GDK_KEY_a, GDK_CONTROL_MASK, "select-all", 0);
1178   gtk_binding_entry_add_signal (binding_set, GDK_KEY_slash, GDK_CONTROL_MASK, "select-all", 0);
1179
1180   gtk_binding_entry_add_signal (binding_set, GDK_KEY_A, GDK_CONTROL_MASK | GDK_SHIFT_MASK, "unselect-all", 0);
1181   gtk_binding_entry_add_signal (binding_set, GDK_KEY_backslash, GDK_CONTROL_MASK, "unselect-all", 0);
1182
1183   gtk_binding_entry_add_signal (binding_set, GDK_KEY_space, GDK_SHIFT_MASK, "select-cursor-row", 1,
1184                                 G_TYPE_BOOLEAN, TRUE);
1185   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Space, GDK_SHIFT_MASK, "select-cursor-row", 1,
1186                                 G_TYPE_BOOLEAN, TRUE);
1187
1188   gtk_binding_entry_add_signal (binding_set, GDK_KEY_space, 0, "select-cursor-row", 1,
1189                                 G_TYPE_BOOLEAN, TRUE);
1190   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Space, 0, "select-cursor-row", 1,
1191                                 G_TYPE_BOOLEAN, TRUE);
1192   gtk_binding_entry_add_signal (binding_set, GDK_KEY_Return, 0, "select-cursor-row", 1,
1193                                 G_TYPE_BOOLEAN, TRUE);
1194   gtk_binding_entry_add_signal (binding_set, GDK_KEY_ISO_Enter, 0, "select-cursor-row", 1,
1195                                 G_TYPE_BOOLEAN, TRUE);
1196   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Enter, 0, "select-cursor-row", 1,
1197                                 G_TYPE_BOOLEAN, TRUE);
1198
1199   /* expand and collapse rows */
1200   gtk_binding_entry_add_signal (binding_set, GDK_KEY_plus, 0, "expand-collapse-cursor-row", 3,
1201                                 G_TYPE_BOOLEAN, TRUE,
1202                                 G_TYPE_BOOLEAN, TRUE,
1203                                 G_TYPE_BOOLEAN, FALSE);
1204
1205   gtk_binding_entry_add_signal (binding_set, GDK_KEY_asterisk, 0,
1206                                 "expand-collapse-cursor-row", 3,
1207                                 G_TYPE_BOOLEAN, TRUE,
1208                                 G_TYPE_BOOLEAN, TRUE,
1209                                 G_TYPE_BOOLEAN, TRUE);
1210   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Multiply, 0,
1211                                 "expand-collapse-cursor-row", 3,
1212                                 G_TYPE_BOOLEAN, TRUE,
1213                                 G_TYPE_BOOLEAN, TRUE,
1214                                 G_TYPE_BOOLEAN, TRUE);
1215
1216   gtk_binding_entry_add_signal (binding_set, GDK_KEY_slash, 0,
1217                                 "expand-collapse-cursor-row", 3,
1218                                 G_TYPE_BOOLEAN, TRUE,
1219                                 G_TYPE_BOOLEAN, FALSE,
1220                                 G_TYPE_BOOLEAN, FALSE);
1221   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Divide, 0,
1222                                 "expand-collapse-cursor-row", 3,
1223                                 G_TYPE_BOOLEAN, TRUE,
1224                                 G_TYPE_BOOLEAN, FALSE,
1225                                 G_TYPE_BOOLEAN, FALSE);
1226
1227   /* Not doable on US keyboards */
1228   gtk_binding_entry_add_signal (binding_set, GDK_KEY_plus, GDK_SHIFT_MASK, "expand-collapse-cursor-row", 3,
1229                                 G_TYPE_BOOLEAN, TRUE,
1230                                 G_TYPE_BOOLEAN, TRUE,
1231                                 G_TYPE_BOOLEAN, TRUE);
1232   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Add, 0, "expand-collapse-cursor-row", 3,
1233                                 G_TYPE_BOOLEAN, TRUE,
1234                                 G_TYPE_BOOLEAN, TRUE,
1235                                 G_TYPE_BOOLEAN, FALSE);
1236   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Add, GDK_SHIFT_MASK, "expand-collapse-cursor-row", 3,
1237                                 G_TYPE_BOOLEAN, TRUE,
1238                                 G_TYPE_BOOLEAN, TRUE,
1239                                 G_TYPE_BOOLEAN, TRUE);
1240   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Add, GDK_SHIFT_MASK, "expand-collapse-cursor-row", 3,
1241                                 G_TYPE_BOOLEAN, TRUE,
1242                                 G_TYPE_BOOLEAN, TRUE,
1243                                 G_TYPE_BOOLEAN, TRUE);
1244   gtk_binding_entry_add_signal (binding_set, GDK_KEY_Right, GDK_SHIFT_MASK,
1245                                 "expand-collapse-cursor-row", 3,
1246                                 G_TYPE_BOOLEAN, FALSE,
1247                                 G_TYPE_BOOLEAN, TRUE,
1248                                 G_TYPE_BOOLEAN, TRUE);
1249   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Right, GDK_SHIFT_MASK,
1250                                 "expand-collapse-cursor-row", 3,
1251                                 G_TYPE_BOOLEAN, FALSE,
1252                                 G_TYPE_BOOLEAN, TRUE,
1253                                 G_TYPE_BOOLEAN, TRUE);
1254   gtk_binding_entry_add_signal (binding_set, GDK_KEY_Right,
1255                                 GDK_CONTROL_MASK | GDK_SHIFT_MASK,
1256                                 "expand-collapse-cursor-row", 3,
1257                                 G_TYPE_BOOLEAN, FALSE,
1258                                 G_TYPE_BOOLEAN, TRUE,
1259                                 G_TYPE_BOOLEAN, TRUE);
1260   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Right,
1261                                 GDK_CONTROL_MASK | GDK_SHIFT_MASK,
1262                                 "expand-collapse-cursor-row", 3,
1263                                 G_TYPE_BOOLEAN, FALSE,
1264                                 G_TYPE_BOOLEAN, TRUE,
1265                                 G_TYPE_BOOLEAN, TRUE);
1266
1267   gtk_binding_entry_add_signal (binding_set, GDK_KEY_minus, 0, "expand-collapse-cursor-row", 3,
1268                                 G_TYPE_BOOLEAN, TRUE,
1269                                 G_TYPE_BOOLEAN, FALSE,
1270                                 G_TYPE_BOOLEAN, FALSE);
1271   gtk_binding_entry_add_signal (binding_set, GDK_KEY_minus, GDK_SHIFT_MASK, "expand-collapse-cursor-row", 3,
1272                                 G_TYPE_BOOLEAN, TRUE,
1273                                 G_TYPE_BOOLEAN, FALSE,
1274                                 G_TYPE_BOOLEAN, TRUE);
1275   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Subtract, 0, "expand-collapse-cursor-row", 3,
1276                                 G_TYPE_BOOLEAN, TRUE,
1277                                 G_TYPE_BOOLEAN, FALSE,
1278                                 G_TYPE_BOOLEAN, FALSE);
1279   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Subtract, GDK_SHIFT_MASK, "expand-collapse-cursor-row", 3,
1280                                 G_TYPE_BOOLEAN, TRUE,
1281                                 G_TYPE_BOOLEAN, FALSE,
1282                                 G_TYPE_BOOLEAN, TRUE);
1283   gtk_binding_entry_add_signal (binding_set, GDK_KEY_Left, GDK_SHIFT_MASK,
1284                                 "expand-collapse-cursor-row", 3,
1285                                 G_TYPE_BOOLEAN, FALSE,
1286                                 G_TYPE_BOOLEAN, FALSE,
1287                                 G_TYPE_BOOLEAN, TRUE);
1288   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Left, GDK_SHIFT_MASK,
1289                                 "expand-collapse-cursor-row", 3,
1290                                 G_TYPE_BOOLEAN, FALSE,
1291                                 G_TYPE_BOOLEAN, FALSE,
1292                                 G_TYPE_BOOLEAN, TRUE);
1293   gtk_binding_entry_add_signal (binding_set, GDK_KEY_Left,
1294                                 GDK_CONTROL_MASK | GDK_SHIFT_MASK,
1295                                 "expand-collapse-cursor-row", 3,
1296                                 G_TYPE_BOOLEAN, FALSE,
1297                                 G_TYPE_BOOLEAN, FALSE,
1298                                 G_TYPE_BOOLEAN, TRUE);
1299   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Left,
1300                                 GDK_CONTROL_MASK | GDK_SHIFT_MASK,
1301                                 "expand-collapse-cursor-row", 3,
1302                                 G_TYPE_BOOLEAN, FALSE,
1303                                 G_TYPE_BOOLEAN, FALSE,
1304                                 G_TYPE_BOOLEAN, TRUE);
1305
1306   gtk_binding_entry_add_signal (binding_set, GDK_KEY_BackSpace, 0, "select-cursor-parent", 0);
1307   gtk_binding_entry_add_signal (binding_set, GDK_KEY_BackSpace, GDK_CONTROL_MASK, "select-cursor-parent", 0);
1308
1309   gtk_binding_entry_add_signal (binding_set, GDK_KEY_f, GDK_CONTROL_MASK, "start-interactive-search", 0);
1310
1311   gtk_binding_entry_add_signal (binding_set, GDK_KEY_F, GDK_CONTROL_MASK, "start-interactive-search", 0);
1312
1313   g_type_class_add_private (o_class, sizeof (GtkTreeViewPrivate));
1314 }
1315
1316 static void
1317 gtk_tree_view_init (GtkTreeView *tree_view)
1318 {
1319   tree_view->priv = G_TYPE_INSTANCE_GET_PRIVATE (tree_view, GTK_TYPE_TREE_VIEW, GtkTreeViewPrivate);
1320
1321   gtk_widget_set_can_focus (GTK_WIDGET (tree_view), TRUE);
1322   gtk_widget_set_redraw_on_allocate (GTK_WIDGET (tree_view), FALSE);
1323
1324   tree_view->priv->flags =  GTK_TREE_VIEW_SHOW_EXPANDERS
1325                             | GTK_TREE_VIEW_DRAW_KEYFOCUS
1326                             | GTK_TREE_VIEW_HEADERS_VISIBLE;
1327
1328   /* We need some padding */
1329   tree_view->priv->dy = 0;
1330   tree_view->priv->cursor_offset = 0;
1331   tree_view->priv->n_columns = 0;
1332   tree_view->priv->header_height = 1;
1333   tree_view->priv->x_drag = 0;
1334   tree_view->priv->drag_pos = -1;
1335   tree_view->priv->header_has_focus = FALSE;
1336   tree_view->priv->pressed_button = -1;
1337   tree_view->priv->press_start_x = -1;
1338   tree_view->priv->press_start_y = -1;
1339   tree_view->priv->reorderable = FALSE;
1340   tree_view->priv->presize_handler_timer = 0;
1341   tree_view->priv->scroll_sync_timer = 0;
1342   tree_view->priv->fixed_height = -1;
1343   tree_view->priv->fixed_height_mode = FALSE;
1344   tree_view->priv->fixed_height_check = 0;
1345   gtk_tree_view_set_adjustments (tree_view, NULL, NULL);
1346   tree_view->priv->selection = _gtk_tree_selection_new_with_tree_view (tree_view);
1347   tree_view->priv->enable_search = TRUE;
1348   tree_view->priv->search_column = -1;
1349   tree_view->priv->search_position_func = gtk_tree_view_search_position_func;
1350   tree_view->priv->search_equal_func = gtk_tree_view_search_equal_func;
1351   tree_view->priv->search_custom_entry_set = FALSE;
1352   tree_view->priv->typeselect_flush_timeout = 0;
1353   tree_view->priv->init_hadjust_value = TRUE;
1354   tree_view->priv->width = 0;
1355
1356   tree_view->priv->hover_selection = FALSE;
1357   tree_view->priv->hover_expand = FALSE;
1358
1359   tree_view->priv->level_indentation = 0;
1360
1361   tree_view->priv->rubber_banding_enable = FALSE;
1362
1363   tree_view->priv->grid_lines = GTK_TREE_VIEW_GRID_LINES_NONE;
1364   tree_view->priv->tree_lines_enabled = FALSE;
1365
1366   tree_view->priv->tooltip_column = -1;
1367
1368   tree_view->priv->post_validation_flag = FALSE;
1369
1370   tree_view->priv->last_button_x = -1;
1371   tree_view->priv->last_button_y = -1;
1372
1373   tree_view->priv->event_last_x = -10000;
1374   tree_view->priv->event_last_y = -10000;
1375 }
1376
1377 \f
1378
1379 /* GObject Methods
1380  */
1381
1382 static void
1383 gtk_tree_view_set_property (GObject         *object,
1384                             guint            prop_id,
1385                             const GValue    *value,
1386                             GParamSpec      *pspec)
1387 {
1388   GtkTreeView *tree_view;
1389
1390   tree_view = GTK_TREE_VIEW (object);
1391
1392   switch (prop_id)
1393     {
1394     case PROP_MODEL:
1395       gtk_tree_view_set_model (tree_view, g_value_get_object (value));
1396       break;
1397     case PROP_HADJUSTMENT:
1398       gtk_tree_view_set_hadjustment (tree_view, g_value_get_object (value));
1399       break;
1400     case PROP_VADJUSTMENT:
1401       gtk_tree_view_set_vadjustment (tree_view, g_value_get_object (value));
1402       break;
1403     case PROP_HEADERS_VISIBLE:
1404       gtk_tree_view_set_headers_visible (tree_view, g_value_get_boolean (value));
1405       break;
1406     case PROP_HEADERS_CLICKABLE:
1407       gtk_tree_view_set_headers_clickable (tree_view, g_value_get_boolean (value));
1408       break;
1409     case PROP_EXPANDER_COLUMN:
1410       gtk_tree_view_set_expander_column (tree_view, g_value_get_object (value));
1411       break;
1412     case PROP_REORDERABLE:
1413       gtk_tree_view_set_reorderable (tree_view, g_value_get_boolean (value));
1414       break;
1415     case PROP_RULES_HINT:
1416       gtk_tree_view_set_rules_hint (tree_view, g_value_get_boolean (value));
1417       break;
1418     case PROP_ENABLE_SEARCH:
1419       gtk_tree_view_set_enable_search (tree_view, g_value_get_boolean (value));
1420       break;
1421     case PROP_SEARCH_COLUMN:
1422       gtk_tree_view_set_search_column (tree_view, g_value_get_int (value));
1423       break;
1424     case PROP_FIXED_HEIGHT_MODE:
1425       gtk_tree_view_set_fixed_height_mode (tree_view, g_value_get_boolean (value));
1426       break;
1427     case PROP_HOVER_SELECTION:
1428       tree_view->priv->hover_selection = g_value_get_boolean (value);
1429       break;
1430     case PROP_HOVER_EXPAND:
1431       tree_view->priv->hover_expand = g_value_get_boolean (value);
1432       break;
1433     case PROP_SHOW_EXPANDERS:
1434       gtk_tree_view_set_show_expanders (tree_view, g_value_get_boolean (value));
1435       break;
1436     case PROP_LEVEL_INDENTATION:
1437       tree_view->priv->level_indentation = g_value_get_int (value);
1438       break;
1439     case PROP_RUBBER_BANDING:
1440       tree_view->priv->rubber_banding_enable = g_value_get_boolean (value);
1441       break;
1442     case PROP_ENABLE_GRID_LINES:
1443       gtk_tree_view_set_grid_lines (tree_view, g_value_get_enum (value));
1444       break;
1445     case PROP_ENABLE_TREE_LINES:
1446       gtk_tree_view_set_enable_tree_lines (tree_view, g_value_get_boolean (value));
1447       break;
1448     case PROP_TOOLTIP_COLUMN:
1449       gtk_tree_view_set_tooltip_column (tree_view, g_value_get_int (value));
1450       break;
1451     default:
1452       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
1453       break;
1454     }
1455 }
1456
1457 static void
1458 gtk_tree_view_get_property (GObject    *object,
1459                             guint       prop_id,
1460                             GValue     *value,
1461                             GParamSpec *pspec)
1462 {
1463   GtkTreeView *tree_view;
1464
1465   tree_view = GTK_TREE_VIEW (object);
1466
1467   switch (prop_id)
1468     {
1469     case PROP_MODEL:
1470       g_value_set_object (value, tree_view->priv->model);
1471       break;
1472     case PROP_HADJUSTMENT:
1473       g_value_set_object (value, tree_view->priv->hadjustment);
1474       break;
1475     case PROP_VADJUSTMENT:
1476       g_value_set_object (value, tree_view->priv->vadjustment);
1477       break;
1478     case PROP_HEADERS_VISIBLE:
1479       g_value_set_boolean (value, gtk_tree_view_get_headers_visible (tree_view));
1480       break;
1481     case PROP_HEADERS_CLICKABLE:
1482       g_value_set_boolean (value, gtk_tree_view_get_headers_clickable (tree_view));
1483       break;
1484     case PROP_EXPANDER_COLUMN:
1485       g_value_set_object (value, tree_view->priv->expander_column);
1486       break;
1487     case PROP_REORDERABLE:
1488       g_value_set_boolean (value, tree_view->priv->reorderable);
1489       break;
1490     case PROP_RULES_HINT:
1491       g_value_set_boolean (value, tree_view->priv->has_rules);
1492       break;
1493     case PROP_ENABLE_SEARCH:
1494       g_value_set_boolean (value, tree_view->priv->enable_search);
1495       break;
1496     case PROP_SEARCH_COLUMN:
1497       g_value_set_int (value, tree_view->priv->search_column);
1498       break;
1499     case PROP_FIXED_HEIGHT_MODE:
1500       g_value_set_boolean (value, tree_view->priv->fixed_height_mode);
1501       break;
1502     case PROP_HOVER_SELECTION:
1503       g_value_set_boolean (value, tree_view->priv->hover_selection);
1504       break;
1505     case PROP_HOVER_EXPAND:
1506       g_value_set_boolean (value, tree_view->priv->hover_expand);
1507       break;
1508     case PROP_SHOW_EXPANDERS:
1509       g_value_set_boolean (value, GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_SHOW_EXPANDERS));
1510       break;
1511     case PROP_LEVEL_INDENTATION:
1512       g_value_set_int (value, tree_view->priv->level_indentation);
1513       break;
1514     case PROP_RUBBER_BANDING:
1515       g_value_set_boolean (value, tree_view->priv->rubber_banding_enable);
1516       break;
1517     case PROP_ENABLE_GRID_LINES:
1518       g_value_set_enum (value, tree_view->priv->grid_lines);
1519       break;
1520     case PROP_ENABLE_TREE_LINES:
1521       g_value_set_boolean (value, tree_view->priv->tree_lines_enabled);
1522       break;
1523     case PROP_TOOLTIP_COLUMN:
1524       g_value_set_int (value, tree_view->priv->tooltip_column);
1525       break;
1526     default:
1527       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
1528       break;
1529     }
1530 }
1531
1532 static void
1533 gtk_tree_view_finalize (GObject *object)
1534 {
1535   G_OBJECT_CLASS (gtk_tree_view_parent_class)->finalize (object);
1536 }
1537
1538
1539 static GtkBuildableIface *parent_buildable_iface;
1540
1541 static void
1542 gtk_tree_view_buildable_init (GtkBuildableIface *iface)
1543 {
1544   parent_buildable_iface = g_type_interface_peek_parent (iface);
1545   iface->add_child = gtk_tree_view_buildable_add_child;
1546   iface->get_internal_child = gtk_tree_view_buildable_get_internal_child;
1547 }
1548
1549 static void
1550 gtk_tree_view_buildable_add_child (GtkBuildable *tree_view,
1551                                    GtkBuilder  *builder,
1552                                    GObject     *child,
1553                                    const gchar *type)
1554 {
1555   gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), GTK_TREE_VIEW_COLUMN (child));
1556 }
1557
1558 static GObject *
1559 gtk_tree_view_buildable_get_internal_child (GtkBuildable      *buildable,
1560                                             GtkBuilder        *builder,
1561                                             const gchar       *childname)
1562 {
1563     if (strcmp (childname, "selection") == 0)
1564       return G_OBJECT (GTK_TREE_VIEW (buildable)->priv->selection);
1565
1566     return parent_buildable_iface->get_internal_child (buildable,
1567                                                        builder,
1568                                                        childname);
1569 }
1570
1571 /* GtkObject Methods
1572  */
1573
1574 static void
1575 gtk_tree_view_free_rbtree (GtkTreeView *tree_view)
1576 {
1577   _gtk_rbtree_free (tree_view->priv->tree);
1578
1579   tree_view->priv->tree = NULL;
1580   tree_view->priv->button_pressed_node = NULL;
1581   tree_view->priv->button_pressed_tree = NULL;
1582   tree_view->priv->prelight_tree = NULL;
1583   tree_view->priv->prelight_node = NULL;
1584   tree_view->priv->expanded_collapsed_node = NULL;
1585   tree_view->priv->expanded_collapsed_tree = NULL;
1586 }
1587
1588 static void
1589 gtk_tree_view_destroy (GtkObject *object)
1590 {
1591   GtkTreeView *tree_view = GTK_TREE_VIEW (object);
1592   GList *list;
1593
1594   gtk_tree_view_stop_editing (tree_view, TRUE);
1595
1596   if (tree_view->priv->columns != NULL)
1597     {
1598       list = tree_view->priv->columns;
1599       while (list)
1600         {
1601           GtkTreeViewColumn *column;
1602           column = GTK_TREE_VIEW_COLUMN (list->data);
1603           list = list->next;
1604           gtk_tree_view_remove_column (tree_view, column);
1605         }
1606       tree_view->priv->columns = NULL;
1607     }
1608
1609   if (tree_view->priv->tree != NULL)
1610     {
1611       gtk_tree_view_unref_and_check_selection_tree (tree_view, tree_view->priv->tree);
1612
1613       gtk_tree_view_free_rbtree (tree_view);
1614     }
1615
1616   if (tree_view->priv->selection != NULL)
1617     {
1618       _gtk_tree_selection_set_tree_view (tree_view->priv->selection, NULL);
1619       g_object_unref (tree_view->priv->selection);
1620       tree_view->priv->selection = NULL;
1621     }
1622
1623   if (tree_view->priv->scroll_to_path != NULL)
1624     {
1625       gtk_tree_row_reference_free (tree_view->priv->scroll_to_path);
1626       tree_view->priv->scroll_to_path = NULL;
1627     }
1628
1629   if (tree_view->priv->drag_dest_row != NULL)
1630     {
1631       gtk_tree_row_reference_free (tree_view->priv->drag_dest_row);
1632       tree_view->priv->drag_dest_row = NULL;
1633     }
1634
1635   if (tree_view->priv->top_row != NULL)
1636     {
1637       gtk_tree_row_reference_free (tree_view->priv->top_row);
1638       tree_view->priv->top_row = NULL;
1639     }
1640
1641   if (tree_view->priv->column_drop_func_data &&
1642       tree_view->priv->column_drop_func_data_destroy)
1643     {
1644       tree_view->priv->column_drop_func_data_destroy (tree_view->priv->column_drop_func_data);
1645       tree_view->priv->column_drop_func_data = NULL;
1646     }
1647
1648   if (tree_view->priv->destroy_count_destroy &&
1649       tree_view->priv->destroy_count_data)
1650     {
1651       tree_view->priv->destroy_count_destroy (tree_view->priv->destroy_count_data);
1652       tree_view->priv->destroy_count_data = NULL;
1653     }
1654
1655   gtk_tree_row_reference_free (tree_view->priv->cursor);
1656   tree_view->priv->cursor = NULL;
1657
1658   gtk_tree_row_reference_free (tree_view->priv->anchor);
1659   tree_view->priv->anchor = NULL;
1660
1661   /* destroy interactive search dialog */
1662   if (tree_view->priv->search_window)
1663     {
1664       gtk_widget_destroy (tree_view->priv->search_window);
1665       tree_view->priv->search_window = NULL;
1666       tree_view->priv->search_entry = NULL;
1667       if (tree_view->priv->typeselect_flush_timeout)
1668         {
1669           g_source_remove (tree_view->priv->typeselect_flush_timeout);
1670           tree_view->priv->typeselect_flush_timeout = 0;
1671         }
1672     }
1673
1674   if (tree_view->priv->search_destroy && tree_view->priv->search_user_data)
1675     {
1676       tree_view->priv->search_destroy (tree_view->priv->search_user_data);
1677       tree_view->priv->search_user_data = NULL;
1678     }
1679
1680   if (tree_view->priv->search_position_destroy && tree_view->priv->search_position_user_data)
1681     {
1682       tree_view->priv->search_position_destroy (tree_view->priv->search_position_user_data);
1683       tree_view->priv->search_position_user_data = NULL;
1684     }
1685
1686   if (tree_view->priv->row_separator_destroy && tree_view->priv->row_separator_data)
1687     {
1688       tree_view->priv->row_separator_destroy (tree_view->priv->row_separator_data);
1689       tree_view->priv->row_separator_data = NULL;
1690     }
1691
1692   gtk_tree_view_set_model (tree_view, NULL);
1693
1694   if (tree_view->priv->hadjustment)
1695     {
1696       g_object_unref (tree_view->priv->hadjustment);
1697       tree_view->priv->hadjustment = NULL;
1698     }
1699   if (tree_view->priv->vadjustment)
1700     {
1701       g_object_unref (tree_view->priv->vadjustment);
1702       tree_view->priv->vadjustment = NULL;
1703     }
1704
1705   GTK_OBJECT_CLASS (gtk_tree_view_parent_class)->destroy (object);
1706 }
1707
1708 \f
1709
1710 /* GtkWidget Methods
1711  */
1712
1713 /* GtkWidget::map helper */
1714 static void
1715 gtk_tree_view_map_buttons (GtkTreeView *tree_view)
1716 {
1717   GList *list;
1718
1719   g_return_if_fail (gtk_widget_get_mapped (GTK_WIDGET (tree_view)));
1720
1721   if (GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_HEADERS_VISIBLE))
1722     {
1723       GtkTreeViewColumn *column;
1724
1725       for (list = tree_view->priv->columns; list; list = list->next)
1726         {
1727           column = list->data;
1728           if (gtk_widget_get_visible (column->button) &&
1729               !gtk_widget_get_mapped (column->button))
1730             gtk_widget_map (column->button);
1731         }
1732       for (list = tree_view->priv->columns; list; list = list->next)
1733         {
1734           column = list->data;
1735           if (column->visible == FALSE)
1736             continue;
1737           if (column->resizable)
1738             {
1739               gdk_window_raise (column->window);
1740               gdk_window_show (column->window);
1741             }
1742           else
1743             gdk_window_hide (column->window);
1744         }
1745       gdk_window_show (tree_view->priv->header_window);
1746     }
1747 }
1748
1749 static void
1750 gtk_tree_view_map (GtkWidget *widget)
1751 {
1752   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
1753   GList *tmp_list;
1754
1755   gtk_widget_set_mapped (widget, TRUE);
1756
1757   tmp_list = tree_view->priv->children;
1758   while (tmp_list)
1759     {
1760       GtkTreeViewChild *child = tmp_list->data;
1761       tmp_list = tmp_list->next;
1762
1763       if (gtk_widget_get_visible (child->widget))
1764         {
1765           if (!gtk_widget_get_mapped (child->widget))
1766             gtk_widget_map (child->widget);
1767         }
1768     }
1769   gdk_window_show (tree_view->priv->bin_window);
1770
1771   gtk_tree_view_map_buttons (tree_view);
1772
1773   gdk_window_show (gtk_widget_get_window (widget));
1774 }
1775
1776 static void
1777 gtk_tree_view_realize (GtkWidget *widget)
1778 {
1779   GtkAllocation allocation;
1780   GtkStyle *style;
1781   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
1782   GdkWindow *window;
1783   GdkWindowAttr attributes;
1784   GList *tmp_list;
1785   gint attributes_mask;
1786
1787   gtk_widget_set_realized (widget, TRUE);
1788
1789   gtk_widget_get_allocation (widget, &allocation);
1790
1791   /* Make the main, clipping window */
1792   attributes.window_type = GDK_WINDOW_CHILD;
1793   attributes.x = allocation.x;
1794   attributes.y = allocation.y;
1795   attributes.width = allocation.width;
1796   attributes.height = allocation.height;
1797   attributes.wclass = GDK_INPUT_OUTPUT;
1798   attributes.visual = gtk_widget_get_visual (widget);
1799   attributes.event_mask = GDK_VISIBILITY_NOTIFY_MASK;
1800
1801   attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL;
1802
1803   window = gdk_window_new (gtk_widget_get_parent_window (widget),
1804                            &attributes, attributes_mask);
1805   gtk_widget_set_window (widget, window);
1806   gdk_window_set_user_data (window, widget);
1807
1808   gtk_widget_get_allocation (widget, &allocation);
1809
1810   /* Make the window for the tree */
1811   attributes.x = 0;
1812   attributes.y = TREE_VIEW_HEADER_HEIGHT (tree_view);
1813   attributes.width = MAX (tree_view->priv->width, allocation.width);
1814   attributes.height = allocation.height;
1815   attributes.event_mask = (GDK_EXPOSURE_MASK |
1816                            GDK_SCROLL_MASK |
1817                            GDK_POINTER_MOTION_MASK |
1818                            GDK_ENTER_NOTIFY_MASK |
1819                            GDK_LEAVE_NOTIFY_MASK |
1820                            GDK_BUTTON_PRESS_MASK |
1821                            GDK_BUTTON_RELEASE_MASK |
1822                            gtk_widget_get_events (widget));
1823
1824   tree_view->priv->bin_window = gdk_window_new (window,
1825                                                 &attributes, attributes_mask);
1826   gdk_window_set_user_data (tree_view->priv->bin_window, widget);
1827
1828   gtk_widget_get_allocation (widget, &allocation);
1829
1830   /* Make the column header window */
1831   attributes.x = 0;
1832   attributes.y = 0;
1833   attributes.width = MAX (tree_view->priv->width, allocation.width);
1834   attributes.height = tree_view->priv->header_height;
1835   attributes.event_mask = (GDK_EXPOSURE_MASK |
1836                            GDK_SCROLL_MASK |
1837                            GDK_ENTER_NOTIFY_MASK |
1838                            GDK_LEAVE_NOTIFY_MASK |
1839                            GDK_BUTTON_PRESS_MASK |
1840                            GDK_BUTTON_RELEASE_MASK |
1841                            GDK_KEY_PRESS_MASK |
1842                            GDK_KEY_RELEASE_MASK |
1843                            gtk_widget_get_events (widget));
1844
1845   tree_view->priv->header_window = gdk_window_new (window,
1846                                                    &attributes, attributes_mask);
1847   gdk_window_set_user_data (tree_view->priv->header_window, widget);
1848
1849   /* Add them all up. */
1850   gtk_widget_style_attach (widget);
1851   style = gtk_widget_get_style (widget);
1852   gdk_window_set_background (tree_view->priv->bin_window,
1853                              &style->base[gtk_widget_get_state (widget)]);
1854   gtk_style_set_background (style, tree_view->priv->header_window, GTK_STATE_NORMAL);
1855
1856   tmp_list = tree_view->priv->children;
1857   while (tmp_list)
1858     {
1859       GtkTreeViewChild *child = tmp_list->data;
1860       tmp_list = tmp_list->next;
1861
1862       gtk_widget_set_parent_window (child->widget, tree_view->priv->bin_window);
1863     }
1864
1865   for (tmp_list = tree_view->priv->columns; tmp_list; tmp_list = tmp_list->next)
1866     _gtk_tree_view_column_realize_button (GTK_TREE_VIEW_COLUMN (tmp_list->data));
1867
1868   /* Need to call those here, since they create GCs */
1869   gtk_tree_view_set_grid_lines (tree_view, tree_view->priv->grid_lines);
1870   gtk_tree_view_set_enable_tree_lines (tree_view, tree_view->priv->tree_lines_enabled);
1871
1872   install_presize_handler (tree_view);
1873 }
1874
1875 static void
1876 gtk_tree_view_unrealize (GtkWidget *widget)
1877 {
1878   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
1879   GtkTreeViewPrivate *priv = tree_view->priv;
1880   GList *list;
1881
1882   if (priv->scroll_timeout != 0)
1883     {
1884       g_source_remove (priv->scroll_timeout);
1885       priv->scroll_timeout = 0;
1886     }
1887
1888   if (priv->auto_expand_timeout != 0)
1889     {
1890       g_source_remove (priv->auto_expand_timeout);
1891       priv->auto_expand_timeout = 0;
1892     }
1893
1894   if (priv->open_dest_timeout != 0)
1895     {
1896       g_source_remove (priv->open_dest_timeout);
1897       priv->open_dest_timeout = 0;
1898     }
1899
1900   remove_expand_collapse_timeout (tree_view);
1901
1902   if (priv->presize_handler_timer != 0)
1903     {
1904       g_source_remove (priv->presize_handler_timer);
1905       priv->presize_handler_timer = 0;
1906     }
1907
1908   if (priv->validate_rows_timer != 0)
1909     {
1910       g_source_remove (priv->validate_rows_timer);
1911       priv->validate_rows_timer = 0;
1912     }
1913
1914   if (priv->scroll_sync_timer != 0)
1915     {
1916       g_source_remove (priv->scroll_sync_timer);
1917       priv->scroll_sync_timer = 0;
1918     }
1919
1920   if (priv->typeselect_flush_timeout)
1921     {
1922       g_source_remove (priv->typeselect_flush_timeout);
1923       priv->typeselect_flush_timeout = 0;
1924     }
1925
1926   for (list = priv->columns; list; list = list->next)
1927     _gtk_tree_view_column_unrealize_button (GTK_TREE_VIEW_COLUMN (list->data));
1928
1929   gdk_window_set_user_data (priv->bin_window, NULL);
1930   gdk_window_destroy (priv->bin_window);
1931   priv->bin_window = NULL;
1932
1933   gdk_window_set_user_data (priv->header_window, NULL);
1934   gdk_window_destroy (priv->header_window);
1935   priv->header_window = NULL;
1936
1937   if (priv->drag_window)
1938     {
1939       gdk_window_set_user_data (priv->drag_window, NULL);
1940       gdk_window_destroy (priv->drag_window);
1941       priv->drag_window = NULL;
1942     }
1943
1944   if (priv->drag_highlight_window)
1945     {
1946       gdk_window_set_user_data (priv->drag_highlight_window, NULL);
1947       gdk_window_destroy (priv->drag_highlight_window);
1948       priv->drag_highlight_window = NULL;
1949     }
1950
1951   GTK_WIDGET_CLASS (gtk_tree_view_parent_class)->unrealize (widget);
1952 }
1953
1954 /* GtkWidget::size_request helper */
1955 static void
1956 gtk_tree_view_size_request_columns (GtkTreeView *tree_view)
1957 {
1958   GList *list;
1959
1960   tree_view->priv->header_height = 0;
1961
1962   if (tree_view->priv->model)
1963     {
1964       for (list = tree_view->priv->columns; list; list = list->next)
1965         {
1966           GtkRequisition requisition;
1967           GtkTreeViewColumn *column = list->data;
1968
1969           if (column->button == NULL)
1970             continue;
1971
1972           column = list->data;
1973
1974           gtk_widget_get_preferred_size (column->button, &requisition, NULL);
1975           column->button_request = requisition.width;
1976           tree_view->priv->header_height = MAX (tree_view->priv->header_height, requisition.height);
1977         }
1978     }
1979 }
1980
1981
1982 /* Called only by ::size_request */
1983 static void
1984 gtk_tree_view_update_size (GtkTreeView *tree_view)
1985 {
1986   GList *list;
1987   GtkTreeViewColumn *column;
1988   gint i;
1989
1990   if (tree_view->priv->model == NULL)
1991     {
1992       tree_view->priv->width = 0;
1993       tree_view->priv->prev_width = 0;
1994       tree_view->priv->height = 0;
1995       return;
1996     }
1997
1998   tree_view->priv->prev_width = tree_view->priv->width;
1999   tree_view->priv->width = 0;
2000
2001   /* keep this in sync with size_allocate below */
2002   for (list = tree_view->priv->columns, i = 0; list; list = list->next, i++)
2003     {
2004       gint real_requested_width = 0;
2005       column = list->data;
2006       if (!column->visible)
2007         continue;
2008
2009       if (column->use_resized_width)
2010         {
2011           real_requested_width = column->resized_width;
2012         }
2013       else if (column->column_type == GTK_TREE_VIEW_COLUMN_FIXED)
2014         {
2015           real_requested_width = column->fixed_width;
2016         }
2017       else if (GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_HEADERS_VISIBLE))
2018         {
2019           real_requested_width = MAX (column->requested_width, column->button_request);
2020         }
2021       else
2022         {
2023           real_requested_width = column->requested_width;
2024         }
2025
2026       if (column->min_width != -1)
2027         real_requested_width = MAX (real_requested_width, column->min_width);
2028       if (column->max_width != -1)
2029         real_requested_width = MIN (real_requested_width, column->max_width);
2030
2031       tree_view->priv->width += real_requested_width;
2032     }
2033
2034   if (tree_view->priv->tree == NULL)
2035     tree_view->priv->height = 0;
2036   else
2037     tree_view->priv->height = tree_view->priv->tree->root->offset;
2038 }
2039
2040 static void
2041 gtk_tree_view_size_request (GtkWidget      *widget,
2042                             GtkRequisition *requisition)
2043 {
2044   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
2045   GList *tmp_list;
2046
2047   /* we validate some rows initially just to make sure we have some size.
2048    * In practice, with a lot of static lists, this should get a good width.
2049    */
2050   do_validate_rows (tree_view, FALSE);
2051   gtk_tree_view_size_request_columns (tree_view);
2052   gtk_tree_view_update_size (GTK_TREE_VIEW (widget));
2053
2054   requisition->width = tree_view->priv->width;
2055   requisition->height = tree_view->priv->height + TREE_VIEW_HEADER_HEIGHT (tree_view);
2056
2057   tmp_list = tree_view->priv->children;
2058
2059   while (tmp_list)
2060     {
2061       GtkTreeViewChild *child = tmp_list->data;
2062       GtkRequisition child_requisition;
2063
2064       tmp_list = tmp_list->next;
2065
2066       if (gtk_widget_get_visible (child->widget))
2067         gtk_widget_get_preferred_size (child->widget, &child_requisition, NULL);
2068     }
2069 }
2070
2071 static int
2072 gtk_tree_view_calculate_width_before_expander (GtkTreeView *tree_view)
2073 {
2074   int width = 0;
2075   GList *list;
2076   gboolean rtl;
2077
2078   rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
2079   for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns));
2080        list->data != tree_view->priv->expander_column;
2081        list = (rtl ? list->prev : list->next))
2082     {
2083       GtkTreeViewColumn *column = list->data;
2084
2085       width += column->width;
2086     }
2087
2088   return width;
2089 }
2090
2091 static void
2092 invalidate_column (GtkTreeView       *tree_view,
2093                    GtkTreeViewColumn *column)
2094 {
2095   gint column_offset = 0;
2096   GList *list;
2097   GtkWidget *widget = GTK_WIDGET (tree_view);
2098   gboolean rtl;
2099
2100   if (!gtk_widget_get_realized (widget))
2101     return;
2102
2103   rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
2104   for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns));
2105        list;
2106        list = (rtl ? list->prev : list->next))
2107     {
2108       GtkTreeViewColumn *tmpcolumn = list->data;
2109       if (tmpcolumn == column)
2110         {
2111           GtkAllocation allocation;
2112           GdkRectangle invalid_rect;
2113
2114           gtk_widget_get_allocation (widget, &allocation);
2115           invalid_rect.x = column_offset;
2116           invalid_rect.y = 0;
2117           invalid_rect.width = column->width;
2118           invalid_rect.height = allocation.height;
2119
2120           gdk_window_invalidate_rect (gtk_widget_get_window (widget), &invalid_rect, TRUE);
2121           break;
2122         }
2123
2124       column_offset += tmpcolumn->width;
2125     }
2126 }
2127
2128 static void
2129 invalidate_last_column (GtkTreeView *tree_view)
2130 {
2131   GList *last_column;
2132   gboolean rtl;
2133
2134   rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
2135
2136   for (last_column = (rtl ? g_list_first (tree_view->priv->columns) : g_list_last (tree_view->priv->columns));
2137        last_column;
2138        last_column = (rtl ? last_column->next : last_column->prev))
2139     {
2140       if (GTK_TREE_VIEW_COLUMN (last_column->data)->visible)
2141         {
2142           invalidate_column (tree_view, last_column->data);
2143           return;
2144         }
2145     }
2146 }
2147
2148 static gint
2149 gtk_tree_view_get_real_requested_width_from_column (GtkTreeView       *tree_view,
2150                                                     GtkTreeViewColumn *column)
2151 {
2152   gint real_requested_width;
2153
2154   if (column->use_resized_width)
2155     {
2156       real_requested_width = column->resized_width;
2157     }
2158   else if (column->column_type == GTK_TREE_VIEW_COLUMN_FIXED)
2159     {
2160       real_requested_width = column->fixed_width;
2161     }
2162   else if (GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_HEADERS_VISIBLE))
2163     {
2164       real_requested_width = MAX (column->requested_width, column->button_request);
2165     }
2166   else
2167     {
2168       real_requested_width = column->requested_width;
2169       if (real_requested_width < 0)
2170         real_requested_width = 0;
2171     }
2172
2173   if (column->min_width != -1)
2174     real_requested_width = MAX (real_requested_width, column->min_width);
2175   if (column->max_width != -1)
2176     real_requested_width = MIN (real_requested_width, column->max_width);
2177
2178   return real_requested_width;
2179 }
2180
2181 /* GtkWidget::size_allocate helper */
2182 static void
2183 gtk_tree_view_size_allocate_columns (GtkWidget *widget,
2184                                      gboolean  *width_changed)
2185 {
2186   GtkTreeView *tree_view;
2187   GList *list, *first_column, *last_column;
2188   GtkTreeViewColumn *column;
2189   GtkAllocation allocation;
2190   GtkAllocation widget_allocation;
2191   gint width = 0;
2192   gint extra, extra_per_column, extra_for_last;
2193   gint full_requested_width = 0;
2194   gint number_of_expand_columns = 0;
2195   gboolean column_changed = FALSE;
2196   gboolean rtl;
2197   gboolean update_expand;
2198
2199   tree_view = GTK_TREE_VIEW (widget);
2200
2201   for (last_column = g_list_last (tree_view->priv->columns);
2202        last_column && !(GTK_TREE_VIEW_COLUMN (last_column->data)->visible);
2203        last_column = last_column->prev)
2204     ;
2205   if (last_column == NULL)
2206     return;
2207
2208   for (first_column = g_list_first (tree_view->priv->columns);
2209        first_column && !(GTK_TREE_VIEW_COLUMN (first_column->data)->visible);
2210        first_column = first_column->next)
2211     ;
2212
2213   allocation.y = 0;
2214   allocation.height = tree_view->priv->header_height;
2215
2216   rtl = (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL);
2217
2218   /* find out how many extra space and expandable columns we have */
2219   for (list = tree_view->priv->columns; list != last_column->next; list = list->next)
2220     {
2221       column = (GtkTreeViewColumn *)list->data;
2222
2223       if (!column->visible)
2224         continue;
2225
2226       full_requested_width += gtk_tree_view_get_real_requested_width_from_column (tree_view, column);
2227
2228       if (column->expand)
2229         number_of_expand_columns++;
2230     }
2231
2232   /* Only update the expand value if the width of the widget has changed,
2233    * or the number of expand columns has changed, or if there are no expand
2234    * columns, or if we didn't have an size-allocation yet after the
2235    * last validated node.
2236    */
2237   update_expand = (width_changed && *width_changed == TRUE)
2238       || number_of_expand_columns != tree_view->priv->last_number_of_expand_columns
2239       || number_of_expand_columns == 0
2240       || tree_view->priv->post_validation_flag == TRUE;
2241
2242   tree_view->priv->post_validation_flag = FALSE;
2243
2244   gtk_widget_get_allocation (widget, &widget_allocation);
2245   if (!update_expand)
2246     {
2247       extra = tree_view->priv->last_extra_space;
2248       extra_for_last = MAX (widget_allocation.width - full_requested_width - extra, 0);
2249     }
2250   else
2251     {
2252       extra = MAX (widget_allocation.width - full_requested_width, 0);
2253       extra_for_last = 0;
2254
2255       tree_view->priv->last_extra_space = extra;
2256     }
2257
2258   if (number_of_expand_columns > 0)
2259     extra_per_column = extra/number_of_expand_columns;
2260   else
2261     extra_per_column = 0;
2262
2263   if (update_expand)
2264     {
2265       tree_view->priv->last_extra_space_per_column = extra_per_column;
2266       tree_view->priv->last_number_of_expand_columns = number_of_expand_columns;
2267     }
2268
2269   for (list = (rtl ? last_column : first_column);
2270        list != (rtl ? first_column->prev : last_column->next);
2271        list = (rtl ? list->prev : list->next))
2272     {
2273       gint real_requested_width = 0;
2274       gint old_width;
2275
2276       column = list->data;
2277       old_width = column->width;
2278
2279       if (!column->visible)
2280         continue;
2281
2282       /* We need to handle the dragged button specially.
2283        */
2284       if (column == tree_view->priv->drag_column)
2285         {
2286           GtkAllocation drag_allocation;
2287
2288           drag_allocation.x = 0;
2289           drag_allocation.y = 0;
2290           drag_allocation.width = gdk_window_get_width (tree_view->priv->drag_window);
2291           drag_allocation.height = gdk_window_get_height (tree_view->priv->drag_window);
2292           gtk_widget_size_allocate (tree_view->priv->drag_column->button,
2293                                     &drag_allocation);
2294           width += drag_allocation.width;
2295           continue;
2296         }
2297
2298       real_requested_width = gtk_tree_view_get_real_requested_width_from_column (tree_view, column);
2299
2300       allocation.x = width;
2301       column->width = real_requested_width;
2302
2303       if (column->expand)
2304         {
2305           if (number_of_expand_columns == 1)
2306             {
2307               /* We add the remander to the last column as
2308                * */
2309               column->width += extra;
2310             }
2311           else
2312             {
2313               column->width += extra_per_column;
2314               extra -= extra_per_column;
2315               number_of_expand_columns --;
2316             }
2317         }
2318       else if (number_of_expand_columns == 0 &&
2319                list == last_column)
2320         {
2321           column->width += extra;
2322         }
2323
2324       /* In addition to expand, the last column can get even more
2325        * extra space so all available space is filled up.
2326        */
2327       if (extra_for_last > 0 && list == last_column)
2328         column->width += extra_for_last;
2329
2330       g_object_notify (G_OBJECT (column), "width");
2331
2332       allocation.width = column->width;
2333       width += column->width;
2334
2335       if (column->width > old_width)
2336         column_changed = TRUE;
2337
2338       gtk_widget_size_allocate (column->button, &allocation);
2339
2340       if (column->window)
2341         gdk_window_move_resize (column->window,
2342                                 allocation.x + (rtl ? 0 : allocation.width) - TREE_VIEW_DRAG_WIDTH/2,
2343                                 allocation.y,
2344                                 TREE_VIEW_DRAG_WIDTH, allocation.height);
2345     }
2346
2347   /* We change the width here.  The user might have been resizing columns,
2348    * so the total width of the tree view changes.
2349    */
2350   tree_view->priv->width = width;
2351   if (width_changed)
2352     *width_changed = TRUE;
2353
2354   if (column_changed)
2355     gtk_widget_queue_draw (GTK_WIDGET (tree_view));
2356 }
2357
2358
2359 static void
2360 gtk_tree_view_size_allocate (GtkWidget     *widget,
2361                              GtkAllocation *allocation)
2362 {
2363   GtkAllocation widget_allocation;
2364   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
2365   GList *tmp_list;
2366   gboolean width_changed = FALSE;
2367   gint old_width;
2368
2369   gtk_widget_get_allocation (widget, &widget_allocation);
2370   old_width = widget_allocation.width;
2371   if (allocation->width != widget_allocation.width)
2372     width_changed = TRUE;
2373
2374   gtk_widget_set_allocation (widget, allocation);
2375
2376   tmp_list = tree_view->priv->children;
2377
2378   while (tmp_list)
2379     {
2380       GtkAllocation allocation;
2381
2382       GtkTreeViewChild *child = tmp_list->data;
2383       tmp_list = tmp_list->next;
2384
2385       /* totally ignore our child's requisition */
2386       allocation.x = child->x;
2387       allocation.y = child->y;
2388       allocation.width = child->width;
2389       allocation.height = child->height;
2390       gtk_widget_size_allocate (child->widget, &allocation);
2391     }
2392
2393   /* We size-allocate the columns first because the width of the
2394    * tree view (used in updating the adjustments below) might change.
2395    */
2396   gtk_tree_view_size_allocate_columns (widget, &width_changed);
2397
2398   tree_view->priv->hadjustment->page_size = allocation->width;
2399   tree_view->priv->hadjustment->page_increment = allocation->width * 0.9;
2400   tree_view->priv->hadjustment->step_increment = allocation->width * 0.1;
2401   tree_view->priv->hadjustment->lower = 0;
2402   tree_view->priv->hadjustment->upper = MAX (tree_view->priv->hadjustment->page_size, tree_view->priv->width);
2403
2404   if (gtk_widget_get_direction(widget) == GTK_TEXT_DIR_RTL)
2405     {
2406       if (allocation->width < tree_view->priv->width)
2407         {
2408           if (tree_view->priv->init_hadjust_value)
2409             {
2410               tree_view->priv->hadjustment->value = MAX (tree_view->priv->width - allocation->width, 0);
2411               tree_view->priv->init_hadjust_value = FALSE;
2412             }
2413           else if (allocation->width != old_width)
2414             {
2415               tree_view->priv->hadjustment->value = CLAMP (tree_view->priv->hadjustment->value - allocation->width + old_width, 0, tree_view->priv->width - allocation->width);
2416             }
2417           else
2418             tree_view->priv->hadjustment->value = CLAMP (tree_view->priv->width - (tree_view->priv->prev_width - tree_view->priv->hadjustment->value), 0, tree_view->priv->width - allocation->width);
2419         }
2420       else
2421         {
2422           tree_view->priv->hadjustment->value = 0;
2423           tree_view->priv->init_hadjust_value = TRUE;
2424         }
2425     }
2426   else
2427     if (tree_view->priv->hadjustment->value + allocation->width > tree_view->priv->width)
2428       tree_view->priv->hadjustment->value = MAX (tree_view->priv->width - allocation->width, 0);
2429
2430   gtk_adjustment_changed (tree_view->priv->hadjustment);
2431
2432   tree_view->priv->vadjustment->page_size = allocation->height - TREE_VIEW_HEADER_HEIGHT (tree_view);
2433   tree_view->priv->vadjustment->step_increment = tree_view->priv->vadjustment->page_size * 0.1;
2434   tree_view->priv->vadjustment->page_increment = tree_view->priv->vadjustment->page_size * 0.9;
2435   tree_view->priv->vadjustment->lower = 0;
2436   tree_view->priv->vadjustment->upper = MAX (tree_view->priv->vadjustment->page_size, tree_view->priv->height);
2437
2438   gtk_adjustment_changed (tree_view->priv->vadjustment);
2439
2440   /* now the adjustments and window sizes are in sync, we can sync toprow/dy again */
2441   if (tree_view->priv->height <= tree_view->priv->vadjustment->page_size)
2442     gtk_adjustment_set_value (GTK_ADJUSTMENT (tree_view->priv->vadjustment), 0);
2443   else if (tree_view->priv->vadjustment->value + tree_view->priv->vadjustment->page_size > tree_view->priv->height)
2444     gtk_adjustment_set_value (GTK_ADJUSTMENT (tree_view->priv->vadjustment),
2445                               tree_view->priv->height - tree_view->priv->vadjustment->page_size);
2446   else if (gtk_tree_row_reference_valid (tree_view->priv->top_row))
2447     gtk_tree_view_top_row_to_dy (tree_view);
2448   else
2449     gtk_tree_view_dy_to_top_row (tree_view);
2450
2451   if (gtk_widget_get_realized (widget))
2452     {
2453       gdk_window_move_resize (gtk_widget_get_window (widget),
2454                               allocation->x, allocation->y,
2455                               allocation->width, allocation->height);
2456       gdk_window_move_resize (tree_view->priv->header_window,
2457                               - (gint) tree_view->priv->hadjustment->value,
2458                               0,
2459                               MAX (tree_view->priv->width, allocation->width),
2460                               tree_view->priv->header_height);
2461       gdk_window_move_resize (tree_view->priv->bin_window,
2462                               - (gint) tree_view->priv->hadjustment->value,
2463                               TREE_VIEW_HEADER_HEIGHT (tree_view),
2464                               MAX (tree_view->priv->width, allocation->width),
2465                               allocation->height - TREE_VIEW_HEADER_HEIGHT (tree_view));
2466     }
2467
2468   if (tree_view->priv->tree == NULL)
2469     invalidate_empty_focus (tree_view);
2470
2471   if (gtk_widget_get_realized (widget))
2472     {
2473       gboolean has_expand_column = FALSE;
2474       for (tmp_list = tree_view->priv->columns; tmp_list; tmp_list = tmp_list->next)
2475         {
2476           if (gtk_tree_view_column_get_expand (GTK_TREE_VIEW_COLUMN (tmp_list->data)))
2477             {
2478               has_expand_column = TRUE;
2479               break;
2480             }
2481         }
2482
2483       if (width_changed && tree_view->priv->expander_column)
2484         {
2485           /* Might seem awkward, but is the best heuristic I could come up
2486            * with.  Only if the width of the columns before the expander
2487            * changes, we will update the prelight status.  It is this
2488            * width that makes the expander move vertically.  Always updating
2489            * prelight status causes trouble with hover selections.
2490            */
2491           gint width_before_expander;
2492
2493           width_before_expander = gtk_tree_view_calculate_width_before_expander (tree_view);
2494
2495           if (tree_view->priv->prev_width_before_expander
2496               != width_before_expander)
2497               update_prelight (tree_view,
2498                                tree_view->priv->event_last_x,
2499                                tree_view->priv->event_last_y);
2500
2501           tree_view->priv->prev_width_before_expander = width_before_expander;
2502         }
2503
2504       /* This little hack only works if we have an LTR locale, and no column has the  */
2505       if (width_changed)
2506         {
2507           if (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_LTR &&
2508               ! has_expand_column)
2509             invalidate_last_column (tree_view);
2510           else
2511             gtk_widget_queue_draw (widget);
2512         }
2513     }
2514 }
2515
2516 /* Grabs the focus and unsets the GTK_TREE_VIEW_DRAW_KEYFOCUS flag */
2517 static void
2518 grab_focus_and_unset_draw_keyfocus (GtkTreeView *tree_view)
2519 {
2520   GtkWidget *widget = GTK_WIDGET (tree_view);
2521
2522   if (gtk_widget_get_can_focus (widget) && !gtk_widget_has_focus (widget))
2523     gtk_widget_grab_focus (widget);
2524   GTK_TREE_VIEW_UNSET_FLAG (tree_view, GTK_TREE_VIEW_DRAW_KEYFOCUS);
2525 }
2526
2527 static inline gboolean
2528 row_is_separator (GtkTreeView *tree_view,
2529                   GtkTreeIter *iter,
2530                   GtkTreePath *path)
2531 {
2532   gboolean is_separator = FALSE;
2533
2534   if (tree_view->priv->row_separator_func)
2535     {
2536       GtkTreeIter tmpiter;
2537
2538       if (iter)
2539         tmpiter = *iter;
2540       else
2541         gtk_tree_model_get_iter (tree_view->priv->model, &tmpiter, path);
2542
2543       is_separator = tree_view->priv->row_separator_func (tree_view->priv->model,
2544                                                           &tmpiter,
2545                                                           tree_view->priv->row_separator_data);
2546     }
2547
2548   return is_separator;
2549 }
2550
2551 static gboolean
2552 gtk_tree_view_button_press (GtkWidget      *widget,
2553                             GdkEventButton *event)
2554 {
2555   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
2556   GList *list;
2557   GtkTreeViewColumn *column = NULL;
2558   gint i;
2559   GdkRectangle background_area;
2560   GdkRectangle cell_area;
2561   gint vertical_separator;
2562   gint horizontal_separator;
2563   gboolean path_is_selectable;
2564   gboolean rtl;
2565
2566   rtl = (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL);
2567   gtk_tree_view_stop_editing (tree_view, FALSE);
2568   gtk_widget_style_get (widget,
2569                         "vertical-separator", &vertical_separator,
2570                         "horizontal-separator", &horizontal_separator,
2571                         NULL);
2572
2573
2574   /* Because grab_focus can cause reentrancy, we delay grab_focus until after
2575    * we're done handling the button press.
2576    */
2577
2578   if (event->window == tree_view->priv->bin_window)
2579     {
2580       GtkRBNode *node;
2581       GtkRBTree *tree;
2582       GtkTreePath *path;
2583       gchar *path_string;
2584       gint depth;
2585       gint new_y;
2586       gint y_offset;
2587       gint dval;
2588       gint pre_val, aft_val;
2589       GtkTreeViewColumn *column = NULL;
2590       GtkCellRenderer *focus_cell = NULL;
2591       gint column_handled_click = FALSE;
2592       gboolean row_double_click = FALSE;
2593       gboolean rtl;
2594       gboolean node_selected;
2595
2596       /* Empty tree? */
2597       if (tree_view->priv->tree == NULL)
2598         {
2599           grab_focus_and_unset_draw_keyfocus (tree_view);
2600           return TRUE;
2601         }
2602
2603       /* are we in an arrow? */
2604       if (tree_view->priv->prelight_node &&
2605           GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_ARROW_PRELIT) &&
2606           TREE_VIEW_DRAW_EXPANDERS (tree_view))
2607         {
2608           if (event->button == 1)
2609             {
2610               gtk_grab_add (widget);
2611               tree_view->priv->button_pressed_node = tree_view->priv->prelight_node;
2612               tree_view->priv->button_pressed_tree = tree_view->priv->prelight_tree;
2613               gtk_tree_view_queue_draw_arrow (GTK_TREE_VIEW (widget),
2614                                               tree_view->priv->prelight_tree,
2615                                               tree_view->priv->prelight_node);
2616             }
2617
2618           grab_focus_and_unset_draw_keyfocus (tree_view);
2619           return TRUE;
2620         }
2621
2622       /* find the node that was clicked */
2623       new_y = TREE_WINDOW_Y_TO_RBTREE_Y(tree_view, event->y);
2624       if (new_y < 0)
2625         new_y = 0;
2626       y_offset = -_gtk_rbtree_find_offset (tree_view->priv->tree, new_y, &tree, &node);
2627
2628       if (node == NULL)
2629         {
2630           /* We clicked in dead space */
2631           grab_focus_and_unset_draw_keyfocus (tree_view);
2632           return TRUE;
2633         }
2634
2635       /* Get the path and the node */
2636       path = _gtk_tree_view_find_path (tree_view, tree, node);
2637       path_is_selectable = !row_is_separator (tree_view, NULL, path);
2638
2639       if (!path_is_selectable)
2640         {
2641           gtk_tree_path_free (path);
2642           grab_focus_and_unset_draw_keyfocus (tree_view);
2643           return TRUE;
2644         }
2645
2646       depth = gtk_tree_path_get_depth (path);
2647       background_area.y = y_offset + event->y;
2648       background_area.height = ROW_HEIGHT (tree_view, GTK_RBNODE_GET_HEIGHT (node));
2649       background_area.x = 0;
2650
2651
2652       /* Let the column have a chance at selecting it. */
2653       rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
2654       for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns));
2655            list; list = (rtl ? list->prev : list->next))
2656         {
2657           GtkTreeViewColumn *candidate = list->data;
2658
2659           if (!candidate->visible)
2660             continue;
2661
2662           background_area.width = candidate->width;
2663           if ((background_area.x > (gint) event->x) ||
2664               (background_area.x + background_area.width <= (gint) event->x))
2665             {
2666               background_area.x += background_area.width;
2667               continue;
2668             }
2669
2670           /* we found the focus column */
2671           column = candidate;
2672           cell_area = background_area;
2673           cell_area.width -= horizontal_separator;
2674           cell_area.height -= vertical_separator;
2675           cell_area.x += horizontal_separator/2;
2676           cell_area.y += vertical_separator/2;
2677           if (gtk_tree_view_is_expander_column (tree_view, column))
2678             {
2679               if (!rtl)
2680                 cell_area.x += (depth - 1) * tree_view->priv->level_indentation;
2681               cell_area.width -= (depth - 1) * tree_view->priv->level_indentation;
2682
2683               if (TREE_VIEW_DRAW_EXPANDERS (tree_view))
2684                 {
2685                   if (!rtl)
2686                     cell_area.x += depth * tree_view->priv->expander_size;
2687                   cell_area.width -= depth * tree_view->priv->expander_size;
2688                 }
2689             }
2690           break;
2691         }
2692
2693       if (column == NULL)
2694         {
2695           gtk_tree_path_free (path);
2696           grab_focus_and_unset_draw_keyfocus (tree_view);
2697           return FALSE;
2698         }
2699
2700       tree_view->priv->focus_column = column;
2701
2702       /* decide if we edit */
2703       if (event->type == GDK_BUTTON_PRESS && event->button == 1 &&
2704           !(event->state & gtk_accelerator_get_default_mod_mask ()))
2705         {
2706           GtkTreePath *anchor;
2707           GtkTreeIter iter;
2708
2709           gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
2710           gtk_tree_view_column_cell_set_cell_data (column,
2711                                                    tree_view->priv->model,
2712                                                    &iter,
2713                                                    GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT),
2714                                                    node->children?TRUE:FALSE);
2715
2716           if (tree_view->priv->anchor)
2717             anchor = gtk_tree_row_reference_get_path (tree_view->priv->anchor);
2718           else
2719             anchor = NULL;
2720
2721           if ((anchor && !gtk_tree_path_compare (anchor, path))
2722               || !_gtk_tree_view_column_has_editable_cell (column))
2723             {
2724               GtkCellEditable *cell_editable = NULL;
2725
2726               /* FIXME: get the right flags */
2727               guint flags = 0;
2728
2729               path_string = gtk_tree_path_to_string (path);
2730
2731               if (_gtk_tree_view_column_cell_event (column,
2732                                                     &cell_editable,
2733                                                     (GdkEvent *)event,
2734                                                     path_string,
2735                                                     &background_area,
2736                                                     &cell_area, flags))
2737                 {
2738                   if (cell_editable != NULL)
2739                     {
2740                       gint left, right;
2741                       GdkRectangle area;
2742
2743                       area = cell_area;
2744                       _gtk_tree_view_column_get_neighbor_sizes (column, _gtk_tree_view_column_get_edited_cell (column), &left, &right);
2745
2746                       area.x += left;
2747                       area.width -= right + left;
2748
2749                       gtk_tree_view_real_start_editing (tree_view,
2750                                                         column,
2751                                                         path,
2752                                                         cell_editable,
2753                                                         &area,
2754                                                         (GdkEvent *)event,
2755                                                         flags);
2756                       g_free (path_string);
2757                       gtk_tree_path_free (path);
2758                       gtk_tree_path_free (anchor);
2759                       return TRUE;
2760                     }
2761                   column_handled_click = TRUE;
2762                 }
2763               g_free (path_string);
2764             }
2765           if (anchor)
2766             gtk_tree_path_free (anchor);
2767         }
2768
2769       /* select */
2770       node_selected = GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SELECTED);
2771       pre_val = tree_view->priv->vadjustment->value;
2772
2773       /* we only handle selection modifications on the first button press
2774        */
2775       if (event->type == GDK_BUTTON_PRESS)
2776         {
2777           if ((event->state & GDK_CONTROL_MASK) == GDK_CONTROL_MASK)
2778             tree_view->priv->ctrl_pressed = TRUE;
2779           if ((event->state & GDK_SHIFT_MASK) == GDK_SHIFT_MASK)
2780             tree_view->priv->shift_pressed = TRUE;
2781
2782           focus_cell = _gtk_tree_view_column_get_cell_at_pos (column, event->x - background_area.x);
2783           if (focus_cell)
2784             gtk_tree_view_column_focus_cell (column, focus_cell);
2785
2786           if (event->state & GDK_CONTROL_MASK)
2787             {
2788               gtk_tree_view_real_set_cursor (tree_view, path, FALSE, TRUE);
2789               gtk_tree_view_real_toggle_cursor_row (tree_view);
2790             }
2791           else if (event->state & GDK_SHIFT_MASK)
2792             {
2793               gtk_tree_view_real_set_cursor (tree_view, path, FALSE, TRUE);
2794               gtk_tree_view_real_select_cursor_row (tree_view, FALSE);
2795             }
2796           else
2797             {
2798               gtk_tree_view_real_set_cursor (tree_view, path, TRUE, TRUE);
2799             }
2800
2801           tree_view->priv->ctrl_pressed = FALSE;
2802           tree_view->priv->shift_pressed = FALSE;
2803         }
2804
2805       /* the treeview may have been scrolled because of _set_cursor,
2806        * correct here
2807        */
2808
2809       aft_val = tree_view->priv->vadjustment->value;
2810       dval = pre_val - aft_val;
2811
2812       cell_area.y += dval;
2813       background_area.y += dval;
2814
2815       /* Save press to possibly begin a drag
2816        */
2817       if (!column_handled_click &&
2818           !tree_view->priv->in_grab &&
2819           tree_view->priv->pressed_button < 0)
2820         {
2821           tree_view->priv->pressed_button = event->button;
2822           tree_view->priv->press_start_x = event->x;
2823           tree_view->priv->press_start_y = event->y;
2824
2825           if (tree_view->priv->rubber_banding_enable
2826               && !node_selected
2827               && tree_view->priv->selection->type == GTK_SELECTION_MULTIPLE)
2828             {
2829               tree_view->priv->press_start_y += tree_view->priv->dy;
2830               tree_view->priv->rubber_band_x = event->x;
2831               tree_view->priv->rubber_band_y = event->y + tree_view->priv->dy;
2832               tree_view->priv->rubber_band_status = RUBBER_BAND_MAYBE_START;
2833
2834               if ((event->state & GDK_CONTROL_MASK) == GDK_CONTROL_MASK)
2835                 tree_view->priv->rubber_band_ctrl = TRUE;
2836               if ((event->state & GDK_SHIFT_MASK) == GDK_SHIFT_MASK)
2837                 tree_view->priv->rubber_band_shift = TRUE;
2838             }
2839         }
2840
2841       /* Test if a double click happened on the same row. */
2842       if (event->button == 1 && event->type == GDK_BUTTON_PRESS)
2843         {
2844           int double_click_time, double_click_distance;
2845
2846           g_object_get (gtk_settings_get_default (),
2847                         "gtk-double-click-time", &double_click_time,
2848                         "gtk-double-click-distance", &double_click_distance,
2849                         NULL);
2850
2851           /* Same conditions as _gdk_event_button_generate */
2852           if (tree_view->priv->last_button_x != -1 &&
2853               (event->time < tree_view->priv->last_button_time + double_click_time) &&
2854               (ABS (event->x - tree_view->priv->last_button_x) <= double_click_distance) &&
2855               (ABS (event->y - tree_view->priv->last_button_y) <= double_click_distance))
2856             {
2857               /* We do no longer compare paths of this row and the
2858                * row clicked previously.  We use the double click
2859                * distance to decide whether this is a valid click,
2860                * allowing the mouse to slightly move over another row.
2861                */
2862               row_double_click = TRUE;
2863
2864               tree_view->priv->last_button_time = 0;
2865               tree_view->priv->last_button_x = -1;
2866               tree_view->priv->last_button_y = -1;
2867             }
2868           else
2869             {
2870               tree_view->priv->last_button_time = event->time;
2871               tree_view->priv->last_button_x = event->x;
2872               tree_view->priv->last_button_y = event->y;
2873             }
2874         }
2875
2876       if (row_double_click)
2877         {
2878           gtk_grab_remove (widget);
2879           gtk_tree_view_row_activated (tree_view, path, column);
2880
2881           if (tree_view->priv->pressed_button == event->button)
2882             tree_view->priv->pressed_button = -1;
2883         }
2884
2885       gtk_tree_path_free (path);
2886
2887       /* If we activated the row through a double click we don't want to grab
2888        * focus back, as moving focus to another widget is pretty common.
2889        */
2890       if (!row_double_click)
2891         grab_focus_and_unset_draw_keyfocus (tree_view);
2892
2893       return TRUE;
2894     }
2895
2896   /* We didn't click in the window.  Let's check to see if we clicked on a column resize window.
2897    */
2898   for (i = 0, list = tree_view->priv->columns; list; list = list->next, i++)
2899     {
2900       column = list->data;
2901       if (event->window == column->window &&
2902           column->resizable &&
2903           column->window)
2904         {
2905           GtkAllocation button_allocation;
2906           gpointer drag_data;
2907
2908           if (event->type == GDK_2BUTTON_PRESS &&
2909               gtk_tree_view_column_get_sizing (column) != GTK_TREE_VIEW_COLUMN_AUTOSIZE)
2910             {
2911               column->use_resized_width = FALSE;
2912               _gtk_tree_view_column_autosize (tree_view, column);
2913               return TRUE;
2914             }
2915
2916           if (gdk_pointer_grab (column->window, FALSE,
2917                                 GDK_POINTER_MOTION_HINT_MASK |
2918                                 GDK_BUTTON1_MOTION_MASK |
2919                                 GDK_BUTTON_RELEASE_MASK,
2920                                 NULL, NULL, event->time))
2921             return FALSE;
2922
2923           gtk_grab_add (widget);
2924           GTK_TREE_VIEW_SET_FLAG (tree_view, GTK_TREE_VIEW_IN_COLUMN_RESIZE);
2925           column->resized_width = column->width - tree_view->priv->last_extra_space_per_column;
2926
2927           /* block attached dnd signal handler */
2928           drag_data = g_object_get_data (G_OBJECT (widget), "gtk-site-data");
2929           if (drag_data)
2930             g_signal_handlers_block_matched (widget,
2931                                              G_SIGNAL_MATCH_DATA,
2932                                              0, 0, NULL, NULL,
2933                                              drag_data);
2934
2935           gtk_widget_get_allocation (column->button, &button_allocation);
2936           tree_view->priv->drag_pos = i;
2937           tree_view->priv->x_drag = button_allocation.x + (rtl ? 0 : button_allocation.width);
2938
2939           if (!gtk_widget_has_focus (widget))
2940             gtk_widget_grab_focus (widget);
2941
2942           return TRUE;
2943         }
2944     }
2945   return FALSE;
2946 }
2947
2948 /* GtkWidget::button_release_event helper */
2949 static gboolean
2950 gtk_tree_view_button_release_drag_column (GtkWidget      *widget,
2951                                           GdkEventButton *event)
2952 {
2953   GtkTreeView *tree_view;
2954   GList *l;
2955   gboolean rtl;
2956
2957   tree_view = GTK_TREE_VIEW (widget);
2958
2959   rtl = (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL);
2960   gdk_display_pointer_ungrab (gtk_widget_get_display (widget), GDK_CURRENT_TIME);
2961   gdk_display_keyboard_ungrab (gtk_widget_get_display (widget), GDK_CURRENT_TIME);
2962
2963   /* Move the button back */
2964   g_object_ref (tree_view->priv->drag_column->button);
2965   gtk_container_remove (GTK_CONTAINER (tree_view), tree_view->priv->drag_column->button);
2966   gtk_widget_set_parent_window (tree_view->priv->drag_column->button, tree_view->priv->header_window);
2967   gtk_widget_set_parent (tree_view->priv->drag_column->button, GTK_WIDGET (tree_view));
2968   g_object_unref (tree_view->priv->drag_column->button);
2969   gtk_widget_queue_resize (widget);
2970   if (tree_view->priv->drag_column->resizable)
2971     {
2972       gdk_window_raise (tree_view->priv->drag_column->window);
2973       gdk_window_show (tree_view->priv->drag_column->window);
2974     }
2975   else
2976     gdk_window_hide (tree_view->priv->drag_column->window);
2977
2978   gtk_widget_grab_focus (tree_view->priv->drag_column->button);
2979
2980   if (rtl)
2981     {
2982       if (tree_view->priv->cur_reorder &&
2983           tree_view->priv->cur_reorder->right_column != tree_view->priv->drag_column)
2984         gtk_tree_view_move_column_after (tree_view, tree_view->priv->drag_column,
2985                                          tree_view->priv->cur_reorder->right_column);
2986     }
2987   else
2988     {
2989       if (tree_view->priv->cur_reorder &&
2990           tree_view->priv->cur_reorder->left_column != tree_view->priv->drag_column)
2991         gtk_tree_view_move_column_after (tree_view, tree_view->priv->drag_column,
2992                                          tree_view->priv->cur_reorder->left_column);
2993     }
2994   tree_view->priv->drag_column = NULL;
2995   gdk_window_hide (tree_view->priv->drag_window);
2996
2997   for (l = tree_view->priv->column_drag_info; l != NULL; l = l->next)
2998     g_slice_free (GtkTreeViewColumnReorder, l->data);
2999   g_list_free (tree_view->priv->column_drag_info);
3000   tree_view->priv->column_drag_info = NULL;
3001   tree_view->priv->cur_reorder = NULL;
3002
3003   if (tree_view->priv->drag_highlight_window)
3004     gdk_window_hide (tree_view->priv->drag_highlight_window);
3005
3006   /* Reset our flags */
3007   tree_view->priv->drag_column_window_state = DRAG_COLUMN_WINDOW_STATE_UNSET;
3008   GTK_TREE_VIEW_UNSET_FLAG (tree_view, GTK_TREE_VIEW_IN_COLUMN_DRAG);
3009
3010   return TRUE;
3011 }
3012
3013 /* GtkWidget::button_release_event helper */
3014 static gboolean
3015 gtk_tree_view_button_release_column_resize (GtkWidget      *widget,
3016                                             GdkEventButton *event)
3017 {
3018   GtkTreeView *tree_view;
3019   gpointer drag_data;
3020
3021   tree_view = GTK_TREE_VIEW (widget);
3022
3023   tree_view->priv->drag_pos = -1;
3024
3025   /* unblock attached dnd signal handler */
3026   drag_data = g_object_get_data (G_OBJECT (widget), "gtk-site-data");
3027   if (drag_data)
3028     g_signal_handlers_unblock_matched (widget,
3029                                        G_SIGNAL_MATCH_DATA,
3030                                        0, 0, NULL, NULL,
3031                                        drag_data);
3032
3033   GTK_TREE_VIEW_UNSET_FLAG (tree_view, GTK_TREE_VIEW_IN_COLUMN_RESIZE);
3034   gtk_grab_remove (widget);
3035   gdk_display_pointer_ungrab (gdk_window_get_display (event->window),
3036                               event->time);
3037   return TRUE;
3038 }
3039
3040 static gboolean
3041 gtk_tree_view_button_release (GtkWidget      *widget,
3042                               GdkEventButton *event)
3043 {
3044   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
3045
3046   if (GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_IN_COLUMN_DRAG))
3047     return gtk_tree_view_button_release_drag_column (widget, event);
3048
3049   if (tree_view->priv->rubber_band_status)
3050     gtk_tree_view_stop_rubber_band (tree_view);
3051
3052   if (tree_view->priv->pressed_button == event->button)
3053     tree_view->priv->pressed_button = -1;
3054
3055   if (GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_IN_COLUMN_RESIZE))
3056     return gtk_tree_view_button_release_column_resize (widget, event);
3057
3058   if (tree_view->priv->button_pressed_node == NULL)
3059     return FALSE;
3060
3061   if (event->button == 1)
3062     {
3063       gtk_grab_remove (widget);
3064       if (tree_view->priv->button_pressed_node == tree_view->priv->prelight_node &&
3065           GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_ARROW_PRELIT))
3066         {
3067           GtkTreePath *path = NULL;
3068
3069           path = _gtk_tree_view_find_path (tree_view,
3070                                            tree_view->priv->button_pressed_tree,
3071                                            tree_view->priv->button_pressed_node);
3072           /* Actually activate the node */
3073           if (tree_view->priv->button_pressed_node->children == NULL)
3074             gtk_tree_view_real_expand_row (tree_view, path,
3075                                            tree_view->priv->button_pressed_tree,
3076                                            tree_view->priv->button_pressed_node,
3077                                            FALSE, TRUE);
3078           else
3079             gtk_tree_view_real_collapse_row (GTK_TREE_VIEW (widget), path,
3080                                              tree_view->priv->button_pressed_tree,
3081                                              tree_view->priv->button_pressed_node, TRUE);
3082           gtk_tree_path_free (path);
3083         }
3084
3085       tree_view->priv->button_pressed_tree = NULL;
3086       tree_view->priv->button_pressed_node = NULL;
3087     }
3088
3089   return TRUE;
3090 }
3091
3092 static gboolean
3093 gtk_tree_view_grab_broken (GtkWidget          *widget,
3094                            GdkEventGrabBroken *event)
3095 {
3096   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
3097
3098   if (GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_IN_COLUMN_DRAG))
3099     gtk_tree_view_button_release_drag_column (widget, (GdkEventButton *)event);
3100
3101   if (GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_IN_COLUMN_RESIZE))
3102     gtk_tree_view_button_release_column_resize (widget, (GdkEventButton *)event);
3103
3104   return TRUE;
3105 }
3106
3107 #if 0
3108 static gboolean
3109 gtk_tree_view_configure (GtkWidget *widget,
3110                          GdkEventConfigure *event)
3111 {
3112   GtkTreeView *tree_view;
3113
3114   tree_view = GTK_TREE_VIEW (widget);
3115   tree_view->priv->search_position_func (tree_view, tree_view->priv->search_window);
3116
3117   return FALSE;
3118 }
3119 #endif
3120
3121 /* GtkWidget::motion_event function set.
3122  */
3123
3124 static gboolean
3125 coords_are_over_arrow (GtkTreeView *tree_view,
3126                        GtkRBTree   *tree,
3127                        GtkRBNode   *node,
3128                        /* these are in bin window coords */
3129                        gint         x,
3130                        gint         y)
3131 {
3132   GdkRectangle arrow;
3133   gint x2;
3134
3135   if (!gtk_widget_get_realized (GTK_WIDGET (tree_view)))
3136     return FALSE;
3137
3138   if ((node->flags & GTK_RBNODE_IS_PARENT) == 0)
3139     return FALSE;
3140
3141   arrow.y = BACKGROUND_FIRST_PIXEL (tree_view, tree, node);
3142
3143   arrow.height = ROW_HEIGHT (tree_view, BACKGROUND_HEIGHT (node));
3144
3145   gtk_tree_view_get_arrow_xrange (tree_view, tree, &arrow.x, &x2);
3146
3147   arrow.width = x2 - arrow.x;
3148
3149   return (x >= arrow.x &&
3150           x < (arrow.x + arrow.width) &&
3151           y >= arrow.y &&
3152           y < (arrow.y + arrow.height));
3153 }
3154
3155 static gboolean
3156 auto_expand_timeout (gpointer data)
3157 {
3158   GtkTreeView *tree_view = GTK_TREE_VIEW (data);
3159   GtkTreePath *path;
3160
3161   if (tree_view->priv->prelight_node)
3162     {
3163       path = _gtk_tree_view_find_path (tree_view,
3164                                        tree_view->priv->prelight_tree,
3165                                        tree_view->priv->prelight_node);
3166
3167       if (tree_view->priv->prelight_node->children)
3168         gtk_tree_view_collapse_row (tree_view, path);
3169       else
3170         gtk_tree_view_expand_row (tree_view, path, FALSE);
3171
3172       gtk_tree_path_free (path);
3173     }
3174
3175   tree_view->priv->auto_expand_timeout = 0;
3176
3177   return FALSE;
3178 }
3179
3180 static void
3181 remove_auto_expand_timeout (GtkTreeView *tree_view)
3182 {
3183   if (tree_view->priv->auto_expand_timeout != 0)
3184     {
3185       g_source_remove (tree_view->priv->auto_expand_timeout);
3186       tree_view->priv->auto_expand_timeout = 0;
3187     }
3188 }
3189
3190 static void
3191 do_prelight (GtkTreeView *tree_view,
3192              GtkRBTree   *tree,
3193              GtkRBNode   *node,
3194              /* these are in bin_window coords */
3195              gint         x,
3196              gint         y)
3197 {
3198   if (tree_view->priv->prelight_tree == tree &&
3199       tree_view->priv->prelight_node == node)
3200     {
3201       /*  We are still on the same node,
3202           but we might need to take care of the arrow  */
3203
3204       if (tree && node && TREE_VIEW_DRAW_EXPANDERS (tree_view))
3205         {
3206           gboolean over_arrow;
3207           gboolean flag_set;
3208
3209           over_arrow = coords_are_over_arrow (tree_view, tree, node, x, y);
3210           flag_set = GTK_TREE_VIEW_FLAG_SET (tree_view,
3211                                              GTK_TREE_VIEW_ARROW_PRELIT);
3212
3213           if (over_arrow != flag_set)
3214             {
3215               if (over_arrow)
3216                 GTK_TREE_VIEW_SET_FLAG (tree_view,
3217                                         GTK_TREE_VIEW_ARROW_PRELIT);
3218               else
3219                 GTK_TREE_VIEW_UNSET_FLAG (tree_view,
3220                                           GTK_TREE_VIEW_ARROW_PRELIT);
3221
3222               gtk_tree_view_queue_draw_arrow (tree_view, tree, node);
3223             }
3224         }
3225
3226       return;
3227     }
3228
3229   if (tree_view->priv->prelight_tree && tree_view->priv->prelight_node)
3230     {
3231       /*  Unprelight the old node and arrow  */
3232
3233       GTK_RBNODE_UNSET_FLAG (tree_view->priv->prelight_node,
3234                              GTK_RBNODE_IS_PRELIT);
3235
3236       if (GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_ARROW_PRELIT)
3237           && TREE_VIEW_DRAW_EXPANDERS (tree_view))
3238         {
3239           GTK_TREE_VIEW_UNSET_FLAG (tree_view, GTK_TREE_VIEW_ARROW_PRELIT);
3240
3241           gtk_tree_view_queue_draw_arrow (tree_view,
3242                                           tree_view->priv->prelight_tree,
3243                                           tree_view->priv->prelight_node);
3244         }
3245
3246       _gtk_tree_view_queue_draw_node (tree_view,
3247                                       tree_view->priv->prelight_tree,
3248                                       tree_view->priv->prelight_node,
3249                                       NULL);
3250     }
3251
3252
3253   if (tree_view->priv->hover_expand)
3254     remove_auto_expand_timeout (tree_view);
3255
3256   /*  Set the new prelight values  */
3257   tree_view->priv->prelight_node = node;
3258   tree_view->priv->prelight_tree = tree;
3259
3260   if (!node || !tree)
3261     return;
3262
3263   /*  Prelight the new node and arrow  */
3264
3265   if (TREE_VIEW_DRAW_EXPANDERS (tree_view)
3266       && coords_are_over_arrow (tree_view, tree, node, x, y))
3267     {
3268       GTK_TREE_VIEW_SET_FLAG (tree_view, GTK_TREE_VIEW_ARROW_PRELIT);
3269
3270       gtk_tree_view_queue_draw_arrow (tree_view, tree, node);
3271     }
3272
3273   GTK_RBNODE_SET_FLAG (node, GTK_RBNODE_IS_PRELIT);
3274
3275   _gtk_tree_view_queue_draw_node (tree_view, tree, node, NULL);
3276
3277   if (tree_view->priv->hover_expand)
3278     {
3279       tree_view->priv->auto_expand_timeout =
3280         gdk_threads_add_timeout (AUTO_EXPAND_TIMEOUT, auto_expand_timeout, tree_view);
3281     }
3282 }
3283
3284 static void
3285 prelight_or_select (GtkTreeView *tree_view,
3286                     GtkRBTree   *tree,
3287                     GtkRBNode   *node,
3288                     /* these are in bin_window coords */
3289                     gint         x,
3290                     gint         y)
3291 {
3292   GtkSelectionMode mode = gtk_tree_selection_get_mode (tree_view->priv->selection);
3293
3294   if (tree_view->priv->hover_selection &&
3295       (mode == GTK_SELECTION_SINGLE || mode == GTK_SELECTION_BROWSE) &&
3296       !(tree_view->priv->edited_column &&
3297         tree_view->priv->edited_column->editable_widget))
3298     {
3299       if (node)
3300         {
3301           if (!GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SELECTED))
3302             {
3303               GtkTreePath *path;
3304
3305               path = _gtk_tree_view_find_path (tree_view, tree, node);
3306               gtk_tree_selection_select_path (tree_view->priv->selection, path);
3307               if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SELECTED))
3308                 {
3309                   GTK_TREE_VIEW_UNSET_FLAG (tree_view, GTK_TREE_VIEW_DRAW_KEYFOCUS);
3310                   gtk_tree_view_real_set_cursor (tree_view, path, FALSE, FALSE);
3311                 }
3312               gtk_tree_path_free (path);
3313             }
3314         }
3315
3316       else if (mode == GTK_SELECTION_SINGLE)
3317         gtk_tree_selection_unselect_all (tree_view->priv->selection);
3318     }
3319
3320     do_prelight (tree_view, tree, node, x, y);
3321 }
3322
3323 static void
3324 ensure_unprelighted (GtkTreeView *tree_view)
3325 {
3326   do_prelight (tree_view,
3327                NULL, NULL,
3328                -1000, -1000); /* coords not possibly over an arrow */
3329
3330   g_assert (tree_view->priv->prelight_node == NULL);
3331 }
3332
3333 static void
3334 update_prelight (GtkTreeView *tree_view,
3335                  gint         x,
3336                  gint         y)
3337 {
3338   int new_y;
3339   GtkRBTree *tree;
3340   GtkRBNode *node;
3341
3342   if (tree_view->priv->tree == NULL)
3343     return;
3344
3345   if (x == -10000)
3346     {
3347       ensure_unprelighted (tree_view);
3348       return;
3349     }
3350
3351   new_y = TREE_WINDOW_Y_TO_RBTREE_Y (tree_view, y);
3352   if (new_y < 0)
3353     new_y = 0;
3354
3355   _gtk_rbtree_find_offset (tree_view->priv->tree,
3356                            new_y, &tree, &node);
3357
3358   if (node)
3359     prelight_or_select (tree_view, tree, node, x, y);
3360 }
3361
3362
3363
3364
3365 /* Our motion arrow is either a box (in the case of the original spot)
3366  * or an arrow.  It is expander_size wide.
3367  */
3368 /*
3369  * 11111111111111
3370  * 01111111111110
3371  * 00111111111100
3372  * 00011111111000
3373  * 00001111110000
3374  * 00000111100000
3375  * 00000111100000
3376  * 00000111100000
3377  * ~ ~ ~ ~ ~ ~ ~
3378  * 00000111100000
3379  * 00000111100000
3380  * 00000111100000
3381  * 00001111110000
3382  * 00011111111000
3383  * 00111111111100
3384  * 01111111111110
3385  * 11111111111111
3386  */
3387
3388 static void
3389 gtk_tree_view_motion_draw_column_motion_arrow (GtkTreeView *tree_view)
3390 {
3391   GtkTreeViewColumnReorder *reorder = tree_view->priv->cur_reorder;
3392   GtkWidget *widget = GTK_WIDGET (tree_view);
3393   cairo_surface_t *mask_image;
3394   cairo_region_t *mask_region;
3395   gint x;
3396   gint y;
3397   gint width;
3398   gint height;
3399   gint arrow_type = DRAG_COLUMN_WINDOW_STATE_UNSET;
3400   GdkWindowAttr attributes;
3401   guint attributes_mask;
3402   cairo_t *cr;
3403
3404   if (!reorder ||
3405       reorder->left_column == tree_view->priv->drag_column ||
3406       reorder->right_column == tree_view->priv->drag_column)
3407     arrow_type = DRAG_COLUMN_WINDOW_STATE_ORIGINAL;
3408   else if (reorder->left_column || reorder->right_column)
3409     {
3410       GtkAllocation left_allocation, right_allocation;
3411       GdkRectangle visible_rect;
3412
3413       gtk_tree_view_get_visible_rect (tree_view, &visible_rect);
3414       if (reorder->left_column)
3415         {
3416           gtk_widget_get_allocation (reorder->left_column->button, &left_allocation);
3417           x = left_allocation.x + left_allocation.width;
3418         }
3419       else
3420         {
3421           gtk_widget_get_allocation (reorder->right_column->button, &right_allocation);
3422           x = right_allocation.x;
3423         }
3424
3425       if (x < visible_rect.x)
3426         arrow_type = DRAG_COLUMN_WINDOW_STATE_ARROW_LEFT;
3427       else if (x > visible_rect.x + visible_rect.width)
3428         arrow_type = DRAG_COLUMN_WINDOW_STATE_ARROW_RIGHT;
3429       else
3430         arrow_type = DRAG_COLUMN_WINDOW_STATE_ARROW;
3431     }
3432
3433   /* We want to draw the rectangle over the initial location. */
3434   if (arrow_type == DRAG_COLUMN_WINDOW_STATE_ORIGINAL)
3435     {
3436       if (tree_view->priv->drag_column_window_state != DRAG_COLUMN_WINDOW_STATE_ORIGINAL)
3437         {
3438           GtkAllocation drag_allocation;
3439
3440           if (tree_view->priv->drag_highlight_window)
3441             {
3442               gdk_window_set_user_data (tree_view->priv->drag_highlight_window,
3443                                         NULL);
3444               gdk_window_destroy (tree_view->priv->drag_highlight_window);
3445             }
3446
3447           attributes.window_type = GDK_WINDOW_CHILD;
3448           attributes.wclass = GDK_INPUT_OUTPUT;
3449           attributes.x = tree_view->priv->drag_column_x;
3450           attributes.y = 0;
3451           gtk_widget_get_allocation (tree_view->priv->drag_column->button, &drag_allocation);
3452           width = attributes.width = drag_allocation.width;
3453           height = attributes.height = drag_allocation.height;
3454           attributes.visual = gtk_widget_get_visual (GTK_WIDGET (tree_view));
3455           attributes.event_mask = GDK_VISIBILITY_NOTIFY_MASK | GDK_EXPOSURE_MASK | GDK_POINTER_MOTION_MASK;
3456           attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL;
3457           tree_view->priv->drag_highlight_window = gdk_window_new (tree_view->priv->header_window, &attributes, attributes_mask);
3458           gdk_window_set_user_data (tree_view->priv->drag_highlight_window, GTK_WIDGET (tree_view));
3459
3460           mask_image = cairo_image_surface_create (CAIRO_FORMAT_A1, width, height);
3461           cr = cairo_create (mask_image);
3462
3463           cairo_rectangle (cr, 1, 1, width - 2, height - 2);
3464           cairo_stroke (cr);
3465           cairo_destroy (cr);
3466
3467           mask_region = gdk_cairo_region_create_from_surface (mask_image);
3468           gdk_window_shape_combine_region (tree_view->priv->drag_highlight_window,
3469                                            mask_region, 0, 0);
3470
3471           cairo_region_destroy (mask_region);
3472           cairo_surface_destroy (mask_image);
3473
3474           tree_view->priv->drag_column_window_state = DRAG_COLUMN_WINDOW_STATE_ORIGINAL;
3475         }
3476     }
3477   else if (arrow_type == DRAG_COLUMN_WINDOW_STATE_ARROW)
3478     {
3479       GtkAllocation button_allocation;
3480
3481       width = tree_view->priv->expander_size;
3482
3483       /* Get x, y, width, height of arrow */
3484       gdk_window_get_origin (tree_view->priv->header_window, &x, &y);
3485       if (reorder->left_column)
3486         {
3487           gtk_widget_get_allocation (reorder->left_column->button, &button_allocation);
3488           x += button_allocation.x + button_allocation.width - width/2;
3489           height = button_allocation.height;
3490         }
3491       else
3492         {
3493           gtk_widget_get_allocation (reorder->right_column->button, &button_allocation);
3494           x += button_allocation.x - width/2;
3495           height = button_allocation.height;
3496         }
3497       y -= tree_view->priv->expander_size/2; /* The arrow takes up only half the space */
3498       height += tree_view->priv->expander_size;
3499
3500       /* Create the new window */
3501       if (tree_view->priv->drag_column_window_state != DRAG_COLUMN_WINDOW_STATE_ARROW)
3502         {
3503           if (tree_view->priv->drag_highlight_window)
3504             {
3505               gdk_window_set_user_data (tree_view->priv->drag_highlight_window,
3506                                         NULL);
3507               gdk_window_destroy (tree_view->priv->drag_highlight_window);
3508             }
3509
3510           attributes.window_type = GDK_WINDOW_TEMP;
3511           attributes.wclass = GDK_INPUT_OUTPUT;
3512           attributes.visual = gtk_widget_get_visual (GTK_WIDGET (tree_view));
3513           attributes.event_mask = GDK_VISIBILITY_NOTIFY_MASK | GDK_EXPOSURE_MASK | GDK_POINTER_MOTION_MASK;
3514           attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL;
3515           attributes.x = x;
3516           attributes.y = y;
3517           attributes.width = width;
3518           attributes.height = height;
3519           tree_view->priv->drag_highlight_window = gdk_window_new (gtk_widget_get_root_window (widget),
3520                                                                    &attributes, attributes_mask);
3521           gdk_window_set_user_data (tree_view->priv->drag_highlight_window, GTK_WIDGET (tree_view));
3522
3523           mask_image = cairo_image_surface_create (CAIRO_FORMAT_A1, width, height);
3524
3525           cr = cairo_create (mask_image);
3526           cairo_move_to (cr, 0, 0);
3527           cairo_line_to (cr, width, 0);
3528           cairo_line_to (cr, width / 2., width / 2);
3529           cairo_move_to (cr, 0, height);
3530           cairo_line_to (cr, width, height);
3531           cairo_line_to (cr, width / 2., height - width / 2.);
3532           cairo_fill (cr);
3533           cairo_destroy (cr);
3534
3535           mask_region = gdk_cairo_region_create_from_surface (mask_image);
3536           gdk_window_shape_combine_region (tree_view->priv->drag_highlight_window,
3537                                            mask_region, 0, 0);
3538
3539           cairo_region_destroy (mask_region);
3540           cairo_surface_destroy (mask_image);
3541         }
3542
3543       tree_view->priv->drag_column_window_state = DRAG_COLUMN_WINDOW_STATE_ARROW;
3544       gdk_window_move (tree_view->priv->drag_highlight_window, x, y);
3545     }
3546   else if (arrow_type == DRAG_COLUMN_WINDOW_STATE_ARROW_LEFT ||
3547            arrow_type == DRAG_COLUMN_WINDOW_STATE_ARROW_RIGHT)
3548     {
3549       GtkAllocation allocation;
3550
3551       width = tree_view->priv->expander_size;
3552
3553       /* Get x, y, width, height of arrow */
3554       width = width/2; /* remember, the arrow only takes half the available width */
3555       gdk_window_get_origin (gtk_widget_get_window (widget),
3556                              &x, &y);
3557       if (arrow_type == DRAG_COLUMN_WINDOW_STATE_ARROW_RIGHT)
3558         {
3559           gtk_widget_get_allocation (widget, &allocation);
3560           x += allocation.width - width;
3561         }
3562
3563       if (reorder->left_column)
3564         {
3565           gtk_widget_get_allocation (reorder->left_column->button, &allocation);
3566           height = allocation.height;
3567         }
3568       else
3569         {
3570           gtk_widget_get_allocation (reorder->right_column->button, &allocation);
3571           height = allocation.height;
3572         }
3573
3574       y -= tree_view->priv->expander_size;
3575       height += 2*tree_view->priv->expander_size;
3576
3577       /* Create the new window */
3578       if (tree_view->priv->drag_column_window_state != DRAG_COLUMN_WINDOW_STATE_ARROW_LEFT &&
3579           tree_view->priv->drag_column_window_state != DRAG_COLUMN_WINDOW_STATE_ARROW_RIGHT)
3580         {
3581           if (tree_view->priv->drag_highlight_window)
3582             {
3583               gdk_window_set_user_data (tree_view->priv->drag_highlight_window,
3584                                         NULL);
3585               gdk_window_destroy (tree_view->priv->drag_highlight_window);
3586             }
3587
3588           attributes.window_type = GDK_WINDOW_TEMP;
3589           attributes.wclass = GDK_INPUT_OUTPUT;
3590           attributes.visual = gtk_widget_get_visual (GTK_WIDGET (tree_view));
3591           attributes.event_mask = GDK_VISIBILITY_NOTIFY_MASK | GDK_EXPOSURE_MASK | GDK_POINTER_MOTION_MASK;
3592           attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL;
3593           attributes.x = x;
3594           attributes.y = y;
3595           attributes.width = width;
3596           attributes.height = height;
3597           tree_view->priv->drag_highlight_window = gdk_window_new (NULL, &attributes, attributes_mask);
3598           gdk_window_set_user_data (tree_view->priv->drag_highlight_window, GTK_WIDGET (tree_view));
3599
3600           mask_image = cairo_image_surface_create (CAIRO_FORMAT_A1, width, height);
3601
3602           cr = cairo_create (mask_image);
3603           /* mirror if we're on the left */
3604           if (arrow_type == DRAG_COLUMN_WINDOW_STATE_ARROW_LEFT)
3605             {
3606               cairo_translate (cr, width, 0);
3607               cairo_scale (cr, -1, 1);
3608             }
3609           cairo_move_to (cr, 0, 0);
3610           cairo_line_to (cr, width, width);
3611           cairo_line_to (cr, 0, tree_view->priv->expander_size);
3612           cairo_move_to (cr, 0, height);
3613           cairo_line_to (cr, width, height - width);
3614           cairo_line_to (cr, 0, height - tree_view->priv->expander_size);
3615           cairo_fill (cr);
3616           cairo_destroy (cr);
3617
3618           mask_region = gdk_cairo_region_create_from_surface (mask_image);
3619           gdk_window_shape_combine_region (tree_view->priv->drag_highlight_window,
3620                                            mask_region, 0, 0);
3621
3622           cairo_region_destroy (mask_region);
3623           cairo_surface_destroy (mask_image);
3624         }
3625
3626       tree_view->priv->drag_column_window_state = arrow_type;
3627       gdk_window_move (tree_view->priv->drag_highlight_window, x, y);
3628    }
3629   else
3630     {
3631       g_warning (G_STRLOC"Invalid GtkTreeViewColumnReorder struct");
3632       gdk_window_hide (tree_view->priv->drag_highlight_window);
3633       return;
3634     }
3635
3636   gdk_window_show (tree_view->priv->drag_highlight_window);
3637   gdk_window_raise (tree_view->priv->drag_highlight_window);
3638 }
3639
3640 static gboolean
3641 gtk_tree_view_motion_resize_column (GtkWidget      *widget,
3642                                     GdkEventMotion *event)
3643 {
3644   gint x;
3645   gint new_width;
3646   GtkTreeViewColumn *column;
3647   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
3648
3649   column = gtk_tree_view_get_column (tree_view, tree_view->priv->drag_pos);
3650
3651   if (event->is_hint || event->window != gtk_widget_get_window (widget))
3652     gtk_widget_get_pointer (widget, &x, NULL);
3653   else
3654     x = event->x;
3655
3656   if (tree_view->priv->hadjustment)
3657     x += tree_view->priv->hadjustment->value;
3658
3659   new_width = gtk_tree_view_new_column_width (tree_view,
3660                                               tree_view->priv->drag_pos, &x);
3661   if (x != tree_view->priv->x_drag &&
3662       (new_width != column->fixed_width))
3663     {
3664       column->use_resized_width = TRUE;
3665       column->resized_width = new_width;
3666       if (column->expand)
3667         column->resized_width -= tree_view->priv->last_extra_space_per_column;
3668       gtk_widget_queue_resize (widget);
3669     }
3670
3671   return FALSE;
3672 }
3673
3674
3675 static void
3676 gtk_tree_view_update_current_reorder (GtkTreeView *tree_view)
3677 {
3678   GtkTreeViewColumnReorder *reorder = NULL;
3679   GList *list;
3680   gint mouse_x;
3681
3682   gdk_window_get_pointer (tree_view->priv->header_window, &mouse_x, NULL, NULL);
3683   for (list = tree_view->priv->column_drag_info; list; list = list->next)
3684     {
3685       reorder = (GtkTreeViewColumnReorder *) list->data;
3686       if (mouse_x >= reorder->left_align && mouse_x < reorder->right_align)
3687         break;
3688       reorder = NULL;
3689     }
3690
3691   /*  if (reorder && reorder == tree_view->priv->cur_reorder)
3692       return;*/
3693
3694   tree_view->priv->cur_reorder = reorder;
3695   gtk_tree_view_motion_draw_column_motion_arrow (tree_view);
3696 }
3697
3698 static void
3699 gtk_tree_view_vertical_autoscroll (GtkTreeView *tree_view)
3700 {
3701   GdkRectangle visible_rect;
3702   gint y;
3703   gint offset;
3704
3705   gdk_window_get_pointer (tree_view->priv->bin_window, NULL, &y, NULL);
3706   y += tree_view->priv->dy;
3707
3708   gtk_tree_view_get_visible_rect (tree_view, &visible_rect);
3709
3710   /* see if we are near the edge. */
3711   offset = y - (visible_rect.y + 2 * SCROLL_EDGE_SIZE);
3712   if (offset > 0)
3713     {
3714       offset = y - (visible_rect.y + visible_rect.height - 2 * SCROLL_EDGE_SIZE);
3715       if (offset < 0)
3716         return;
3717     }
3718
3719   gtk_adjustment_set_value (tree_view->priv->vadjustment,
3720                             MAX (tree_view->priv->vadjustment->value + offset, 0.0));
3721 }
3722
3723 static gboolean
3724 gtk_tree_view_horizontal_autoscroll (GtkTreeView *tree_view)
3725 {
3726   GdkRectangle visible_rect;
3727   gint x;
3728   gint offset;
3729
3730   gdk_window_get_pointer (tree_view->priv->bin_window, &x, NULL, NULL);
3731
3732   gtk_tree_view_get_visible_rect (tree_view, &visible_rect);
3733
3734   /* See if we are near the edge. */
3735   offset = x - (visible_rect.x + SCROLL_EDGE_SIZE);
3736   if (offset > 0)
3737     {
3738       offset = x - (visible_rect.x + visible_rect.width - SCROLL_EDGE_SIZE);
3739       if (offset < 0)
3740         return TRUE;
3741     }
3742   offset = offset/3;
3743
3744   gtk_adjustment_set_value (tree_view->priv->hadjustment,
3745                             MAX (tree_view->priv->hadjustment->value + offset, 0.0));
3746
3747   return TRUE;
3748
3749 }
3750
3751 static gboolean
3752 gtk_tree_view_motion_drag_column (GtkWidget      *widget,
3753                                   GdkEventMotion *event)
3754 {
3755   GtkAllocation allocation, button_allocation;
3756   GtkTreeView *tree_view = (GtkTreeView *) widget;
3757   GtkTreeViewColumn *column = tree_view->priv->drag_column;
3758   gint x, y;
3759
3760   /* Sanity Check */
3761   if ((column == NULL) ||
3762       (event->window != tree_view->priv->drag_window))
3763     return FALSE;
3764
3765   /* Handle moving the header */
3766   gdk_window_get_position (tree_view->priv->drag_window, &x, &y);
3767   gtk_widget_get_allocation (widget, &allocation);
3768   gtk_widget_get_allocation (column->button, &button_allocation);
3769   x = CLAMP (x + (gint)event->x - column->drag_x, 0,
3770              MAX (tree_view->priv->width, allocation.width) - button_allocation.width);
3771   gdk_window_move (tree_view->priv->drag_window, x, y);
3772
3773   /* autoscroll, if needed */
3774   gtk_tree_view_horizontal_autoscroll (tree_view);
3775   /* Update the current reorder position and arrow; */
3776   gtk_tree_view_update_current_reorder (tree_view);
3777
3778   return TRUE;
3779 }
3780
3781 static void
3782 gtk_tree_view_stop_rubber_band (GtkTreeView *tree_view)
3783 {
3784   remove_scroll_timeout (tree_view);
3785   gtk_grab_remove (GTK_WIDGET (tree_view));
3786
3787   if (tree_view->priv->rubber_band_status == RUBBER_BAND_ACTIVE)
3788     {
3789       GtkTreePath *tmp_path;
3790
3791       gtk_widget_queue_draw (GTK_WIDGET (tree_view));
3792
3793       /* The anchor path should be set to the start path */
3794       tmp_path = _gtk_tree_view_find_path (tree_view,
3795                                            tree_view->priv->rubber_band_start_tree,
3796                                            tree_view->priv->rubber_band_start_node);
3797
3798       if (tree_view->priv->anchor)
3799         gtk_tree_row_reference_free (tree_view->priv->anchor);
3800
3801       tree_view->priv->anchor =
3802         gtk_tree_row_reference_new_proxy (G_OBJECT (tree_view),
3803                                           tree_view->priv->model,
3804                                           tmp_path);
3805
3806       gtk_tree_path_free (tmp_path);
3807
3808       /* ... and the cursor to the end path */
3809       tmp_path = _gtk_tree_view_find_path (tree_view,
3810                                            tree_view->priv->rubber_band_end_tree,
3811                                            tree_view->priv->rubber_band_end_node);
3812       gtk_tree_view_real_set_cursor (GTK_TREE_VIEW (tree_view), tmp_path, FALSE, FALSE);
3813       gtk_tree_path_free (tmp_path);
3814
3815       _gtk_tree_selection_emit_changed (tree_view->priv->selection);
3816     }
3817
3818   /* Clear status variables */
3819   tree_view->priv->rubber_band_status = RUBBER_BAND_OFF;
3820   tree_view->priv->rubber_band_shift = 0;
3821   tree_view->priv->rubber_band_ctrl = 0;
3822
3823   tree_view->priv->rubber_band_start_node = NULL;
3824   tree_view->priv->rubber_band_start_tree = NULL;
3825   tree_view->priv->rubber_band_end_node = NULL;
3826   tree_view->priv->rubber_band_end_tree = NULL;
3827 }
3828
3829 static void
3830 gtk_tree_view_update_rubber_band_selection_range (GtkTreeView *tree_view,
3831                                                  GtkRBTree   *start_tree,
3832                                                  GtkRBNode   *start_node,
3833                                                  GtkRBTree   *end_tree,
3834                                                  GtkRBNode   *end_node,
3835                                                  gboolean     select,
3836                                                  gboolean     skip_start,
3837                                                  gboolean     skip_end)
3838 {
3839   if (start_node == end_node)
3840     return;
3841
3842   /* We skip the first node and jump inside the loop */
3843   if (skip_start)
3844     goto skip_first;
3845
3846   do
3847     {
3848       /* Small optimization by assuming insensitive nodes are never
3849        * selected.
3850        */
3851       if (!GTK_RBNODE_FLAG_SET (start_node, GTK_RBNODE_IS_SELECTED))
3852         {
3853           GtkTreePath *path;
3854           gboolean selectable;
3855
3856           path = _gtk_tree_view_find_path (tree_view, start_tree, start_node);
3857           selectable = _gtk_tree_selection_row_is_selectable (tree_view->priv->selection, start_node, path);
3858           gtk_tree_path_free (path);
3859
3860           if (!selectable)
3861             goto node_not_selectable;
3862         }
3863
3864       if (select)
3865         {
3866           if (tree_view->priv->rubber_band_shift)
3867             GTK_RBNODE_SET_FLAG (start_node, GTK_RBNODE_IS_SELECTED);
3868           else if (tree_view->priv->rubber_band_ctrl)
3869             {
3870               /* Toggle the selection state */
3871               if (GTK_RBNODE_FLAG_SET (start_node, GTK_RBNODE_IS_SELECTED))
3872                 GTK_RBNODE_UNSET_FLAG (start_node, GTK_RBNODE_IS_SELECTED);
3873               else
3874                 GTK_RBNODE_SET_FLAG (start_node, GTK_RBNODE_IS_SELECTED);
3875             }
3876           else
3877             GTK_RBNODE_SET_FLAG (start_node, GTK_RBNODE_IS_SELECTED);
3878         }
3879       else
3880         {
3881           /* Mirror the above */
3882           if (tree_view->priv->rubber_band_shift)
3883             GTK_RBNODE_UNSET_FLAG (start_node, GTK_RBNODE_IS_SELECTED);
3884           else if (tree_view->priv->rubber_band_ctrl)
3885             {
3886               /* Toggle the selection state */
3887               if (GTK_RBNODE_FLAG_SET (start_node, GTK_RBNODE_IS_SELECTED))
3888                 GTK_RBNODE_UNSET_FLAG (start_node, GTK_RBNODE_IS_SELECTED);
3889               else
3890                 GTK_RBNODE_SET_FLAG (start_node, GTK_RBNODE_IS_SELECTED);
3891             }
3892           else
3893             GTK_RBNODE_UNSET_FLAG (start_node, GTK_RBNODE_IS_SELECTED);
3894         }
3895
3896       _gtk_tree_view_queue_draw_node (tree_view, start_tree, start_node, NULL);
3897
3898 node_not_selectable:
3899       if (start_node == end_node)
3900         break;
3901
3902 skip_first:
3903
3904       if (start_node->children)
3905         {
3906           start_tree = start_node->children;
3907           start_node = start_tree->root;
3908           while (start_node->left != start_tree->nil)
3909             start_node = start_node->left;
3910         }
3911       else
3912         {
3913           _gtk_rbtree_next_full (start_tree, start_node, &start_tree, &start_node);
3914
3915           if (!start_tree)
3916             /* Ran out of tree */
3917             break;
3918         }
3919
3920       if (skip_end && start_node == end_node)
3921         break;
3922     }
3923   while (TRUE);
3924 }
3925
3926 static void
3927 gtk_tree_view_update_rubber_band_selection (GtkTreeView *tree_view)
3928 {
3929   GtkRBTree *start_tree, *end_tree;
3930   GtkRBNode *start_node, *end_node;
3931
3932   _gtk_rbtree_find_offset (tree_view->priv->tree, MIN (tree_view->priv->press_start_y, tree_view->priv->rubber_band_y), &start_tree, &start_node);
3933   _gtk_rbtree_find_offset (tree_view->priv->tree, MAX (tree_view->priv->press_start_y, tree_view->priv->rubber_band_y), &end_tree, &end_node);
3934
3935   /* Handle the start area first */
3936   if (!tree_view->priv->rubber_band_start_node)
3937     {
3938       gtk_tree_view_update_rubber_band_selection_range (tree_view,
3939                                                        start_tree,
3940                                                        start_node,
3941                                                        end_tree,
3942                                                        end_node,
3943                                                        TRUE,
3944                                                        FALSE,
3945                                                        FALSE);
3946     }
3947   else if (_gtk_rbtree_node_find_offset (start_tree, start_node) <
3948            _gtk_rbtree_node_find_offset (tree_view->priv->rubber_band_start_tree, tree_view->priv->rubber_band_start_node))
3949     {
3950       /* New node is above the old one; selection became bigger */
3951       gtk_tree_view_update_rubber_band_selection_range (tree_view,
3952                                                        start_tree,
3953                                                        start_node,
3954                                                        tree_view->priv->rubber_band_start_tree,
3955                                                        tree_view->priv->rubber_band_start_node,
3956                                                        TRUE,
3957                                                        FALSE,
3958                                                        TRUE);
3959     }
3960   else if (_gtk_rbtree_node_find_offset (start_tree, start_node) >
3961            _gtk_rbtree_node_find_offset (tree_view->priv->rubber_band_start_tree, tree_view->priv->rubber_band_start_node))
3962     {
3963       /* New node is below the old one; selection became smaller */
3964       gtk_tree_view_update_rubber_band_selection_range (tree_view,
3965                                                        tree_view->priv->rubber_band_start_tree,
3966                                                        tree_view->priv->rubber_band_start_node,
3967                                                        start_tree,
3968                                                        start_node,
3969                                                        FALSE,
3970                                                        FALSE,
3971                                                        TRUE);
3972     }
3973
3974   tree_view->priv->rubber_band_start_tree = start_tree;
3975   tree_view->priv->rubber_band_start_node = start_node;
3976
3977   /* Next, handle the end area */
3978   if (!tree_view->priv->rubber_band_end_node)
3979     {
3980       /* In the event this happens, start_node was also NULL; this case is
3981        * handled above.
3982        */
3983     }
3984   else if (!end_node)
3985     {
3986       /* Find the last node in the tree */
3987       _gtk_rbtree_find_offset (tree_view->priv->tree, tree_view->priv->height - 1,
3988                                &end_tree, &end_node);
3989
3990       /* Selection reached end of the tree */
3991       gtk_tree_view_update_rubber_band_selection_range (tree_view,
3992                                                        tree_view->priv->rubber_band_end_tree,
3993                                                        tree_view->priv->rubber_band_end_node,
3994                                                        end_tree,
3995                                                        end_node,
3996                                                        TRUE,
3997                                                        TRUE,
3998                                                        FALSE);
3999     }
4000   else if (_gtk_rbtree_node_find_offset (end_tree, end_node) >
4001            _gtk_rbtree_node_find_offset (tree_view->priv->rubber_band_end_tree, tree_view->priv->rubber_band_end_node))
4002     {
4003       /* New node is below the old one; selection became bigger */
4004       gtk_tree_view_update_rubber_band_selection_range (tree_view,
4005                                                        tree_view->priv->rubber_band_end_tree,
4006                                                        tree_view->priv->rubber_band_end_node,
4007                                                        end_tree,
4008                                                        end_node,
4009                                                        TRUE,
4010                                                        TRUE,
4011                                                        FALSE);
4012     }
4013   else if (_gtk_rbtree_node_find_offset (end_tree, end_node) <
4014            _gtk_rbtree_node_find_offset (tree_view->priv->rubber_band_end_tree, tree_view->priv->rubber_band_end_node))
4015     {
4016       /* New node is above the old one; selection became smaller */
4017       gtk_tree_view_update_rubber_band_selection_range (tree_view,
4018                                                        end_tree,
4019                                                        end_node,
4020                                                        tree_view->priv->rubber_band_end_tree,
4021                                                        tree_view->priv->rubber_band_end_node,
4022                                                        FALSE,
4023                                                        TRUE,
4024                                                        FALSE);
4025     }
4026
4027   tree_view->priv->rubber_band_end_tree = end_tree;
4028   tree_view->priv->rubber_band_end_node = end_node;
4029 }
4030
4031 static void
4032 gtk_tree_view_update_rubber_band (GtkTreeView *tree_view)
4033 {
4034   gint x, y;
4035   GdkRectangle old_area;
4036   GdkRectangle new_area;
4037   GdkRectangle common;
4038   cairo_region_t *invalid_region;
4039
4040   old_area.x = MIN (tree_view->priv->press_start_x, tree_view->priv->rubber_band_x);
4041   old_area.y = MIN (tree_view->priv->press_start_y, tree_view->priv->rubber_band_y) - tree_view->priv->dy;
4042   old_area.width = ABS (tree_view->priv->rubber_band_x - tree_view->priv->press_start_x) + 1;
4043   old_area.height = ABS (tree_view->priv->rubber_band_y - tree_view->priv->press_start_y) + 1;
4044
4045   gdk_window_get_pointer (tree_view->priv->bin_window, &x, &y, NULL);
4046
4047   x = MAX (x, 0);
4048   y = MAX (y, 0) + tree_view->priv->dy;
4049
4050   new_area.x = MIN (tree_view->priv->press_start_x, x);
4051   new_area.y = MIN (tree_view->priv->press_start_y, y) - tree_view->priv->dy;
4052   new_area.width = ABS (x - tree_view->priv->press_start_x) + 1;
4053   new_area.height = ABS (y - tree_view->priv->press_start_y) + 1;
4054
4055   invalid_region = cairo_region_create_rectangle (&old_area);
4056   cairo_region_union_rectangle (invalid_region, &new_area);
4057
4058   gdk_rectangle_intersect (&old_area, &new_area, &common);
4059   if (common.width > 2 && common.height > 2)
4060     {
4061       cairo_region_t *common_region;
4062
4063       /* make sure the border is invalidated */
4064       common.x += 1;
4065       common.y += 1;
4066       common.width -= 2;
4067       common.height -= 2;
4068
4069       common_region = cairo_region_create_rectangle (&common);
4070
4071       cairo_region_subtract (invalid_region, common_region);
4072       cairo_region_destroy (common_region);
4073     }
4074
4075   gdk_window_invalidate_region (tree_view->priv->bin_window, invalid_region, TRUE);
4076
4077   cairo_region_destroy (invalid_region);
4078
4079   tree_view->priv->rubber_band_x = x;
4080   tree_view->priv->rubber_band_y = y;
4081
4082   gtk_tree_view_update_rubber_band_selection (tree_view);
4083 }
4084
4085 static void
4086 gtk_tree_view_paint_rubber_band (GtkTreeView  *tree_view,
4087                                  cairo_t      *cr)
4088 {
4089   GdkRectangle rect;
4090   GtkStyle *style;
4091
4092   cairo_save (cr);
4093
4094   rect.x = MIN (tree_view->priv->press_start_x, tree_view->priv->rubber_band_x);
4095   rect.y = MIN (tree_view->priv->press_start_y, tree_view->priv->rubber_band_y) - tree_view->priv->dy;
4096   rect.width = ABS (tree_view->priv->press_start_x - tree_view->priv->rubber_band_x) + 1;
4097   rect.height = ABS (tree_view->priv->press_start_y - tree_view->priv->rubber_band_y) + 1;
4098
4099   cairo_set_line_width (cr, 1.0);
4100
4101   style = gtk_widget_get_style (GTK_WIDGET (tree_view));
4102
4103   gdk_cairo_set_source_color (cr, &style->fg[GTK_STATE_NORMAL]);
4104
4105   gdk_cairo_rectangle (cr, &rect);
4106   cairo_clip (cr);
4107   cairo_paint_with_alpha (cr, 0.25);
4108
4109   cairo_rectangle (cr,
4110                    rect.x + 0.5, rect.y + 0.5,
4111                    rect.width - 1, rect.height - 1);
4112   cairo_stroke (cr);
4113
4114   cairo_restore (cr);
4115 }
4116
4117 static gboolean
4118 gtk_tree_view_motion_bin_window (GtkWidget      *widget,
4119                                  GdkEventMotion *event)
4120 {
4121   GtkTreeView *tree_view;
4122   GtkRBTree *tree;
4123   GtkRBNode *node;
4124   gint new_y;
4125
4126   tree_view = (GtkTreeView *) widget;
4127
4128   if (tree_view->priv->tree == NULL)
4129     return FALSE;
4130
4131   if (tree_view->priv->rubber_band_status == RUBBER_BAND_MAYBE_START)
4132     {
4133       gtk_grab_add (GTK_WIDGET (tree_view));
4134       gtk_tree_view_update_rubber_band (tree_view);
4135
4136       tree_view->priv->rubber_band_status = RUBBER_BAND_ACTIVE;
4137     }
4138   else if (tree_view->priv->rubber_band_status == RUBBER_BAND_ACTIVE)
4139     {
4140       gtk_tree_view_update_rubber_band (tree_view);
4141
4142       add_scroll_timeout (tree_view);
4143     }
4144
4145   /* only check for an initiated drag when a button is pressed */
4146   if (tree_view->priv->pressed_button >= 0
4147       && !tree_view->priv->rubber_band_status)
4148     gtk_tree_view_maybe_begin_dragging_row (tree_view, event);
4149
4150   new_y = TREE_WINDOW_Y_TO_RBTREE_Y(tree_view, event->y);
4151   if (new_y < 0)
4152     new_y = 0;
4153
4154   _gtk_rbtree_find_offset (tree_view->priv->tree, new_y, &tree, &node);
4155
4156   /* If we are currently pressing down a button, we don't want to prelight anything else. */
4157   if ((tree_view->priv->button_pressed_node != NULL) &&
4158       (tree_view->priv->button_pressed_node != node))
4159     node = NULL;
4160
4161   tree_view->priv->event_last_x = event->x;
4162   tree_view->priv->event_last_y = event->y;
4163
4164   prelight_or_select (tree_view, tree, node, event->x, event->y);
4165
4166   return TRUE;
4167 }
4168
4169 static gboolean
4170 gtk_tree_view_motion (GtkWidget      *widget,
4171                       GdkEventMotion *event)
4172 {
4173   GtkTreeView *tree_view;
4174
4175   tree_view = (GtkTreeView *) widget;
4176
4177   /* Resizing a column */
4178   if (GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_IN_COLUMN_RESIZE))
4179     return gtk_tree_view_motion_resize_column (widget, event);
4180
4181   /* Drag column */
4182   if (GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_IN_COLUMN_DRAG))
4183     return gtk_tree_view_motion_drag_column (widget, event);
4184
4185   /* Sanity check it */
4186   if (event->window == tree_view->priv->bin_window)
4187     return gtk_tree_view_motion_bin_window (widget, event);
4188
4189   return FALSE;
4190 }
4191
4192 /* Invalidate the focus rectangle near the edge of the bin_window; used when
4193  * the tree is empty.
4194  */
4195 static void
4196 invalidate_empty_focus (GtkTreeView *tree_view)
4197 {
4198   GdkRectangle area;
4199
4200   if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
4201     return;
4202
4203   area.x = 0;
4204   area.y = 0;
4205   area.width = gdk_window_get_width (tree_view->priv->bin_window);
4206   area.height = gdk_window_get_height (tree_view->priv->bin_window);
4207   gdk_window_invalidate_rect (tree_view->priv->bin_window, &area, FALSE);
4208 }
4209
4210 /* Draws a focus rectangle near the edge of the bin_window; used when the tree
4211  * is empty.
4212  */
4213 static void
4214 draw_empty_focus (GtkTreeView *tree_view, cairo_t *cr)
4215 {
4216   GtkWidget *widget = GTK_WIDGET (tree_view);
4217   gint w, h;
4218
4219   if (!gtk_widget_has_focus (widget))
4220     return;
4221
4222   w = gdk_window_get_width (tree_view->priv->bin_window) - 2;
4223   h = gdk_window_get_height (tree_view->priv->bin_window) - 2;
4224
4225   if (w > 0 && h > 0)
4226     gtk_paint_focus (gtk_widget_get_style (widget),
4227                      cr,
4228                      gtk_widget_get_state (widget),
4229                      widget,
4230                      NULL,
4231                      1, 1, w, h);
4232 }
4233
4234 typedef enum {
4235   GTK_TREE_VIEW_GRID_LINE,
4236   GTK_TREE_VIEW_TREE_LINE,
4237   GTK_TREE_VIEW_FOREGROUND_LINE
4238 } GtkTreeViewLineType;
4239
4240 static void
4241 gtk_tree_view_draw_line (GtkTreeView         *tree_view,
4242                          cairo_t             *cr,
4243                          GtkTreeViewLineType  type,
4244                          int                  x1,
4245                          int                  y1,
4246                          int                  x2,
4247                          int                  y2)
4248 {
4249   cairo_save (cr);
4250
4251   switch (type)
4252     {
4253     case GTK_TREE_VIEW_TREE_LINE:
4254       cairo_set_source_rgb (cr, 0, 0, 0);
4255       cairo_set_line_width (cr, tree_view->priv->tree_line_width);
4256       if (tree_view->priv->tree_line_dashes[0])
4257         cairo_set_dash (cr,
4258                         tree_view->priv->tree_line_dashes,
4259                         2, 0.5);
4260       break;
4261     case GTK_TREE_VIEW_GRID_LINE:
4262       cairo_set_source_rgb (cr, 0, 0, 0);
4263       cairo_set_line_width (cr, tree_view->priv->grid_line_width);
4264       if (tree_view->priv->grid_line_dashes[0])
4265         cairo_set_dash (cr,
4266                         tree_view->priv->grid_line_dashes,
4267                         2, 0.5);
4268       break;
4269     default:
4270       g_assert_not_reached ();
4271       /* fall through */
4272     case GTK_TREE_VIEW_FOREGROUND_LINE:
4273       cairo_set_line_width (cr, 1.0);
4274       gdk_cairo_set_source_color (cr,
4275                                   &gtk_widget_get_style (GTK_WIDGET (tree_view))->fg[gtk_widget_get_state (GTK_WIDGET (tree_view))]);
4276       break;
4277     }
4278
4279   cairo_move_to (cr, x1 + 0.5, y1 + 0.5);
4280   cairo_line_to (cr, x2 + 0.5, y2 + 0.5);
4281   cairo_stroke (cr);
4282
4283   cairo_restore (cr);
4284 }
4285
4286 static void
4287 gtk_tree_view_draw_grid_lines (GtkTreeView    *tree_view,
4288                                cairo_t        *cr,
4289                                gint            n_visible_columns)
4290 {
4291   GList *list = tree_view->priv->columns;
4292   gint i = 0;
4293   gint current_x = 0;
4294
4295   if (tree_view->priv->grid_lines != GTK_TREE_VIEW_GRID_LINES_VERTICAL
4296       && tree_view->priv->grid_lines != GTK_TREE_VIEW_GRID_LINES_BOTH)
4297     return;
4298
4299   /* Only draw the lines for visible rows and columns */
4300   for (list = tree_view->priv->columns; list; list = list->next, i++)
4301     {
4302       GtkTreeViewColumn *column = list->data;
4303
4304       /* We don't want a line for the last column */
4305       if (i == n_visible_columns - 1)
4306         break;
4307
4308       if (! column->visible)
4309         continue;
4310
4311       current_x += column->width;
4312
4313       gtk_tree_view_draw_line (tree_view, cr,
4314                                GTK_TREE_VIEW_GRID_LINE,
4315                                current_x - 1, 0,
4316                                current_x - 1, tree_view->priv->height);
4317     }
4318 }
4319
4320 /* Warning: Very scary function.
4321  * Modify at your own risk
4322  *
4323  * KEEP IN SYNC WITH gtk_tree_view_create_row_drag_icon()!
4324  * FIXME: It's not...
4325  */
4326 static gboolean
4327 gtk_tree_view_bin_draw (GtkWidget      *widget,
4328                         cairo_t        *cr)
4329 {
4330   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
4331   GtkTreePath *path;
4332   GtkStyle *style;
4333   GtkRBTree *tree;
4334   GList *list;
4335   GtkRBNode *node;
4336   GtkRBNode *cursor = NULL;
4337   GtkRBTree *cursor_tree = NULL;
4338   GtkRBNode *drag_highlight = NULL;
4339   GtkRBTree *drag_highlight_tree = NULL;
4340   GtkTreeIter iter;
4341   gint new_y;
4342   gint y_offset, cell_offset;
4343   gint max_height;
4344   gint depth;
4345   GdkRectangle background_area;
4346   GdkRectangle cell_area;
4347   GdkRectangle clip;
4348   guint flags;
4349   gint highlight_x;
4350   gint expander_cell_width;
4351   gint bin_window_width;
4352   gint bin_window_height;
4353   GtkTreePath *cursor_path;
4354   GtkTreePath *drag_dest_path;
4355   GList *first_column, *last_column;
4356   gint vertical_separator;
4357   gint horizontal_separator;
4358   gint focus_line_width;
4359   gboolean allow_rules;
4360   gboolean has_special_cell;
4361   gboolean rtl;
4362   gint n_visible_columns;
4363   gint pointer_x, pointer_y;
4364   gint grid_line_width;
4365   gboolean got_pointer = FALSE;
4366   gboolean draw_vgrid_lines, draw_hgrid_lines;
4367
4368   rtl = (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL);
4369
4370   gtk_widget_style_get (widget,
4371                         "horizontal-separator", &horizontal_separator,
4372                         "vertical-separator", &vertical_separator,
4373                         "allow-rules", &allow_rules,
4374                         "focus-line-width", &focus_line_width,
4375                         NULL);
4376
4377   if (tree_view->priv->tree == NULL)
4378     {
4379       draw_empty_focus (tree_view, cr);
4380       return TRUE;
4381     }
4382
4383   validate_visible_area (tree_view);
4384
4385   style = gtk_widget_get_style (widget);
4386
4387   bin_window_width = gdk_window_get_width (tree_view->priv->bin_window);
4388   bin_window_height = gdk_window_get_height (tree_view->priv->bin_window);
4389   cairo_rectangle (cr, 0, 0, bin_window_width, bin_window_height);
4390   cairo_clip (cr);
4391   if (!gdk_cairo_get_clip_rectangle (cr, &clip))
4392     return TRUE;
4393
4394   new_y = TREE_WINDOW_Y_TO_RBTREE_Y (tree_view, clip.y);
4395
4396   if (new_y < 0)
4397     new_y = 0;
4398   y_offset = -_gtk_rbtree_find_offset (tree_view->priv->tree, new_y, &tree, &node);
4399
4400   if (tree_view->priv->height < bin_window_height)
4401     {
4402       gtk_paint_flat_box (style,
4403                           cr,
4404                           gtk_widget_get_state (widget),
4405                           GTK_SHADOW_NONE,
4406                           widget,
4407                           "cell_even",
4408                           0, tree_view->priv->height,
4409                           bin_window_width,
4410                           bin_window_height - tree_view->priv->height);
4411     }
4412
4413   if (node == NULL)
4414     return TRUE;
4415
4416   /* find the path for the node */
4417   path = _gtk_tree_view_find_path ((GtkTreeView *)widget,
4418                                    tree,
4419                                    node);
4420   gtk_tree_model_get_iter (tree_view->priv->model,
4421                            &iter,
4422                            path);
4423   depth = gtk_tree_path_get_depth (path);
4424   gtk_tree_path_free (path);
4425
4426   cursor_path = NULL;
4427   drag_dest_path = NULL;
4428
4429   if (tree_view->priv->cursor)
4430     cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
4431
4432   if (cursor_path)
4433     _gtk_tree_view_find_node (tree_view, cursor_path,
4434                               &cursor_tree, &cursor);
4435
4436   if (tree_view->priv->drag_dest_row)
4437     drag_dest_path = gtk_tree_row_reference_get_path (tree_view->priv->drag_dest_row);
4438
4439   if (drag_dest_path)
4440     _gtk_tree_view_find_node (tree_view, drag_dest_path,
4441                               &drag_highlight_tree, &drag_highlight);
4442
4443   draw_vgrid_lines =
4444     tree_view->priv->grid_lines == GTK_TREE_VIEW_GRID_LINES_VERTICAL
4445     || tree_view->priv->grid_lines == GTK_TREE_VIEW_GRID_LINES_BOTH;
4446   draw_hgrid_lines =
4447     tree_view->priv->grid_lines == GTK_TREE_VIEW_GRID_LINES_HORIZONTAL
4448     || tree_view->priv->grid_lines == GTK_TREE_VIEW_GRID_LINES_BOTH;
4449
4450   if (draw_vgrid_lines || draw_hgrid_lines)
4451     gtk_widget_style_get (widget, "grid-line-width", &grid_line_width, NULL);
4452
4453   n_visible_columns = 0;
4454   for (list = tree_view->priv->columns; list; list = list->next)
4455     {
4456       if (! GTK_TREE_VIEW_COLUMN (list->data)->visible)
4457         continue;
4458       n_visible_columns ++;
4459     }
4460
4461   /* Find the last column */
4462   for (last_column = g_list_last (tree_view->priv->columns);
4463        last_column && !(GTK_TREE_VIEW_COLUMN (last_column->data)->visible);
4464        last_column = last_column->prev)
4465     ;
4466
4467   /* and the first */
4468   for (first_column = g_list_first (tree_view->priv->columns);
4469        first_column && !(GTK_TREE_VIEW_COLUMN (first_column->data)->visible);
4470        first_column = first_column->next)
4471     ;
4472
4473   /* Actually process the expose event.  To do this, we want to
4474    * start at the first node of the event, and walk the tree in
4475    * order, drawing each successive node.
4476    */
4477
4478   do
4479     {
4480       gboolean parity;
4481       gboolean is_separator = FALSE;
4482       gboolean is_first = FALSE;
4483       gboolean is_last = FALSE;
4484
4485       is_separator = row_is_separator (tree_view, &iter, NULL);
4486
4487       max_height = ROW_HEIGHT (tree_view, BACKGROUND_HEIGHT (node));
4488
4489       cell_offset = 0;
4490       highlight_x = 0; /* should match x coord of first cell */
4491       expander_cell_width = 0;
4492
4493       background_area.y = y_offset + clip.y;
4494       background_area.height = max_height;
4495
4496       flags = 0;
4497
4498       if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PRELIT))
4499         flags |= GTK_CELL_RENDERER_PRELIT;
4500
4501       if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SELECTED))
4502         flags |= GTK_CELL_RENDERER_SELECTED;
4503
4504       parity = _gtk_rbtree_node_find_parity (tree, node);
4505
4506       /* we *need* to set cell data on all cells before the call
4507        * to _has_special_cell, else _has_special_cell() does not
4508        * return a correct value.
4509        */
4510       for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns));
4511            list;
4512            list = (rtl ? list->prev : list->next))
4513         {
4514           GtkTreeViewColumn *column = list->data;
4515           gtk_tree_view_column_cell_set_cell_data (column,
4516                                                    tree_view->priv->model,
4517                                                    &iter,
4518                                                    GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT),
4519                                                    node->children?TRUE:FALSE);
4520         }
4521
4522       has_special_cell = gtk_tree_view_has_special_cell (tree_view);
4523
4524       for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns));
4525            list;
4526            list = (rtl ? list->prev : list->next))
4527         {
4528           GtkTreeViewColumn *column = list->data;
4529           const gchar *detail = NULL;
4530           gchar new_detail[128];
4531           GtkStateType state;
4532
4533           if (!column->visible)
4534             continue;
4535
4536           if (cell_offset > clip.x + clip.width ||
4537               cell_offset + column->width < clip.x)
4538             {
4539               cell_offset += column->width;
4540               continue;
4541             }
4542
4543           if (column->show_sort_indicator)
4544             flags |= GTK_CELL_RENDERER_SORTED;
4545           else
4546             flags &= ~GTK_CELL_RENDERER_SORTED;
4547
4548           if (cursor == node)
4549             flags |= GTK_CELL_RENDERER_FOCUSED;
4550           else
4551             flags &= ~GTK_CELL_RENDERER_FOCUSED;
4552
4553           background_area.x = cell_offset;
4554           background_area.width = column->width;
4555
4556           cell_area = background_area;
4557           cell_area.y += vertical_separator / 2;
4558           cell_area.x += horizontal_separator / 2;
4559           cell_area.height -= vertical_separator;
4560           cell_area.width -= horizontal_separator;
4561
4562           if (draw_vgrid_lines)
4563             {
4564               if (list == first_column)
4565                 {
4566                   cell_area.width -= grid_line_width / 2;
4567                 }
4568               else if (list == last_column)
4569                 {
4570                   cell_area.x += grid_line_width / 2;
4571                   cell_area.width -= grid_line_width / 2;
4572                 }
4573               else
4574                 {
4575                   cell_area.x += grid_line_width / 2;
4576                   cell_area.width -= grid_line_width;
4577                 }
4578             }
4579
4580           if (draw_hgrid_lines)
4581             {
4582               cell_area.y += grid_line_width / 2;
4583               cell_area.height -= grid_line_width;
4584             }
4585
4586           if (!gdk_rectangle_intersect (&clip, &background_area, NULL))
4587             {
4588               cell_offset += column->width;
4589               continue;
4590             }
4591
4592           gtk_tree_view_column_cell_set_cell_data (column,
4593                                                    tree_view->priv->model,
4594                                                    &iter,
4595                                                    GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT),
4596                                                    node->children?TRUE:FALSE);
4597
4598           /* Select the detail for drawing the cell.  relevant
4599            * factors are parity, sortedness, and whether to
4600            * display rules.
4601            */
4602           if (allow_rules && tree_view->priv->has_rules)
4603             {
4604               if ((flags & GTK_CELL_RENDERER_SORTED) &&
4605                   n_visible_columns >= 3)
4606                 {
4607                   if (parity)
4608                     detail = "cell_odd_ruled_sorted";
4609                   else
4610                     detail = "cell_even_ruled_sorted";
4611                 }
4612               else
4613                 {
4614                   if (parity)
4615                     detail = "cell_odd_ruled";
4616                   else
4617                     detail = "cell_even_ruled";
4618                 }
4619             }
4620           else
4621             {
4622               if ((flags & GTK_CELL_RENDERER_SORTED) &&
4623                   n_visible_columns >= 3)
4624                 {
4625                   if (parity)
4626                     detail = "cell_odd_sorted";
4627                   else
4628                     detail = "cell_even_sorted";
4629                 }
4630               else
4631                 {
4632                   if (parity)
4633                     detail = "cell_odd";
4634                   else
4635                     detail = "cell_even";
4636                 }
4637             }
4638
4639           g_assert (detail);
4640
4641           if (gtk_widget_get_state (widget) == GTK_STATE_INSENSITIVE)
4642             state = GTK_STATE_INSENSITIVE;
4643           else if (flags & GTK_CELL_RENDERER_SELECTED)
4644             state = GTK_STATE_SELECTED;
4645           else
4646             state = GTK_STATE_NORMAL;
4647
4648           /* Draw background */
4649           is_first = (rtl ? !list->next : !list->prev);
4650           is_last = (rtl ? !list->prev : !list->next);
4651
4652           /* (I don't like the snprintfs either, but couldn't find a
4653            * less messy way).
4654            */
4655           if (is_first && is_last)
4656             g_snprintf (new_detail, 127, "%s", detail);
4657           else if (is_first)
4658             g_snprintf (new_detail, 127, "%s_start", detail);
4659           else if (is_last)
4660             g_snprintf (new_detail, 127, "%s_end", detail);
4661           else
4662             g_snprintf (new_detail, 127, "%s_middle", detail);
4663
4664           gtk_paint_flat_box (style,
4665                               cr,
4666                               state,
4667                               GTK_SHADOW_NONE,
4668                               widget,
4669                               new_detail,
4670                               background_area.x,
4671                               background_area.y,
4672                               background_area.width,
4673                               background_area.height);
4674
4675           if (gtk_tree_view_is_expander_column (tree_view, column))
4676             {
4677               if (!rtl)
4678                 cell_area.x += (depth - 1) * tree_view->priv->level_indentation;
4679               cell_area.width -= (depth - 1) * tree_view->priv->level_indentation;
4680
4681               if (TREE_VIEW_DRAW_EXPANDERS(tree_view))
4682                 {
4683                   if (!rtl)
4684                     cell_area.x += depth * tree_view->priv->expander_size;
4685                   cell_area.width -= depth * tree_view->priv->expander_size;
4686                 }
4687
4688               /* If we have an expander column, the highlight underline
4689                * starts with that column, so that it indicates which
4690                * level of the tree we're dropping at.
4691                */
4692               highlight_x = cell_area.x;
4693               expander_cell_width = cell_area.width;
4694
4695               if (is_separator)
4696                 gtk_paint_hline (style,
4697                                  cr,
4698                                  state,
4699                                  widget,
4700                                  NULL,
4701                                  cell_area.x,
4702                                  cell_area.x + cell_area.width,
4703                                  cell_area.y + cell_area.height / 2);
4704               else
4705                 _gtk_tree_view_column_cell_render (column,
4706                                                    cr,
4707                                                    &background_area,
4708                                                    &cell_area,
4709                                                    flags);
4710               if (TREE_VIEW_DRAW_EXPANDERS(tree_view)
4711                   && (node->flags & GTK_RBNODE_IS_PARENT) == GTK_RBNODE_IS_PARENT)
4712                 {
4713                   if (!got_pointer)
4714                     {
4715                       gdk_window_get_pointer (tree_view->priv->bin_window,
4716                                               &pointer_x, &pointer_y, NULL);
4717                       got_pointer = TRUE;
4718                     }
4719
4720                   gtk_tree_view_draw_arrow (GTK_TREE_VIEW (widget),
4721                                             cr,
4722                                             tree,
4723                                             node,
4724                                             pointer_x, pointer_y);
4725                 }
4726             }
4727           else
4728             {
4729               if (is_separator)
4730                 gtk_paint_hline (style,
4731                                  cr,
4732                                  state,
4733                                  widget,
4734                                  NULL,
4735                                  cell_area.x,
4736                                  cell_area.x + cell_area.width,
4737                                  cell_area.y + cell_area.height / 2);
4738               else
4739                 _gtk_tree_view_column_cell_render (column,
4740                                                    cr,
4741                                                    &background_area,
4742                                                    &cell_area,
4743                                                    flags);
4744             }
4745
4746           if (draw_hgrid_lines)
4747             {
4748               if (background_area.y > 0)
4749                 gtk_tree_view_draw_line (tree_view, cr,
4750                                          GTK_TREE_VIEW_GRID_LINE,
4751                                          background_area.x, background_area.y,
4752                                          background_area.x + background_area.width,
4753                                          background_area.y);
4754
4755               if (y_offset + max_height >= clip.height)
4756                 gtk_tree_view_draw_line (tree_view, cr,
4757                                          GTK_TREE_VIEW_GRID_LINE,
4758                                          background_area.x, background_area.y + max_height,
4759                                          background_area.x + background_area.width,
4760                                          background_area.y + max_height);
4761             }
4762
4763           if (gtk_tree_view_is_expander_column (tree_view, column) &&
4764               tree_view->priv->tree_lines_enabled)
4765             {
4766               gint x = background_area.x;
4767               gint mult = rtl ? -1 : 1;
4768               gint y0 = background_area.y;
4769               gint y1 = background_area.y + background_area.height/2;
4770               gint y2 = background_area.y + background_area.height;
4771
4772               if (rtl)
4773                 x += background_area.width - 1;
4774
4775               if ((node->flags & GTK_RBNODE_IS_PARENT) == GTK_RBNODE_IS_PARENT
4776                   && depth > 1)
4777                 {
4778                   gtk_tree_view_draw_line (tree_view, cr,
4779                                            GTK_TREE_VIEW_TREE_LINE,
4780                                            x + tree_view->priv->expander_size * (depth - 1.5) * mult,
4781                                            y1,
4782                                            x + tree_view->priv->expander_size * (depth - 1.1) * mult,
4783                                            y1);
4784                 }
4785               else if (depth > 1)
4786                 {
4787                   gtk_tree_view_draw_line (tree_view, cr,
4788                                            GTK_TREE_VIEW_TREE_LINE,
4789                                            x + tree_view->priv->expander_size * (depth - 1.5) * mult,
4790                                            y1,
4791                                            x + tree_view->priv->expander_size * (depth - 0.5) * mult,
4792                                            y1);
4793                 }
4794
4795               if (depth > 1)
4796                 {
4797                   gint i;
4798                   GtkRBNode *tmp_node;
4799                   GtkRBTree *tmp_tree;
4800
4801                   if (!_gtk_rbtree_next (tree, node))
4802                     gtk_tree_view_draw_line (tree_view, cr,
4803                                              GTK_TREE_VIEW_TREE_LINE,
4804                                              x + tree_view->priv->expander_size * (depth - 1.5) * mult,
4805                                              y0,
4806                                              x + tree_view->priv->expander_size * (depth - 1.5) * mult,
4807                                              y1);
4808                   else
4809                     gtk_tree_view_draw_line (tree_view, cr,
4810                                              GTK_TREE_VIEW_TREE_LINE,
4811                                              x + tree_view->priv->expander_size * (depth - 1.5) * mult,
4812                                              y0,
4813                                              x + tree_view->priv->expander_size * (depth - 1.5) * mult,
4814                                              y2);
4815
4816                   tmp_node = tree->parent_node;
4817                   tmp_tree = tree->parent_tree;
4818
4819                   for (i = depth - 2; i > 0; i--)
4820                     {
4821                       if (_gtk_rbtree_next (tmp_tree, tmp_node))
4822                         gtk_tree_view_draw_line (tree_view, cr,
4823                                                  GTK_TREE_VIEW_TREE_LINE,
4824                                                  x + tree_view->priv->expander_size * (i - 0.5) * mult,
4825                                                  y0,
4826                                                  x + tree_view->priv->expander_size * (i - 0.5) * mult,
4827                                                  y2);
4828
4829                       tmp_node = tmp_tree->parent_node;
4830                       tmp_tree = tmp_tree->parent_tree;
4831                     }
4832                 }
4833             }
4834
4835           if (node == cursor && has_special_cell &&
4836               ((column == tree_view->priv->focus_column &&
4837                 GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_DRAW_KEYFOCUS) &&
4838                 gtk_widget_has_focus (widget)) ||
4839                (column == tree_view->priv->edited_column)))
4840             {
4841               _gtk_tree_view_column_cell_draw_focus (column,
4842                                                      cr,
4843                                                      &background_area,
4844                                                      &cell_area,
4845                                                      flags);
4846             }
4847
4848           cell_offset += column->width;
4849         }
4850
4851       if (node == drag_highlight)
4852         {
4853           /* Draw indicator for the drop
4854            */
4855           gint highlight_y = -1;
4856           GtkRBTree *tree = NULL;
4857           GtkRBNode *node = NULL;
4858
4859           switch (tree_view->priv->drag_dest_pos)
4860             {
4861             case GTK_TREE_VIEW_DROP_BEFORE:
4862               highlight_y = background_area.y - 1;
4863               if (highlight_y < 0)
4864                       highlight_y = 0;
4865               break;
4866
4867             case GTK_TREE_VIEW_DROP_AFTER:
4868               highlight_y = background_area.y + background_area.height - 1;
4869               break;
4870
4871             case GTK_TREE_VIEW_DROP_INTO_OR_BEFORE:
4872             case GTK_TREE_VIEW_DROP_INTO_OR_AFTER:
4873               _gtk_tree_view_find_node (tree_view, drag_dest_path, &tree, &node);
4874
4875               if (tree == NULL)
4876                 break;
4877
4878               gtk_paint_focus (style,
4879                                cr,
4880                                gtk_widget_get_state (widget),
4881                                widget,
4882                                (is_first
4883                                 ? (is_last ? "treeview-drop-indicator" : "treeview-drop-indicator-left" )
4884                                 : (is_last ? "treeview-drop-indicator-right" : "tree-view-drop-indicator-middle" )),
4885                                 0, BACKGROUND_FIRST_PIXEL (tree_view, tree, node)
4886                                    - focus_line_width / 2,
4887                                 gdk_window_get_width (tree_view->priv->bin_window),
4888                                 ROW_HEIGHT (tree_view, BACKGROUND_HEIGHT (node))
4889                                    - focus_line_width + 1);
4890               break;
4891             }
4892
4893           if (highlight_y >= 0)
4894             {
4895               gtk_tree_view_draw_line (tree_view, cr,
4896                                        GTK_TREE_VIEW_FOREGROUND_LINE,
4897                                        rtl ? highlight_x + expander_cell_width : highlight_x,
4898                                        highlight_y,
4899                                        rtl ? 0 : bin_window_width,
4900                                        highlight_y);
4901             }
4902         }
4903
4904       /* draw the big row-spanning focus rectangle, if needed */
4905       if (!has_special_cell && node == cursor &&
4906           GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_DRAW_KEYFOCUS) &&
4907           gtk_widget_has_focus (widget))
4908         {
4909           gint tmp_y, tmp_height;
4910           GtkStateType focus_rect_state;
4911
4912           focus_rect_state =
4913             flags & GTK_CELL_RENDERER_SELECTED ? GTK_STATE_SELECTED :
4914             (flags & GTK_CELL_RENDERER_PRELIT ? GTK_STATE_PRELIGHT :
4915              (flags & GTK_CELL_RENDERER_INSENSITIVE ? GTK_STATE_INSENSITIVE :
4916               GTK_STATE_NORMAL));
4917
4918           if (draw_hgrid_lines)
4919             {
4920               tmp_y = BACKGROUND_FIRST_PIXEL (tree_view, tree, node) + grid_line_width / 2;
4921               tmp_height = ROW_HEIGHT (tree_view, BACKGROUND_HEIGHT (node)) - grid_line_width;
4922             }
4923           else
4924             {
4925               tmp_y = BACKGROUND_FIRST_PIXEL (tree_view, tree, node);
4926               tmp_height = ROW_HEIGHT (tree_view, BACKGROUND_HEIGHT (node));
4927             }
4928
4929           gtk_paint_focus (style,
4930                            cr,
4931                            focus_rect_state,
4932                            widget,
4933                            (is_first
4934                             ? (is_last ? "treeview" : "treeview-left" )
4935                             : (is_last ? "treeview-right" : "treeview-middle" )),
4936                            0, tmp_y,
4937                            gdk_window_get_width (tree_view->priv->bin_window),
4938                            tmp_height);
4939         }
4940
4941       y_offset += max_height;
4942       if (node->children)
4943         {
4944           GtkTreeIter parent = iter;
4945           gboolean has_child;
4946
4947           tree = node->children;
4948           node = tree->root;
4949
4950           g_assert (node != tree->nil);
4951
4952           while (node->left != tree->nil)
4953             node = node->left;
4954           has_child = gtk_tree_model_iter_children (tree_view->priv->model,
4955                                                     &iter,
4956                                                     &parent);
4957           depth++;
4958
4959           /* Sanity Check! */
4960           TREE_VIEW_INTERNAL_ASSERT (has_child, FALSE);
4961         }
4962       else
4963         {
4964           gboolean done = FALSE;
4965
4966           do
4967             {
4968               node = _gtk_rbtree_next (tree, node);
4969               if (node != NULL)
4970                 {
4971                   gboolean has_next = gtk_tree_model_iter_next (tree_view->priv->model, &iter);
4972                   done = TRUE;
4973
4974                   /* Sanity Check! */
4975                   TREE_VIEW_INTERNAL_ASSERT (has_next, FALSE);
4976                 }
4977               else
4978                 {
4979                   GtkTreeIter parent_iter = iter;
4980                   gboolean has_parent;
4981
4982                   node = tree->parent_node;
4983                   tree = tree->parent_tree;
4984                   if (tree == NULL)
4985                     /* we should go to done to free some memory */
4986                     goto done;
4987                   has_parent = gtk_tree_model_iter_parent (tree_view->priv->model,
4988                                                            &iter,
4989                                                            &parent_iter);
4990                   depth--;
4991
4992                   /* Sanity check */
4993                   TREE_VIEW_INTERNAL_ASSERT (has_parent, FALSE);
4994                 }
4995             }
4996           while (!done);
4997         }
4998     }
4999   while (y_offset < clip.height);
5000
5001 done:
5002   gtk_tree_view_draw_grid_lines (tree_view, cr, n_visible_columns);
5003
5004   if (tree_view->priv->rubber_band_status == RUBBER_BAND_ACTIVE)
5005     gtk_tree_view_paint_rubber_band (tree_view, cr);
5006
5007   if (cursor_path)
5008     gtk_tree_path_free (cursor_path);
5009
5010   if (drag_dest_path)
5011     gtk_tree_path_free (drag_dest_path);
5012
5013   return FALSE;
5014 }
5015
5016 static gboolean
5017 gtk_tree_view_draw (GtkWidget *widget,
5018                     cairo_t   *cr)
5019 {
5020   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
5021
5022   if (gtk_cairo_should_draw_window (cr, tree_view->priv->bin_window))
5023     {
5024       GList *tmp_list;
5025
5026       cairo_save (cr);
5027
5028       gtk_cairo_transform_to_window (cr, widget, tree_view->priv->bin_window);
5029
5030       gtk_tree_view_bin_draw (widget, cr);
5031
5032       cairo_restore (cr);
5033
5034       /* We can't just chain up to Container::draw as it will try to send the
5035        * event to the headers, so we handle propagating it to our children
5036        * (eg. widgets being edited) ourselves.
5037        */
5038       tmp_list = tree_view->priv->children;
5039       while (tmp_list)
5040         {
5041           GtkTreeViewChild *child = tmp_list->data;
5042           tmp_list = tmp_list->next;
5043
5044           gtk_container_propagate_draw (GTK_CONTAINER (tree_view), child->widget, cr);
5045         }
5046     }
5047
5048   if (gtk_cairo_should_draw_window (cr, tree_view->priv->header_window))
5049     {
5050       GList *list;
5051
5052       for (list = tree_view->priv->columns; list != NULL; list = list->next)
5053         {
5054           GtkTreeViewColumn *column = list->data;
5055
5056           if (column == tree_view->priv->drag_column)
5057             continue;
5058
5059           if (column->visible)
5060             gtk_container_propagate_draw (GTK_CONTAINER (tree_view),
5061                                           column->button,
5062                                           cr);
5063         }
5064     }
5065
5066   if (tree_view->priv->drag_window &&
5067       gtk_cairo_should_draw_window (cr, tree_view->priv->drag_window))
5068     {
5069       gtk_container_propagate_draw (GTK_CONTAINER (tree_view),
5070                                     tree_view->priv->drag_column->button,
5071                                     cr);
5072     }
5073
5074   return TRUE;
5075 }
5076
5077 enum
5078 {
5079   DROP_HOME,
5080   DROP_RIGHT,
5081   DROP_LEFT,
5082   DROP_END
5083 };
5084
5085 /* returns 0x1 when no column has been found -- yes it's hackish */
5086 static GtkTreeViewColumn *
5087 gtk_tree_view_get_drop_column (GtkTreeView       *tree_view,
5088                                GtkTreeViewColumn *column,
5089                                gint               drop_position)
5090 {
5091   GtkTreeViewColumn *left_column = NULL;
5092   GtkTreeViewColumn *cur_column = NULL;
5093   GList *tmp_list;
5094
5095   if (!column->reorderable)
5096     return (GtkTreeViewColumn *)0x1;
5097
5098   switch (drop_position)
5099     {
5100       case DROP_HOME:
5101         /* find first column where we can drop */
5102         tmp_list = tree_view->priv->columns;
5103         if (column == GTK_TREE_VIEW_COLUMN (tmp_list->data))
5104           return (GtkTreeViewColumn *)0x1;
5105
5106         while (tmp_list)
5107           {
5108             g_assert (tmp_list);
5109
5110             cur_column = GTK_TREE_VIEW_COLUMN (tmp_list->data);
5111             tmp_list = tmp_list->next;
5112
5113             if (left_column && left_column->visible == FALSE)
5114               continue;
5115
5116             if (!tree_view->priv->column_drop_func)
5117               return left_column;
5118
5119             if (!tree_view->priv->column_drop_func (tree_view, column, left_column, cur_column, tree_view->priv->column_drop_func_data))
5120               {
5121                 left_column = cur_column;
5122                 continue;
5123               }
5124
5125             return left_column;
5126           }
5127
5128         if (!tree_view->priv->column_drop_func)
5129           return left_column;
5130
5131         if (tree_view->priv->column_drop_func (tree_view, column, left_column, NULL, tree_view->priv->column_drop_func_data))
5132           return left_column;
5133         else
5134           return (GtkTreeViewColumn *)0x1;
5135         break;
5136
5137       case DROP_RIGHT:
5138         /* find first column after column where we can drop */
5139         tmp_list = tree_view->priv->columns;
5140
5141         for (; tmp_list; tmp_list = tmp_list->next)
5142           if (GTK_TREE_VIEW_COLUMN (tmp_list->data) == column)
5143             break;
5144
5145         if (!tmp_list || !tmp_list->next)
5146           return (GtkTreeViewColumn *)0x1;
5147
5148         tmp_list = tmp_list->next;
5149         left_column = GTK_TREE_VIEW_COLUMN (tmp_list->data);
5150         tmp_list = tmp_list->next;
5151
5152         while (tmp_list)
5153           {
5154             g_assert (tmp_list);
5155
5156             cur_column = GTK_TREE_VIEW_COLUMN (tmp_list->data);
5157             tmp_list = tmp_list->next;
5158
5159             if (left_column && left_column->visible == FALSE)
5160               {
5161                 left_column = cur_column;
5162                 if (tmp_list)
5163                   tmp_list = tmp_list->next;
5164                 continue;
5165               }
5166
5167             if (!tree_view->priv->column_drop_func)
5168               return left_column;
5169
5170             if (!tree_view->priv->column_drop_func (tree_view, column, left_column, cur_column, tree_view->priv->column_drop_func_data))
5171               {
5172                 left_column = cur_column;
5173                 continue;
5174               }
5175
5176             return left_column;
5177           }
5178
5179         if (!tree_view->priv->column_drop_func)
5180           return left_column;
5181
5182         if (tree_view->priv->column_drop_func (tree_view, column, left_column, NULL, tree_view->priv->column_drop_func_data))
5183           return left_column;
5184         else
5185           return (GtkTreeViewColumn *)0x1;
5186         break;
5187
5188       case DROP_LEFT:
5189         /* find first column before column where we can drop */
5190         tmp_list = tree_view->priv->columns;
5191
5192         for (; tmp_list; tmp_list = tmp_list->next)
5193           if (GTK_TREE_VIEW_COLUMN (tmp_list->data) == column)
5194             break;
5195
5196         if (!tmp_list || !tmp_list->prev)
5197           return (GtkTreeViewColumn *)0x1;
5198
5199         tmp_list = tmp_list->prev;
5200         cur_column = GTK_TREE_VIEW_COLUMN (tmp_list->data);
5201         tmp_list = tmp_list->prev;
5202
5203         while (tmp_list)
5204           {
5205             g_assert (tmp_list);
5206
5207             left_column = GTK_TREE_VIEW_COLUMN (tmp_list->data);
5208
5209             if (left_column && !left_column->visible)
5210               {
5211                 /*if (!tmp_list->prev)
5212                   return (GtkTreeViewColumn *)0x1;
5213                   */
5214 /*
5215                 cur_column = GTK_TREE_VIEW_COLUMN (tmp_list->prev->data);
5216                 tmp_list = tmp_list->prev->prev;
5217                 continue;*/
5218
5219                 cur_column = left_column;
5220                 if (tmp_list)
5221                   tmp_list = tmp_list->prev;
5222                 continue;
5223               }
5224
5225             if (!tree_view->priv->column_drop_func)
5226               return left_column;
5227
5228             if (tree_view->priv->column_drop_func (tree_view, column, left_column, cur_column, tree_view->priv->column_drop_func_data))
5229               return left_column;
5230
5231             cur_column = left_column;
5232             tmp_list = tmp_list->prev;
5233           }
5234
5235         if (!tree_view->priv->column_drop_func)
5236           return NULL;
5237
5238         if (tree_view->priv->column_drop_func (tree_view, column, NULL, cur_column, tree_view->priv->column_drop_func_data))
5239           return NULL;
5240         else
5241           return (GtkTreeViewColumn *)0x1;
5242         break;
5243
5244       case DROP_END:
5245         /* same as DROP_HOME case, but doing it backwards */
5246         tmp_list = g_list_last (tree_view->priv->columns);
5247         cur_column = NULL;
5248
5249         if (column == GTK_TREE_VIEW_COLUMN (tmp_list->data))
5250           return (GtkTreeViewColumn *)0x1;
5251
5252         while (tmp_list)
5253           {
5254             g_assert (tmp_list);
5255
5256             left_column = GTK_TREE_VIEW_COLUMN (tmp_list->data);
5257
5258             if (left_column && !left_column->visible)
5259               {
5260                 cur_column = left_column;
5261                 tmp_list = tmp_list->prev;
5262               }
5263
5264             if (!tree_view->priv->column_drop_func)
5265               return left_column;
5266
5267             if (tree_view->priv->column_drop_func (tree_view, column, left_column, cur_column, tree_view->priv->column_drop_func_data))
5268               return left_column;
5269
5270             cur_column = left_column;
5271             tmp_list = tmp_list->prev;
5272           }
5273
5274         if (!tree_view->priv->column_drop_func)
5275           return NULL;
5276
5277         if (tree_view->priv->column_drop_func (tree_view, column, NULL, cur_column, tree_view->priv->column_drop_func_data))
5278           return NULL;
5279         else
5280           return (GtkTreeViewColumn *)0x1;
5281         break;
5282     }
5283
5284   return (GtkTreeViewColumn *)0x1;
5285 }
5286
5287 static gboolean
5288 gtk_tree_view_key_press (GtkWidget   *widget,
5289                          GdkEventKey *event)
5290 {
5291   GtkTreeView *tree_view = (GtkTreeView *) widget;
5292
5293   if (tree_view->priv->rubber_band_status)
5294     {
5295       if (event->keyval == GDK_KEY_Escape)
5296         gtk_tree_view_stop_rubber_band (tree_view);
5297
5298       return TRUE;
5299     }
5300
5301   if (GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_IN_COLUMN_DRAG))
5302     {
5303       if (event->keyval == GDK_KEY_Escape)
5304         {
5305           tree_view->priv->cur_reorder = NULL;
5306           gtk_tree_view_button_release_drag_column (widget, NULL);
5307         }
5308       return TRUE;
5309     }
5310
5311   if (GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_HEADERS_VISIBLE))
5312     {
5313       GList *focus_column;
5314       gboolean rtl;
5315
5316       rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
5317
5318       for (focus_column = tree_view->priv->columns;
5319            focus_column;
5320            focus_column = focus_column->next)
5321         {
5322           GtkTreeViewColumn *column = GTK_TREE_VIEW_COLUMN (focus_column->data);
5323
5324           if (gtk_widget_has_focus (column->button))
5325             break;
5326         }
5327
5328       if (focus_column &&
5329           (event->state & GDK_SHIFT_MASK) && (event->state & GDK_MOD1_MASK) &&
5330           (event->keyval == GDK_KEY_Left || event->keyval == GDK_KEY_KP_Left
5331            || event->keyval == GDK_KEY_Right || event->keyval == GDK_KEY_KP_Right))
5332         {
5333           GtkTreeViewColumn *column = GTK_TREE_VIEW_COLUMN (focus_column->data);
5334
5335           if (!column->resizable)
5336             {
5337               gtk_widget_error_bell (widget);
5338               return TRUE;
5339             }
5340
5341           if (event->keyval == (rtl ? GDK_KEY_Right : GDK_KEY_Left)
5342               || event->keyval == (rtl ? GDK_KEY_KP_Right : GDK_KEY_KP_Left))
5343             {
5344               GtkRequisition button_req;
5345               gint old_width = column->resized_width;
5346
5347               gtk_widget_get_preferred_size (column->button, &button_req, NULL);
5348
5349               column->resized_width = MAX (column->resized_width,
5350                                            column->width);
5351               column->resized_width -= 2;
5352               if (column->resized_width < 0)
5353                 column->resized_width = 0;
5354
5355               if (column->min_width == -1)
5356                 column->resized_width = MAX (button_req.width,
5357                                              column->resized_width);
5358               else
5359                 {
5360                   column->resized_width = MAX (column->min_width,
5361                                                column->resized_width);
5362                 }
5363
5364               if (column->max_width != -1)
5365                 column->resized_width = MIN (column->resized_width,
5366                                              column->max_width);
5367
5368               column->use_resized_width = TRUE;
5369
5370               if (column->resized_width != old_width)
5371                 gtk_widget_queue_resize (widget);
5372               else
5373                 gtk_widget_error_bell (widget);
5374             }
5375           else if (event->keyval == (rtl ? GDK_KEY_Left : GDK_KEY_Right)
5376                    || event->keyval == (rtl ? GDK_KEY_KP_Left : GDK_KEY_KP_Right))
5377             {
5378               gint old_width = column->resized_width;
5379
5380               column->resized_width = MAX (column->resized_width,
5381                                            column->width);
5382               column->resized_width += 2;
5383
5384               if (column->max_width != -1)
5385                 column->resized_width = MIN (column->resized_width,
5386                                              column->max_width);
5387
5388               column->use_resized_width = TRUE;
5389
5390               if (column->resized_width != old_width)
5391                 gtk_widget_queue_resize (widget);
5392               else
5393                 gtk_widget_error_bell (widget);
5394             }
5395
5396           return TRUE;
5397         }
5398
5399       if (focus_column &&
5400           (event->state & GDK_MOD1_MASK) &&
5401           (event->keyval == GDK_KEY_Left || event->keyval == GDK_KEY_KP_Left
5402            || event->keyval == GDK_KEY_Right || event->keyval == GDK_KEY_KP_Right
5403            || event->keyval == GDK_KEY_Home || event->keyval == GDK_KEY_KP_Home
5404            || event->keyval == GDK_KEY_End || event->keyval == GDK_KEY_KP_End))
5405         {
5406           GtkTreeViewColumn *column = GTK_TREE_VIEW_COLUMN (focus_column->data);
5407
5408           if (event->keyval == (rtl ? GDK_KEY_Right : GDK_KEY_Left)
5409               || event->keyval == (rtl ? GDK_KEY_KP_Right : GDK_KEY_KP_Left))
5410             {
5411               GtkTreeViewColumn *col;
5412               col = gtk_tree_view_get_drop_column (tree_view, column, DROP_LEFT);
5413               if (col != (GtkTreeViewColumn *)0x1)
5414                 gtk_tree_view_move_column_after (tree_view, column, col);
5415               else
5416                 gtk_widget_error_bell (widget);
5417             }
5418           else if (event->keyval == (rtl ? GDK_KEY_Left : GDK_KEY_Right)
5419                    || event->keyval == (rtl ? GDK_KEY_KP_Left : GDK_KEY_KP_Right))
5420             {
5421               GtkTreeViewColumn *col;
5422               col = gtk_tree_view_get_drop_column (tree_view, column, DROP_RIGHT);
5423               if (col != (GtkTreeViewColumn *)0x1)
5424                 gtk_tree_view_move_column_after (tree_view, column, col);
5425               else
5426                 gtk_widget_error_bell (widget);
5427             }
5428           else if (event->keyval == GDK_KEY_Home || event->keyval == GDK_KEY_KP_Home)
5429             {
5430               GtkTreeViewColumn *col;
5431               col = gtk_tree_view_get_drop_column (tree_view, column, DROP_HOME);
5432               if (col != (GtkTreeViewColumn *)0x1)
5433                 gtk_tree_view_move_column_after (tree_view, column, col);
5434               else
5435                 gtk_widget_error_bell (widget);
5436             }
5437           else if (event->keyval == GDK_KEY_End || event->keyval == GDK_KEY_KP_End)
5438             {
5439               GtkTreeViewColumn *col;
5440               col = gtk_tree_view_get_drop_column (tree_view, column, DROP_END);
5441               if (col != (GtkTreeViewColumn *)0x1)
5442                 gtk_tree_view_move_column_after (tree_view, column, col);
5443               else
5444                 gtk_widget_error_bell (widget);
5445             }
5446
5447           return TRUE;
5448         }
5449     }
5450
5451   /* Chain up to the parent class.  It handles the keybindings. */
5452   if (GTK_WIDGET_CLASS (gtk_tree_view_parent_class)->key_press_event (widget, event))
5453     return TRUE;
5454
5455   if (tree_view->priv->search_entry_avoid_unhandled_binding)
5456     {
5457       tree_view->priv->search_entry_avoid_unhandled_binding = FALSE;
5458       return FALSE;
5459     }
5460
5461   /* We pass the event to the search_entry.  If its text changes, then we start
5462    * the typeahead find capabilities. */
5463   if (gtk_widget_has_focus (GTK_WIDGET (tree_view))
5464       && tree_view->priv->enable_search
5465       && !tree_view->priv->search_custom_entry_set)
5466     {
5467       GdkEvent *new_event;
5468       char *old_text;
5469       const char *new_text;
5470       gboolean retval;
5471       GdkScreen *screen;
5472       gboolean text_modified;
5473       gulong popup_menu_id;
5474
5475       gtk_tree_view_ensure_interactive_directory (tree_view);
5476
5477       /* Make a copy of the current text */
5478       old_text = g_strdup (gtk_entry_get_text (GTK_ENTRY (tree_view->priv->search_entry)));
5479       new_event = gdk_event_copy ((GdkEvent *) event);
5480       g_object_unref (((GdkEventKey *) new_event)->window);
5481       ((GdkEventKey *) new_event)->window = g_object_ref (gtk_widget_get_window (tree_view->priv->search_window));
5482       gtk_widget_realize (tree_view->priv->search_window);
5483
5484       popup_menu_id = g_signal_connect (tree_view->priv->search_entry,
5485                                         "popup-menu", G_CALLBACK (gtk_true),
5486                                         NULL);
5487
5488       /* Move the entry off screen */
5489       screen = gtk_widget_get_screen (GTK_WIDGET (tree_view));
5490       gtk_window_move (GTK_WINDOW (tree_view->priv->search_window),
5491                        gdk_screen_get_width (screen) + 1,
5492                        gdk_screen_get_height (screen) + 1);
5493       gtk_widget_show (tree_view->priv->search_window);
5494
5495       /* Send the event to the window.  If the preedit_changed signal is emitted
5496        * during this event, we will set priv->imcontext_changed  */
5497       tree_view->priv->imcontext_changed = FALSE;
5498       retval = gtk_widget_event (tree_view->priv->search_window, new_event);
5499       gdk_event_free (new_event);
5500       gtk_widget_hide (tree_view->priv->search_window);
5501
5502       g_signal_handler_disconnect (tree_view->priv->search_entry,
5503                                    popup_menu_id);
5504
5505       /* We check to make sure that the entry tried to handle the text, and that
5506        * the text has changed.
5507        */
5508       new_text = gtk_entry_get_text (GTK_ENTRY (tree_view->priv->search_entry));
5509       text_modified = strcmp (old_text, new_text) != 0;
5510       g_free (old_text);
5511       if (tree_view->priv->imcontext_changed ||    /* we're in a preedit */
5512           (retval && text_modified))               /* ...or the text was modified */
5513         {
5514           if (gtk_tree_view_real_start_interactive_search (tree_view,
5515                                                            gdk_event_get_device ((GdkEvent *) event),
5516                                                            FALSE))
5517             {
5518               gtk_widget_grab_focus (GTK_WIDGET (tree_view));
5519               return TRUE;
5520             }
5521           else
5522             {
5523               gtk_entry_set_text (GTK_ENTRY (tree_view->priv->search_entry), "");
5524               return FALSE;
5525             }
5526         }
5527     }
5528
5529   return FALSE;
5530 }
5531
5532 static gboolean
5533 gtk_tree_view_key_release (GtkWidget   *widget,
5534                            GdkEventKey *event)
5535 {
5536   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
5537
5538   if (tree_view->priv->rubber_band_status)
5539     return TRUE;
5540
5541   return GTK_WIDGET_CLASS (gtk_tree_view_parent_class)->key_release_event (widget, event);
5542 }
5543
5544 /* FIXME Is this function necessary? Can I get an enter_notify event
5545  * w/o either an expose event or a mouse motion event?
5546  */
5547 static gboolean
5548 gtk_tree_view_enter_notify (GtkWidget        *widget,
5549                             GdkEventCrossing *event)
5550 {
5551   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
5552   GtkRBTree *tree;
5553   GtkRBNode *node;
5554   gint new_y;
5555
5556   /* Sanity check it */
5557   if (event->window != tree_view->priv->bin_window)
5558     return FALSE;
5559
5560   if (tree_view->priv->tree == NULL)
5561     return FALSE;
5562
5563   if (event->mode == GDK_CROSSING_GRAB ||
5564       event->mode == GDK_CROSSING_GTK_GRAB ||
5565       event->mode == GDK_CROSSING_GTK_UNGRAB ||
5566       event->mode == GDK_CROSSING_STATE_CHANGED)
5567     return TRUE;
5568
5569   /* find the node internally */
5570   new_y = TREE_WINDOW_Y_TO_RBTREE_Y(tree_view, event->y);
5571   if (new_y < 0)
5572     new_y = 0;
5573   _gtk_rbtree_find_offset (tree_view->priv->tree, new_y, &tree, &node);
5574
5575   tree_view->priv->event_last_x = event->x;
5576   tree_view->priv->event_last_y = event->y;
5577
5578   if ((tree_view->priv->button_pressed_node == NULL) ||
5579       (tree_view->priv->button_pressed_node == node))
5580     prelight_or_select (tree_view, tree, node, event->x, event->y);
5581
5582   return TRUE;
5583 }
5584
5585 static gboolean
5586 gtk_tree_view_leave_notify (GtkWidget        *widget,
5587                             GdkEventCrossing *event)
5588 {
5589   GtkTreeView *tree_view;
5590
5591   if (event->mode == GDK_CROSSING_GRAB)
5592     return TRUE;
5593
5594   tree_view = GTK_TREE_VIEW (widget);
5595
5596   if (tree_view->priv->prelight_node)
5597     _gtk_tree_view_queue_draw_node (tree_view,
5598                                    tree_view->priv->prelight_tree,
5599                                    tree_view->priv->prelight_node,
5600                                    NULL);
5601
5602   tree_view->priv->event_last_x = -10000;
5603   tree_view->priv->event_last_y = -10000;
5604
5605   prelight_or_select (tree_view,
5606                       NULL, NULL,
5607                       -1000, -1000); /* coords not possibly over an arrow */
5608
5609   return TRUE;
5610 }
5611
5612
5613 static gint
5614 gtk_tree_view_focus_out (GtkWidget     *widget,
5615                          GdkEventFocus *event)
5616 {
5617   GtkTreeView *tree_view;
5618
5619   tree_view = GTK_TREE_VIEW (widget);
5620
5621   gtk_widget_queue_draw (widget);
5622
5623   /* destroy interactive search dialog */
5624   if (tree_view->priv->search_window)
5625     gtk_tree_view_search_dialog_hide (tree_view->priv->search_window, tree_view,
5626                                       gdk_event_get_device ((GdkEvent *) event));
5627
5628   return FALSE;
5629 }
5630
5631
5632 /* Incremental Reflow
5633  */
5634
5635 static void
5636 gtk_tree_view_node_queue_redraw (GtkTreeView *tree_view,
5637                                  GtkRBTree   *tree,
5638                                  GtkRBNode   *node)
5639 {
5640   GtkAllocation allocation;
5641   gint y;
5642
5643   y = _gtk_rbtree_node_find_offset (tree, node)
5644     - tree_view->priv->vadjustment->value
5645     + TREE_VIEW_HEADER_HEIGHT (tree_view);
5646
5647   gtk_widget_get_allocation (GTK_WIDGET (tree_view), &allocation);
5648   gtk_widget_queue_draw_area (GTK_WIDGET (tree_view),
5649                               0, y,
5650                               allocation.width,
5651                               GTK_RBNODE_GET_HEIGHT (node));
5652 }
5653
5654 static gboolean
5655 node_is_visible (GtkTreeView *tree_view,
5656                  GtkRBTree   *tree,
5657                  GtkRBNode   *node)
5658 {
5659   int y;
5660   int height;
5661
5662   y = _gtk_rbtree_node_find_offset (tree, node);
5663   height = ROW_HEIGHT (tree_view, GTK_RBNODE_GET_HEIGHT (node));
5664
5665   if (y >= tree_view->priv->vadjustment->value &&
5666       y + height <= (tree_view->priv->vadjustment->value
5667                      + tree_view->priv->vadjustment->page_size))
5668     return TRUE;
5669
5670   return FALSE;
5671 }
5672
5673 /* Returns TRUE if it updated the size
5674  */
5675 static gboolean
5676 validate_row (GtkTreeView *tree_view,
5677               GtkRBTree   *tree,
5678               GtkRBNode   *node,
5679               GtkTreeIter *iter,
5680               GtkTreePath *path)
5681 {
5682   GtkTreeViewColumn *column;
5683   GList *list, *first_column, *last_column;
5684   gint height = 0;
5685   gint horizontal_separator;
5686   gint vertical_separator;
5687   gint focus_line_width;
5688   gint depth = gtk_tree_path_get_depth (path);
5689   gboolean retval = FALSE;
5690   gboolean is_separator = FALSE;
5691   gboolean draw_vgrid_lines, draw_hgrid_lines;
5692   gint focus_pad;
5693   gint grid_line_width;
5694   gboolean wide_separators;
5695   gint separator_height;
5696
5697   /* double check the row needs validating */
5698   if (! GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_INVALID) &&
5699       ! GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_COLUMN_INVALID))
5700     return FALSE;
5701
5702   is_separator = row_is_separator (tree_view, iter, NULL);
5703
5704   gtk_widget_style_get (GTK_WIDGET (tree_view),
5705                         "focus-padding", &focus_pad,
5706                         "focus-line-width", &focus_line_width,
5707                         "horizontal-separator", &horizontal_separator,
5708                         "vertical-separator", &vertical_separator,
5709                         "grid-line-width", &grid_line_width,
5710                         "wide-separators",  &wide_separators,
5711                         "separator-height", &separator_height,
5712                         NULL);
5713
5714   draw_vgrid_lines =
5715     tree_view->priv->grid_lines == GTK_TREE_VIEW_GRID_LINES_VERTICAL
5716     || tree_view->priv->grid_lines == GTK_TREE_VIEW_GRID_LINES_BOTH;
5717   draw_hgrid_lines =
5718     tree_view->priv->grid_lines == GTK_TREE_VIEW_GRID_LINES_HORIZONTAL
5719     || tree_view->priv->grid_lines == GTK_TREE_VIEW_GRID_LINES_BOTH;
5720
5721   for (last_column = g_list_last (tree_view->priv->columns);
5722        last_column && !(GTK_TREE_VIEW_COLUMN (last_column->data)->visible);
5723        last_column = last_column->prev)
5724     ;
5725
5726   for (first_column = g_list_first (tree_view->priv->columns);
5727        first_column && !(GTK_TREE_VIEW_COLUMN (first_column->data)->visible);
5728        first_column = first_column->next)
5729     ;
5730
5731   for (list = tree_view->priv->columns; list; list = list->next)
5732     {
5733       gint tmp_width;
5734       gint tmp_height;
5735
5736       column = list->data;
5737
5738       if (! column->visible)
5739         continue;
5740
5741       if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_COLUMN_INVALID) && !column->dirty)
5742         continue;
5743
5744       gtk_tree_view_column_cell_set_cell_data (column, tree_view->priv->model, iter,
5745                                                GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT),
5746                                                node->children?TRUE:FALSE);
5747       gtk_tree_view_column_cell_get_size (column,
5748                                           NULL, NULL, NULL,
5749                                           &tmp_width, &tmp_height);
5750
5751       if (!is_separator)
5752         {
5753           tmp_height += vertical_separator;
5754           height = MAX (height, tmp_height);
5755           height = MAX (height, tree_view->priv->expander_size);
5756         }
5757       else
5758         {
5759           if (wide_separators)
5760             height = separator_height + 2 * focus_pad;
5761           else
5762             height = 2 + 2 * focus_pad;
5763         }
5764
5765       if (gtk_tree_view_is_expander_column (tree_view, column))
5766         {
5767           tmp_width = tmp_width + horizontal_separator + (depth - 1) * tree_view->priv->level_indentation;
5768
5769           if (TREE_VIEW_DRAW_EXPANDERS (tree_view))
5770             tmp_width += depth * tree_view->priv->expander_size;
5771         }
5772       else
5773         tmp_width = tmp_width + horizontal_separator;
5774
5775       if (draw_vgrid_lines)
5776         {
5777           if (list->data == first_column || list->data == last_column)
5778             tmp_width += grid_line_width / 2.0;
5779           else
5780             tmp_width += grid_line_width;
5781         }
5782
5783       if (tmp_width > column->requested_width)
5784         {
5785           retval = TRUE;
5786           column->requested_width = tmp_width;
5787         }
5788     }
5789
5790   if (draw_hgrid_lines)
5791     height += grid_line_width;
5792
5793   if (height != GTK_RBNODE_GET_HEIGHT (node))
5794     {
5795       retval = TRUE;
5796       _gtk_rbtree_node_set_height (tree, node, height);
5797     }
5798   _gtk_rbtree_node_mark_valid (tree, node);
5799   tree_view->priv->post_validation_flag = TRUE;
5800
5801   return retval;
5802 }
5803
5804
5805 static void
5806 validate_visible_area (GtkTreeView *tree_view)
5807 {
5808   GtkAllocation allocation;
5809   GtkTreePath *path = NULL;
5810   GtkTreePath *above_path = NULL;
5811   GtkTreeIter iter;
5812   GtkRBTree *tree = NULL;
5813   GtkRBNode *node = NULL;
5814   gboolean need_redraw = FALSE;
5815   gboolean size_changed = FALSE;
5816   gint total_height;
5817   gint area_above = 0;
5818   gint area_below = 0;
5819
5820   if (tree_view->priv->tree == NULL)
5821     return;
5822
5823   if (! GTK_RBNODE_FLAG_SET (tree_view->priv->tree->root, GTK_RBNODE_DESCENDANTS_INVALID) &&
5824       tree_view->priv->scroll_to_path == NULL)
5825     return;
5826
5827   gtk_widget_get_allocation (GTK_WIDGET (tree_view), &allocation);
5828   total_height = allocation.height - TREE_VIEW_HEADER_HEIGHT (tree_view);
5829
5830   if (total_height == 0)
5831     return;
5832
5833   /* First, we check to see if we need to scroll anywhere
5834    */
5835   if (tree_view->priv->scroll_to_path)
5836     {
5837       path = gtk_tree_row_reference_get_path (tree_view->priv->scroll_to_path);
5838       if (path && !_gtk_tree_view_find_node (tree_view, path, &tree, &node))
5839         {
5840           /* we are going to scroll, and will update dy */
5841           gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
5842           if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_INVALID) ||
5843               GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_COLUMN_INVALID))
5844             {
5845               _gtk_tree_view_queue_draw_node (tree_view, tree, node, NULL);
5846               if (validate_row (tree_view, tree, node, &iter, path))
5847                 size_changed = TRUE;
5848             }
5849
5850           if (tree_view->priv->scroll_to_use_align)
5851             {
5852               gint height = ROW_HEIGHT (tree_view, GTK_RBNODE_GET_HEIGHT (node));
5853               area_above = (total_height - height) *
5854                 tree_view->priv->scroll_to_row_align;
5855               area_below = total_height - area_above - height;
5856               area_above = MAX (area_above, 0);
5857               area_below = MAX (area_below, 0);
5858             }
5859           else
5860             {
5861               /* two cases:
5862                * 1) row not visible
5863                * 2) row visible
5864                */
5865               gint dy;
5866               gint height = ROW_HEIGHT (tree_view, GTK_RBNODE_GET_HEIGHT (node));
5867
5868               dy = _gtk_rbtree_node_find_offset (tree, node);
5869
5870               if (dy >= tree_view->priv->vadjustment->value &&
5871                   dy + height <= (tree_view->priv->vadjustment->value
5872                                   + tree_view->priv->vadjustment->page_size))
5873                 {
5874                   /* row visible: keep the row at the same position */
5875                   area_above = dy - tree_view->priv->vadjustment->value;
5876                   area_below = (tree_view->priv->vadjustment->value +
5877                                 tree_view->priv->vadjustment->page_size)
5878                                - dy - height;
5879                 }
5880               else
5881                 {
5882                   /* row not visible */
5883                   if (dy >= 0
5884                       && dy + height <= tree_view->priv->vadjustment->page_size)
5885                     {
5886                       /* row at the beginning -- fixed */
5887                       area_above = dy;
5888                       area_below = tree_view->priv->vadjustment->page_size
5889                                    - area_above - height;
5890                     }
5891                   else if (dy >= (tree_view->priv->vadjustment->upper -
5892                                   tree_view->priv->vadjustment->page_size))
5893                     {
5894                       /* row at the end -- fixed */
5895                       area_above = dy - (tree_view->priv->vadjustment->upper -
5896                                    tree_view->priv->vadjustment->page_size);
5897                       area_below = tree_view->priv->vadjustment->page_size -
5898                                    area_above - height;
5899
5900                       if (area_below < 0)
5901                         {
5902                           area_above = tree_view->priv->vadjustment->page_size - height;
5903                           area_below = 0;
5904                         }
5905                     }
5906                   else
5907                     {
5908                       /* row somewhere in the middle, bring it to the top
5909                        * of the view
5910                        */
5911                       area_above = 0;
5912                       area_below = total_height - height;
5913                     }
5914                 }
5915             }
5916         }
5917       else
5918         /* the scroll to isn't valid; ignore it.
5919          */
5920         {
5921           if (tree_view->priv->scroll_to_path && !path)
5922             {
5923               gtk_tree_row_reference_free (tree_view->priv->scroll_to_path);
5924               tree_view->priv->scroll_to_path = NULL;
5925             }
5926           if (path)
5927             gtk_tree_path_free (path);
5928           path = NULL;
5929         }
5930     }
5931
5932   /* We didn't have a scroll_to set, so we just handle things normally
5933    */
5934   if (path == NULL)
5935     {
5936       gint offset;
5937
5938       offset = _gtk_rbtree_find_offset (tree_view->priv->tree,
5939                                         TREE_WINDOW_Y_TO_RBTREE_Y (tree_view, 0),
5940                                         &tree, &node);
5941       if (node == NULL)
5942         {
5943           /* In this case, nothing has been validated */
5944           path = gtk_tree_path_new_first ();
5945           _gtk_tree_view_find_node (tree_view, path, &tree, &node);
5946         }
5947       else
5948         {
5949           path = _gtk_tree_view_find_path (tree_view, tree, node);
5950           total_height += offset;
5951         }
5952
5953       gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
5954
5955       if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_INVALID) ||
5956           GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_COLUMN_INVALID))
5957         {
5958           _gtk_tree_view_queue_draw_node (tree_view, tree, node, NULL);
5959           if (validate_row (tree_view, tree, node, &iter, path))
5960             size_changed = TRUE;
5961         }
5962       area_above = 0;
5963       area_below = total_height - ROW_HEIGHT (tree_view, GTK_RBNODE_GET_HEIGHT (node));
5964     }
5965
5966   above_path = gtk_tree_path_copy (path);
5967
5968   /* if we do not validate any row above the new top_row, we will make sure
5969    * that the row immediately above top_row has been validated. (if we do not
5970    * do this, _gtk_rbtree_find_offset will find the row above top_row, because
5971    * when invalidated that row's height will be zero. and this will mess up
5972    * scrolling).
5973    */
5974   if (area_above == 0)
5975     {
5976       GtkRBTree *tmptree;
5977       GtkRBNode *tmpnode;
5978
5979       _gtk_tree_view_find_node (tree_view, above_path, &tmptree, &tmpnode);
5980       _gtk_rbtree_prev_full (tmptree, tmpnode, &tmptree, &tmpnode);
5981
5982       if (tmpnode)
5983         {
5984           GtkTreePath *tmppath;
5985           GtkTreeIter tmpiter;
5986
5987           tmppath = _gtk_tree_view_find_path (tree_view, tmptree, tmpnode);
5988           gtk_tree_model_get_iter (tree_view->priv->model, &tmpiter, tmppath);
5989
5990           if (GTK_RBNODE_FLAG_SET (tmpnode, GTK_RBNODE_INVALID) ||
5991               GTK_RBNODE_FLAG_SET (tmpnode, GTK_RBNODE_COLUMN_INVALID))
5992             {
5993               _gtk_tree_view_queue_draw_node (tree_view, tmptree, tmpnode, NULL);
5994               if (validate_row (tree_view, tmptree, tmpnode, &tmpiter, tmppath))
5995                 size_changed = TRUE;
5996             }
5997
5998           gtk_tree_path_free (tmppath);
5999         }
6000     }
6001
6002   /* Now, we walk forwards and backwards, measuring rows. Unfortunately,
6003    * backwards is much slower then forward, as there is no iter_prev function.
6004    * We go forwards first in case we run out of tree.  Then we go backwards to
6005    * fill out the top.
6006    */
6007   while (node && area_below > 0)
6008     {
6009       if (node->children)
6010         {
6011           GtkTreeIter parent = iter;
6012           gboolean has_child;
6013
6014           tree = node->children;
6015           node = tree->root;
6016
6017           g_assert (node != tree->nil);
6018
6019           while (node->left != tree->nil)
6020             node = node->left;
6021           has_child = gtk_tree_model_iter_children (tree_view->priv->model,
6022                                                     &iter,
6023                                                     &parent);
6024           TREE_VIEW_INTERNAL_ASSERT_VOID (has_child);
6025           gtk_tree_path_down (path);
6026         }
6027       else
6028         {
6029           gboolean done = FALSE;
6030           do
6031             {
6032               node = _gtk_rbtree_next (tree, node);
6033               if (node != NULL)
6034                 {
6035                   gboolean has_next = gtk_tree_model_iter_next (tree_view->priv->model, &iter);
6036                   done = TRUE;
6037                   gtk_tree_path_next (path);
6038
6039                   /* Sanity Check! */
6040                   TREE_VIEW_INTERNAL_ASSERT_VOID (has_next);
6041                 }
6042               else
6043                 {
6044                   GtkTreeIter parent_iter = iter;
6045                   gboolean has_parent;
6046
6047                   node = tree->parent_node;
6048                   tree = tree->parent_tree;
6049                   if (tree == NULL)
6050                     break;
6051                   has_parent = gtk_tree_model_iter_parent (tree_view->priv->model,
6052                                                            &iter,
6053                                                            &parent_iter);
6054                   gtk_tree_path_up (path);
6055
6056                   /* Sanity check */
6057                   TREE_VIEW_INTERNAL_ASSERT_VOID (has_parent);
6058                 }
6059             }
6060           while (!done);
6061         }
6062
6063       if (!node)
6064         break;
6065
6066       if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_INVALID) ||
6067           GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_COLUMN_INVALID))
6068         {
6069           _gtk_tree_view_queue_draw_node (tree_view, tree, node, NULL);
6070           if (validate_row (tree_view, tree, node, &iter, path))
6071               size_changed = TRUE;
6072         }
6073
6074       area_below -= ROW_HEIGHT (tree_view, GTK_RBNODE_GET_HEIGHT (node));
6075     }
6076   gtk_tree_path_free (path);
6077
6078   /* If we ran out of tree, and have extra area_below left, we need to add it
6079    * to area_above */
6080   if (area_below > 0)
6081     area_above += area_below;
6082
6083   _gtk_tree_view_find_node (tree_view, above_path, &tree, &node);
6084
6085   /* We walk backwards */
6086   while (area_above > 0)
6087     {
6088       _gtk_rbtree_prev_full (tree, node, &tree, &node);
6089
6090       /* Always find the new path in the tree.  We cannot just assume
6091        * a gtk_tree_path_prev() is enough here, as there might be children
6092        * in between this node and the previous sibling node.  If this
6093        * appears to be a performance hotspot in profiles, we can look into
6094        * intrigate logic for keeping path, node and iter in sync like
6095        * we do for forward walks.  (Which will be hard because of the lacking
6096        * iter_prev).
6097        */
6098
6099       if (node == NULL)
6100         break;
6101
6102       gtk_tree_path_free (above_path);
6103       above_path = _gtk_tree_view_find_path (tree_view, tree, node);
6104
6105       gtk_tree_model_get_iter (tree_view->priv->model, &iter, above_path);
6106
6107       if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_INVALID) ||
6108           GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_COLUMN_INVALID))
6109         {
6110           _gtk_tree_view_queue_draw_node (tree_view, tree, node, NULL);
6111           if (validate_row (tree_view, tree, node, &iter, above_path))
6112             size_changed = TRUE;
6113         }
6114       area_above -= ROW_HEIGHT (tree_view, GTK_RBNODE_GET_HEIGHT (node));
6115     }
6116
6117   /* if we scrolled to a path, we need to set the dy here,
6118    * and sync the top row accordingly
6119    */
6120   if (tree_view->priv->scroll_to_path)
6121     {
6122       gtk_tree_view_set_top_row (tree_view, above_path, -area_above);
6123       gtk_tree_view_top_row_to_dy (tree_view);
6124
6125       need_redraw = TRUE;
6126     }
6127   else if (tree_view->priv->height <= tree_view->priv->vadjustment->page_size)
6128     {
6129       /* when we are not scrolling, we should never set dy to something
6130        * else than zero. we update top_row to be in sync with dy = 0.
6131        */
6132       gtk_adjustment_set_value (GTK_ADJUSTMENT (tree_view->priv->vadjustment), 0);
6133       gtk_tree_view_dy_to_top_row (tree_view);
6134     }
6135   else if (tree_view->priv->vadjustment->value + tree_view->priv->vadjustment->page_size > tree_view->priv->height)
6136     {
6137       gtk_adjustment_set_value (GTK_ADJUSTMENT (tree_view->priv->vadjustment), tree_view->priv->height - tree_view->priv->vadjustment->page_size);
6138       gtk_tree_view_dy_to_top_row (tree_view);
6139     }
6140   else
6141     gtk_tree_view_top_row_to_dy (tree_view);
6142
6143   /* update width/height and queue a resize */
6144   if (size_changed)
6145     {
6146       GtkRequisition requisition;
6147
6148       /* We temporarily guess a size, under the assumption that it will be the
6149        * same when we get our next size_allocate.  If we don't do this, we'll be
6150        * in an inconsistent state if we call top_row_to_dy. */
6151
6152       gtk_widget_get_preferred_size (GTK_WIDGET (tree_view),
6153                                      &requisition, NULL);
6154       tree_view->priv->hadjustment->upper = MAX (tree_view->priv->hadjustment->upper, (gfloat)requisition.width);
6155       tree_view->priv->vadjustment->upper = MAX (tree_view->priv->vadjustment->upper, (gfloat)requisition.height);
6156       gtk_adjustment_changed (tree_view->priv->hadjustment);
6157       gtk_adjustment_changed (tree_view->priv->vadjustment);
6158       gtk_widget_queue_resize (GTK_WIDGET (tree_view));
6159     }
6160
6161   if (tree_view->priv->scroll_to_path)
6162     {
6163       gtk_tree_row_reference_free (tree_view->priv->scroll_to_path);
6164       tree_view->priv->scroll_to_path = NULL;
6165     }
6166
6167   if (above_path)
6168     gtk_tree_path_free (above_path);
6169
6170   if (tree_view->priv->scroll_to_column)
6171     {
6172       tree_view->priv->scroll_to_column = NULL;
6173     }
6174   if (need_redraw)
6175     gtk_widget_queue_draw (GTK_WIDGET (tree_view));
6176 }
6177
6178 static void
6179 initialize_fixed_height_mode (GtkTreeView *tree_view)
6180 {
6181   if (!tree_view->priv->tree)
6182     return;
6183
6184   if (tree_view->priv->fixed_height < 0)
6185     {
6186       GtkTreeIter iter;
6187       GtkTreePath *path;
6188
6189       GtkRBTree *tree = NULL;
6190       GtkRBNode *node = NULL;
6191
6192       tree = tree_view->priv->tree;
6193       node = tree->root;
6194
6195       path = _gtk_tree_view_find_path (tree_view, tree, node);
6196       gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
6197
6198       validate_row (tree_view, tree, node, &iter, path);
6199
6200       gtk_tree_path_free (path);
6201
6202       tree_view->priv->fixed_height = ROW_HEIGHT (tree_view, GTK_RBNODE_GET_HEIGHT (node));
6203     }
6204
6205    _gtk_rbtree_set_fixed_height (tree_view->priv->tree,
6206                                  tree_view->priv->fixed_height, TRUE);
6207 }
6208
6209 /* Our strategy for finding nodes to validate is a little convoluted.  We find
6210  * the left-most uninvalidated node.  We then try walking right, validating
6211  * nodes.  Once we find a valid node, we repeat the previous process of finding
6212  * the first invalid node.
6213  */
6214
6215 static gboolean
6216 do_validate_rows (GtkTreeView *tree_view, gboolean queue_resize)
6217 {
6218   GtkRBTree *tree = NULL;
6219   GtkRBNode *node = NULL;
6220   gboolean validated_area = FALSE;
6221   gint retval = TRUE;
6222   GtkTreePath *path = NULL;
6223   GtkTreeIter iter;
6224   GTimer *timer;
6225   gint i = 0;
6226
6227   gint prev_height = -1;
6228   gboolean fixed_height = TRUE;
6229
6230   g_assert (tree_view);
6231
6232   if (tree_view->priv->tree == NULL)
6233       return FALSE;
6234
6235   if (tree_view->priv->fixed_height_mode)
6236     {
6237       if (tree_view->priv->fixed_height < 0)
6238         initialize_fixed_height_mode (tree_view);
6239
6240       return FALSE;
6241     }
6242
6243   timer = g_timer_new ();
6244   g_timer_start (timer);
6245
6246   do
6247     {
6248       if (! GTK_RBNODE_FLAG_SET (tree_view->priv->tree->root, GTK_RBNODE_DESCENDANTS_INVALID))
6249         {
6250           retval = FALSE;
6251           goto done;
6252         }
6253
6254       if (path != NULL)
6255         {
6256           node = _gtk_rbtree_next (tree, node);
6257           if (node != NULL)
6258             {
6259               TREE_VIEW_INTERNAL_ASSERT (gtk_tree_model_iter_next (tree_view->priv->model, &iter), FALSE);
6260               gtk_tree_path_next (path);
6261             }
6262           else
6263             {
6264               gtk_tree_path_free (path);
6265               path = NULL;
6266             }
6267         }
6268
6269       if (path == NULL)
6270         {
6271           tree = tree_view->priv->tree;
6272           node = tree_view->priv->tree->root;
6273
6274           g_assert (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_DESCENDANTS_INVALID));
6275
6276           do
6277             {
6278               if (node->left != tree->nil &&
6279                   GTK_RBNODE_FLAG_SET (node->left, GTK_RBNODE_DESCENDANTS_INVALID))
6280                 {
6281                   node = node->left;
6282                 }
6283               else if (node->right != tree->nil &&
6284                        GTK_RBNODE_FLAG_SET (node->right, GTK_RBNODE_DESCENDANTS_INVALID))
6285                 {
6286                   node = node->right;
6287                 }
6288               else if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_INVALID) ||
6289                        GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_COLUMN_INVALID))
6290                 {
6291                   break;
6292                 }
6293               else if (node->children != NULL)
6294                 {
6295                   tree = node->children;
6296                   node = tree->root;
6297                 }
6298               else
6299                 /* RBTree corruption!  All bad */
6300                 g_assert_not_reached ();
6301             }
6302           while (TRUE);
6303           path = _gtk_tree_view_find_path (tree_view, tree, node);
6304           gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
6305         }
6306
6307       validated_area = validate_row (tree_view, tree, node, &iter, path) ||
6308                        validated_area;
6309
6310       if (!tree_view->priv->fixed_height_check)
6311         {
6312           gint height;
6313
6314           height = ROW_HEIGHT (tree_view, GTK_RBNODE_GET_HEIGHT (node));
6315           if (prev_height < 0)
6316             prev_height = height;
6317           else if (prev_height != height)
6318             fixed_height = FALSE;
6319         }
6320
6321       i++;
6322     }
6323   while (g_timer_elapsed (timer, NULL) < GTK_TREE_VIEW_TIME_MS_PER_IDLE / 1000.);
6324
6325   if (!tree_view->priv->fixed_height_check)
6326    {
6327      if (fixed_height)
6328        _gtk_rbtree_set_fixed_height (tree_view->priv->tree, prev_height, FALSE);
6329
6330      tree_view->priv->fixed_height_check = 1;
6331    }
6332
6333  done:
6334   if (validated_area)
6335     {
6336       GtkRequisition requisition;
6337       /* We temporarily guess a size, under the assumption that it will be the
6338        * same when we get our next size_allocate.  If we don't do this, we'll be
6339        * in an inconsistent state when we call top_row_to_dy. */
6340
6341       gtk_widget_get_preferred_size (GTK_WIDGET (tree_view),
6342                                      &requisition, NULL);
6343       tree_view->priv->hadjustment->upper = MAX (tree_view->priv->hadjustment->upper, (gfloat)requisition.width);
6344       tree_view->priv->vadjustment->upper = MAX (tree_view->priv->vadjustment->upper, (gfloat)requisition.height);
6345       gtk_adjustment_changed (tree_view->priv->hadjustment);
6346       gtk_adjustment_changed (tree_view->priv->vadjustment);
6347
6348       if (queue_resize)
6349         gtk_widget_queue_resize (GTK_WIDGET (tree_view));
6350     }
6351
6352   if (path) gtk_tree_path_free (path);
6353   g_timer_destroy (timer);
6354
6355   return retval;
6356 }
6357
6358 static gboolean
6359 validate_rows (GtkTreeView *tree_view)
6360 {
6361   gboolean retval;
6362
6363   retval = do_validate_rows (tree_view, TRUE);
6364
6365   if (! retval && tree_view->priv->validate_rows_timer)
6366     {
6367       g_source_remove (tree_view->priv->validate_rows_timer);
6368       tree_view->priv->validate_rows_timer = 0;
6369     }
6370
6371   return retval;
6372 }
6373
6374 static gboolean
6375 validate_rows_handler (GtkTreeView *tree_view)
6376 {
6377   gboolean retval;
6378
6379   retval = do_validate_rows (tree_view, TRUE);
6380   if (! retval && tree_view->priv->validate_rows_timer)
6381     {
6382       g_source_remove (tree_view->priv->validate_rows_timer);
6383       tree_view->priv->validate_rows_timer = 0;
6384     }
6385
6386   return retval;
6387 }
6388
6389 static gboolean
6390 do_presize_handler (GtkTreeView *tree_view)
6391 {
6392   if (tree_view->priv->mark_rows_col_dirty)
6393     {
6394       if (tree_view->priv->tree)
6395         _gtk_rbtree_column_invalid (tree_view->priv->tree);
6396       tree_view->priv->mark_rows_col_dirty = FALSE;
6397     }
6398   validate_visible_area (tree_view);
6399   tree_view->priv->presize_handler_timer = 0;
6400
6401   if (tree_view->priv->fixed_height_mode)
6402     {
6403       GtkRequisition requisition;
6404
6405       gtk_widget_get_preferred_size (GTK_WIDGET (tree_view),
6406                                      &requisition, NULL);
6407
6408       tree_view->priv->hadjustment->upper = MAX (tree_view->priv->hadjustment->upper, (gfloat)requisition.width);
6409       tree_view->priv->vadjustment->upper = MAX (tree_view->priv->vadjustment->upper, (gfloat)requisition.height);
6410       gtk_adjustment_changed (tree_view->priv->hadjustment);
6411       gtk_adjustment_changed (tree_view->priv->vadjustment);
6412       gtk_widget_queue_resize (GTK_WIDGET (tree_view));
6413     }
6414
6415   return FALSE;
6416 }
6417
6418 static gboolean
6419 presize_handler_callback (gpointer data)
6420 {
6421   do_presize_handler (GTK_TREE_VIEW (data));
6422
6423   return FALSE;
6424 }
6425
6426 static void
6427 install_presize_handler (GtkTreeView *tree_view)
6428 {
6429   if (! gtk_widget_get_realized (GTK_WIDGET (tree_view)))
6430     return;
6431
6432   if (! tree_view->priv->presize_handler_timer)
6433     {
6434       tree_view->priv->presize_handler_timer =
6435         gdk_threads_add_idle_full (GTK_PRIORITY_RESIZE - 2, presize_handler_callback, tree_view, NULL);
6436     }
6437   if (! tree_view->priv->validate_rows_timer)
6438     {
6439       tree_view->priv->validate_rows_timer =
6440         gdk_threads_add_idle_full (GTK_TREE_VIEW_PRIORITY_VALIDATE, (GSourceFunc) validate_rows_handler, tree_view, NULL);
6441     }
6442 }
6443
6444 static gboolean
6445 scroll_sync_handler (GtkTreeView *tree_view)
6446 {
6447   if (tree_view->priv->height <= tree_view->priv->vadjustment->page_size)
6448     gtk_adjustment_set_value (GTK_ADJUSTMENT (tree_view->priv->vadjustment), 0);
6449   else if (gtk_tree_row_reference_valid (tree_view->priv->top_row))
6450     gtk_tree_view_top_row_to_dy (tree_view);
6451   else
6452     gtk_tree_view_dy_to_top_row (tree_view);
6453
6454   tree_view->priv->scroll_sync_timer = 0;
6455
6456   return FALSE;
6457 }
6458
6459 static void
6460 install_scroll_sync_handler (GtkTreeView *tree_view)
6461 {
6462   if (!gtk_widget_get_realized (GTK_WIDGET (tree_view)))
6463     return;
6464
6465   if (!tree_view->priv->scroll_sync_timer)
6466     {
6467       tree_view->priv->scroll_sync_timer =
6468         gdk_threads_add_idle_full (GTK_TREE_VIEW_PRIORITY_SCROLL_SYNC, (GSourceFunc) scroll_sync_handler, tree_view, NULL);
6469     }
6470 }
6471
6472 static void
6473 gtk_tree_view_set_top_row (GtkTreeView *tree_view,
6474                            GtkTreePath *path,
6475                            gint         offset)
6476 {
6477   gtk_tree_row_reference_free (tree_view->priv->top_row);
6478
6479   if (!path)
6480     {
6481       tree_view->priv->top_row = NULL;
6482       tree_view->priv->top_row_dy = 0;
6483     }
6484   else
6485     {
6486       tree_view->priv->top_row = gtk_tree_row_reference_new_proxy (G_OBJECT (tree_view), tree_view->priv->model, path);
6487       tree_view->priv->top_row_dy = offset;
6488     }
6489 }
6490
6491 /* Always call this iff dy is in the visible range.  If the tree is empty, then
6492  * it's set to be NULL, and top_row_dy is 0;
6493  */
6494 static void
6495 gtk_tree_view_dy_to_top_row (GtkTreeView *tree_view)
6496 {
6497   gint offset;
6498   GtkTreePath *path;
6499   GtkRBTree *tree;
6500   GtkRBNode *node;
6501
6502   if (tree_view->priv->tree == NULL)
6503     {
6504       gtk_tree_view_set_top_row (tree_view, NULL, 0);
6505     }
6506   else
6507     {
6508       offset = _gtk_rbtree_find_offset (tree_view->priv->tree,
6509                                         tree_view->priv->dy,
6510                                         &tree, &node);
6511
6512       if (tree == NULL)
6513         {
6514           gtk_tree_view_set_top_row (tree_view, NULL, 0);
6515         }
6516       else
6517         {
6518           path = _gtk_tree_view_find_path (tree_view, tree, node);
6519           gtk_tree_view_set_top_row (tree_view, path, offset);
6520           gtk_tree_path_free (path);
6521         }
6522     }
6523 }
6524
6525 static void
6526 gtk_tree_view_top_row_to_dy (GtkTreeView *tree_view)
6527 {
6528   GtkTreePath *path;
6529   GtkRBTree *tree;
6530   GtkRBNode *node;
6531   int new_dy;
6532
6533   /* Avoid recursive calls */
6534   if (tree_view->priv->in_top_row_to_dy)
6535     return;
6536
6537   if (tree_view->priv->top_row)
6538     path = gtk_tree_row_reference_get_path (tree_view->priv->top_row);
6539   else
6540     path = NULL;
6541
6542   if (!path)
6543     tree = NULL;
6544   else
6545     _gtk_tree_view_find_node (tree_view, path, &tree, &node);
6546
6547   if (path)
6548     gtk_tree_path_free (path);
6549
6550   if (tree == NULL)
6551     {
6552       /* keep dy and set new toprow */
6553       gtk_tree_row_reference_free (tree_view->priv->top_row);
6554       tree_view->priv->top_row = NULL;
6555       tree_view->priv->top_row_dy = 0;
6556       /* DO NOT install the idle handler */
6557       gtk_tree_view_dy_to_top_row (tree_view);
6558       return;
6559     }
6560
6561   if (ROW_HEIGHT (tree_view, BACKGROUND_HEIGHT (node))
6562       < tree_view->priv->top_row_dy)
6563     {
6564       /* new top row -- do NOT install the idle handler */
6565       gtk_tree_view_dy_to_top_row (tree_view);
6566       return;
6567     }
6568
6569   new_dy = _gtk_rbtree_node_find_offset (tree, node);
6570   new_dy += tree_view->priv->top_row_dy;
6571
6572   if (new_dy + tree_view->priv->vadjustment->page_size > tree_view->priv->height)
6573     new_dy = tree_view->priv->height - tree_view->priv->vadjustment->page_size;
6574
6575   new_dy = MAX (0, new_dy);
6576
6577   tree_view->priv->in_top_row_to_dy = TRUE;
6578   gtk_adjustment_set_value (tree_view->priv->vadjustment, (gdouble)new_dy);
6579   tree_view->priv->in_top_row_to_dy = FALSE;
6580 }
6581
6582
6583 void
6584 _gtk_tree_view_install_mark_rows_col_dirty (GtkTreeView *tree_view)
6585 {
6586   tree_view->priv->mark_rows_col_dirty = TRUE;
6587
6588   install_presize_handler (tree_view);
6589 }
6590
6591 /*
6592  * This function works synchronously (due to the while (validate_rows...)
6593  * loop).
6594  *
6595  * There was a check for column_type != GTK_TREE_VIEW_COLUMN_AUTOSIZE
6596  * here. You now need to check that yourself.
6597  */
6598 void
6599 _gtk_tree_view_column_autosize (GtkTreeView *tree_view,
6600                                 GtkTreeViewColumn *column)
6601 {
6602   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
6603   g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (column));
6604
6605   _gtk_tree_view_column_cell_set_dirty (column, FALSE);
6606
6607   do_presize_handler (tree_view);
6608   while (validate_rows (tree_view));
6609
6610   gtk_widget_queue_resize (GTK_WIDGET (tree_view));
6611 }
6612
6613 /* Drag-and-drop */
6614
6615 static void
6616 set_source_row (GdkDragContext *context,
6617                 GtkTreeModel   *model,
6618                 GtkTreePath    *source_row)
6619 {
6620   g_object_set_data_full (G_OBJECT (context),
6621                           I_("gtk-tree-view-source-row"),
6622                           source_row ? gtk_tree_row_reference_new (model, source_row) : NULL,
6623                           (GDestroyNotify) (source_row ? gtk_tree_row_reference_free : NULL));
6624 }
6625
6626 static GtkTreePath*
6627 get_source_row (GdkDragContext *context)
6628 {
6629   GtkTreeRowReference *ref =
6630     g_object_get_data (G_OBJECT (context), "gtk-tree-view-source-row");
6631
6632   if (ref)
6633     return gtk_tree_row_reference_get_path (ref);
6634   else
6635     return NULL;
6636 }
6637
6638 typedef struct
6639 {
6640   GtkTreeRowReference *dest_row;
6641   guint                path_down_mode   : 1;
6642   guint                empty_view_drop  : 1;
6643   guint                drop_append_mode : 1;
6644 }
6645 DestRow;
6646
6647 static void
6648 dest_row_free (gpointer data)
6649 {
6650   DestRow *dr = (DestRow *)data;
6651
6652   gtk_tree_row_reference_free (dr->dest_row);
6653   g_slice_free (DestRow, dr);
6654 }
6655
6656 static void
6657 set_dest_row (GdkDragContext *context,
6658               GtkTreeModel   *model,
6659               GtkTreePath    *dest_row,
6660               gboolean        path_down_mode,
6661               gboolean        empty_view_drop,
6662               gboolean        drop_append_mode)
6663 {
6664   DestRow *dr;
6665
6666   if (!dest_row)
6667     {
6668       g_object_set_data_full (G_OBJECT (context), I_("gtk-tree-view-dest-row"),
6669                               NULL, NULL);
6670       return;
6671     }
6672
6673   dr = g_slice_new (DestRow);
6674
6675   dr->dest_row = gtk_tree_row_reference_new (model, dest_row);
6676   dr->path_down_mode = path_down_mode != FALSE;
6677   dr->empty_view_drop = empty_view_drop != FALSE;
6678   dr->drop_append_mode = drop_append_mode != FALSE;
6679
6680   g_object_set_data_full (G_OBJECT (context), I_("gtk-tree-view-dest-row"),
6681                           dr, (GDestroyNotify) dest_row_free);
6682 }
6683
6684 static GtkTreePath*
6685 get_dest_row (GdkDragContext *context,
6686               gboolean       *path_down_mode)
6687 {
6688   DestRow *dr =
6689     g_object_get_data (G_OBJECT (context), "gtk-tree-view-dest-row");
6690
6691   if (dr)
6692     {
6693       GtkTreePath *path = NULL;
6694
6695       if (path_down_mode)
6696         *path_down_mode = dr->path_down_mode;
6697
6698       if (dr->dest_row)
6699         path = gtk_tree_row_reference_get_path (dr->dest_row);
6700       else if (dr->empty_view_drop)
6701         path = gtk_tree_path_new_from_indices (0, -1);
6702       else
6703         path = NULL;
6704
6705       if (path && dr->drop_append_mode)
6706         gtk_tree_path_next (path);
6707
6708       return path;
6709     }
6710   else
6711     return NULL;
6712 }
6713
6714 /* Get/set whether drag_motion requested the drag data and
6715  * drag_data_received should thus not actually insert the data,
6716  * since the data doesn't result from a drop.
6717  */
6718 static void
6719 set_status_pending (GdkDragContext *context,
6720                     GdkDragAction   suggested_action)
6721 {
6722   g_object_set_data (G_OBJECT (context),
6723                      I_("gtk-tree-view-status-pending"),
6724                      GINT_TO_POINTER (suggested_action));
6725 }
6726
6727 static GdkDragAction
6728 get_status_pending (GdkDragContext *context)
6729 {
6730   return GPOINTER_TO_INT (g_object_get_data (G_OBJECT (context),
6731                                              "gtk-tree-view-status-pending"));
6732 }
6733
6734 static TreeViewDragInfo*
6735 get_info (GtkTreeView *tree_view)
6736 {
6737   return g_object_get_data (G_OBJECT (tree_view), "gtk-tree-view-drag-info");
6738 }
6739
6740 static void
6741 destroy_info (TreeViewDragInfo *di)
6742 {
6743   g_slice_free (TreeViewDragInfo, di);
6744 }
6745
6746 static TreeViewDragInfo*
6747 ensure_info (GtkTreeView *tree_view)
6748 {
6749   TreeViewDragInfo *di;
6750
6751   di = get_info (tree_view);
6752
6753   if (di == NULL)
6754     {
6755       di = g_slice_new0 (TreeViewDragInfo);
6756
6757       g_object_set_data_full (G_OBJECT (tree_view),
6758                               I_("gtk-tree-view-drag-info"),
6759                               di,
6760                               (GDestroyNotify) destroy_info);
6761     }
6762
6763   return di;
6764 }
6765
6766 static void
6767 remove_info (GtkTreeView *tree_view)
6768 {
6769   g_object_set_data (G_OBJECT (tree_view), I_("gtk-tree-view-drag-info"), NULL);
6770 }
6771
6772 #if 0
6773 static gint
6774 drag_scan_timeout (gpointer data)
6775 {
6776   GtkTreeView *tree_view;
6777   gint x, y;
6778   GdkModifierType state;
6779   GtkTreePath *path = NULL;
6780   GtkTreeViewColumn *column = NULL;
6781   GdkRectangle visible_rect;
6782
6783   GDK_THREADS_ENTER ();
6784
6785   tree_view = GTK_TREE_VIEW (data);
6786
6787   gdk_window_get_pointer (tree_view->priv->bin_window,
6788                           &x, &y, &state);
6789
6790   gtk_tree_view_get_visible_rect (tree_view, &visible_rect);
6791
6792   /* See if we are near the edge. */
6793   if ((x - visible_rect.x) < SCROLL_EDGE_SIZE ||
6794       (visible_rect.x + visible_rect.width - x) < SCROLL_EDGE_SIZE ||
6795       (y - visible_rect.y) < SCROLL_EDGE_SIZE ||
6796       (visible_rect.y + visible_rect.height - y) < SCROLL_EDGE_SIZE)
6797     {
6798       gtk_tree_view_get_path_at_pos (tree_view,
6799                                      tree_view->priv->bin_window,
6800                                      x, y,
6801                                      &path,
6802                                      &column,
6803                                      NULL,
6804                                      NULL);
6805
6806       if (path != NULL)
6807         {
6808           gtk_tree_view_scroll_to_cell (tree_view,
6809                                         path,
6810                                         column,
6811                                         TRUE,
6812                                         0.5, 0.5);
6813
6814           gtk_tree_path_free (path);
6815         }
6816     }
6817
6818   GDK_THREADS_LEAVE ();
6819
6820   return TRUE;
6821 }
6822 #endif /* 0 */
6823
6824 static void
6825 add_scroll_timeout (GtkTreeView *tree_view)
6826 {
6827   if (tree_view->priv->scroll_timeout == 0)
6828     {
6829       tree_view->priv->scroll_timeout =
6830         gdk_threads_add_timeout (150, scroll_row_timeout, tree_view);
6831     }
6832 }
6833
6834 static void
6835 remove_scroll_timeout (GtkTreeView *tree_view)
6836 {
6837   if (tree_view->priv->scroll_timeout != 0)
6838     {
6839       g_source_remove (tree_view->priv->scroll_timeout);
6840       tree_view->priv->scroll_timeout = 0;
6841     }
6842 }
6843
6844 static gboolean
6845 check_model_dnd (GtkTreeModel *model,
6846                  GType         required_iface,
6847                  const gchar  *signal)
6848 {
6849   if (model == NULL || !G_TYPE_CHECK_INSTANCE_TYPE ((model), required_iface))
6850     {
6851       g_warning ("You must override the default '%s' handler "
6852                  "on GtkTreeView when using models that don't support "
6853                  "the %s interface and enabling drag-and-drop. The simplest way to do this "
6854                  "is to connect to '%s' and call "
6855                  "g_signal_stop_emission_by_name() in your signal handler to prevent "
6856                  "the default handler from running. Look at the source code "
6857                  "for the default handler in gtktreeview.c to get an idea what "
6858                  "your handler should do. (gtktreeview.c is in the GTK source "
6859                  "code.) If you're using GTK from a language other than C, "
6860                  "there may be a more natural way to override default handlers, e.g. via derivation.",
6861                  signal, g_type_name (required_iface), signal);
6862       return FALSE;
6863     }
6864   else
6865     return TRUE;
6866 }
6867
6868 static void
6869 remove_open_timeout (GtkTreeView *tree_view)
6870 {
6871   if (tree_view->priv->open_dest_timeout != 0)
6872     {
6873       g_source_remove (tree_view->priv->open_dest_timeout);
6874       tree_view->priv->open_dest_timeout = 0;
6875     }
6876 }
6877
6878
6879 static gint
6880 open_row_timeout (gpointer data)
6881 {
6882   GtkTreeView *tree_view = data;
6883   GtkTreePath *dest_path = NULL;
6884   GtkTreeViewDropPosition pos;
6885   gboolean result = FALSE;
6886
6887   gtk_tree_view_get_drag_dest_row (tree_view,
6888                                    &dest_path,
6889                                    &pos);
6890
6891   if (dest_path &&
6892       (pos == GTK_TREE_VIEW_DROP_INTO_OR_AFTER ||
6893        pos == GTK_TREE_VIEW_DROP_INTO_OR_BEFORE))
6894     {
6895       gtk_tree_view_expand_row (tree_view, dest_path, FALSE);
6896       tree_view->priv->open_dest_timeout = 0;
6897
6898       gtk_tree_path_free (dest_path);
6899     }
6900   else
6901     {
6902       if (dest_path)
6903         gtk_tree_path_free (dest_path);
6904
6905       result = TRUE;
6906     }
6907
6908   return result;
6909 }
6910
6911 static gboolean
6912 scroll_row_timeout (gpointer data)
6913 {
6914   GtkTreeView *tree_view = data;
6915
6916   gtk_tree_view_vertical_autoscroll (tree_view);
6917
6918   if (tree_view->priv->rubber_band_status == RUBBER_BAND_ACTIVE)
6919     gtk_tree_view_update_rubber_band (tree_view);
6920
6921   return TRUE;
6922 }
6923
6924 /* Returns TRUE if event should not be propagated to parent widgets */
6925 static gboolean
6926 set_destination_row (GtkTreeView    *tree_view,
6927                      GdkDragContext *context,
6928                      /* coordinates relative to the widget */
6929                      gint            x,
6930                      gint            y,
6931                      GdkDragAction  *suggested_action,
6932                      GdkAtom        *target)
6933 {
6934   GtkTreePath *path = NULL;
6935   GtkTreeViewDropPosition pos;
6936   GtkTreeViewDropPosition old_pos;
6937   TreeViewDragInfo *di;
6938   GtkWidget *widget;
6939   GtkTreePath *old_dest_path = NULL;
6940   gboolean can_drop = FALSE;
6941
6942   *suggested_action = 0;
6943   *target = GDK_NONE;
6944
6945   widget = GTK_WIDGET (tree_view);
6946
6947   di = get_info (tree_view);
6948
6949   if (di == NULL || y - TREE_VIEW_HEADER_HEIGHT (tree_view) < 0)
6950     {
6951       /* someone unset us as a drag dest, note that if
6952        * we return FALSE drag_leave isn't called
6953        */
6954
6955       gtk_tree_view_set_drag_dest_row (tree_view,
6956                                        NULL,
6957                                        GTK_TREE_VIEW_DROP_BEFORE);
6958
6959       remove_scroll_timeout (GTK_TREE_VIEW (widget));
6960       remove_open_timeout (GTK_TREE_VIEW (widget));
6961
6962       return FALSE; /* no longer a drop site */
6963     }
6964
6965   *target = gtk_drag_dest_find_target (widget, context,
6966                                        gtk_drag_dest_get_target_list (widget));
6967   if (*target == GDK_NONE)
6968     {
6969       return FALSE;
6970     }
6971
6972   if (!gtk_tree_view_get_dest_row_at_pos (tree_view,
6973                                           x, y,
6974                                           &path,
6975                                           &pos))
6976     {
6977       gint n_children;
6978       GtkTreeModel *model;
6979
6980       remove_open_timeout (tree_view);
6981
6982       /* the row got dropped on empty space, let's setup a special case
6983        */
6984
6985       if (path)
6986         gtk_tree_path_free (path);
6987
6988       model = gtk_tree_view_get_model (tree_view);
6989
6990       n_children = gtk_tree_model_iter_n_children (model, NULL);
6991       if (n_children)
6992         {
6993           pos = GTK_TREE_VIEW_DROP_AFTER;
6994           path = gtk_tree_path_new_from_indices (n_children - 1, -1);
6995         }
6996       else
6997         {
6998           pos = GTK_TREE_VIEW_DROP_BEFORE;
6999           path = gtk_tree_path_new_from_indices (0, -1);
7000         }
7001
7002       can_drop = TRUE;
7003
7004       goto out;
7005     }
7006
7007   g_assert (path);
7008
7009   /* If we left the current row's "open" zone, unset the timeout for
7010    * opening the row
7011    */
7012   gtk_tree_view_get_drag_dest_row (tree_view,
7013                                    &old_dest_path,
7014                                    &old_pos);
7015
7016   if (old_dest_path &&
7017       (gtk_tree_path_compare (path, old_dest_path) != 0 ||
7018        !(pos == GTK_TREE_VIEW_DROP_INTO_OR_AFTER ||
7019          pos == GTK_TREE_VIEW_DROP_INTO_OR_BEFORE)))
7020     remove_open_timeout (tree_view);
7021
7022   if (old_dest_path)
7023     gtk_tree_path_free (old_dest_path);
7024
7025   if (TRUE /* FIXME if the location droppable predicate */)
7026     {
7027       can_drop = TRUE;
7028     }
7029
7030 out:
7031   if (can_drop)
7032     {
7033       GtkWidget *source_widget;
7034
7035       *suggested_action = context->suggested_action;
7036       source_widget = gtk_drag_get_source_widget (context);
7037
7038       if (source_widget == widget)
7039         {
7040           /* Default to MOVE, unless the user has
7041            * pressed ctrl or shift to affect available actions
7042            */
7043           if ((context->actions & GDK_ACTION_MOVE) != 0)
7044             *suggested_action = GDK_ACTION_MOVE;
7045         }
7046
7047       gtk_tree_view_set_drag_dest_row (GTK_TREE_VIEW (widget),
7048                                        path, pos);
7049     }
7050   else
7051     {
7052       /* can't drop here */
7053       remove_open_timeout (tree_view);
7054
7055       gtk_tree_view_set_drag_dest_row (GTK_TREE_VIEW (widget),
7056                                        NULL,
7057                                        GTK_TREE_VIEW_DROP_BEFORE);
7058     }
7059
7060   if (path)
7061     gtk_tree_path_free (path);
7062
7063   return TRUE;
7064 }
7065
7066 static GtkTreePath*
7067 get_logical_dest_row (GtkTreeView *tree_view,
7068                       gboolean    *path_down_mode,
7069                       gboolean    *drop_append_mode)
7070 {
7071   /* adjust path to point to the row the drop goes in front of */
7072   GtkTreePath *path = NULL;
7073   GtkTreeViewDropPosition pos;
7074
7075   g_return_val_if_fail (path_down_mode != NULL, NULL);
7076   g_return_val_if_fail (drop_append_mode != NULL, NULL);
7077
7078   *path_down_mode = FALSE;
7079   *drop_append_mode = 0;
7080
7081   gtk_tree_view_get_drag_dest_row (tree_view, &path, &pos);
7082
7083   if (path == NULL)
7084     return NULL;
7085
7086   if (pos == GTK_TREE_VIEW_DROP_BEFORE)
7087     ; /* do nothing */
7088   else if (pos == GTK_TREE_VIEW_DROP_INTO_OR_BEFORE ||
7089            pos == GTK_TREE_VIEW_DROP_INTO_OR_AFTER)
7090     *path_down_mode = TRUE;
7091   else
7092     {
7093       GtkTreeIter iter;
7094       GtkTreeModel *model = gtk_tree_view_get_model (tree_view);
7095
7096       g_assert (pos == GTK_TREE_VIEW_DROP_AFTER);
7097
7098       if (!gtk_tree_model_get_iter (model, &iter, path) ||
7099           !gtk_tree_model_iter_next (model, &iter))
7100         *drop_append_mode = 1;
7101       else
7102         {
7103           *drop_append_mode = 0;
7104           gtk_tree_path_next (path);
7105         }
7106     }
7107
7108   return path;
7109 }
7110
7111 static gboolean
7112 gtk_tree_view_maybe_begin_dragging_row (GtkTreeView      *tree_view,
7113                                         GdkEventMotion   *event)
7114 {
7115   GtkWidget *widget = GTK_WIDGET (tree_view);
7116   GdkDragContext *context;
7117   TreeViewDragInfo *di;
7118   GtkTreePath *path = NULL;
7119   gint button;
7120   gint cell_x, cell_y;
7121   GtkTreeModel *model;
7122   gboolean retval = FALSE;
7123
7124   di = get_info (tree_view);
7125
7126   if (di == NULL || !di->source_set)
7127     goto out;
7128
7129   if (tree_view->priv->pressed_button < 0)
7130     goto out;
7131
7132   if (!gtk_drag_check_threshold (widget,
7133                                  tree_view->priv->press_start_x,
7134                                  tree_view->priv->press_start_y,
7135                                  event->x, event->y))
7136     goto out;
7137
7138   model = gtk_tree_view_get_model (tree_view);
7139
7140   if (model == NULL)
7141     goto out;
7142
7143   button = tree_view->priv->pressed_button;
7144   tree_view->priv->pressed_button = -1;
7145
7146   gtk_tree_view_get_path_at_pos (tree_view,
7147                                  tree_view->priv->press_start_x,
7148                                  tree_view->priv->press_start_y,
7149                                  &path,
7150                                  NULL,
7151                                  &cell_x,
7152                                  &cell_y);
7153
7154   if (path == NULL)
7155     goto out;
7156
7157   if (!GTK_IS_TREE_DRAG_SOURCE (model) ||
7158       !gtk_tree_drag_source_row_draggable (GTK_TREE_DRAG_SOURCE (model),
7159                                            path))
7160     goto out;
7161
7162   if (!(GDK_BUTTON1_MASK << (button - 1) & di->start_button_mask))
7163     goto out;
7164
7165   /* Now we can begin the drag */
7166
7167   retval = TRUE;
7168
7169   context = gtk_drag_begin (widget,
7170                             gtk_drag_source_get_target_list (widget),
7171                             di->source_actions,
7172                             button,
7173                             (GdkEvent*)event);
7174
7175   set_source_row (context, model, path);
7176
7177  out:
7178   if (path)
7179     gtk_tree_path_free (path);
7180
7181   return retval;
7182 }
7183
7184
7185 static void
7186 gtk_tree_view_drag_begin (GtkWidget      *widget,
7187                           GdkDragContext *context)
7188 {
7189   GtkTreeView *tree_view;
7190   GtkTreePath *path = NULL;
7191   gint cell_x, cell_y;
7192   cairo_surface_t *row_pix;
7193   TreeViewDragInfo *di;
7194
7195   tree_view = GTK_TREE_VIEW (widget);
7196
7197   /* if the user uses a custom DND source impl, we don't set the icon here */
7198   di = get_info (tree_view);
7199
7200   if (di == NULL || !di->source_set)
7201     return;
7202
7203   gtk_tree_view_get_path_at_pos (tree_view,
7204                                  tree_view->priv->press_start_x,
7205                                  tree_view->priv->press_start_y,
7206                                  &path,
7207                                  NULL,
7208                                  &cell_x,
7209                                  &cell_y);
7210
7211   g_return_if_fail (path != NULL);
7212
7213   row_pix = gtk_tree_view_create_row_drag_icon (tree_view,
7214                                                 path);
7215   cairo_surface_set_device_offset (row_pix,
7216                                    /* the + 1 is for the black border in the icon */
7217                                    - (tree_view->priv->press_start_x + 1),
7218                                    - (cell_y + 1));
7219
7220   gtk_drag_set_icon_surface (context, row_pix);
7221
7222   cairo_surface_destroy (row_pix);
7223   gtk_tree_path_free (path);
7224 }
7225
7226 static void
7227 gtk_tree_view_drag_end (GtkWidget      *widget,
7228                         GdkDragContext *context)
7229 {
7230   /* do nothing */
7231 }
7232
7233 /* Default signal implementations for the drag signals */
7234 static void
7235 gtk_tree_view_drag_data_get (GtkWidget        *widget,
7236                              GdkDragContext   *context,
7237                              GtkSelectionData *selection_data,
7238                              guint             info,
7239                              guint             time)
7240 {
7241   GtkTreeView *tree_view;
7242   GtkTreeModel *model;
7243   TreeViewDragInfo *di;
7244   GtkTreePath *source_row;
7245
7246   tree_view = GTK_TREE_VIEW (widget);
7247
7248   model = gtk_tree_view_get_model (tree_view);
7249
7250   if (model == NULL)
7251     return;
7252
7253   di = get_info (GTK_TREE_VIEW (widget));
7254
7255   if (di == NULL)
7256     return;
7257
7258   source_row = get_source_row (context);
7259
7260   if (source_row == NULL)
7261     return;
7262
7263   /* We can implement the GTK_TREE_MODEL_ROW target generically for
7264    * any model; for DragSource models there are some other targets
7265    * we also support.
7266    */
7267
7268   if (GTK_IS_TREE_DRAG_SOURCE (model) &&
7269       gtk_tree_drag_source_drag_data_get (GTK_TREE_DRAG_SOURCE (model),
7270                                           source_row,
7271                                           selection_data))
7272     goto done;
7273
7274   /* If drag_data_get does nothing, try providing row data. */
7275   if (selection_data->target == gdk_atom_intern_static_string ("GTK_TREE_MODEL_ROW"))
7276     {
7277       gtk_tree_set_row_drag_data (selection_data,
7278                                   model,
7279                                   source_row);
7280     }
7281
7282  done:
7283   gtk_tree_path_free (source_row);
7284 }
7285
7286
7287 static void
7288 gtk_tree_view_drag_data_delete (GtkWidget      *widget,
7289                                 GdkDragContext *context)
7290 {
7291   TreeViewDragInfo *di;
7292   GtkTreeModel *model;
7293   GtkTreeView *tree_view;
7294   GtkTreePath *source_row;
7295
7296   tree_view = GTK_TREE_VIEW (widget);
7297   model = gtk_tree_view_get_model (tree_view);
7298
7299   if (!check_model_dnd (model, GTK_TYPE_TREE_DRAG_SOURCE, "drag_data_delete"))
7300     return;
7301
7302   di = get_info (tree_view);
7303
7304   if (di == NULL)
7305     return;
7306
7307   source_row = get_source_row (context);
7308
7309   if (source_row == NULL)
7310     return;
7311
7312   gtk_tree_drag_source_drag_data_delete (GTK_TREE_DRAG_SOURCE (model),
7313                                          source_row);
7314
7315   gtk_tree_path_free (source_row);
7316
7317   set_source_row (context, NULL, NULL);
7318 }
7319
7320 static void
7321 gtk_tree_view_drag_leave (GtkWidget      *widget,
7322                           GdkDragContext *context,
7323                           guint             time)
7324 {
7325   /* unset any highlight row */
7326   gtk_tree_view_set_drag_dest_row (GTK_TREE_VIEW (widget),
7327                                    NULL,
7328                                    GTK_TREE_VIEW_DROP_BEFORE);
7329
7330   remove_scroll_timeout (GTK_TREE_VIEW (widget));
7331   remove_open_timeout (GTK_TREE_VIEW (widget));
7332 }
7333
7334
7335 static gboolean
7336 gtk_tree_view_drag_motion (GtkWidget        *widget,
7337                            GdkDragContext   *context,
7338                            /* coordinates relative to the widget */
7339                            gint              x,
7340                            gint              y,
7341                            guint             time)
7342 {
7343   gboolean empty;
7344   GtkTreePath *path = NULL;
7345   GtkTreeViewDropPosition pos;
7346   GtkTreeView *tree_view;
7347   GdkDragAction suggested_action = 0;
7348   GdkAtom target;
7349
7350   tree_view = GTK_TREE_VIEW (widget);
7351
7352   if (!set_destination_row (tree_view, context, x, y, &suggested_action, &target))
7353     return FALSE;
7354
7355   gtk_tree_view_get_drag_dest_row (tree_view, &path, &pos);
7356
7357   /* we only know this *after* set_desination_row */
7358   empty = tree_view->priv->empty_view_drop;
7359
7360   if (path == NULL && !empty)
7361     {
7362       /* Can't drop here. */
7363       gdk_drag_status (context, 0, time);
7364     }
7365   else
7366     {
7367       if (tree_view->priv->open_dest_timeout == 0 &&
7368           (pos == GTK_TREE_VIEW_DROP_INTO_OR_AFTER ||
7369            pos == GTK_TREE_VIEW_DROP_INTO_OR_BEFORE))
7370         {
7371           tree_view->priv->open_dest_timeout =
7372             gdk_threads_add_timeout (AUTO_EXPAND_TIMEOUT, open_row_timeout, tree_view);
7373         }
7374       else
7375         {
7376           add_scroll_timeout (tree_view);
7377         }
7378
7379       if (target == gdk_atom_intern_static_string ("GTK_TREE_MODEL_ROW"))
7380         {
7381           /* Request data so we can use the source row when
7382            * determining whether to accept the drop
7383            */
7384           set_status_pending (context, suggested_action);
7385           gtk_drag_get_data (widget, context, target, time);
7386         }
7387       else
7388         {
7389           set_status_pending (context, 0);
7390           gdk_drag_status (context, suggested_action, time);
7391         }
7392     }
7393
7394   if (path)
7395     gtk_tree_path_free (path);
7396
7397   return TRUE;
7398 }
7399
7400
7401 static gboolean
7402 gtk_tree_view_drag_drop (GtkWidget        *widget,
7403                          GdkDragContext   *context,
7404                          /* coordinates relative to the widget */
7405                          gint              x,
7406                          gint              y,
7407                          guint             time)
7408 {
7409   GtkTreeView *tree_view;
7410   GtkTreePath *path;
7411   GdkDragAction suggested_action = 0;
7412   GdkAtom target = GDK_NONE;
7413   TreeViewDragInfo *di;
7414   GtkTreeModel *model;
7415   gboolean path_down_mode;
7416   gboolean drop_append_mode;
7417
7418   tree_view = GTK_TREE_VIEW (widget);
7419
7420   model = gtk_tree_view_get_model (tree_view);
7421
7422   remove_scroll_timeout (GTK_TREE_VIEW (widget));
7423   remove_open_timeout (GTK_TREE_VIEW (widget));
7424
7425   di = get_info (tree_view);
7426
7427   if (di == NULL)
7428     return FALSE;
7429
7430   if (!check_model_dnd (model, GTK_TYPE_TREE_DRAG_DEST, "drag_drop"))
7431     return FALSE;
7432
7433   if (!set_destination_row (tree_view, context, x, y, &suggested_action, &target))
7434     return FALSE;
7435
7436   path = get_logical_dest_row (tree_view, &path_down_mode, &drop_append_mode);
7437
7438   if (target != GDK_NONE && path != NULL)
7439     {
7440       /* in case a motion had requested drag data, change things so we
7441        * treat drag data receives as a drop.
7442        */
7443       set_status_pending (context, 0);
7444       set_dest_row (context, model, path,
7445                     path_down_mode, tree_view->priv->empty_view_drop,
7446                     drop_append_mode);
7447     }
7448
7449   if (path)
7450     gtk_tree_path_free (path);
7451
7452   /* Unset this thing */
7453   gtk_tree_view_set_drag_dest_row (GTK_TREE_VIEW (widget),
7454                                    NULL,
7455                                    GTK_TREE_VIEW_DROP_BEFORE);
7456
7457   if (target != GDK_NONE)
7458     {
7459       gtk_drag_get_data (widget, context, target, time);
7460       return TRUE;
7461     }
7462   else
7463     return FALSE;
7464 }
7465
7466 static void
7467 gtk_tree_view_drag_data_received (GtkWidget        *widget,
7468                                   GdkDragContext   *context,
7469                                   /* coordinates relative to the widget */
7470                                   gint              x,
7471                                   gint              y,
7472                                   GtkSelectionData *selection_data,
7473                                   guint             info,
7474                                   guint             time)
7475 {
7476   GtkTreePath *path;
7477   TreeViewDragInfo *di;
7478   gboolean accepted = FALSE;
7479   GtkTreeModel *model;
7480   GtkTreeView *tree_view;
7481   GtkTreePath *dest_row;
7482   GdkDragAction suggested_action;
7483   gboolean path_down_mode;
7484   gboolean drop_append_mode;
7485
7486   tree_view = GTK_TREE_VIEW (widget);
7487
7488   model = gtk_tree_view_get_model (tree_view);
7489
7490   if (!check_model_dnd (model, GTK_TYPE_TREE_DRAG_DEST, "drag_data_received"))
7491     return;
7492
7493   di = get_info (tree_view);
7494
7495   if (di == NULL)
7496     return;
7497
7498   suggested_action = get_status_pending (context);
7499
7500   if (suggested_action)
7501     {
7502       /* We are getting this data due to a request in drag_motion,
7503        * rather than due to a request in drag_drop, so we are just
7504        * supposed to call drag_status, not actually paste in the
7505        * data.
7506        */
7507       path = get_logical_dest_row (tree_view, &path_down_mode,
7508                                    &drop_append_mode);
7509
7510       if (path == NULL)
7511         suggested_action = 0;
7512       else if (path_down_mode)
7513         gtk_tree_path_down (path);
7514
7515       if (suggested_action)
7516         {
7517           if (!gtk_tree_drag_dest_row_drop_possible (GTK_TREE_DRAG_DEST (model),
7518                                                      path,
7519                                                      selection_data))
7520             {
7521               if (path_down_mode)
7522                 {
7523                   path_down_mode = FALSE;
7524                   gtk_tree_path_up (path);
7525
7526                   if (!gtk_tree_drag_dest_row_drop_possible (GTK_TREE_DRAG_DEST (model),
7527                                                              path,
7528                                                              selection_data))
7529                     suggested_action = 0;
7530                 }
7531               else
7532                 suggested_action = 0;
7533             }
7534         }
7535
7536       gdk_drag_status (context, suggested_action, time);
7537
7538       if (path)
7539         gtk_tree_path_free (path);
7540
7541       /* If you can't drop, remove user drop indicator until the next motion */
7542       if (suggested_action == 0)
7543         gtk_tree_view_set_drag_dest_row (GTK_TREE_VIEW (widget),
7544                                          NULL,
7545                                          GTK_TREE_VIEW_DROP_BEFORE);
7546
7547       return;
7548     }
7549
7550   dest_row = get_dest_row (context, &path_down_mode);
7551
7552   if (dest_row == NULL)
7553     return;
7554
7555   if (selection_data->length >= 0)
7556     {
7557       if (path_down_mode)
7558         {
7559           gtk_tree_path_down (dest_row);
7560           if (!gtk_tree_drag_dest_row_drop_possible (GTK_TREE_DRAG_DEST (model),
7561                                                      dest_row, selection_data))
7562             gtk_tree_path_up (dest_row);
7563         }
7564     }
7565
7566   if (selection_data->length >= 0)
7567     {
7568       if (gtk_tree_drag_dest_drag_data_received (GTK_TREE_DRAG_DEST (model),
7569                                                  dest_row,
7570                                                  selection_data))
7571         accepted = TRUE;
7572     }
7573
7574   gtk_drag_finish (context,
7575                    accepted,
7576                    (context->action == GDK_ACTION_MOVE),
7577                    time);
7578
7579   if (gtk_tree_path_get_depth (dest_row) == 1
7580       && gtk_tree_path_get_indices (dest_row)[0] == 0)
7581     {
7582       /* special special case drag to "0", scroll to first item */
7583       if (!tree_view->priv->scroll_to_path)
7584         gtk_tree_view_scroll_to_cell (tree_view, dest_row, NULL, FALSE, 0.0, 0.0);
7585     }
7586
7587   gtk_tree_path_free (dest_row);
7588
7589   /* drop dest_row */
7590   set_dest_row (context, NULL, NULL, FALSE, FALSE, FALSE);
7591 }
7592
7593
7594
7595 /* GtkContainer Methods
7596  */
7597
7598
7599 static void
7600 gtk_tree_view_remove (GtkContainer *container,
7601                       GtkWidget    *widget)
7602 {
7603   GtkTreeView *tree_view = GTK_TREE_VIEW (container);
7604   GtkTreeViewChild *child = NULL;
7605   GList *tmp_list;
7606
7607   tmp_list = tree_view->priv->children;
7608   while (tmp_list)
7609     {
7610       child = tmp_list->data;
7611       if (child->widget == widget)
7612         {
7613           gtk_widget_unparent (widget);
7614
7615           tree_view->priv->children = g_list_remove_link (tree_view->priv->children, tmp_list);
7616           g_list_free_1 (tmp_list);
7617           g_slice_free (GtkTreeViewChild, child);
7618           return;
7619         }
7620
7621       tmp_list = tmp_list->next;
7622     }
7623
7624   tmp_list = tree_view->priv->columns;
7625
7626   while (tmp_list)
7627     {
7628       GtkTreeViewColumn *column;
7629       column = tmp_list->data;
7630       if (column->button == widget)
7631         {
7632           gtk_widget_unparent (widget);
7633           return;
7634         }
7635       tmp_list = tmp_list->next;
7636     }
7637 }
7638
7639 static void
7640 gtk_tree_view_forall (GtkContainer *container,
7641                       gboolean      include_internals,
7642                       GtkCallback   callback,
7643                       gpointer      callback_data)
7644 {
7645   GtkTreeView *tree_view = GTK_TREE_VIEW (container);
7646   GtkTreeViewChild *child = NULL;
7647   GtkTreeViewColumn *column;
7648   GList *tmp_list;
7649
7650   tmp_list = tree_view->priv->children;
7651   while (tmp_list)
7652     {
7653       child = tmp_list->data;
7654       tmp_list = tmp_list->next;
7655
7656       (* callback) (child->widget, callback_data);
7657     }
7658   if (include_internals == FALSE)
7659     return;
7660
7661   for (tmp_list = tree_view->priv->columns; tmp_list; tmp_list = tmp_list->next)
7662     {
7663       column = tmp_list->data;
7664
7665       if (column->button)
7666         (* callback) (column->button, callback_data);
7667     }
7668 }
7669
7670 /* Returns TRUE if the treeview contains no "special" (editable or activatable)
7671  * cells. If so we draw one big row-spanning focus rectangle.
7672  */
7673 static gboolean
7674 gtk_tree_view_has_special_cell (GtkTreeView *tree_view)
7675 {
7676   GList *list;
7677
7678   for (list = tree_view->priv->columns; list; list = list->next)
7679     {
7680       if (!((GtkTreeViewColumn *)list->data)->visible)
7681         continue;
7682       if (_gtk_tree_view_column_count_special_cells (list->data))
7683         return TRUE;
7684     }
7685
7686   return FALSE;
7687 }
7688
7689 static void
7690 column_sizing_notify (GObject    *object,
7691                       GParamSpec *pspec,
7692                       gpointer    data)
7693 {
7694   GtkTreeViewColumn *c = GTK_TREE_VIEW_COLUMN (object);
7695
7696   if (gtk_tree_view_column_get_sizing (c) != GTK_TREE_VIEW_COLUMN_FIXED)
7697     /* disable fixed height mode */
7698     g_object_set (data, "fixed-height-mode", FALSE, NULL);
7699 }
7700
7701 /**
7702  * gtk_tree_view_set_fixed_height_mode:
7703  * @tree_view: a #GtkTreeView
7704  * @enable: %TRUE to enable fixed height mode
7705  *
7706  * Enables or disables the fixed height mode of @tree_view.
7707  * Fixed height mode speeds up #GtkTreeView by assuming that all
7708  * rows have the same height.
7709  * Only enable this option if all rows are the same height and all
7710  * columns are of type %GTK_TREE_VIEW_COLUMN_FIXED.
7711  *
7712  * Since: 2.6
7713  **/
7714 void
7715 gtk_tree_view_set_fixed_height_mode (GtkTreeView *tree_view,
7716                                      gboolean     enable)
7717 {
7718   GList *l;
7719
7720   enable = enable != FALSE;
7721
7722   if (enable == tree_view->priv->fixed_height_mode)
7723     return;
7724
7725   if (!enable)
7726     {
7727       tree_view->priv->fixed_height_mode = 0;
7728       tree_view->priv->fixed_height = -1;
7729
7730       /* force a revalidation */
7731       install_presize_handler (tree_view);
7732     }
7733   else
7734     {
7735       /* make sure all columns are of type FIXED */
7736       for (l = tree_view->priv->columns; l; l = l->next)
7737         {
7738           GtkTreeViewColumn *c = l->data;
7739
7740           g_return_if_fail (gtk_tree_view_column_get_sizing (c) == GTK_TREE_VIEW_COLUMN_FIXED);
7741         }
7742
7743       /* yes, we really have to do this is in a separate loop */
7744       for (l = tree_view->priv->columns; l; l = l->next)
7745         g_signal_connect (l->data, "notify::sizing",
7746                           G_CALLBACK (column_sizing_notify), tree_view);
7747
7748       tree_view->priv->fixed_height_mode = 1;
7749       tree_view->priv->fixed_height = -1;
7750
7751       if (tree_view->priv->tree)
7752         initialize_fixed_height_mode (tree_view);
7753     }
7754
7755   g_object_notify (G_OBJECT (tree_view), "fixed-height-mode");
7756 }
7757
7758 /**
7759  * gtk_tree_view_get_fixed_height_mode:
7760  * @tree_view: a #GtkTreeView
7761  *
7762  * Returns whether fixed height mode is turned on for @tree_view.
7763  *
7764  * Return value: %TRUE if @tree_view is in fixed height mode
7765  *
7766  * Since: 2.6
7767  **/
7768 gboolean
7769 gtk_tree_view_get_fixed_height_mode (GtkTreeView *tree_view)
7770 {
7771   return tree_view->priv->fixed_height_mode;
7772 }
7773
7774 /* Returns TRUE if the focus is within the headers, after the focus operation is
7775  * done
7776  */
7777 static gboolean
7778 gtk_tree_view_header_focus (GtkTreeView      *tree_view,
7779                             GtkDirectionType  dir,
7780                             gboolean          clamp_column_visible)
7781 {
7782   GtkWidget *focus_child;
7783
7784   GList *last_column, *first_column;
7785   GList *tmp_list;
7786   gboolean rtl;
7787
7788   if (! GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_HEADERS_VISIBLE))
7789     return FALSE;
7790
7791   focus_child = gtk_container_get_focus_child (GTK_CONTAINER (tree_view));
7792
7793   first_column = tree_view->priv->columns;
7794   while (first_column)
7795     {
7796       if (gtk_widget_get_can_focus (GTK_TREE_VIEW_COLUMN (first_column->data)->button) &&
7797           GTK_TREE_VIEW_COLUMN (first_column->data)->visible &&
7798           (GTK_TREE_VIEW_COLUMN (first_column->data)->clickable ||
7799            GTK_TREE_VIEW_COLUMN (first_column->data)->reorderable))
7800         break;
7801       first_column = first_column->next;
7802     }
7803
7804   /* No headers are visible, or are focusable.  We can't focus in or out.
7805    */
7806   if (first_column == NULL)
7807     return FALSE;
7808
7809   last_column = g_list_last (tree_view->priv->columns);
7810   while (last_column)
7811     {
7812       if (gtk_widget_get_can_focus (GTK_TREE_VIEW_COLUMN (last_column->data)->button) &&
7813           GTK_TREE_VIEW_COLUMN (last_column->data)->visible &&
7814           (GTK_TREE_VIEW_COLUMN (last_column->data)->clickable ||
7815            GTK_TREE_VIEW_COLUMN (last_column->data)->reorderable))
7816         break;
7817       last_column = last_column->prev;
7818     }
7819
7820
7821   rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
7822
7823   switch (dir)
7824     {
7825     case GTK_DIR_TAB_BACKWARD:
7826     case GTK_DIR_TAB_FORWARD:
7827     case GTK_DIR_UP:
7828     case GTK_DIR_DOWN:
7829       if (focus_child == NULL)
7830         {
7831           if (tree_view->priv->focus_column != NULL &&
7832               gtk_widget_get_can_focus (tree_view->priv->focus_column->button))
7833             focus_child = tree_view->priv->focus_column->button;
7834           else
7835             focus_child = GTK_TREE_VIEW_COLUMN (first_column->data)->button;
7836           gtk_widget_grab_focus (focus_child);
7837           break;
7838         }
7839       return FALSE;
7840
7841     case GTK_DIR_LEFT:
7842     case GTK_DIR_RIGHT:
7843       if (focus_child == NULL)
7844         {
7845           if (tree_view->priv->focus_column != NULL)
7846             focus_child = tree_view->priv->focus_column->button;
7847           else if (dir == GTK_DIR_LEFT)
7848             focus_child = GTK_TREE_VIEW_COLUMN (last_column->data)->button;
7849           else
7850             focus_child = GTK_TREE_VIEW_COLUMN (first_column->data)->button;
7851           gtk_widget_grab_focus (focus_child);
7852           break;
7853         }
7854
7855       if (gtk_widget_child_focus (focus_child, dir))
7856         {
7857           /* The focus moves inside the button. */
7858           /* This is probably a great example of bad UI */
7859           break;
7860         }
7861
7862       /* We need to move the focus among the row of buttons. */
7863       for (tmp_list = tree_view->priv->columns; tmp_list; tmp_list = tmp_list->next)
7864         if (GTK_TREE_VIEW_COLUMN (tmp_list->data)->button == focus_child)
7865           break;
7866
7867       if ((tmp_list == first_column && dir == (rtl ? GTK_DIR_RIGHT : GTK_DIR_LEFT))
7868           || (tmp_list == last_column && dir == (rtl ? GTK_DIR_LEFT : GTK_DIR_RIGHT)))
7869         {
7870           gtk_widget_error_bell (GTK_WIDGET (tree_view));
7871           break;
7872         }
7873
7874       while (tmp_list)
7875         {
7876           GtkTreeViewColumn *column;
7877
7878           if (dir == (rtl ? GTK_DIR_LEFT : GTK_DIR_RIGHT))
7879             tmp_list = tmp_list->next;
7880           else
7881             tmp_list = tmp_list->prev;
7882
7883           if (tmp_list == NULL)
7884             {
7885               g_warning ("Internal button not found");
7886               break;
7887             }
7888           column = tmp_list->data;
7889           if (column->button &&
7890               column->visible &&
7891               gtk_widget_get_can_focus (column->button))
7892             {
7893               focus_child = column->button;
7894               gtk_widget_grab_focus (column->button);
7895               break;
7896             }
7897         }
7898       break;
7899     default:
7900       g_assert_not_reached ();
7901       break;
7902     }
7903
7904   /* if focus child is non-null, we assume it's been set to the current focus child
7905    */
7906   if (focus_child)
7907     {
7908       for (tmp_list = tree_view->priv->columns; tmp_list; tmp_list = tmp_list->next)
7909         if (GTK_TREE_VIEW_COLUMN (tmp_list->data)->button == focus_child)
7910           {
7911             tree_view->priv->focus_column = GTK_TREE_VIEW_COLUMN (tmp_list->data);
7912             break;
7913           }
7914
7915       if (clamp_column_visible)
7916         {
7917           gtk_tree_view_clamp_column_visible (tree_view,
7918                                               tree_view->priv->focus_column,
7919                                               FALSE);
7920         }
7921     }
7922
7923   return (focus_child != NULL);
7924 }
7925
7926 /* This function returns in 'path' the first focusable path, if the given path
7927  * is already focusable, it's the returned one.
7928  */
7929 static gboolean
7930 search_first_focusable_path (GtkTreeView  *tree_view,
7931                              GtkTreePath **path,
7932                              gboolean      search_forward,
7933                              GtkRBTree   **new_tree,
7934                              GtkRBNode   **new_node)
7935 {
7936   GtkRBTree *tree = NULL;
7937   GtkRBNode *node = NULL;
7938
7939   if (!path || !*path)
7940     return FALSE;
7941
7942   _gtk_tree_view_find_node (tree_view, *path, &tree, &node);
7943
7944   if (!tree || !node)
7945     return FALSE;
7946
7947   while (node && row_is_separator (tree_view, NULL, *path))
7948     {
7949       if (search_forward)
7950         _gtk_rbtree_next_full (tree, node, &tree, &node);
7951       else
7952         _gtk_rbtree_prev_full (tree, node, &tree, &node);
7953
7954       if (*path)
7955         gtk_tree_path_free (*path);
7956
7957       if (node)
7958         *path = _gtk_tree_view_find_path (tree_view, tree, node);
7959       else
7960         *path = NULL;
7961     }
7962
7963   if (new_tree)
7964     *new_tree = tree;
7965
7966   if (new_node)
7967     *new_node = node;
7968
7969   return (*path != NULL);
7970 }
7971
7972 static gint
7973 gtk_tree_view_focus (GtkWidget        *widget,
7974                      GtkDirectionType  direction)
7975 {
7976   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
7977   GtkContainer *container = GTK_CONTAINER (widget);
7978   GtkWidget *focus_child;
7979
7980   if (!gtk_widget_is_sensitive (widget) || !gtk_widget_get_can_focus (widget))
7981     return FALSE;
7982
7983   focus_child = gtk_container_get_focus_child (container);
7984
7985   gtk_tree_view_stop_editing (GTK_TREE_VIEW (widget), FALSE);
7986   /* Case 1.  Headers currently have focus. */
7987   if (focus_child)
7988     {
7989       switch (direction)
7990         {
7991         case GTK_DIR_LEFT:
7992         case GTK_DIR_RIGHT:
7993           gtk_tree_view_header_focus (tree_view, direction, TRUE);
7994           return TRUE;
7995         case GTK_DIR_TAB_BACKWARD:
7996         case GTK_DIR_UP:
7997           return FALSE;
7998         case GTK_DIR_TAB_FORWARD:
7999         case GTK_DIR_DOWN:
8000           gtk_widget_grab_focus (widget);
8001           return TRUE;
8002         default:
8003           g_assert_not_reached ();
8004           return FALSE;
8005         }
8006     }
8007
8008   /* Case 2. We don't have focus at all. */
8009   if (!gtk_widget_has_focus (widget))
8010     {
8011       if (!gtk_tree_view_header_focus (tree_view, direction, FALSE))
8012         gtk_widget_grab_focus (widget);
8013       return TRUE;
8014     }
8015
8016   /* Case 3. We have focus already. */
8017   if (direction == GTK_DIR_TAB_BACKWARD)
8018     return (gtk_tree_view_header_focus (tree_view, direction, FALSE));
8019   else if (direction == GTK_DIR_TAB_FORWARD)
8020     return FALSE;
8021
8022   /* Other directions caught by the keybindings */
8023   gtk_widget_grab_focus (widget);
8024   return TRUE;
8025 }
8026
8027 static void
8028 gtk_tree_view_grab_focus (GtkWidget *widget)
8029 {
8030   GTK_WIDGET_CLASS (gtk_tree_view_parent_class)->grab_focus (widget);
8031
8032   gtk_tree_view_focus_to_cursor (GTK_TREE_VIEW (widget));
8033 }
8034
8035 static void
8036 gtk_tree_view_style_set (GtkWidget *widget,
8037                          GtkStyle *previous_style)
8038 {
8039   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
8040   GtkStyle *style;
8041   GList *list;
8042   GtkTreeViewColumn *column;
8043
8044   if (gtk_widget_get_realized (widget))
8045     {
8046       style = gtk_widget_get_style (widget);
8047       gdk_window_set_background (tree_view->priv->bin_window,
8048                                  &style->base[gtk_widget_get_state (widget)]);
8049       gtk_style_set_background (style, tree_view->priv->header_window, GTK_STATE_NORMAL);
8050
8051       gtk_tree_view_set_grid_lines (tree_view, tree_view->priv->grid_lines);
8052       gtk_tree_view_set_enable_tree_lines (tree_view, tree_view->priv->tree_lines_enabled);
8053     }
8054
8055   gtk_widget_style_get (widget,
8056                         "expander-size", &tree_view->priv->expander_size,
8057                         NULL);
8058   tree_view->priv->expander_size += EXPANDER_EXTRA_PADDING;
8059
8060   for (list = tree_view->priv->columns; list; list = list->next)
8061     {
8062       column = list->data;
8063       _gtk_tree_view_column_cell_set_dirty (column, TRUE);
8064     }
8065
8066   tree_view->priv->fixed_height = -1;
8067   _gtk_rbtree_mark_invalid (tree_view->priv->tree);
8068
8069   gtk_widget_queue_resize (widget);
8070 }
8071
8072
8073 static void
8074 gtk_tree_view_set_focus_child (GtkContainer *container,
8075                                GtkWidget    *child)
8076 {
8077   GtkTreeView *tree_view = GTK_TREE_VIEW (container);
8078   GList *list;
8079
8080   for (list = tree_view->priv->columns; list; list = list->next)
8081     {
8082       if (GTK_TREE_VIEW_COLUMN (list->data)->button == child)
8083         {
8084           tree_view->priv->focus_column = GTK_TREE_VIEW_COLUMN (list->data);
8085           break;
8086         }
8087     }
8088
8089   GTK_CONTAINER_CLASS (gtk_tree_view_parent_class)->set_focus_child (container, child);
8090 }
8091
8092 static void
8093 gtk_tree_view_set_adjustments (GtkTreeView   *tree_view,
8094                                GtkAdjustment *hadj,
8095                                GtkAdjustment *vadj)
8096 {
8097   gboolean need_adjust = FALSE;
8098
8099   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
8100
8101   if (hadj)
8102     g_return_if_fail (GTK_IS_ADJUSTMENT (hadj));
8103   else
8104     hadj = GTK_ADJUSTMENT (gtk_adjustment_new (0.0, 0.0, 0.0, 0.0, 0.0, 0.0));
8105   if (vadj)
8106     g_return_if_fail (GTK_IS_ADJUSTMENT (vadj));
8107   else
8108     vadj = GTK_ADJUSTMENT (gtk_adjustment_new (0.0, 0.0, 0.0, 0.0, 0.0, 0.0));
8109
8110   if (tree_view->priv->hadjustment && (tree_view->priv->hadjustment != hadj))
8111     {
8112       g_signal_handlers_disconnect_by_func (tree_view->priv->hadjustment,
8113                                             gtk_tree_view_adjustment_changed,
8114                                             tree_view);
8115       g_object_unref (tree_view->priv->hadjustment);
8116     }
8117
8118   if (tree_view->priv->vadjustment && (tree_view->priv->vadjustment != vadj))
8119     {
8120       g_signal_handlers_disconnect_by_func (tree_view->priv->vadjustment,
8121                                             gtk_tree_view_adjustment_changed,
8122                                             tree_view);
8123       g_object_unref (tree_view->priv->vadjustment);
8124     }
8125
8126   if (tree_view->priv->hadjustment != hadj)
8127     {
8128       tree_view->priv->hadjustment = hadj;
8129       g_object_ref_sink (tree_view->priv->hadjustment);
8130
8131       g_signal_connect (tree_view->priv->hadjustment, "value-changed",
8132                         G_CALLBACK (gtk_tree_view_adjustment_changed),
8133                         tree_view);
8134       need_adjust = TRUE;
8135     }
8136
8137   if (tree_view->priv->vadjustment != vadj)
8138     {
8139       tree_view->priv->vadjustment = vadj;
8140       g_object_ref_sink (tree_view->priv->vadjustment);
8141
8142       g_signal_connect (tree_view->priv->vadjustment, "value-changed",
8143                         G_CALLBACK (gtk_tree_view_adjustment_changed),
8144                         tree_view);
8145       need_adjust = TRUE;
8146     }
8147
8148   if (need_adjust)
8149     gtk_tree_view_adjustment_changed (NULL, tree_view);
8150 }
8151
8152
8153 static gboolean
8154 gtk_tree_view_real_move_cursor (GtkTreeView       *tree_view,
8155                                 GtkMovementStep    step,
8156                                 gint               count)
8157 {
8158   GdkModifierType state;
8159
8160   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
8161   g_return_val_if_fail (step == GTK_MOVEMENT_LOGICAL_POSITIONS ||
8162                         step == GTK_MOVEMENT_VISUAL_POSITIONS ||
8163                         step == GTK_MOVEMENT_DISPLAY_LINES ||
8164                         step == GTK_MOVEMENT_PAGES ||
8165                         step == GTK_MOVEMENT_BUFFER_ENDS, FALSE);
8166
8167   if (tree_view->priv->tree == NULL)
8168     return FALSE;
8169   if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
8170     return FALSE;
8171
8172   gtk_tree_view_stop_editing (tree_view, FALSE);
8173   GTK_TREE_VIEW_SET_FLAG (tree_view, GTK_TREE_VIEW_DRAW_KEYFOCUS);
8174   gtk_widget_grab_focus (GTK_WIDGET (tree_view));
8175
8176   if (gtk_get_current_event_state (&state))
8177     {
8178       if ((state & GDK_CONTROL_MASK) == GDK_CONTROL_MASK)
8179         tree_view->priv->ctrl_pressed = TRUE;
8180       if ((state & GDK_SHIFT_MASK) == GDK_SHIFT_MASK)
8181         tree_view->priv->shift_pressed = TRUE;
8182     }
8183   /* else we assume not pressed */
8184
8185   switch (step)
8186     {
8187       /* currently we make no distinction.  When we go bi-di, we need to */
8188     case GTK_MOVEMENT_LOGICAL_POSITIONS:
8189     case GTK_MOVEMENT_VISUAL_POSITIONS:
8190       gtk_tree_view_move_cursor_left_right (tree_view, count);
8191       break;
8192     case GTK_MOVEMENT_DISPLAY_LINES:
8193       gtk_tree_view_move_cursor_up_down (tree_view, count);
8194       break;
8195     case GTK_MOVEMENT_PAGES:
8196       gtk_tree_view_move_cursor_page_up_down (tree_view, count);
8197       break;
8198     case GTK_MOVEMENT_BUFFER_ENDS:
8199       gtk_tree_view_move_cursor_start_end (tree_view, count);
8200       break;
8201     default:
8202       g_assert_not_reached ();
8203     }
8204
8205   tree_view->priv->ctrl_pressed = FALSE;
8206   tree_view->priv->shift_pressed = FALSE;
8207
8208   return TRUE;
8209 }
8210
8211 static void
8212 gtk_tree_view_put (GtkTreeView *tree_view,
8213                    GtkWidget   *child_widget,
8214                    /* in bin_window coordinates */
8215                    gint         x,
8216                    gint         y,
8217                    gint         width,
8218                    gint         height)
8219 {
8220   GtkTreeViewChild *child;
8221
8222   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
8223   g_return_if_fail (GTK_IS_WIDGET (child_widget));
8224
8225   child = g_slice_new (GtkTreeViewChild);
8226
8227   child->widget = child_widget;
8228   child->x = x;
8229   child->y = y;
8230   child->width = width;
8231   child->height = height;
8232
8233   tree_view->priv->children = g_list_append (tree_view->priv->children, child);
8234
8235   if (gtk_widget_get_realized (GTK_WIDGET (tree_view)))
8236     gtk_widget_set_parent_window (child->widget, tree_view->priv->bin_window);
8237
8238   gtk_widget_set_parent (child_widget, GTK_WIDGET (tree_view));
8239 }
8240
8241 void
8242 _gtk_tree_view_child_move_resize (GtkTreeView *tree_view,
8243                                   GtkWidget   *widget,
8244                                   /* in tree coordinates */
8245                                   gint         x,
8246                                   gint         y,
8247                                   gint         width,
8248                                   gint         height)
8249 {
8250   GtkTreeViewChild *child = NULL;
8251   GList *list;
8252   GdkRectangle allocation;
8253
8254   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
8255   g_return_if_fail (GTK_IS_WIDGET (widget));
8256
8257   for (list = tree_view->priv->children; list; list = list->next)
8258     {
8259       if (((GtkTreeViewChild *)list->data)->widget == widget)
8260         {
8261           child = list->data;
8262           break;
8263         }
8264     }
8265   if (child == NULL)
8266     return;
8267
8268   allocation.x = child->x = x;
8269   allocation.y = child->y = y;
8270   allocation.width = child->width = width;
8271   allocation.height = child->height = height;
8272
8273   if (gtk_widget_get_realized (widget))
8274     gtk_widget_size_allocate (widget, &allocation);
8275 }
8276
8277
8278 /* TreeModel Callbacks
8279  */
8280
8281 static void
8282 gtk_tree_view_row_changed (GtkTreeModel *model,
8283                            GtkTreePath  *path,
8284                            GtkTreeIter  *iter,
8285                            gpointer      data)
8286 {
8287   GtkTreeView *tree_view = (GtkTreeView *)data;
8288   GtkRBTree *tree;
8289   GtkRBNode *node;
8290   gboolean free_path = FALSE;
8291   GList *list;
8292   GtkTreePath *cursor_path;
8293
8294   g_return_if_fail (path != NULL || iter != NULL);
8295
8296   if (tree_view->priv->cursor != NULL)
8297     cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
8298   else
8299     cursor_path = NULL;
8300
8301   if (tree_view->priv->edited_column &&
8302       (cursor_path == NULL || gtk_tree_path_compare (cursor_path, path) == 0))
8303     gtk_tree_view_stop_editing (tree_view, TRUE);
8304
8305   if (cursor_path != NULL)
8306     gtk_tree_path_free (cursor_path);
8307
8308   if (path == NULL)
8309     {
8310       path = gtk_tree_model_get_path (model, iter);
8311       free_path = TRUE;
8312     }
8313   else if (iter == NULL)
8314     gtk_tree_model_get_iter (model, iter, path);
8315
8316   if (_gtk_tree_view_find_node (tree_view,
8317                                 path,
8318                                 &tree,
8319                                 &node))
8320     /* We aren't actually showing the node */
8321     goto done;
8322
8323   if (tree == NULL)
8324     goto done;
8325
8326   if (tree_view->priv->fixed_height_mode
8327       && tree_view->priv->fixed_height >= 0)
8328     {
8329       _gtk_rbtree_node_set_height (tree, node, tree_view->priv->fixed_height);
8330       if (gtk_widget_get_realized (GTK_WIDGET (tree_view)))
8331         gtk_tree_view_node_queue_redraw (tree_view, tree, node);
8332     }
8333   else
8334     {
8335       _gtk_rbtree_node_mark_invalid (tree, node);
8336       for (list = tree_view->priv->columns; list; list = list->next)
8337         {
8338           GtkTreeViewColumn *column;
8339
8340           column = list->data;
8341           if (! column->visible)
8342             continue;
8343
8344           if (column->column_type == GTK_TREE_VIEW_COLUMN_AUTOSIZE)
8345             {
8346               _gtk_tree_view_column_cell_set_dirty (column, TRUE);
8347             }
8348         }
8349     }
8350
8351  done:
8352   if (!tree_view->priv->fixed_height_mode &&
8353       gtk_widget_get_realized (GTK_WIDGET (tree_view)))
8354     install_presize_handler (tree_view);
8355   if (free_path)
8356     gtk_tree_path_free (path);
8357 }
8358
8359 static void
8360 gtk_tree_view_row_inserted (GtkTreeModel *model,
8361                             GtkTreePath  *path,
8362                             GtkTreeIter  *iter,
8363                             gpointer      data)
8364 {
8365   GtkTreeView *tree_view = (GtkTreeView *) data;
8366   gint *indices;
8367   GtkRBTree *tmptree, *tree;
8368   GtkRBNode *tmpnode = NULL;
8369   gint depth;
8370   gint i = 0;
8371   gint height;
8372   gboolean free_path = FALSE;
8373   gboolean node_visible = TRUE;
8374
8375   g_return_if_fail (path != NULL || iter != NULL);
8376
8377   if (tree_view->priv->fixed_height_mode
8378       && tree_view->priv->fixed_height >= 0)
8379     height = tree_view->priv->fixed_height;
8380   else
8381     height = 0;
8382
8383   if (path == NULL)
8384     {
8385       path = gtk_tree_model_get_path (model, iter);
8386       free_path = TRUE;
8387     }
8388   else if (iter == NULL)
8389     gtk_tree_model_get_iter (model, iter, path);
8390
8391   if (tree_view->priv->tree == NULL)
8392     tree_view->priv->tree = _gtk_rbtree_new ();
8393
8394   tmptree = tree = tree_view->priv->tree;
8395
8396   /* Update all row-references */
8397   gtk_tree_row_reference_inserted (G_OBJECT (data), path);
8398   depth = gtk_tree_path_get_depth (path);
8399   indices = gtk_tree_path_get_indices (path);
8400
8401   /* First, find the parent tree */
8402   while (i < depth - 1)
8403     {
8404       if (tmptree == NULL)
8405         {
8406           /* We aren't showing the node */
8407           node_visible = FALSE;
8408           goto done;
8409         }
8410
8411       tmpnode = _gtk_rbtree_find_count (tmptree, indices[i] + 1);
8412       if (tmpnode == NULL)
8413         {
8414           g_warning ("A node was inserted with a parent that's not in the tree.\n" \
8415                      "This possibly means that a GtkTreeModel inserted a child node\n" \
8416                      "before the parent was inserted.");
8417           goto done;
8418         }
8419       else if (!GTK_RBNODE_FLAG_SET (tmpnode, GTK_RBNODE_IS_PARENT))
8420         {
8421           /* FIXME enforce correct behavior on model, probably */
8422           /* In theory, the model should have emitted has_child_toggled here.  We
8423            * try to catch it anyway, just to be safe, in case the model hasn't.
8424            */
8425           GtkTreePath *tmppath = _gtk_tree_view_find_path (tree_view,
8426                                                            tree,
8427                                                            tmpnode);
8428           gtk_tree_view_row_has_child_toggled (model, tmppath, NULL, data);
8429           gtk_tree_path_free (tmppath);
8430           goto done;
8431         }
8432
8433       tmptree = tmpnode->children;
8434       tree = tmptree;
8435       i++;
8436     }
8437
8438   if (tree == NULL)
8439     {
8440       node_visible = FALSE;
8441       goto done;
8442     }
8443
8444   /* ref the node */
8445   gtk_tree_model_ref_node (tree_view->priv->model, iter);
8446   if (indices[depth - 1] == 0)
8447     {
8448       tmpnode = _gtk_rbtree_find_count (tree, 1);
8449       tmpnode = _gtk_rbtree_insert_before (tree, tmpnode, height, FALSE);
8450     }
8451   else
8452     {
8453       tmpnode = _gtk_rbtree_find_count (tree, indices[depth - 1]);
8454       tmpnode = _gtk_rbtree_insert_after (tree, tmpnode, height, FALSE);
8455     }
8456
8457  done:
8458   if (height > 0)
8459     {
8460       if (tree)
8461         _gtk_rbtree_node_mark_valid (tree, tmpnode);
8462
8463       if (node_visible && node_is_visible (tree_view, tree, tmpnode))
8464         gtk_widget_queue_resize (GTK_WIDGET (tree_view));
8465       else
8466         gtk_widget_queue_resize_no_redraw (GTK_WIDGET (tree_view));
8467     }
8468   else
8469     install_presize_handler (tree_view);
8470   if (free_path)
8471     gtk_tree_path_free (path);
8472 }
8473
8474 static void
8475 gtk_tree_view_row_has_child_toggled (GtkTreeModel *model,
8476                                      GtkTreePath  *path,
8477                                      GtkTreeIter  *iter,
8478                                      gpointer      data)
8479 {
8480   GtkTreeView *tree_view = (GtkTreeView *)data;
8481   GtkTreeIter real_iter;
8482   gboolean has_child;
8483   GtkRBTree *tree;
8484   GtkRBNode *node;
8485   gboolean free_path = FALSE;
8486
8487   g_return_if_fail (path != NULL || iter != NULL);
8488
8489   if (iter)
8490     real_iter = *iter;
8491
8492   if (path == NULL)
8493     {
8494       path = gtk_tree_model_get_path (model, iter);
8495       free_path = TRUE;
8496     }
8497   else if (iter == NULL)
8498     gtk_tree_model_get_iter (model, &real_iter, path);
8499
8500   if (_gtk_tree_view_find_node (tree_view,
8501                                 path,
8502                                 &tree,
8503                                 &node))
8504     /* We aren't actually showing the node */
8505     goto done;
8506
8507   if (tree == NULL)
8508     goto done;
8509
8510   has_child = gtk_tree_model_iter_has_child (model, &real_iter);
8511   /* Sanity check.
8512    */
8513   if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT) == has_child)
8514     goto done;
8515
8516   if (has_child)
8517     GTK_RBNODE_SET_FLAG (node, GTK_RBNODE_IS_PARENT);
8518   else
8519     GTK_RBNODE_UNSET_FLAG (node, GTK_RBNODE_IS_PARENT);
8520
8521   if (has_child && GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_IS_LIST))
8522     {
8523       GTK_TREE_VIEW_UNSET_FLAG (tree_view, GTK_TREE_VIEW_IS_LIST);
8524       if (GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_SHOW_EXPANDERS))
8525         {
8526           GList *list;
8527
8528           for (list = tree_view->priv->columns; list; list = list->next)
8529             if (GTK_TREE_VIEW_COLUMN (list->data)->visible)
8530               {
8531                 GTK_TREE_VIEW_COLUMN (list->data)->dirty = TRUE;
8532                 _gtk_tree_view_column_cell_set_dirty (GTK_TREE_VIEW_COLUMN (list->data), TRUE);
8533                 break;
8534               }
8535         }
8536       gtk_widget_queue_resize (GTK_WIDGET (tree_view));
8537     }
8538   else
8539     {
8540       _gtk_tree_view_queue_draw_node (tree_view, tree, node, NULL);
8541     }
8542
8543  done:
8544   if (free_path)
8545     gtk_tree_path_free (path);
8546 }
8547
8548 static void
8549 count_children_helper (GtkRBTree *tree,
8550                        GtkRBNode *node,
8551                        gpointer   data)
8552 {
8553   if (node->children)
8554     _gtk_rbtree_traverse (node->children, node->children->root, G_POST_ORDER, count_children_helper, data);
8555   (*((gint *)data))++;
8556 }
8557
8558 static void
8559 check_selection_helper (GtkRBTree *tree,
8560                         GtkRBNode *node,
8561                         gpointer   data)
8562 {
8563   gint *value = (gint *)data;
8564
8565   *value = GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SELECTED);
8566
8567   if (node->children && !*value)
8568     _gtk_rbtree_traverse (node->children, node->children->root, G_POST_ORDER, check_selection_helper, data);
8569 }
8570
8571 static void
8572 gtk_tree_view_row_deleted (GtkTreeModel *model,
8573                            GtkTreePath  *path,
8574                            gpointer      data)
8575 {
8576   GtkTreeView *tree_view = (GtkTreeView *)data;
8577   GtkRBTree *tree;
8578   GtkRBNode *node;
8579   GList *list;
8580   gint selection_changed = FALSE;
8581
8582   g_return_if_fail (path != NULL);
8583
8584   gtk_tree_row_reference_deleted (G_OBJECT (data), path);
8585
8586   if (_gtk_tree_view_find_node (tree_view, path, &tree, &node))
8587     return;
8588
8589   if (tree == NULL)
8590     return;
8591
8592   /* check if the selection has been changed */
8593   _gtk_rbtree_traverse (tree, node, G_POST_ORDER,
8594                         check_selection_helper, &selection_changed);
8595
8596   for (list = tree_view->priv->columns; list; list = list->next)
8597     if (((GtkTreeViewColumn *)list->data)->visible &&
8598         ((GtkTreeViewColumn *)list->data)->column_type == GTK_TREE_VIEW_COLUMN_AUTOSIZE)
8599       _gtk_tree_view_column_cell_set_dirty ((GtkTreeViewColumn *)list->data, TRUE);
8600
8601   /* Ensure we don't have a dangling pointer to a dead node */
8602   ensure_unprelighted (tree_view);
8603
8604   /* Cancel editting if we've started */
8605   gtk_tree_view_stop_editing (tree_view, TRUE);
8606
8607   /* If we have a node expanded/collapsed timeout, remove it */
8608   remove_expand_collapse_timeout (tree_view);
8609
8610   if (tree_view->priv->destroy_count_func)
8611     {
8612       gint child_count = 0;
8613       if (node->children)
8614         _gtk_rbtree_traverse (node->children, node->children->root, G_POST_ORDER, count_children_helper, &child_count);
8615       tree_view->priv->destroy_count_func (tree_view, path, child_count, tree_view->priv->destroy_count_data);
8616     }
8617
8618   if (tree->root->count == 1)
8619     {
8620       if (tree_view->priv->tree == tree)
8621         tree_view->priv->tree = NULL;
8622
8623       _gtk_rbtree_remove (tree);
8624     }
8625   else
8626     {
8627       _gtk_rbtree_remove_node (tree, node);
8628     }
8629
8630   if (! gtk_tree_row_reference_valid (tree_view->priv->top_row))
8631     {
8632       gtk_tree_row_reference_free (tree_view->priv->top_row);
8633       tree_view->priv->top_row = NULL;
8634     }
8635
8636   install_scroll_sync_handler (tree_view);
8637
8638   gtk_widget_queue_resize (GTK_WIDGET (tree_view));
8639
8640   if (selection_changed)
8641     g_signal_emit_by_name (tree_view->priv->selection, "changed");
8642 }
8643
8644 static void
8645 gtk_tree_view_rows_reordered (GtkTreeModel *model,
8646                               GtkTreePath  *parent,
8647                               GtkTreeIter  *iter,
8648                               gint         *new_order,
8649                               gpointer      data)
8650 {
8651   GtkTreeView *tree_view = GTK_TREE_VIEW (data);
8652   GtkRBTree *tree;
8653   GtkRBNode *node;
8654   gint len;
8655
8656   len = gtk_tree_model_iter_n_children (model, iter);
8657
8658   if (len < 2)
8659     return;
8660
8661   gtk_tree_row_reference_reordered (G_OBJECT (data),
8662                                     parent,
8663                                     iter,
8664                                     new_order);
8665
8666   if (_gtk_tree_view_find_node (tree_view,
8667                                 parent,
8668                                 &tree,
8669                                 &node))
8670     return;
8671
8672   /* We need to special case the parent path */
8673   if (tree == NULL)
8674     tree = tree_view->priv->tree;
8675   else
8676     tree = node->children;
8677
8678   if (tree == NULL)
8679     return;
8680
8681   if (tree_view->priv->edited_column)
8682     gtk_tree_view_stop_editing (tree_view, TRUE);
8683
8684   /* we need to be unprelighted */
8685   ensure_unprelighted (tree_view);
8686
8687   /* clear the timeout */
8688   cancel_arrow_animation (tree_view);
8689
8690   _gtk_rbtree_reorder (tree, new_order, len);
8691
8692   gtk_widget_queue_draw (GTK_WIDGET (tree_view));
8693
8694   gtk_tree_view_dy_to_top_row (tree_view);
8695 }
8696
8697
8698 /* Internal tree functions
8699  */
8700
8701
8702 static void
8703 gtk_tree_view_get_background_xrange (GtkTreeView       *tree_view,
8704                                      GtkRBTree         *tree,
8705                                      GtkTreeViewColumn *column,
8706                                      gint              *x1,
8707                                      gint              *x2)
8708 {
8709   GtkTreeViewColumn *tmp_column = NULL;
8710   gint total_width;
8711   GList *list;
8712   gboolean rtl;
8713
8714   if (x1)
8715     *x1 = 0;
8716
8717   if (x2)
8718     *x2 = 0;
8719
8720   rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
8721
8722   total_width = 0;
8723   for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns));
8724        list;
8725        list = (rtl ? list->prev : list->next))
8726     {
8727       tmp_column = list->data;
8728
8729       if (tmp_column == column)
8730         break;
8731
8732       if (tmp_column->visible)
8733         total_width += tmp_column->width;
8734     }
8735
8736   if (tmp_column != column)
8737     {
8738       g_warning (G_STRLOC": passed-in column isn't in the tree");
8739       return;
8740     }
8741
8742   if (x1)
8743     *x1 = total_width;
8744
8745   if (x2)
8746     {
8747       if (column->visible)
8748         *x2 = total_width + column->width;
8749       else
8750         *x2 = total_width; /* width of 0 */
8751     }
8752 }
8753 static void
8754 gtk_tree_view_get_arrow_xrange (GtkTreeView *tree_view,
8755                                 GtkRBTree   *tree,
8756                                 gint        *x1,
8757                                 gint        *x2)
8758 {
8759   gint x_offset = 0;
8760   GList *list;
8761   GtkTreeViewColumn *tmp_column = NULL;
8762   gint total_width;
8763   gboolean indent_expanders;
8764   gboolean rtl;
8765
8766   rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
8767
8768   total_width = 0;
8769   for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns));
8770        list;
8771        list = (rtl ? list->prev : list->next))
8772     {
8773       tmp_column = list->data;
8774
8775       if (gtk_tree_view_is_expander_column (tree_view, tmp_column))
8776         {
8777           if (rtl)
8778             x_offset = total_width + tmp_column->width - tree_view->priv->expander_size;
8779           else
8780             x_offset = total_width;
8781           break;
8782         }
8783
8784       if (tmp_column->visible)
8785         total_width += tmp_column->width;
8786     }
8787
8788   gtk_widget_style_get (GTK_WIDGET (tree_view),
8789                         "indent-expanders", &indent_expanders,
8790                         NULL);
8791
8792   if (indent_expanders)
8793     {
8794       if (rtl)
8795         x_offset -= tree_view->priv->expander_size * _gtk_rbtree_get_depth (tree);
8796       else
8797         x_offset += tree_view->priv->expander_size * _gtk_rbtree_get_depth (tree);
8798     }
8799
8800   *x1 = x_offset;
8801
8802   if (tmp_column && tmp_column->visible)
8803     /* +1 because x2 isn't included in the range. */
8804     *x2 = *x1 + tree_view->priv->expander_size + 1;
8805   else
8806     *x2 = *x1;
8807 }
8808
8809 static void
8810 gtk_tree_view_build_tree (GtkTreeView *tree_view,
8811                           GtkRBTree   *tree,
8812                           GtkTreeIter *iter,
8813                           gint         depth,
8814                           gboolean     recurse)
8815 {
8816   GtkRBNode *temp = NULL;
8817   GtkTreePath *path = NULL;
8818   gboolean is_list = GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_IS_LIST);
8819
8820   do
8821     {
8822       gtk_tree_model_ref_node (tree_view->priv->model, iter);
8823       temp = _gtk_rbtree_insert_after (tree, temp, 0, FALSE);
8824
8825       if (tree_view->priv->fixed_height > 0)
8826         {
8827           if (GTK_RBNODE_FLAG_SET (temp, GTK_RBNODE_INVALID))
8828             {
8829               _gtk_rbtree_node_set_height (tree, temp, tree_view->priv->fixed_height);
8830               _gtk_rbtree_node_mark_valid (tree, temp);
8831             }
8832         }
8833
8834       if (is_list)
8835         continue;
8836
8837       if (recurse)
8838         {
8839           GtkTreeIter child;
8840
8841           if (!path)
8842             path = gtk_tree_model_get_path (tree_view->priv->model, iter);
8843           else
8844             gtk_tree_path_next (path);
8845
8846           if (gtk_tree_model_iter_children (tree_view->priv->model, &child, iter))
8847             {
8848               gboolean expand;
8849
8850               g_signal_emit (tree_view, tree_view_signals[TEST_EXPAND_ROW], 0, iter, path, &expand);
8851
8852               if (gtk_tree_model_iter_has_child (tree_view->priv->model, iter)
8853                   && !expand)
8854                 {
8855                   temp->children = _gtk_rbtree_new ();
8856                   temp->children->parent_tree = tree;
8857                   temp->children->parent_node = temp;
8858                   gtk_tree_view_build_tree (tree_view, temp->children, &child, depth + 1, recurse);
8859                 }
8860             }
8861         }
8862
8863       if (gtk_tree_model_iter_has_child (tree_view->priv->model, iter))
8864         {
8865           if ((temp->flags&GTK_RBNODE_IS_PARENT) != GTK_RBNODE_IS_PARENT)
8866             temp->flags ^= GTK_RBNODE_IS_PARENT;
8867         }
8868     }
8869   while (gtk_tree_model_iter_next (tree_view->priv->model, iter));
8870
8871   if (path)
8872     gtk_tree_path_free (path);
8873 }
8874
8875 /* Make sure the node is visible vertically */
8876 static void
8877 gtk_tree_view_clamp_node_visible (GtkTreeView *tree_view,
8878                                   GtkRBTree   *tree,
8879                                   GtkRBNode   *node)
8880 {
8881   gint node_dy, height;
8882   GtkTreePath *path = NULL;
8883
8884   if (!gtk_widget_get_realized (GTK_WIDGET (tree_view)))
8885     return;
8886
8887   /* just return if the node is visible, avoiding a costly expose */
8888   node_dy = _gtk_rbtree_node_find_offset (tree, node);
8889   height = ROW_HEIGHT (tree_view, GTK_RBNODE_GET_HEIGHT (node));
8890   if (! GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_INVALID)
8891       && node_dy >= tree_view->priv->vadjustment->value
8892       && node_dy + height <= (tree_view->priv->vadjustment->value
8893                               + tree_view->priv->vadjustment->page_size))
8894     return;
8895
8896   path = _gtk_tree_view_find_path (tree_view, tree, node);
8897   if (path)
8898     {
8899       /* We process updates because we want to clear old selected items when we scroll.
8900        * if this is removed, we get a "selection streak" at the bottom. */
8901       gdk_window_process_updates (tree_view->priv->bin_window, TRUE);
8902       gtk_tree_view_scroll_to_cell (tree_view, path, NULL, FALSE, 0.0, 0.0);
8903       gtk_tree_path_free (path);
8904     }
8905 }
8906
8907 static void
8908 gtk_tree_view_clamp_column_visible (GtkTreeView       *tree_view,
8909                                     GtkTreeViewColumn *column,
8910                                     gboolean           focus_to_cell)
8911 {
8912   GtkAllocation allocation;
8913   gint x, width;
8914
8915   if (column == NULL)
8916     return;
8917
8918   gtk_widget_get_allocation (column->button, &allocation);
8919   x = allocation.x;
8920   width = allocation.width;
8921
8922   if (width > tree_view->priv->hadjustment->page_size)
8923     {
8924       /* The column is larger than the horizontal page size.  If the
8925        * column has cells which can be focussed individually, then we make
8926        * sure the cell which gets focus is fully visible (if even the
8927        * focus cell is bigger than the page size, we make sure the
8928        * left-hand side of the cell is visible).
8929        *
8930        * If the column does not have those so-called special cells, we
8931        * make sure the left-hand side of the column is visible.
8932        */
8933
8934       if (focus_to_cell && gtk_tree_view_has_special_cell (tree_view))
8935         {
8936           GtkTreePath *cursor_path;
8937           GdkRectangle background_area, cell_area, focus_area;
8938
8939           cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
8940
8941           gtk_tree_view_get_cell_area (tree_view,
8942                                        cursor_path, column, &cell_area);
8943           gtk_tree_view_get_background_area (tree_view,
8944                                              cursor_path, column,
8945                                              &background_area);
8946
8947           gtk_tree_path_free (cursor_path);
8948
8949           _gtk_tree_view_column_get_focus_area (column,
8950                                                 &background_area,
8951                                                 &cell_area,
8952                                                 &focus_area);
8953
8954           x = focus_area.x;
8955           width = focus_area.width;
8956
8957           if (width < tree_view->priv->hadjustment->page_size)
8958             {
8959               if ((tree_view->priv->hadjustment->value + tree_view->priv->hadjustment->page_size) < (x + width))
8960                 gtk_adjustment_set_value (tree_view->priv->hadjustment,
8961                                           x + width - tree_view->priv->hadjustment->page_size);
8962               else if (tree_view->priv->hadjustment->value > x)
8963                 gtk_adjustment_set_value (tree_view->priv->hadjustment, x);
8964             }
8965         }
8966
8967       gtk_adjustment_set_value (tree_view->priv->hadjustment, x);
8968     }
8969   else
8970     {
8971       if ((tree_view->priv->hadjustment->value + tree_view->priv->hadjustment->page_size) < (x + width))
8972           gtk_adjustment_set_value (tree_view->priv->hadjustment,
8973                                     x + width - tree_view->priv->hadjustment->page_size);
8974       else if (tree_view->priv->hadjustment->value > x)
8975         gtk_adjustment_set_value (tree_view->priv->hadjustment, x);
8976   }
8977 }
8978
8979 /* This function could be more efficient.  I'll optimize it if profiling seems
8980  * to imply that it is important */
8981 GtkTreePath *
8982 _gtk_tree_view_find_path (GtkTreeView *tree_view,
8983                           GtkRBTree   *tree,
8984                           GtkRBNode   *node)
8985 {
8986   GtkTreePath *path;
8987   GtkRBTree *tmp_tree;
8988   GtkRBNode *tmp_node, *last;
8989   gint count;
8990
8991   path = gtk_tree_path_new ();
8992
8993   g_return_val_if_fail (node != NULL, path);
8994   g_return_val_if_fail (node != tree->nil, path);
8995
8996   count = 1 + node->left->count;
8997
8998   last = node;
8999   tmp_node = node->parent;
9000   tmp_tree = tree;
9001   while (tmp_tree)
9002     {
9003       while (tmp_node != tmp_tree->nil)
9004         {
9005           if (tmp_node->right == last)
9006             count += 1 + tmp_node->left->count;
9007           last = tmp_node;
9008           tmp_node = tmp_node->parent;
9009         }
9010       gtk_tree_path_prepend_index (path, count - 1);
9011       last = tmp_tree->parent_node;
9012       tmp_tree = tmp_tree->parent_tree;
9013       if (last)
9014         {
9015           count = 1 + last->left->count;
9016           tmp_node = last->parent;
9017         }
9018     }
9019   return path;
9020 }
9021
9022 /* Returns TRUE if we ran out of tree before finding the path.  If the path is
9023  * invalid (ie. points to a node that's not in the tree), *tree and *node are
9024  * both set to NULL.
9025  */
9026 gboolean
9027 _gtk_tree_view_find_node (GtkTreeView  *tree_view,
9028                           GtkTreePath  *path,
9029                           GtkRBTree   **tree,
9030                           GtkRBNode   **node)
9031 {
9032   GtkRBNode *tmpnode = NULL;
9033   GtkRBTree *tmptree = tree_view->priv->tree;
9034   gint *indices = gtk_tree_path_get_indices (path);
9035   gint depth = gtk_tree_path_get_depth (path);
9036   gint i = 0;
9037
9038   *node = NULL;
9039   *tree = NULL;
9040
9041   if (depth == 0 || tmptree == NULL)
9042     return FALSE;
9043   do
9044     {
9045       tmpnode = _gtk_rbtree_find_count (tmptree, indices[i] + 1);
9046       ++i;
9047       if (tmpnode == NULL)
9048         {
9049           *tree = NULL;
9050           *node = NULL;
9051           return FALSE;
9052         }
9053       if (i >= depth)
9054         {
9055           *tree = tmptree;
9056           *node = tmpnode;
9057           return FALSE;
9058         }
9059       *tree = tmptree;
9060       *node = tmpnode;
9061       tmptree = tmpnode->children;
9062       if (tmptree == NULL)
9063         return TRUE;
9064     }
9065   while (1);
9066 }
9067
9068 static gboolean
9069 gtk_tree_view_is_expander_column (GtkTreeView       *tree_view,
9070                                   GtkTreeViewColumn *column)
9071 {
9072   GList *list;
9073
9074   if (GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_IS_LIST))
9075     return FALSE;
9076
9077   if (tree_view->priv->expander_column != NULL)
9078     {
9079       if (tree_view->priv->expander_column == column)
9080         return TRUE;
9081       return FALSE;
9082     }
9083   else
9084     {
9085       for (list = tree_view->priv->columns;
9086            list;
9087            list = list->next)
9088         if (((GtkTreeViewColumn *)list->data)->visible)
9089           break;
9090       if (list && list->data == column)
9091         return TRUE;
9092     }
9093   return FALSE;
9094 }
9095
9096 static void
9097 gtk_tree_view_add_move_binding (GtkBindingSet  *binding_set,
9098                                 guint           keyval,
9099                                 guint           modmask,
9100                                 gboolean        add_shifted_binding,
9101                                 GtkMovementStep step,
9102                                 gint            count)
9103 {
9104
9105   gtk_binding_entry_add_signal (binding_set, keyval, modmask,
9106                                 "move-cursor", 2,
9107                                 G_TYPE_ENUM, step,
9108                                 G_TYPE_INT, count);
9109
9110   if (add_shifted_binding)
9111     gtk_binding_entry_add_signal (binding_set, keyval, GDK_SHIFT_MASK,
9112                                   "move-cursor", 2,
9113                                   G_TYPE_ENUM, step,
9114                                   G_TYPE_INT, count);
9115
9116   if ((modmask & GDK_CONTROL_MASK) == GDK_CONTROL_MASK)
9117    return;
9118
9119   gtk_binding_entry_add_signal (binding_set, keyval, GDK_CONTROL_MASK | GDK_SHIFT_MASK,
9120                                 "move-cursor", 2,
9121                                 G_TYPE_ENUM, step,
9122                                 G_TYPE_INT, count);
9123
9124   gtk_binding_entry_add_signal (binding_set, keyval, GDK_CONTROL_MASK,
9125                                 "move-cursor", 2,
9126                                 G_TYPE_ENUM, step,
9127                                 G_TYPE_INT, count);
9128 }
9129
9130 static gint
9131 gtk_tree_view_unref_tree_helper (GtkTreeModel *model,
9132                                  GtkTreeIter  *iter,
9133                                  GtkRBTree    *tree,
9134                                  GtkRBNode    *node)
9135 {
9136   gint retval = FALSE;
9137   do
9138     {
9139       g_return_val_if_fail (node != NULL, FALSE);
9140
9141       if (node->children)
9142         {
9143           GtkTreeIter child;
9144           GtkRBTree *new_tree;
9145           GtkRBNode *new_node;
9146
9147           new_tree = node->children;
9148           new_node = new_tree->root;
9149
9150           while (new_node && new_node->left != new_tree->nil)
9151             new_node = new_node->left;
9152
9153           if (!gtk_tree_model_iter_children (model, &child, iter))
9154             return FALSE;
9155
9156           retval = retval || gtk_tree_view_unref_tree_helper (model, &child, new_tree, new_node);
9157         }
9158
9159       if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SELECTED))
9160         retval = TRUE;
9161       gtk_tree_model_unref_node (model, iter);
9162       node = _gtk_rbtree_next (tree, node);
9163     }
9164   while (gtk_tree_model_iter_next (model, iter));
9165
9166   return retval;
9167 }
9168
9169 static gint
9170 gtk_tree_view_unref_and_check_selection_tree (GtkTreeView *tree_view,
9171                                               GtkRBTree   *tree)
9172 {
9173   GtkTreeIter iter;
9174   GtkTreePath *path;
9175   GtkRBNode *node;
9176   gint retval;
9177
9178   if (!tree)
9179     return FALSE;
9180
9181   node = tree->root;
9182   while (node && node->left != tree->nil)
9183     node = node->left;
9184
9185   g_return_val_if_fail (node != NULL, FALSE);
9186   path = _gtk_tree_view_find_path (tree_view, tree, node);
9187   gtk_tree_model_get_iter (GTK_TREE_MODEL (tree_view->priv->model),
9188                            &iter, path);
9189   retval = gtk_tree_view_unref_tree_helper (GTK_TREE_MODEL (tree_view->priv->model), &iter, tree, node);
9190   gtk_tree_path_free (path);
9191
9192   return retval;
9193 }
9194
9195 static void
9196 gtk_tree_view_set_column_drag_info (GtkTreeView       *tree_view,
9197                                     GtkTreeViewColumn *column)
9198 {
9199   GtkTreeViewColumn *left_column;
9200   GtkTreeViewColumn *cur_column = NULL;
9201   GtkTreeViewColumnReorder *reorder;
9202   gboolean rtl;
9203   GList *tmp_list;
9204   gint left;
9205
9206   /* We want to precalculate the motion list such that we know what column slots
9207    * are available.
9208    */
9209   left_column = NULL;
9210   rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
9211
9212   /* First, identify all possible drop spots */
9213   if (rtl)
9214     tmp_list = g_list_last (tree_view->priv->columns);
9215   else
9216     tmp_list = g_list_first (tree_view->priv->columns);
9217
9218   while (tmp_list)
9219     {
9220       cur_column = GTK_TREE_VIEW_COLUMN (tmp_list->data);
9221       tmp_list = rtl?g_list_previous (tmp_list):g_list_next (tmp_list);
9222
9223       if (cur_column->visible == FALSE)
9224         continue;
9225
9226       /* If it's not the column moving and func tells us to skip over the column, we continue. */
9227       if (left_column != column && cur_column != column &&
9228           tree_view->priv->column_drop_func &&
9229           ! tree_view->priv->column_drop_func (tree_view, column, left_column, cur_column, tree_view->priv->column_drop_func_data))
9230         {
9231           left_column = cur_column;
9232           continue;
9233         }
9234       reorder = g_slice_new0 (GtkTreeViewColumnReorder);
9235       reorder->left_column = left_column;
9236       left_column = reorder->right_column = cur_column;
9237
9238       tree_view->priv->column_drag_info = g_list_append (tree_view->priv->column_drag_info, reorder);
9239     }
9240
9241   /* Add the last one */
9242   if (tree_view->priv->column_drop_func == NULL ||
9243       ((left_column != column) &&
9244        tree_view->priv->column_drop_func (tree_view, column, left_column, NULL, tree_view->priv->column_drop_func_data)))
9245     {
9246       reorder = g_slice_new0 (GtkTreeViewColumnReorder);
9247       reorder->left_column = left_column;
9248       reorder->right_column = NULL;
9249       tree_view->priv->column_drag_info = g_list_append (tree_view->priv->column_drag_info, reorder);
9250     }
9251
9252   /* We quickly check to see if it even makes sense to reorder columns. */
9253   /* If there is nothing that can be moved, then we return */
9254
9255   if (tree_view->priv->column_drag_info == NULL)
9256     return;
9257
9258   /* We know there are always 2 slots possbile, as you can always return column. */
9259   /* If that's all there is, return */
9260   if (tree_view->priv->column_drag_info->next == NULL ||
9261       (tree_view->priv->column_drag_info->next->next == NULL &&
9262        ((GtkTreeViewColumnReorder *)tree_view->priv->column_drag_info->data)->right_column == column &&
9263        ((GtkTreeViewColumnReorder *)tree_view->priv->column_drag_info->next->data)->left_column == column))
9264     {
9265       for (tmp_list = tree_view->priv->column_drag_info; tmp_list; tmp_list = tmp_list->next)
9266         g_slice_free (GtkTreeViewColumnReorder, tmp_list->data);
9267       g_list_free (tree_view->priv->column_drag_info);
9268       tree_view->priv->column_drag_info = NULL;
9269       return;
9270     }
9271   /* We fill in the ranges for the columns, now that we've isolated them */
9272   left = - TREE_VIEW_COLUMN_DRAG_DEAD_MULTIPLIER (tree_view);
9273
9274   for (tmp_list = tree_view->priv->column_drag_info; tmp_list; tmp_list = tmp_list->next)
9275     {
9276       reorder = (GtkTreeViewColumnReorder *) tmp_list->data;
9277
9278       reorder->left_align = left;
9279       if (tmp_list->next != NULL)
9280         {
9281           GtkAllocation right_allocation, left_allocation;
9282
9283           g_assert (tmp_list->next->data);
9284
9285           gtk_widget_get_allocation (reorder->right_column->button, &right_allocation);
9286           gtk_widget_get_allocation (((GtkTreeViewColumnReorder *)tmp_list->next->data)->left_column->button, &left_allocation);
9287           left = reorder->right_align = (right_allocation.x + right_allocation.width + left_allocation.x) / 2;
9288         }
9289       else
9290         {
9291           reorder->right_align = gdk_window_get_width (tree_view->priv->header_window)
9292                                  + TREE_VIEW_COLUMN_DRAG_DEAD_MULTIPLIER (tree_view);
9293         }
9294     }
9295 }
9296
9297 void
9298 _gtk_tree_view_column_start_drag (GtkTreeView       *tree_view,
9299                                   GtkTreeViewColumn *column,
9300                                   GdkDevice         *device)
9301 {
9302   GdkEvent *send_event;
9303   GtkAllocation allocation;
9304   GtkAllocation button_allocation;
9305   GdkScreen *screen = gtk_widget_get_screen (GTK_WIDGET (tree_view));
9306   GdkDisplay *display = gdk_screen_get_display (screen);
9307
9308   g_return_if_fail (tree_view->priv->column_drag_info == NULL);
9309   g_return_if_fail (tree_view->priv->cur_reorder == NULL);
9310
9311   gtk_tree_view_set_column_drag_info (tree_view, column);
9312
9313   if (tree_view->priv->column_drag_info == NULL)
9314     return;
9315
9316   if (tree_view->priv->drag_window == NULL)
9317     {
9318       GdkWindowAttr attributes;
9319       guint attributes_mask;
9320
9321       gtk_widget_get_allocation (column->button, &button_allocation);
9322
9323       attributes.window_type = GDK_WINDOW_CHILD;
9324       attributes.wclass = GDK_INPUT_OUTPUT;
9325       attributes.x = button_allocation.x;
9326       attributes.y = 0;
9327       attributes.width = button_allocation.width;
9328       attributes.height = button_allocation.height;
9329       attributes.visual = gtk_widget_get_visual (GTK_WIDGET (tree_view));
9330       attributes.event_mask = GDK_VISIBILITY_NOTIFY_MASK | GDK_EXPOSURE_MASK | GDK_POINTER_MOTION_MASK;
9331       attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL;
9332
9333       tree_view->priv->drag_window = gdk_window_new (tree_view->priv->bin_window,
9334                                                      &attributes,
9335                                                      attributes_mask);
9336       gdk_window_set_user_data (tree_view->priv->drag_window, GTK_WIDGET (tree_view));
9337     }
9338
9339   gdk_display_pointer_ungrab (display, GDK_CURRENT_TIME);
9340   gdk_display_keyboard_ungrab (display, GDK_CURRENT_TIME);
9341
9342   gtk_grab_remove (column->button);
9343
9344   send_event = gdk_event_new (GDK_LEAVE_NOTIFY);
9345   send_event->crossing.send_event = TRUE;
9346   send_event->crossing.window = g_object_ref (GTK_BUTTON (column->button)->event_window);
9347   send_event->crossing.subwindow = NULL;
9348   send_event->crossing.detail = GDK_NOTIFY_ANCESTOR;
9349   send_event->crossing.time = GDK_CURRENT_TIME;
9350   gdk_event_set_device (send_event, device);
9351
9352   gtk_propagate_event (column->button, send_event);
9353   gdk_event_free (send_event);
9354
9355   send_event = gdk_event_new (GDK_BUTTON_RELEASE);
9356   send_event->button.window = g_object_ref (gdk_screen_get_root_window (screen));
9357   send_event->button.send_event = TRUE;
9358   send_event->button.time = GDK_CURRENT_TIME;
9359   send_event->button.x = -1;
9360   send_event->button.y = -1;
9361   send_event->button.axes = NULL;
9362   send_event->button.state = 0;
9363   send_event->button.button = 1;
9364   send_event->button.x_root = 0;
9365   send_event->button.y_root = 0;
9366   gdk_event_set_device (send_event, device);
9367
9368   gtk_propagate_event (column->button, send_event);
9369   gdk_event_free (send_event);
9370
9371   /* Kids, don't try this at home */
9372   g_object_ref (column->button);
9373   gtk_container_remove (GTK_CONTAINER (tree_view), column->button);
9374   gtk_widget_set_parent_window (column->button, tree_view->priv->drag_window);
9375   gtk_widget_set_parent (column->button, GTK_WIDGET (tree_view));
9376   g_object_unref (column->button);
9377
9378   gtk_widget_get_allocation (column->button, &button_allocation);
9379   tree_view->priv->drag_column_x = button_allocation.x;
9380   allocation = button_allocation;
9381   allocation.x = 0;
9382   gtk_widget_size_allocate (column->button, &allocation);
9383   gtk_widget_set_parent_window (column->button, tree_view->priv->drag_window);
9384
9385   tree_view->priv->drag_column = column;
9386   gdk_window_show (tree_view->priv->drag_window);
9387
9388   gtk_widget_grab_focus (GTK_WIDGET (tree_view));
9389   while (gtk_events_pending ())
9390     gtk_main_iteration ();
9391
9392   GTK_TREE_VIEW_SET_FLAG (tree_view, GTK_TREE_VIEW_IN_COLUMN_DRAG);
9393   gdk_pointer_grab (tree_view->priv->drag_window,
9394                     FALSE,
9395                     GDK_POINTER_MOTION_MASK|GDK_BUTTON_RELEASE_MASK,
9396                     NULL, NULL, GDK_CURRENT_TIME);
9397   gdk_keyboard_grab (tree_view->priv->drag_window,
9398                      FALSE,
9399                      GDK_CURRENT_TIME);
9400 }
9401
9402 static void
9403 gtk_tree_view_queue_draw_arrow (GtkTreeView        *tree_view,
9404                                 GtkRBTree          *tree,
9405                                 GtkRBNode          *node)
9406 {
9407   GtkAllocation allocation;
9408   GdkRectangle rect;
9409
9410   if (!gtk_widget_get_realized (GTK_WIDGET (tree_view)))
9411     return;
9412
9413   gtk_widget_get_allocation (GTK_WIDGET (tree_view), &allocation);
9414   rect.x = 0;
9415   rect.width = MAX (tree_view->priv->expander_size, MAX (tree_view->priv->width, allocation.width));
9416
9417   rect.y = BACKGROUND_FIRST_PIXEL (tree_view, tree, node);
9418   rect.height = ROW_HEIGHT (tree_view, BACKGROUND_HEIGHT (node));
9419
9420   gdk_window_invalidate_rect (tree_view->priv->bin_window, &rect, TRUE);
9421 }
9422
9423 void
9424 _gtk_tree_view_queue_draw_node (GtkTreeView        *tree_view,
9425                                 GtkRBTree          *tree,
9426                                 GtkRBNode          *node,
9427                                 const GdkRectangle *clip_rect)
9428 {
9429   GtkAllocation allocation;
9430   GdkRectangle rect;
9431
9432   if (!gtk_widget_get_realized (GTK_WIDGET (tree_view)))
9433     return;
9434
9435   gtk_widget_get_allocation (GTK_WIDGET (tree_view), &allocation);
9436   rect.x = 0;
9437   rect.width = MAX (tree_view->priv->width, allocation.width);
9438
9439   rect.y = BACKGROUND_FIRST_PIXEL (tree_view, tree, node);
9440   rect.height = ROW_HEIGHT (tree_view, BACKGROUND_HEIGHT (node));
9441
9442   if (clip_rect)
9443     {
9444       GdkRectangle new_rect;
9445
9446       gdk_rectangle_intersect (clip_rect, &rect, &new_rect);
9447
9448       gdk_window_invalidate_rect (tree_view->priv->bin_window, &new_rect, TRUE);
9449     }
9450   else
9451     {
9452       gdk_window_invalidate_rect (tree_view->priv->bin_window, &rect, TRUE);
9453     }
9454 }
9455
9456 static void
9457 gtk_tree_view_queue_draw_path (GtkTreeView        *tree_view,
9458                                GtkTreePath        *path,
9459                                const GdkRectangle *clip_rect)
9460 {
9461   GtkRBTree *tree = NULL;
9462   GtkRBNode *node = NULL;
9463
9464   _gtk_tree_view_find_node (tree_view, path, &tree, &node);
9465
9466   if (tree)
9467     _gtk_tree_view_queue_draw_node (tree_view, tree, node, clip_rect);
9468 }
9469
9470 /* x and y are the mouse position
9471  */
9472 static void
9473 gtk_tree_view_draw_arrow (GtkTreeView *tree_view,
9474                           cairo_t     *cr,
9475                           GtkRBTree   *tree,
9476                           GtkRBNode   *node,
9477                           /* in bin_window coordinates */
9478                           gint         x,
9479                           gint         y)
9480 {
9481   GdkRectangle area;
9482   GtkStateType state;
9483   GtkWidget *widget;
9484   gint x_offset = 0;
9485   gint x2;
9486   gint vertical_separator;
9487   gint expander_size;
9488   GtkExpanderStyle expander_style;
9489
9490   widget = GTK_WIDGET (tree_view);
9491
9492   gtk_widget_style_get (widget,
9493                         "vertical-separator", &vertical_separator,
9494                         NULL);
9495   expander_size = tree_view->priv->expander_size - EXPANDER_EXTRA_PADDING;
9496
9497   if (! GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT))
9498     return;
9499
9500   gtk_tree_view_get_arrow_xrange (tree_view, tree, &x_offset, &x2);
9501
9502   area.x = x_offset;
9503   area.y = CELL_FIRST_PIXEL (tree_view, tree, node, vertical_separator);
9504   area.width = expander_size + 2;
9505   area.height = MAX (CELL_HEIGHT (node, vertical_separator), (expander_size - vertical_separator));
9506
9507   if (gtk_widget_get_state (widget) == GTK_STATE_INSENSITIVE)
9508     {
9509       state = GTK_STATE_INSENSITIVE;
9510     }
9511   else if (node == tree_view->priv->button_pressed_node)
9512     {
9513       if (x >= area.x && x <= (area.x + area.width) &&
9514           y >= area.y && y <= (area.y + area.height))
9515         state = GTK_STATE_ACTIVE;
9516       else
9517         state = GTK_STATE_NORMAL;
9518     }
9519   else
9520     {
9521       if (node == tree_view->priv->prelight_node &&
9522           GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_ARROW_PRELIT))
9523         state = GTK_STATE_PRELIGHT;
9524       else
9525         state = GTK_STATE_NORMAL;
9526     }
9527
9528   if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SEMI_EXPANDED))
9529     expander_style = GTK_EXPANDER_SEMI_EXPANDED;
9530   else if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SEMI_COLLAPSED))
9531     expander_style = GTK_EXPANDER_SEMI_COLLAPSED;
9532   else if (node->children != NULL)
9533     expander_style = GTK_EXPANDER_EXPANDED;
9534   else
9535     expander_style = GTK_EXPANDER_COLLAPSED;
9536
9537   gtk_paint_expander (gtk_widget_get_style (widget),
9538                       cr,
9539                       state,
9540                       widget,
9541                       "treeview",
9542                       area.x + area.width / 2,
9543                       area.y + area.height / 2,
9544                       expander_style);
9545 }
9546
9547 static void
9548 gtk_tree_view_focus_to_cursor (GtkTreeView *tree_view)
9549
9550 {
9551   GtkTreePath *cursor_path;
9552
9553   if ((tree_view->priv->tree == NULL) ||
9554       (! gtk_widget_get_realized (GTK_WIDGET (tree_view))))
9555     return;
9556
9557   cursor_path = NULL;
9558   if (tree_view->priv->cursor)
9559     cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
9560
9561   if (cursor_path == NULL)
9562     {
9563       /* Consult the selection before defaulting to the
9564        * first focusable element
9565        */
9566       GList *selected_rows;
9567       GtkTreeModel *model;
9568       GtkTreeSelection *selection;
9569
9570       selection = gtk_tree_view_get_selection (tree_view);
9571       selected_rows = gtk_tree_selection_get_selected_rows (selection, &model);
9572
9573       if (selected_rows)
9574         {
9575           cursor_path = gtk_tree_path_copy((const GtkTreePath *)(selected_rows->data));
9576           g_list_foreach (selected_rows, (GFunc)gtk_tree_path_free, NULL);
9577           g_list_free (selected_rows);
9578         }
9579       else
9580         {
9581           cursor_path = gtk_tree_path_new_first ();
9582           search_first_focusable_path (tree_view, &cursor_path,
9583                                        TRUE, NULL, NULL);
9584         }
9585
9586       gtk_tree_row_reference_free (tree_view->priv->cursor);
9587       tree_view->priv->cursor = NULL;
9588
9589       if (cursor_path)
9590         {
9591           if (tree_view->priv->selection->type == GTK_SELECTION_MULTIPLE)
9592             gtk_tree_view_real_set_cursor (tree_view, cursor_path, FALSE, FALSE);
9593           else
9594             gtk_tree_view_real_set_cursor (tree_view, cursor_path, TRUE, FALSE);
9595         }
9596     }
9597
9598   if (cursor_path)
9599     {
9600       GTK_TREE_VIEW_SET_FLAG (tree_view, GTK_TREE_VIEW_DRAW_KEYFOCUS);
9601
9602       gtk_tree_view_queue_draw_path (tree_view, cursor_path, NULL);
9603       gtk_tree_path_free (cursor_path);
9604
9605       if (tree_view->priv->focus_column == NULL)
9606         {
9607           GList *list;
9608           for (list = tree_view->priv->columns; list; list = list->next)
9609             {
9610               if (GTK_TREE_VIEW_COLUMN (list->data)->visible)
9611                 {
9612                   tree_view->priv->focus_column = GTK_TREE_VIEW_COLUMN (list->data);
9613                   break;
9614                 }
9615             }
9616         }
9617     }
9618 }
9619
9620 static void
9621 gtk_tree_view_move_cursor_up_down (GtkTreeView *tree_view,
9622                                    gint         count)
9623 {
9624   gint selection_count;
9625   GtkRBTree *cursor_tree = NULL;
9626   GtkRBNode *cursor_node = NULL;
9627   GtkRBTree *new_cursor_tree = NULL;
9628   GtkRBNode *new_cursor_node = NULL;
9629   GtkTreePath *cursor_path = NULL;
9630   gboolean grab_focus = TRUE;
9631   gboolean selectable;
9632
9633   if (! gtk_widget_has_focus (GTK_WIDGET (tree_view)))
9634     return;
9635
9636   cursor_path = NULL;
9637   if (!gtk_tree_row_reference_valid (tree_view->priv->cursor))
9638     /* FIXME: we lost the cursor; should we get the first? */
9639     return;
9640
9641   cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
9642   _gtk_tree_view_find_node (tree_view, cursor_path,
9643                             &cursor_tree, &cursor_node);
9644
9645   if (cursor_tree == NULL)
9646     /* FIXME: we lost the cursor; should we get the first? */
9647     return;
9648
9649   selection_count = gtk_tree_selection_count_selected_rows (tree_view->priv->selection);
9650   selectable = _gtk_tree_selection_row_is_selectable (tree_view->priv->selection,
9651                                                       cursor_node,
9652                                                       cursor_path);
9653
9654   if (selection_count == 0
9655       && tree_view->priv->selection->type != GTK_SELECTION_NONE
9656       && !tree_view->priv->ctrl_pressed
9657       && selectable)
9658     {
9659       /* Don't move the cursor, but just select the current node */
9660       new_cursor_tree = cursor_tree;
9661       new_cursor_node = cursor_node;
9662     }
9663   else
9664     {
9665       if (count == -1)
9666         _gtk_rbtree_prev_full (cursor_tree, cursor_node,
9667                                &new_cursor_tree, &new_cursor_node);
9668       else
9669         _gtk_rbtree_next_full (cursor_tree, cursor_node,
9670                                &new_cursor_tree, &new_cursor_node);
9671     }
9672
9673   gtk_tree_path_free (cursor_path);
9674
9675   if (new_cursor_node)
9676     {
9677       cursor_path = _gtk_tree_view_find_path (tree_view,
9678                                               new_cursor_tree, new_cursor_node);
9679
9680       search_first_focusable_path (tree_view, &cursor_path,
9681                                    (count != -1),
9682                                    &new_cursor_tree,
9683                                    &new_cursor_node);
9684
9685       if (cursor_path)
9686         gtk_tree_path_free (cursor_path);
9687     }
9688
9689   /*
9690    * If the list has only one item and multi-selection is set then select
9691    * the row (if not yet selected).
9692    */
9693   if (tree_view->priv->selection->type == GTK_SELECTION_MULTIPLE &&
9694       new_cursor_node == NULL)
9695     {
9696       if (count == -1)
9697         _gtk_rbtree_next_full (cursor_tree, cursor_node,
9698                                &new_cursor_tree, &new_cursor_node);
9699       else
9700         _gtk_rbtree_prev_full (cursor_tree, cursor_node,
9701                                &new_cursor_tree, &new_cursor_node);
9702
9703       if (new_cursor_node == NULL
9704           && !GTK_RBNODE_FLAG_SET (cursor_node, GTK_RBNODE_IS_SELECTED))
9705         {
9706           new_cursor_node = cursor_node;
9707           new_cursor_tree = cursor_tree;
9708         }
9709       else
9710         {
9711           new_cursor_node = NULL;
9712         }
9713     }
9714
9715   if (new_cursor_node)
9716     {
9717       cursor_path = _gtk_tree_view_find_path (tree_view, new_cursor_tree, new_cursor_node);
9718       gtk_tree_view_real_set_cursor (tree_view, cursor_path, TRUE, TRUE);
9719       gtk_tree_path_free (cursor_path);
9720     }
9721   else
9722     {
9723       gtk_tree_view_clamp_node_visible (tree_view, cursor_tree, cursor_node);
9724
9725       if (!tree_view->priv->shift_pressed)
9726         {
9727           if (! gtk_widget_keynav_failed (GTK_WIDGET (tree_view),
9728                                           count < 0 ?
9729                                           GTK_DIR_UP : GTK_DIR_DOWN))
9730             {
9731               GtkWidget *toplevel = gtk_widget_get_toplevel (GTK_WIDGET (tree_view));
9732
9733               if (toplevel)
9734                 gtk_widget_child_focus (toplevel,
9735                                         count < 0 ?
9736                                         GTK_DIR_TAB_BACKWARD :
9737                                         GTK_DIR_TAB_FORWARD);
9738
9739               grab_focus = FALSE;
9740             }
9741         }
9742       else
9743         {
9744           gtk_widget_error_bell (GTK_WIDGET (tree_view));
9745         }
9746     }
9747
9748   if (grab_focus)
9749     gtk_widget_grab_focus (GTK_WIDGET (tree_view));
9750 }
9751
9752 static void
9753 gtk_tree_view_move_cursor_page_up_down (GtkTreeView *tree_view,
9754                                         gint         count)
9755 {
9756   GtkRBTree *cursor_tree = NULL;
9757   GtkRBNode *cursor_node = NULL;
9758   GtkTreePath *old_cursor_path = NULL;
9759   GtkTreePath *cursor_path = NULL;
9760   GtkRBTree *start_cursor_tree = NULL;
9761   GtkRBNode *start_cursor_node = NULL;
9762   gint y;
9763   gint window_y;
9764   gint vertical_separator;
9765
9766   if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
9767     return;
9768
9769   if (gtk_tree_row_reference_valid (tree_view->priv->cursor))
9770     old_cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
9771   else
9772     /* This is sorta weird.  Focus in should give us a cursor */
9773     return;
9774
9775   gtk_widget_style_get (GTK_WIDGET (tree_view), "vertical-separator", &vertical_separator, NULL);
9776   _gtk_tree_view_find_node (tree_view, old_cursor_path,
9777                             &cursor_tree, &cursor_node);
9778
9779   if (cursor_tree == NULL)
9780     {
9781       /* FIXME: we lost the cursor.  Should we try to get one? */
9782       gtk_tree_path_free (old_cursor_path);
9783       return;
9784     }
9785   g_return_if_fail (cursor_node != NULL);
9786
9787   y = _gtk_rbtree_node_find_offset (cursor_tree, cursor_node);
9788   window_y = RBTREE_Y_TO_TREE_WINDOW_Y (tree_view, y);
9789   y += tree_view->priv->cursor_offset;
9790   y += count * (int)tree_view->priv->vadjustment->page_increment;
9791   y = CLAMP (y, (gint)tree_view->priv->vadjustment->lower,  (gint)tree_view->priv->vadjustment->upper - vertical_separator);
9792
9793   if (y >= tree_view->priv->height)
9794     y = tree_view->priv->height - 1;
9795
9796   tree_view->priv->cursor_offset =
9797     _gtk_rbtree_find_offset (tree_view->priv->tree, y,
9798                              &cursor_tree, &cursor_node);
9799
9800   if (cursor_tree == NULL)
9801     {
9802       /* FIXME: we lost the cursor.  Should we try to get one? */
9803       gtk_tree_path_free (old_cursor_path);
9804       return;
9805     }
9806
9807   if (tree_view->priv->cursor_offset > BACKGROUND_HEIGHT (cursor_node))
9808     {
9809       _gtk_rbtree_next_full (cursor_tree, cursor_node,
9810                              &cursor_tree, &cursor_node);
9811       tree_view->priv->cursor_offset -= BACKGROUND_HEIGHT (cursor_node);
9812     }
9813
9814   y -= tree_view->priv->cursor_offset;
9815   cursor_path = _gtk_tree_view_find_path (tree_view, cursor_tree, cursor_node);
9816
9817   start_cursor_tree = cursor_tree;
9818   start_cursor_node = cursor_node;
9819
9820   if (! search_first_focusable_path (tree_view, &cursor_path,
9821                                      (count != -1),
9822                                      &cursor_tree, &cursor_node))
9823     {
9824       /* It looks like we reached the end of the view without finding
9825        * a focusable row.  We will step backwards to find the last
9826        * focusable row.
9827        */
9828       cursor_tree = start_cursor_tree;
9829       cursor_node = start_cursor_node;
9830       cursor_path = _gtk_tree_view_find_path (tree_view, cursor_tree, cursor_node);
9831
9832       search_first_focusable_path (tree_view, &cursor_path,
9833                                    (count == -1),
9834                                    &cursor_tree, &cursor_node);
9835     }
9836
9837   if (!cursor_path)
9838     goto cleanup;
9839
9840   /* update y */
9841   y = _gtk_rbtree_node_find_offset (cursor_tree, cursor_node);
9842
9843   gtk_tree_view_real_set_cursor (tree_view, cursor_path, TRUE, FALSE);
9844
9845   y -= window_y;
9846   gtk_tree_view_scroll_to_point (tree_view, -1, y);
9847   gtk_tree_view_clamp_node_visible (tree_view, cursor_tree, cursor_node);
9848   _gtk_tree_view_queue_draw_node (tree_view, cursor_tree, cursor_node, NULL);
9849
9850   if (!gtk_tree_path_compare (old_cursor_path, cursor_path))
9851     gtk_widget_error_bell (GTK_WIDGET (tree_view));
9852
9853   gtk_widget_grab_focus (GTK_WIDGET (tree_view));
9854
9855 cleanup:
9856   gtk_tree_path_free (old_cursor_path);
9857   gtk_tree_path_free (cursor_path);
9858 }
9859
9860 static void
9861 gtk_tree_view_move_cursor_left_right (GtkTreeView *tree_view,
9862                                       gint         count)
9863 {
9864   GtkRBTree *cursor_tree = NULL;
9865   GtkRBNode *cursor_node = NULL;
9866   GtkTreePath *cursor_path = NULL;
9867   GtkTreeViewColumn *column;
9868   GtkTreeIter iter;
9869   GList *list;
9870   gboolean found_column = FALSE;
9871   gboolean rtl;
9872
9873   rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
9874
9875   if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
9876     return;
9877
9878   if (gtk_tree_row_reference_valid (tree_view->priv->cursor))
9879     cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
9880   else
9881     return;
9882
9883   _gtk_tree_view_find_node (tree_view, cursor_path, &cursor_tree, &cursor_node);
9884   if (cursor_tree == NULL)
9885     return;
9886   if (gtk_tree_model_get_iter (tree_view->priv->model, &iter, cursor_path) == FALSE)
9887     {
9888       gtk_tree_path_free (cursor_path);
9889       return;
9890     }
9891   gtk_tree_path_free (cursor_path);
9892
9893   list = rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns);
9894   if (tree_view->priv->focus_column)
9895     {
9896       for (; list; list = (rtl ? list->prev : list->next))
9897         {
9898           if (list->data == tree_view->priv->focus_column)
9899             break;
9900         }
9901     }
9902
9903   while (list)
9904     {
9905       gboolean left, right;
9906
9907       column = list->data;
9908       if (column->visible == FALSE)
9909         goto loop_end;
9910
9911       gtk_tree_view_column_cell_set_cell_data (column,
9912                                                tree_view->priv->model,
9913                                                &iter,
9914                                                GTK_RBNODE_FLAG_SET (cursor_node, GTK_RBNODE_IS_PARENT),
9915                                                cursor_node->children?TRUE:FALSE);
9916
9917       if (rtl)
9918         {
9919           right = list->prev ? TRUE : FALSE;
9920           left = list->next ? TRUE : FALSE;
9921         }
9922       else
9923         {
9924           left = list->prev ? TRUE : FALSE;
9925           right = list->next ? TRUE : FALSE;
9926         }
9927
9928       if (_gtk_tree_view_column_cell_focus (column, count, left, right))
9929         {
9930           tree_view->priv->focus_column = column;
9931           found_column = TRUE;
9932           break;
9933         }
9934     loop_end:
9935       if (count == 1)
9936         list = rtl ? list->prev : list->next;
9937       else
9938         list = rtl ? list->next : list->prev;
9939     }
9940
9941   if (found_column)
9942     {
9943       if (!gtk_tree_view_has_special_cell (tree_view))
9944         _gtk_tree_view_queue_draw_node (tree_view,
9945                                         cursor_tree,
9946                                         cursor_node,
9947                                         NULL);
9948       g_signal_emit (tree_view, tree_view_signals[CURSOR_CHANGED], 0);
9949       gtk_widget_grab_focus (GTK_WIDGET (tree_view));
9950     }
9951   else
9952     {
9953       gtk_widget_error_bell (GTK_WIDGET (tree_view));
9954     }
9955
9956   gtk_tree_view_clamp_column_visible (tree_view,
9957                                       tree_view->priv->focus_column, TRUE);
9958 }
9959
9960 static void
9961 gtk_tree_view_move_cursor_start_end (GtkTreeView *tree_view,
9962                                      gint         count)
9963 {
9964   GtkRBTree *cursor_tree;
9965   GtkRBNode *cursor_node;
9966   GtkTreePath *path;
9967   GtkTreePath *old_path;
9968
9969   if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
9970     return;
9971
9972   g_return_if_fail (tree_view->priv->tree != NULL);
9973
9974   gtk_tree_view_get_cursor (tree_view, &old_path, NULL);
9975
9976   cursor_tree = tree_view->priv->tree;
9977   cursor_node = cursor_tree->root;
9978
9979   if (count == -1)
9980     {
9981       while (cursor_node && cursor_node->left != cursor_tree->nil)
9982         cursor_node = cursor_node->left;
9983
9984       /* Now go forward to find the first focusable row. */
9985       path = _gtk_tree_view_find_path (tree_view, cursor_tree, cursor_node);
9986       search_first_focusable_path (tree_view, &path,
9987                                    TRUE, &cursor_tree, &cursor_node);
9988     }
9989   else
9990     {
9991       do
9992         {
9993           while (cursor_node && cursor_node->right != cursor_tree->nil)
9994             cursor_node = cursor_node->right;
9995           if (cursor_node->children == NULL)
9996             break;
9997
9998           cursor_tree = cursor_node->children;
9999           cursor_node = cursor_tree->root;
10000         }
10001       while (1);
10002
10003       /* Now go backwards to find last focusable row. */
10004       path = _gtk_tree_view_find_path (tree_view, cursor_tree, cursor_node);
10005       search_first_focusable_path (tree_view, &path,
10006                                    FALSE, &cursor_tree, &cursor_node);
10007     }
10008
10009   if (!path)
10010     goto cleanup;
10011
10012   if (gtk_tree_path_compare (old_path, path))
10013     {
10014       gtk_tree_view_real_set_cursor (tree_view, path, TRUE, TRUE);
10015       gtk_widget_grab_focus (GTK_WIDGET (tree_view));
10016     }
10017   else
10018     {
10019       gtk_widget_error_bell (GTK_WIDGET (tree_view));
10020     }
10021
10022 cleanup:
10023   gtk_tree_path_free (old_path);
10024   gtk_tree_path_free (path);
10025 }
10026
10027 static gboolean
10028 gtk_tree_view_real_select_all (GtkTreeView *tree_view)
10029 {
10030   if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
10031     return FALSE;
10032
10033   if (tree_view->priv->selection->type != GTK_SELECTION_MULTIPLE)
10034     return FALSE;
10035
10036   gtk_tree_selection_select_all (tree_view->priv->selection);
10037
10038   return TRUE;
10039 }
10040
10041 static gboolean
10042 gtk_tree_view_real_unselect_all (GtkTreeView *tree_view)
10043 {
10044   if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
10045     return FALSE;
10046
10047   if (tree_view->priv->selection->type != GTK_SELECTION_MULTIPLE)
10048     return FALSE;
10049
10050   gtk_tree_selection_unselect_all (tree_view->priv->selection);
10051
10052   return TRUE;
10053 }
10054
10055 static gboolean
10056 gtk_tree_view_real_select_cursor_row (GtkTreeView *tree_view,
10057                                       gboolean     start_editing)
10058 {
10059   GtkRBTree *new_tree = NULL;
10060   GtkRBNode *new_node = NULL;
10061   GtkRBTree *cursor_tree = NULL;
10062   GtkRBNode *cursor_node = NULL;
10063   GtkTreePath *cursor_path = NULL;
10064   GtkTreeSelectMode mode = 0;
10065
10066   if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
10067     return FALSE;
10068
10069   if (tree_view->priv->cursor)
10070     cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
10071
10072   if (cursor_path == NULL)
10073     return FALSE;
10074
10075   _gtk_tree_view_find_node (tree_view, cursor_path,
10076                             &cursor_tree, &cursor_node);
10077
10078   if (cursor_tree == NULL)
10079     {
10080       gtk_tree_path_free (cursor_path);
10081       return FALSE;
10082     }
10083
10084   if (!tree_view->priv->shift_pressed && start_editing &&
10085       tree_view->priv->focus_column)
10086     {
10087       if (gtk_tree_view_start_editing (tree_view, cursor_path))
10088         {
10089           gtk_tree_path_free (cursor_path);
10090           return TRUE;
10091         }
10092     }
10093
10094   if (tree_view->priv->ctrl_pressed)
10095     mode |= GTK_TREE_SELECT_MODE_TOGGLE;
10096   if (tree_view->priv->shift_pressed)
10097     mode |= GTK_TREE_SELECT_MODE_EXTEND;
10098
10099   _gtk_tree_selection_internal_select_node (tree_view->priv->selection,
10100                                             cursor_node,
10101                                             cursor_tree,
10102                                             cursor_path,
10103                                             mode,
10104                                             FALSE);
10105
10106   /* We bail out if the original (tree, node) don't exist anymore after
10107    * handling the selection-changed callback.  We do return TRUE because
10108    * the key press has been handled at this point.
10109    */
10110   _gtk_tree_view_find_node (tree_view, cursor_path, &new_tree, &new_node);
10111
10112   if (cursor_tree != new_tree || cursor_node != new_node)
10113     return FALSE;
10114
10115   gtk_tree_view_clamp_node_visible (tree_view, cursor_tree, cursor_node);
10116
10117   gtk_widget_grab_focus (GTK_WIDGET (tree_view));
10118   _gtk_tree_view_queue_draw_node (tree_view, cursor_tree, cursor_node, NULL);
10119
10120   if (!tree_view->priv->shift_pressed)
10121     gtk_tree_view_row_activated (tree_view, cursor_path,
10122                                  tree_view->priv->focus_column);
10123
10124   gtk_tree_path_free (cursor_path);
10125
10126   return TRUE;
10127 }
10128
10129 static gboolean
10130 gtk_tree_view_real_toggle_cursor_row (GtkTreeView *tree_view)
10131 {
10132   GtkRBTree *new_tree = NULL;
10133   GtkRBNode *new_node = NULL;
10134   GtkRBTree *cursor_tree = NULL;
10135   GtkRBNode *cursor_node = NULL;
10136   GtkTreePath *cursor_path = NULL;
10137
10138   if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
10139     return FALSE;
10140
10141   cursor_path = NULL;
10142   if (tree_view->priv->cursor)
10143     cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
10144
10145   if (cursor_path == NULL)
10146     return FALSE;
10147
10148   _gtk_tree_view_find_node (tree_view, cursor_path,
10149                             &cursor_tree, &cursor_node);
10150   if (cursor_tree == NULL)
10151     {
10152       gtk_tree_path_free (cursor_path);
10153       return FALSE;
10154     }
10155
10156   _gtk_tree_selection_internal_select_node (tree_view->priv->selection,
10157                                             cursor_node,
10158                                             cursor_tree,
10159                                             cursor_path,
10160                                             GTK_TREE_SELECT_MODE_TOGGLE,
10161                                             FALSE);
10162
10163   /* We bail out if the original (tree, node) don't exist anymore after
10164    * handling the selection-changed callback.  We do return TRUE because
10165    * the key press has been handled at this point.
10166    */
10167   _gtk_tree_view_find_node (tree_view, cursor_path, &new_tree, &new_node);
10168
10169   if (cursor_tree != new_tree || cursor_node != new_node)
10170     return FALSE;
10171
10172   gtk_tree_view_clamp_node_visible (tree_view, cursor_tree, cursor_node);
10173
10174   gtk_widget_grab_focus (GTK_WIDGET (tree_view));
10175   gtk_tree_view_queue_draw_path (tree_view, cursor_path, NULL);
10176   gtk_tree_path_free (cursor_path);
10177
10178   return TRUE;
10179 }
10180
10181 static gboolean
10182 gtk_tree_view_real_expand_collapse_cursor_row (GtkTreeView *tree_view,
10183                                                gboolean     logical,
10184                                                gboolean     expand,
10185                                                gboolean     open_all)
10186 {
10187   GtkTreePath *cursor_path = NULL;
10188   GtkRBTree *tree;
10189   GtkRBNode *node;
10190
10191   if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
10192     return FALSE;
10193
10194   cursor_path = NULL;
10195   if (tree_view->priv->cursor)
10196     cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
10197
10198   if (cursor_path == NULL)
10199     return FALSE;
10200
10201   if (_gtk_tree_view_find_node (tree_view, cursor_path, &tree, &node))
10202     return FALSE;
10203
10204   /* Don't handle the event if we aren't an expander */
10205   if (!((node->flags & GTK_RBNODE_IS_PARENT) == GTK_RBNODE_IS_PARENT))
10206     return FALSE;
10207
10208   if (!logical
10209       && gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL)
10210     expand = !expand;
10211
10212   if (expand)
10213     gtk_tree_view_real_expand_row (tree_view, cursor_path, tree, node, open_all, TRUE);
10214   else
10215     gtk_tree_view_real_collapse_row (tree_view, cursor_path, tree, node, TRUE);
10216
10217   gtk_tree_path_free (cursor_path);
10218
10219   return TRUE;
10220 }
10221
10222 static gboolean
10223 gtk_tree_view_real_select_cursor_parent (GtkTreeView *tree_view)
10224 {
10225   GtkRBTree *cursor_tree = NULL;
10226   GtkRBNode *cursor_node = NULL;
10227   GtkTreePath *cursor_path = NULL;
10228   GdkModifierType state;
10229
10230   if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
10231     goto out;
10232
10233   cursor_path = NULL;
10234   if (tree_view->priv->cursor)
10235     cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
10236
10237   if (cursor_path == NULL)
10238     goto out;
10239
10240   _gtk_tree_view_find_node (tree_view, cursor_path,
10241                             &cursor_tree, &cursor_node);
10242   if (cursor_tree == NULL)
10243     {
10244       gtk_tree_path_free (cursor_path);
10245       goto out;
10246     }
10247
10248   if (cursor_tree->parent_node)
10249     {
10250       gtk_tree_view_queue_draw_path (tree_view, cursor_path, NULL);
10251       cursor_node = cursor_tree->parent_node;
10252       cursor_tree = cursor_tree->parent_tree;
10253
10254       gtk_tree_path_up (cursor_path);
10255
10256       if (gtk_get_current_event_state (&state))
10257         {
10258           if ((state & GDK_CONTROL_MASK) == GDK_CONTROL_MASK)
10259             tree_view->priv->ctrl_pressed = TRUE;
10260         }
10261
10262       gtk_tree_view_real_set_cursor (tree_view, cursor_path, TRUE, FALSE);
10263       gtk_tree_view_clamp_node_visible (tree_view, cursor_tree, cursor_node);
10264
10265       gtk_widget_grab_focus (GTK_WIDGET (tree_view));
10266       gtk_tree_view_queue_draw_path (tree_view, cursor_path, NULL);
10267       gtk_tree_path_free (cursor_path);
10268
10269       tree_view->priv->ctrl_pressed = FALSE;
10270
10271       return TRUE;
10272     }
10273
10274  out:
10275
10276   tree_view->priv->search_entry_avoid_unhandled_binding = TRUE;
10277   return FALSE;
10278 }
10279
10280 static gboolean
10281 gtk_tree_view_search_entry_flush_timeout (GtkTreeView *tree_view)
10282 {
10283   gtk_tree_view_search_dialog_hide (tree_view->priv->search_window, tree_view, NULL);
10284   tree_view->priv->typeselect_flush_timeout = 0;
10285
10286   return FALSE;
10287 }
10288
10289 /* Cut and paste from gtkwindow.c */
10290 static void
10291 send_focus_change (GtkWidget *widget,
10292                    GdkDevice *device,
10293                    gboolean   in)
10294 {
10295   GdkDeviceManager *device_manager;
10296   GList *devices, *d;
10297
10298   device_manager = gdk_display_get_device_manager (gtk_widget_get_display (widget));
10299   devices = gdk_device_manager_list_devices (device_manager, GDK_DEVICE_TYPE_MASTER);
10300   devices = g_list_concat (devices, gdk_device_manager_list_devices (device_manager, GDK_DEVICE_TYPE_SLAVE));
10301   devices = g_list_concat (devices, gdk_device_manager_list_devices (device_manager, GDK_DEVICE_TYPE_FLOATING));
10302
10303   for (d = devices; d; d = d->next)
10304     {
10305       GdkDevice *dev = d->data;
10306       GdkEvent *fevent;
10307       GdkWindow *window;
10308
10309       if (dev->source != GDK_SOURCE_KEYBOARD)
10310         continue;
10311
10312       window = gtk_widget_get_window (widget);
10313
10314       /* Skip non-master keyboards that haven't
10315        * selected for events from this window
10316        */
10317       if (gdk_device_get_device_type (dev) != GDK_DEVICE_TYPE_MASTER &&
10318           !gdk_window_get_device_events (window, dev))
10319         continue;
10320
10321       fevent = gdk_event_new (GDK_FOCUS_CHANGE);
10322
10323       fevent->focus_change.type = GDK_FOCUS_CHANGE;
10324       fevent->focus_change.window = g_object_ref (window);
10325       fevent->focus_change.in = in;
10326       gdk_event_set_device (fevent, device);
10327
10328       gtk_widget_send_focus_change (widget, fevent);
10329
10330       gdk_event_free (fevent);
10331     }
10332 }
10333
10334 static void
10335 gtk_tree_view_ensure_interactive_directory (GtkTreeView *tree_view)
10336 {
10337   GtkWidget *frame, *vbox, *toplevel;
10338   GdkScreen *screen;
10339
10340   if (tree_view->priv->search_custom_entry_set)
10341     return;
10342
10343   toplevel = gtk_widget_get_toplevel (GTK_WIDGET (tree_view));
10344   screen = gtk_widget_get_screen (GTK_WIDGET (tree_view));
10345
10346    if (tree_view->priv->search_window != NULL)
10347      {
10348        if (gtk_window_has_group (GTK_WINDOW (toplevel)))
10349          gtk_window_group_add_window (gtk_window_get_group (GTK_WINDOW (toplevel)),
10350                                       GTK_WINDOW (tree_view->priv->search_window));
10351        else if (gtk_window_has_group (GTK_WINDOW (tree_view->priv->search_window)))
10352          gtk_window_group_remove_window (gtk_window_get_group (GTK_WINDOW (tree_view->priv->search_window)),
10353                                          GTK_WINDOW (tree_view->priv->search_window));
10354
10355        gtk_window_set_screen (GTK_WINDOW (tree_view->priv->search_window), screen);
10356
10357        return;
10358      }
10359
10360   tree_view->priv->search_window = gtk_window_new (GTK_WINDOW_POPUP);
10361   gtk_window_set_screen (GTK_WINDOW (tree_view->priv->search_window), screen);
10362
10363   if (gtk_window_has_group (GTK_WINDOW (toplevel)))
10364     gtk_window_group_add_window (gtk_window_get_group (GTK_WINDOW (toplevel)),
10365                                  GTK_WINDOW (tree_view->priv->search_window));
10366
10367   gtk_window_set_type_hint (GTK_WINDOW (tree_view->priv->search_window),
10368                             GDK_WINDOW_TYPE_HINT_UTILITY);
10369   gtk_window_set_modal (GTK_WINDOW (tree_view->priv->search_window), TRUE);
10370   g_signal_connect (tree_view->priv->search_window, "delete-event",
10371                     G_CALLBACK (gtk_tree_view_search_delete_event),
10372                     tree_view);
10373   g_signal_connect (tree_view->priv->search_window, "key-press-event",
10374                     G_CALLBACK (gtk_tree_view_search_key_press_event),
10375                     tree_view);
10376   g_signal_connect (tree_view->priv->search_window, "button-press-event",
10377                     G_CALLBACK (gtk_tree_view_search_button_press_event),
10378                     tree_view);
10379   g_signal_connect (tree_view->priv->search_window, "scroll-event",
10380                     G_CALLBACK (gtk_tree_view_search_scroll_event),
10381                     tree_view);
10382
10383   frame = gtk_frame_new (NULL);
10384   gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_ETCHED_IN);
10385   gtk_widget_show (frame);
10386   gtk_container_add (GTK_CONTAINER (tree_view->priv->search_window), frame);
10387
10388   vbox = gtk_vbox_new (FALSE, 0);
10389   gtk_widget_show (vbox);
10390   gtk_container_add (GTK_CONTAINER (frame), vbox);
10391   gtk_container_set_border_width (GTK_CONTAINER (vbox), 3);
10392
10393   /* add entry */
10394   tree_view->priv->search_entry = gtk_entry_new ();
10395   gtk_widget_show (tree_view->priv->search_entry);
10396   g_signal_connect (tree_view->priv->search_entry, "populate-popup",
10397                     G_CALLBACK (gtk_tree_view_search_disable_popdown),
10398                     tree_view);
10399   g_signal_connect (tree_view->priv->search_entry,
10400                     "activate", G_CALLBACK (gtk_tree_view_search_activate),
10401                     tree_view);
10402   g_signal_connect (GTK_ENTRY (tree_view->priv->search_entry)->im_context,
10403                     "preedit-changed",
10404                     G_CALLBACK (gtk_tree_view_search_preedit_changed),
10405                     tree_view);
10406   gtk_container_add (GTK_CONTAINER (vbox),
10407                      tree_view->priv->search_entry);
10408
10409   gtk_widget_realize (tree_view->priv->search_entry);
10410 }
10411
10412 /* Pops up the interactive search entry.  If keybinding is TRUE then the user
10413  * started this by typing the start_interactive_search keybinding.  Otherwise, it came from
10414  */
10415 static gboolean
10416 gtk_tree_view_real_start_interactive_search (GtkTreeView *tree_view,
10417                                              GdkDevice   *device,
10418                                              gboolean     keybinding)
10419 {
10420   /* We only start interactive search if we have focus or the columns
10421    * have focus.  If one of our children have focus, we don't want to
10422    * start the search.
10423    */
10424   GList *list;
10425   gboolean found_focus = FALSE;
10426   GtkWidgetClass *entry_parent_class;
10427
10428   if (!tree_view->priv->enable_search && !keybinding)
10429     return FALSE;
10430
10431   if (tree_view->priv->search_custom_entry_set)
10432     return FALSE;
10433
10434   if (tree_view->priv->search_window != NULL &&
10435       gtk_widget_get_visible (tree_view->priv->search_window))
10436     return TRUE;
10437
10438   for (list = tree_view->priv->columns; list; list = list->next)
10439     {
10440       GtkTreeViewColumn *column;
10441
10442       column = list->data;
10443       if (! column->visible)
10444         continue;
10445
10446       if (gtk_widget_has_focus (column->button))
10447         {
10448           found_focus = TRUE;
10449           break;
10450         }
10451     }
10452
10453   if (gtk_widget_has_focus (GTK_WIDGET (tree_view)))
10454     found_focus = TRUE;
10455
10456   if (!found_focus)
10457     return FALSE;
10458
10459   if (tree_view->priv->search_column < 0)
10460     return FALSE;
10461
10462   gtk_tree_view_ensure_interactive_directory (tree_view);
10463
10464   if (keybinding)
10465     gtk_entry_set_text (GTK_ENTRY (tree_view->priv->search_entry), "");
10466
10467   /* done, show it */
10468   tree_view->priv->search_position_func (tree_view, tree_view->priv->search_window, tree_view->priv->search_position_user_data);
10469   gtk_widget_show (tree_view->priv->search_window);
10470   if (tree_view->priv->search_entry_changed_id == 0)
10471     {
10472       tree_view->priv->search_entry_changed_id =
10473         g_signal_connect (tree_view->priv->search_entry, "changed",
10474                           G_CALLBACK (gtk_tree_view_search_init),
10475                           tree_view);
10476     }
10477
10478   tree_view->priv->typeselect_flush_timeout =
10479     gdk_threads_add_timeout (GTK_TREE_VIEW_SEARCH_DIALOG_TIMEOUT,
10480                    (GSourceFunc) gtk_tree_view_search_entry_flush_timeout,
10481                    tree_view);
10482
10483   /* Grab focus will select all the text.  We don't want that to happen, so we
10484    * call the parent instance and bypass the selection change.  This is probably
10485    * really non-kosher. */
10486   entry_parent_class = g_type_class_peek_parent (GTK_ENTRY_GET_CLASS (tree_view->priv->search_entry));
10487   (entry_parent_class->grab_focus) (tree_view->priv->search_entry);
10488
10489   /* send focus-in event */
10490   send_focus_change (tree_view->priv->search_entry, device, TRUE);
10491
10492   /* search first matching iter */
10493   gtk_tree_view_search_init (tree_view->priv->search_entry, tree_view);
10494
10495   return TRUE;
10496 }
10497
10498 static gboolean
10499 gtk_tree_view_start_interactive_search (GtkTreeView *tree_view)
10500 {
10501   return gtk_tree_view_real_start_interactive_search (tree_view,
10502                                                       gtk_get_current_event_device (),
10503                                                       TRUE);
10504 }
10505
10506 /* this function returns the new width of the column being resized given
10507  * the column and x position of the cursor; the x cursor position is passed
10508  * in as a pointer and automagicly corrected if it's beyond min/max limits
10509  */
10510 static gint
10511 gtk_tree_view_new_column_width (GtkTreeView *tree_view,
10512                                 gint       i,
10513                                 gint      *x)
10514 {
10515   GtkAllocation allocation;
10516   GtkTreeViewColumn *column;
10517   GtkRequisition button_req;
10518   gint width;
10519   gboolean rtl;
10520
10521   /* first translate the x position from widget->window
10522    * to clist->clist_window
10523    */
10524   rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
10525   column = g_list_nth (tree_view->priv->columns, i)->data;
10526   gtk_widget_get_allocation (column->button, &allocation);
10527   width = rtl ? (allocation.x + allocation.width - *x) : (*x - allocation.x);
10528
10529   /* Clamp down the value */
10530   if (column->min_width == -1)
10531     {
10532       gtk_widget_get_preferred_size (column->button, &button_req, NULL);
10533       width = MAX (button_req.width, width);
10534     }
10535   else
10536     width = MAX (column->min_width,
10537                  width);
10538   if (column->max_width != -1)
10539     width = MIN (width, column->max_width);
10540
10541   *x = rtl ? (allocation.x + allocation.width - width) : (allocation.x + width);
10542
10543   return width;
10544 }
10545
10546
10547 /* FIXME this adjust_allocation is a big cut-and-paste from
10548  * GtkCList, needs to be some "official" way to do this
10549  * factored out.
10550  */
10551 typedef struct
10552 {
10553   GdkWindow *window;
10554   int dx;
10555   int dy;
10556 } ScrollData;
10557
10558 /* The window to which widget->window is relative */
10559 #define ALLOCATION_WINDOW(widget)               \
10560    (!gtk_widget_get_has_window (widget) ?                   \
10561     gtk_widget_get_window (widget) :                        \
10562     gdk_window_get_parent (gtk_widget_get_window (widget)))
10563
10564 static void
10565 adjust_allocation_recurse (GtkWidget *widget,
10566                            gpointer   data)
10567 {
10568   GtkAllocation allocation;
10569   ScrollData *scroll_data = data;
10570
10571   /* Need to really size allocate instead of just poking
10572    * into widget->allocation if the widget is not realized.
10573    * FIXME someone figure out why this was.
10574    */
10575   gtk_widget_get_allocation (widget, &allocation);
10576   if (!gtk_widget_get_realized (widget))
10577     {
10578       if (gtk_widget_get_visible (widget))
10579         {
10580           GdkRectangle tmp_rectangle = allocation;
10581           tmp_rectangle.x += scroll_data->dx;
10582           tmp_rectangle.y += scroll_data->dy;
10583
10584           gtk_widget_size_allocate (widget, &tmp_rectangle);
10585         }
10586     }
10587   else
10588     {
10589       if (ALLOCATION_WINDOW (widget) == scroll_data->window)
10590         {
10591           allocation.x += scroll_data->dx;
10592           allocation.y += scroll_data->dy;
10593           gtk_widget_set_allocation (widget, &allocation);
10594
10595           if (GTK_IS_CONTAINER (widget))
10596             gtk_container_forall (GTK_CONTAINER (widget),
10597                                   adjust_allocation_recurse,
10598                                   data);
10599         }
10600     }
10601 }
10602
10603 static void
10604 adjust_allocation (GtkWidget *widget,
10605                    int        dx,
10606                    int        dy)
10607 {
10608   ScrollData scroll_data;
10609
10610   if (gtk_widget_get_realized (widget))
10611     scroll_data.window = ALLOCATION_WINDOW (widget);
10612   else
10613     scroll_data.window = NULL;
10614
10615   scroll_data.dx = dx;
10616   scroll_data.dy = dy;
10617
10618   adjust_allocation_recurse (widget, &scroll_data);
10619 }
10620
10621 /* Callbacks */
10622 static void
10623 gtk_tree_view_adjustment_changed (GtkAdjustment *adjustment,
10624                                   GtkTreeView   *tree_view)
10625 {
10626   if (gtk_widget_get_realized (GTK_WIDGET (tree_view)))
10627     {
10628       gint dy;
10629
10630       gdk_window_move (tree_view->priv->bin_window,
10631                        - tree_view->priv->hadjustment->value,
10632                        TREE_VIEW_HEADER_HEIGHT (tree_view));
10633       gdk_window_move (tree_view->priv->header_window,
10634                        - tree_view->priv->hadjustment->value,
10635                        0);
10636       dy = tree_view->priv->dy - (int) tree_view->priv->vadjustment->value;
10637       if (dy)
10638         {
10639           update_prelight (tree_view,
10640                            tree_view->priv->event_last_x,
10641                            tree_view->priv->event_last_y - dy);
10642
10643           if (tree_view->priv->edited_column &&
10644               GTK_IS_WIDGET (tree_view->priv->edited_column->editable_widget))
10645             {
10646               GList *list;
10647               GtkWidget *widget;
10648               GtkTreeViewChild *child = NULL;
10649
10650               widget = GTK_WIDGET (tree_view->priv->edited_column->editable_widget);
10651               adjust_allocation (widget, 0, dy);
10652
10653               for (list = tree_view->priv->children; list; list = list->next)
10654                 {
10655                   child = (GtkTreeViewChild *)list->data;
10656                   if (child->widget == widget)
10657                     {
10658                       child->y += dy;
10659                       break;
10660                     }
10661                 }
10662             }
10663         }
10664       gdk_window_scroll (tree_view->priv->bin_window, 0, dy);
10665
10666       if (tree_view->priv->dy != (int) tree_view->priv->vadjustment->value)
10667         {
10668           /* update our dy and top_row */
10669           tree_view->priv->dy = (int) tree_view->priv->vadjustment->value;
10670
10671           if (!tree_view->priv->in_top_row_to_dy)
10672             gtk_tree_view_dy_to_top_row (tree_view);
10673         }
10674
10675       gdk_window_process_updates (tree_view->priv->header_window, TRUE);
10676       gdk_window_process_updates (tree_view->priv->bin_window, TRUE);
10677     }
10678 }
10679
10680 \f
10681
10682 /* Public methods
10683  */
10684
10685 /**
10686  * gtk_tree_view_new:
10687  *
10688  * Creates a new #GtkTreeView widget.
10689  *
10690  * Return value: A newly created #GtkTreeView widget.
10691  **/
10692 GtkWidget *
10693 gtk_tree_view_new (void)
10694 {
10695   return g_object_new (GTK_TYPE_TREE_VIEW, NULL);
10696 }
10697
10698 /**
10699  * gtk_tree_view_new_with_model:
10700  * @model: the model.
10701  *
10702  * Creates a new #GtkTreeView widget with the model initialized to @model.
10703  *
10704  * Return value: A newly created #GtkTreeView widget.
10705  **/
10706 GtkWidget *
10707 gtk_tree_view_new_with_model (GtkTreeModel *model)
10708 {
10709   return g_object_new (GTK_TYPE_TREE_VIEW, "model", model, NULL);
10710 }
10711
10712 /* Public Accessors
10713  */
10714
10715 /**
10716  * gtk_tree_view_get_model:
10717  * @tree_view: a #GtkTreeView
10718  *
10719  * Returns the model the #GtkTreeView is based on.  Returns %NULL if the
10720  * model is unset.
10721  *
10722  * Return value: (transfer none): A #GtkTreeModel, or %NULL if none is currently being used.
10723  **/
10724 GtkTreeModel *
10725 gtk_tree_view_get_model (GtkTreeView *tree_view)
10726 {
10727   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
10728
10729   return tree_view->priv->model;
10730 }
10731
10732 /**
10733  * gtk_tree_view_set_model:
10734  * @tree_view: A #GtkTreeNode.
10735  * @model: (allow-none): The model.
10736  *
10737  * Sets the model for a #GtkTreeView.  If the @tree_view already has a model
10738  * set, it will remove it before setting the new model.  If @model is %NULL,
10739  * then it will unset the old model.
10740  **/
10741 void
10742 gtk_tree_view_set_model (GtkTreeView  *tree_view,
10743                          GtkTreeModel *model)
10744 {
10745   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
10746   g_return_if_fail (model == NULL || GTK_IS_TREE_MODEL (model));
10747
10748   if (model == tree_view->priv->model)
10749     return;
10750
10751   if (tree_view->priv->scroll_to_path)
10752     {
10753       gtk_tree_row_reference_free (tree_view->priv->scroll_to_path);
10754       tree_view->priv->scroll_to_path = NULL;
10755     }
10756
10757   if (tree_view->priv->model)
10758     {
10759       GList *tmplist = tree_view->priv->columns;
10760
10761       gtk_tree_view_unref_and_check_selection_tree (tree_view, tree_view->priv->tree);
10762       gtk_tree_view_stop_editing (tree_view, TRUE);
10763
10764       remove_expand_collapse_timeout (tree_view);
10765
10766       g_signal_handlers_disconnect_by_func (tree_view->priv->model,
10767                                             gtk_tree_view_row_changed,
10768                                             tree_view);
10769       g_signal_handlers_disconnect_by_func (tree_view->priv->model,
10770                                             gtk_tree_view_row_inserted,
10771                                             tree_view);
10772       g_signal_handlers_disconnect_by_func (tree_view->priv->model,
10773                                             gtk_tree_view_row_has_child_toggled,
10774                                             tree_view);
10775       g_signal_handlers_disconnect_by_func (tree_view->priv->model,
10776                                             gtk_tree_view_row_deleted,
10777                                             tree_view);
10778       g_signal_handlers_disconnect_by_func (tree_view->priv->model,
10779                                             gtk_tree_view_rows_reordered,
10780                                             tree_view);
10781
10782       for (; tmplist; tmplist = tmplist->next)
10783         _gtk_tree_view_column_unset_model (tmplist->data,
10784                                            tree_view->priv->model);
10785
10786       if (tree_view->priv->tree)
10787         gtk_tree_view_free_rbtree (tree_view);
10788
10789       gtk_tree_row_reference_free (tree_view->priv->drag_dest_row);
10790       tree_view->priv->drag_dest_row = NULL;
10791       gtk_tree_row_reference_free (tree_view->priv->cursor);
10792       tree_view->priv->cursor = NULL;
10793       gtk_tree_row_reference_free (tree_view->priv->anchor);
10794       tree_view->priv->anchor = NULL;
10795       gtk_tree_row_reference_free (tree_view->priv->top_row);
10796       tree_view->priv->top_row = NULL;
10797       gtk_tree_row_reference_free (tree_view->priv->scroll_to_path);
10798       tree_view->priv->scroll_to_path = NULL;
10799
10800       tree_view->priv->scroll_to_column = NULL;
10801
10802       g_object_unref (tree_view->priv->model);
10803
10804       tree_view->priv->search_column = -1;
10805       tree_view->priv->fixed_height_check = 0;
10806       tree_view->priv->fixed_height = -1;
10807       tree_view->priv->dy = tree_view->priv->top_row_dy = 0;
10808       tree_view->priv->last_button_x = -1;
10809       tree_view->priv->last_button_y = -1;
10810     }
10811
10812   tree_view->priv->model = model;
10813
10814   if (tree_view->priv->model)
10815     {
10816       gint i;
10817       GtkTreePath *path;
10818       GtkTreeIter iter;
10819       GtkTreeModelFlags flags;
10820
10821       if (tree_view->priv->search_column == -1)
10822         {
10823           for (i = 0; i < gtk_tree_model_get_n_columns (model); i++)
10824             {
10825               GType type = gtk_tree_model_get_column_type (model, i);
10826
10827               if (g_value_type_transformable (type, G_TYPE_STRING))
10828                 {
10829                   tree_view->priv->search_column = i;
10830                   break;
10831                 }
10832             }
10833         }
10834
10835       g_object_ref (tree_view->priv->model);
10836       g_signal_connect (tree_view->priv->model,
10837                         "row-changed",
10838                         G_CALLBACK (gtk_tree_view_row_changed),
10839                         tree_view);
10840       g_signal_connect (tree_view->priv->model,
10841                         "row-inserted",
10842                         G_CALLBACK (gtk_tree_view_row_inserted),
10843                         tree_view);
10844       g_signal_connect (tree_view->priv->model,
10845                         "row-has-child-toggled",
10846                         G_CALLBACK (gtk_tree_view_row_has_child_toggled),
10847                         tree_view);
10848       g_signal_connect (tree_view->priv->model,
10849                         "row-deleted",
10850                         G_CALLBACK (gtk_tree_view_row_deleted),
10851                         tree_view);
10852       g_signal_connect (tree_view->priv->model,
10853                         "rows-reordered",
10854                         G_CALLBACK (gtk_tree_view_rows_reordered),
10855                         tree_view);
10856
10857       flags = gtk_tree_model_get_flags (tree_view->priv->model);
10858       if ((flags & GTK_TREE_MODEL_LIST_ONLY) == GTK_TREE_MODEL_LIST_ONLY)
10859         GTK_TREE_VIEW_SET_FLAG (tree_view, GTK_TREE_VIEW_IS_LIST);
10860       else
10861         GTK_TREE_VIEW_UNSET_FLAG (tree_view, GTK_TREE_VIEW_IS_LIST);
10862
10863       path = gtk_tree_path_new_first ();
10864       if (gtk_tree_model_get_iter (tree_view->priv->model, &iter, path))
10865         {
10866           tree_view->priv->tree = _gtk_rbtree_new ();
10867           gtk_tree_view_build_tree (tree_view, tree_view->priv->tree, &iter, 1, FALSE);
10868         }
10869       gtk_tree_path_free (path);
10870
10871       /*  FIXME: do I need to do this? gtk_tree_view_create_buttons (tree_view); */
10872       install_presize_handler (tree_view);
10873     }
10874
10875   g_object_notify (G_OBJECT (tree_view), "model");
10876
10877   if (tree_view->priv->selection)
10878   _gtk_tree_selection_emit_changed (tree_view->priv->selection);
10879
10880   if (gtk_widget_get_realized (GTK_WIDGET (tree_view)))
10881     gtk_widget_queue_resize (GTK_WIDGET (tree_view));
10882 }
10883
10884 /**
10885  * gtk_tree_view_get_selection:
10886  * @tree_view: A #GtkTreeView.
10887  *
10888  * Gets the #GtkTreeSelection associated with @tree_view.
10889  *
10890  * Return value: (transfer none): A #GtkTreeSelection object.
10891  **/
10892 GtkTreeSelection *
10893 gtk_tree_view_get_selection (GtkTreeView *tree_view)
10894 {
10895   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
10896
10897   return tree_view->priv->selection;
10898 }
10899
10900 /**
10901  * gtk_tree_view_get_hadjustment:
10902  * @tree_view: A #GtkTreeView
10903  *
10904  * Gets the #GtkAdjustment currently being used for the horizontal aspect.
10905  *
10906  * Return value: (transfer none): A #GtkAdjustment object, or %NULL
10907  *     if none is currently being used.
10908  **/
10909 GtkAdjustment *
10910 gtk_tree_view_get_hadjustment (GtkTreeView *tree_view)
10911 {
10912   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
10913
10914   if (tree_view->priv->hadjustment == NULL)
10915     gtk_tree_view_set_hadjustment (tree_view, NULL);
10916
10917   return tree_view->priv->hadjustment;
10918 }
10919
10920 /**
10921  * gtk_tree_view_set_hadjustment:
10922  * @tree_view: A #GtkTreeView
10923  * @adjustment: (allow-none): The #GtkAdjustment to set, or %NULL
10924  *
10925  * Sets the #GtkAdjustment for the current horizontal aspect.
10926  **/
10927 void
10928 gtk_tree_view_set_hadjustment (GtkTreeView   *tree_view,
10929                                GtkAdjustment *adjustment)
10930 {
10931   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
10932
10933   gtk_tree_view_set_adjustments (tree_view,
10934                                  adjustment,
10935                                  tree_view->priv->vadjustment);
10936
10937   g_object_notify (G_OBJECT (tree_view), "hadjustment");
10938 }
10939
10940 /**
10941  * gtk_tree_view_get_vadjustment:
10942  * @tree_view: A #GtkTreeView
10943  *
10944  * Gets the #GtkAdjustment currently being used for the vertical aspect.
10945  *
10946  * Return value: (transfer none): A #GtkAdjustment object, or %NULL
10947  *     if none is currently being used.
10948  **/
10949 GtkAdjustment *
10950 gtk_tree_view_get_vadjustment (GtkTreeView *tree_view)
10951 {
10952   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
10953
10954   if (tree_view->priv->vadjustment == NULL)
10955     gtk_tree_view_set_vadjustment (tree_view, NULL);
10956
10957   return tree_view->priv->vadjustment;
10958 }
10959
10960 /**
10961  * gtk_tree_view_set_vadjustment:
10962  * @tree_view: A #GtkTreeView
10963  * @adjustment: (allow-none): The #GtkAdjustment to set, or %NULL
10964  *
10965  * Sets the #GtkAdjustment for the current vertical aspect.
10966  **/
10967 void
10968 gtk_tree_view_set_vadjustment (GtkTreeView   *tree_view,
10969                                GtkAdjustment *adjustment)
10970 {
10971   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
10972
10973   gtk_tree_view_set_adjustments (tree_view,
10974                                  tree_view->priv->hadjustment,
10975                                  adjustment);
10976
10977   g_object_notify (G_OBJECT (tree_view), "vadjustment");
10978 }
10979
10980 /* Column and header operations */
10981
10982 /**
10983  * gtk_tree_view_get_headers_visible:
10984  * @tree_view: A #GtkTreeView.
10985  *
10986  * Returns %TRUE if the headers on the @tree_view are visible.
10987  *
10988  * Return value: Whether the headers are visible or not.
10989  **/
10990 gboolean
10991 gtk_tree_view_get_headers_visible (GtkTreeView *tree_view)
10992 {
10993   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
10994
10995   return GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_HEADERS_VISIBLE);
10996 }
10997
10998 /**
10999  * gtk_tree_view_set_headers_visible:
11000  * @tree_view: A #GtkTreeView.
11001  * @headers_visible: %TRUE if the headers are visible
11002  *
11003  * Sets the visibility state of the headers.
11004  **/
11005 void
11006 gtk_tree_view_set_headers_visible (GtkTreeView *tree_view,
11007                                    gboolean     headers_visible)
11008 {
11009   gint x, y;
11010   GList *list;
11011   GtkTreeViewColumn *column;
11012   GtkAllocation allocation;
11013
11014   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
11015
11016   headers_visible = !! headers_visible;
11017
11018   if (GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_HEADERS_VISIBLE) == headers_visible)
11019     return;
11020
11021   if (headers_visible)
11022     GTK_TREE_VIEW_SET_FLAG (tree_view, GTK_TREE_VIEW_HEADERS_VISIBLE);
11023   else
11024     GTK_TREE_VIEW_UNSET_FLAG (tree_view, GTK_TREE_VIEW_HEADERS_VISIBLE);
11025
11026   if (gtk_widget_get_realized (GTK_WIDGET (tree_view)))
11027     {
11028       gdk_window_get_position (tree_view->priv->bin_window, &x, &y);
11029       if (headers_visible)
11030         {
11031           gtk_widget_get_allocation (GTK_WIDGET (tree_view), &allocation);
11032           gdk_window_move_resize (tree_view->priv->bin_window,
11033                                   x, y  + TREE_VIEW_HEADER_HEIGHT (tree_view),
11034                                   tree_view->priv->width, allocation.height -  + TREE_VIEW_HEADER_HEIGHT (tree_view));
11035
11036           if (gtk_widget_get_mapped (GTK_WIDGET (tree_view)))
11037             gtk_tree_view_map_buttons (tree_view);
11038         }
11039       else
11040         {
11041           gdk_window_move_resize (tree_view->priv->bin_window, x, y, tree_view->priv->width, tree_view->priv->height);
11042
11043           for (list = tree_view->priv->columns; list; list = list->next)
11044             {
11045               column = list->data;
11046               gtk_widget_unmap (column->button);
11047             }
11048           gdk_window_hide (tree_view->priv->header_window);
11049         }
11050     }
11051
11052   gtk_widget_get_allocation (GTK_WIDGET (tree_view), &allocation);
11053   tree_view->priv->vadjustment->page_size = allocation.height - TREE_VIEW_HEADER_HEIGHT (tree_view);
11054   tree_view->priv->vadjustment->page_increment = (allocation.height - TREE_VIEW_HEADER_HEIGHT (tree_view)) / 2;
11055   tree_view->priv->vadjustment->lower = 0;
11056   tree_view->priv->vadjustment->upper = tree_view->priv->height;
11057   gtk_adjustment_changed (tree_view->priv->vadjustment);
11058
11059   gtk_widget_queue_resize (GTK_WIDGET (tree_view));
11060
11061   g_object_notify (G_OBJECT (tree_view), "headers-visible");
11062 }
11063
11064 /**
11065  * gtk_tree_view_columns_autosize:
11066  * @tree_view: A #GtkTreeView.
11067  *
11068  * Resizes all columns to their optimal width. Only works after the
11069  * treeview has been realized.
11070  **/
11071 void
11072 gtk_tree_view_columns_autosize (GtkTreeView *tree_view)
11073 {
11074   gboolean dirty = FALSE;
11075   GList *list;
11076   GtkTreeViewColumn *column;
11077
11078   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
11079
11080   for (list = tree_view->priv->columns; list; list = list->next)
11081     {
11082       column = list->data;
11083       if (column->column_type == GTK_TREE_VIEW_COLUMN_AUTOSIZE)
11084         continue;
11085       _gtk_tree_view_column_cell_set_dirty (column, TRUE);
11086       dirty = TRUE;
11087     }
11088
11089   if (dirty)
11090     gtk_widget_queue_resize (GTK_WIDGET (tree_view));
11091 }
11092
11093 /**
11094  * gtk_tree_view_set_headers_clickable:
11095  * @tree_view: A #GtkTreeView.
11096  * @setting: %TRUE if the columns are clickable.
11097  *
11098  * Allow the column title buttons to be clicked.
11099  **/
11100 void
11101 gtk_tree_view_set_headers_clickable (GtkTreeView *tree_view,
11102                                      gboolean   setting)
11103 {
11104   GList *list;
11105
11106   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
11107
11108   for (list = tree_view->priv->columns; list; list = list->next)
11109     gtk_tree_view_column_set_clickable (GTK_TREE_VIEW_COLUMN (list->data), setting);
11110
11111   g_object_notify (G_OBJECT (tree_view), "headers-clickable");
11112 }
11113
11114
11115 /**
11116  * gtk_tree_view_get_headers_clickable:
11117  * @tree_view: A #GtkTreeView.
11118  *
11119  * Returns whether all header columns are clickable.
11120  *
11121  * Return value: %TRUE if all header columns are clickable, otherwise %FALSE
11122  *
11123  * Since: 2.10
11124  **/
11125 gboolean
11126 gtk_tree_view_get_headers_clickable (GtkTreeView *tree_view)
11127 {
11128   GList *list;
11129
11130   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
11131
11132   for (list = tree_view->priv->columns; list; list = list->next)
11133     if (!GTK_TREE_VIEW_COLUMN (list->data)->clickable)
11134       return FALSE;
11135
11136   return TRUE;
11137 }
11138
11139 /**
11140  * gtk_tree_view_set_rules_hint
11141  * @tree_view: a #GtkTreeView
11142  * @setting: %TRUE if the tree requires reading across rows
11143  *
11144  * This function tells GTK+ that the user interface for your
11145  * application requires users to read across tree rows and associate
11146  * cells with one another. By default, GTK+ will then render the tree
11147  * with alternating row colors. Do <emphasis>not</emphasis> use it
11148  * just because you prefer the appearance of the ruled tree; that's a
11149  * question for the theme. Some themes will draw tree rows in
11150  * alternating colors even when rules are turned off, and users who
11151  * prefer that appearance all the time can choose those themes. You
11152  * should call this function only as a <emphasis>semantic</emphasis>
11153  * hint to the theme engine that your tree makes alternating colors
11154  * useful from a functional standpoint (since it has lots of columns,
11155  * generally).
11156  *
11157  **/
11158 void
11159 gtk_tree_view_set_rules_hint (GtkTreeView  *tree_view,
11160                               gboolean      setting)
11161 {
11162   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
11163
11164   setting = setting != FALSE;
11165
11166   if (tree_view->priv->has_rules != setting)
11167     {
11168       tree_view->priv->has_rules = setting;
11169       gtk_widget_queue_draw (GTK_WIDGET (tree_view));
11170     }
11171
11172   g_object_notify (G_OBJECT (tree_view), "rules-hint");
11173 }
11174
11175 /**
11176  * gtk_tree_view_get_rules_hint
11177  * @tree_view: a #GtkTreeView
11178  *
11179  * Gets the setting set by gtk_tree_view_set_rules_hint().
11180  *
11181  * Return value: %TRUE if rules are useful for the user of this tree
11182  **/
11183 gboolean
11184 gtk_tree_view_get_rules_hint (GtkTreeView  *tree_view)
11185 {
11186   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
11187
11188   return tree_view->priv->has_rules;
11189 }
11190
11191 /* Public Column functions
11192  */
11193
11194 /**
11195  * gtk_tree_view_append_column:
11196  * @tree_view: A #GtkTreeView.
11197  * @column: The #GtkTreeViewColumn to add.
11198  *
11199  * Appends @column to the list of columns. If @tree_view has "fixed_height"
11200  * mode enabled, then @column must have its "sizing" property set to be
11201  * GTK_TREE_VIEW_COLUMN_FIXED.
11202  *
11203  * Return value: The number of columns in @tree_view after appending.
11204  **/
11205 gint
11206 gtk_tree_view_append_column (GtkTreeView       *tree_view,
11207                              GtkTreeViewColumn *column)
11208 {
11209   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), -1);
11210   g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (column), -1);
11211   g_return_val_if_fail (column->tree_view == NULL, -1);
11212
11213   return gtk_tree_view_insert_column (tree_view, column, -1);
11214 }
11215
11216
11217 /**
11218  * gtk_tree_view_remove_column:
11219  * @tree_view: A #GtkTreeView.
11220  * @column: The #GtkTreeViewColumn to remove.
11221  *
11222  * Removes @column from @tree_view.
11223  *
11224  * Return value: The number of columns in @tree_view after removing.
11225  **/
11226 gint
11227 gtk_tree_view_remove_column (GtkTreeView       *tree_view,
11228                              GtkTreeViewColumn *column)
11229 {
11230   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), -1);
11231   g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (column), -1);
11232   g_return_val_if_fail (column->tree_view == GTK_WIDGET (tree_view), -1);
11233
11234   if (tree_view->priv->focus_column == column)
11235     tree_view->priv->focus_column = NULL;
11236
11237   if (tree_view->priv->edited_column == column)
11238     {
11239       gtk_tree_view_stop_editing (tree_view, TRUE);
11240
11241       /* no need to, but just to be sure ... */
11242       tree_view->priv->edited_column = NULL;
11243     }
11244
11245   if (tree_view->priv->expander_column == column)
11246     tree_view->priv->expander_column = NULL;
11247
11248   g_signal_handlers_disconnect_by_func (column,
11249                                         G_CALLBACK (column_sizing_notify),
11250                                         tree_view);
11251
11252   _gtk_tree_view_column_unset_tree_view (column);
11253
11254   tree_view->priv->columns = g_list_remove (tree_view->priv->columns, column);
11255   tree_view->priv->n_columns--;
11256
11257   if (gtk_widget_get_realized (GTK_WIDGET (tree_view)))
11258     {
11259       GList *list;
11260
11261       _gtk_tree_view_column_unrealize_button (column);
11262       for (list = tree_view->priv->columns; list; list = list->next)
11263         {
11264           GtkTreeViewColumn *tmp_column;
11265
11266           tmp_column = GTK_TREE_VIEW_COLUMN (list->data);
11267           if (tmp_column->visible)
11268             _gtk_tree_view_column_cell_set_dirty (tmp_column, TRUE);
11269         }
11270
11271       if (tree_view->priv->n_columns == 0 &&
11272           gtk_tree_view_get_headers_visible (tree_view))
11273         gdk_window_hide (tree_view->priv->header_window);
11274
11275       gtk_widget_queue_resize (GTK_WIDGET (tree_view));
11276     }
11277
11278   g_object_unref (column);
11279   g_signal_emit (tree_view, tree_view_signals[COLUMNS_CHANGED], 0);
11280
11281   return tree_view->priv->n_columns;
11282 }
11283
11284 /**
11285  * gtk_tree_view_insert_column:
11286  * @tree_view: A #GtkTreeView.
11287  * @column: The #GtkTreeViewColumn to be inserted.
11288  * @position: The position to insert @column in.
11289  *
11290  * This inserts the @column into the @tree_view at @position.  If @position is
11291  * -1, then the column is inserted at the end. If @tree_view has
11292  * "fixed_height" mode enabled, then @column must have its "sizing" property
11293  * set to be GTK_TREE_VIEW_COLUMN_FIXED.
11294  *
11295  * Return value: The number of columns in @tree_view after insertion.
11296  **/
11297 gint
11298 gtk_tree_view_insert_column (GtkTreeView       *tree_view,
11299                              GtkTreeViewColumn *column,
11300                              gint               position)
11301 {
11302   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), -1);
11303   g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (column), -1);
11304   g_return_val_if_fail (column->tree_view == NULL, -1);
11305
11306   if (tree_view->priv->fixed_height_mode)
11307     g_return_val_if_fail (gtk_tree_view_column_get_sizing (column)
11308                           == GTK_TREE_VIEW_COLUMN_FIXED, -1);
11309
11310   g_object_ref_sink (column);
11311
11312   if (tree_view->priv->n_columns == 0 &&
11313       gtk_widget_get_realized (GTK_WIDGET (tree_view)) &&
11314       gtk_tree_view_get_headers_visible (tree_view))
11315     {
11316       gdk_window_show (tree_view->priv->header_window);
11317     }
11318
11319   g_signal_connect (column, "notify::sizing",
11320                     G_CALLBACK (column_sizing_notify), tree_view);
11321
11322   tree_view->priv->columns = g_list_insert (tree_view->priv->columns,
11323                                             column, position);
11324   tree_view->priv->n_columns++;
11325
11326   _gtk_tree_view_column_set_tree_view (column, tree_view);
11327
11328   if (gtk_widget_get_realized (GTK_WIDGET (tree_view)))
11329     {
11330       GList *list;
11331
11332       _gtk_tree_view_column_realize_button (column);
11333
11334       for (list = tree_view->priv->columns; list; list = list->next)
11335         {
11336           column = GTK_TREE_VIEW_COLUMN (list->data);
11337           if (column->visible)
11338             _gtk_tree_view_column_cell_set_dirty (column, TRUE);
11339         }
11340       gtk_widget_queue_resize (GTK_WIDGET (tree_view));
11341     }
11342
11343   g_signal_emit (tree_view, tree_view_signals[COLUMNS_CHANGED], 0);
11344
11345   return tree_view->priv->n_columns;
11346 }
11347
11348 /**
11349  * gtk_tree_view_insert_column_with_attributes:
11350  * @tree_view: A #GtkTreeView
11351  * @position: The position to insert the new column in.
11352  * @title: The title to set the header to.
11353  * @cell: The #GtkCellRenderer.
11354  * @Varargs: A %NULL-terminated list of attributes.
11355  *
11356  * Creates a new #GtkTreeViewColumn and inserts it into the @tree_view at
11357  * @position.  If @position is -1, then the newly created column is inserted at
11358  * the end.  The column is initialized with the attributes given. If @tree_view
11359  * has "fixed_height" mode enabled, then the new column will have its sizing
11360  * property set to be GTK_TREE_VIEW_COLUMN_FIXED.
11361  *
11362  * Return value: The number of columns in @tree_view after insertion.
11363  **/
11364 gint
11365 gtk_tree_view_insert_column_with_attributes (GtkTreeView     *tree_view,
11366                                              gint             position,
11367                                              const gchar     *title,
11368                                              GtkCellRenderer *cell,
11369                                              ...)
11370 {
11371   GtkTreeViewColumn *column;
11372   gchar *attribute;
11373   va_list args;
11374   gint column_id;
11375
11376   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), -1);
11377
11378   column = gtk_tree_view_column_new ();
11379   if (tree_view->priv->fixed_height_mode)
11380     gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_FIXED);
11381
11382   gtk_tree_view_column_set_title (column, title);
11383   gtk_tree_view_column_pack_start (column, cell, TRUE);
11384
11385   va_start (args, cell);
11386
11387   attribute = va_arg (args, gchar *);
11388
11389   while (attribute != NULL)
11390     {
11391       column_id = va_arg (args, gint);
11392       gtk_tree_view_column_add_attribute (column, cell, attribute, column_id);
11393       attribute = va_arg (args, gchar *);
11394     }
11395
11396   va_end (args);
11397
11398   gtk_tree_view_insert_column (tree_view, column, position);
11399
11400   return tree_view->priv->n_columns;
11401 }
11402
11403 /**
11404  * gtk_tree_view_insert_column_with_data_func:
11405  * @tree_view: a #GtkTreeView
11406  * @position: Position to insert, -1 for append
11407  * @title: column title
11408  * @cell: cell renderer for column
11409  * @func: function to set attributes of cell renderer
11410  * @data: data for @func
11411  * @dnotify: destroy notifier for @data
11412  *
11413  * Convenience function that inserts a new column into the #GtkTreeView
11414  * with the given cell renderer and a #GtkCellDataFunc to set cell renderer
11415  * attributes (normally using data from the model). See also
11416  * gtk_tree_view_column_set_cell_data_func(), gtk_tree_view_column_pack_start().
11417  * If @tree_view has "fixed_height" mode enabled, then the new column will have its
11418  * "sizing" property set to be GTK_TREE_VIEW_COLUMN_FIXED.
11419  *
11420  * Return value: number of columns in the tree view post-insert
11421  **/
11422 gint
11423 gtk_tree_view_insert_column_with_data_func  (GtkTreeView               *tree_view,
11424                                              gint                       position,
11425                                              const gchar               *title,
11426                                              GtkCellRenderer           *cell,
11427                                              GtkTreeCellDataFunc        func,
11428                                              gpointer                   data,
11429                                              GDestroyNotify             dnotify)
11430 {
11431   GtkTreeViewColumn *column;
11432
11433   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), -1);
11434
11435   column = gtk_tree_view_column_new ();
11436   if (tree_view->priv->fixed_height_mode)
11437     gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_FIXED);
11438
11439   gtk_tree_view_column_set_title (column, title);
11440   gtk_tree_view_column_pack_start (column, cell, TRUE);
11441   gtk_tree_view_column_set_cell_data_func (column, cell, func, data, dnotify);
11442
11443   gtk_tree_view_insert_column (tree_view, column, position);
11444
11445   return tree_view->priv->n_columns;
11446 }
11447
11448 /**
11449  * gtk_tree_view_get_column:
11450  * @tree_view: A #GtkTreeView.
11451  * @n: The position of the column, counting from 0.
11452  *
11453  * Gets the #GtkTreeViewColumn at the given position in the #tree_view.
11454  *
11455  * Return value: (transfer none): The #GtkTreeViewColumn, or %NULL if the
11456  *     position is outside the range of columns.
11457  **/
11458 GtkTreeViewColumn *
11459 gtk_tree_view_get_column (GtkTreeView *tree_view,
11460                           gint         n)
11461 {
11462   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
11463
11464   if (n < 0 || n >= tree_view->priv->n_columns)
11465     return NULL;
11466
11467   if (tree_view->priv->columns == NULL)
11468     return NULL;
11469
11470   return GTK_TREE_VIEW_COLUMN (g_list_nth (tree_view->priv->columns, n)->data);
11471 }
11472
11473 /**
11474  * gtk_tree_view_get_columns:
11475  * @tree_view: A #GtkTreeView
11476  *
11477  * Returns a #GList of all the #GtkTreeViewColumn s currently in @tree_view.
11478  * The returned list must be freed with g_list_free ().
11479  *
11480  * Return value: (element-type GtkTreeViewColumn) (transfer container): A list of #GtkTreeViewColumn s
11481  **/
11482 GList *
11483 gtk_tree_view_get_columns (GtkTreeView *tree_view)
11484 {
11485   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
11486
11487   return g_list_copy (tree_view->priv->columns);
11488 }
11489
11490 /**
11491  * gtk_tree_view_move_column_after:
11492  * @tree_view: A #GtkTreeView
11493  * @column: The #GtkTreeViewColumn to be moved.
11494  * @base_column: (allow-none): The #GtkTreeViewColumn to be moved relative to, or %NULL.
11495  *
11496  * Moves @column to be after to @base_column.  If @base_column is %NULL, then
11497  * @column is placed in the first position.
11498  **/
11499 void
11500 gtk_tree_view_move_column_after (GtkTreeView       *tree_view,
11501                                  GtkTreeViewColumn *column,
11502                                  GtkTreeViewColumn *base_column)
11503 {
11504   GList *column_list_el, *base_el = NULL;
11505
11506   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
11507
11508   column_list_el = g_list_find (tree_view->priv->columns, column);
11509   g_return_if_fail (column_list_el != NULL);
11510
11511   if (base_column)
11512     {
11513       base_el = g_list_find (tree_view->priv->columns, base_column);
11514       g_return_if_fail (base_el != NULL);
11515     }
11516
11517   if (column_list_el->prev == base_el)
11518     return;
11519
11520   tree_view->priv->columns = g_list_remove_link (tree_view->priv->columns, column_list_el);
11521   if (base_el == NULL)
11522     {
11523       column_list_el->prev = NULL;
11524       column_list_el->next = tree_view->priv->columns;
11525       if (column_list_el->next)
11526         column_list_el->next->prev = column_list_el;
11527       tree_view->priv->columns = column_list_el;
11528     }
11529   else
11530     {
11531       column_list_el->prev = base_el;
11532       column_list_el->next = base_el->next;
11533       if (column_list_el->next)
11534         column_list_el->next->prev = column_list_el;
11535       base_el->next = column_list_el;
11536     }
11537
11538   if (gtk_widget_get_realized (GTK_WIDGET (tree_view)))
11539     {
11540       gtk_widget_queue_resize (GTK_WIDGET (tree_view));
11541       gtk_tree_view_size_allocate_columns (GTK_WIDGET (tree_view), NULL);
11542     }
11543
11544   g_signal_emit (tree_view, tree_view_signals[COLUMNS_CHANGED], 0);
11545 }
11546
11547 /**
11548  * gtk_tree_view_set_expander_column:
11549  * @tree_view: A #GtkTreeView
11550  * @column: %NULL, or the column to draw the expander arrow at.
11551  *
11552  * Sets the column to draw the expander arrow at. It must be in @tree_view.
11553  * If @column is %NULL, then the expander arrow is always at the first
11554  * visible column.
11555  *
11556  * If you do not want expander arrow to appear in your tree, set the
11557  * expander column to a hidden column.
11558  **/
11559 void
11560 gtk_tree_view_set_expander_column (GtkTreeView       *tree_view,
11561                                    GtkTreeViewColumn *column)
11562 {
11563   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
11564   g_return_if_fail (column == NULL || GTK_IS_TREE_VIEW_COLUMN (column));
11565
11566   if (tree_view->priv->expander_column != column)
11567     {
11568       GList *list;
11569
11570       if (column)
11571         {
11572           /* Confirm that column is in tree_view */
11573           for (list = tree_view->priv->columns; list; list = list->next)
11574             if (list->data == column)
11575               break;
11576           g_return_if_fail (list != NULL);
11577         }
11578
11579       tree_view->priv->expander_column = column;
11580       g_object_notify (G_OBJECT (tree_view), "expander-column");
11581     }
11582 }
11583
11584 /**
11585  * gtk_tree_view_get_expander_column:
11586  * @tree_view: A #GtkTreeView
11587  *
11588  * Returns the column that is the current expander column.
11589  * This column has the expander arrow drawn next to it.
11590  *
11591  * Return value: (transfer none): The expander column.
11592  **/
11593 GtkTreeViewColumn *
11594 gtk_tree_view_get_expander_column (GtkTreeView *tree_view)
11595 {
11596   GList *list;
11597
11598   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
11599
11600   for (list = tree_view->priv->columns; list; list = list->next)
11601     if (gtk_tree_view_is_expander_column (tree_view, GTK_TREE_VIEW_COLUMN (list->data)))
11602       return (GtkTreeViewColumn *) list->data;
11603   return NULL;
11604 }
11605
11606
11607 /**
11608  * gtk_tree_view_set_column_drag_function:
11609  * @tree_view: A #GtkTreeView.
11610  * @func: (allow-none): A function to determine which columns are reorderable, or %NULL.
11611  * @user_data: (allow-none): User data to be passed to @func, or %NULL
11612  * @destroy: (allow-none): Destroy notifier for @user_data, or %NULL
11613  *
11614  * Sets a user function for determining where a column may be dropped when
11615  * dragged.  This function is called on every column pair in turn at the
11616  * beginning of a column drag to determine where a drop can take place.  The
11617  * arguments passed to @func are: the @tree_view, the #GtkTreeViewColumn being
11618  * dragged, the two #GtkTreeViewColumn s determining the drop spot, and
11619  * @user_data.  If either of the #GtkTreeViewColumn arguments for the drop spot
11620  * are %NULL, then they indicate an edge.  If @func is set to be %NULL, then
11621  * @tree_view reverts to the default behavior of allowing all columns to be
11622  * dropped everywhere.
11623  **/
11624 void
11625 gtk_tree_view_set_column_drag_function (GtkTreeView               *tree_view,
11626                                         GtkTreeViewColumnDropFunc  func,
11627                                         gpointer                   user_data,
11628                                         GDestroyNotify             destroy)
11629 {
11630   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
11631
11632   if (tree_view->priv->column_drop_func_data_destroy)
11633     tree_view->priv->column_drop_func_data_destroy (tree_view->priv->column_drop_func_data);
11634
11635   tree_view->priv->column_drop_func = func;
11636   tree_view->priv->column_drop_func_data = user_data;
11637   tree_view->priv->column_drop_func_data_destroy = destroy;
11638 }
11639
11640 /**
11641  * gtk_tree_view_scroll_to_point:
11642  * @tree_view: a #GtkTreeView
11643  * @tree_x: X coordinate of new top-left pixel of visible area, or -1
11644  * @tree_y: Y coordinate of new top-left pixel of visible area, or -1
11645  *
11646  * Scrolls the tree view such that the top-left corner of the visible
11647  * area is @tree_x, @tree_y, where @tree_x and @tree_y are specified
11648  * in tree coordinates.  The @tree_view must be realized before
11649  * this function is called.  If it isn't, you probably want to be
11650  * using gtk_tree_view_scroll_to_cell().
11651  *
11652  * If either @tree_x or @tree_y are -1, then that direction isn't scrolled.
11653  **/
11654 void
11655 gtk_tree_view_scroll_to_point (GtkTreeView *tree_view,
11656                                gint         tree_x,
11657                                gint         tree_y)
11658 {
11659   GtkAdjustment *hadj;
11660   GtkAdjustment *vadj;
11661
11662   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
11663   g_return_if_fail (gtk_widget_get_realized (GTK_WIDGET (tree_view)));
11664
11665   hadj = tree_view->priv->hadjustment;
11666   vadj = tree_view->priv->vadjustment;
11667
11668   if (tree_x != -1)
11669     gtk_adjustment_set_value (hadj, tree_x);
11670   if (tree_y != -1)
11671     gtk_adjustment_set_value (vadj, tree_y);
11672 }
11673
11674 /**
11675  * gtk_tree_view_scroll_to_cell:
11676  * @tree_view: A #GtkTreeView.
11677  * @path: (allow-none): The path of the row to move to, or %NULL.
11678  * @column: (allow-none): The #GtkTreeViewColumn to move horizontally to, or %NULL.
11679  * @use_align: whether to use alignment arguments, or %FALSE.
11680  * @row_align: The vertical alignment of the row specified by @path.
11681  * @col_align: The horizontal alignment of the column specified by @column.
11682  *
11683  * Moves the alignments of @tree_view to the position specified by @column and
11684  * @path.  If @column is %NULL, then no horizontal scrolling occurs.  Likewise,
11685  * if @path is %NULL no vertical scrolling occurs.  At a minimum, one of @column
11686  * or @path need to be non-%NULL.  @row_align determines where the row is
11687  * placed, and @col_align determines where @column is placed.  Both are expected
11688  * to be between 0.0 and 1.0. 0.0 means left/top alignment, 1.0 means
11689  * right/bottom alignment, 0.5 means center.
11690  *
11691  * If @use_align is %FALSE, then the alignment arguments are ignored, and the
11692  * tree does the minimum amount of work to scroll the cell onto the screen.
11693  * This means that the cell will be scrolled to the edge closest to its current
11694  * position.  If the cell is currently visible on the screen, nothing is done.
11695  *
11696  * This function only works if the model is set, and @path is a valid row on the
11697  * model.  If the model changes before the @tree_view is realized, the centered
11698  * path will be modified to reflect this change.
11699  **/
11700 void
11701 gtk_tree_view_scroll_to_cell (GtkTreeView       *tree_view,
11702                               GtkTreePath       *path,
11703                               GtkTreeViewColumn *column,
11704                               gboolean           use_align,
11705                               gfloat             row_align,
11706                               gfloat             col_align)
11707 {
11708   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
11709   g_return_if_fail (tree_view->priv->model != NULL);
11710   g_return_if_fail (tree_view->priv->tree != NULL);
11711   g_return_if_fail (row_align >= 0.0 && row_align <= 1.0);
11712   g_return_if_fail (col_align >= 0.0 && col_align <= 1.0);
11713   g_return_if_fail (path != NULL || column != NULL);
11714
11715 #if 0
11716   g_print ("gtk_tree_view_scroll_to_cell:\npath: %s\ncolumn: %s\nuse_align: %d\nrow_align: %f\ncol_align: %f\n",
11717            gtk_tree_path_to_string (path), column?"non-null":"null", use_align, row_align, col_align);
11718 #endif
11719   row_align = CLAMP (row_align, 0.0, 1.0);
11720   col_align = CLAMP (col_align, 0.0, 1.0);
11721
11722
11723   /* Note: Despite the benefits that come from having one code path for the
11724    * scrolling code, we short-circuit validate_visible_area's immplementation as
11725    * it is much slower than just going to the point.
11726    */
11727   if (!gtk_widget_get_visible (GTK_WIDGET (tree_view)) ||
11728       !gtk_widget_get_realized (GTK_WIDGET (tree_view)) ||
11729       GTK_WIDGET_ALLOC_NEEDED (tree_view) ||
11730       GTK_RBNODE_FLAG_SET (tree_view->priv->tree->root, GTK_RBNODE_DESCENDANTS_INVALID))
11731     {
11732       if (tree_view->priv->scroll_to_path)
11733         gtk_tree_row_reference_free (tree_view->priv->scroll_to_path);
11734
11735       tree_view->priv->scroll_to_path = NULL;
11736       tree_view->priv->scroll_to_column = NULL;
11737
11738       if (path)
11739         tree_view->priv->scroll_to_path = gtk_tree_row_reference_new_proxy (G_OBJECT (tree_view), tree_view->priv->model, path);
11740       if (column)
11741         tree_view->priv->scroll_to_column = column;
11742       tree_view->priv->scroll_to_use_align = use_align;
11743       tree_view->priv->scroll_to_row_align = row_align;
11744       tree_view->priv->scroll_to_col_align = col_align;
11745
11746       install_presize_handler (tree_view);
11747     }
11748   else
11749     {
11750       GdkRectangle cell_rect;
11751       GdkRectangle vis_rect;
11752       gint dest_x, dest_y;
11753
11754       gtk_tree_view_get_background_area (tree_view, path, column, &cell_rect);
11755       gtk_tree_view_get_visible_rect (tree_view, &vis_rect);
11756
11757       cell_rect.y = TREE_WINDOW_Y_TO_RBTREE_Y (tree_view, cell_rect.y);
11758
11759       dest_x = vis_rect.x;
11760       dest_y = vis_rect.y;
11761
11762       if (column)
11763         {
11764           if (use_align)
11765             {
11766               dest_x = cell_rect.x - ((vis_rect.width - cell_rect.width) * col_align);
11767             }
11768           else
11769             {
11770               if (cell_rect.x < vis_rect.x)
11771                 dest_x = cell_rect.x;
11772               if (cell_rect.x + cell_rect.width > vis_rect.x + vis_rect.width)
11773                 dest_x = cell_rect.x + cell_rect.width - vis_rect.width;
11774             }
11775         }
11776
11777       if (path)
11778         {
11779           if (use_align)
11780             {
11781               dest_y = cell_rect.y - ((vis_rect.height - cell_rect.height) * row_align);
11782               dest_y = MAX (dest_y, 0);
11783             }
11784           else
11785             {
11786               if (cell_rect.y < vis_rect.y)
11787                 dest_y = cell_rect.y;
11788               if (cell_rect.y + cell_rect.height > vis_rect.y + vis_rect.height)
11789                 dest_y = cell_rect.y + cell_rect.height - vis_rect.height;
11790             }
11791         }
11792
11793       gtk_tree_view_scroll_to_point (tree_view, dest_x, dest_y);
11794     }
11795 }
11796
11797 /**
11798  * gtk_tree_view_row_activated:
11799  * @tree_view: A #GtkTreeView
11800  * @path: The #GtkTreePath to be activated.
11801  * @column: The #GtkTreeViewColumn to be activated.
11802  *
11803  * Activates the cell determined by @path and @column.
11804  **/
11805 void
11806 gtk_tree_view_row_activated (GtkTreeView       *tree_view,
11807                              GtkTreePath       *path,
11808                              GtkTreeViewColumn *column)
11809 {
11810   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
11811
11812   g_signal_emit (tree_view, tree_view_signals[ROW_ACTIVATED], 0, path, column);
11813 }
11814
11815
11816 static void
11817 gtk_tree_view_expand_all_emission_helper (GtkRBTree *tree,
11818                                           GtkRBNode *node,
11819                                           gpointer   data)
11820 {
11821   GtkTreeView *tree_view = data;
11822
11823   if ((node->flags & GTK_RBNODE_IS_PARENT) == GTK_RBNODE_IS_PARENT &&
11824       node->children)
11825     {
11826       GtkTreePath *path;
11827       GtkTreeIter iter;
11828
11829       path = _gtk_tree_view_find_path (tree_view, tree, node);
11830       gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
11831
11832       g_signal_emit (tree_view, tree_view_signals[ROW_EXPANDED], 0, &iter, path);
11833
11834       gtk_tree_path_free (path);
11835     }
11836
11837   if (node->children)
11838     _gtk_rbtree_traverse (node->children,
11839                           node->children->root,
11840                           G_PRE_ORDER,
11841                           gtk_tree_view_expand_all_emission_helper,
11842                           tree_view);
11843 }
11844
11845 /**
11846  * gtk_tree_view_expand_all:
11847  * @tree_view: A #GtkTreeView.
11848  *
11849  * Recursively expands all nodes in the @tree_view.
11850  **/
11851 void
11852 gtk_tree_view_expand_all (GtkTreeView *tree_view)
11853 {
11854   GtkTreePath *path;
11855   GtkRBTree *tree;
11856   GtkRBNode *node;
11857
11858   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
11859
11860   if (tree_view->priv->tree == NULL)
11861     return;
11862
11863   path = gtk_tree_path_new_first ();
11864   _gtk_tree_view_find_node (tree_view, path, &tree, &node);
11865
11866   while (node)
11867     {
11868       gtk_tree_view_real_expand_row (tree_view, path, tree, node, TRUE, FALSE);
11869       node = _gtk_rbtree_next (tree, node);
11870       gtk_tree_path_next (path);
11871   }
11872
11873   gtk_tree_path_free (path);
11874 }
11875
11876 /* Timeout to animate the expander during expands and collapses */
11877 static gboolean
11878 expand_collapse_timeout (gpointer data)
11879 {
11880   return do_expand_collapse (data);
11881 }
11882
11883 static void
11884 add_expand_collapse_timeout (GtkTreeView *tree_view,
11885                              GtkRBTree   *tree,
11886                              GtkRBNode   *node,
11887                              gboolean     expand)
11888 {
11889   if (tree_view->priv->expand_collapse_timeout != 0)
11890     return;
11891
11892   tree_view->priv->expand_collapse_timeout =
11893       gdk_threads_add_timeout (50, expand_collapse_timeout, tree_view);
11894   tree_view->priv->expanded_collapsed_tree = tree;
11895   tree_view->priv->expanded_collapsed_node = node;
11896
11897   if (expand)
11898     GTK_RBNODE_SET_FLAG (node, GTK_RBNODE_IS_SEMI_COLLAPSED);
11899   else
11900     GTK_RBNODE_SET_FLAG (node, GTK_RBNODE_IS_SEMI_EXPANDED);
11901 }
11902
11903 static void
11904 remove_expand_collapse_timeout (GtkTreeView *tree_view)
11905 {
11906   if (tree_view->priv->expand_collapse_timeout)
11907     {
11908       g_source_remove (tree_view->priv->expand_collapse_timeout);
11909       tree_view->priv->expand_collapse_timeout = 0;
11910     }
11911
11912   if (tree_view->priv->expanded_collapsed_node != NULL)
11913     {
11914       GTK_RBNODE_UNSET_FLAG (tree_view->priv->expanded_collapsed_node, GTK_RBNODE_IS_SEMI_EXPANDED);
11915       GTK_RBNODE_UNSET_FLAG (tree_view->priv->expanded_collapsed_node, GTK_RBNODE_IS_SEMI_COLLAPSED);
11916
11917       tree_view->priv->expanded_collapsed_node = NULL;
11918     }
11919 }
11920
11921 static void
11922 cancel_arrow_animation (GtkTreeView *tree_view)
11923 {
11924   if (tree_view->priv->expand_collapse_timeout)
11925     {
11926       while (do_expand_collapse (tree_view));
11927
11928       remove_expand_collapse_timeout (tree_view);
11929     }
11930 }
11931
11932 static gboolean
11933 do_expand_collapse (GtkTreeView *tree_view)
11934 {
11935   GtkRBNode *node;
11936   GtkRBTree *tree;
11937   gboolean expanding;
11938   gboolean redraw;
11939
11940   redraw = FALSE;
11941   expanding = TRUE;
11942
11943   node = tree_view->priv->expanded_collapsed_node;
11944   tree = tree_view->priv->expanded_collapsed_tree;
11945
11946   if (node->children == NULL)
11947     expanding = FALSE;
11948
11949   if (expanding)
11950     {
11951       if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SEMI_COLLAPSED))
11952         {
11953           GTK_RBNODE_UNSET_FLAG (node, GTK_RBNODE_IS_SEMI_COLLAPSED);
11954           GTK_RBNODE_SET_FLAG (node, GTK_RBNODE_IS_SEMI_EXPANDED);
11955
11956           redraw = TRUE;
11957
11958         }
11959       else if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SEMI_EXPANDED))
11960         {
11961           GTK_RBNODE_UNSET_FLAG (node, GTK_RBNODE_IS_SEMI_EXPANDED);
11962
11963           redraw = TRUE;
11964         }
11965     }
11966   else
11967     {
11968       if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SEMI_EXPANDED))
11969         {
11970           GTK_RBNODE_UNSET_FLAG (node, GTK_RBNODE_IS_SEMI_EXPANDED);
11971           GTK_RBNODE_SET_FLAG (node, GTK_RBNODE_IS_SEMI_COLLAPSED);
11972
11973           redraw = TRUE;
11974         }
11975       else if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SEMI_COLLAPSED))
11976         {
11977           GTK_RBNODE_UNSET_FLAG (node, GTK_RBNODE_IS_SEMI_COLLAPSED);
11978
11979           redraw = TRUE;
11980
11981         }
11982     }
11983
11984   if (redraw)
11985     {
11986       gtk_tree_view_queue_draw_arrow (tree_view, tree, node);
11987
11988       return TRUE;
11989     }
11990
11991   return FALSE;
11992 }
11993
11994 /**
11995  * gtk_tree_view_collapse_all:
11996  * @tree_view: A #GtkTreeView.
11997  *
11998  * Recursively collapses all visible, expanded nodes in @tree_view.
11999  **/
12000 void
12001 gtk_tree_view_collapse_all (GtkTreeView *tree_view)
12002 {
12003   GtkRBTree *tree;
12004   GtkRBNode *node;
12005   GtkTreePath *path;
12006   gint *indices;
12007
12008   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
12009
12010   if (tree_view->priv->tree == NULL)
12011     return;
12012
12013   path = gtk_tree_path_new ();
12014   gtk_tree_path_down (path);
12015   indices = gtk_tree_path_get_indices (path);
12016
12017   tree = tree_view->priv->tree;
12018   node = tree->root;
12019   while (node && node->left != tree->nil)
12020     node = node->left;
12021
12022   while (node)
12023     {
12024       if (node->children)
12025         gtk_tree_view_real_collapse_row (tree_view, path, tree, node, FALSE);
12026       indices[0]++;
12027       node = _gtk_rbtree_next (tree, node);
12028     }
12029
12030   gtk_tree_path_free (path);
12031 }
12032
12033 /**
12034  * gtk_tree_view_expand_to_path:
12035  * @tree_view: A #GtkTreeView.
12036  * @path: path to a row.
12037  *
12038  * Expands the row at @path. This will also expand all parent rows of
12039  * @path as necessary.
12040  *
12041  * Since: 2.2
12042  **/
12043 void
12044 gtk_tree_view_expand_to_path (GtkTreeView *tree_view,
12045                               GtkTreePath *path)
12046 {
12047   gint i, depth;
12048   gint *indices;
12049   GtkTreePath *tmp;
12050
12051   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
12052   g_return_if_fail (path != NULL);
12053
12054   depth = gtk_tree_path_get_depth (path);
12055   indices = gtk_tree_path_get_indices (path);
12056
12057   tmp = gtk_tree_path_new ();
12058   g_return_if_fail (tmp != NULL);
12059
12060   for (i = 0; i < depth; i++)
12061     {
12062       gtk_tree_path_append_index (tmp, indices[i]);
12063       gtk_tree_view_expand_row (tree_view, tmp, FALSE);
12064     }
12065
12066   gtk_tree_path_free (tmp);
12067 }
12068
12069 /* FIXME the bool return values for expand_row and collapse_row are
12070  * not analagous; they should be TRUE if the row had children and
12071  * was not already in the requested state.
12072  */
12073
12074
12075 static gboolean
12076 gtk_tree_view_real_expand_row (GtkTreeView *tree_view,
12077                                GtkTreePath *path,
12078                                GtkRBTree   *tree,
12079                                GtkRBNode   *node,
12080                                gboolean     open_all,
12081                                gboolean     animate)
12082 {
12083   GtkTreeIter iter;
12084   GtkTreeIter temp;
12085   gboolean expand;
12086
12087   if (animate)
12088     g_object_get (gtk_widget_get_settings (GTK_WIDGET (tree_view)),
12089                   "gtk-enable-animations", &animate,
12090                   NULL);
12091
12092   remove_auto_expand_timeout (tree_view);
12093
12094   if (node->children && !open_all)
12095     return FALSE;
12096
12097   if (! GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT))
12098     return FALSE;
12099
12100   gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
12101   if (! gtk_tree_model_iter_has_child (tree_view->priv->model, &iter))
12102     return FALSE;
12103
12104
12105    if (node->children && open_all)
12106     {
12107       gboolean retval = FALSE;
12108       GtkTreePath *tmp_path = gtk_tree_path_copy (path);
12109
12110       gtk_tree_path_append_index (tmp_path, 0);
12111       tree = node->children;
12112       node = tree->root;
12113       while (node->left != tree->nil)
12114         node = node->left;
12115       /* try to expand the children */
12116       do
12117         {
12118          gboolean t;
12119          t = gtk_tree_view_real_expand_row (tree_view, tmp_path, tree, node,
12120                                             TRUE, animate);
12121          if (t)
12122            retval = TRUE;
12123
12124          gtk_tree_path_next (tmp_path);
12125          node = _gtk_rbtree_next (tree, node);
12126        }
12127       while (node != NULL);
12128
12129       gtk_tree_path_free (tmp_path);
12130
12131       return retval;
12132     }
12133
12134   g_signal_emit (tree_view, tree_view_signals[TEST_EXPAND_ROW], 0, &iter, path, &expand);
12135
12136   if (!gtk_tree_model_iter_has_child (tree_view->priv->model, &iter))
12137     return FALSE;
12138
12139   if (expand)
12140     return FALSE;
12141
12142   node->children = _gtk_rbtree_new ();
12143   node->children->parent_tree = tree;
12144   node->children->parent_node = node;
12145
12146   gtk_tree_model_iter_children (tree_view->priv->model, &temp, &iter);
12147
12148   gtk_tree_view_build_tree (tree_view,
12149                             node->children,
12150                             &temp,
12151                             gtk_tree_path_get_depth (path) + 1,
12152                             open_all);
12153
12154   remove_expand_collapse_timeout (tree_view);
12155
12156   if (animate)
12157     add_expand_collapse_timeout (tree_view, tree, node, TRUE);
12158
12159   install_presize_handler (tree_view);
12160
12161   g_signal_emit (tree_view, tree_view_signals[ROW_EXPANDED], 0, &iter, path);
12162   if (open_all && node->children)
12163     {
12164       _gtk_rbtree_traverse (node->children,
12165                             node->children->root,
12166                             G_PRE_ORDER,
12167                             gtk_tree_view_expand_all_emission_helper,
12168                             tree_view);
12169     }
12170   return TRUE;
12171 }
12172
12173
12174 /**
12175  * gtk_tree_view_expand_row:
12176  * @tree_view: a #GtkTreeView
12177  * @path: path to a row
12178  * @open_all: whether to recursively expand, or just expand immediate children
12179  *
12180  * Opens the row so its children are visible.
12181  *
12182  * Return value: %TRUE if the row existed and had children
12183  **/
12184 gboolean
12185 gtk_tree_view_expand_row (GtkTreeView *tree_view,
12186                           GtkTreePath *path,
12187                           gboolean     open_all)
12188 {
12189   GtkRBTree *tree;
12190   GtkRBNode *node;
12191
12192   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
12193   g_return_val_if_fail (tree_view->priv->model != NULL, FALSE);
12194   g_return_val_if_fail (path != NULL, FALSE);
12195
12196   if (_gtk_tree_view_find_node (tree_view,
12197                                 path,
12198                                 &tree,
12199                                 &node))
12200     return FALSE;
12201
12202   if (tree != NULL)
12203     return gtk_tree_view_real_expand_row (tree_view, path, tree, node, open_all, FALSE);
12204   else
12205     return FALSE;
12206 }
12207
12208 static gboolean
12209 gtk_tree_view_real_collapse_row (GtkTreeView *tree_view,
12210                                  GtkTreePath *path,
12211                                  GtkRBTree   *tree,
12212                                  GtkRBNode   *node,
12213                                  gboolean     animate)
12214 {
12215   GtkTreeIter iter;
12216   GtkTreeIter children;
12217   gboolean collapse;
12218   gint x, y;
12219   GList *list;
12220   GdkWindow *child, *parent;
12221
12222   if (animate)
12223     g_object_get (gtk_widget_get_settings (GTK_WIDGET (tree_view)),
12224                   "gtk-enable-animations", &animate,
12225                   NULL);
12226
12227   remove_auto_expand_timeout (tree_view);
12228
12229   if (node->children == NULL)
12230     return FALSE;
12231
12232   gtk_tree_model_get_iter (tree_view->priv->model, &iter, path);
12233
12234   g_signal_emit (tree_view, tree_view_signals[TEST_COLLAPSE_ROW], 0, &iter, path, &collapse);
12235
12236   if (collapse)
12237     return FALSE;
12238
12239   /* if the prelighted node is a child of us, we want to unprelight it.  We have
12240    * a chance to prelight the correct node below */
12241
12242   if (tree_view->priv->prelight_tree)
12243     {
12244       GtkRBTree *parent_tree;
12245       GtkRBNode *parent_node;
12246
12247       parent_tree = tree_view->priv->prelight_tree->parent_tree;
12248       parent_node = tree_view->priv->prelight_tree->parent_node;
12249       while (parent_tree)
12250         {
12251           if (parent_tree == tree && parent_node == node)
12252             {
12253               ensure_unprelighted (tree_view);
12254               break;
12255             }
12256           parent_node = parent_tree->parent_node;
12257           parent_tree = parent_tree->parent_tree;
12258         }
12259     }
12260
12261   TREE_VIEW_INTERNAL_ASSERT (gtk_tree_model_iter_children (tree_view->priv->model, &children, &iter), FALSE);
12262
12263   for (list = tree_view->priv->columns; list; list = list->next)
12264     {
12265       GtkTreeViewColumn *column = list->data;
12266
12267       if (column->visible == FALSE)
12268         continue;
12269       if (gtk_tree_view_column_get_sizing (column) == GTK_TREE_VIEW_COLUMN_AUTOSIZE)
12270         _gtk_tree_view_column_cell_set_dirty (column, TRUE);
12271     }
12272
12273   if (tree_view->priv->destroy_count_func)
12274     {
12275       GtkTreePath *child_path;
12276       gint child_count = 0;
12277       child_path = gtk_tree_path_copy (path);
12278       gtk_tree_path_down (child_path);
12279       if (node->children)
12280         _gtk_rbtree_traverse (node->children, node->children->root, G_POST_ORDER, count_children_helper, &child_count);
12281       tree_view->priv->destroy_count_func (tree_view, child_path, child_count, tree_view->priv->destroy_count_data);
12282       gtk_tree_path_free (child_path);
12283     }
12284
12285   if (gtk_tree_row_reference_valid (tree_view->priv->cursor))
12286     {
12287       GtkTreePath *cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
12288
12289       if (gtk_tree_path_is_ancestor (path, cursor_path))
12290         {
12291           gtk_tree_row_reference_free (tree_view->priv->cursor);
12292           tree_view->priv->cursor = gtk_tree_row_reference_new_proxy (G_OBJECT (tree_view),
12293                                                                       tree_view->priv->model,
12294                                                                       path);
12295         }
12296       gtk_tree_path_free (cursor_path);
12297     }
12298
12299   if (gtk_tree_row_reference_valid (tree_view->priv->anchor))
12300     {
12301       GtkTreePath *anchor_path = gtk_tree_row_reference_get_path (tree_view->priv->anchor);
12302       if (gtk_tree_path_is_ancestor (path, anchor_path))
12303         {
12304           gtk_tree_row_reference_free (tree_view->priv->anchor);
12305           tree_view->priv->anchor = NULL;
12306         }
12307       gtk_tree_path_free (anchor_path);
12308     }
12309
12310   /* Stop a pending double click */
12311   tree_view->priv->last_button_x = -1;
12312   tree_view->priv->last_button_y = -1;
12313
12314   remove_expand_collapse_timeout (tree_view);
12315
12316   if (gtk_tree_view_unref_and_check_selection_tree (tree_view, node->children))
12317     {
12318       _gtk_rbtree_remove (node->children);
12319       g_signal_emit_by_name (tree_view->priv->selection, "changed");
12320     }
12321   else
12322     _gtk_rbtree_remove (node->children);
12323
12324   if (animate)
12325     add_expand_collapse_timeout (tree_view, tree, node, FALSE);
12326
12327   if (gtk_widget_get_mapped (GTK_WIDGET (tree_view)))
12328     {
12329       gtk_widget_queue_resize (GTK_WIDGET (tree_view));
12330     }
12331
12332   g_signal_emit (tree_view, tree_view_signals[ROW_COLLAPSED], 0, &iter, path);
12333
12334   if (gtk_widget_get_mapped (GTK_WIDGET (tree_view)))
12335     {
12336       /* now that we've collapsed all rows, we want to try to set the prelight
12337        * again. To do this, we fake a motion event and send it to ourselves. */
12338
12339       child = tree_view->priv->bin_window;
12340       parent = gdk_window_get_parent (child);
12341
12342       if (gdk_window_get_pointer (parent, &x, &y, NULL) == child)
12343         {
12344           GdkEventMotion event;
12345           gint child_x, child_y;
12346
12347           gdk_window_get_position (child, &child_x, &child_y);
12348
12349           event.window = tree_view->priv->bin_window;
12350           event.x = x - child_x;
12351           event.y = y - child_y;
12352
12353           /* despite the fact this isn't a real event, I'm almost positive it will
12354            * never trigger a drag event.  maybe_drag is the only function that uses
12355            * more than just event.x and event.y. */
12356           gtk_tree_view_motion_bin_window (GTK_WIDGET (tree_view), &event);
12357         }
12358     }
12359
12360   return TRUE;
12361 }
12362
12363 /**
12364  * gtk_tree_view_collapse_row:
12365  * @tree_view: a #GtkTreeView
12366  * @path: path to a row in the @tree_view
12367  *
12368  * Collapses a row (hides its child rows, if they exist).
12369  *
12370  * Return value: %TRUE if the row was collapsed.
12371  **/
12372 gboolean
12373 gtk_tree_view_collapse_row (GtkTreeView *tree_view,
12374                             GtkTreePath *path)
12375 {
12376   GtkRBTree *tree;
12377   GtkRBNode *node;
12378
12379   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
12380   g_return_val_if_fail (tree_view->priv->tree != NULL, FALSE);
12381   g_return_val_if_fail (path != NULL, FALSE);
12382
12383   if (_gtk_tree_view_find_node (tree_view,
12384                                 path,
12385                                 &tree,
12386                                 &node))
12387     return FALSE;
12388
12389   if (tree == NULL || node->children == NULL)
12390     return FALSE;
12391
12392   return gtk_tree_view_real_collapse_row (tree_view, path, tree, node, FALSE);
12393 }
12394
12395 static void
12396 gtk_tree_view_map_expanded_rows_helper (GtkTreeView            *tree_view,
12397                                         GtkRBTree              *tree,
12398                                         GtkTreePath            *path,
12399                                         GtkTreeViewMappingFunc  func,
12400                                         gpointer                user_data)
12401 {
12402   GtkRBNode *node;
12403
12404   if (tree == NULL || tree->root == NULL)
12405     return;
12406
12407   node = tree->root;
12408
12409   while (node && node->left != tree->nil)
12410     node = node->left;
12411
12412   while (node)
12413     {
12414       if (node->children)
12415         {
12416           (* func) (tree_view, path, user_data);
12417           gtk_tree_path_down (path);
12418           gtk_tree_view_map_expanded_rows_helper (tree_view, node->children, path, func, user_data);
12419           gtk_tree_path_up (path);
12420         }
12421       gtk_tree_path_next (path);
12422       node = _gtk_rbtree_next (tree, node);
12423     }
12424 }
12425
12426 /**
12427  * gtk_tree_view_map_expanded_rows:
12428  * @tree_view: A #GtkTreeView
12429  * @func: (scope call): A function to be called
12430  * @data: User data to be passed to the function.
12431  *
12432  * Calls @func on all expanded rows.
12433  **/
12434 void
12435 gtk_tree_view_map_expanded_rows (GtkTreeView            *tree_view,
12436                                  GtkTreeViewMappingFunc  func,
12437                                  gpointer                user_data)
12438 {
12439   GtkTreePath *path;
12440
12441   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
12442   g_return_if_fail (func != NULL);
12443
12444   path = gtk_tree_path_new_first ();
12445
12446   gtk_tree_view_map_expanded_rows_helper (tree_view,
12447                                           tree_view->priv->tree,
12448                                           path, func, user_data);
12449
12450   gtk_tree_path_free (path);
12451 }
12452
12453 /**
12454  * gtk_tree_view_row_expanded:
12455  * @tree_view: A #GtkTreeView.
12456  * @path: A #GtkTreePath to test expansion state.
12457  *
12458  * Returns %TRUE if the node pointed to by @path is expanded in @tree_view.
12459  *
12460  * Return value: %TRUE if #path is expanded.
12461  **/
12462 gboolean
12463 gtk_tree_view_row_expanded (GtkTreeView *tree_view,
12464                             GtkTreePath *path)
12465 {
12466   GtkRBTree *tree;
12467   GtkRBNode *node;
12468
12469   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
12470   g_return_val_if_fail (path != NULL, FALSE);
12471
12472   _gtk_tree_view_find_node (tree_view, path, &tree, &node);
12473
12474   if (node == NULL)
12475     return FALSE;
12476
12477   return (node->children != NULL);
12478 }
12479
12480 /**
12481  * gtk_tree_view_get_reorderable:
12482  * @tree_view: a #GtkTreeView
12483  *
12484  * Retrieves whether the user can reorder the tree via drag-and-drop. See
12485  * gtk_tree_view_set_reorderable().
12486  *
12487  * Return value: %TRUE if the tree can be reordered.
12488  **/
12489 gboolean
12490 gtk_tree_view_get_reorderable (GtkTreeView *tree_view)
12491 {
12492   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
12493
12494   return tree_view->priv->reorderable;
12495 }
12496
12497 /**
12498  * gtk_tree_view_set_reorderable:
12499  * @tree_view: A #GtkTreeView.
12500  * @reorderable: %TRUE, if the tree can be reordered.
12501  *
12502  * This function is a convenience function to allow you to reorder
12503  * models that support the #GtkDragSourceIface and the
12504  * #GtkDragDestIface.  Both #GtkTreeStore and #GtkListStore support
12505  * these.  If @reorderable is %TRUE, then the user can reorder the
12506  * model by dragging and dropping rows. The developer can listen to
12507  * these changes by connecting to the model's row_inserted and
12508  * row_deleted signals. The reordering is implemented by setting up
12509  * the tree view as a drag source and destination. Therefore, drag and
12510  * drop can not be used in a reorderable view for any other purpose.
12511  *
12512  * This function does not give you any degree of control over the order -- any
12513  * reordering is allowed.  If more control is needed, you should probably
12514  * handle drag and drop manually.
12515  **/
12516 void
12517 gtk_tree_view_set_reorderable (GtkTreeView *tree_view,
12518                                gboolean     reorderable)
12519 {
12520   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
12521
12522   reorderable = reorderable != FALSE;
12523
12524   if (tree_view->priv->reorderable == reorderable)
12525     return;
12526
12527   if (reorderable)
12528     {
12529       const GtkTargetEntry row_targets[] = {
12530         { "GTK_TREE_MODEL_ROW", GTK_TARGET_SAME_WIDGET, 0 }
12531       };
12532
12533       gtk_tree_view_enable_model_drag_source (tree_view,
12534                                               GDK_BUTTON1_MASK,
12535                                               row_targets,
12536                                               G_N_ELEMENTS (row_targets),
12537                                               GDK_ACTION_MOVE);
12538       gtk_tree_view_enable_model_drag_dest (tree_view,
12539                                             row_targets,
12540                                             G_N_ELEMENTS (row_targets),
12541                                             GDK_ACTION_MOVE);
12542     }
12543   else
12544     {
12545       gtk_tree_view_unset_rows_drag_source (tree_view);
12546       gtk_tree_view_unset_rows_drag_dest (tree_view);
12547     }
12548
12549   tree_view->priv->reorderable = reorderable;
12550
12551   g_object_notify (G_OBJECT (tree_view), "reorderable");
12552 }
12553
12554 static void
12555 gtk_tree_view_real_set_cursor (GtkTreeView     *tree_view,
12556                                GtkTreePath     *path,
12557                                gboolean         clear_and_select,
12558                                gboolean         clamp_node)
12559 {
12560   GtkRBTree *tree = NULL;
12561   GtkRBNode *node = NULL;
12562
12563   if (gtk_tree_row_reference_valid (tree_view->priv->cursor))
12564     {
12565       GtkTreePath *cursor_path;
12566       cursor_path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
12567       gtk_tree_view_queue_draw_path (tree_view, cursor_path, NULL);
12568       gtk_tree_path_free (cursor_path);
12569     }
12570
12571   gtk_tree_row_reference_free (tree_view->priv->cursor);
12572   tree_view->priv->cursor = NULL;
12573
12574   /* One cannot set the cursor on a separator.   Also, if
12575    * _gtk_tree_view_find_node returns TRUE, it ran out of tree
12576    * before finding the tree and node belonging to path.  The
12577    * path maps to a non-existing path and we will silently bail out.
12578    * We unset tree and node to avoid further processing.
12579    */
12580   if (!row_is_separator (tree_view, NULL, path)
12581       && _gtk_tree_view_find_node (tree_view, path, &tree, &node) == FALSE)
12582     {
12583       tree_view->priv->cursor =
12584           gtk_tree_row_reference_new_proxy (G_OBJECT (tree_view),
12585                                             tree_view->priv->model,
12586                                             path);
12587     }
12588   else
12589     {
12590       tree = NULL;
12591       node = NULL;
12592     }
12593
12594   if (tree != NULL)
12595     {
12596       GtkRBTree *new_tree = NULL;
12597       GtkRBNode *new_node = NULL;
12598
12599       if (clear_and_select && !tree_view->priv->ctrl_pressed)
12600         {
12601           GtkTreeSelectMode mode = 0;
12602
12603           if (tree_view->priv->ctrl_pressed)
12604             mode |= GTK_TREE_SELECT_MODE_TOGGLE;
12605           if (tree_view->priv->shift_pressed)
12606             mode |= GTK_TREE_SELECT_MODE_EXTEND;
12607
12608           _gtk_tree_selection_internal_select_node (tree_view->priv->selection,
12609                                                     node, tree, path, mode,
12610                                                     FALSE);
12611         }
12612
12613       /* We have to re-find tree and node here again, somebody might have
12614        * cleared the node or the whole tree in the GtkTreeSelection::changed
12615        * callback. If the nodes differ we bail out here.
12616        */
12617       _gtk_tree_view_find_node (tree_view, path, &new_tree, &new_node);
12618
12619       if (tree != new_tree || node != new_node)
12620         return;
12621
12622       if (clamp_node)
12623         {
12624           gtk_tree_view_clamp_node_visible (tree_view, tree, node);
12625           _gtk_tree_view_queue_draw_node (tree_view, tree, node, NULL);
12626         }
12627     }
12628
12629   g_signal_emit (tree_view, tree_view_signals[CURSOR_CHANGED], 0);
12630 }
12631
12632 /**
12633  * gtk_tree_view_get_cursor:
12634  * @tree_view: A #GtkTreeView
12635  * @path: (out) (allow-none): A pointer to be filled with the current cursor path, or %NULL
12636  * @focus_column: (out) (allow-none): A pointer to be filled with the current focus column, or %NULL
12637  *
12638  * Fills in @path and @focus_column with the current path and focus column.  If
12639  * the cursor isn't currently set, then *@path will be %NULL.  If no column
12640  * currently has focus, then *@focus_column will be %NULL.
12641  *
12642  * The returned #GtkTreePath must be freed with gtk_tree_path_free() when
12643  * you are done with it.
12644  **/
12645 void
12646 gtk_tree_view_get_cursor (GtkTreeView        *tree_view,
12647                           GtkTreePath       **path,
12648                           GtkTreeViewColumn **focus_column)
12649 {
12650   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
12651
12652   if (path)
12653     {
12654       if (gtk_tree_row_reference_valid (tree_view->priv->cursor))
12655         *path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
12656       else
12657         *path = NULL;
12658     }
12659
12660   if (focus_column)
12661     {
12662       *focus_column = tree_view->priv->focus_column;
12663     }
12664 }
12665
12666 /**
12667  * gtk_tree_view_set_cursor:
12668  * @tree_view: A #GtkTreeView
12669  * @path: A #GtkTreePath
12670  * @focus_column: (allow-none): A #GtkTreeViewColumn, or %NULL
12671  * @start_editing: %TRUE if the specified cell should start being edited.
12672  *
12673  * Sets the current keyboard focus to be at @path, and selects it.  This is
12674  * useful when you want to focus the user's attention on a particular row.  If
12675  * @focus_column is not %NULL, then focus is given to the column specified by
12676  * it. Additionally, if @focus_column is specified, and @start_editing is
12677  * %TRUE, then editing should be started in the specified cell.
12678  * This function is often followed by @gtk_widget_grab_focus (@tree_view)
12679  * in order to give keyboard focus to the widget.  Please note that editing
12680  * can only happen when the widget is realized.
12681  *
12682  * If @path is invalid for @model, the current cursor (if any) will be unset
12683  * and the function will return without failing.
12684  **/
12685 void
12686 gtk_tree_view_set_cursor (GtkTreeView       *tree_view,
12687                           GtkTreePath       *path,
12688                           GtkTreeViewColumn *focus_column,
12689                           gboolean           start_editing)
12690 {
12691   gtk_tree_view_set_cursor_on_cell (tree_view, path, focus_column,
12692                                     NULL, start_editing);
12693 }
12694
12695 /**
12696  * gtk_tree_view_set_cursor_on_cell:
12697  * @tree_view: A #GtkTreeView
12698  * @path: A #GtkTreePath
12699  * @focus_column: (allow-none): A #GtkTreeViewColumn, or %NULL
12700  * @focus_cell: (allow-none): A #GtkCellRenderer, or %NULL
12701  * @start_editing: %TRUE if the specified cell should start being edited.
12702  *
12703  * Sets the current keyboard focus to be at @path, and selects it.  This is
12704  * useful when you want to focus the user's attention on a particular row.  If
12705  * @focus_column is not %NULL, then focus is given to the column specified by
12706  * it. If @focus_column and @focus_cell are not %NULL, and @focus_column
12707  * contains 2 or more editable or activatable cells, then focus is given to
12708  * the cell specified by @focus_cell. Additionally, if @focus_column is
12709  * specified, and @start_editing is %TRUE, then editing should be started in
12710  * the specified cell.  This function is often followed by
12711  * @gtk_widget_grab_focus (@tree_view) in order to give keyboard focus to the
12712  * widget.  Please note that editing can only happen when the widget is
12713  * realized.
12714  *
12715  * If @path is invalid for @model, the current cursor (if any) will be unset
12716  * and the function will return without failing.
12717  *
12718  * Since: 2.2
12719  **/
12720 void
12721 gtk_tree_view_set_cursor_on_cell (GtkTreeView       *tree_view,
12722                                   GtkTreePath       *path,
12723                                   GtkTreeViewColumn *focus_column,
12724                                   GtkCellRenderer   *focus_cell,
12725                                   gboolean           start_editing)
12726 {
12727   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
12728   g_return_if_fail (path != NULL);
12729   g_return_if_fail (focus_column == NULL || GTK_IS_TREE_VIEW_COLUMN (focus_column));
12730
12731   if (!tree_view->priv->model)
12732     return;
12733
12734   if (focus_cell)
12735     {
12736       g_return_if_fail (focus_column);
12737       g_return_if_fail (GTK_IS_CELL_RENDERER (focus_cell));
12738     }
12739
12740   /* cancel the current editing, if it exists */
12741   if (tree_view->priv->edited_column &&
12742       tree_view->priv->edited_column->editable_widget)
12743     gtk_tree_view_stop_editing (tree_view, TRUE);
12744
12745   gtk_tree_view_real_set_cursor (tree_view, path, TRUE, TRUE);
12746
12747   if (focus_column && focus_column->visible)
12748     {
12749       GList *list;
12750       gboolean column_in_tree = FALSE;
12751
12752       for (list = tree_view->priv->columns; list; list = list->next)
12753         if (list->data == focus_column)
12754           {
12755             column_in_tree = TRUE;
12756             break;
12757           }
12758       g_return_if_fail (column_in_tree);
12759       tree_view->priv->focus_column = focus_column;
12760       if (focus_cell)
12761         gtk_tree_view_column_focus_cell (focus_column, focus_cell);
12762       if (start_editing)
12763         gtk_tree_view_start_editing (tree_view, path);
12764     }
12765 }
12766
12767 /**
12768  * gtk_tree_view_get_bin_window:
12769  * @tree_view: A #GtkTreeView
12770  *
12771  * Returns the window that @tree_view renders to.
12772  * This is used primarily to compare to <literal>event->window</literal>
12773  * to confirm that the event on @tree_view is on the right window.
12774  *
12775  * Return value: (transfer none): A #GdkWindow, or %NULL when @tree_view
12776  *     hasn't been realized yet
12777  **/
12778 GdkWindow *
12779 gtk_tree_view_get_bin_window (GtkTreeView *tree_view)
12780 {
12781   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
12782
12783   return tree_view->priv->bin_window;
12784 }
12785
12786 /**
12787  * gtk_tree_view_get_path_at_pos:
12788  * @tree_view: A #GtkTreeView.
12789  * @x: The x position to be identified (relative to bin_window).
12790  * @y: The y position to be identified (relative to bin_window).
12791  * @path: (out) (allow-none): A pointer to a #GtkTreePath pointer to be filled in, or %NULL
12792  * @column: (out) (allow-none): A pointer to a #GtkTreeViewColumn pointer to be filled in, or %NULL
12793  * @cell_x: (out) (allow-none): A pointer where the X coordinate relative to the cell can be placed, or %NULL
12794  * @cell_y: (out) (allow-none): A pointer where the Y coordinate relative to the cell can be placed, or %NULL
12795  *
12796  * Finds the path at the point (@x, @y), relative to bin_window coordinates
12797  * (please see gtk_tree_view_get_bin_window()).
12798  * That is, @x and @y are relative to an events coordinates. @x and @y must
12799  * come from an event on the @tree_view only where <literal>event->window ==
12800  * gtk_tree_view_get_bin_window (<!-- -->)</literal>. It is primarily for
12801  * things like popup menus. If @path is non-%NULL, then it will be filled
12802  * with the #GtkTreePath at that point.  This path should be freed with
12803  * gtk_tree_path_free().  If @column is non-%NULL, then it will be filled
12804  * with the column at that point.  @cell_x and @cell_y return the coordinates
12805  * relative to the cell background (i.e. the @background_area passed to
12806  * gtk_cell_renderer_render()).  This function is only meaningful if
12807  * @tree_view is realized.  Therefore this function will always return %FALSE
12808  * if @tree_view is not realized or does not have a model.
12809  *
12810  * For converting widget coordinates (eg. the ones you get from
12811  * GtkWidget::query-tooltip), please see
12812  * gtk_tree_view_convert_widget_to_bin_window_coords().
12813  *
12814  * Return value: %TRUE if a row exists at that coordinate.
12815  **/
12816 gboolean
12817 gtk_tree_view_get_path_at_pos (GtkTreeView        *tree_view,
12818                                gint                x,
12819                                gint                y,
12820                                GtkTreePath       **path,
12821                                GtkTreeViewColumn **column,
12822                                gint               *cell_x,
12823                                gint               *cell_y)
12824 {
12825   GtkRBTree *tree;
12826   GtkRBNode *node;
12827   gint y_offset;
12828
12829   g_return_val_if_fail (tree_view != NULL, FALSE);
12830
12831   if (path)
12832     *path = NULL;
12833   if (column)
12834     *column = NULL;
12835
12836   if (tree_view->priv->bin_window == NULL)
12837     return FALSE;
12838
12839   if (tree_view->priv->tree == NULL)
12840     return FALSE;
12841
12842   if (x > tree_view->priv->hadjustment->upper)
12843     return FALSE;
12844
12845   if (x < 0 || y < 0)
12846     return FALSE;
12847
12848   if (column || cell_x)
12849     {
12850       GtkTreeViewColumn *tmp_column;
12851       GtkTreeViewColumn *last_column = NULL;
12852       GList *list;
12853       gint remaining_x = x;
12854       gboolean found = FALSE;
12855       gboolean rtl;
12856
12857       rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
12858       for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns));
12859            list;
12860            list = (rtl ? list->prev : list->next))
12861         {
12862           tmp_column = list->data;
12863
12864           if (tmp_column->visible == FALSE)
12865             continue;
12866
12867           last_column = tmp_column;
12868           if (remaining_x <= tmp_column->width)
12869             {
12870               found = TRUE;
12871
12872               if (column)
12873                 *column = tmp_column;
12874
12875               if (cell_x)
12876                 *cell_x = remaining_x;
12877
12878               break;
12879             }
12880           remaining_x -= tmp_column->width;
12881         }
12882
12883       /* If found is FALSE and there is a last_column, then it the remainder
12884        * space is in that area
12885        */
12886       if (!found)
12887         {
12888           if (last_column)
12889             {
12890               if (column)
12891                 *column = last_column;
12892
12893               if (cell_x)
12894                 *cell_x = last_column->width + remaining_x;
12895             }
12896           else
12897             {
12898               return FALSE;
12899             }
12900         }
12901     }
12902
12903   y_offset = _gtk_rbtree_find_offset (tree_view->priv->tree,
12904                                       TREE_WINDOW_Y_TO_RBTREE_Y (tree_view, y),
12905                                       &tree, &node);
12906
12907   if (tree == NULL)
12908     return FALSE;
12909
12910   if (cell_y)
12911     *cell_y = y_offset;
12912
12913   if (path)
12914     *path = _gtk_tree_view_find_path (tree_view, tree, node);
12915
12916   return TRUE;
12917 }
12918
12919
12920 /**
12921  * gtk_tree_view_get_cell_area:
12922  * @tree_view: a #GtkTreeView
12923  * @path: (allow-none): a #GtkTreePath for the row, or %NULL to get only horizontal coordinates
12924  * @column: (allow-none): a #GtkTreeViewColumn for the column, or %NULL to get only vertical coordinates
12925  * @rect: rectangle to fill with cell rect
12926  *
12927  * Fills the bounding rectangle in bin_window coordinates for the cell at the
12928  * row specified by @path and the column specified by @column.  If @path is
12929  * %NULL, or points to a path not currently displayed, the @y and @height fields
12930  * of the rectangle will be filled with 0. If @column is %NULL, the @x and @width
12931  * fields will be filled with 0.  The sum of all cell rects does not cover the
12932  * entire tree; there are extra pixels in between rows, for example. The
12933  * returned rectangle is equivalent to the @cell_area passed to
12934  * gtk_cell_renderer_render().  This function is only valid if @tree_view is
12935  * realized.
12936  **/
12937 void
12938 gtk_tree_view_get_cell_area (GtkTreeView        *tree_view,
12939                              GtkTreePath        *path,
12940                              GtkTreeViewColumn  *column,
12941                              GdkRectangle       *rect)
12942 {
12943   GtkAllocation allocation;
12944   GtkRBTree *tree = NULL;
12945   GtkRBNode *node = NULL;
12946   gint vertical_separator;
12947   gint horizontal_separator;
12948
12949   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
12950   g_return_if_fail (column == NULL || GTK_IS_TREE_VIEW_COLUMN (column));
12951   g_return_if_fail (rect != NULL);
12952   g_return_if_fail (!column || column->tree_view == (GtkWidget *) tree_view);
12953   g_return_if_fail (gtk_widget_get_realized (GTK_WIDGET (tree_view)));
12954
12955   gtk_widget_style_get (GTK_WIDGET (tree_view),
12956                         "vertical-separator", &vertical_separator,
12957                         "horizontal-separator", &horizontal_separator,
12958                         NULL);
12959
12960   rect->x = 0;
12961   rect->y = 0;
12962   rect->width = 0;
12963   rect->height = 0;
12964
12965   if (column)
12966     {
12967       gtk_widget_get_allocation (column->button, &allocation);
12968       rect->x = allocation.x + horizontal_separator/2;
12969       rect->width = allocation.width - horizontal_separator;
12970     }
12971
12972   if (path)
12973     {
12974       gboolean ret = _gtk_tree_view_find_node (tree_view, path, &tree, &node);
12975
12976       /* Get vertical coords */
12977       if ((!ret && tree == NULL) || ret)
12978         return;
12979
12980       rect->y = CELL_FIRST_PIXEL (tree_view, tree, node, vertical_separator);
12981       rect->height = MAX (CELL_HEIGHT (node, vertical_separator), tree_view->priv->expander_size - vertical_separator);
12982
12983       if (column &&
12984           gtk_tree_view_is_expander_column (tree_view, column))
12985         {
12986           gint depth = gtk_tree_path_get_depth (path);
12987           gboolean rtl;
12988
12989           rtl = gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL;
12990
12991           if (!rtl)
12992             rect->x += (depth - 1) * tree_view->priv->level_indentation;
12993           rect->width -= (depth - 1) * tree_view->priv->level_indentation;
12994
12995           if (TREE_VIEW_DRAW_EXPANDERS (tree_view))
12996             {
12997               if (!rtl)
12998                 rect->x += depth * tree_view->priv->expander_size;
12999               rect->width -= depth * tree_view->priv->expander_size;
13000             }
13001
13002           rect->width = MAX (rect->width, 0);
13003         }
13004     }
13005 }
13006
13007 /**
13008  * gtk_tree_view_get_background_area:
13009  * @tree_view: a #GtkTreeView
13010  * @path: (allow-none): a #GtkTreePath for the row, or %NULL to get only horizontal coordinates
13011  * @column: (allow-none): a #GtkTreeViewColumn for the column, or %NULL to get only vertical coordiantes
13012  * @rect: rectangle to fill with cell background rect
13013  *
13014  * Fills the bounding rectangle in bin_window coordinates for the cell at the
13015  * row specified by @path and the column specified by @column.  If @path is
13016  * %NULL, or points to a node not found in the tree, the @y and @height fields of
13017  * the rectangle will be filled with 0. If @column is %NULL, the @x and @width
13018  * fields will be filled with 0.  The returned rectangle is equivalent to the
13019  * @background_area passed to gtk_cell_renderer_render().  These background
13020  * areas tile to cover the entire bin window.  Contrast with the @cell_area,
13021  * returned by gtk_tree_view_get_cell_area(), which returns only the cell
13022  * itself, excluding surrounding borders and the tree expander area.
13023  *
13024  **/
13025 void
13026 gtk_tree_view_get_background_area (GtkTreeView        *tree_view,
13027                                    GtkTreePath        *path,
13028                                    GtkTreeViewColumn  *column,
13029                                    GdkRectangle       *rect)
13030 {
13031   GtkRBTree *tree = NULL;
13032   GtkRBNode *node = NULL;
13033
13034   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13035   g_return_if_fail (column == NULL || GTK_IS_TREE_VIEW_COLUMN (column));
13036   g_return_if_fail (rect != NULL);
13037
13038   rect->x = 0;
13039   rect->y = 0;
13040   rect->width = 0;
13041   rect->height = 0;
13042
13043   if (path)
13044     {
13045       /* Get vertical coords */
13046
13047       if (!_gtk_tree_view_find_node (tree_view, path, &tree, &node) &&
13048           tree == NULL)
13049         return;
13050
13051       rect->y = BACKGROUND_FIRST_PIXEL (tree_view, tree, node);
13052
13053       rect->height = ROW_HEIGHT (tree_view, BACKGROUND_HEIGHT (node));
13054     }
13055
13056   if (column)
13057     {
13058       gint x2 = 0;
13059
13060       gtk_tree_view_get_background_xrange (tree_view, tree, column, &rect->x, &x2);
13061       rect->width = x2 - rect->x;
13062     }
13063 }
13064
13065 /**
13066  * gtk_tree_view_get_visible_rect:
13067  * @tree_view: a #GtkTreeView
13068  * @visible_rect: rectangle to fill
13069  *
13070  * Fills @visible_rect with the currently-visible region of the
13071  * buffer, in tree coordinates. Convert to bin_window coordinates with
13072  * gtk_tree_view_convert_tree_to_bin_window_coords().
13073  * Tree coordinates start at 0,0 for row 0 of the tree, and cover the entire
13074  * scrollable area of the tree.
13075  **/
13076 void
13077 gtk_tree_view_get_visible_rect (GtkTreeView  *tree_view,
13078                                 GdkRectangle *visible_rect)
13079 {
13080   GtkAllocation allocation;
13081   GtkWidget *widget;
13082
13083   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13084
13085   widget = GTK_WIDGET (tree_view);
13086
13087   if (visible_rect)
13088     {
13089       gtk_widget_get_allocation (widget, &allocation);
13090       visible_rect->x = tree_view->priv->hadjustment->value;
13091       visible_rect->y = tree_view->priv->vadjustment->value;
13092       visible_rect->width = allocation.width;
13093       visible_rect->height = allocation.height - TREE_VIEW_HEADER_HEIGHT (tree_view);
13094     }
13095 }
13096
13097 /**
13098  * gtk_tree_view_convert_widget_to_tree_coords:
13099  * @tree_view: a #GtkTreeView
13100  * @wx: X coordinate relative to the widget
13101  * @wy: Y coordinate relative to the widget
13102  * @tx: return location for tree X coordinate
13103  * @ty: return location for tree Y coordinate
13104  *
13105  * Converts widget coordinates to coordinates for the
13106  * tree (the full scrollable area of the tree).
13107  *
13108  * Since: 2.12
13109  **/
13110 void
13111 gtk_tree_view_convert_widget_to_tree_coords (GtkTreeView *tree_view,
13112                                              gint         wx,
13113                                              gint         wy,
13114                                              gint        *tx,
13115                                              gint        *ty)
13116 {
13117   gint x, y;
13118
13119   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13120
13121   gtk_tree_view_convert_widget_to_bin_window_coords (tree_view,
13122                                                      wx, wy,
13123                                                      &x, &y);
13124   gtk_tree_view_convert_bin_window_to_tree_coords (tree_view,
13125                                                    x, y,
13126                                                    tx, ty);
13127 }
13128
13129 /**
13130  * gtk_tree_view_convert_tree_to_widget_coords:
13131  * @tree_view: a #GtkTreeView
13132  * @tx: X coordinate relative to the tree
13133  * @ty: Y coordinate relative to the tree
13134  * @wx: return location for widget X coordinate
13135  * @wy: return location for widget Y coordinate
13136  *
13137  * Converts tree coordinates (coordinates in full scrollable area of the tree)
13138  * to widget coordinates.
13139  *
13140  * Since: 2.12
13141  **/
13142 void
13143 gtk_tree_view_convert_tree_to_widget_coords (GtkTreeView *tree_view,
13144                                              gint         tx,
13145                                              gint         ty,
13146                                              gint        *wx,
13147                                              gint        *wy)
13148 {
13149   gint x, y;
13150
13151   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13152
13153   gtk_tree_view_convert_tree_to_bin_window_coords (tree_view,
13154                                                    tx, ty,
13155                                                    &x, &y);
13156   gtk_tree_view_convert_bin_window_to_widget_coords (tree_view,
13157                                                      x, y,
13158                                                      wx, wy);
13159 }
13160
13161 /**
13162  * gtk_tree_view_convert_widget_to_bin_window_coords:
13163  * @tree_view: a #GtkTreeView
13164  * @wx: X coordinate relative to the widget
13165  * @wy: Y coordinate relative to the widget
13166  * @bx: return location for bin_window X coordinate
13167  * @by: return location for bin_window Y coordinate
13168  *
13169  * Converts widget coordinates to coordinates for the bin_window
13170  * (see gtk_tree_view_get_bin_window()).
13171  *
13172  * Since: 2.12
13173  **/
13174 void
13175 gtk_tree_view_convert_widget_to_bin_window_coords (GtkTreeView *tree_view,
13176                                                    gint         wx,
13177                                                    gint         wy,
13178                                                    gint        *bx,
13179                                                    gint        *by)
13180 {
13181   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13182
13183   if (bx)
13184     *bx = wx + tree_view->priv->hadjustment->value;
13185   if (by)
13186     *by = wy - TREE_VIEW_HEADER_HEIGHT (tree_view);
13187 }
13188
13189 /**
13190  * gtk_tree_view_convert_bin_window_to_widget_coords:
13191  * @tree_view: a #GtkTreeView
13192  * @bx: bin_window X coordinate
13193  * @by: bin_window Y coordinate
13194  * @wx: return location for widget X coordinate
13195  * @wy: return location for widget Y coordinate
13196  *
13197  * Converts bin_window coordinates (see gtk_tree_view_get_bin_window())
13198  * to widget relative coordinates.
13199  *
13200  * Since: 2.12
13201  **/
13202 void
13203 gtk_tree_view_convert_bin_window_to_widget_coords (GtkTreeView *tree_view,
13204                                                    gint         bx,
13205                                                    gint         by,
13206                                                    gint        *wx,
13207                                                    gint        *wy)
13208 {
13209   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13210
13211   if (wx)
13212     *wx = bx - tree_view->priv->hadjustment->value;
13213   if (wy)
13214     *wy = by + TREE_VIEW_HEADER_HEIGHT (tree_view);
13215 }
13216
13217 /**
13218  * gtk_tree_view_convert_tree_to_bin_window_coords:
13219  * @tree_view: a #GtkTreeView
13220  * @tx: tree X coordinate
13221  * @ty: tree Y coordinate
13222  * @bx: return location for X coordinate relative to bin_window
13223  * @by: return location for Y coordinate relative to bin_window
13224  *
13225  * Converts tree coordinates (coordinates in full scrollable area of the tree)
13226  * to bin_window coordinates.
13227  *
13228  * Since: 2.12
13229  **/
13230 void
13231 gtk_tree_view_convert_tree_to_bin_window_coords (GtkTreeView *tree_view,
13232                                                  gint         tx,
13233                                                  gint         ty,
13234                                                  gint        *bx,
13235                                                  gint        *by)
13236 {
13237   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13238
13239   if (bx)
13240     *bx = tx;
13241   if (by)
13242     *by = ty - tree_view->priv->dy;
13243 }
13244
13245 /**
13246  * gtk_tree_view_convert_bin_window_to_tree_coords:
13247  * @tree_view: a #GtkTreeView
13248  * @bx: X coordinate relative to bin_window
13249  * @by: Y coordinate relative to bin_window
13250  * @tx: return location for tree X coordinate
13251  * @ty: return location for tree Y coordinate
13252  *
13253  * Converts bin_window coordinates to coordinates for the
13254  * tree (the full scrollable area of the tree).
13255  *
13256  * Since: 2.12
13257  **/
13258 void
13259 gtk_tree_view_convert_bin_window_to_tree_coords (GtkTreeView *tree_view,
13260                                                  gint         bx,
13261                                                  gint         by,
13262                                                  gint        *tx,
13263                                                  gint        *ty)
13264 {
13265   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13266
13267   if (tx)
13268     *tx = bx;
13269   if (ty)
13270     *ty = by + tree_view->priv->dy;
13271 }
13272
13273
13274
13275 /**
13276  * gtk_tree_view_get_visible_range:
13277  * @tree_view: A #GtkTreeView
13278  * @start_path: (allow-none): Return location for start of region, or %NULL.
13279  * @end_path: (allow-none): Return location for end of region, or %NULL.
13280  *
13281  * Sets @start_path and @end_path to be the first and last visible path.
13282  * Note that there may be invisible paths in between.
13283  *
13284  * The paths should be freed with gtk_tree_path_free() after use.
13285  *
13286  * Returns: %TRUE, if valid paths were placed in @start_path and @end_path.
13287  *
13288  * Since: 2.8
13289  **/
13290 gboolean
13291 gtk_tree_view_get_visible_range (GtkTreeView  *tree_view,
13292                                  GtkTreePath **start_path,
13293                                  GtkTreePath **end_path)
13294 {
13295   GtkRBTree *tree;
13296   GtkRBNode *node;
13297   gboolean retval;
13298
13299   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
13300
13301   if (!tree_view->priv->tree)
13302     return FALSE;
13303
13304   retval = TRUE;
13305
13306   if (start_path)
13307     {
13308       _gtk_rbtree_find_offset (tree_view->priv->tree,
13309                                TREE_WINDOW_Y_TO_RBTREE_Y (tree_view, 0),
13310                                &tree, &node);
13311       if (node)
13312         *start_path = _gtk_tree_view_find_path (tree_view, tree, node);
13313       else
13314         retval = FALSE;
13315     }
13316
13317   if (end_path)
13318     {
13319       gint y;
13320
13321       if (tree_view->priv->height < tree_view->priv->vadjustment->page_size)
13322         y = tree_view->priv->height - 1;
13323       else
13324         y = TREE_WINDOW_Y_TO_RBTREE_Y (tree_view, tree_view->priv->vadjustment->page_size) - 1;
13325
13326       _gtk_rbtree_find_offset (tree_view->priv->tree, y, &tree, &node);
13327       if (node)
13328         *end_path = _gtk_tree_view_find_path (tree_view, tree, node);
13329       else
13330         retval = FALSE;
13331     }
13332
13333   return retval;
13334 }
13335
13336 static void
13337 unset_reorderable (GtkTreeView *tree_view)
13338 {
13339   if (tree_view->priv->reorderable)
13340     {
13341       tree_view->priv->reorderable = FALSE;
13342       g_object_notify (G_OBJECT (tree_view), "reorderable");
13343     }
13344 }
13345
13346 /**
13347  * gtk_tree_view_enable_model_drag_source:
13348  * @tree_view: a #GtkTreeView
13349  * @start_button_mask: Mask of allowed buttons to start drag
13350  * @targets: the table of targets that the drag will support
13351  * @n_targets: the number of items in @targets
13352  * @actions: the bitmask of possible actions for a drag from this
13353  *    widget
13354  *
13355  * Turns @tree_view into a drag source for automatic DND. Calling this
13356  * method sets #GtkTreeView:reorderable to %FALSE.
13357  **/
13358 void
13359 gtk_tree_view_enable_model_drag_source (GtkTreeView              *tree_view,
13360                                         GdkModifierType           start_button_mask,
13361                                         const GtkTargetEntry     *targets,
13362                                         gint                      n_targets,
13363                                         GdkDragAction             actions)
13364 {
13365   TreeViewDragInfo *di;
13366
13367   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13368
13369   gtk_drag_source_set (GTK_WIDGET (tree_view),
13370                        0,
13371                        targets,
13372                        n_targets,
13373                        actions);
13374
13375   di = ensure_info (tree_view);
13376
13377   di->start_button_mask = start_button_mask;
13378   di->source_actions = actions;
13379   di->source_set = TRUE;
13380
13381   unset_reorderable (tree_view);
13382 }
13383
13384 /**
13385  * gtk_tree_view_enable_model_drag_dest:
13386  * @tree_view: a #GtkTreeView
13387  * @targets: the table of targets that the drag will support
13388  * @n_targets: the number of items in @targets
13389  * @actions: the bitmask of possible actions for a drag from this
13390  *    widget
13391  *
13392  * Turns @tree_view into a drop destination for automatic DND. Calling
13393  * this method sets #GtkTreeView:reorderable to %FALSE.
13394  **/
13395 void
13396 gtk_tree_view_enable_model_drag_dest (GtkTreeView              *tree_view,
13397                                       const GtkTargetEntry     *targets,
13398                                       gint                      n_targets,
13399                                       GdkDragAction             actions)
13400 {
13401   TreeViewDragInfo *di;
13402
13403   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13404
13405   gtk_drag_dest_set (GTK_WIDGET (tree_view),
13406                      0,
13407                      targets,
13408                      n_targets,
13409                      actions);
13410
13411   di = ensure_info (tree_view);
13412   di->dest_set = TRUE;
13413
13414   unset_reorderable (tree_view);
13415 }
13416
13417 /**
13418  * gtk_tree_view_unset_rows_drag_source:
13419  * @tree_view: a #GtkTreeView
13420  *
13421  * Undoes the effect of
13422  * gtk_tree_view_enable_model_drag_source(). Calling this method sets
13423  * #GtkTreeView:reorderable to %FALSE.
13424  **/
13425 void
13426 gtk_tree_view_unset_rows_drag_source (GtkTreeView *tree_view)
13427 {
13428   TreeViewDragInfo *di;
13429
13430   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13431
13432   di = get_info (tree_view);
13433
13434   if (di)
13435     {
13436       if (di->source_set)
13437         {
13438           gtk_drag_source_unset (GTK_WIDGET (tree_view));
13439           di->source_set = FALSE;
13440         }
13441
13442       if (!di->dest_set && !di->source_set)
13443         remove_info (tree_view);
13444     }
13445
13446   unset_reorderable (tree_view);
13447 }
13448
13449 /**
13450  * gtk_tree_view_unset_rows_drag_dest:
13451  * @tree_view: a #GtkTreeView
13452  *
13453  * Undoes the effect of
13454  * gtk_tree_view_enable_model_drag_dest(). Calling this method sets
13455  * #GtkTreeView:reorderable to %FALSE.
13456  **/
13457 void
13458 gtk_tree_view_unset_rows_drag_dest (GtkTreeView *tree_view)
13459 {
13460   TreeViewDragInfo *di;
13461
13462   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13463
13464   di = get_info (tree_view);
13465
13466   if (di)
13467     {
13468       if (di->dest_set)
13469         {
13470           gtk_drag_dest_unset (GTK_WIDGET (tree_view));
13471           di->dest_set = FALSE;
13472         }
13473
13474       if (!di->dest_set && !di->source_set)
13475         remove_info (tree_view);
13476     }
13477
13478   unset_reorderable (tree_view);
13479 }
13480
13481 /**
13482  * gtk_tree_view_set_drag_dest_row:
13483  * @tree_view: a #GtkTreeView
13484  * @path: (allow-none): The path of the row to highlight, or %NULL.
13485  * @pos: Specifies whether to drop before, after or into the row
13486  *
13487  * Sets the row that is highlighted for feedback.
13488  **/
13489 void
13490 gtk_tree_view_set_drag_dest_row (GtkTreeView            *tree_view,
13491                                  GtkTreePath            *path,
13492                                  GtkTreeViewDropPosition pos)
13493 {
13494   GtkTreePath *current_dest;
13495
13496   /* Note; this function is exported to allow a custom DND
13497    * implementation, so it can't touch TreeViewDragInfo
13498    */
13499
13500   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13501
13502   current_dest = NULL;
13503
13504   if (tree_view->priv->drag_dest_row)
13505     {
13506       current_dest = gtk_tree_row_reference_get_path (tree_view->priv->drag_dest_row);
13507       gtk_tree_row_reference_free (tree_view->priv->drag_dest_row);
13508     }
13509
13510   /* special case a drop on an empty model */
13511   tree_view->priv->empty_view_drop = 0;
13512
13513   if (pos == GTK_TREE_VIEW_DROP_BEFORE && path
13514       && gtk_tree_path_get_depth (path) == 1
13515       && gtk_tree_path_get_indices (path)[0] == 0)
13516     {
13517       gint n_children;
13518
13519       n_children = gtk_tree_model_iter_n_children (tree_view->priv->model,
13520                                                    NULL);
13521
13522       if (!n_children)
13523         tree_view->priv->empty_view_drop = 1;
13524     }
13525
13526   tree_view->priv->drag_dest_pos = pos;
13527
13528   if (path)
13529     {
13530       tree_view->priv->drag_dest_row =
13531         gtk_tree_row_reference_new_proxy (G_OBJECT (tree_view), tree_view->priv->model, path);
13532       gtk_tree_view_queue_draw_path (tree_view, path, NULL);
13533     }
13534   else
13535     tree_view->priv->drag_dest_row = NULL;
13536
13537   if (current_dest)
13538     {
13539       GtkRBTree *tree, *new_tree;
13540       GtkRBNode *node, *new_node;
13541
13542       _gtk_tree_view_find_node (tree_view, current_dest, &tree, &node);
13543       _gtk_tree_view_queue_draw_node (tree_view, tree, node, NULL);
13544
13545       if (tree && node)
13546         {
13547           _gtk_rbtree_next_full (tree, node, &new_tree, &new_node);
13548           if (new_tree && new_node)
13549             _gtk_tree_view_queue_draw_node (tree_view, new_tree, new_node, NULL);
13550
13551           _gtk_rbtree_prev_full (tree, node, &new_tree, &new_node);
13552           if (new_tree && new_node)
13553             _gtk_tree_view_queue_draw_node (tree_view, new_tree, new_node, NULL);
13554         }
13555       gtk_tree_path_free (current_dest);
13556     }
13557 }
13558
13559 /**
13560  * gtk_tree_view_get_drag_dest_row:
13561  * @tree_view: a #GtkTreeView
13562  * @path: (out) (allow-none): Return location for the path of the highlighted row, or %NULL.
13563  * @pos: (out) (allow-none): Return location for the drop position, or %NULL
13564  *
13565  * Gets information about the row that is highlighted for feedback.
13566  **/
13567 void
13568 gtk_tree_view_get_drag_dest_row (GtkTreeView              *tree_view,
13569                                  GtkTreePath             **path,
13570                                  GtkTreeViewDropPosition  *pos)
13571 {
13572   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13573
13574   if (path)
13575     {
13576       if (tree_view->priv->drag_dest_row)
13577         *path = gtk_tree_row_reference_get_path (tree_view->priv->drag_dest_row);
13578       else
13579         {
13580           if (tree_view->priv->empty_view_drop)
13581             *path = gtk_tree_path_new_from_indices (0, -1);
13582           else
13583             *path = NULL;
13584         }
13585     }
13586
13587   if (pos)
13588     *pos = tree_view->priv->drag_dest_pos;
13589 }
13590
13591 /**
13592  * gtk_tree_view_get_dest_row_at_pos:
13593  * @tree_view: a #GtkTreeView
13594  * @drag_x: the position to determine the destination row for
13595  * @drag_y: the position to determine the destination row for
13596  * @path: (out) (allow-none): Return location for the path of the highlighted row, or %NULL.
13597  * @pos: (out) (allow-none): Return location for the drop position, or %NULL
13598  *
13599  * Determines the destination row for a given position.  @drag_x and
13600  * @drag_y are expected to be in widget coordinates.  This function is only
13601  * meaningful if @tree_view is realized.  Therefore this function will always
13602  * return %FALSE if @tree_view is not realized or does not have a model.
13603  *
13604  * Return value: whether there is a row at the given position, %TRUE if this
13605  * is indeed the case.
13606  **/
13607 gboolean
13608 gtk_tree_view_get_dest_row_at_pos (GtkTreeView             *tree_view,
13609                                    gint                     drag_x,
13610                                    gint                     drag_y,
13611                                    GtkTreePath            **path,
13612                                    GtkTreeViewDropPosition *pos)
13613 {
13614   gint cell_y;
13615   gint bin_x, bin_y;
13616   gdouble offset_into_row;
13617   gdouble third;
13618   GdkRectangle cell;
13619   GtkTreeViewColumn *column = NULL;
13620   GtkTreePath *tmp_path = NULL;
13621
13622   /* Note; this function is exported to allow a custom DND
13623    * implementation, so it can't touch TreeViewDragInfo
13624    */
13625
13626   g_return_val_if_fail (tree_view != NULL, FALSE);
13627   g_return_val_if_fail (drag_x >= 0, FALSE);
13628   g_return_val_if_fail (drag_y >= 0, FALSE);
13629
13630   if (path)
13631     *path = NULL;
13632
13633   if (tree_view->priv->bin_window == NULL)
13634     return FALSE;
13635
13636   if (tree_view->priv->tree == NULL)
13637     return FALSE;
13638
13639   /* If in the top third of a row, we drop before that row; if
13640    * in the bottom third, drop after that row; if in the middle,
13641    * and the row has children, drop into the row.
13642    */
13643   gtk_tree_view_convert_widget_to_bin_window_coords (tree_view, drag_x, drag_y,
13644                                                      &bin_x, &bin_y);
13645
13646   if (!gtk_tree_view_get_path_at_pos (tree_view,
13647                                       bin_x,
13648                                       bin_y,
13649                                       &tmp_path,
13650                                       &column,
13651                                       NULL,
13652                                       &cell_y))
13653     return FALSE;
13654
13655   gtk_tree_view_get_background_area (tree_view, tmp_path, column,
13656                                      &cell);
13657
13658   offset_into_row = cell_y;
13659
13660   if (path)
13661     *path = tmp_path;
13662   else
13663     gtk_tree_path_free (tmp_path);
13664
13665   tmp_path = NULL;
13666
13667   third = cell.height / 3.0;
13668
13669   if (pos)
13670     {
13671       if (offset_into_row < third)
13672         {
13673           *pos = GTK_TREE_VIEW_DROP_BEFORE;
13674         }
13675       else if (offset_into_row < (cell.height / 2.0))
13676         {
13677           *pos = GTK_TREE_VIEW_DROP_INTO_OR_BEFORE;
13678         }
13679       else if (offset_into_row < third * 2.0)
13680         {
13681           *pos = GTK_TREE_VIEW_DROP_INTO_OR_AFTER;
13682         }
13683       else
13684         {
13685           *pos = GTK_TREE_VIEW_DROP_AFTER;
13686         }
13687     }
13688
13689   return TRUE;
13690 }
13691
13692
13693
13694 /* KEEP IN SYNC WITH GTK_TREE_VIEW_BIN_EXPOSE */
13695 /**
13696  * gtk_tree_view_create_row_drag_icon:
13697  * @tree_view: a #GtkTreeView
13698  * @path: a #GtkTreePath in @tree_view
13699  *
13700  * Creates a #cairo_surface_t representation of the row at @path.
13701  * This image is used for a drag icon.
13702  *
13703  * Return value: (transfer full): a newly-allocated surface of the drag icon.
13704  **/
13705 cairo_surface_t *
13706 gtk_tree_view_create_row_drag_icon (GtkTreeView  *tree_view,
13707                                     GtkTreePath  *path)
13708 {
13709   GtkTreeIter   iter;
13710   GtkRBTree    *tree;
13711   GtkRBNode    *node;
13712   GtkStyle *style;
13713   gint cell_offset;
13714   GList *list;
13715   GdkRectangle background_area;
13716   GtkWidget *widget;
13717   gint depth;
13718   /* start drawing inside the black outline */
13719   gint x = 1, y = 1;
13720   cairo_surface_t *surface;
13721   gint bin_window_width;
13722   gboolean is_separator = FALSE;
13723   gboolean rtl;
13724   cairo_t *cr;
13725
13726   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
13727   g_return_val_if_fail (path != NULL, NULL);
13728
13729   widget = GTK_WIDGET (tree_view);
13730
13731   if (!gtk_widget_get_realized (widget))
13732     return NULL;
13733
13734   depth = gtk_tree_path_get_depth (path);
13735
13736   _gtk_tree_view_find_node (tree_view,
13737                             path,
13738                             &tree,
13739                             &node);
13740
13741   if (tree == NULL)
13742     return NULL;
13743
13744   if (!gtk_tree_model_get_iter (tree_view->priv->model,
13745                                 &iter,
13746                                 path))
13747     return NULL;
13748
13749   style = gtk_widget_get_style (widget);
13750
13751   is_separator = row_is_separator (tree_view, &iter, NULL);
13752
13753   cell_offset = x;
13754
13755   background_area.y = y;
13756   background_area.height = ROW_HEIGHT (tree_view, BACKGROUND_HEIGHT (node));
13757
13758   bin_window_width = gdk_window_get_width (tree_view->priv->bin_window);
13759
13760   surface = gdk_window_create_similar_surface (tree_view->priv->bin_window,
13761                                                CAIRO_CONTENT_COLOR,
13762                                                bin_window_width + 2,
13763                                                background_area.height + 2);
13764
13765   cr = cairo_create (surface);
13766   gdk_cairo_set_source_color (cr, &style->base [gtk_widget_get_state (widget)]);
13767   cairo_paint (cr);
13768
13769   rtl = gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL;
13770
13771   for (list = (rtl ? g_list_last (tree_view->priv->columns) : g_list_first (tree_view->priv->columns));
13772       list;
13773       list = (rtl ? list->prev : list->next))
13774     {
13775       GtkTreeViewColumn *column = list->data;
13776       GdkRectangle cell_area;
13777       gint vertical_separator;
13778
13779       if (!column->visible)
13780         continue;
13781
13782       gtk_tree_view_column_cell_set_cell_data (column, tree_view->priv->model, &iter,
13783                                                GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_PARENT),
13784                                                node->children?TRUE:FALSE);
13785
13786       background_area.x = cell_offset;
13787       background_area.width = column->width;
13788
13789       gtk_widget_style_get (widget,
13790                             "vertical-separator", &vertical_separator,
13791                             NULL);
13792
13793       cell_area = background_area;
13794
13795       cell_area.y += vertical_separator / 2;
13796       cell_area.height -= vertical_separator;
13797
13798       if (gtk_tree_view_is_expander_column (tree_view, column))
13799         {
13800           if (!rtl)
13801             cell_area.x += (depth - 1) * tree_view->priv->level_indentation;
13802           cell_area.width -= (depth - 1) * tree_view->priv->level_indentation;
13803
13804           if (TREE_VIEW_DRAW_EXPANDERS(tree_view))
13805             {
13806               if (!rtl)
13807                 cell_area.x += depth * tree_view->priv->expander_size;
13808               cell_area.width -= depth * tree_view->priv->expander_size;
13809             }
13810         }
13811
13812       if (gtk_tree_view_column_cell_is_visible (column))
13813         {
13814           if (is_separator)
13815             gtk_paint_hline (style,
13816                                    cr,
13817                                    GTK_STATE_NORMAL,
13818                                    widget,
13819                                    NULL,
13820                                    cell_area.x,
13821                                    cell_area.x + cell_area.width,
13822                                    cell_area.y + cell_area.height / 2);
13823           else
13824             _gtk_tree_view_column_cell_render (column,
13825                                                cr,
13826                                                &background_area,
13827                                                &cell_area,
13828                                                0);
13829         }
13830       cell_offset += column->width;
13831     }
13832
13833   cairo_set_source_rgb (cr, 0, 0, 0);
13834   cairo_rectangle (cr,
13835                    0.5, 0.5,
13836                    bin_window_width + 1,
13837                    background_area.height + 1);
13838   cairo_set_line_width (cr, 1.0);
13839   cairo_stroke (cr);
13840
13841   cairo_destroy (cr);
13842
13843   cairo_surface_set_device_offset (surface, 2, 2);
13844
13845   return surface;
13846 }
13847
13848
13849 /**
13850  * gtk_tree_view_set_destroy_count_func:
13851  * @tree_view: A #GtkTreeView
13852  * @func: (allow-none): Function to be called when a view row is destroyed, or %NULL
13853  * @data: (allow-none): User data to be passed to @func, or %NULL
13854  * @destroy: (allow-none): Destroy notifier for @data, or %NULL
13855  *
13856  * This function should almost never be used.  It is meant for private use by
13857  * ATK for determining the number of visible children that are removed when the
13858  * user collapses a row, or a row is deleted.
13859  **/
13860 void
13861 gtk_tree_view_set_destroy_count_func (GtkTreeView             *tree_view,
13862                                       GtkTreeDestroyCountFunc  func,
13863                                       gpointer                 data,
13864                                       GDestroyNotify           destroy)
13865 {
13866   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13867
13868   if (tree_view->priv->destroy_count_destroy)
13869     tree_view->priv->destroy_count_destroy (tree_view->priv->destroy_count_data);
13870
13871   tree_view->priv->destroy_count_func = func;
13872   tree_view->priv->destroy_count_data = data;
13873   tree_view->priv->destroy_count_destroy = destroy;
13874 }
13875
13876
13877 /*
13878  * Interactive search
13879  */
13880
13881 /**
13882  * gtk_tree_view_set_enable_search:
13883  * @tree_view: A #GtkTreeView
13884  * @enable_search: %TRUE, if the user can search interactively
13885  *
13886  * If @enable_search is set, then the user can type in text to search through
13887  * the tree interactively (this is sometimes called "typeahead find").
13888  *
13889  * Note that even if this is %FALSE, the user can still initiate a search
13890  * using the "start-interactive-search" key binding.
13891  */
13892 void
13893 gtk_tree_view_set_enable_search (GtkTreeView *tree_view,
13894                                  gboolean     enable_search)
13895 {
13896   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13897
13898   enable_search = !!enable_search;
13899
13900   if (tree_view->priv->enable_search != enable_search)
13901     {
13902        tree_view->priv->enable_search = enable_search;
13903        g_object_notify (G_OBJECT (tree_view), "enable-search");
13904     }
13905 }
13906
13907 /**
13908  * gtk_tree_view_get_enable_search:
13909  * @tree_view: A #GtkTreeView
13910  *
13911  * Returns whether or not the tree allows to start interactive searching
13912  * by typing in text.
13913  *
13914  * Return value: whether or not to let the user search interactively
13915  */
13916 gboolean
13917 gtk_tree_view_get_enable_search (GtkTreeView *tree_view)
13918 {
13919   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
13920
13921   return tree_view->priv->enable_search;
13922 }
13923
13924
13925 /**
13926  * gtk_tree_view_get_search_column:
13927  * @tree_view: A #GtkTreeView
13928  *
13929  * Gets the column searched on by the interactive search code.
13930  *
13931  * Return value: the column the interactive search code searches in.
13932  */
13933 gint
13934 gtk_tree_view_get_search_column (GtkTreeView *tree_view)
13935 {
13936   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), -1);
13937
13938   return (tree_view->priv->search_column);
13939 }
13940
13941 /**
13942  * gtk_tree_view_set_search_column:
13943  * @tree_view: A #GtkTreeView
13944  * @column: the column of the model to search in, or -1 to disable searching
13945  *
13946  * Sets @column as the column where the interactive search code should
13947  * search in for the current model.
13948  *
13949  * If the search column is set, users can use the "start-interactive-search"
13950  * key binding to bring up search popup. The enable-search property controls
13951  * whether simply typing text will also start an interactive search.
13952  *
13953  * Note that @column refers to a column of the current model. The search
13954  * column is reset to -1 when the model is changed.
13955  */
13956 void
13957 gtk_tree_view_set_search_column (GtkTreeView *tree_view,
13958                                  gint         column)
13959 {
13960   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
13961   g_return_if_fail (column >= -1);
13962
13963   if (tree_view->priv->search_column == column)
13964     return;
13965
13966   tree_view->priv->search_column = column;
13967   g_object_notify (G_OBJECT (tree_view), "search-column");
13968 }
13969
13970 /**
13971  * gtk_tree_view_get_search_equal_func:
13972  * @tree_view: A #GtkTreeView
13973  *
13974  * Returns the compare function currently in use.
13975  *
13976  * Return value: the currently used compare function for the search code.
13977  */
13978
13979 GtkTreeViewSearchEqualFunc
13980 gtk_tree_view_get_search_equal_func (GtkTreeView *tree_view)
13981 {
13982   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
13983
13984   return tree_view->priv->search_equal_func;
13985 }
13986
13987 /**
13988  * gtk_tree_view_set_search_equal_func:
13989  * @tree_view: A #GtkTreeView
13990  * @search_equal_func: the compare function to use during the search
13991  * @search_user_data: (allow-none): user data to pass to @search_equal_func, or %NULL
13992  * @search_destroy: (allow-none): Destroy notifier for @search_user_data, or %NULL
13993  *
13994  * Sets the compare function for the interactive search capabilities; note
13995  * that somewhat like strcmp() returning 0 for equality
13996  * #GtkTreeViewSearchEqualFunc returns %FALSE on matches.
13997  **/
13998 void
13999 gtk_tree_view_set_search_equal_func (GtkTreeView                *tree_view,
14000                                      GtkTreeViewSearchEqualFunc  search_equal_func,
14001                                      gpointer                    search_user_data,
14002                                      GDestroyNotify              search_destroy)
14003 {
14004   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
14005   g_return_if_fail (search_equal_func != NULL);
14006
14007   if (tree_view->priv->search_destroy)
14008     tree_view->priv->search_destroy (tree_view->priv->search_user_data);
14009
14010   tree_view->priv->search_equal_func = search_equal_func;
14011   tree_view->priv->search_user_data = search_user_data;
14012   tree_view->priv->search_destroy = search_destroy;
14013   if (tree_view->priv->search_equal_func == NULL)
14014     tree_view->priv->search_equal_func = gtk_tree_view_search_equal_func;
14015 }
14016
14017 /**
14018  * gtk_tree_view_get_search_entry:
14019  * @tree_view: A #GtkTreeView
14020  *
14021  * Returns the #GtkEntry which is currently in use as interactive search
14022  * entry for @tree_view.  In case the built-in entry is being used, %NULL
14023  * will be returned.
14024  *
14025  * Return value: (transfer none): the entry currently in use as search entry.
14026  *
14027  * Since: 2.10
14028  */
14029 GtkEntry *
14030 gtk_tree_view_get_search_entry (GtkTreeView *tree_view)
14031 {
14032   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
14033
14034   if (tree_view->priv->search_custom_entry_set)
14035     return GTK_ENTRY (tree_view->priv->search_entry);
14036
14037   return NULL;
14038 }
14039
14040 /**
14041  * gtk_tree_view_set_search_entry:
14042  * @tree_view: A #GtkTreeView
14043  * @entry: (allow-none): the entry the interactive search code of @tree_view should use or %NULL
14044  *
14045  * Sets the entry which the interactive search code will use for this
14046  * @tree_view.  This is useful when you want to provide a search entry
14047  * in our interface at all time at a fixed position.  Passing %NULL for
14048  * @entry will make the interactive search code use the built-in popup
14049  * entry again.
14050  *
14051  * Since: 2.10
14052  */
14053 void
14054 gtk_tree_view_set_search_entry (GtkTreeView *tree_view,
14055                                 GtkEntry    *entry)
14056 {
14057   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
14058   g_return_if_fail (entry == NULL || GTK_IS_ENTRY (entry));
14059
14060   if (tree_view->priv->search_custom_entry_set)
14061     {
14062       if (tree_view->priv->search_entry_changed_id)
14063         {
14064           g_signal_handler_disconnect (tree_view->priv->search_entry,
14065                                        tree_view->priv->search_entry_changed_id);
14066           tree_view->priv->search_entry_changed_id = 0;
14067         }
14068       g_signal_handlers_disconnect_by_func (tree_view->priv->search_entry,
14069                                             G_CALLBACK (gtk_tree_view_search_key_press_event),
14070                                             tree_view);
14071
14072       g_object_unref (tree_view->priv->search_entry);
14073     }
14074   else if (tree_view->priv->search_window)
14075     {
14076       gtk_widget_destroy (tree_view->priv->search_window);
14077
14078       tree_view->priv->search_window = NULL;
14079     }
14080
14081   if (entry)
14082     {
14083       tree_view->priv->search_entry = g_object_ref (entry);
14084       tree_view->priv->search_custom_entry_set = TRUE;
14085
14086       if (tree_view->priv->search_entry_changed_id == 0)
14087         {
14088           tree_view->priv->search_entry_changed_id =
14089             g_signal_connect (tree_view->priv->search_entry, "changed",
14090                               G_CALLBACK (gtk_tree_view_search_init),
14091                               tree_view);
14092         }
14093
14094         g_signal_connect (tree_view->priv->search_entry, "key-press-event",
14095                           G_CALLBACK (gtk_tree_view_search_key_press_event),
14096                           tree_view);
14097
14098         gtk_tree_view_search_init (tree_view->priv->search_entry, tree_view);
14099     }
14100   else
14101     {
14102       tree_view->priv->search_entry = NULL;
14103       tree_view->priv->search_custom_entry_set = FALSE;
14104     }
14105 }
14106
14107 /**
14108  * gtk_tree_view_set_search_position_func:
14109  * @tree_view: A #GtkTreeView
14110  * @func: (allow-none): the function to use to position the search dialog, or %NULL
14111  *    to use the default search position function
14112  * @data: (allow-none): user data to pass to @func, or %NULL
14113  * @destroy: (allow-none): Destroy notifier for @data, or %NULL
14114  *
14115  * Sets the function to use when positioning the search dialog.
14116  *
14117  * Since: 2.10
14118  **/
14119 void
14120 gtk_tree_view_set_search_position_func (GtkTreeView                   *tree_view,
14121                                         GtkTreeViewSearchPositionFunc  func,
14122                                         gpointer                       user_data,
14123                                         GDestroyNotify                 destroy)
14124 {
14125   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
14126
14127   if (tree_view->priv->search_position_destroy)
14128     tree_view->priv->search_position_destroy (tree_view->priv->search_position_user_data);
14129
14130   tree_view->priv->search_position_func = func;
14131   tree_view->priv->search_position_user_data = user_data;
14132   tree_view->priv->search_position_destroy = destroy;
14133   if (tree_view->priv->search_position_func == NULL)
14134     tree_view->priv->search_position_func = gtk_tree_view_search_position_func;
14135 }
14136
14137 /**
14138  * gtk_tree_view_get_search_position_func:
14139  * @tree_view: A #GtkTreeView
14140  *
14141  * Returns the positioning function currently in use.
14142  *
14143  * Return value: the currently used function for positioning the search dialog.
14144  *
14145  * Since: 2.10
14146  */
14147 GtkTreeViewSearchPositionFunc
14148 gtk_tree_view_get_search_position_func (GtkTreeView *tree_view)
14149 {
14150   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
14151
14152   return tree_view->priv->search_position_func;
14153 }
14154
14155
14156 static void
14157 gtk_tree_view_search_dialog_hide (GtkWidget   *search_dialog,
14158                                   GtkTreeView *tree_view,
14159                                   GdkDevice   *device)
14160 {
14161   if (tree_view->priv->disable_popdown)
14162     return;
14163
14164   if (tree_view->priv->search_entry_changed_id)
14165     {
14166       g_signal_handler_disconnect (tree_view->priv->search_entry,
14167                                    tree_view->priv->search_entry_changed_id);
14168       tree_view->priv->search_entry_changed_id = 0;
14169     }
14170   if (tree_view->priv->typeselect_flush_timeout)
14171     {
14172       g_source_remove (tree_view->priv->typeselect_flush_timeout);
14173       tree_view->priv->typeselect_flush_timeout = 0;
14174     }
14175
14176   if (gtk_widget_get_visible (search_dialog))
14177     {
14178       /* send focus-in event */
14179       send_focus_change (GTK_WIDGET (tree_view->priv->search_entry), device, FALSE);
14180       gtk_widget_hide (search_dialog);
14181       gtk_entry_set_text (GTK_ENTRY (tree_view->priv->search_entry), "");
14182       send_focus_change (GTK_WIDGET (tree_view), device, TRUE);
14183     }
14184 }
14185
14186 static void
14187 gtk_tree_view_search_position_func (GtkTreeView *tree_view,
14188                                     GtkWidget   *search_dialog,
14189                                     gpointer     user_data)
14190 {
14191   gint x, y;
14192   gint tree_x, tree_y;
14193   gint tree_width, tree_height;
14194   GdkWindow *tree_window = gtk_widget_get_window (GTK_WIDGET (tree_view));
14195   GdkScreen *screen = gdk_window_get_screen (tree_window);
14196   GtkRequisition requisition;
14197   gint monitor_num;
14198   GdkRectangle monitor;
14199
14200   monitor_num = gdk_screen_get_monitor_at_window (screen, tree_window);
14201   gdk_screen_get_monitor_geometry (screen, monitor_num, &monitor);
14202
14203   gtk_widget_realize (search_dialog);
14204
14205   gdk_window_get_origin (tree_window, &tree_x, &tree_y);
14206   tree_width = gdk_window_get_width (tree_window);
14207   tree_height = gdk_window_get_height (tree_window);
14208   gtk_widget_get_preferred_size (search_dialog, &requisition, NULL);
14209
14210   if (tree_x + tree_width > gdk_screen_get_width (screen))
14211     x = gdk_screen_get_width (screen) - requisition.width;
14212   else if (tree_x + tree_width - requisition.width < 0)
14213     x = 0;
14214   else
14215     x = tree_x + tree_width - requisition.width;
14216
14217   if (tree_y + tree_height + requisition.height > gdk_screen_get_height (screen))
14218     y = gdk_screen_get_height (screen) - requisition.height;
14219   else if (tree_y + tree_height < 0) /* isn't really possible ... */
14220     y = 0;
14221   else
14222     y = tree_y + tree_height;
14223
14224   gtk_window_move (GTK_WINDOW (search_dialog), x, y);
14225 }
14226
14227 static void
14228 gtk_tree_view_search_disable_popdown (GtkEntry *entry,
14229                                       GtkMenu  *menu,
14230                                       gpointer  data)
14231 {
14232   GtkTreeView *tree_view = (GtkTreeView *)data;
14233
14234   tree_view->priv->disable_popdown = 1;
14235   g_signal_connect (menu, "hide",
14236                     G_CALLBACK (gtk_tree_view_search_enable_popdown), data);
14237 }
14238
14239 /* Because we're visible but offscreen, we just set a flag in the preedit
14240  * callback.
14241  */
14242 static void
14243 gtk_tree_view_search_preedit_changed (GtkIMContext *im_context,
14244                                       GtkTreeView  *tree_view)
14245 {
14246   tree_view->priv->imcontext_changed = 1;
14247   if (tree_view->priv->typeselect_flush_timeout)
14248     {
14249       g_source_remove (tree_view->priv->typeselect_flush_timeout);
14250       tree_view->priv->typeselect_flush_timeout =
14251         gdk_threads_add_timeout (GTK_TREE_VIEW_SEARCH_DIALOG_TIMEOUT,
14252                        (GSourceFunc) gtk_tree_view_search_entry_flush_timeout,
14253                        tree_view);
14254     }
14255
14256 }
14257
14258 static void
14259 gtk_tree_view_search_activate (GtkEntry    *entry,
14260                                GtkTreeView *tree_view)
14261 {
14262   GtkTreePath *path;
14263   GtkRBNode *node;
14264   GtkRBTree *tree;
14265
14266   gtk_tree_view_search_dialog_hide (tree_view->priv->search_window,
14267                                     tree_view,
14268                                     gtk_get_current_event_device ());
14269
14270   /* If we have a row selected and it's the cursor row, we activate
14271    * the row XXX */
14272   if (gtk_tree_row_reference_valid (tree_view->priv->cursor))
14273     {
14274       path = gtk_tree_row_reference_get_path (tree_view->priv->cursor);
14275
14276       _gtk_tree_view_find_node (tree_view, path, &tree, &node);
14277
14278       if (node && GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_IS_SELECTED))
14279         gtk_tree_view_row_activated (tree_view, path, tree_view->priv->focus_column);
14280
14281       gtk_tree_path_free (path);
14282     }
14283 }
14284
14285 static gboolean
14286 gtk_tree_view_real_search_enable_popdown (gpointer data)
14287 {
14288   GtkTreeView *tree_view = (GtkTreeView *)data;
14289
14290   tree_view->priv->disable_popdown = 0;
14291
14292   return FALSE;
14293 }
14294
14295 static void
14296 gtk_tree_view_search_enable_popdown (GtkWidget *widget,
14297                                      gpointer   data)
14298 {
14299   gdk_threads_add_timeout_full (G_PRIORITY_HIGH, 200, gtk_tree_view_real_search_enable_popdown, g_object_ref (data), g_object_unref);
14300 }
14301
14302 static gboolean
14303 gtk_tree_view_search_delete_event (GtkWidget *widget,
14304                                    GdkEventAny *event,
14305                                    GtkTreeView *tree_view)
14306 {
14307   g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
14308
14309   gtk_tree_view_search_dialog_hide (widget, tree_view, NULL);
14310
14311   return TRUE;
14312 }
14313
14314 static gboolean
14315 gtk_tree_view_search_button_press_event (GtkWidget *widget,
14316                                          GdkEventButton *event,
14317                                          GtkTreeView *tree_view)
14318 {
14319   GdkDevice *keyb_device;
14320
14321   g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
14322
14323   keyb_device = gdk_device_get_associated_device (event->device);
14324   gtk_tree_view_search_dialog_hide (widget, tree_view, keyb_device);
14325
14326   if (event->window == tree_view->priv->bin_window)
14327     gtk_tree_view_button_press (GTK_WIDGET (tree_view), event);
14328
14329   return TRUE;
14330 }
14331
14332 static gboolean
14333 gtk_tree_view_search_scroll_event (GtkWidget *widget,
14334                                    GdkEventScroll *event,
14335                                    GtkTreeView *tree_view)
14336 {
14337   gboolean retval = FALSE;
14338
14339   if (event->direction == GDK_SCROLL_UP)
14340     {
14341       gtk_tree_view_search_move (widget, tree_view, TRUE);
14342       retval = TRUE;
14343     }
14344   else if (event->direction == GDK_SCROLL_DOWN)
14345     {
14346       gtk_tree_view_search_move (widget, tree_view, FALSE);
14347       retval = TRUE;
14348     }
14349
14350   /* renew the flush timeout */
14351   if (retval && tree_view->priv->typeselect_flush_timeout
14352       && !tree_view->priv->search_custom_entry_set)
14353     {
14354       g_source_remove (tree_view->priv->typeselect_flush_timeout);
14355       tree_view->priv->typeselect_flush_timeout =
14356         gdk_threads_add_timeout (GTK_TREE_VIEW_SEARCH_DIALOG_TIMEOUT,
14357                        (GSourceFunc) gtk_tree_view_search_entry_flush_timeout,
14358                        tree_view);
14359     }
14360
14361   return retval;
14362 }
14363
14364 static gboolean
14365 gtk_tree_view_search_key_press_event (GtkWidget *widget,
14366                                       GdkEventKey *event,
14367                                       GtkTreeView *tree_view)
14368 {
14369   gboolean retval = FALSE;
14370
14371   g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
14372   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
14373
14374   /* close window and cancel the search */
14375   if (!tree_view->priv->search_custom_entry_set
14376       && (event->keyval == GDK_KEY_Escape ||
14377           event->keyval == GDK_KEY_Tab ||
14378             event->keyval == GDK_KEY_KP_Tab ||
14379             event->keyval == GDK_KEY_ISO_Left_Tab))
14380     {
14381       gtk_tree_view_search_dialog_hide (widget, tree_view,
14382                                         gdk_event_get_device ((GdkEvent *) event));
14383       return TRUE;
14384     }
14385
14386   /* select previous matching iter */
14387   if (event->keyval == GDK_KEY_Up || event->keyval == GDK_KEY_KP_Up)
14388     {
14389       if (!gtk_tree_view_search_move (widget, tree_view, TRUE))
14390         gtk_widget_error_bell (widget);
14391
14392       retval = TRUE;
14393     }
14394
14395   if (((event->state & (GTK_DEFAULT_ACCEL_MOD_MASK | GDK_SHIFT_MASK)) == (GTK_DEFAULT_ACCEL_MOD_MASK | GDK_SHIFT_MASK))
14396       && (event->keyval == GDK_KEY_g || event->keyval == GDK_KEY_G))
14397     {
14398       if (!gtk_tree_view_search_move (widget, tree_view, TRUE))
14399         gtk_widget_error_bell (widget);
14400
14401       retval = TRUE;
14402     }
14403
14404   /* select next matching iter */
14405   if (event->keyval == GDK_KEY_Down || event->keyval == GDK_KEY_KP_Down)
14406     {
14407       if (!gtk_tree_view_search_move (widget, tree_view, FALSE))
14408         gtk_widget_error_bell (widget);
14409
14410       retval = TRUE;
14411     }
14412
14413   if (((event->state & (GTK_DEFAULT_ACCEL_MOD_MASK | GDK_SHIFT_MASK)) == GTK_DEFAULT_ACCEL_MOD_MASK)
14414       && (event->keyval == GDK_KEY_g || event->keyval == GDK_KEY_G))
14415     {
14416       if (!gtk_tree_view_search_move (widget, tree_view, FALSE))
14417         gtk_widget_error_bell (widget);
14418
14419       retval = TRUE;
14420     }
14421
14422   /* renew the flush timeout */
14423   if (retval && tree_view->priv->typeselect_flush_timeout
14424       && !tree_view->priv->search_custom_entry_set)
14425     {
14426       g_source_remove (tree_view->priv->typeselect_flush_timeout);
14427       tree_view->priv->typeselect_flush_timeout =
14428         gdk_threads_add_timeout (GTK_TREE_VIEW_SEARCH_DIALOG_TIMEOUT,
14429                        (GSourceFunc) gtk_tree_view_search_entry_flush_timeout,
14430                        tree_view);
14431     }
14432
14433   return retval;
14434 }
14435
14436 /*  this function returns FALSE if there is a search string but
14437  *  nothing was found, and TRUE otherwise.
14438  */
14439 static gboolean
14440 gtk_tree_view_search_move (GtkWidget   *window,
14441                            GtkTreeView *tree_view,
14442                            gboolean     up)
14443 {
14444   gboolean ret;
14445   gint len;
14446   gint count = 0;
14447   const gchar *text;
14448   GtkTreeIter iter;
14449   GtkTreeModel *model;
14450   GtkTreeSelection *selection;
14451
14452   text = gtk_entry_get_text (GTK_ENTRY (tree_view->priv->search_entry));
14453
14454   g_return_val_if_fail (text != NULL, FALSE);
14455
14456   len = strlen (text);
14457
14458   if (up && tree_view->priv->selected_iter == 1)
14459     return strlen (text) < 1;
14460
14461   len = strlen (text);
14462
14463   if (len < 1)
14464     return TRUE;
14465
14466   model = gtk_tree_view_get_model (tree_view);
14467   selection = gtk_tree_view_get_selection (tree_view);
14468
14469   /* search */
14470   gtk_tree_selection_unselect_all (selection);
14471   if (!gtk_tree_model_get_iter_first (model, &iter))
14472     return TRUE;
14473
14474   ret = gtk_tree_view_search_iter (model, selection, &iter, text,
14475                                    &count, up?((tree_view->priv->selected_iter) - 1):((tree_view->priv->selected_iter + 1)));
14476
14477   if (ret)
14478     {
14479       /* found */
14480       tree_view->priv->selected_iter += up?(-1):(1);
14481       return TRUE;
14482     }
14483   else
14484     {
14485       /* return to old iter */
14486       count = 0;
14487       gtk_tree_model_get_iter_first (model, &iter);
14488       gtk_tree_view_search_iter (model, selection,
14489                                  &iter, text,
14490                                  &count, tree_view->priv->selected_iter);
14491       return FALSE;
14492     }
14493 }
14494
14495 static gboolean
14496 gtk_tree_view_search_equal_func (GtkTreeModel *model,
14497                                  gint          column,
14498                                  const gchar  *key,
14499                                  GtkTreeIter  *iter,
14500                                  gpointer      search_data)
14501 {
14502   gboolean retval = TRUE;
14503   const gchar *str;
14504   gchar *normalized_string;
14505   gchar *normalized_key;
14506   gchar *case_normalized_string = NULL;
14507   gchar *case_normalized_key = NULL;
14508   GValue value = {0,};
14509   GValue transformed = {0,};
14510
14511   gtk_tree_model_get_value (model, iter, column, &value);
14512
14513   g_value_init (&transformed, G_TYPE_STRING);
14514
14515   if (!g_value_transform (&value, &transformed))
14516     {
14517       g_value_unset (&value);
14518       return TRUE;
14519     }
14520
14521   g_value_unset (&value);
14522
14523   str = g_value_get_string (&transformed);
14524   if (!str)
14525     {
14526       g_value_unset (&transformed);
14527       return TRUE;
14528     }
14529
14530   normalized_string = g_utf8_normalize (str, -1, G_NORMALIZE_ALL);
14531   normalized_key = g_utf8_normalize (key, -1, G_NORMALIZE_ALL);
14532
14533   if (normalized_string && normalized_key)
14534     {
14535       case_normalized_string = g_utf8_casefold (normalized_string, -1);
14536       case_normalized_key = g_utf8_casefold (normalized_key, -1);
14537
14538       if (strncmp (case_normalized_key, case_normalized_string, strlen (case_normalized_key)) == 0)
14539         retval = FALSE;
14540     }
14541
14542   g_value_unset (&transformed);
14543   g_free (normalized_key);
14544   g_free (normalized_string);
14545   g_free (case_normalized_key);
14546   g_free (case_normalized_string);
14547
14548   return retval;
14549 }
14550
14551 static gboolean
14552 gtk_tree_view_search_iter (GtkTreeModel     *model,
14553                            GtkTreeSelection *selection,
14554                            GtkTreeIter      *iter,
14555                            const gchar      *text,
14556                            gint             *count,
14557                            gint              n)
14558 {
14559   GtkRBTree *tree = NULL;
14560   GtkRBNode *node = NULL;
14561   GtkTreePath *path;
14562
14563   GtkTreeView *tree_view = gtk_tree_selection_get_tree_view (selection);
14564
14565   path = gtk_tree_model_get_path (model, iter);
14566   _gtk_tree_view_find_node (tree_view, path, &tree, &node);
14567
14568   do
14569     {
14570       if (! tree_view->priv->search_equal_func (model, tree_view->priv->search_column, text, iter, tree_view->priv->search_user_data))
14571         {
14572           (*count)++;
14573           if (*count == n)
14574             {
14575               gtk_tree_view_scroll_to_cell (tree_view, path, NULL,
14576                                             TRUE, 0.5, 0.0);
14577               gtk_tree_selection_select_iter (selection, iter);
14578               gtk_tree_view_real_set_cursor (tree_view, path, FALSE, TRUE);
14579
14580               if (path)
14581                 gtk_tree_path_free (path);
14582
14583               return TRUE;
14584             }
14585         }
14586
14587       if (node->children)
14588         {
14589           gboolean has_child;
14590           GtkTreeIter tmp;
14591
14592           tree = node->children;
14593           node = tree->root;
14594
14595           while (node->left != tree->nil)
14596             node = node->left;
14597
14598           tmp = *iter;
14599           has_child = gtk_tree_model_iter_children (model, iter, &tmp);
14600           gtk_tree_path_down (path);
14601
14602           /* sanity check */
14603           TREE_VIEW_INTERNAL_ASSERT (has_child, FALSE);
14604         }
14605       else
14606         {
14607           gboolean done = FALSE;
14608
14609           do
14610             {
14611               node = _gtk_rbtree_next (tree, node);
14612
14613               if (node)
14614                 {
14615                   gboolean has_next;
14616
14617                   has_next = gtk_tree_model_iter_next (model, iter);
14618
14619                   done = TRUE;
14620                   gtk_tree_path_next (path);
14621
14622                   /* sanity check */
14623                   TREE_VIEW_INTERNAL_ASSERT (has_next, FALSE);
14624                 }
14625               else
14626                 {
14627                   gboolean has_parent;
14628                   GtkTreeIter tmp_iter = *iter;
14629
14630                   node = tree->parent_node;
14631                   tree = tree->parent_tree;
14632
14633                   if (!tree)
14634                     {
14635                       if (path)
14636                         gtk_tree_path_free (path);
14637
14638                       /* we've run out of tree, done with this func */
14639                       return FALSE;
14640                     }
14641
14642                   has_parent = gtk_tree_model_iter_parent (model,
14643                                                            iter,
14644                                                            &tmp_iter);
14645                   gtk_tree_path_up (path);
14646
14647                   /* sanity check */
14648                   TREE_VIEW_INTERNAL_ASSERT (has_parent, FALSE);
14649                 }
14650             }
14651           while (!done);
14652         }
14653     }
14654   while (1);
14655
14656   return FALSE;
14657 }
14658
14659 static void
14660 gtk_tree_view_search_init (GtkWidget   *entry,
14661                            GtkTreeView *tree_view)
14662 {
14663   gint ret;
14664   gint count = 0;
14665   const gchar *text;
14666   GtkTreeIter iter;
14667   GtkTreeModel *model;
14668   GtkTreeSelection *selection;
14669
14670   g_return_if_fail (GTK_IS_ENTRY (entry));
14671   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
14672
14673   text = gtk_entry_get_text (GTK_ENTRY (entry));
14674
14675   model = gtk_tree_view_get_model (tree_view);
14676   selection = gtk_tree_view_get_selection (tree_view);
14677
14678   /* search */
14679   gtk_tree_selection_unselect_all (selection);
14680   if (tree_view->priv->typeselect_flush_timeout
14681       && !tree_view->priv->search_custom_entry_set)
14682     {
14683       g_source_remove (tree_view->priv->typeselect_flush_timeout);
14684       tree_view->priv->typeselect_flush_timeout =
14685         gdk_threads_add_timeout (GTK_TREE_VIEW_SEARCH_DIALOG_TIMEOUT,
14686                        (GSourceFunc) gtk_tree_view_search_entry_flush_timeout,
14687                        tree_view);
14688     }
14689
14690   if (*text == '\0')
14691     return;
14692
14693   if (!gtk_tree_model_get_iter_first (model, &iter))
14694     return;
14695
14696   ret = gtk_tree_view_search_iter (model, selection,
14697                                    &iter, text,
14698                                    &count, 1);
14699
14700   if (ret)
14701     tree_view->priv->selected_iter = 1;
14702 }
14703
14704 static void
14705 gtk_tree_view_remove_widget (GtkCellEditable *cell_editable,
14706                              GtkTreeView     *tree_view)
14707 {
14708   if (tree_view->priv->edited_column == NULL)
14709     return;
14710
14711   _gtk_tree_view_column_stop_editing (tree_view->priv->edited_column);
14712   tree_view->priv->edited_column = NULL;
14713
14714   if (gtk_widget_has_focus (GTK_WIDGET (cell_editable)))
14715     gtk_widget_grab_focus (GTK_WIDGET (tree_view));
14716
14717   g_signal_handlers_disconnect_by_func (cell_editable,
14718                                         gtk_tree_view_remove_widget,
14719                                         tree_view);
14720
14721   gtk_container_remove (GTK_CONTAINER (tree_view),
14722                         GTK_WIDGET (cell_editable));
14723
14724   /* FIXME should only redraw a single node */
14725   gtk_widget_queue_draw (GTK_WIDGET (tree_view));
14726 }
14727
14728 static gboolean
14729 gtk_tree_view_start_editing (GtkTreeView *tree_view,
14730                              GtkTreePath *cursor_path)
14731 {
14732   GtkTreeIter iter;
14733   GdkRectangle background_area;
14734   GdkRectangle cell_area;
14735   GtkCellEditable *editable_widget = NULL;
14736   gchar *path_string;
14737   guint flags = 0; /* can be 0, as the flags are primarily for rendering */
14738   gint retval = FALSE;
14739   GtkRBTree *cursor_tree;
14740   GtkRBNode *cursor_node;
14741
14742   g_assert (tree_view->priv->focus_column);
14743
14744   if (!gtk_widget_get_realized (GTK_WIDGET (tree_view)))
14745     return FALSE;
14746
14747   if (_gtk_tree_view_find_node (tree_view, cursor_path, &cursor_tree, &cursor_node) ||
14748       cursor_node == NULL)
14749     return FALSE;
14750
14751   path_string = gtk_tree_path_to_string (cursor_path);
14752   gtk_tree_model_get_iter (tree_view->priv->model, &iter, cursor_path);
14753
14754   validate_row (tree_view, cursor_tree, cursor_node, &iter, cursor_path);
14755
14756   gtk_tree_view_column_cell_set_cell_data (tree_view->priv->focus_column,
14757                                            tree_view->priv->model,
14758                                            &iter,
14759                                            GTK_RBNODE_FLAG_SET (cursor_node, GTK_RBNODE_IS_PARENT),
14760                                            cursor_node->children?TRUE:FALSE);
14761   gtk_tree_view_get_background_area (tree_view,
14762                                      cursor_path,
14763                                      tree_view->priv->focus_column,
14764                                      &background_area);
14765   gtk_tree_view_get_cell_area (tree_view,
14766                                cursor_path,
14767                                tree_view->priv->focus_column,
14768                                &cell_area);
14769
14770   if (_gtk_tree_view_column_cell_event (tree_view->priv->focus_column,
14771                                         &editable_widget,
14772                                         NULL,
14773                                         path_string,
14774                                         &background_area,
14775                                         &cell_area,
14776                                         flags))
14777     {
14778       retval = TRUE;
14779       if (editable_widget != NULL)
14780         {
14781           gint left, right;
14782           GdkRectangle area;
14783           GtkCellRenderer *cell;
14784
14785           area = cell_area;
14786           cell = _gtk_tree_view_column_get_edited_cell (tree_view->priv->focus_column);
14787
14788           _gtk_tree_view_column_get_neighbor_sizes (tree_view->priv->focus_column, cell, &left, &right);
14789
14790           area.x += left;
14791           area.width -= right + left;
14792
14793           gtk_tree_view_real_start_editing (tree_view,
14794                                             tree_view->priv->focus_column,
14795                                             cursor_path,
14796                                             editable_widget,
14797                                             &area,
14798                                             NULL,
14799                                             flags);
14800         }
14801
14802     }
14803   g_free (path_string);
14804   return retval;
14805 }
14806
14807 static void
14808 gtk_tree_view_real_start_editing (GtkTreeView       *tree_view,
14809                                   GtkTreeViewColumn *column,
14810                                   GtkTreePath       *path,
14811                                   GtkCellEditable   *cell_editable,
14812                                   GdkRectangle      *cell_area,
14813                                   GdkEvent          *event,
14814                                   guint              flags)
14815 {
14816   gint pre_val = tree_view->priv->vadjustment->value;
14817   GtkRequisition requisition;
14818
14819   tree_view->priv->edited_column = column;
14820   _gtk_tree_view_column_start_editing (column, GTK_CELL_EDITABLE (cell_editable));
14821
14822   gtk_tree_view_real_set_cursor (tree_view, path, FALSE, TRUE);
14823   cell_area->y += pre_val - (int)tree_view->priv->vadjustment->value;
14824
14825   gtk_widget_get_preferred_size (GTK_WIDGET (cell_editable),
14826                                  &requisition, NULL);
14827
14828   GTK_TREE_VIEW_SET_FLAG (tree_view, GTK_TREE_VIEW_DRAW_KEYFOCUS);
14829
14830   if (requisition.height < cell_area->height)
14831     {
14832       gint diff = cell_area->height - requisition.height;
14833       gtk_tree_view_put (tree_view,
14834                          GTK_WIDGET (cell_editable),
14835                          cell_area->x, cell_area->y + diff/2,
14836                          cell_area->width, requisition.height);
14837     }
14838   else
14839     {
14840       gtk_tree_view_put (tree_view,
14841                          GTK_WIDGET (cell_editable),
14842                          cell_area->x, cell_area->y,
14843                          cell_area->width, cell_area->height);
14844     }
14845
14846   gtk_cell_editable_start_editing (GTK_CELL_EDITABLE (cell_editable),
14847                                    (GdkEvent *)event);
14848
14849   gtk_widget_grab_focus (GTK_WIDGET (cell_editable));
14850   g_signal_connect (cell_editable, "remove-widget",
14851                     G_CALLBACK (gtk_tree_view_remove_widget), tree_view);
14852 }
14853
14854 static void
14855 gtk_tree_view_stop_editing (GtkTreeView *tree_view,
14856                             gboolean     cancel_editing)
14857 {
14858   GtkTreeViewColumn *column;
14859   GtkCellRenderer *cell;
14860
14861   if (tree_view->priv->edited_column == NULL)
14862     return;
14863
14864   /*
14865    * This is very evil. We need to do this, because
14866    * gtk_cell_editable_editing_done may trigger gtk_tree_view_row_changed
14867    * later on. If gtk_tree_view_row_changed notices
14868    * tree_view->priv->edited_column != NULL, it'll call
14869    * gtk_tree_view_stop_editing again. Bad things will happen then.
14870    *
14871    * Please read that again if you intend to modify anything here.
14872    */
14873
14874   column = tree_view->priv->edited_column;
14875   tree_view->priv->edited_column = NULL;
14876
14877   cell = _gtk_tree_view_column_get_edited_cell (column);
14878   gtk_cell_renderer_stop_editing (cell, cancel_editing);
14879
14880   if (!cancel_editing)
14881     gtk_cell_editable_editing_done (column->editable_widget);
14882
14883   tree_view->priv->edited_column = column;
14884
14885   gtk_cell_editable_remove_widget (column->editable_widget);
14886 }
14887
14888
14889 /**
14890  * gtk_tree_view_set_hover_selection:
14891  * @tree_view: a #GtkTreeView
14892  * @hover: %TRUE to enable hover selection mode
14893  *
14894  * Enables of disables the hover selection mode of @tree_view.
14895  * Hover selection makes the selected row follow the pointer.
14896  * Currently, this works only for the selection modes
14897  * %GTK_SELECTION_SINGLE and %GTK_SELECTION_BROWSE.
14898  *
14899  * Since: 2.6
14900  **/
14901 void
14902 gtk_tree_view_set_hover_selection (GtkTreeView *tree_view,
14903                                    gboolean     hover)
14904 {
14905   hover = hover != FALSE;
14906
14907   if (hover != tree_view->priv->hover_selection)
14908     {
14909       tree_view->priv->hover_selection = hover;
14910
14911       g_object_notify (G_OBJECT (tree_view), "hover-selection");
14912     }
14913 }
14914
14915 /**
14916  * gtk_tree_view_get_hover_selection:
14917  * @tree_view: a #GtkTreeView
14918  *
14919  * Returns whether hover selection mode is turned on for @tree_view.
14920  *
14921  * Return value: %TRUE if @tree_view is in hover selection mode
14922  *
14923  * Since: 2.6
14924  **/
14925 gboolean
14926 gtk_tree_view_get_hover_selection (GtkTreeView *tree_view)
14927 {
14928   return tree_view->priv->hover_selection;
14929 }
14930
14931 /**
14932  * gtk_tree_view_set_hover_expand:
14933  * @tree_view: a #GtkTreeView
14934  * @expand: %TRUE to enable hover selection mode
14935  *
14936  * Enables of disables the hover expansion mode of @tree_view.
14937  * Hover expansion makes rows expand or collapse if the pointer
14938  * moves over them.
14939  *
14940  * Since: 2.6
14941  **/
14942 void
14943 gtk_tree_view_set_hover_expand (GtkTreeView *tree_view,
14944                                 gboolean     expand)
14945 {
14946   expand = expand != FALSE;
14947
14948   if (expand != tree_view->priv->hover_expand)
14949     {
14950       tree_view->priv->hover_expand = expand;
14951
14952       g_object_notify (G_OBJECT (tree_view), "hover-expand");
14953     }
14954 }
14955
14956 /**
14957  * gtk_tree_view_get_hover_expand:
14958  * @tree_view: a #GtkTreeView
14959  *
14960  * Returns whether hover expansion mode is turned on for @tree_view.
14961  *
14962  * Return value: %TRUE if @tree_view is in hover expansion mode
14963  *
14964  * Since: 2.6
14965  **/
14966 gboolean
14967 gtk_tree_view_get_hover_expand (GtkTreeView *tree_view)
14968 {
14969   return tree_view->priv->hover_expand;
14970 }
14971
14972 /**
14973  * gtk_tree_view_set_rubber_banding:
14974  * @tree_view: a #GtkTreeView
14975  * @enable: %TRUE to enable rubber banding
14976  *
14977  * Enables or disables rubber banding in @tree_view.  If the selection mode
14978  * is #GTK_SELECTION_MULTIPLE, rubber banding will allow the user to select
14979  * multiple rows by dragging the mouse.
14980  *
14981  * Since: 2.10
14982  **/
14983 void
14984 gtk_tree_view_set_rubber_banding (GtkTreeView *tree_view,
14985                                   gboolean     enable)
14986 {
14987   enable = enable != FALSE;
14988
14989   if (enable != tree_view->priv->rubber_banding_enable)
14990     {
14991       tree_view->priv->rubber_banding_enable = enable;
14992
14993       g_object_notify (G_OBJECT (tree_view), "rubber-banding");
14994     }
14995 }
14996
14997 /**
14998  * gtk_tree_view_get_rubber_banding:
14999  * @tree_view: a #GtkTreeView
15000  *
15001  * Returns whether rubber banding is turned on for @tree_view.  If the
15002  * selection mode is #GTK_SELECTION_MULTIPLE, rubber banding will allow the
15003  * user to select multiple rows by dragging the mouse.
15004  *
15005  * Return value: %TRUE if rubber banding in @tree_view is enabled.
15006  *
15007  * Since: 2.10
15008  **/
15009 gboolean
15010 gtk_tree_view_get_rubber_banding (GtkTreeView *tree_view)
15011 {
15012   return tree_view->priv->rubber_banding_enable;
15013 }
15014
15015 /**
15016  * gtk_tree_view_is_rubber_banding_active:
15017  * @tree_view: a #GtkTreeView
15018  *
15019  * Returns whether a rubber banding operation is currently being done
15020  * in @tree_view.
15021  *
15022  * Return value: %TRUE if a rubber banding operation is currently being
15023  * done in @tree_view.
15024  *
15025  * Since: 2.12
15026  **/
15027 gboolean
15028 gtk_tree_view_is_rubber_banding_active (GtkTreeView *tree_view)
15029 {
15030   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
15031
15032   if (tree_view->priv->rubber_banding_enable
15033       && tree_view->priv->rubber_band_status == RUBBER_BAND_ACTIVE)
15034     return TRUE;
15035
15036   return FALSE;
15037 }
15038
15039 /**
15040  * gtk_tree_view_get_row_separator_func:
15041  * @tree_view: a #GtkTreeView
15042  *
15043  * Returns the current row separator function.
15044  *
15045  * Return value: the current row separator function.
15046  *
15047  * Since: 2.6
15048  **/
15049 GtkTreeViewRowSeparatorFunc
15050 gtk_tree_view_get_row_separator_func (GtkTreeView *tree_view)
15051 {
15052   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), NULL);
15053
15054   return tree_view->priv->row_separator_func;
15055 }
15056
15057 /**
15058  * gtk_tree_view_set_row_separator_func:
15059  * @tree_view: a #GtkTreeView
15060  * @func: (allow-none): a #GtkTreeViewRowSeparatorFunc
15061  * @data: (allow-none): user data to pass to @func, or %NULL
15062  * @destroy: (allow-none): destroy notifier for @data, or %NULL
15063  *
15064  * Sets the row separator function, which is used to determine
15065  * whether a row should be drawn as a separator. If the row separator
15066  * function is %NULL, no separators are drawn. This is the default value.
15067  *
15068  * Since: 2.6
15069  **/
15070 void
15071 gtk_tree_view_set_row_separator_func (GtkTreeView                 *tree_view,
15072                                       GtkTreeViewRowSeparatorFunc  func,
15073                                       gpointer                     data,
15074                                       GDestroyNotify               destroy)
15075 {
15076   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
15077
15078   if (tree_view->priv->row_separator_destroy)
15079     tree_view->priv->row_separator_destroy (tree_view->priv->row_separator_data);
15080
15081   tree_view->priv->row_separator_func = func;
15082   tree_view->priv->row_separator_data = data;
15083   tree_view->priv->row_separator_destroy = destroy;
15084
15085   /* Have the tree recalculate heights */
15086   _gtk_rbtree_mark_invalid (tree_view->priv->tree);
15087   gtk_widget_queue_resize (GTK_WIDGET (tree_view));
15088 }
15089
15090
15091 static void
15092 gtk_tree_view_grab_notify (GtkWidget *widget,
15093                            gboolean   was_grabbed)
15094 {
15095   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
15096
15097   tree_view->priv->in_grab = !was_grabbed;
15098
15099   if (!was_grabbed)
15100     {
15101       tree_view->priv->pressed_button = -1;
15102
15103       if (tree_view->priv->rubber_band_status)
15104         gtk_tree_view_stop_rubber_band (tree_view);
15105     }
15106 }
15107
15108 static void
15109 gtk_tree_view_state_changed (GtkWidget      *widget,
15110                              GtkStateType    previous_state)
15111 {
15112   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
15113
15114   if (gtk_widget_get_realized (widget))
15115     {
15116       gdk_window_set_background (tree_view->priv->bin_window,
15117                                  &gtk_widget_get_style (widget)->base[gtk_widget_get_state (widget)]);
15118     }
15119
15120   gtk_widget_queue_draw (widget);
15121 }
15122
15123 /**
15124  * gtk_tree_view_get_grid_lines:
15125  * @tree_view: a #GtkTreeView
15126  *
15127  * Returns which grid lines are enabled in @tree_view.
15128  *
15129  * Return value: a #GtkTreeViewGridLines value indicating which grid lines
15130  * are enabled.
15131  *
15132  * Since: 2.10
15133  */
15134 GtkTreeViewGridLines
15135 gtk_tree_view_get_grid_lines (GtkTreeView *tree_view)
15136 {
15137   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), 0);
15138
15139   return tree_view->priv->grid_lines;
15140 }
15141
15142 /**
15143  * gtk_tree_view_set_grid_lines:
15144  * @tree_view: a #GtkTreeView
15145  * @grid_lines: a #GtkTreeViewGridLines value indicating which grid lines to
15146  * enable.
15147  *
15148  * Sets which grid lines to draw in @tree_view.
15149  *
15150  * Since: 2.10
15151  */
15152 void
15153 gtk_tree_view_set_grid_lines (GtkTreeView           *tree_view,
15154                               GtkTreeViewGridLines   grid_lines)
15155 {
15156   GtkTreeViewPrivate *priv;
15157   GtkWidget *widget;
15158   GtkTreeViewGridLines old_grid_lines;
15159
15160   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
15161
15162   priv = tree_view->priv;
15163   widget = GTK_WIDGET (tree_view);
15164
15165   old_grid_lines = priv->grid_lines;
15166   priv->grid_lines = grid_lines;
15167
15168   if (gtk_widget_get_realized (widget))
15169     {
15170       if (grid_lines == GTK_TREE_VIEW_GRID_LINES_NONE &&
15171           priv->grid_line_width)
15172         {
15173           priv->grid_line_width = 0;
15174         }
15175
15176       if (grid_lines != GTK_TREE_VIEW_GRID_LINES_NONE &&
15177           !priv->grid_line_width)
15178         {
15179           gint8 *dash_list;
15180
15181           gtk_widget_style_get (widget,
15182                                 "grid-line-width", &priv->grid_line_width,
15183                                 "grid-line-pattern", (gchar *)&dash_list,
15184                                 NULL);
15185
15186           if (dash_list)
15187             {
15188               priv->grid_line_dashes[0] = dash_list[0];
15189               if (dash_list[0])
15190                 priv->grid_line_dashes[1] = dash_list[1];
15191
15192               g_free (dash_list);
15193             }
15194           else
15195             {
15196               priv->grid_line_dashes[0] = 1;
15197               priv->grid_line_dashes[1] = 1;
15198             }
15199         }
15200     }
15201
15202   if (old_grid_lines != grid_lines)
15203     {
15204       gtk_widget_queue_draw (GTK_WIDGET (tree_view));
15205
15206       g_object_notify (G_OBJECT (tree_view), "enable-grid-lines");
15207     }
15208 }
15209
15210 /**
15211  * gtk_tree_view_get_enable_tree_lines:
15212  * @tree_view: a #GtkTreeView.
15213  *
15214  * Returns whether or not tree lines are drawn in @tree_view.
15215  *
15216  * Return value: %TRUE if tree lines are drawn in @tree_view, %FALSE
15217  * otherwise.
15218  *
15219  * Since: 2.10
15220  */
15221 gboolean
15222 gtk_tree_view_get_enable_tree_lines (GtkTreeView *tree_view)
15223 {
15224   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
15225
15226   return tree_view->priv->tree_lines_enabled;
15227 }
15228
15229 /**
15230  * gtk_tree_view_set_enable_tree_lines:
15231  * @tree_view: a #GtkTreeView
15232  * @enabled: %TRUE to enable tree line drawing, %FALSE otherwise.
15233  *
15234  * Sets whether to draw lines interconnecting the expanders in @tree_view.
15235  * This does not have any visible effects for lists.
15236  *
15237  * Since: 2.10
15238  */
15239 void
15240 gtk_tree_view_set_enable_tree_lines (GtkTreeView *tree_view,
15241                                      gboolean     enabled)
15242 {
15243   GtkTreeViewPrivate *priv;
15244   GtkWidget *widget;
15245   gboolean was_enabled;
15246
15247   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
15248
15249   enabled = enabled != FALSE;
15250
15251   priv = tree_view->priv;
15252   widget = GTK_WIDGET (tree_view);
15253
15254   was_enabled = priv->tree_lines_enabled;
15255
15256   priv->tree_lines_enabled = enabled;
15257
15258   if (gtk_widget_get_realized (widget))
15259     {
15260       if (!enabled && priv->tree_line_width)
15261         {
15262           priv->tree_line_width = 0;
15263         }
15264
15265       if (enabled && !priv->tree_line_width)
15266         {
15267           gint8 *dash_list;
15268           gtk_widget_style_get (widget,
15269                                 "tree-line-width", &priv->tree_line_width,
15270                                 "tree-line-pattern", (gchar *)&dash_list,
15271                                 NULL);
15272
15273           if (dash_list)
15274             {
15275               priv->tree_line_dashes[0] = dash_list[0];
15276               if (dash_list[0])
15277                 priv->tree_line_dashes[1] = dash_list[1];
15278
15279               g_free (dash_list);
15280             }
15281           else
15282             {
15283               priv->tree_line_dashes[0] = 1;
15284               priv->tree_line_dashes[1] = 1;
15285             }
15286         }
15287     }
15288
15289   if (was_enabled != enabled)
15290     {
15291       gtk_widget_queue_draw (GTK_WIDGET (tree_view));
15292
15293       g_object_notify (G_OBJECT (tree_view), "enable-tree-lines");
15294     }
15295 }
15296
15297
15298 /**
15299  * gtk_tree_view_set_show_expanders:
15300  * @tree_view: a #GtkTreeView
15301  * @enabled: %TRUE to enable expander drawing, %FALSE otherwise.
15302  *
15303  * Sets whether to draw and enable expanders and indent child rows in
15304  * @tree_view.  When disabled there will be no expanders visible in trees
15305  * and there will be no way to expand and collapse rows by default.  Also
15306  * note that hiding the expanders will disable the default indentation.  You
15307  * can set a custom indentation in this case using
15308  * gtk_tree_view_set_level_indentation().
15309  * This does not have any visible effects for lists.
15310  *
15311  * Since: 2.12
15312  */
15313 void
15314 gtk_tree_view_set_show_expanders (GtkTreeView *tree_view,
15315                                   gboolean     enabled)
15316 {
15317   gboolean was_enabled;
15318
15319   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
15320
15321   enabled = enabled != FALSE;
15322   was_enabled = GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_SHOW_EXPANDERS);
15323
15324   if (enabled)
15325     GTK_TREE_VIEW_SET_FLAG (tree_view, GTK_TREE_VIEW_SHOW_EXPANDERS);
15326   else
15327     GTK_TREE_VIEW_UNSET_FLAG (tree_view, GTK_TREE_VIEW_SHOW_EXPANDERS);
15328
15329   if (enabled != was_enabled)
15330     gtk_widget_queue_draw (GTK_WIDGET (tree_view));
15331 }
15332
15333 /**
15334  * gtk_tree_view_get_show_expanders:
15335  * @tree_view: a #GtkTreeView.
15336  *
15337  * Returns whether or not expanders are drawn in @tree_view.
15338  *
15339  * Return value: %TRUE if expanders are drawn in @tree_view, %FALSE
15340  * otherwise.
15341  *
15342  * Since: 2.12
15343  */
15344 gboolean
15345 gtk_tree_view_get_show_expanders (GtkTreeView *tree_view)
15346 {
15347   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
15348
15349   return GTK_TREE_VIEW_FLAG_SET (tree_view, GTK_TREE_VIEW_SHOW_EXPANDERS);
15350 }
15351
15352 /**
15353  * gtk_tree_view_set_level_indentation:
15354  * @tree_view: a #GtkTreeView
15355  * @indentation: the amount, in pixels, of extra indentation in @tree_view.
15356  *
15357  * Sets the amount of extra indentation for child levels to use in @tree_view
15358  * in addition to the default indentation.  The value should be specified in
15359  * pixels, a value of 0 disables this feature and in this case only the default
15360  * indentation will be used.
15361  * This does not have any visible effects for lists.
15362  *
15363  * Since: 2.12
15364  */
15365 void
15366 gtk_tree_view_set_level_indentation (GtkTreeView *tree_view,
15367                                      gint         indentation)
15368 {
15369   tree_view->priv->level_indentation = indentation;
15370
15371   gtk_widget_queue_draw (GTK_WIDGET (tree_view));
15372 }
15373
15374 /**
15375  * gtk_tree_view_get_level_indentation:
15376  * @tree_view: a #GtkTreeView.
15377  *
15378  * Returns the amount, in pixels, of extra indentation for child levels
15379  * in @tree_view.
15380  *
15381  * Return value: the amount of extra indentation for child levels in
15382  * @tree_view.  A return value of 0 means that this feature is disabled.
15383  *
15384  * Since: 2.12
15385  */
15386 gint
15387 gtk_tree_view_get_level_indentation (GtkTreeView *tree_view)
15388 {
15389   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), 0);
15390
15391   return tree_view->priv->level_indentation;
15392 }
15393
15394 /**
15395  * gtk_tree_view_set_tooltip_row:
15396  * @tree_view: a #GtkTreeView
15397  * @tooltip: a #GtkTooltip
15398  * @path: a #GtkTreePath
15399  *
15400  * Sets the tip area of @tooltip to be the area covered by the row at @path.
15401  * See also gtk_tree_view_set_tooltip_column() for a simpler alternative.
15402  * See also gtk_tooltip_set_tip_area().
15403  *
15404  * Since: 2.12
15405  */
15406 void
15407 gtk_tree_view_set_tooltip_row (GtkTreeView *tree_view,
15408                                GtkTooltip  *tooltip,
15409                                GtkTreePath *path)
15410 {
15411   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
15412   g_return_if_fail (GTK_IS_TOOLTIP (tooltip));
15413
15414   gtk_tree_view_set_tooltip_cell (tree_view, tooltip, path, NULL, NULL);
15415 }
15416
15417 /**
15418  * gtk_tree_view_set_tooltip_cell:
15419  * @tree_view: a #GtkTreeView
15420  * @tooltip: a #GtkTooltip
15421  * @path: (allow-none): a #GtkTreePath or %NULL
15422  * @column: (allow-none): a #GtkTreeViewColumn or %NULL
15423  * @cell: (allow-none): a #GtkCellRenderer or %NULL
15424  *
15425  * Sets the tip area of @tooltip to the area @path, @column and @cell have
15426  * in common.  For example if @path is %NULL and @column is set, the tip
15427  * area will be set to the full area covered by @column.  See also
15428  * gtk_tooltip_set_tip_area().
15429  *
15430  * Note that if @path is not specified and @cell is set and part of a column
15431  * containing the expander, the tooltip might not show and hide at the correct
15432  * position.  In such cases @path must be set to the current node under the
15433  * mouse cursor for this function to operate correctly.
15434  *
15435  * See also gtk_tree_view_set_tooltip_column() for a simpler alternative.
15436  *
15437  * Since: 2.12
15438  */
15439 void
15440 gtk_tree_view_set_tooltip_cell (GtkTreeView       *tree_view,
15441                                 GtkTooltip        *tooltip,
15442                                 GtkTreePath       *path,
15443                                 GtkTreeViewColumn *column,
15444                                 GtkCellRenderer   *cell)
15445 {
15446   GtkAllocation allocation;
15447   GdkRectangle rect;
15448
15449   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
15450   g_return_if_fail (GTK_IS_TOOLTIP (tooltip));
15451   g_return_if_fail (column == NULL || GTK_IS_TREE_VIEW_COLUMN (column));
15452   g_return_if_fail (cell == NULL || GTK_IS_CELL_RENDERER (cell));
15453
15454   /* Determine x values. */
15455   if (column && cell)
15456     {
15457       GdkRectangle tmp;
15458       gint start, width;
15459
15460       /* We always pass in path here, whether it is NULL or not.
15461        * For cells in expander columns path must be specified so that
15462        * we can correctly account for the indentation.  This also means
15463        * that the tooltip is constrained vertically by the "Determine y
15464        * values" code below; this is not a real problem since cells actually
15465        * don't stretch vertically in constrast to columns.
15466        */
15467       gtk_tree_view_get_cell_area (tree_view, path, column, &tmp);
15468       gtk_tree_view_column_cell_get_position (column, cell, &start, &width);
15469
15470       gtk_tree_view_convert_bin_window_to_widget_coords (tree_view,
15471                                                          tmp.x + start, 0,
15472                                                          &rect.x, NULL);
15473       rect.width = width;
15474     }
15475   else if (column)
15476     {
15477       GdkRectangle tmp;
15478
15479       gtk_tree_view_get_background_area (tree_view, NULL, column, &tmp);
15480       gtk_tree_view_convert_bin_window_to_widget_coords (tree_view,
15481                                                          tmp.x, 0,
15482                                                          &rect.x, NULL);
15483       rect.width = tmp.width;
15484     }
15485   else
15486     {
15487       gtk_widget_get_allocation (GTK_WIDGET (tree_view), &allocation);
15488       rect.x = 0;
15489       rect.width = allocation.width;
15490     }
15491
15492   /* Determine y values. */
15493   if (path)
15494     {
15495       GdkRectangle tmp;
15496
15497       gtk_tree_view_get_background_area (tree_view, path, NULL, &tmp);
15498       gtk_tree_view_convert_bin_window_to_widget_coords (tree_view,
15499                                                          0, tmp.y,
15500                                                          NULL, &rect.y);
15501       rect.height = tmp.height;
15502     }
15503   else
15504     {
15505       rect.y = 0;
15506       rect.height = tree_view->priv->vadjustment->page_size;
15507     }
15508
15509   gtk_tooltip_set_tip_area (tooltip, &rect);
15510 }
15511
15512 /**
15513  * gtk_tree_view_get_tooltip_context:
15514  * @tree_view: a #GtkTreeView
15515  * @x: the x coordinate (relative to widget coordinates)
15516  * @y: the y coordinate (relative to widget coordinates)
15517  * @keyboard_tip: whether this is a keyboard tooltip or not
15518  * @model: (out) (allow-none): a pointer to receive a #GtkTreeModel or %NULL
15519  * @path: (out) (allow-none): a pointer to receive a #GtkTreePath or %NULL
15520  * @iter: (out) (allow-none): a pointer to receive a #GtkTreeIter or %NULL
15521  *
15522  * This function is supposed to be used in a #GtkWidget::query-tooltip
15523  * signal handler for #GtkTreeView.  The @x, @y and @keyboard_tip values
15524  * which are received in the signal handler, should be passed to this
15525  * function without modification.
15526  *
15527  * The return value indicates whether there is a tree view row at the given
15528  * coordinates (%TRUE) or not (%FALSE) for mouse tooltips.  For keyboard
15529  * tooltips the row returned will be the cursor row.  When %TRUE, then any of
15530  * @model, @path and @iter which have been provided will be set to point to
15531  * that row and the corresponding model.  @x and @y will always be converted
15532  * to be relative to @tree_view's bin_window if @keyboard_tooltip is %FALSE.
15533  *
15534  * Return value: whether or not the given tooltip context points to a row.
15535  *
15536  * Since: 2.12
15537  */
15538 gboolean
15539 gtk_tree_view_get_tooltip_context (GtkTreeView   *tree_view,
15540                                    gint          *x,
15541                                    gint          *y,
15542                                    gboolean       keyboard_tip,
15543                                    GtkTreeModel **model,
15544                                    GtkTreePath  **path,
15545                                    GtkTreeIter   *iter)
15546 {
15547   GtkTreePath *tmppath = NULL;
15548
15549   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
15550   g_return_val_if_fail (x != NULL, FALSE);
15551   g_return_val_if_fail (y != NULL, FALSE);
15552
15553   if (keyboard_tip)
15554     {
15555       gtk_tree_view_get_cursor (tree_view, &tmppath, NULL);
15556
15557       if (!tmppath)
15558         return FALSE;
15559     }
15560   else
15561     {
15562       gtk_tree_view_convert_widget_to_bin_window_coords (tree_view, *x, *y,
15563                                                          x, y);
15564
15565       if (!gtk_tree_view_get_path_at_pos (tree_view, *x, *y,
15566                                           &tmppath, NULL, NULL, NULL))
15567         return FALSE;
15568     }
15569
15570   if (model)
15571     *model = gtk_tree_view_get_model (tree_view);
15572
15573   if (iter)
15574     gtk_tree_model_get_iter (gtk_tree_view_get_model (tree_view),
15575                              iter, tmppath);
15576
15577   if (path)
15578     *path = tmppath;
15579   else
15580     gtk_tree_path_free (tmppath);
15581
15582   return TRUE;
15583 }
15584
15585 static gboolean
15586 gtk_tree_view_set_tooltip_query_cb (GtkWidget  *widget,
15587                                     gint        x,
15588                                     gint        y,
15589                                     gboolean    keyboard_tip,
15590                                     GtkTooltip *tooltip,
15591                                     gpointer    data)
15592 {
15593   GValue value = { 0, };
15594   GValue transformed = { 0, };
15595   GtkTreeIter iter;
15596   GtkTreePath *path;
15597   GtkTreeModel *model;
15598   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
15599
15600   if (!gtk_tree_view_get_tooltip_context (GTK_TREE_VIEW (widget),
15601                                           &x, &y,
15602                                           keyboard_tip,
15603                                           &model, &path, &iter))
15604     return FALSE;
15605
15606   gtk_tree_model_get_value (model, &iter,
15607                             tree_view->priv->tooltip_column, &value);
15608
15609   g_value_init (&transformed, G_TYPE_STRING);
15610
15611   if (!g_value_transform (&value, &transformed))
15612     {
15613       g_value_unset (&value);
15614       gtk_tree_path_free (path);
15615
15616       return FALSE;
15617     }
15618
15619   g_value_unset (&value);
15620
15621   if (!g_value_get_string (&transformed))
15622     {
15623       g_value_unset (&transformed);
15624       gtk_tree_path_free (path);
15625
15626       return FALSE;
15627     }
15628
15629   gtk_tooltip_set_markup (tooltip, g_value_get_string (&transformed));
15630   gtk_tree_view_set_tooltip_row (tree_view, tooltip, path);
15631
15632   gtk_tree_path_free (path);
15633   g_value_unset (&transformed);
15634
15635   return TRUE;
15636 }
15637
15638 /**
15639  * gtk_tree_view_set_tooltip_column:
15640  * @tree_view: a #GtkTreeView
15641  * @column: an integer, which is a valid column number for @tree_view's model
15642  *
15643  * If you only plan to have simple (text-only) tooltips on full rows, you
15644  * can use this function to have #GtkTreeView handle these automatically
15645  * for you. @column should be set to the column in @tree_view's model
15646  * containing the tooltip texts, or -1 to disable this feature.
15647  *
15648  * When enabled, #GtkWidget::has-tooltip will be set to %TRUE and
15649  * @tree_view will connect a #GtkWidget::query-tooltip signal handler.
15650  *
15651  * Note that the signal handler sets the text with gtk_tooltip_set_markup(),
15652  * so &amp;, &lt;, etc have to be escaped in the text.
15653  *
15654  * Since: 2.12
15655  */
15656 void
15657 gtk_tree_view_set_tooltip_column (GtkTreeView *tree_view,
15658                                   gint         column)
15659 {
15660   g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
15661
15662   if (column == tree_view->priv->tooltip_column)
15663     return;
15664
15665   if (column == -1)
15666     {
15667       g_signal_handlers_disconnect_by_func (tree_view,
15668                                             gtk_tree_view_set_tooltip_query_cb,
15669                                             NULL);
15670       gtk_widget_set_has_tooltip (GTK_WIDGET (tree_view), FALSE);
15671     }
15672   else
15673     {
15674       if (tree_view->priv->tooltip_column == -1)
15675         {
15676           g_signal_connect (tree_view, "query-tooltip",
15677                             G_CALLBACK (gtk_tree_view_set_tooltip_query_cb), NULL);
15678           gtk_widget_set_has_tooltip (GTK_WIDGET (tree_view), TRUE);
15679         }
15680     }
15681
15682   tree_view->priv->tooltip_column = column;
15683   g_object_notify (G_OBJECT (tree_view), "tooltip-column");
15684 }
15685
15686 /**
15687  * gtk_tree_view_get_tooltip_column:
15688  * @tree_view: a #GtkTreeView
15689  *
15690  * Returns the column of @tree_view's model which is being used for
15691  * displaying tooltips on @tree_view's rows.
15692  *
15693  * Return value: the index of the tooltip column that is currently being
15694  * used, or -1 if this is disabled.
15695  *
15696  * Since: 2.12
15697  */
15698 gint
15699 gtk_tree_view_get_tooltip_column (GtkTreeView *tree_view)
15700 {
15701   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), 0);
15702
15703   return tree_view->priv->tooltip_column;
15704 }